def main():
""" Main function """
wp.wiringPiSetup()
datasocket = DateDataPullSocket('furnaceroom_controller',
['temperature', 'setpoint', 'dutycycle', 'pid_p', 'pid_i'],
timeouts=999999, port=9000)
datasocket.start()
pushsocket = DataPushSocket('furnaceroom_push_control', action='store_last')
pushsocket.start()
power_calculator = PowerCalculatorClass(datasocket, pushsocket)
power_calculator.daemon = True
power_calculator.start()
heater = HeaterClass(power_calculator, datasocket)
heater.start()
tui = CursesTui(heater)
tui.daemon = True
tui.start()
# make sure tui close down properly and the T setpoint is put low.
try:
while not heater.quit:
time.sleep(1)
except KeyboardInterrupt:
print("Keyboard Interrupt detected, closing program")
heater.quit = True
finally:
power_calculator.quit = True
time.sleep(0.1)
tui.stop()
def __init__(self):
sql_queue = queue.Queue()
self.data_saver = database_saver.SqlSaver(settings.username,
settings.username, sql_queue)
self.data_saver.start()
if settings.qmg == '420':
self.qmg = qmg420.qmg_420(settings.port)
if settings.qmg == '422':
print(settings.port)
self.qmg = qmg422.qmg_422(port=settings.port, speed=settings.speed)
try:
livesocket = LiveSocket(settings.name + '-mass-spec',
['qms-value'])
livesocket.start()
except:
livesocket = None
pullsocket = DateDataPullSocket(settings.name + '-mass-spec',
['qms-value'])
pullsocket.start()
self.qms = ms.QMS(self.qmg,
sql_queue,
chamber=settings.chamber,
credentials=settings.username,
livesocket=livesocket,
pullsocket=pullsocket)
self.qmg.reverse_range = settings.reverse_range
self.printer = qmg_status_output.QmsStatusOutput(
self.qms, sql_saver_instance=self.data_saver)
self.printer.start()
def main():
""" Main function """
logging.basicConfig(filename="logger.txt", level=logging.ERROR)
logging.basicConfig(level=logging.ERROR)
#port = '/dev/serial/by-id/usb-FTDI_USB-RS485_Cable_FTY5BU0H-if00-port0'
port = '/dev/serial/by-id/usb-FTDI_USB-RS485_Cable_FTY3GX3T-if00-port0'
# Set up criterium logger
logger = LoggingCriteriumChecker(
codenames=[CODENAME],
types=['lin'],
criteria=[0.2],
time_outs=[300],
)
# Set up pullsocket
datasocket = DateDataPullSocket('mgw_temp', [CODENAME],
timeouts=4,
port=9000)
datasocket.start()
db_logger = ContinuousDataSaver(continuous_data_table='dateplots_omicron',
username=credentials.user,
password=credentials.passwd,
measurement_codenames=[CODENAME])
db_logger.start()
measurement = TcReader(port, datasocket, logger, db_logger)
measurement.start()
def __init__(self):
threading.Thread.__init__(self)
self.watchdog = Watchdog()
self.watchdog.daemon = True
self.watchdog.start()
time.sleep(1)
self.setup = settings.setup
self.quit = False
for i in range(0, 7): #Set GPIO pins to output
wp.pinMode(i, 1)
self.setup = settings.setup
self.dutycycles = [0, 0, 0, 0, 0, 0]
channels = ['1', '2', '3', '4', '5', '6']
# Setup up extra status for the diode relay status
diode_channels = ['diode' + number for number in channels]
self.diode_channel_last = {name: None for name in diode_channels}
# Setup sockets
self.livesocket = LiveSocket(self.setup + '-bakeout', channels + diode_channels)
self.livesocket.start()
self.pullsocket = DateDataPullSocket(self.setup + '-bakeout', channels, timeouts=None)
self.pullsocket.start()
self.pushsocket = DataPushSocket(self.setup + '-push_control', action='enqueue')
self.pushsocket.start()
def main():
""" Main function """
logging.basicConfig(filename="logger.txt", level=logging.ERROR)
logging.basicConfig(level=logging.ERROR)
omron_instance = omron_d6fph.OmronD6fph()
hih_instance = honeywell_6000.HIH6130()
reader = Reader(omron_instance, hih_instance)
reader.start()
time.sleep(5)
codenames = [
'hall_ventilation_pressure', 'hall_temperature', 'hall_humidity'
]
loggers = {}
loggers[codenames[0]] = ValueLogger(reader,
comp_val=1.0,
maximumtime=300,
comp_type='lin',
channel=0)
loggers[codenames[0]].start()
loggers[codenames[1]] = ValueLogger(reader,
comp_val=0.2,
maximumtime=600,
comp_type='lin',
channel=1)
loggers[codenames[1]].start()
loggers[codenames[2]] = ValueLogger(reader,
comp_val=0.2,
maximumtime=600,
comp_type='lin',
channel=2)
loggers[codenames[2]].start()
livesocket = LiveSocket('Hall Ventilation Logger', codenames)
livesocket.start()
socket = DateDataPullSocket('Hall Ventilation logger',
codenames,
timeouts=[1.0] * len(loggers))
socket.start()
db_logger = ContinuousDataSaver(continuous_data_table='dateplots_hall',
username=credentials.user,
password=credentials.passwd,
measurement_codenames=codenames)
db_logger.start()
while reader.isAlive():
time.sleep(1)
for name in codenames:
value = loggers[name].read_value()
livesocket.set_point_now(name, value)
socket.set_point_now(name, value)
if loggers[name].read_trigged():
print(name + ': ' + str(value))
db_logger.save_point_now(name, value)
loggers[name].clear_trigged()
def main():
""" Main function """
port = '/dev/serial/by-id/usb-FTDI_USB-RS485_Cable_FTWGRR44-if00-port0'
devices = ['F25600004', 'F25600005', 'F25600006', 'F25600001', 'F25600002',
'F25600003', 'F25698001']
datasocket = DateDataPullSocket('vhp_mfc_control',
devices,
timeouts=[3.0, 3.0, 3.0, 3.0, 3.0, 3.0, 3.0],
port=9000)
datasocket.start()
pushsocket = DataPushSocket('vhp_push_control', action='enqueue')
pushsocket.start()
i = 0
mfcs = {}
for device in devices:
mfcs[device] = brooks.Brooks(device, port=port)
print(mfcs[device].read_flow())
fc = FlowControl(mfcs, datasocket, pushsocket)
fc.start()
while True:
time.sleep(0.5)
def main():
""" Main function """
ps1 = cpx.CPX400DPDriver(1, device='/dev/ttyACM0', interface='serial')
ps2 = cpx.CPX400DPDriver(2, device='/dev/ttyACM0', interface='serial')
isotech = ips.IPS(
'/dev/serial/by-id/' +
'usb-Prolific_Technology_Inc._USB-Serial_Controller-if00-port0')
pullsocket = DateDataPullSocket(
'vhp_temp_control',
['setpoint', 'dutycycle', 'pid_p', 'pid_i', 'pid_e'],
timeouts=[999999, 3.0, 3.0, 3.0, 3.0],
port=9001)
pullsocket.start()
pushsocket = DataPushSocket('vhp_push_control', action='store_last')
pushsocket.start()
power_calc = PowerCalculatorClass(pullsocket, pushsocket)
power_calc.daemon = True
power_calc.start()
heater = HeaterClass(power_calc, pullsocket, ps1, ps2, isotech)
heater.start()
tui = CursesTui(heater, ps1)
tui.daemon = True
tui.start()
def main():
""" Main function """
power_supplies = {}
for i in range(1, 3):
power_supplies[i] = cpx.CPX400DPDriver(
i,
interface='lan',
hostname='cinf-palle-heating-ps',
tcp_port=9221)
power_supplies[i].set_voltage(0)
power_supplies[i].output_status(True)
codenames = [
'setpoint', 'wanted_voltage', 'actual_voltage_1', 'actual_voltage_2',
'actual_current_1', 'actual_current_2', 'power', 'temperature'
]
pullsocket = DateDataPullSocket(
'palle_temp_control',
codenames,
timeouts=[999999, 3.0, 3.0, 3.0, 3.0, 3.0, 3.0, 3.0])
pullsocket.start()
pushsocket = DataPushSocket('mgw_push_control', action='store_last')
pushsocket.start()
power_calculator = PowerCalculatorClass(pullsocket, pushsocket)
power_calculator.daemon = True
power_calculator.start()
heater = HeaterClass(power_calculator, pullsocket, power_supplies)
heater.start()
tui = CursesTui(heater)
tui.daemon = True
tui.start()
def main():
""" Main function """
valve_names = [0] * 20
for i in range(0, 20):
valve_names[i] = str(i + 1)
try: # Python 3
name = chr(0x03BC)
except ValueError: # Python 2
name = unichr(0x03BC) # pylint: disable=undefined-variable
pullsocket = DateDataPullSocket(name + '-reacorNG valve control',
valve_names, timeouts=[2]*20)
pullsocket.start()
pushsocket = DataPushSocket(name + '-reactorNG valve control',
action='enqueue')
pushsocket.start()
valve_controller = valve_control.ValveControl(valve_names, pullsocket, pushsocket)
valve_controller.start()
while True:
time.sleep(1)
valve_controller.running = False
def __init__(self, ):
logging.info('MainPID class started')
threading.Thread.__init__(self)
#from datalogger import TemperatureReader
self.quit = False
self.codenames = [
'tabs_guard_pid_value',
'tabs_floor_pid_value',
'tabs_ceiling_pid_value',
'tabs_cooling_pid_value',
'tabs_guard_valve_heating',
'tabs_floor_valve_heating',
'tabs_ceiling_valve_heating',
'tabs_guard_valve_cooling',
'tabs_floor_valve_cooling',
'tabs_ceiling_valve_cooling',
'tabs_cooling_valve_cooling',
]
sockname = 'tabs_pids'
self.PullSocket = DateDataPullSocket(
sockname,
self.codenames,
timeouts=[60.0] * len(self.codenames),
port=socketinfo.INFO[sockname]['port'])
self.PullSocket.start()
self.PTC = PidTemperatureControl(self.codenames)
self.PTC.daemon = True
self.PTC.start()
#time.sleep(5)
chlist = {
'tabs_guard_pid_value': 0,
'tabs_floor_pid_value': 1,
'tabs_ceiling_pid_value': 2,
'tabs_cooling_pid_value': 3,
'tabs_guard_valve_heating': 4,
'tabs_floor_valve_heating': 5,
'tabs_ceiling_valve_heating': 6,
'tabs_guard_valve_cooling': 7,
'tabs_floor_valve_cooling': 8,
'tabs_ceiling_valve_cooling': 9,
'tabs_cooling_valve_cooling': 10
}
self.loggers = {}
for key in self.codenames:
self.loggers[key] = ValueLogger(self.PTC,
comp_val=0.10,
maximumtime=60,
comp_type='lin',
channel=chlist[key])
self.loggers[key].start()
#livesocket = LiveSocket('tabs_temperature_logger', codenames, 2)
#livesocket.start()
self.db_logger = ContinuousLogger(table='dateplots_tabs',
username=credentials.user,
password=credentials.passwd,
measurement_codenames=self.codenames)
self.db_logger.start()
def main():
""" Main function """
tempreader = TemperatureReader()
tempreader.daemon = True
tempreader.start()
temp_logger = ValueLogger(tempreader, comp_val=1)
temp_logger.start()
db_logger = ContinuousDataSaver(
continuous_data_table='dateplots_chemlab307',
username=credentials.user,
password=credentials.passwd,
measurement_codenames=['chemlab307_muffle_furnace'])
socket = DateDataPullSocket('muffle_furnace',
['chemlab307_muffle_furnace'],
timeouts=[1.0])
socket.start()
livesocket = LiveSocket('muffle_furnace', ['chemlab307_muffle_furnace'])
livesocket.start()
db_logger.start()
time.sleep(5)
while True:
time.sleep(0.25)
value = temp_logger.read_value()
socket.set_point_now('chemlab307_muffle_furnace', value)
livesocket.set_point_now('chemlab307_muffle_furnace', value)
if temp_logger.read_trigged():
print(value)
db_logger.save_point_now('chemlab307_muffle_furnace', value)
temp_logger.clear_trigged()
def __init__(self):
# Initialize omega driver
LOGGER.info('Initialize omega d6400 driver')
d6400_id = '/dev/serial/by-id/usb-FTDI_USB-RS485_Cable_FTWGRP0B-if00'\
'-port0'
self.d6400 = D6400.OmegaD6400(1, d6400_id)
for channel in range(1, 8):
LOGGER.info('Set range for channel {}'.format(channel))
self.d6400.update_range_and_function(channel,
action='tc',
fullrange='K')
# Initialize socket
name = 'Coupled reactor temperatures'
self.codenames = {
1: 'R1_temp',
2: 'R1_sample_temp',
3: 'R2_temp',
4: 'R2_sample_temp',
5: 'pro_inlet_temp',
6: 'pro_d1_temp',
7: 'pro_d2_temp',
}
codenames_list = [self.codenames[channel] for channel in range(1, 8)]
self.socket = DateDataPullSocket(name, codenames_list, timeouts=2.0)
self.socket.start()
# Measure initial values
self.temperatures = {}
for channel in range(1, 8):
self.temperatures[channel] = self.d6400.read_value(channel)
LOGGER.info('Get initial value {} for channel: {}'.format(
self.temperatures[channel], channel))
self.socket.set_point_now(self.codenames[channel],
self.temperatures[channel])
def main():
""" Main function """
logging.basicConfig(filename="logger.txt", level=logging.ERROR)
logging.basicConfig(level=logging.ERROR)
port = '/dev/serial/by-id/usb-Prolific_Technology_Inc._USB-Serial_Controller_D-if00-port'
port = '/dev/ttyUSB0'
codenames = [
'xrd_pressure_turbo_gas_system', 'xrd_pressure_gas_system_wrg',
'xrd_pressure_mass_spec_wrg', 'xrd_pressure_gas_system_baratron'
]
reader = PressureReader(port)
reader.daemon = True
reader.start()
loggers = {}
loggers[codenames[0]] = ValueLogger(reader,
comp_val=0.02,
comp_type='log',
channel=1)
loggers[codenames[1]] = ValueLogger(reader,
comp_val=0.02,
comp_type='log',
channel=2)
loggers[codenames[2]] = ValueLogger(reader,
comp_val=0.02,
comp_type='log',
channel=3)
loggers[codenames[3]] = ValueLogger(reader,
comp_val=2,
comp_type='lin',
channel=4)
for i in range(0, 4):
loggers[codenames[i]].start()
socket = DateDataPullSocket('XRD Pressure',
codenames,
timeouts=[2.0] * len(codenames))
socket.start()
live_socket = LiveSocket('XRD pressure', codenames, 2)
live_socket.start()
db_logger = ContinuousDataSaver(continuous_data_table='dateplots_xrd',
username=credentials.user,
password=credentials.passwd,
measurement_codenames=codenames)
db_logger.start()
time.sleep(5)
while True:
time.sleep(0.25)
for name in codenames:
value = loggers[name].read_value()
socket.set_point_now(name, value)
live_socket.set_point_now(name, value)
if loggers[name].read_trigged():
print(name + ': ' + str(value))
db_logger.save_point_now(name, value)
loggers[name].clear_trigged()
def main():
""" Main function """
logging.basicConfig(filename="logger.txt", level=logging.ERROR)
logging.basicConfig(level=logging.ERROR)
ports = dict()
ports[
'Sample'] = '/dev/serial/by-id/usb-FTDI_USB-RS485_Cable_FTY5BU0H-if00-port0'
ports[
'Base'] = '/dev/serial/by-id/usb-FTDI_USB-RS485_Cable_FTY3GX3T-if00-port0'
# Set up criterium logger
logger = LoggingCriteriumChecker(
codenames=[CODENAMES['Base']],
types=['lin'],
criteria=[0.2],
time_outs=[300],
)
# Set up pullsocket
datasocket = DateDataPullSocket('mgw_temp',
list(CODENAMES.values()),
timeouts=4,
port=9000)
datasocket.start()
db_logger = ContinuousDataSaver(continuous_data_table='dateplots_omicron',
username=credentials.user,
password=credentials.passwd,
measurement_codenames=[CODENAMES['Base']])
db_logger.start()
measurement = TcReader(ports['Base'],
datasocket,
crit_logger=logger,
db_logger=db_logger,
codename=CODENAMES['Base'])
measurement.start()
sample_logger = TcReader(ports['Sample'],
datasocket,
codename=CODENAMES['Sample'])
sample_logger.start()
time.sleep(5)
string = 'Base: {: >6.4} C, Sample: {: >6.4} C'
while True:
try:
time.sleep(1)
print(
string.format(measurement.temperature,
sample_logger.temperature))
except KeyboardInterrupt:
measurement.stop()
sample_logger.stop()
time.sleep(2)
print('\nTcReaders stopped')
datasocket.stop()
print('Pullsocket stopped\nExiting.')
break
def main():
""" Main loop """
mainpump = tp.TurboDriver(adress=1, port=settings.port)
mainpump.start()
tui = tp.CursesTui(mainpump)
tui.daemon = True
tui.start()
reader = tp.TurboReader(mainpump)
reader.daemon = True
reader.start()
time.sleep(10) # Allow reader to make meaningfull moving avarage
codenames = [settings.table_prefix + '_turbo_speed',
settings.table_prefix + '_turbo_power',
settings.table_prefix + '_turbo_current',
settings.table_prefix + '_turbo_temp_motor',
settings.table_prefix + '_turbo_temp_bottom',
settings.table_prefix + '_turbo_temp_bearings',
settings.table_prefix + '_turbo_temp_electronics']
loggers = {}
loggers[codenames[0]] = tp.TurboLogger(reader, 'rotation_speed', maximumtime=600)
loggers[codenames[1]] = tp.TurboLogger(reader, 'drive_power', maximumtime=600)
loggers[codenames[2]] = tp.TurboLogger(reader, 'drive_current', maximumtime=600)
loggers[codenames[3]] = tp.TurboLogger(reader, 'temp_motor', maximumtime=600)
loggers[codenames[4]] = tp.TurboLogger(reader, 'temp_bottom', maximumtime=600)
loggers[codenames[5]] = tp.TurboLogger(reader, 'temp_bearings', maximumtime=600)
loggers[codenames[6]] = tp.TurboLogger(reader, 'temp_electronics', maximumtime=600)
for name in codenames:
loggers[name].daemon = True
loggers[name].start()
livesocket = LiveSocket(settings.name + '-turboreader', codenames)
livesocket.start()
socket = DateDataPullSocket(settings.name + '-turboreader', codenames,
timeouts=[1.0] * len(codenames), port=9000)
socket.start()
db_logger = ContinuousDataSaver(continuous_data_table=settings.table,
username=settings.user,
password=settings.passwd,
measurement_codenames=codenames)
db_logger.start()
time.sleep(5)
while mainpump.running:
time.sleep(0.1)
for name in codenames:
value = loggers[name].read_value()
socket.set_point_now(name, value) # Notice, this is the averaged value
livesocket.set_point_now(name, value) # Notice, this is the averaged value
if loggers[name].trigged:
db_logger.save_point_now(name, value)
loggers[name].trigged = False
def __init__(self, ranges, devices, socket_name):
threading.Thread.__init__(self)
self.devices = devices
name = {}
mfcs = {}
print('!')
for i in range(0, 8):
print('----------------')
print('Cheking port number: {}'.format(i))
error = 0
name[i] = ''
while (error < 3) and (name[i] == ''):
# Pro forma-range will be update in a few lines
ioerror = 0
while ioerror < 10:
time.sleep(0.5)
print(ioerror)
try:
bronk = bronkhorst.Bronkhorst('/dev/ttyUSB' + str(i),
1)
print('MFC Found')
break
except: # pylint: disable=bare-except
ioerror = ioerror + 1
if ioerror == 10:
print('No MFC found on this port')
break
print('Error count before identification: {}'.format(ioerror))
name[i] = bronk.read_serial()
print('MFC Name: {}'.format(name[i]))
name[i] = name[i].strip()
error = error + 1
if name[i] in devices:
ioerror = 0
if ioerror < 10:
print(ioerror)
try:
mfcs[name[i]] = bronkhorst.Bronkhorst(
'/dev/ttyUSB' + str(i), ranges[name[i]])
mfcs[name[i]].set_control_mode(
) #Accept setpoint from rs232
except IOError:
ioerror = ioerror + 1
if ioerror == 10:
print('Found MFC but could not set range')
self.mfcs = mfcs
self.pullsocket = DateDataPullSocket(socket_name,
devices,
timeouts=3.0,
port=9000)
self.pullsocket.start()
self.pushsocket = DataPushSocket(socket_name, action='enqueue')
self.pushsocket.start()
self.livesocket = LiveSocket(socket_name, devices)
self.livesocket.start()
self.running = True
self.reactor_pressure = float('NaN')
def main():
""" Main function """
logging.basicConfig(filename="logger.txt", level=logging.ERROR)
logging.basicConfig(level=logging.ERROR)
l3g4200d_instance = l3g4200d.L3G4200D()
l3g4200d_reader = Reader(l3g4200d_instance)
l3g4200d_reader.start()
ais328dq_instance = ais328dq.AIS328DQTR()
ais328dq_reader = Reader(ais328dq_instance)
ais328dq_reader.start()
time.sleep(2.5)
codenames = [
'b307_049_vibration_measurement', 'b307_049_vibration_measurement_accl'
]
loggers = {}
loggers[codenames[0]] = ValueLogger(l3g4200d_reader,
comp_val=0.02,
maximumtime=600,
comp_type='lin',
channel=0)
loggers[codenames[0]].start()
loggers[codenames[1]] = ValueLogger(ais328dq_reader,
comp_val=0.01,
maximumtime=100,
comp_type='lin',
channel=0)
loggers[codenames[1]].start()
livesocket = LiveSocket('307 Vibraton logger', codenames)
livesocket.start()
socket = DateDataPullSocket('307 vibration logger',
codenames,
timeouts=[1.0] * len(loggers))
socket.start()
db_logger = ContinuousDataSaver(continuous_data_table='dateplots_b307_049',
username=credentials.user,
password=credentials.passwd,
measurement_codenames=codenames)
db_logger.start()
while l3g4200d_reader.isAlive():
time.sleep(10)
for name in codenames:
value = loggers[name].read_value()
print(value)
livesocket.set_point_now(name, value)
socket.set_point_now(name, value)
if loggers[name].read_trigged():
print(name + ': ' + str(value))
db_logger.save_point_now(name, value)
loggers[name].clear_trigged()
def main():
""" Main function """
sock = socket.socket(socket.AF_INET, socket.SOCK_DGRAM)
sock.settimeout(1)
try:
network_adress = 'rasppi12'
command = 'microreactorng_temp_sample#raw'.encode()
sock.sendto(command, (network_adress, 9000))
received = sock.recv(1024)
received = received.decode('ascii')
if received == 'OLD_DATA':
raise RuntimeError(
"Received OLD_DATA from rasppi12. Please check it.")
start_temp = float(received[received.find(',') + 1:])
agilent_hostname = '10.54.6.56'
rtd_reader = RtdReader(agilent_hostname, start_temp)
except socket.timeout:
print('Could not find rasppi12')
exit()
rtd_reader.daemon = True
rtd_reader.start()
time.sleep(1)
power_supply = {}
for k in range(1, 3):
power_supply[k] = cpx.CPX400DPDriver(
k,
interface='lan',
hostname='surfcat-stm312-heating-ps',
tcp_port=9221)
power_supply[k].set_voltage(0)
power_supply[k].output_status(True)
codenames = [
'setpoint', 'wanted_voltage', 'actual_voltage_1', 'actual_voltage_2',
'actual_current_1', 'actual_current_2', 'power', 'temperature'
]
pullsocket = DateDataPullSocket(
MICRO + '-reactorng_temp_control',
codenames,
timeouts=[999999, 3.0, 3.0, 3.0, 3.0, 3.0, 3.0, 3.0])
pullsocket.start()
pushsocket = DataPushSocket(MICRO + '-reactorng_push_control',
action='store_last')
pushsocket.start()
power_calculator = PowerCalculatorClass(pullsocket, pushsocket, rtd_reader)
power_calculator.daemon = True
power_calculator.start()
heater = HeaterClass(power_calculator, pullsocket, power_supply)
heater.start()
tui_class = CursesTui(heater)
tui_class.start()
LOGGER.info('script ended')
def main():
""" Main function """
ports = dict()
ports['Sample'] = '/dev/serial/by-id/usb-FTDI_USB-RS485_Cable_FTY5BU0H-if00-port0'
ports['Base'] = '/dev/serial/by-id/usb-FTDI_USB-RS485_Cable_FTY3GX3T-if00-port0'
# Set up criterium logger
logger = LoggingCriteriumChecker(
codenames=[CODENAMES['Base']],
types=['lin'],
criteria=[0.73],
time_outs=[600],
low_compare_values=[-200],
)
# Set up pullsocket
datasocket = DateDataPullSocket('mgw_temp', list(CODENAMES.values()), timeouts=4, port=9000)
datasocket.start()
db_logger = ContinuousDataSaver(continuous_data_table='dateplots_omicron',
username=credentials.user,
password=credentials.passwd,
measurement_codenames=[CODENAMES['Base']])
db_logger.start()
logger1 = LOGGER.getChild('Base_reader')
measurement = TcReader(ports['Base'], datasocket, crit_logger=logger, db_logger=db_logger, codename=CODENAMES['Base'], logger=logger1)
measurement.start()
logger2 = LOGGER.getChild('Sample_reader')
sample_logger = TcReader(ports['Sample'], datasocket, codename=CODENAMES['Sample'], logger=logger2)
sample_logger.start()
time.sleep(2)
string = 'Base: {: <6.4} C, Sample: {: <6.4} C'
while True:
try:
time.sleep(1)
sample = sample_logger.temperature
if sample is None:
sample = '----'
base = measurement.temperature
if base is None:
base = '----'
print(string.format(base, sample))
except ValueError:
print('ValueError')
print(repr(measurement.temperature), type(measurement.temperature))
print(repr(sample_logger.temperature))
except KeyboardInterrupt:
measurement.stop()
sample_logger.stop()
time.sleep(2)
LOGGER.info('\nTcReaders stopped')
datasocket.stop()
LOGGER.info('Pullsocket stopped\nExiting.')
break
def __init__(self):
threading.Thread.__init__(self)
#self.daemon = True
self.pullsocket = DateDataPullSocket('local MS socket',
['analog_in'], timeouts=2, port=9250)
self.pullsocket.start()
port = '/dev/serial/by-id/usb-FTDI_USB-RS485_Cable_FTWBEDQ3-if00-port0'
self.omega = OmegaD6400(1, port=port)
self.omega.update_range_and_function(2, action='voltage', fullrange='10')
def __init__(self,):
logging.info('MainDatalogger class started')
threading.Thread.__init__(self)
#from datalogger import TemperatureReader
self.quit = False
self.codenames = ['tabs_guard_temperature_inlet',
'tabs_floor_temperature_inlet',
'tabs_ceiling_temperature_inlet',
'tabs_cooling_temperature_inlet',
]
self.MC302 = WaterTemperatureReader()
self.MC302.start()
self.codenames = [
'tabs_cooling_temperature_inlet',
]
self.omega_temperature = TemperatureReader(['tabs_cooling_temperature_inlet',])
self.omega_temperature.daemon = True
self.omega_temperature.start()
#omega_temperature.update_values()
time.sleep(1.5)
chlist = {'tabs_guard_temperature_control': 0,
'tabs_room_temperature_control': 1,
#'tabs_ceiling_temperature_inlet': 2,
'tabs_cooling_temperature_inlet': 3}
self.loggers = {}
for key in chlist.keys():
self.loggers[key] = ValueLogger(self.omega_temperature, comp_val = 0.2, maximumtime=300,
comp_type = 'lin', channel = chlist[key])
self.loggers[key].start()
chlist = {'tabs_guard_temperature_inlet': 0,
'tabs_guard_temperature_outlet': 1,
'tabs_guard_temperature_delta': 2,
'tabs_floor_temperature_inlet': 3,
'tabs_floor_temperature_outlet': 4,
'tabs_floor_temperature_delta': 5,
'tabs_ceiling_temperature_inlet': 6,
'tabs_ceiling_temperature_outlet': 7,
'tabs_ceiling_temperature_delta': 8,
'tabs_guard_water_flow': 9,
'tabs_floor_water_flow': 10,
'tabs_ceiling_water_flow': 11,}
for key in chlist.keys():
self.loggers[ key] = ValueLogger(self.MC302, comp_val = 0.2, maximumtime=300,
comp_type = 'lin', channel = chlist[key])
self.loggers[key].start()
self.codenames = self.loggers.keys()
#livesocket = LiveSocket('tabs_temperature_logger', codenames, 2)
#livesocket.start()
sockname = 'tabs_temperatures'
self.PullSocket = DateDataPullSocket(sockname, self.codenames, timeouts=[60.0]*len(self.codenames), port = socketinfo.INFO[sockname]['port'])
self.PullSocket.start()
self.db_logger = ContinuousLogger(table='dateplots_tabs', username=credentials.user, password=credentials.passwd, measurement_codenames=self.codenames)
self.db_logger.start()
def main():
""" Main function """
logging.basicConfig(filename="logger.txt", level=logging.ERROR)
logging.basicConfig(level=logging.ERROR)
ports = '/dev/serial/by-id/'
ports += 'usb-Prolific_Technology_Inc._USB-Serial_Controller_D-if00-port0'
xgs_instance = xgs600.XGS600Driver(ports)
print(xgs_instance.read_all_pressures())
pressure = PressureReader(xgs_instance)
pressure.start()
time.sleep(2.5)
codenames = ['ps_qms_pressure', 'ps_chamber_pressure']
loggers = {}
loggers[codenames[0]] = ValueLogger(pressure,
comp_val=0.1,
low_comp=1e-11,
comp_type='log',
channel=0)
loggers[codenames[0]].start()
loggers[codenames[1]] = ValueLogger(pressure,
comp_val=0.1,
low_comp=1e-11,
comp_type='log',
channel=1)
loggers[codenames[1]].start()
#livesocket = LiveSocket('PS', codenames, 2)
#livesocket.start()
socket = DateDataPullSocket('PS pressure logger',
codenames,
timeouts=2 * [1.0],
port=9001)
socket.start()
db_logger = ContinuousDataSaver(continuous_data_table='dateplots_ps',
username=credentials.user,
password=credentials.passwd,
measurement_codenames=codenames)
db_logger.start()
while pressure.isAlive():
time.sleep(0.5)
for name in codenames:
value = loggers[name].read_value()
#livesocket.set_point_now(name, value)
socket.set_point_now(name, value)
if loggers[name].read_trigged():
print(value)
db_logger.save_point_now(name, value)
loggers[name].clear_trigged()
def __init__(self, ):
logging.info('MainMultilogger class started')
threading.Thread.__init__(self)
#from datalogger import TemperatureReader
self.quit = False
self.codenames = Setting_channel_list.keys()
"""['tabs_ceiling_temperature_delta',
'tabs_ceiling_temperature_deltaref',
'tabs_floor_temperature_delta',
'tabs_floor_temperature_deltaref',
'tabs_room_temperature_aircenter010',
'tabs_room_temperature_aircenter060',
'tabs_room_temperature_aircenter110',
'tabs_room_temperature_aircenter170',
'tabs_room_temperature_aircenter355',
'tabs_guard_temperature_airfloor',
'tabs_guard_temperature_airceiling',
'tabs_guard_temperature_airwallsouth',
'tabs_guard_temperature_airwallnorth',
'tabs_guard_temperature_airwalleast',
'tabs_guard_temperature_airwallwest',
]"""
self.multiplex_reader = MultiplexReader(self.codenames)
self.multiplex_reader.daemon = True
self.multiplex_reader.start()
#omega_temperature.update_values()
time.sleep(3.5)
chlist = Setting_channel_list
self.loggers = {}
for key in self.codenames:
self.loggers[key] = ValueLogger(self.multiplex_reader,
comp_val=0.5,
maximumtime=300,
comp_type='lin',
channel=chlist[key])
self.loggers[key].start()
#livesocket = LiveSocket('tabs_temperature_logger', codenames, 2)
#livesocket.start()
sockname = 'tabs_multiplexer'
self.PullSocket = DateDataPullSocket(
sockname,
self.codenames,
timeouts=[60.0] * len(self.codenames),
port=socketinfo.INFO[sockname]['port'])
self.PullSocket.start()
self.db_logger = ContinuousLogger(table='dateplots_tabs',
username=credentials.user,
password=credentials.passwd,
measurement_codenames=self.codenames)
self.db_logger.start()
def main():
""" Main function """
wp.wiringPiSetup()
datasocket = DateDataPullSocket(
'furnaceroom_controller',
['temperature', 'setpoint', 'dutycycle', 'pid_p', 'pid_i'],
timeouts=999999,
port=9000)
datasocket.start()
pushsocket = DataPushSocket('furnaceroom_push_control',
action='store_last')
pushsocket.start()
power_calculator = PowerCalculatorClass(datasocket, pushsocket)
power_calculator.daemon = True
power_calculator.start()
codenames = [
'fr307_furnace_1_dutycycle', 'fr307_furnace_1_S',
'fr307_furnace_1_pid_p', 'fr307_furnace_1_pid_i'
]
db_logger = ContinuousDataSaver(
continuous_data_table='dateplots_furnaceroom307',
username=credentials.user,
password=credentials.passwd,
measurement_codenames=codenames)
db_logger.start()
# Criterium checker
criterium_checker = LoggingCriteriumChecker(
codenames=codenames,
types=['lin'] * len(codenames),
criteria=[0.1, 0.99, 1., 1.],
time_outs=[60, 600, 300, 300],
)
heater = HeaterClass(power_calculator, datasocket, db_logger,
criterium_checker)
heater.start()
tui = CursesTui(heater)
tui.daemon = True
tui.start()
# make sure tui close down properly and the T setpoint is put low.
try:
while not heater.quit:
time.sleep(1)
except KeyboardInterrupt:
print("Keyboard Interrupt detected, closing program")
heater.quit = True
finally:
power_calculator.quit = True
time.sleep(0.1)
tui.stop()
def main():
""" Main function """
i2c_helper = ABEHelpers()
bus = i2c_helper.get_smbus()
adc_instance = ADCPi(bus, 0x68, 0x69, 18)
windreader = WindReader(adc_instance)
windreader.daemon = True
windreader.start()
loggers = {}
for channel, codename in settings.channels.items():
loggers[codename + '_raw'] = ValueLogger(windreader,
comp_val=1.05,
channel=channel + '_raw',
maximumtime=30)
loggers[codename + '_raw'].start()
loggers[codename] = ValueLogger(windreader,
comp_val=1.005,
channel=channel,
maximumtime=30)
loggers[codename].start()
codenames = []
for name in settings.channels.values():
codenames.append(name)
codenames.append(name + '_raw')
socket = DateDataPullSocket('Fumehood Wind Speed', codenames, timeouts=2.0)
socket.start()
live_socket = LiveSocket('Fumehood Wind Speed', codenames)
live_socket.start()
db_logger = ContinuousDataSaver(
continuous_data_table=settings.dateplot_table,
username=credentials.user,
password=credentials.passwd,
measurement_codenames=codenames)
db_logger.start()
time.sleep(10)
while windreader.is_alive():
time.sleep(0.25)
for name in codenames:
value = loggers[name].read_value()
socket.set_point_now(name, value)
live_socket.set_point_now(name, value)
if loggers[name].read_trigged():
print(name + ': ' + str(value))
db_logger.save_point_now(name, value)
loggers[name].clear_trigged()
def main():
""" Main function """
logging.basicConfig(filename="logger.txt", level=logging.ERROR)
logging.basicConfig(level=logging.ERROR)
port = 'serial/by-id/usb-1a86_USB2.0-Ser_-if00-port0'
xgs = xgs600.XGS600Driver('/dev/' + port)
print(xgs.read_all_pressures())
reader = PressureReader(xgs)
reader.daemon = True
reader.start()
buffer_logger = ValueLogger(reader, comp_val=0.1, comp_type='log',
channel=0, low_comp=1e-3)
containment_logger = ValueLogger(reader, comp_val=0.1, comp_type='log',
channel=1, low_comp=1e-3)
buffer_logger.start()
containment_logger.start()
socket = DateDataPullSocket('mgw',
['containment_pressure', 'buffer_pressure'],
timeouts=[1.0, 1.0])
socket.start()
livesocket = LiveSocket('mgw', ['containment_pressure', 'buffer_pressure'])
livesocket.start()
codenames = ['mgw_pressure_containment', 'mgw_pressure_buffer']
db_logger = ContinuousDataSaver(continuous_data_table='dateplots_mgw',
username=credentials.user,
password=credentials.passwd,
measurement_codenames=codenames)
db_logger.start()
time.sleep(5)
while reader.isAlive():
time.sleep(0.2)
p_containment = containment_logger.read_value()
p_buffer = buffer_logger.read_value()
socket.set_point_now('containment_pressure', p_containment)
socket.set_point_now('buffer_pressure', p_buffer)
livesocket.set_point_now('containment_pressure', p_containment)
livesocket.set_point_now('buffer_pressure', p_buffer)
if containment_logger.read_trigged():
print(p_containment)
db_logger.save_point_now('mgw_pressure_containment', p_containment)
containment_logger.clear_trigged()
if buffer_logger.read_trigged():
print(p_buffer)
db_logger.save_point_now('mgw_pressure_buffer', p_buffer)
buffer_logger.clear_trigged()
def main():
""" Main function """
sock = socket.socket(socket.AF_INET, socket.SOCK_DGRAM)
sock.settimeout(1)
try:
temperature_string = 'mr_sample_tc_temperature#raw'
sock.sendto(temperature_string.encode('ascii'), ('rasppi12', 9000))
received = sock.recv(1024).decode('ascii')
start_temp = float(received[received.find(',') + 1:])
except socket.gaierror:
print('Could not find rasppi12')
exit()
except ValueError:
print('Bad reply from rasppi12')
exit()
rtd_reader = RtdReader(start_temp)
rtd_reader.daemon = True
rtd_reader.start()
time.sleep(1)
power_supply = {}
for k in range(1, 3):
power_supply[k] = cpx.CPX400DPDriver(k,
interface='serial',
device='/dev/ttyACM0')
power_supply[k].set_voltage(0)
power_supply[k].output_status(True)
codenames = [
'setpoint', 'wanted_voltage', 'actual_voltage_1', 'actual_voltage_2',
'actual_current_1', 'actual_current_2', 'power', 'temperature'
]
pullsocket = DateDataPullSocket(
MICRO + '-reactor_temp_control',
codenames,
timeouts=[999999, 3.0, 3.0, 3.0, 3.0, 3.0, 3.0, 3.0])
pullsocket.start()
pushsocket = DataPushSocket(MICRO + '-reactor push control',
action='store_last')
pushsocket.start()
power_calculator = PowerCalculatorClass(pullsocket, pushsocket, rtd_reader)
power_calculator.daemon = True
power_calculator.start()
heater = HeaterClass(power_calculator, pullsocket, power_supply)
heater.start()
tui = CursesTui(heater)
tui.daemon = True
tui.start()
def main():
""" Main code """
mux_instance = agilent_34972A.Agilent34972ADriver(
interface='lan', hostname='volvo-agilent-34972a')
port = '/dev/serial/by-id/usb-Prolific_Technology_Inc._USB-Serial_Controller-if00-port0'
xgs_instance = xgs600.XGS600Driver(port)
analog_measurement = MuxReader(mux_instance)
analog_measurement.start()
pressure = PressureReader(xgs_instance)
print('-')
pressure.start()
time.sleep(2.5)
codenames = ['volvo_pressure', 'volvo_temperature']
loggers = {}
loggers[codenames[0]] = ValueLogger(pressure,
comp_val=0.1,
comp_type='log')
loggers[codenames[0]].start()
loggers[codenames[1]] = ValueLogger(analog_measurement,
comp_val=0.5,
comp_type='lin')
loggers[codenames[1]].start()
socket = DateDataPullSocket('Volvo data logger',
codenames,
timeouts=[1.0, 1.0])
socket.start()
livesocket = LiveSocket('Volvo data logger', codenames)
livesocket.start()
db_logger = ContinuousDataSaver(continuous_data_table='dateplots_volvo',
username=credentials.user,
password=credentials.passwd,
measurement_codenames=codenames)
db_logger.start()
#while pressure.isAlive() and analog_measurement.isAlive():
while True:
time.sleep(0.25)
for name in codenames:
value = loggers[name].read_value()
socket.set_point_now(name, value)
livesocket.set_point_now(name, value)
if loggers[name].read_trigged():
print(value)
db_logger.save_point_now(name, value)
loggers[name].clear_trigged()
def __init__(self):
threading.Thread.__init__(self)
self.quit = False
self.ports = settings.ports
self.setup = settings.setup
print self.ports
print len(self.ports)
print[str(port) for port in self.ports]
self.pullsocket = DateDataPullSocket(
self.setup + '-socket supervisor',
[str(port) for port in self.ports],
timeouts=len(self.ports) * [5])
self.pullsocket.start()
def main():
""" Main function """
logging.basicConfig(filename="logger.txt", level=logging.ERROR)
logging.basicConfig(level=logging.ERROR)
hih_instance = honeywell_6000.HIH6130()
reader = Reader(hih_instance)
reader.start()
print('wait start 20s')
time.sleep(25)
print('Wait end')
codenames = ['home_temperature_bedroom', 'home_humidity_bedroom']
loggers = {}
loggers[codenames[0]] = ValueLogger(reader,
comp_val=0.25,
comp_type='lin',
channel=1)
loggers[codenames[0]].start()
loggers[codenames[1]] = ValueLogger(reader,
comp_val=1.1,
comp_type='lin',
channel=2)
loggers[codenames[1]].start()
#livesocket = LiveSocket('Home Air Logger', codenames)
#livesocket.start()
socket = DateDataPullSocket('Home Air Logger',
codenames,
timeouts=[1.0] * len(loggers))
socket.start()
table = 'dateplots_rued_langgaards_vej'
db_logger = ContinuousDataSaver(continuous_data_table=table,
username=credentials.user,
password=credentials.passwd,
measurement_codenames=codenames)
db_logger.start()
while reader.isAlive():
time.sleep(1)
for name in codenames:
value = loggers[name].read_value()
#livesocket.set_point_now(name, value)
socket.set_point_now(name, value)
if loggers[name].read_trigged():
print(value)
db_logger.save_point_now(name, value)
loggers[name].clear_trigged()
