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 """ 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 """ 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 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 main(): """ Main function """ code_names = ['pvd309_temp_dca_cell', 'pvd309_temp_mai_cell'] reader = TemperatureReader() reader.start() loggers = {} loggers[code_names[0]] = ValueLogger(reader, channel=1, comp_val = 0.5, comp_type = 'lin') loggers[code_names[0]].start() loggers[code_names[1]] = ValueLogger(reader, channel=2, comp_val = 0.5, comp_type = 'lin') loggers[code_names[1]].start() datasocket = DateDataPullSocket('pvd_309_temp', code_names, timeouts=[2.0] * 2, port=9001) datasocket.start() livesocket = LiveSocket('pvd_309_temperatures', code_names) livesocket.start() db_logger = ContinuousDataSaver(continuous_data_table='dateplots_pvd309', username=credentials.user, password=credentials.passwd, measurement_codenames=code_names) db_logger.start() time.sleep(5) while not reader.quit: time.sleep(0.25) for name in code_names: print(reader.ttl) value = loggers[name].read_value() datasocket.set_point_now(name, value) livesocket.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 """ valve_names = [0] * 20 for i in range(0, 20): valve_names[i] = str(i + 1) try: name = chr(0x03BC) # Python 3 except ValueError: name = unichr(0x03BC) # Python 2 pullsocket = DateDataPullSocket(name + '-reacor Valvecontrol', valve_names, timeouts=[2]*20) pullsocket.start() pushsocket = DataPushSocket(name + '-reactor 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
class FlowControl(threading.Thread): """ Keep updated values of the current flow """ def __init__(self, mks_instance, mfcs, devices, name): threading.Thread.__init__(self) self.mfcs = mfcs self.mks = mks_instance self.pullsocket = DateDataPullSocket(name, devices, timeouts=3.0, port=9000) self.pullsocket.start() self.pushsocket = DataPushSocket(name, action='enqueue') self.pushsocket.start() self.livesocket = LiveSocket(name, devices) self.livesocket.start() self.running = True def run(self): while self.running: time.sleep(0.1) qsize = self.pushsocket.queue.qsize() while qsize > 0: element = self.pushsocket.queue.get() mfc = list(element.keys())[0] print(element[mfc]) print('Queue: ' + str(qsize)) self.mks.set_flow(element[mfc], self.mfcs[mfc]) qsize = self.pushsocket.queue.qsize() for mfc in self.mfcs: print('!!!') flow = self.mks.read_flow(self.mfcs[mfc]) print(mfc + ': ' + str(flow)) self.pullsocket.set_point_now(mfc, flow) self.livesocket.set_point_now(mfc, flow)
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 """ 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 __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 """ 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 __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 __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 """ 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 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(): port_brooks = '/dev/serial/by-id/usb-FTDI_USB-RS485_Cable_FTWDN166-if00-port0' devices = ['3F2320902001', '3F2320901001'] datasocket = DateDataPullSocket('palle_mfc_control', devices, timeouts=[3.0, 3.0], port=9000) datasocket.start() pushsocket = DataPushSocket('palle_brooks_push_control', action='enqueue') pushsocket.start() i = 0 mfcs = {} for i in range(0, 2): device = devices[i] mfcs[device] = brooks.Brooks(device, port=port_brooks) print(mfcs[device].long_address) print(mfcs[device].read_flow()) fc = FlowControl(mfcs, datasocket, pushsocket) fc.start() while fc.running: try: time.sleep(1) except KeyboardInterrupt: fc.running = False print('stopping, waiting for 2 sek') time.sleep(2) print('stopped')
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 __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 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 main(): """ Main loop """ il800 = intellemetrics_il800.IL800( "/dev/serial/by-id/" + "usb-Prolific_Technology_Inc." + "_USB-Serial_Controller_D-if00-port0" ) sqm160 = inficon_sqm160.InficonSQM160("/dev/serial/by-id/usb-1a86_USB2.0-Ser_-if00-port0") qcm1 = QcmReader(il800) qcm1.start() qcm2 = QcmReader(sqm160) qcm2.start() time.sleep(2.5) codenames = [ "pvd309_qcm1_rate", "pvd309_qcm1_thickness", "pvd309_qcm1_frequency", "pvd309_qcm2_rate", "pvd309_qcm2_thickness", "pvd309_qcm2_frequency", ] loggers = {} loggers[codenames[0]] = ValueLogger(qcm1, comp_val=0.01, comp_type="lin", channel=0) loggers[codenames[1]] = ValueLogger(qcm1, comp_val=0.1, comp_type="lin", channel=1) loggers[codenames[2]] = ValueLogger(qcm1, comp_val=1, comp_type="lin", channel=2) loggers[codenames[3]] = ValueLogger(qcm2, comp_val=0.3, comp_type="lin", channel=0) loggers[codenames[4]] = ValueLogger(qcm2, comp_val=0.1, comp_type="lin", channel=1) loggers[codenames[5]] = ValueLogger(qcm2, comp_val=1, comp_type="lin", channel=2) for name in codenames: loggers[name].daemon = True loggers[name].start() livesocket = LiveSocket("pvd309 qcm logger", codenames) livesocket.start() socket = DateDataPullSocket("pvd309 qcm", codenames, timeouts=[1.0] * len(codenames)) socket.start() db_logger = ContinuousLogger( table="dateplots_pvd309", username=credentials.user, password=credentials.passwd, measurement_codenames=codenames, ) db_logger.start() while qcm1.isAlive() and qcm2.isAlive(): time.sleep(0.25) 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.enqueue_point_now(name, value) loggers[name].clear_trigged()
class IonOpticsControl(threading.Thread): """ Main optics control """ def __init__(self, port, name, lenses): threading.Thread.__init__(self) name = name + '_ion_optics' self.pullsocket = DateDataPullSocket(name, lenses, timeouts=20.0) self.pullsocket.start() self.pushsocket = DataPushSocket(name, action='enqueue') self.pushsocket.start() self.ion_optics = stahl_hv_400.StahlHV400(port) self.lenses = lenses self.set_voltages = {} self.actual_voltages = {} for lens in self.lenses: self.set_voltages[lens] = 0 self.actual_voltages[lens] = 0 self.status = {} self.status['channel_status'] = {} for i in range(1, len(self.lenses) + 1): self.status['channel_status'][i] = False self.status['temperature'] = None self.status['output_error'] = None self.quit = False def run(self): current_lens = 1 while not self.quit: self.status['temperature'] = self.ion_optics.read_temperature() if self.status['temperature'] > 50: for lens in self.lenses: self.set_voltages[lens] = 0 self.status[ 'channel_status'] = self.ion_optics.check_channel_status() self.status['output_error'] = False in self.status[ 'channel_status'] actual_voltage = self.ion_optics.query_voltage(current_lens) self.actual_voltages[self.lenses[current_lens - 1]] = actual_voltage self.pullsocket.set_point_now(self.lenses[current_lens - 1], actual_voltage) if current_lens == len(self.lenses): current_lens = 1 else: current_lens += 1 qsize = self.pushsocket.queue.qsize() while qsize > 0: element = self.pushsocket.queue.get() lens = str(list(element.keys())[0]) value = element[lens] self.set_voltages[lens] = value channel_number = self.lenses.index(lens) + 1 self.ion_optics.set_voltage(channel_number, value) qsize = self.pushsocket.queue.qsize() time.sleep(0.1)
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 __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 __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()
class IonOpticsControl(threading.Thread): """ Main optics control """ def __init__(self, port, name, lenses): threading.Thread.__init__(self) name = name + '_ion_optics' self.pullsocket = DateDataPullSocket(name, lenses, timeouts=20.0) self.pullsocket.start() self.pushsocket = DataPushSocket(name, action='enqueue') self.pushsocket.start() self.ion_optics = stahl_hv_400.StahlHV400(port) self.lenses = lenses self.set_voltages = {} self.actual_voltages = {} for lens in self.lenses: self.set_voltages[lens] = 0 self.actual_voltages[lens] = 0 self.status = {} self.status['channel_status'] = {} for i in range(1, len(self.lenses)+1): self.status['channel_status'][i] = False self.status['temperature'] = None self.status['output_error'] = None self.quit = False def run(self): current_lens = 1 while not self.quit: self.status['temperature'] = self.ion_optics.read_temperature() if self.status['temperature'] > 50: for lens in self.lenses: self.set_voltages[lens] = 0 self.status['channel_status'] = self.ion_optics.check_channel_status() self.status['output_error'] = False in self.status['channel_status'] actual_voltage = self.ion_optics.query_voltage(current_lens) self.actual_voltages[self.lenses[current_lens-1]] = actual_voltage self.pullsocket.set_point_now(self.lenses[current_lens-1], actual_voltage) if current_lens == len(self.lenses): current_lens = 1 else: current_lens += 1 qsize = self.pushsocket.queue.qsize() while qsize > 0: element = self.pushsocket.queue.get() lens = str(list(element.keys())[0]) value = element[lens] self.set_voltages[lens] = value channel_number = self.lenses.index(lens) + 1 self.ion_optics.set_voltage(channel_number, value) qsize = self.pushsocket.queue.qsize() time.sleep(0.1)
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 __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) port = 'usb-FTDI_USB-RS232_Cable_FTV9UVIO-if00-port0' omega = omegabus.OmegaBus(device='/dev/serial/by-id/' + port, model='D5251', baud=300) hih_instance = honeywell_6000.HIH6130() reader = Reader(omega, hih_instance) reader.start() time.sleep(2.5) codenames = ['b307_049_h2_pressure', 'b307_049_temperature', 'b307_049_humidity'] loggers = {} loggers[codenames[0]] = ValueLogger(reader, comp_val=0.1, maximumtime=600, 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.5, maximumtime=600, comp_type='lin', channel=2) loggers[codenames[2]].start() livesocket = LiveSocket('307_049 Logger', codenames) livesocket.start() socket = DateDataPullSocket('307_049 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 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(): 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:]) agilent_hostname = '10.54.6.79' rtd_reader = RtdReader(agilent_hostname, start_temp) except: print('Could not find rasppi12') exit() rtd_reader.daemon = True rtd_reader.start() time.sleep(1) PS = {} for k in range(1, 3): PS[k] = cpx.CPX400DPDriver(k, interface='serial', device='/dev/ttyACM0') PS[k].set_voltage(0) PS[k].output_status(True) try: micro = chr(0x03BC) # Python 3 except ValueError: micro = unichr(0x03BC) # Python 2 Pullsocket = DateDataPullSocket(micro + 'reactor temp_control', ['setpoint', 'voltage', 'temperature'], timeouts=[999999, 3.0, 3.0], port=9000) Pullsocket.start() Pushsocket = DataPushSocket(micro + '-reactor push control', action='store_last') Pushsocket.start() pcc = PowerCalculatorClass(Pullsocket, Pushsocket, rtd_reader) pcc.daemon = True pcc.start() heater = HeaterClass(P, Pullsocket, PS) heater.start() tui = CursesTui(H) tui.daemon = True tui.start()
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 """ 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 """ 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 function """ ups = galaxy_3500.Galaxy3500('b312-ups') reader = UpsReader(ups) reader.daemon = True reader.start() time.sleep(5) codenames = ['b312_ups_temperature', 'b312_ups_kVAPh1', 'b312_ups_kVAPh2', 'b312_ups_kVAPh3', 'b312_ups_output_current_Ph1', 'b312_ups_output_current_Ph2', 'b312_ups_output_current_Ph3', 'b312_ups_input_frequency', 'b312_ups_input_voltage_Ph1', 'b312_ups_input_voltage_Ph2', 'b312_ups_input_voltage_Ph3', 'b312_ups_output_voltage_Ph1', 'b312_ups_output_voltage_Ph2', 'b312_ups_output_voltage_Ph3', 'b312_ups_battery_voltage', 'b312_ups_battery_current', 'b312_ups_battery_state_of_charge', 'b312_ups_output_frequency'] loggers = {} for i in range(0, len(codenames)): loggers[codenames[i]] = ValueLogger(reader, comp_val=0.1, channel=i) loggers[codenames[i]].start() socket = DateDataPullSocket('UPS status', codenames, timeouts=[5.0] * len(codenames)) socket.start() live_socket = LiveSocket('UPS Status', codenames) live_socket.start() db_logger = ContinuousDataSaver(continuous_data_table='dateplots_ups_b312', username=credentials.user, password=credentials.passwd, measurement_codenames=codenames) db_logger.start() time.sleep(5) while reader.isAlive(): 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(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) 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 """ 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): threading.Thread.__init__(self) channels = ['setpoint', 'emission', 'ionenergy'] self.datasocket = DateDataPullSocket('emission_tof', channels, timeouts=[99999999, 1.0, 99999999]) self.datasocket.start() self.pushsocket = DataPushSocket('tof-emission-push_control', action='enqueue') self.pushsocket.start() self.livesocket = LiveSocket('tof-emission', channels) self.livesocket.start() self.filament = {} port = '/dev/serial/by-id/usb-TTI_CPX400_Series_PSU_C2F952E5-if00' self.filament['device'] = CPX.CPX400DPDriver(1, interface='serial', device=port) self.filament['voltage'] = 0 self.filament['current'] = 0 self.filament['idle_voltage'] = 1.7 self.filament['device'].set_current_limit(4.0) self.filament['device'].output_status(True) self.bias = {} self.bias['device'] = CPX.CPX400DPDriver(2, interface='serial', device=port) self.bias['grid_voltage'] = 0 self.bias['grid_current'] = 0 self.bias['device'].output_status(True) cns = 'USB0::0x0957::0x0607::MY45000583::INSTR' self.bias['current_reader'] = a34410A.Agilent34410ADriver(interface='usbtmc', connection_string=cns) self.bias['current_reader'].select_measurement_function('CURRENT') self.pid = pid.PID(0.01, 0.1, 0, 4) self.looptime = 0 self.setpoint = 0.05 self.pid.update_setpoint(self.setpoint) self.running = True self.wanted_voltage = 0 self.emission_current = 999
def __init__(self): threading.Thread.__init__(self) self.sock = socket.socket(socket.AF_INET, socket.SOCK_DGRAM) self.sock.settimeout(2) self.quit = False sockname = 'tabs_all' self.codenames = socketinfo.INFO[sockname]['codenames'] self.PullSocket = DateDataPullSocket( sockname, self.codenames, timeouts=[60.0] * len(self.codenames), port=socketinfo.INFO[sockname]['port']) self.PullSocket.start() self.data = {} for co in self.codenames: self.data[co] = None
def __init__(self): threading.Thread.__init__(self) channels = ['setpoint', 'emission', 'ionenergy'] self.datasocket = DateDataPullSocket('emission_tof', channels, timeouts=[99999999, 1.0, 99999999]) self.datasocket.start() self.pushsocket = DataPushSocket('tof-emission-push_control', action='enqueue') self.pushsocket.start() self.livesocket = LiveSocket('tof-emission', channels) self.livesocket.start() self.filament = {} port = '/dev/serial/by-id/usb-TTI_CPX400_Series_PSU_C2F952E5-if00' self.filament['device'] = CPX.CPX400DPDriver(1, interface='serial', device=port) self.filament['voltage'] = 0 self.filament['current'] = 0 self.filament['idle_voltage'] = 1.7 self.filament['device'].set_current_limit(7) self.filament['device'].output_status(True) self.bias = {} port = '/dev/serial/by-id/' port += 'usb-Prolific_Technology_Inc._USB-Serial_Controller_D-if00-port0' self.keithley_port = port self.bias['device'] = smu.KeithleySMU(interface='serial', device=self.keithley_port) self.bias['grid_voltage'] = 0 self.bias['grid_current'] = 0 self.bias['device'].output_state(True) self.pid = pid.PID(0.01, 0.1, 0, 4) self.looptime = 0 self.setpoint = 0.05 self.pid.update_setpoint(self.setpoint) self.running = True self.wanted_voltage = 0 self.emission_current = 999
def __init__(self, mks_instance, mfcs, devices, name): threading.Thread.__init__(self) self.mfcs = mfcs self.mks = mks_instance self.pullsocket = DateDataPullSocket(name, devices, timeouts=3.0, port=9000) self.pullsocket.start() self.pushsocket = DataPushSocket(name, action='enqueue') self.pushsocket.start() self.livesocket = LiveSocket('palle_mks_flows', devices) self.livesocket.start() self.running = True
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 __init__(self,): threading.Thread.__init__(self) #from mytui import CursesTui self.quit = False self.codenames = ['tabs_guard_temperature_setpoint', 'tabs_floor_temperature_setpoint', 'tabs_ceiling_temperature_setpoint', 'tabs_cooling_temperature_setpoint', ] sockname = 'tabs_setpoints' self.PullSocket = DateDataPullSocket(sockname, self.codenames, timeouts=[60.0]*len(self.codenames), port = socketinfo.INFO[sockname]['port']) self.PullSocket.start() self.TUI = CursesTui(self.codenames) self.TUI.start() #time.sleep(5) chlist = {'tabs_guard_temperature_setpoint': 0, 'tabs_floor_temperature_setpoint': 1, 'tabs_ceiling_temperature_setpoint': 2, 'tabs_cooling_temperature_setpoint': 3} self.loggers = {} for key in self.codenames: self.loggers[key] = ValueLogger(self.TUI, comp_val = 0.2, 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) #print('Hostname of db logger: ' + db_logger.host) self.db_logger.start()
def main(): 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:]) agilent_hostname = '10.54.6.79' rtd_reader = RtdReader(agilent_hostname, start_temp) except: print('Could not find rasppi12') exit() rtd_reader.daemon = True rtd_reader.start() time.sleep(1) PS = {} for k in range(1, 3): PS[k] = cpx.CPX400DPDriver(k, interface='serial', device='/dev/ttyACM0') PS[k].set_voltage(0) PS[k].output_status(True) try: micro = chr(0x03BC) # Python 3 except ValueError: micro = unichr(0x03BC) # Python 2 Pullsocket = DateDataPullSocket(micro + 'reactor temp_control', ['setpoint', 'voltage', 'temperature'], timeouts=[999999, 3.0, 3.0], port=9000) Pullsocket.start() Pushsocket = DataPushSocket(micro + '-reactor push control', action='store_last') Pushsocket.start() pcc = PowerCalculatorClass(Pullsocket, Pushsocket, rtd_reader) pcc.daemon = True pcc.start() heater = HeaterClass(pcc, Pullsocket, PS) heater.start() tui = CursesTui(heater) tui.daemon = True tui.start()
def main(): """ Main function """ logging.basicConfig(filename="logger.txt", level=logging.ERROR) logging.basicConfig(level=logging.ERROR) qcm_port = ('/dev/serial/by-id/' + 'usb-Prolific_Technology_Inc._USB-Serial_Controller-if00-port0') qcm = inficon.InficonSQM160(qcm_port) reader = QcmReader(qcm) reader.daemon = True reader.start() codenames = ['volvo_qcm_frequency', 'volvo_qcm_crystal_life', 'volvo_qcm_thickness'] loggers = {} loggers[codenames[0]] = ValueLogger(reader, comp_val=0.1, channel=0) loggers[codenames[0]].start() loggers[codenames[1]] = ValueLogger(reader, comp_val=0.01, channel=1) loggers[codenames[1]].start() loggers[codenames[2]] = ValueLogger(reader, comp_val=0.001, channel=2) loggers[codenames[2]].start() socket = DateDataPullSocket('Volvo QCM', codenames, port=9000, timeouts=[5.0] * len(codenames)) 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() time.sleep(5) while reader.isAlive(): 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) #from mytui import CursesTui self.quit = False self.codenames = [ 'tabs_guard_temperature_setpoint', 'tabs_floor_temperature_setpoint', 'tabs_ceiling_temperature_setpoint', 'tabs_cooling_temperature_setpoint', ] sockname = 'tabs_setpoints' self.PullSocket = DateDataPullSocket( sockname, self.codenames, timeouts=[60.0] * len(self.codenames), port=socketinfo.INFO[sockname]['port']) self.PullSocket.start() self.TUI = CursesTui(self.codenames) self.TUI.daemon = True self.TUI.start() #time.sleep(5) chlist = { 'tabs_guard_temperature_setpoint': 0, 'tabs_floor_temperature_setpoint': 1, 'tabs_ceiling_temperature_setpoint': 2, 'tabs_cooling_temperature_setpoint': 3 } self.loggers = {} for key in self.codenames: self.loggers[key] = ValueLogger(self.TUI, comp_val=0.2, 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) #print('Hostname of db logger: ' + db_logger.host) self.db_logger.start()
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'] codenames = ['volvo_pressure'] loggers = {} loggers[codenames[0]] = ValueLogger(pressure, comp_val=0.1, comp_type='log', low_comp=1e-9) 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) 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 main(): """ Main function """ codenames = [] for channel in settings.channels.values(): channel['reader'] = SocketReaderClass(channel['host'], channel['port'], channel['command']) channel['reader'].start() channel['logger'] = ValueLogger(channel['reader'], comp_val=channel['comp_value']) channel['logger'].daemon = True channel['logger'].start() codenames.append(channel['codename']) try: port = settings.port_number except AttributeError: port = 9000 pullsocket = DateDataPullSocket(settings.user + '-socket_logger', codenames, timeouts=5, port=port) pullsocket.start() db_logger = ContinuousDataSaver(continuous_data_table=settings.dateplot_table, username=settings.user, password=settings.passwd, measurement_codenames=codenames) db_logger.start() time.sleep(2) everything_ok = True while everything_ok: time.sleep(0.25) for channel in settings.channels.values(): if not channel['reader'].isAlive(): everything_ok = False # Report error here!!! # Consider to keep program running even in case of # socket failures value = channel['logger'].read_value() pullsocket.set_point_now(channel['codename'], value) if channel['logger'].read_trigged(): print(value) db_logger.save_point_now(channel['codename'], value) channel['logger'].clear_trigged()
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.daemon = True reader.start() time.sleep(5) codenames = ['chemlab312_temperature', 'chemlab312_humidity'] loggers = {} loggers[codenames[0]] = ValueLogger(reader, comp_val=0.2, comp_type='lin', channel=1) loggers[codenames[0]].daemon = True loggers[codenames[0]].start() loggers[codenames[1]] = ValueLogger(reader, comp_val=0.2, comp_type='lin', channel=2) loggers[codenames[1]].daemon = True loggers[codenames[1]].start() livesocket = LiveSocket('Chemlab312 Air Logger', codenames) livesocket.start() socket = DateDataPullSocket('Chemlab312 Air Logger', codenames, timeouts=[1.0] * len(loggers)) socket.start() db_logger = ContinuousDataSaver(continuous_data_table='dateplots_chemlab312', username=credentials.user, password=credentials.passwd, measurement_codenames=codenames) db_logger.start() while reader.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()
class FlowControl(threading.Thread): """ Keep updated values of the current flow or pressure """ def __init__(self, mfcs, name): threading.Thread.__init__(self) self.daemon = True self.mfcs = mfcs print(mfcs) devices = list(self.mfcs.keys()) self.values = {} for device in devices: self.values[device] = None self.pullsocket = DateDataPullSocket(name + '_analog_control', devices, timeouts=[3.0] * len(devices)) self.pullsocket.start() self.pushsocket = DataPushSocket(name + '_analog_pc_control', action='enqueue') self.pushsocket.start() self.livesocket = LiveSocket(name + '_analog_mfc_control', devices) self.livesocket.start() self.running = True def value(self, device): """ Return the current value of a device """ return self.values[device] def run(self): while self.running: time.sleep(0.1) qsize = self.pushsocket.queue.qsize() while qsize > 0: print('queue-size: ' + str(qsize)) element = self.pushsocket.queue.get() mfc = list(element.keys())[0] self.mfcs[mfc].set_flow(element[mfc]) qsize = self.pushsocket.queue.qsize() for mfc in self.mfcs: flow = self.mfcs[mfc].read_flow() self.values[mfc] = flow print(flow) self.pullsocket.set_point_now(mfc, flow) self.livesocket.set_point_now(mfc, flow)
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 __init__(self, mfcs, name): threading.Thread.__init__(self) self.mfcs = mfcs print(mfcs) devices = list(self.mfcs.keys()) self.values = {} for device in devices: self.values[device] = None self.pullsocket = DateDataPullSocket(name + '_analog_control', devices, timeouts=[3.0] * len(devices)) self.pullsocket.start() self.pushsocket = DataPushSocket(name + '_analog_pc_control', action='enqueue') self.pushsocket.start() self.livesocket = LiveSocket(name + '_analog_mfc_control', devices) self.livesocket.start() self.running = True
def main(): """ Main function """ valve_names = [0] * 20 for i in range(0, 20): valve_names[i] = str(i + 1) pullsocket = DateDataPullSocket('VHP Valvecontrol', valve_names, timeouts=[2]*20) pullsocket.start() pushsocket = DataPushSocket('VHP calve 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): 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'] self.livesocket = LiveSocket(self.setup + '-bakeout', channels, 1) self.livesocket.start() self.pullsocket = DateDataPullSocket(self.setup + '-bakeout', channels, timeouts=[2]*6) self.pullsocket.start() self.pushsocket = DataPushSocket(self.setup + '-push_control', action='enqueue') self.pushsocket.start()
class Local(threading.Thread): """ This class will be automatically started by the mass-spec program it can be arbritrarily simply or complex and will provide a local udp-socket to be included in a meta-channel in the mass-spec, thus allowing integraion of local instruments """ 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 run(self): while True: time.sleep(0.1) value = self.omega.read_value(2) self.pullsocket.set_point_now('analog_in', value)
def main(): """ main function""" wp.wiringPiSetup() watchdog = Watchdog() watchdog.daemon = True watchdog.start() time.sleep(1) datasocket = DateDataPullSocket('stm312_bakeoutbox', ['stm312_bakeoutbox'], timeouts=[1.0]) datasocket.start() baker = Bakeout(watchdog, datasocket) baker.start() tui = CursesTui(baker) #tui.daemon = True tui.start() while not baker.quit: time.sleep(1) watchdog.quit = True time.sleep(2) baker.quit = True