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 """ 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 __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(): """ 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, 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 __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 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 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 """ 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 __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(): """ 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.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(): 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 __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): 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 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): 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): 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
# pylint: disable=R0913,W0142,C0103 import time import PyExpLabSys.common.valve_control as valve_control from PyExpLabSys.common.sockets import DateDataPullSocket from PyExpLabSys.common.sockets import DataPushSocket valve_names = [0] * 20 for i in range(0, 20): valve_names[i] = str(i + 1) Pullsocket = DateDataPullSocket('Palle, Valve control', valve_names, timeouts=[2] * 20) Pullsocket.start() Pushsocket = DataPushSocket('Palle, push control', action='enqueue') Pushsocket.start() vc = valve_control.ValveControl(valve_names, Pullsocket, Pushsocket) vc.start() while True: time.sleep(1) vc.running = False
name[i] = bronk.read_serial() name[i] = name[i].strip() error = error + 1 if name[i] in devices: MFCs[name[i]] = bronkhorst.Bronkhorst('/dev/ttyUSB' + str(i), ranges[name[i]]) MFCs[name[i]].set_control_mode() #Accept setpoint from rs232 print name[i] Datasocket = DateDataPullSocket('microreactor_mfc_control', devices, timeouts=[3.0, 3.0, 3.0, 3.0, 3.0, 3.0, 3.0], port=9000) Datasocket.start() Pushsocket = DataPushSocket('microreactor_mfc_control', action='enqueue') Pushsocket.start() Livesocket = LiveSocket('microreactor_mfc_control', devices, 1) Livesocket.start() fc = FlowControl(MFCs, Datasocket, Pushsocket, Livesocket) fc.start() Logger = ValueLogger(fc, comp_val=1, comp_type='log', low_comp=0.0001, channel=1) Logger.start() Sniffer_Logger = ValueLogger(fc,
PS = CommonPowerSupply() PS.start() Pullsocket_mai = DateDataPullSocket('pvd_temp_control_mai', ['setpoint', 'voltage'], timeouts=[999999, 3], port=9000) Pullsocket_mai.start() Pullsocket_dca = DateDataPullSocket('pvd_temp_control_dca', ['setpoint', 'voltage'], timeouts=[999999, 3], port=9002) Pullsocket_dca.start() Pushsocket_mai = DataPushSocket('pvd309_push_control_mai', action='store_last', port=8500) Pushsocket_mai.start() Pushsocket_dca = DataPushSocket('pvd309_push_control_dca', action='store_last', port=8502) Pushsocket_dca.start() P_mai = PowerCalculatorClass(Pullsocket_mai, Pushsocket_mai, 'pvd309_temp_mai_cell#raw') P_mai.daemon = True P_mai.start() P_dca = PowerCalculatorClass(Pullsocket_mai, Pushsocket_dca, 'pvd309_temp_dca_cell#raw') P_dca.daemon = True
time.sleep(1.0 * self.beatperiod / self.beatsteps) if i < self.beatsteps * self.dutycycle: wp.digitalWrite(self.pinnumber, 1) else: wp.digitalWrite(self.pinnumber, 0) wp.digitalWrite(self.pinnumber, 0) wp.wiringPiSetup() datasocket = DateDataPullSocket('furnaceroom_controller', ['setpoint', 'dutycycle'], timeouts=[999999, 3.0], port=9000) datasocket.start() pushsocket = DataPushSocket('furnaceroom_push_control', action='store_last') pushsocket.start() P = PowerCalculatorClass(datasocket, pushsocket) #print P.ramp_calculator(2) #print P.ramp_calculator(2000) P.daemon = True P.start() H = HeaterClass(P, datasocket) #H.daemon = True H.start() T = CursesTui(H) T.daemon = True T.start()
def __init__(self, port, socket_name, codenames, user_labels, valve_properties, db_saver=None): """ Args: port (int): directory to port of USB to RS232 communication socket_name (str): name on net for pushsocket codenames (list of str): names for retrieving all pressures and states of valves user_labels (list of str): userlabel on each device connected to xgs600 valve_properties (dict): A dictionarie of valve with a list of properties to each valve in the form of {valve_name: [channel, device, setpoint_on, setpoint_off], } each valve must have a channel in the XGS600 and a devices to measure the pressure and two setpoints for the pressure for which the valve is on and off Returns: PushSocket to control XGSvalve states PullSocket to acces state of Valves PullSocket to acces measured pressure in system """ self.xgs600 = xgs600(port=port) time.sleep(0.2) threading.Thread.__init__(self) #setting the initial setup specific values self.codenames = codenames self.devices = user_labels self.valve_properties = valve_properties self.valve_names = list(self.valve_properties.keys()) #setting the initial program specific values self.pressures = None self.setpointstates = None self.quit = False self.update_time = [time.time()] * len(self.valve_names) self.updated = [0] * len(self.valve_names) names = self.codenames + self.devices print(names) #starting push-, pull-, and live- sockets self.pullsocket = DateDataPullSocket( socket_name, names, timeouts=3.0, port=9000, ) self.pullsocket.start() self.pushsocket = DataPushSocket(socket_name, action='enqueue') self.pushsocket.start() self.livesocket = LiveSocket(socket_name, names) self.livesocket.start() if db_saver is not None: self.db_saver = db_saver self.db_saver.start() self.queue = self.pushsocket.queue
port = '/dev/serial/by-id/usb-TTI_CPX400_Series_PSU_55126216-if00' PS = {} for i in range(1, 3): PS[i] = cpx.CPX400DPDriver(i, interface='lan', hostname='cinf-palle-heating-ps', tcp_port=9221) PS[i].set_voltage(0) PS[i].output_status(True) Pullsocket = DateDataPullSocket('mgw_temp_control', ['setpoint', 'voltage'], timeouts=[999999, 3.0], port=9000) Pullsocket.start() Pushsocket = DataPushSocket('mgw_push_control', action='store_last') Pushsocket.start() P = PowerCalculatorClass(Pullsocket, Pushsocket) P.daemon = True P.start() H = HeaterClass(P, Pullsocket, PS) #H.daemon = True H.start() T = CursesTui(H) T.daemon = True T.start()