def main():
""" Main function """
logging.basicConfig(filename="logger.txt", level=logging.ERROR)
logging.basicConfig(level=logging.ERROR)
port = '/dev/serial/by-id/usb-Prolific_Technology_Inc._USB-Serial_Controller_D-if00-port'
port = '/dev/ttyUSB0'
codenames = [
'xrd_pressure_turbo_gas_system', 'xrd_pressure_gas_system_wrg',
'xrd_pressure_mass_spec_wrg', 'xrd_pressure_gas_system_baratron'
]
reader = PressureReader(port)
reader.daemon = True
reader.start()
loggers = {}
loggers[codenames[0]] = ValueLogger(reader,
comp_val=0.02,
comp_type='log',
channel=1)
loggers[codenames[1]] = ValueLogger(reader,
comp_val=0.02,
comp_type='log',
channel=2)
loggers[codenames[2]] = ValueLogger(reader,
comp_val=0.02,
comp_type='log',
channel=3)
loggers[codenames[3]] = ValueLogger(reader,
comp_val=2,
comp_type='lin',
channel=4)
for i in range(0, 4):
loggers[codenames[i]].start()
socket = DateDataPullSocket('XRD Pressure',
codenames,
timeouts=[2.0] * len(codenames))
socket.start()
live_socket = LiveSocket('XRD pressure', codenames, 2)
live_socket.start()
db_logger = ContinuousDataSaver(continuous_data_table='dateplots_xrd',
username=credentials.user,
password=credentials.passwd,
measurement_codenames=codenames)
db_logger.start()
time.sleep(5)
while True:
time.sleep(0.25)
for name in codenames:
value = loggers[name].read_value()
socket.set_point_now(name, value)
live_socket.set_point_now(name, value)
if loggers[name].read_trigged():
print(name + ': ' + str(value))
db_logger.save_point_now(name, value)
loggers[name].clear_trigged()
class FlowControl(threading.Thread):
""" Keep updated values of the current flow """
def __init__(self, mks_instance, mfcs, devices, name):
threading.Thread.__init__(self)
self.mfcs = mfcs
self.mks = mks_instance
self.pullsocket = DateDataPullSocket(name, devices, timeouts=3.0, port=9000)
self.pullsocket.start()
self.pushsocket = DataPushSocket(name, action='enqueue')
self.pushsocket.start()
self.livesocket = LiveSocket(name, devices)
self.livesocket.start()
self.running = True
def run(self):
while self.running:
time.sleep(0.1)
qsize = self.pushsocket.queue.qsize()
while qsize > 0:
element = self.pushsocket.queue.get()
mfc = list(element.keys())[0]
print(element[mfc])
print('Queue: ' + str(qsize))
self.mks.set_flow(element[mfc], self.mfcs[mfc])
qsize = self.pushsocket.queue.qsize()
for mfc in self.mfcs:
print('!!!')
flow = self.mks.read_flow(self.mfcs[mfc])
print(mfc + ': ' + str(flow))
self.pullsocket.set_point_now(mfc, flow)
self.livesocket.set_point_now(mfc, flow)
def main():
""" Main function """
tempreader = TemperatureReader()
tempreader.daemon = True
tempreader.start()
temp_logger = ValueLogger(tempreader, comp_val=1)
temp_logger.start()
db_logger = ContinuousDataSaver(continuous_data_table='dateplots_chemlab307',
username=credentials.user,
password=credentials.passwd,
measurement_codenames=['chemlab307_muffle_furnace'])
socket = DateDataPullSocket('muffle_furnace',
['chemlab307_muffle_furnace'],
timeouts=[1.0])
socket.start()
livesocket = LiveSocket('muffle_furnace', ['chemlab307_muffle_furnace'])
livesocket.start()
db_logger.start()
time.sleep(5)
while True:
time.sleep(0.25)
value = temp_logger.read_value()
socket.set_point_now('chemlab307_muffle_furnace', value)
livesocket.set_point_now('chemlab307_muffle_furnace', value)
if temp_logger.read_trigged():
print(value)
db_logger.save_point_now('chemlab307_muffle_furnace', value)
temp_logger.clear_trigged()
def main():
""" Main function """
logging.basicConfig(filename="logger.txt", level=logging.ERROR)
logging.basicConfig(level=logging.ERROR)
omron_instance = omron_d6fph.OmronD6fph()
hih_instance = honeywell_6000.HIH6130()
reader = Reader(omron_instance, hih_instance)
reader.start()
time.sleep(5)
codenames = [
'hall_ventilation_pressure', 'hall_temperature', 'hall_humidity'
]
loggers = {}
loggers[codenames[0]] = ValueLogger(reader,
comp_val=1.0,
maximumtime=300,
comp_type='lin',
channel=0)
loggers[codenames[0]].start()
loggers[codenames[1]] = ValueLogger(reader,
comp_val=0.2,
maximumtime=600,
comp_type='lin',
channel=1)
loggers[codenames[1]].start()
loggers[codenames[2]] = ValueLogger(reader,
comp_val=0.2,
maximumtime=600,
comp_type='lin',
channel=2)
loggers[codenames[2]].start()
livesocket = LiveSocket('Hall Ventilation Logger', codenames)
livesocket.start()
socket = DateDataPullSocket('Hall Ventilation logger',
codenames,
timeouts=[1.0] * len(loggers))
socket.start()
db_logger = ContinuousDataSaver(continuous_data_table='dateplots_hall',
username=credentials.user,
password=credentials.passwd,
measurement_codenames=codenames)
db_logger.start()
while reader.isAlive():
time.sleep(1)
for name in codenames:
value = loggers[name].read_value()
livesocket.set_point_now(name, value)
socket.set_point_now(name, value)
if loggers[name].read_trigged():
print(name + ': ' + str(value))
db_logger.save_point_now(name, value)
loggers[name].clear_trigged()
class SocketSupervisor(threading.Thread):
""" Supervisor will check that a list of ports are still open """
def __init__(self):
threading.Thread.__init__(self)
self.quit = False
self.ports = settings.ports
self.setup = settings.setup
self.pullsocket = DateDataPullSocket(self.setup + '-socket supervisor',
[str(port) for port in self.ports],
timeouts=len(self.ports)*[5])
self.pullsocket.start()
def run(self):
""" Main loop """
while not self.quit:
for port in self.ports:
time.sleep(1)
sock = socket.socket(socket.AF_INET, socket.SOCK_STREAM)
result = sock.connect_ex(('127.0.0.1', port))
if result == 0:
self.pullsocket.set_point_now(str(port), True)
print(port, True)
else:
self.pullsocket.set_point_now(str(port), False)
print(port, False)
def main():
""" Main function """
code_names = ['pvd309_temp_dca_cell', 'pvd309_temp_mai_cell']
reader = TemperatureReader()
reader.start()
loggers = {}
loggers[code_names[0]] = ValueLogger(reader, channel=1, comp_val = 0.5, comp_type = 'lin')
loggers[code_names[0]].start()
loggers[code_names[1]] = ValueLogger(reader, channel=2, comp_val = 0.5, comp_type = 'lin')
loggers[code_names[1]].start()
datasocket = DateDataPullSocket('pvd_309_temp', code_names, timeouts=[2.0] * 2, port=9001)
datasocket.start()
livesocket = LiveSocket('pvd_309_temperatures', code_names)
livesocket.start()
db_logger = ContinuousDataSaver(continuous_data_table='dateplots_pvd309',
username=credentials.user,
password=credentials.passwd,
measurement_codenames=code_names)
db_logger.start()
time.sleep(5)
while not reader.quit:
time.sleep(0.25)
for name in code_names:
print(reader.ttl)
value = loggers[name].read_value()
datasocket.set_point_now(name, value)
livesocket.set_point_now(name, value)
if loggers[name].read_trigged():
print(name + ': ' + str(value))
db_logger.save_point_now(name, value)
loggers[name].clear_trigged()
class SocketSupervisor(threading.Thread):
""" Supervisor will check that a list of ports are still open """
def __init__(self):
threading.Thread.__init__(self)
self.quit = False
self.ports = settings.ports
self.setup = settings.setup
print self.ports
print len(self.ports)
print[str(port) for port in self.ports]
self.pullsocket = DateDataPullSocket(
self.setup + '-socket supervisor',
[str(port) for port in self.ports],
timeouts=len(self.ports) * [5])
self.pullsocket.start()
def run(self):
""" Main loop """
while not self.quit:
for port in self.ports:
time.sleep(1)
sock = socket.socket(socket.AF_INET, socket.SOCK_STREAM)
result = sock.connect_ex(('127.0.0.1', port))
if result == 0:
self.pullsocket.set_point_now(str(port), True)
print(port, True)
else:
self.pullsocket.set_point_now(str(port), False)
print(port, False)
def main():
""" Main function """
tempreader = TemperatureReader()
tempreader.daemon = True
tempreader.start()
temp_logger = ValueLogger(tempreader, comp_val=1)
temp_logger.start()
db_logger = ContinuousDataSaver(
continuous_data_table='dateplots_chemlab307',
username=credentials.user,
password=credentials.passwd,
measurement_codenames=['chemlab307_muffle_furnace'])
socket = DateDataPullSocket('muffle_furnace',
['chemlab307_muffle_furnace'],
timeouts=[1.0])
socket.start()
livesocket = LiveSocket('muffle_furnace', ['chemlab307_muffle_furnace'])
livesocket.start()
db_logger.start()
time.sleep(5)
while True:
time.sleep(0.25)
value = temp_logger.read_value()
socket.set_point_now('chemlab307_muffle_furnace', value)
livesocket.set_point_now('chemlab307_muffle_furnace', value)
if temp_logger.read_trigged():
print(value)
db_logger.save_point_now('chemlab307_muffle_furnace', value)
temp_logger.clear_trigged()
def main():
""" Main loop """
il800 = intellemetrics_il800.IL800(
"/dev/serial/by-id/" + "usb-Prolific_Technology_Inc." + "_USB-Serial_Controller_D-if00-port0"
)
sqm160 = inficon_sqm160.InficonSQM160("/dev/serial/by-id/usb-1a86_USB2.0-Ser_-if00-port0")
qcm1 = QcmReader(il800)
qcm1.start()
qcm2 = QcmReader(sqm160)
qcm2.start()
time.sleep(2.5)
codenames = [
"pvd309_qcm1_rate",
"pvd309_qcm1_thickness",
"pvd309_qcm1_frequency",
"pvd309_qcm2_rate",
"pvd309_qcm2_thickness",
"pvd309_qcm2_frequency",
]
loggers = {}
loggers[codenames[0]] = ValueLogger(qcm1, comp_val=0.01, comp_type="lin", channel=0)
loggers[codenames[1]] = ValueLogger(qcm1, comp_val=0.1, comp_type="lin", channel=1)
loggers[codenames[2]] = ValueLogger(qcm1, comp_val=1, comp_type="lin", channel=2)
loggers[codenames[3]] = ValueLogger(qcm2, comp_val=0.3, comp_type="lin", channel=0)
loggers[codenames[4]] = ValueLogger(qcm2, comp_val=0.1, comp_type="lin", channel=1)
loggers[codenames[5]] = ValueLogger(qcm2, comp_val=1, comp_type="lin", channel=2)
for name in codenames:
loggers[name].daemon = True
loggers[name].start()
livesocket = LiveSocket("pvd309 qcm logger", codenames)
livesocket.start()
socket = DateDataPullSocket("pvd309 qcm", codenames, timeouts=[1.0] * len(codenames))
socket.start()
db_logger = ContinuousLogger(
table="dateplots_pvd309",
username=credentials.user,
password=credentials.passwd,
measurement_codenames=codenames,
)
db_logger.start()
while qcm1.isAlive() and qcm2.isAlive():
time.sleep(0.25)
for name in codenames:
value = loggers[name].read_value()
livesocket.set_point_now(name, value)
socket.set_point_now(name, value)
if loggers[name].read_trigged():
print(name + ": " + str(value))
db_logger.enqueue_point_now(name, value)
loggers[name].clear_trigged()
def main():
""" Main loop """
mainpump = tp.TurboDriver(adress=1, port=settings.port)
mainpump.start()
tui = tp.CursesTui(mainpump)
tui.daemon = True
tui.start()
reader = tp.TurboReader(mainpump)
reader.daemon = True
reader.start()
time.sleep(10) # Allow reader to make meaningfull moving avarage
codenames = [settings.table_prefix + '_turbo_speed',
settings.table_prefix + '_turbo_power',
settings.table_prefix + '_turbo_current',
settings.table_prefix + '_turbo_temp_motor',
settings.table_prefix + '_turbo_temp_bottom',
settings.table_prefix + '_turbo_temp_bearings',
settings.table_prefix + '_turbo_temp_electronics']
loggers = {}
loggers[codenames[0]] = tp.TurboLogger(reader, 'rotation_speed', maximumtime=600)
loggers[codenames[1]] = tp.TurboLogger(reader, 'drive_power', maximumtime=600)
loggers[codenames[2]] = tp.TurboLogger(reader, 'drive_current', maximumtime=600)
loggers[codenames[3]] = tp.TurboLogger(reader, 'temp_motor', maximumtime=600)
loggers[codenames[4]] = tp.TurboLogger(reader, 'temp_bottom', maximumtime=600)
loggers[codenames[5]] = tp.TurboLogger(reader, 'temp_bearings', maximumtime=600)
loggers[codenames[6]] = tp.TurboLogger(reader, 'temp_electronics', maximumtime=600)
for name in codenames:
loggers[name].daemon = True
loggers[name].start()
livesocket = LiveSocket(settings.name + '-turboreader', codenames)
livesocket.start()
socket = DateDataPullSocket(settings.name + '-turboreader', codenames,
timeouts=[1.0] * len(codenames), port=9000)
socket.start()
db_logger = ContinuousDataSaver(continuous_data_table=settings.table,
username=settings.user,
password=settings.passwd,
measurement_codenames=codenames)
db_logger.start()
time.sleep(5)
while mainpump.running:
time.sleep(0.1)
for name in codenames:
value = loggers[name].read_value()
socket.set_point_now(name, value) # Notice, this is the averaged value
livesocket.set_point_now(name, value) # Notice, this is the averaged value
if loggers[name].trigged:
db_logger.save_point_now(name, value)
loggers[name].trigged = False
class IonOpticsControl(threading.Thread):
""" Main optics control """
def __init__(self, port, name, lenses):
threading.Thread.__init__(self)
name = name + '_ion_optics'
self.pullsocket = DateDataPullSocket(name, lenses, timeouts=20.0)
self.pullsocket.start()
self.pushsocket = DataPushSocket(name, action='enqueue')
self.pushsocket.start()
self.ion_optics = stahl_hv_400.StahlHV400(port)
self.lenses = lenses
self.set_voltages = {}
self.actual_voltages = {}
for lens in self.lenses:
self.set_voltages[lens] = 0
self.actual_voltages[lens] = 0
self.status = {}
self.status['channel_status'] = {}
for i in range(1, len(self.lenses) + 1):
self.status['channel_status'][i] = False
self.status['temperature'] = None
self.status['output_error'] = None
self.quit = False
def run(self):
current_lens = 1
while not self.quit:
self.status['temperature'] = self.ion_optics.read_temperature()
if self.status['temperature'] > 50:
for lens in self.lenses:
self.set_voltages[lens] = 0
self.status[
'channel_status'] = self.ion_optics.check_channel_status()
self.status['output_error'] = False in self.status[
'channel_status']
actual_voltage = self.ion_optics.query_voltage(current_lens)
self.actual_voltages[self.lenses[current_lens -
1]] = actual_voltage
self.pullsocket.set_point_now(self.lenses[current_lens - 1],
actual_voltage)
if current_lens == len(self.lenses):
current_lens = 1
else:
current_lens += 1
qsize = self.pushsocket.queue.qsize()
while qsize > 0:
element = self.pushsocket.queue.get()
lens = str(list(element.keys())[0])
value = element[lens]
self.set_voltages[lens] = value
channel_number = self.lenses.index(lens) + 1
self.ion_optics.set_voltage(channel_number, value)
qsize = self.pushsocket.queue.qsize()
time.sleep(0.1)
def main():
""" Main function """
logging.basicConfig(filename="logger.txt", level=logging.ERROR)
logging.basicConfig(level=logging.ERROR)
l3g4200d_instance = l3g4200d.L3G4200D()
l3g4200d_reader = Reader(l3g4200d_instance)
l3g4200d_reader.start()
ais328dq_instance = ais328dq.AIS328DQTR()
ais328dq_reader = Reader(ais328dq_instance)
ais328dq_reader.start()
time.sleep(2.5)
codenames = [
'b307_049_vibration_measurement', 'b307_049_vibration_measurement_accl'
]
loggers = {}
loggers[codenames[0]] = ValueLogger(l3g4200d_reader,
comp_val=0.02,
maximumtime=600,
comp_type='lin',
channel=0)
loggers[codenames[0]].start()
loggers[codenames[1]] = ValueLogger(ais328dq_reader,
comp_val=0.01,
maximumtime=100,
comp_type='lin',
channel=0)
loggers[codenames[1]].start()
livesocket = LiveSocket('307 Vibraton logger', codenames)
livesocket.start()
socket = DateDataPullSocket('307 vibration logger',
codenames,
timeouts=[1.0] * len(loggers))
socket.start()
db_logger = ContinuousDataSaver(continuous_data_table='dateplots_b307_049',
username=credentials.user,
password=credentials.passwd,
measurement_codenames=codenames)
db_logger.start()
while l3g4200d_reader.isAlive():
time.sleep(10)
for name in codenames:
value = loggers[name].read_value()
print(value)
livesocket.set_point_now(name, value)
socket.set_point_now(name, value)
if loggers[name].read_trigged():
print(name + ': ' + str(value))
db_logger.save_point_now(name, value)
loggers[name].clear_trigged()
class MySocket(threading.Thread):
""" Temperature reader """
def __init__(self):
threading.Thread.__init__(self)
self.sock = socket.socket(socket.AF_INET, socket.SOCK_DGRAM)
self.sock.settimeout(2)
self.quit = False
sockname = 'tabs_all'
self.codenames = socketinfo.INFO[sockname]['codenames']
self.PullSocket = DateDataPullSocket(sockname, self.codenames, timeouts=[60.0]*len(self.codenames), port = socketinfo.INFO[sockname]['port'])
self.PullSocket.start()
self.data = {}
for co in self.codenames:
self.data[co] = None
def run(self,):
i = 0
while not self.quit:
try:
#print(i)
time.sleep(2)
for name in self.codenames:
v = self.loggers[name].read_value()
v = self.data[name]
self.PullSocket.set_point_now(name, v)
except (KeyboardInterrupt, SystemExit):
pass
#self.VC.stop()
#report error and proceed
i += 1
def update_values(self,):
""" Read the temperature from a external socket server"""
for so in ['tabs_temperatures', 'tabs_setpoints', 'tabs_pids', 'tabs_valve', 'tabs_multiplexer']:
try:
info = socketinfo.INFO[so]
host_port = (info['host'], info['port'])
command = 'json_wn'
self.sock.sendto(command, host_port)
data = json.loads(self.sock.recv(2048))
now = time.time()
#print(data)
for key, value in data.items():
try:
if abs(now - value[0]) > 3*60 or value[1] == 'OLD_DATA': # this is 3min change to 5s
self.data[key] = None
else:
self.data[key] = value[1]
except:
self.data[key] = None
except socket.timeout:
pass
return self.data
def stop(self):
self.quit = True
self.PullSocket.stop()
def main():
""" Main function """
logging.basicConfig(filename="logger.txt", level=logging.ERROR)
logging.basicConfig(level=logging.ERROR)
ports = '/dev/serial/by-id/'
ports += 'usb-Prolific_Technology_Inc._USB-Serial_Controller_D-if00-port0'
xgs_instance = xgs600.XGS600Driver(ports)
print(xgs_instance.read_all_pressures())
pressure = PressureReader(xgs_instance)
pressure.start()
time.sleep(2.5)
codenames = ['ps_qms_pressure', 'ps_chamber_pressure']
loggers = {}
loggers[codenames[0]] = ValueLogger(pressure,
comp_val=0.1,
low_comp=1e-11,
comp_type='log',
channel=0)
loggers[codenames[0]].start()
loggers[codenames[1]] = ValueLogger(pressure,
comp_val=0.1,
low_comp=1e-11,
comp_type='log',
channel=1)
loggers[codenames[1]].start()
#livesocket = LiveSocket('PS', codenames, 2)
#livesocket.start()
socket = DateDataPullSocket('PS pressure logger',
codenames,
timeouts=2 * [1.0],
port=9001)
socket.start()
db_logger = ContinuousDataSaver(continuous_data_table='dateplots_ps',
username=credentials.user,
password=credentials.passwd,
measurement_codenames=codenames)
db_logger.start()
while pressure.isAlive():
time.sleep(0.5)
for name in codenames:
value = loggers[name].read_value()
#livesocket.set_point_now(name, value)
socket.set_point_now(name, value)
if loggers[name].read_trigged():
print(value)
db_logger.save_point_now(name, value)
loggers[name].clear_trigged()
class IonOpticsControl(threading.Thread):
""" Main optics control """
def __init__(self, port, name, lenses):
threading.Thread.__init__(self)
name = name + '_ion_optics'
self.pullsocket = DateDataPullSocket(name, lenses, timeouts=20.0)
self.pullsocket.start()
self.pushsocket = DataPushSocket(name, action='enqueue')
self.pushsocket.start()
self.ion_optics = stahl_hv_400.StahlHV400(port)
self.lenses = lenses
self.set_voltages = {}
self.actual_voltages = {}
for lens in self.lenses:
self.set_voltages[lens] = 0
self.actual_voltages[lens] = 0
self.status = {}
self.status['channel_status'] = {}
for i in range(1, len(self.lenses)+1):
self.status['channel_status'][i] = False
self.status['temperature'] = None
self.status['output_error'] = None
self.quit = False
def run(self):
current_lens = 1
while not self.quit:
self.status['temperature'] = self.ion_optics.read_temperature()
if self.status['temperature'] > 50:
for lens in self.lenses:
self.set_voltages[lens] = 0
self.status['channel_status'] = self.ion_optics.check_channel_status()
self.status['output_error'] = False in self.status['channel_status']
actual_voltage = self.ion_optics.query_voltage(current_lens)
self.actual_voltages[self.lenses[current_lens-1]] = actual_voltage
self.pullsocket.set_point_now(self.lenses[current_lens-1], actual_voltage)
if current_lens == len(self.lenses):
current_lens = 1
else:
current_lens += 1
qsize = self.pushsocket.queue.qsize()
while qsize > 0:
element = self.pushsocket.queue.get()
lens = str(list(element.keys())[0])
value = element[lens]
self.set_voltages[lens] = value
channel_number = self.lenses.index(lens) + 1
self.ion_optics.set_voltage(channel_number, value)
qsize = self.pushsocket.queue.qsize()
time.sleep(0.1)
def main():
""" Main function """
logging.basicConfig(filename="logger.txt", level=logging.ERROR)
logging.basicConfig(level=logging.ERROR)
port = 'serial/by-id/usb-1a86_USB2.0-Ser_-if00-port0'
xgs = xgs600.XGS600Driver('/dev/' + port)
print(xgs.read_all_pressures())
reader = PressureReader(xgs)
reader.daemon = True
reader.start()
buffer_logger = ValueLogger(reader, comp_val=0.1, comp_type='log',
channel=0, low_comp=1e-3)
containment_logger = ValueLogger(reader, comp_val=0.1, comp_type='log',
channel=1, low_comp=1e-3)
buffer_logger.start()
containment_logger.start()
socket = DateDataPullSocket('mgw',
['containment_pressure', 'buffer_pressure'],
timeouts=[1.0, 1.0])
socket.start()
livesocket = LiveSocket('mgw', ['containment_pressure', 'buffer_pressure'])
livesocket.start()
codenames = ['mgw_pressure_containment', 'mgw_pressure_buffer']
db_logger = ContinuousDataSaver(continuous_data_table='dateplots_mgw',
username=credentials.user,
password=credentials.passwd,
measurement_codenames=codenames)
db_logger.start()
time.sleep(5)
while reader.isAlive():
time.sleep(0.2)
p_containment = containment_logger.read_value()
p_buffer = buffer_logger.read_value()
socket.set_point_now('containment_pressure', p_containment)
socket.set_point_now('buffer_pressure', p_buffer)
livesocket.set_point_now('containment_pressure', p_containment)
livesocket.set_point_now('buffer_pressure', p_buffer)
if containment_logger.read_trigged():
print(p_containment)
db_logger.save_point_now('mgw_pressure_containment', p_containment)
containment_logger.clear_trigged()
if buffer_logger.read_trigged():
print(p_buffer)
db_logger.save_point_now('mgw_pressure_buffer', p_buffer)
buffer_logger.clear_trigged()
def main():
""" Main function """
i2c_helper = ABEHelpers()
bus = i2c_helper.get_smbus()
adc_instance = ADCPi(bus, 0x68, 0x69, 18)
windreader = WindReader(adc_instance)
windreader.daemon = True
windreader.start()
loggers = {}
for channel, codename in settings.channels.items():
loggers[codename + '_raw'] = ValueLogger(windreader,
comp_val=1.05,
channel=channel + '_raw',
maximumtime=30)
loggers[codename + '_raw'].start()
loggers[codename] = ValueLogger(windreader,
comp_val=1.005,
channel=channel,
maximumtime=30)
loggers[codename].start()
codenames = []
for name in settings.channels.values():
codenames.append(name)
codenames.append(name + '_raw')
socket = DateDataPullSocket('Fumehood Wind Speed', codenames, timeouts=2.0)
socket.start()
live_socket = LiveSocket('Fumehood Wind Speed', codenames)
live_socket.start()
db_logger = ContinuousDataSaver(
continuous_data_table=settings.dateplot_table,
username=credentials.user,
password=credentials.passwd,
measurement_codenames=codenames)
db_logger.start()
time.sleep(10)
while windreader.is_alive():
time.sleep(0.25)
for name in codenames:
value = loggers[name].read_value()
socket.set_point_now(name, value)
live_socket.set_point_now(name, value)
if loggers[name].read_trigged():
print(name + ': ' + str(value))
db_logger.save_point_now(name, value)
loggers[name].clear_trigged()
def main():
""" Main function """
logging.basicConfig(filename="logger.txt", level=logging.ERROR)
logging.basicConfig(level=logging.ERROR)
port = 'serial/by-id/usb-1a86_USB2.0-Ser_-if00-port0'
xgs = xgs600.XGS600Driver('/dev/' + port)
print(xgs.read_all_pressures())
reader = PressureReader(xgs)
reader.daemon = True
reader.start()
buffer_logger = ValueLogger(reader, comp_val=0.1, comp_type='log',
channel=0, low_comp=1e-3)
containment_logger = ValueLogger(reader, comp_val=0.1, comp_type='log',
channel=1, low_comp=1e-3)
buffer_logger.start()
containment_logger.start()
socket = DateDataPullSocket('mgw',
['containment_pressure', 'buffer_pressure'],
timeouts=[1.0, 1.0])
socket.start()
livesocket = LiveSocket('mgw', ['containment_pressure', 'buffer_pressure'])
livesocket.start()
codenames = ['mgw_pressure_containment', 'mgw_pressure_buffer']
db_logger = ContinuousDataSaver(continuous_data_table='dateplots_mgw',
username=credentials.user,
password=credentials.passwd,
measurement_codenames=codenames)
db_logger.start()
time.sleep(5)
while reader.isAlive():
time.sleep(0.2)
p_containment = containment_logger.read_value()
p_buffer = buffer_logger.read_value()
socket.set_point_now('containment_pressure', p_containment)
socket.set_point_now('buffer_pressure', p_buffer)
livesocket.set_point_now('containment_pressure', p_containment)
livesocket.set_point_now('buffer_pressure', p_buffer)
if containment_logger.read_trigged():
print(p_containment)
db_logger.save_point_now('mgw_pressure_containment', p_containment)
containment_logger.clear_trigged()
if buffer_logger.read_trigged():
print(p_buffer)
db_logger.save_point_now('mgw_pressure_buffer', p_buffer)
buffer_logger.clear_trigged()
class TemperatureLogger(object):
def __init__(self):
# Initialize omega driver
LOGGER.info('Initialize omega d6400 driver')
d6400_id = '/dev/serial/by-id/usb-FTDI_USB-RS485_Cable_FTWGRP0B-if00'\
'-port0'
self.d6400 = D6400.OmegaD6400(1, d6400_id)
for channel in range(1, 8):
LOGGER.info('Set range for channel {}'.format(channel))
self.d6400.update_range_and_function(channel, action='tc',
fullrange='K')
# Initialize socket
name = 'Coupled reactor temperatures'
self.codenames = {
1: 'R1_temp',
2: 'R1_sample_temp',
3: 'R2_temp',
4: 'R2_sample_temp',
5: 'pro_inlet_temp',
6: 'pro_d1_temp',
7: 'pro_d2_temp',
}
codenames_list = [self.codenames[channel] for channel in range(1, 8)]
self.socket = DateDataPullSocket(name, codenames_list, timeouts = 2.0)
self.socket.start()
# Measure initial values
self.temperatures = {}
for channel in range(1, 8):
self.temperatures[channel] = self.d6400.read_value(channel)
LOGGER.info('Get initial value {} for channel: {}'.format(
self.temperatures[channel], channel))
self.socket.set_point_now(self.codenames[channel],
self.temperatures[channel])
def main(self):
"""Main meaurement loop"""
while True:
for channel in range(1, 8):
self.temperatures[channel] = self.d6400.read_value(channel)
LOGGER.info('Measured value {} for channel: {}'.format(
self.temperatures[channel], channel))
self.socket.set_point_now(self.codenames[channel],
self.temperatures[channel])
def close(self):
"""Shut down the socket"""
self.socket.stop()
time.sleep(2)
def main():
""" Main code """
mux_instance = agilent_34972A.Agilent34972ADriver(
interface='lan', hostname='volvo-agilent-34972a')
port = '/dev/serial/by-id/usb-Prolific_Technology_Inc._USB-Serial_Controller-if00-port0'
xgs_instance = xgs600.XGS600Driver(port)
analog_measurement = MuxReader(mux_instance)
analog_measurement.start()
pressure = PressureReader(xgs_instance)
print('-')
pressure.start()
time.sleep(2.5)
codenames = ['volvo_pressure', 'volvo_temperature']
loggers = {}
loggers[codenames[0]] = ValueLogger(pressure,
comp_val=0.1,
comp_type='log')
loggers[codenames[0]].start()
loggers[codenames[1]] = ValueLogger(analog_measurement,
comp_val=0.5,
comp_type='lin')
loggers[codenames[1]].start()
socket = DateDataPullSocket('Volvo data logger',
codenames,
timeouts=[1.0, 1.0])
socket.start()
livesocket = LiveSocket('Volvo data logger', codenames)
livesocket.start()
db_logger = ContinuousDataSaver(continuous_data_table='dateplots_volvo',
username=credentials.user,
password=credentials.passwd,
measurement_codenames=codenames)
db_logger.start()
#while pressure.isAlive() and analog_measurement.isAlive():
while True:
time.sleep(0.25)
for name in codenames:
value = loggers[name].read_value()
socket.set_point_now(name, value)
livesocket.set_point_now(name, value)
if loggers[name].read_trigged():
print(value)
db_logger.save_point_now(name, value)
loggers[name].clear_trigged()
class TemperatureLogger(object):
def __init__(self):
# Initialize omega driver
LOGGER.info('Initialize omega d6400 driver')
d6400_id = '/dev/serial/by-id/usb-FTDI_USB-RS485_Cable_FTWGRP0B-if00'\
'-port0'
self.d6400 = D6400.OmegaD6400(1, d6400_id)
for channel in range(1, 8):
LOGGER.info('Set range for channel {}'.format(channel))
self.d6400.update_range_and_function(channel,
action='tc',
fullrange='K')
# Initialize socket
name = 'Coupled reactor temperatures'
self.codenames = {
1: 'R1_temp',
2: 'R1_sample_temp',
3: 'R2_temp',
4: 'R2_sample_temp',
5: 'pro_inlet_temp',
6: 'pro_d1_temp',
7: 'pro_d2_temp',
}
codenames_list = [self.codenames[channel] for channel in range(1, 8)]
self.socket = DateDataPullSocket(name, codenames_list, timeouts=2.0)
self.socket.start()
# Measure initial values
self.temperatures = {}
for channel in range(1, 8):
self.temperatures[channel] = self.d6400.read_value(channel)
LOGGER.info('Get initial value {} for channel: {}'.format(
self.temperatures[channel], channel))
self.socket.set_point_now(self.codenames[channel],
self.temperatures[channel])
def main(self):
"""Main meaurement loop"""
while True:
for channel in range(1, 8):
self.temperatures[channel] = self.d6400.read_value(channel)
LOGGER.info('Measured value {} for channel: {}'.format(
self.temperatures[channel], channel))
self.socket.set_point_now(self.codenames[channel],
self.temperatures[channel])
def close(self):
"""Shut down the socket"""
self.socket.stop()
time.sleep(2)
def main():
""" Main function """
ups = galaxy_3500.Galaxy3500('b312-ups')
reader = UpsReader(ups)
reader.daemon = True
reader.start()
time.sleep(5)
codenames = [
'b312_ups_temperature', 'b312_ups_kVAPh1', 'b312_ups_kVAPh2',
'b312_ups_kVAPh3', 'b312_ups_output_current_Ph1',
'b312_ups_output_current_Ph2', 'b312_ups_output_current_Ph3',
'b312_ups_input_frequency', 'b312_ups_input_voltage_Ph1',
'b312_ups_input_voltage_Ph2', 'b312_ups_input_voltage_Ph3',
'b312_ups_output_voltage_Ph1', 'b312_ups_output_voltage_Ph2',
'b312_ups_output_voltage_Ph3', 'b312_ups_battery_voltage',
'b312_ups_battery_current', 'b312_ups_battery_state_of_charge',
'b312_ups_output_frequency'
]
loggers = {}
for i in range(0, len(codenames)):
loggers[codenames[i]] = ValueLogger(reader, comp_val=0.1, channel=i)
loggers[codenames[i]].start()
socket = DateDataPullSocket('UPS status',
codenames,
timeouts=[5.0] * len(codenames))
socket.start()
live_socket = LiveSocket('UPS Status', codenames)
live_socket.start()
db_logger = ContinuousDataSaver(continuous_data_table='dateplots_ups_b312',
username=credentials.user,
password=credentials.passwd,
measurement_codenames=codenames)
db_logger.start()
time.sleep(5)
while reader.isAlive():
time.sleep(0.25)
for name in codenames:
value = loggers[name].read_value()
socket.set_point_now(name, value)
live_socket.set_point_now(name, value)
if loggers[name].read_trigged():
print(value)
db_logger.save_point_now(name, value)
loggers[name].clear_trigged()
def main():
""" Main function """
logging.basicConfig(filename="logger.txt", level=logging.ERROR)
logging.basicConfig(level=logging.ERROR)
hih_instance = honeywell_6000.HIH6130()
reader = Reader(hih_instance)
reader.start()
print('wait start 20s')
time.sleep(25)
print('Wait end')
codenames = ['home_temperature_bedroom', 'home_humidity_bedroom']
loggers = {}
loggers[codenames[0]] = ValueLogger(reader,
comp_val=0.25,
comp_type='lin',
channel=1)
loggers[codenames[0]].start()
loggers[codenames[1]] = ValueLogger(reader,
comp_val=1.1,
comp_type='lin',
channel=2)
loggers[codenames[1]].start()
#livesocket = LiveSocket('Home Air Logger', codenames)
#livesocket.start()
socket = DateDataPullSocket('Home Air Logger',
codenames,
timeouts=[1.0] * len(loggers))
socket.start()
table = 'dateplots_rued_langgaards_vej'
db_logger = ContinuousDataSaver(continuous_data_table=table,
username=credentials.user,
password=credentials.passwd,
measurement_codenames=codenames)
db_logger.start()
while reader.isAlive():
time.sleep(1)
for name in codenames:
value = loggers[name].read_value()
#livesocket.set_point_now(name, value)
socket.set_point_now(name, value)
if loggers[name].read_trigged():
print(value)
db_logger.save_point_now(name, value)
loggers[name].clear_trigged()
def main():
""" Main function """
logging.basicConfig(filename="logger.txt", level=logging.ERROR)
logging.basicConfig(level=logging.ERROR)
hih_instance = honeywell_6000.HIH6130()
reader = Reader(hih_instance)
reader.start()
time.sleep(5)
codenames = ['chemlab312_temperature', 'chemlab312_humidity']
loggers = {}
loggers[codenames[0]] = ValueLogger(reader,
comp_val=1,
comp_type='lin',
channel=1)
loggers[codenames[0]].start()
loggers[codenames[1]] = ValueLogger(reader,
comp_val=1,
comp_type='lin',
channel=2)
loggers[codenames[1]].start()
livesocket = LiveSocket('Chemlab312 Air Logger', codenames, 2)
livesocket.start()
socket = DateDataPullSocket('Chemlab312 Air Logger',
codenames,
timeouts=[1.0] * len(loggers))
socket.start()
db_logger = ContinuousDataSaver(
continuous_data_table='dateplots_chemlab312',
username=credentials.user,
password=credentials.passwd,
measurement_codenames=codenames)
db_logger.start()
while reader.isAlive():
time.sleep(1)
for name in codenames:
value = loggers[name].read_value()
livesocket.set_point_now(name, value)
socket.set_point_now(name, value)
if loggers[name].read_trigged():
print(value)
db_logger.save_point_now(name, value)
loggers[name].clear_trigged()
def main():
""" Main function """
logging.basicConfig(filename="logger.txt", level=logging.ERROR)
logging.basicConfig(level=logging.ERROR)
port = 'usb-FTDI_USB-RS232_Cable_FTV9UVIO-if00-port0'
omega = omegabus.OmegaBus(device='/dev/serial/by-id/' + port, model='D5251', baud=300)
hih_instance = honeywell_6000.HIH6130()
reader = Reader(omega, hih_instance)
reader.start()
time.sleep(2.5)
codenames = ['b307_049_h2_pressure', 'b307_049_temperature', 'b307_049_humidity']
loggers = {}
loggers[codenames[0]] = ValueLogger(reader, comp_val=0.1, maximumtime=600,
comp_type='lin', channel=0)
loggers[codenames[0]].start()
loggers[codenames[1]] = ValueLogger(reader, comp_val=0.2, maximumtime=600,
comp_type='lin', channel=1)
loggers[codenames[1]].start()
loggers[codenames[2]] = ValueLogger(reader, comp_val=0.5, maximumtime=600,
comp_type='lin', channel=2)
loggers[codenames[2]].start()
livesocket = LiveSocket('307_049 Logger', codenames)
livesocket.start()
socket = DateDataPullSocket('307_049 logger', codenames,
timeouts=[1.0] * len(loggers))
socket.start()
db_logger = ContinuousDataSaver(continuous_data_table='dateplots_b307_049',
username=credentials.user,
password=credentials.passwd,
measurement_codenames=codenames)
db_logger.start()
while reader.isAlive():
time.sleep(1)
for name in codenames:
value = loggers[name].read_value()
livesocket.set_point_now(name, value)
socket.set_point_now(name, value)
if loggers[name].read_trigged():
print(name + ': ' + str(value))
db_logger.save_point_now(name, value)
loggers[name].clear_trigged()
def main():
""" Main function """
logging.basicConfig(filename="logger.txt", level=logging.ERROR)
logging.basicConfig(level=logging.ERROR)
qcm_port = (
'/dev/serial/by-id/' +
'usb-Prolific_Technology_Inc._USB-Serial_Controller-if00-port0')
qcm = inficon.InficonSQM160(qcm_port)
reader = QcmReader(qcm)
reader.daemon = True
reader.start()
codenames = [
'volvo_qcm_frequency', 'volvo_qcm_crystal_life', 'volvo_qcm_thickness'
]
loggers = {}
loggers[codenames[0]] = ValueLogger(reader, comp_val=0.1, channel=0)
loggers[codenames[0]].start()
loggers[codenames[1]] = ValueLogger(reader, comp_val=0.01, channel=1)
loggers[codenames[1]].start()
loggers[codenames[2]] = ValueLogger(reader, comp_val=0.001, channel=2)
loggers[codenames[2]].start()
socket = DateDataPullSocket('Volvo QCM',
codenames,
port=9000,
timeouts=[5.0] * len(codenames))
socket.start()
livesocket = LiveSocket('Volvo data logger', codenames)
livesocket.start()
db_logger = ContinuousDataSaver(continuous_data_table='dateplots_volvo',
username=credentials.user,
password=credentials.passwd,
measurement_codenames=codenames)
db_logger.start()
time.sleep(5)
while reader.isAlive():
time.sleep(0.25)
for name in codenames:
value = loggers[name].read_value()
socket.set_point_now(name, value)
livesocket.set_point_now(name, value)
if loggers[name].read_trigged():
print(value)
db_logger.save_point_now(name, value)
loggers[name].clear_trigged()
def main():
""" Main function """
logging.basicConfig(filename="logger.txt", level=logging.ERROR)
logging.basicConfig(level=logging.ERROR)
l3g4200d_instance = l3g4200d.L3G4200D()
l3g4200d_reader = Reader(l3g4200d_instance)
l3g4200d_reader.start()
ais328dq_instance = ais328dq.AIS328DQTR()
ais328dq_reader = Reader(ais328dq_instance)
ais328dq_reader.start()
time.sleep(2.5)
codenames = ['b307_049_vibration_measurement', 'b307_049_vibration_measurement_accl']
loggers = {}
loggers[codenames[0]] = ValueLogger(l3g4200d_reader, comp_val=0.02, maximumtime=600,
comp_type='lin', channel=0)
loggers[codenames[0]].start()
loggers[codenames[1]] = ValueLogger(ais328dq_reader, comp_val=0.01, maximumtime=100,
comp_type='lin', channel=0)
loggers[codenames[1]].start()
livesocket = LiveSocket('307 Vibraton logger', codenames)
livesocket.start()
socket = DateDataPullSocket('307 vibration logger', codenames,
timeouts=[1.0] * len(loggers))
socket.start()
db_logger = ContinuousDataSaver(continuous_data_table='dateplots_b307_049',
username=credentials.user,
password=credentials.passwd,
measurement_codenames=codenames)
db_logger.start()
while l3g4200d_reader.isAlive():
time.sleep(10)
for name in codenames:
value = loggers[name].read_value()
print(value)
livesocket.set_point_now(name, value)
socket.set_point_now(name, value)
if loggers[name].read_trigged():
print(name + ': ' + str(value))
db_logger.save_point_now(name, value)
loggers[name].clear_trigged()
def main():
""" Main function """
logging.basicConfig(filename="logger.txt", level=logging.ERROR)
logging.basicConfig(level=logging.ERROR)
port = 'usb-FTDI_USB-RS232_Cable_FTWZKOU0-if00-port0'
omega = omegabus.OmegaBus(device='/dev/serial/by-id/' + port,
model='D5251',
baud=300)
reader = Reader(omega)
reader.start()
time.sleep(2.5)
codenames = ['propene_ox_setup_abs_pressure']
loggers = {}
loggers[codenames[0]] = ValueLogger(reader,
comp_val=5,
maximumtime=300,
comp_type='lin')
loggers[codenames[0]].start()
livesocket = LiveSocket('propene_ox Logger', codenames)
livesocket.start()
socket = DateDataPullSocket('propene_ox logger',
codenames,
timeouts=[3.0] * len(loggers))
socket.start()
db_logger = ContinuousDataSaver(
continuous_data_table='dateplots_propene_ox',
username=credentials.user,
password=credentials.passwd,
measurement_codenames=codenames)
db_logger.start()
while reader.isAlive():
time.sleep(1)
for name in codenames:
value = loggers[name].read_value()
livesocket.set_point_now(name, value)
socket.set_point_now(name, value)
if loggers[name].read_trigged():
print(name + ': ' + str(value))
db_logger.save_point_now(name, value)
loggers[name].clear_trigged()
def main():
""" Main function """
logging.basicConfig(filename="logger.txt", level=logging.ERROR)
logging.basicConfig(level=logging.ERROR)
omron_instance = omron_d6fph.OmronD6fph()
hih_instance = honeywell_6000.HIH6130()
reader = Reader(omron_instance, hih_instance)
reader.start()
time.sleep(5)
codenames = ['hall_ventilation_pressure', 'hall_temperature', 'hall_humidity']
loggers = {}
loggers[codenames[0]] = ValueLogger(reader, comp_val=1.0, maximumtime=300,
comp_type='lin', channel=0)
loggers[codenames[0]].start()
loggers[codenames[1]] = ValueLogger(reader, comp_val=0.2, maximumtime=600,
comp_type='lin', channel=1)
loggers[codenames[1]].start()
loggers[codenames[2]] = ValueLogger(reader, comp_val=0.2, maximumtime=600,
comp_type='lin', channel=2)
loggers[codenames[2]].start()
livesocket = LiveSocket('Hall Ventilation Logger', codenames)
livesocket.start()
socket = DateDataPullSocket('Hall Ventilation logger', codenames,
timeouts=[1.0] * len(loggers))
socket.start()
db_logger = ContinuousDataSaver(continuous_data_table='dateplots_hall',
username=credentials.user,
password=credentials.passwd,
measurement_codenames=codenames)
db_logger.start()
while reader.isAlive():
time.sleep(1)
for name in codenames:
value = loggers[name].read_value()
livesocket.set_point_now(name, value)
socket.set_point_now(name, value)
if loggers[name].read_trigged():
print(name + ': ' + str(value))
db_logger.save_point_now(name, value)
loggers[name].clear_trigged()
def main():
""" Main function """
logging.basicConfig(filename="logger.txt", level=logging.ERROR)
logging.basicConfig(level=logging.ERROR)
ports = '/dev/serial/by-id/'
ports += 'usb-Prolific_Technology_Inc._USB-Serial_Controller_D-if00-port0'
xgs_instance = xgs600.XGS600Driver(ports)
print(xgs_instance.read_all_pressures())
pressure = PressureReader(xgs_instance)
pressure.start()
time.sleep(2.5)
codenames = ['ps_qms_pressure', 'ps_chamber_pressure']
loggers = {}
loggers[codenames[0]] = ValueLogger(pressure, comp_val=0.1, low_comp=1e-11,
comp_type='log', channel=0)
loggers[codenames[0]].start()
loggers[codenames[1]] = ValueLogger(pressure, comp_val=0.1, low_comp=1e-11,
comp_type='log', channel=1)
loggers[codenames[1]].start()
#livesocket = LiveSocket('PS', codenames, 2)
#livesocket.start()
socket = DateDataPullSocket('PS pressure logger',
codenames, timeouts=2 * [1.0], port=9001)
socket.start()
db_logger = ContinuousDataSaver(continuous_data_table='dateplots_ps',
username=credentials.user,
password=credentials.passwd,
measurement_codenames=codenames)
db_logger.start()
while pressure.isAlive():
time.sleep(0.5)
for name in codenames:
value = loggers[name].read_value()
#livesocket.set_point_now(name, value)
socket.set_point_now(name, value)
if loggers[name].read_trigged():
print(value)
db_logger.save_point_now(name, value)
loggers[name].clear_trigged()
def main():
""" Main function """
ups = galaxy_3500.Galaxy3500('b312-ups')
reader = UpsReader(ups)
reader.daemon = True
reader.start()
time.sleep(5)
codenames = ['b312_ups_temperature', 'b312_ups_kVAPh1', 'b312_ups_kVAPh2',
'b312_ups_kVAPh3', 'b312_ups_output_current_Ph1',
'b312_ups_output_current_Ph2', 'b312_ups_output_current_Ph3',
'b312_ups_input_frequency', 'b312_ups_input_voltage_Ph1',
'b312_ups_input_voltage_Ph2', 'b312_ups_input_voltage_Ph3',
'b312_ups_output_voltage_Ph1', 'b312_ups_output_voltage_Ph2',
'b312_ups_output_voltage_Ph3', 'b312_ups_battery_voltage',
'b312_ups_battery_current', 'b312_ups_battery_state_of_charge',
'b312_ups_output_frequency']
loggers = {}
for i in range(0, len(codenames)):
loggers[codenames[i]] = ValueLogger(reader, comp_val=0.1, channel=i)
loggers[codenames[i]].start()
socket = DateDataPullSocket('UPS status', codenames,
timeouts=[5.0] * len(codenames))
socket.start()
live_socket = LiveSocket('UPS Status', codenames)
live_socket.start()
db_logger = ContinuousDataSaver(continuous_data_table='dateplots_ups_b312',
username=credentials.user,
password=credentials.passwd,
measurement_codenames=codenames)
db_logger.start()
time.sleep(5)
while reader.isAlive():
time.sleep(0.25)
for name in codenames:
value = loggers[name].read_value()
socket.set_point_now(name, value)
live_socket.set_point_now(name, value)
if loggers[name].read_trigged():
print(value)
db_logger.save_point_now(name, value)
loggers[name].clear_trigged()
def main():
""" Main function """
logging.basicConfig(filename="logger.txt", level=logging.ERROR)
logging.basicConfig(level=logging.ERROR)
qcm_port = ('/dev/serial/by-id/' +
'usb-Prolific_Technology_Inc._USB-Serial_Controller-if00-port0')
qcm = inficon.InficonSQM160(qcm_port)
reader = QcmReader(qcm)
reader.daemon = True
reader.start()
codenames = ['volvo_qcm_frequency',
'volvo_qcm_crystal_life',
'volvo_qcm_thickness']
loggers = {}
loggers[codenames[0]] = ValueLogger(reader, comp_val=0.1, channel=0)
loggers[codenames[0]].start()
loggers[codenames[1]] = ValueLogger(reader, comp_val=0.01, channel=1)
loggers[codenames[1]].start()
loggers[codenames[2]] = ValueLogger(reader, comp_val=0.001, channel=2)
loggers[codenames[2]].start()
socket = DateDataPullSocket('Volvo QCM', codenames, port=9000,
timeouts=[5.0] * len(codenames))
socket.start()
livesocket = LiveSocket('Volvo data logger', codenames)
livesocket.start()
db_logger = ContinuousDataSaver(continuous_data_table='dateplots_volvo',
username=credentials.user,
password=credentials.passwd,
measurement_codenames=codenames)
db_logger.start()
time.sleep(5)
while reader.isAlive():
time.sleep(0.25)
for name in codenames:
value = loggers[name].read_value()
socket.set_point_now(name, value)
livesocket.set_point_now(name, value)
if loggers[name].read_trigged():
print(value)
db_logger.save_point_now(name, value)
loggers[name].clear_trigged()
def main():
""" Main function """
logging.basicConfig(filename="logger.txt", level=logging.ERROR)
logging.basicConfig(level=logging.ERROR)
i2c_helper = ABEHelpers()
bus = i2c_helper.get_smbus()
adc_instance = ADCPi(bus, 0x68, 0x69, 18)
pressurereader = PressureReader(adc_instance)
pressurereader.daemon = True
pressurereader.start()
codenames = ['chemlab312_sample_storage_pressure']
loggers = {}
for i in range(0, 1):
loggers[codenames[i]] = ValueLogger(pressurereader,
comp_val=0.05,
comp_type='log')
loggers[codenames[i]].start()
socket = DateDataPullSocket('chemlab312_sample_storage',
codenames,
timeouts=[2.0])
socket.start()
live_socket = LiveSocket('chemlab312_sample_storage', codenames)
live_socket.start()
db_logger = ContinuousDataSaver(
continuous_data_table='dateplots_chemlab312',
username=credentials.user,
password=credentials.passwd,
measurement_codenames=codenames)
db_logger.start()
time.sleep(5)
while True:
time.sleep(0.5)
for name in codenames:
value = loggers[name].read_value()
socket.set_point_now(name, value)
live_socket.set_point_now(name, value)
if loggers[name].read_trigged():
print(value)
db_logger.save_point_now(name, value)
loggers[name].clear_trigged()
def main():
""" Main function """
logging.basicConfig(filename="logger.txt", level=logging.ERROR)
logging.basicConfig(level=logging.ERROR)
codenames = ['fr307_furnace_1_T', 'fr307_furnace_2_T']
datasocket = DateDataPullSocket('furnaceroom_reader',
codenames,
timeouts=[3.0, 3.0],
port=9001)
datasocket.start()
db_logger = ContinuousDataSaver(
continuous_data_table='dateplots_furnaceroom307',
username=credentials.user,
password=credentials.passwd,
measurement_codenames=codenames)
db_logger.start()
ports = {}
ports['fr307_furnace_1_T'] = 'usb-FTDI_USB-RS485_Cable_FTYIZLJV-if00-port0'
ports['fr307_furnace_2_T'] = 'usb-FTDI_USB-RS485_Cable_FTYJ1V33-if00-port0'
loggers = {}
temperature_readers = {}
for logger_name in codenames:
temperature_readers[logger_name] = TemperatureReader(
ports[logger_name])
temperature_readers[logger_name].daemon = True
temperature_readers[logger_name].start()
loggers[logger_name] = ValueLogger(temperature_readers[logger_name],
comp_val=0.09)
loggers[logger_name].start()
time.sleep(5)
values = {}
while True:
time.sleep(1)
for logger_name in codenames:
values[logger_name] = loggers[logger_name].read_value()
datasocket.set_point_now(logger_name, values[logger_name])
if loggers[logger_name].read_trigged():
print(logger_name + ': ' + str(values[logger_name]))
db_logger.save_point_now(logger_name, values[logger_name])
loggers[logger_name].clear_trigged()
def main():
""" Main code """
#mux_instance = agilent_34972A.Agilent34972ADriver(interface='lan', hostname='volvo-agilent-34972a')
port = '/dev/serial/by-id/usb-Prolific_Technology_Inc._USB-Serial_Controller-if00-port0'
xgs_instance = xgs600.XGS600Driver(port)
#analog_measurement = MuxReader(mux_instance)
#analog_measurement.start()
pressure = PressureReader(xgs_instance)
print('-')
pressure.start()
time.sleep(2.5)
#codenames = ['volvo_pressure', 'volvo_temperature']
codenames = ['volvo_pressure']
loggers = {}
loggers[codenames[0]] = ValueLogger(pressure, comp_val=0.1, comp_type='log', low_comp=1e-9)
loggers[codenames[0]].start()
#loggers[codenames[1]] = ValueLogger(analog_measurement, comp_val=0.5, comp_type='lin')
#loggers[codenames[1]].start()
socket = DateDataPullSocket('Volvo data logger', codenames, timeouts=1.0)
socket.start()
livesocket = LiveSocket('Volvo data logger', codenames)
livesocket.start()
db_logger = ContinuousDataSaver(continuous_data_table='dateplots_volvo',
username=credentials.user,
password=credentials.passwd,
measurement_codenames=codenames)
db_logger.start()
#while pressure.isAlive() and analog_measurement.isAlive():
while True:
time.sleep(0.25)
for name in codenames:
value = loggers[name].read_value()
socket.set_point_now(name, value)
livesocket.set_point_now(name, value)
if loggers[name].read_trigged():
print(value)
db_logger.save_point_now(name, value)
loggers[name].clear_trigged()
def main():
""" Main function """
logging.basicConfig(filename="logger.txt", level=logging.ERROR)
logging.basicConfig(level=logging.ERROR)
i2c_helper = ABEHelpers()
bus = i2c_helper.get_smbus()
adc_instance = DeltaSigma(bus, 0x68, 0x69, 18)
tempreader = TemperatureReader(adc_instance)
tempreader.daemon = True
tempreader.start()
codenames = ['cooling_water_hot', 'cooling_water_cold']
loggers = {}
for i in range(0, 2):
loggers[codenames[i]] = ValueLogger(tempreader,
comp_val=0.5,
channel=i)
loggers[codenames[i]].start()
socket = DateDataPullSocket('hall_cooling_water_temp',
codenames,
timeouts=2.0)
socket.start()
live_socket = LiveSocket('hall_waterpressure', codenames)
live_socket.start()
db_logger = ContinuousDataSaver(continuous_data_table='dateplots_hall',
username=credentials.user,
password=credentials.passwd,
measurement_codenames=codenames)
db_logger.start()
time.sleep(5)
while tempreader.is_alive():
time.sleep(0.25)
for name in codenames:
value = loggers[name].read_value()
socket.set_point_now(name, value)
live_socket.set_point_now(name, value)
if loggers[name].read_trigged():
print(value)
db_logger.save_point_now(name, value)
loggers[name].clear_trigged()
def main():
""" Main function """
codenames = []
for channel in settings.channels.values():
channel['reader'] = SocketReaderClass(channel['host'], channel['port'],
channel['command'])
channel['reader'].start()
channel['logger'] = ValueLogger(channel['reader'], comp_val=channel['comp_value'])
channel['logger'].daemon = True
channel['logger'].start()
codenames.append(channel['codename'])
try:
port = settings.port_number
except AttributeError:
port = 9000
pullsocket = DateDataPullSocket(settings.user + '-socket_logger',
codenames, timeouts=5, port=port)
pullsocket.start()
db_logger = ContinuousDataSaver(continuous_data_table=settings.dateplot_table,
username=settings.user,
password=settings.passwd,
measurement_codenames=codenames)
db_logger.start()
time.sleep(2)
everything_ok = True
while everything_ok:
time.sleep(0.25)
for channel in settings.channels.values():
if not channel['reader'].isAlive():
everything_ok = False
# Report error here!!!
# Consider to keep program running even in case of
# socket failures
value = channel['logger'].read_value()
pullsocket.set_point_now(channel['codename'], value)
if channel['logger'].read_trigged():
print(value)
db_logger.save_point_now(channel['codename'], value)
channel['logger'].clear_trigged()
def main():
""" Main function """
logging.basicConfig(filename="logger.txt", level=logging.ERROR)
logging.basicConfig(level=logging.ERROR)
hih_instance = honeywell_6000.HIH6130()
reader = Reader(hih_instance)
reader.daemon = True
reader.start()
time.sleep(5)
codenames = ['chemlab312_temperature', 'chemlab312_humidity']
loggers = {}
loggers[codenames[0]] = ValueLogger(reader, comp_val=0.2, comp_type='lin', channel=1)
loggers[codenames[0]].daemon = True
loggers[codenames[0]].start()
loggers[codenames[1]] = ValueLogger(reader, comp_val=0.2, comp_type='lin', channel=2)
loggers[codenames[1]].daemon = True
loggers[codenames[1]].start()
livesocket = LiveSocket('Chemlab312 Air Logger', codenames)
livesocket.start()
socket = DateDataPullSocket('Chemlab312 Air Logger', codenames,
timeouts=[1.0] * len(loggers))
socket.start()
db_logger = ContinuousDataSaver(continuous_data_table='dateplots_chemlab312',
username=credentials.user,
password=credentials.passwd,
measurement_codenames=codenames)
db_logger.start()
while reader.isAlive():
time.sleep(0.5)
for name in codenames:
value = loggers[name].read_value()
livesocket.set_point_now(name, value)
socket.set_point_now(name, value)
if loggers[name].read_trigged():
print(value)
db_logger.save_point_now(name, value)
loggers[name].clear_trigged()
def main():
""" Main function """
hih_instance = honeywell_6000.HIH6130()
reader = Reader(hih_instance)
reader.start()
time.sleep(5)
codenames = ['gc_ms_inner_temperature', 'gc_ms_inner_humidity']
loggers = {}
loggers[codenames[0]] = ValueLogger(reader,
comp_val=0.1,
maximumtime=10,
comp_type='lin',
channel=1)
loggers[codenames[0]].start()
loggers[codenames[1]] = ValueLogger(reader,
comp_val=1,
maximumtime=10,
comp_type='lin',
channel=2)
loggers[codenames[1]].start()
socket = DateDataPullSocket('gc_ms_temperature_humidity',
codenames,
timeouts=[1.0] * len(loggers))
socket.start()
db_logger = ContinuousDataSaver(continuous_data_table='dateplots_gc_ms',
username=credentials.user,
password=credentials.passwd,
measurement_codenames=codenames)
db_logger.start()
while reader.isAlive():
time.sleep(1)
for name in codenames:
value = loggers[name].read_value()
socket.set_point_now(name, value)
if loggers[name].read_trigged():
print(value)
db_logger.save_point_now(name, value)
loggers[name].clear_trigged()
def main():
""" Main function """
logging.basicConfig(filename="logger.txt", level=logging.ERROR)
logging.basicConfig(level=logging.ERROR)
port = '/dev/serial/by-id/usb-Prolific_Technology_Inc._USB-Serial_Controller_D-if00-port'
port = '/dev/ttyUSB0'
codenames = ['xrd_pressure_turbo_gas_system', 'xrd_pressure_gas_system_wrg',
'xrd_pressure_mass_spec_wrg', 'xrd_pressure_gas_system_baratron']
reader = PressureReader(port)
reader.daemon = True
reader.start()
loggers = {}
loggers[codenames[0]] = ValueLogger(reader, comp_val=0.02, comp_type='log', channel=1)
loggers[codenames[1]] = ValueLogger(reader, comp_val=0.02, comp_type='log', channel=2)
loggers[codenames[2]] = ValueLogger(reader, comp_val=0.02, comp_type='log', channel=3)
loggers[codenames[3]] = ValueLogger(reader, comp_val=2, comp_type='lin', channel=4)
for i in range(0, 4):
loggers[codenames[i]].start()
socket = DateDataPullSocket('XRD Pressure', codenames, timeouts=[2.0] * len(codenames))
socket.start()
live_socket = LiveSocket('XRD pressure', codenames, 2)
live_socket.start()
db_logger = ContinuousDataSaver(continuous_data_table='dateplots_xrd',
username=credentials.user,
password=credentials.passwd,
measurement_codenames=codenames)
db_logger.start()
time.sleep(5)
while True:
time.sleep(0.25)
for name in codenames:
value = loggers[name].read_value()
socket.set_point_now(name, value)
live_socket.set_point_now(name, value)
if loggers[name].read_trigged():
print(name + ': ' + str(value))
db_logger.save_point_now(name, value)
loggers[name].clear_trigged()
def main():
""" Main function """
logging.basicConfig(filename="logger.txt", level=logging.ERROR)
logging.basicConfig(level=logging.ERROR)
port = 'usb-FTDI_USB-RS232_Cable_FTWZKOU0-if00-port0'
omega = omegabus.OmegaBus(device='/dev/serial/by-id/' + port, model='D5251', baud=300)
reader = Reader(omega)
reader.start()
time.sleep(2.5)
codenames = ['propene_ox_setup_abs_pressure']
loggers = {}
loggers[codenames[0]] = ValueLogger(reader, comp_val=5, maximumtime=300,
comp_type='lin')
loggers[codenames[0]].start()
livesocket = LiveSocket('propene_ox Logger', codenames)
livesocket.start()
socket = DateDataPullSocket('propene_ox logger', codenames,
timeouts=[3.0] * len(loggers))
socket.start()
db_logger = ContinuousDataSaver(continuous_data_table='dateplots_propene_ox',
username=credentials.user,
password=credentials.passwd,
measurement_codenames=codenames)
db_logger.start()
while reader.isAlive():
time.sleep(1)
for name in codenames:
value = loggers[name].read_value()
livesocket.set_point_now(name, value)
socket.set_point_now(name, value)
if loggers[name].read_trigged():
print(name + ': ' + str(value))
db_logger.save_point_now(name, value)
loggers[name].clear_trigged()
def main():
""" Main function """
logging.basicConfig(filename="logger.txt", level=logging.ERROR)
logging.basicConfig(level=logging.ERROR)
i2c_helper = ABEHelpers()
bus = i2c_helper.get_smbus()
adc_instance = DeltaSigma(bus, 0x68, 0x69, 18)
tempreader = TemperatureReader(adc_instance)
tempreader.daemon = True
tempreader.start()
codenames = ["cooling_water_hot", "cooling_water_cold"]
loggers = {}
for i in range(0, 2):
loggers[codenames[i]] = ValueLogger(tempreader, comp_val=0.5, channel=i)
loggers[codenames[i]].start()
socket = DateDataPullSocket("hall_cooling_water_temp", codenames, timeouts=2.0)
socket.start()
live_socket = LiveSocket("hall_waterpressure", codenames)
live_socket.start()
db_logger = ContinuousDataSaver(
continuous_data_table="dateplots_hall",
username=credentials.user,
password=credentials.passwd,
measurement_codenames=codenames,
)
db_logger.start()
time.sleep(5)
while tempreader.is_alive():
time.sleep(0.25)
for name in codenames:
value = loggers[name].read_value()
socket.set_point_now(name, value)
live_socket.set_point_now(name, value)
if loggers[name].read_trigged():
print(value)
db_logger.save_point_now(name, value)
loggers[name].clear_trigged()
def main():
""" Main function """
logging.basicConfig(filename="logger.txt", level=logging.ERROR)
logging.basicConfig(level=logging.ERROR)
i2c_helper = ABEHelpers()
bus = i2c_helper.get_smbus()
adc_instance = ADCPi(bus, 0x68, 0x69, 18)
pressurereader = PressureReader(adc_instance)
pressurereader.daemon = True
pressurereader.start()
codenames = ["chemlab312_sample_storage_pressure"]
loggers = {}
for i in range(0, 1):
loggers[codenames[i]] = ValueLogger(pressurereader, comp_val=0.05, comp_type="log")
loggers[codenames[i]].start()
socket = DateDataPullSocket("chemlab312_sample_storage", codenames, timeouts=[2.0])
socket.start()
live_socket = LiveSocket("chemlab312_sample_storage", codenames)
live_socket.start()
db_logger = ContinuousDataSaver(
continuous_data_table="dateplots_chemlab312",
username=credentials.user,
password=credentials.passwd,
measurement_codenames=codenames,
)
db_logger.start()
time.sleep(5)
while True:
time.sleep(0.5)
for name in codenames:
value = loggers[name].read_value()
socket.set_point_now(name, value)
live_socket.set_point_now(name, value)
if loggers[name].read_trigged():
print(value)
db_logger.save_point_now(name, value)
loggers[name].clear_trigged()
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 """
code_names = ['pvd309_temp_dca_cell', 'pvd309_temp_mai_cell']
reader = TemperatureReader()
reader.start()
loggers = {}
loggers[code_names[0]] = ValueLogger(reader,
channel=1,
comp_val=0.5,
comp_type='lin')
loggers[code_names[0]].start()
loggers[code_names[1]] = ValueLogger(reader,
channel=2,
comp_val=0.5,
comp_type='lin')
loggers[code_names[1]].start()
datasocket = DateDataPullSocket('pvd_309_temp',
code_names,
timeouts=[2.0] * 2,
port=9001)
datasocket.start()
livesocket = LiveSocket('pvd_309_temperatures', code_names)
livesocket.start()
db_logger = ContinuousDataSaver(continuous_data_table='dateplots_pvd309',
username=credentials.user,
password=credentials.passwd,
measurement_codenames=code_names)
db_logger.start()
time.sleep(5)
while not reader.quit:
time.sleep(0.25)
for name in code_names:
print(reader.ttl)
value = loggers[name].read_value()
datasocket.set_point_now(name, value)
livesocket.set_point_now(name, value)
if loggers[name].read_trigged():
print(name + ': ' + str(value))
db_logger.save_point_now(name, value)
loggers[name].clear_trigged()
def main():
""" Main function """
logging.basicConfig(filename="logger.txt", level=logging.ERROR)
logging.basicConfig(level=logging.ERROR)
codenames = ['vhp_T_jacket']
datasocket = DateDataPullSocket('VHP_T_jacket_reader',
codenames,
port=9001)
datasocket.start()
db_logger = ContinuousDataSaver(
continuous_data_table='dateplots_vhp_setup',
username=credentials.user,
password=credentials.passwd,
measurement_codenames=codenames)
db_logger.start()
ports = {}
ports['vhp_T_jacket'] = 'usb-FTDI_USB-RS485_Cable_FT1F9WC2-if00-port0'
loggers = {}
temperature_readers = {}
for logger_name in codenames:
temperature_readers[logger_name] = TemperatureReader(
CN7800(ports[logger_name]))
temperature_readers[logger_name].daemon = True
temperature_readers[logger_name].start()
loggers[logger_name] = ValueLogger(temperature_readers[logger_name],
comp_val=1)
loggers[logger_name].start()
time.sleep(5)
values = {}
while True:
time.sleep(1)
for logger_name in codenames:
values[logger_name] = loggers[logger_name].read_value()
datasocket.set_point_now(logger_name, values[logger_name])
if loggers[logger_name].read_trigged():
print(logger_name + ': ' + str(values[logger_name]))
db_logger.save_point_now(logger_name, values[logger_name])
loggers[logger_name].clear_trigged()
def main():
""" Main function """
logging.basicConfig(filename="logger.txt", level=logging.ERROR)
logging.basicConfig(level=logging.ERROR)
qcm_port = '/dev/serial/by-id/usb-1a86_USB2.0-Ser_-if00-port0'
qcm = inficon.InficonSQM160(qcm_port)
reader = QcmReader(qcm)
reader.daemon = True
reader.start()
codenames = [
'sputterchamber_qcm_frequency', 'sputterchamber_qcm_qrystal_life',
'sputterchamber_qcm_thickness'
]
loggers = {}
for i in range(0, len(codenames)):
loggers[codenames[i]] = ValueLogger(reader, comp_val=0.25, channel=i)
loggers[codenames[i]].start()
socket = DateDataPullSocket('Sputterchamber QCM',
codenames,
port=9000,
timeouts=[5.0] * len(codenames))
socket.start()
db_logger = ContinuousDataSaver(
continuous_data_table='dateplots_sputterchamber',
username=credentials.user,
password=credentials.passwd,
measurement_codenames=codenames)
db_logger.start()
time.sleep(5)
while reader.isAlive():
time.sleep(0.25)
for name in codenames:
value = loggers[name].read_value()
socket.set_point_now(name, value)
if loggers[name].read_trigged():
print(value)
db_logger.save_point_now(name, value)
loggers[name].clear_trigged()
def main():
""" Main function """
logging.basicConfig(filename="logger.txt", level=logging.ERROR)
logging.basicConfig(level=logging.ERROR)
i2c_helper = ABEHelpers()
bus = i2c_helper.get_smbus()
adc_instance = ADCPi(bus, 0x68, 0x69, 18)
pressurereader = PressureReader(adc_instance)
pressurereader.daemon = True
pressurereader.start()
logger = ValueLogger(pressurereader, comp_val=0.5)
logger.start()
socket = DateDataPullSocket('hall_n5_argon_pressure',
['n5_argon_pressure'],
timeouts=[1.0])
socket.start()
live_socket = LiveSocket('hall_n5_argon_pressure', ['n5_argon_pressure'],
2)
live_socket.start()
db_logger = ContinuousDataSaver(
continuous_data_table='dateplots_hall',
username=credentials.user,
password=credentials.passwd,
measurement_codenames=['n5_argon_pressure'])
db_logger.start()
time.sleep(2)
while True:
time.sleep(0.25)
value = logger.read_value()
socket.set_point_now('n5_argon_pressure', value)
live_socket.set_point_now('n5_argon_pressure', value)
if logger.read_trigged():
print(value)
db_logger.save_point_now('n5_argon_pressure', value)
logger.clear_trigged()
class Local(threading.Thread):
""" This class will be automatically started by the mass-spec program
it can be arbritrarily simply or complex and will provide a local udp-socket
to be included in a meta-channel in the mass-spec, thus allowing integraion
of local instruments """
def __init__(self):
threading.Thread.__init__(self)
#self.daemon = True
self.pullsocket = DateDataPullSocket('local MS socket',
['analog_in'], timeouts=2, port=9250)
self.pullsocket.start()
port = '/dev/serial/by-id/usb-FTDI_USB-RS485_Cable_FTWBEDQ3-if00-port0'
self.omega = OmegaD6400(1, port=port)
self.omega.update_range_and_function(2, action='voltage', fullrange='10')
def run(self):
while True:
time.sleep(0.1)
value = self.omega.read_value(2)
self.pullsocket.set_point_now('analog_in', value)
def main():
""" Main function """
logging.basicConfig(filename="logger.txt", level=logging.ERROR)
logging.basicConfig(level=logging.ERROR)
codenames = ['fr307_furnace_1_T', 'fr307_furnace_2_T']
datasocket = DateDataPullSocket('furnaceroom_reader', codenames,
timeouts=[3.0, 3.0], port=9001)
datasocket.start()
db_logger = ContinuousDataSaver(continuous_data_table='dateplots_furnaceroom307',
username=credentials.user,
password=credentials.passwd,
measurement_codenames=codenames)
db_logger.start()
ports = {}
ports['fr307_furnace_1_T'] = 'usb-FTDI_USB-RS485_Cable_FTWGRL9C-if00-port0'
ports['fr307_furnace_2_T'] = 'usb-FTDI_USB-RS485_Cable_FTWGRN2W-if00-port0'
loggers = {}
temperature_readers = {}
for logger_name in codenames:
temperature_readers[logger_name] = TemperatureReader(ports[logger_name])
temperature_readers[logger_name].daemon = True
temperature_readers[logger_name].start()
loggers[logger_name] = ValueLogger(temperature_readers[logger_name], comp_val=0.09)
loggers[logger_name].start()
time.sleep(5)
values = {}
while True:
time.sleep(1)
for logger_name in codenames:
values[logger_name] = loggers[logger_name].read_value()
datasocket.set_point_now(logger_name, values[logger_name])
if loggers[logger_name].read_trigged():
print(logger_name + ': ' + str(values[logger_name]))
db_logger.save_point_now(logger_name, values[logger_name])
loggers[logger_name].clear_trigged()
def main():
""" Main function """
logging.basicConfig(filename="logger.txt", level=logging.ERROR)
logging.basicConfig(level=logging.ERROR)
i2c_helper = ABEHelpers()
bus = i2c_helper.get_smbus()
adc_instance = DeltaSigma(bus, 0x68, 0x69, 18)
pressurereader = PressureReader(adc_instance)
pressurereader.daemon = True
pressurereader.start()
codenames = ['mr_iongauge_pressure']
logger = ValueLogger(pressurereader, comp_val=0.5)
logger.start()
socket = DateDataPullSocket('Microreactor Ion Gauge', codenames, timeouts=[1.0])
socket.start()
live_socket = LiveSocket('Microreactor Ion Gauge', codenames)
live_socket.start()
db_logger = ContinuousDataSaver(continuous_data_table='dateplots_microreactor',
username=credentials.user,
password=credentials.passwd,
measurement_codenames=codenames)
db_logger.start()
time.sleep(2)
while True:
time.sleep(0.25)
value = logger.read_value()
socket.set_point_now(codenames[0], value)
live_socket.set_point_now(codenames[0], value)
if logger.read_trigged():
print(value)
db_logger.save_point_now(codenames[0], value)
logger.clear_trigged()
def main():
""" Main function """
hih_instance = honeywell_6000.HIH6130()
reader = Reader(hih_instance)
reader.start()
time.sleep(5)
codenames = ['small_office_312_temperature', 'small_office_312_humidity']
loggers = {}
loggers[codenames[0]] = ValueLogger(reader, comp_val=1, comp_type='lin', channel=1)
loggers[codenames[0]].start()
loggers[codenames[1]] = ValueLogger(reader, comp_val=1, comp_type='lin', channel=2)
loggers[codenames[1]].start()
livesocket = LiveSocket('Large Office 312 Air Logger', codenames)
livesocket.start()
socket = DateDataPullSocket('Small Office 312 Air Logger', codenames,
timeouts=[1.0] * len(loggers))
socket.start()
db_logger = ContinuousDataSaver(continuous_data_table='dateplots_offices_312',
username=credentials.user,
password=credentials.passwd,
measurement_codenames=codenames)
db_logger.start()
while reader.isAlive():
time.sleep(1)
for name in codenames:
value = loggers[name].read_value()
livesocket.set_point_now(name, value)
socket.set_point_now(name, value)
if loggers[name].read_trigged():
print(value)
db_logger.save_point_now(name, value)
loggers[name].clear_trigged()
def main():
""" Main function """
logging.basicConfig(filename="logger.txt", level=logging.ERROR)
logging.basicConfig(level=logging.ERROR)
qcm_port = '/dev/serial/by-id/usb-1a86_USB2.0-Ser_-if00-port0'
qcm = inficon.InficonSQM160(qcm_port)
reader = QcmReader(qcm)
reader.daemon = True
reader.start()
codenames = ['sputterchamber_qcm_frequency',
'sputterchamber_qcm_qrystal_life',
'sputterchamber_qcm_thickness']
loggers = {}
for i in range(0, len(codenames)):
loggers[codenames[i]] = ValueLogger(reader, comp_val=0.25, channel=i)
loggers[codenames[i]].start()
socket = DateDataPullSocket('Sputterchamber QCM', codenames, port=9000,
timeouts=[5.0] * len(codenames))
socket.start()
db_logger = ContinuousDataSaver(continuous_data_table='dateplots_sputterchamber',
username=credentials.user,
password=credentials.passwd,
measurement_codenames=codenames)
db_logger.start()
time.sleep(5)
while reader.isAlive():
time.sleep(0.25)
for name in codenames:
value = loggers[name].read_value()
socket.set_point_now(name, value)
if loggers[name].read_trigged():
print(value)
db_logger.save_point_now(name, value)
loggers[name].clear_trigged()
class FlowControl(threading.Thread):
""" Keep updated values of the current flow """
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)
loggers = {}
loggers['pvd309_main_chamber_ig'] = PressureLogger(pressurereader, 3)
loggers['pvd309_main_chamber_pirani'] = PressureLogger(pressurereader, 2)
loggers['pvd309_load_lock_pirani'] = PressureLogger(pressurereader, 5)
for codename in pressure_codenames:
loggers[codename].start()
socket = DateDataPullSocket('pvd309', pressure_codenames, timeouts=[5.0, 5.0, 5.0])
socket.start()
db_logger = ContinuousLogger(table='dateplots_pvd309',
username=credentials.user,
password=credentials.passwd,
measurement_codenames=pressure_codenames)
db_logger.start()
time.sleep(3)
while True:
time.sleep(0.25)
for codename in pressure_codenames:
p = loggers[codename].read_pressure()
socket.set_point_now(codename, p)
if loggers[codename].trigged:
print p
db_logger.enqueue_point_now(codename, p)
loggers[codename].trigged = 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)