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()
