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()
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)
class GC_start_stop_socket(object): def __init__(self): self.state = 'alive' self.injection_number = 0 self.relay = Relay() self.name = 'Sigrun_GC_start_stop' self.socket = DataPushSocket(self.name, action='callback_direct', callback=self.callback, return_format='json', port=8502) self.socket.start() def callback(self, data): method_name = data.pop('method') method = self.__getattribute__(method_name) return method(**data) def stop(self): self.socket.stop() def start_run(self): self.relay.start_GC() print('Starting GC on '+time.ctime()) self.run_in_progress = True def stop_run(self): self.relay.stop_GC() print('Stopping GC on '+time.ctime()) self.run_in_progress = False
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
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 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 __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 """ 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(): 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 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, 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 test_init_enqueue(self): """Test initialization with when action is enqueue""" dps = DataPushSocket(NAME, action='enqueue') dps.start() self.init_common_tests(dps, 'enqueue') assert(isinstance(dps.queue, Queue.Queue)) assert(DATA[PORT]['queue'] is dps.queue) dps.stop()
class I2CComm(object): """Handle I2C communication with DAC and ADC""" def __init__(self): self.measurements = {} self.mcp3428 = MCP3428() self.ad5667 = AD5667() self.dps = DataPushSocket( 'large_CO2_mea_push_socket', action='callback_direct', callback=self.communicate, return_format='json', ) # These two queues form a pair, that is used to interrupt the # continuous measurement of the values from the ADC to allow # setting the DAC and return copy the values from the ADC self.comm_flag = Queue() self.comm_return = Queue() self.dps.start() def measure(self): """Main measure loop (busy)""" while True: for channel in range(1, 5): self.measurements[channel] = self.mcp3428.read_sample(channel) print("Measured:", self.measurements) try: values_to_set = self.comm_flag.get(block=False) except Empty: continue # If we escaped the comm_flag test, we should set and enqueue current values if "no_voltages_to_set" not in values_to_set: print("Asked to set DAC values", values_to_set) sleep(0.01) self.ad5667.set_channel_A(values_to_set['A']) self.ad5667.set_channel_B(values_to_set['B']) sleep(0.01) self.comm_return.put(dict(self.measurements)) def run(self): """Run method used to allow keyboard interrupts""" try: self.measure() except KeyboardInterrupt: self.dps.stop() def communicate(self, data): """Send the received values to be written on the DAC and return values from the ADC """ self.comm_flag.put(data) # Wait until we get values back result = self.comm_return.get() return result
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 test_init_callback_direct_default(self): """Test initialization when action is callback_direct""" # Test init of callback dps = DataPushSocket(NAME, action='callback_direct', callback=dir) dps.start() self.init_common_tests(dps, 'callback_direct') assert(DATA[PORT]['callback'] is dir) assert(DATA[PORT]['return_format'] == 'json') dps.stop()
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 test_init_custom_queue(self): """Test initialization when action is enqueue and use custom queue""" queue = Queue.Queue() dps = DataPushSocket(NAME, action='enqueue', queue=queue) dps.start() self.init_common_tests(dps, 'enqueue') assert(dps.queue is queue) assert(DATA[PORT]['queue'] is queue) dps.stop()
def test_init_callback_direct_raw(self): """Test initialization when action is callback_direct""" # Test init of callback dps_ = DataPushSocket(NAME, action='callback_direct', callback=dir, return_format='raw') dps_.start() self.init_common_tests(dps_, 'callback_direct') assert DATA[PORT]['callback'] is dir assert DATA[PORT]['return_format'] == 'raw' dps_.stop()
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 test_init_callback_async(self): """Test initialization when action is callback_async""" # Test init of callback dps = DataPushSocket(NAME, action='callback_async', callback=dir) dps.start() self.init_common_tests(dps, 'callback_async') assert(isinstance(dps.queue, Queue.Queue)) assert(DATA[PORT]['queue'] is dps.queue) assert(isinstance(dps._callback_thread, CallBackThread)) assert(dps._callback_thread.callback is dir) dps.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 __init__(self): self.state = 'alive' self.injection_number = 0 self.relay = Relay() self.name = 'Sigrun_GC_start_stop' self.socket = DataPushSocket(self.name, action='callback_direct', callback=self.callback, return_format='json', port=8502) self.socket.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 __init__(self): self.settings = {'power': 100, 'focus': 100, 'target': None} self._state = 'idle' self._stop = False self._temperature_meas = Queue.Queue() name = 'Laser control, callback socket, for giant laser on the moon' self.dps = DataPushSocket(name, action='callback_direct', callback=self.callback, return_format='json') self.dps.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(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 __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): 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) 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 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 __init__(self, devices=None): """Initialize CPXServer Args: devices (dict): Mapping of power supply names (letters) to hostnames. E.g: {'A': '/dev/serial/by-id/usb-TTI_CPX400_Series_PSU_C2F95400-if00', 'B': '/dev/serial/by-id/usb-TTI_CPX400_Series_PSU_12345600-if00'} """ if not devices: msg = '"devices" must be dict of power supply number to hostname, not: {}' raise ValueError(msg.format(devices)) self.devices = devices self.cpxs = {} # Plural of cpx?? # Mapping of power supply name to driver for power_supply_name, device in devices.items(): LOG.debug('Connect %s, %s', power_supply_name, device) if not isinstance(power_supply_name, str): msg = '"power_supply_name" in devices must be str, not: {}' raise ValueError(msg.format(type(power_supply_name))) # Init CPX400DP driver self.cpxs[power_supply_name] = CPX400DPDriver( 1, # will be overwritten anyway interface='serial', device=device, ) self.accepted_commands = { 'set_voltage', 'read_set_voltage', 'set_current_limit', 'read_current_limit', 'read_actual_voltage', 'read_actual_current', 'output_status', 'read_output_status' } self.valid_outputs = {'1', '2'} # Test connection for cpx_name, cpx in self.cpxs.items(): for _ in range(3): try: print('Connect to CPS', cpx.read_actual_voltage()) break except TypeError: message = "Connection error, waiting 3 sec and try again" print(message) LOG.error(message) sleep(3) else: message = ('Unable to connect to power supplies\n' 'Swich them off and on and wait 3min and try again') LOG.critical(message) raise RuntimeError(message) if cpx.read_actual_voltage() < -999: error = 'Unable to connect to power supply "{}" with name "{}"' raise RuntimeError(error.format(cpx, cpx_name)) # Form data push socket for receiving commands self.dps = DataPushSocket('H2O2_ps_server', action='callback_direct', callback=self.handle_command)
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): self.measurements = {} self.mcp3428 = MCP3428() self.ad5667 = AD5667() self.dps = DataPushSocket( 'large_CO2_mea_push_socket', action='callback_direct', callback=self.communicate, return_format='json', ) # These two queues form a pair, that is used to interrupt the # continuous measurement of the values from the ADC to allow # setting the DAC and return copy the values from the ADC self.comm_flag = Queue() self.comm_return = Queue() self.dps.start()
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 """ 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, 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 __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 __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()
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()
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 __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, 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 __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, 1) 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
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('palle_mks_flows', 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 """ power_supply = cpx.CPX400DPDriver(1, device='/dev/ttyACM0', interface='serial') power_supply.set_dual_output(False) # Synchronize outputs power_supply.set_current_limit(2.4) pullsocket = DateDataPullSocket('vhp_temp_control', ['setpoint', 'pid_p', 'pid_i', 'pid_e', 'voltage'], timeouts=[999999, 3.0, 3.0, 3.0, 3.0], port=9000) 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, power_supply) heater.start() tui = CursesTui(heater, power_supply) tui.daemon = True tui.start()
def class_dps(request): """DataPushSocket fixture If requested in a class that has dps_kwargs class variable, use those in init .. note:: This fixture lasts for the duration of a test class. It has been setup like this because the sockets take a long time to shut down. So in order to save time on the test run, we only initiate the socket once per class, but reset it in the dps fixture. It is the dps fixture that should be used. """ if hasattr(request, 'cls') and hasattr(request.cls, 'dps_kwargs'): dps_ = DataPushSocket(NAME, **request.cls.dps_kwargs) else: dps_ = DataPushSocket(NAME) dps_.start() yield dps_ dps_.stop()
def dps(request): """DataPushSocket fixture, if requested in a class that has dps_kwargs class variable, use those in init """ if hasattr(request, 'cls') and hasattr(request.cls, 'dps_kwargs'): dps = DataPushSocket(NAME, **request.cls.dps_kwargs) else: dps = DataPushSocket(NAME) dps.start() yield dps dps.stop()
def __init__(self): self.measurements = {} self.mcp3428 = MCP3428() #self.ad5667 = AD5667() self.dps = DataPushSocket( 'large_CO2_mea_push_socket', action='callback_direct', callback=self.communicate, return_format='json', ) # These two queues form a pair, that is used to interrupt the # continuous measurement of the values from the ADC to allow # setting the DAC and return copy the values from the ADC self.comm_flag = Queue() self.comm_return = Queue() self.dps.start()
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('sniffer_pc_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 __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
class Bakeout(threading.Thread): """ The actual heater """ 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() def activate(self, pin): """ Activate a pin """ if settings.count_from_right: pin = pin else: pin = 7 - pin if self.watchdog.watchdog_safe: wp.digitalWrite(pin, 1) else: wp.digitalWrite(pin, 0) def deactivate(self, pin): """ De-activate a pin """ if settings.count_from_right: pin = pin else: pin = 7 - pin wp.digitalWrite(pin, 0) def modify_dutycycle(self, channel, amount=None, value=None): """ Change the dutycycle of a channel """ if amount is not None: self.dutycycles[channel-1] = self.dutycycles[channel-1] + amount if value is not None: self.dutycycles[channel-1] = value if self.dutycycles[channel-1] > 1: self.dutycycles[channel-1] = 1 if self.dutycycles[channel-1] < 0.0001: self.dutycycles[channel-1] = 0 self.livesocket.set_point_now(str(channel), self.dutycycles[channel-1]) self.pullsocket.set_point_now(str(channel), self.dutycycles[channel-1]) return self.dutycycles[channel-1] def run(self): totalcycles = settings.number_of_cycles self.quit = False cycle = 0 while not self.quit: start_time = time.time() qsize = self.pushsocket.queue.qsize() LOGGER.debug('qsize: ' + str(qsize)) while qsize > 0: element = self.pushsocket.queue.get() LOGGER.debug('Element: ' + str(element)) channel = element.keys()[0] value = element[channel] self.modify_dutycycle(int(channel), value=value) qsize = self.pushsocket.queue.qsize() self.watchdog.reset_ttl() for i in range(1, 7): if (1.0*cycle/totalcycles) < self.dutycycles[i-1]: self.activate(i) else: self.deactivate(i) cycle = cycle + 1 cycle = cycle % totalcycles run_time = time.time() - start_time sleep_time = 1.0 * settings.cycle_time / settings.number_of_cycles try: time.sleep(sleep_time - run_time) except IOError: self.quit = True LOGGER.fatal('Program runs too slow to perform this operation!') for i in range(0, 7): # Ready to quit self.deactivate(i)