def __init__(self, ):
logging.info('MainPID class started')
threading.Thread.__init__(self)
#from datalogger import TemperatureReader
self.quit = False
self.codenames = [
'tabs_guard_pid_value',
'tabs_floor_pid_value',
'tabs_ceiling_pid_value',
'tabs_cooling_pid_value',
'tabs_guard_valve_heating',
'tabs_floor_valve_heating',
'tabs_ceiling_valve_heating',
'tabs_guard_valve_cooling',
'tabs_floor_valve_cooling',
'tabs_ceiling_valve_cooling',
'tabs_cooling_valve_cooling',
]
sockname = 'tabs_pids'
self.PullSocket = DateDataPullSocket(
sockname,
self.codenames,
timeouts=[60.0] * len(self.codenames),
port=socketinfo.INFO[sockname]['port'])
self.PullSocket.start()
self.PTC = PidTemperatureControl(self.codenames)
self.PTC.daemon = True
self.PTC.start()
#time.sleep(5)
chlist = {
'tabs_guard_pid_value': 0,
'tabs_floor_pid_value': 1,
'tabs_ceiling_pid_value': 2,
'tabs_cooling_pid_value': 3,
'tabs_guard_valve_heating': 4,
'tabs_floor_valve_heating': 5,
'tabs_ceiling_valve_heating': 6,
'tabs_guard_valve_cooling': 7,
'tabs_floor_valve_cooling': 8,
'tabs_ceiling_valve_cooling': 9,
'tabs_cooling_valve_cooling': 10
}
self.loggers = {}
for key in self.codenames:
self.loggers[key] = ValueLogger(self.PTC,
comp_val=0.10,
maximumtime=60,
comp_type='lin',
channel=chlist[key])
self.loggers[key].start()
#livesocket = LiveSocket('tabs_temperature_logger', codenames, 2)
#livesocket.start()
self.db_logger = ContinuousLogger(table='dateplots_tabs',
username=credentials.user,
password=credentials.passwd,
measurement_codenames=self.codenames)
self.db_logger.start()
def main():
""" 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 __init__(self,):
logging.info('MainDatalogger class started')
threading.Thread.__init__(self)
#from datalogger import TemperatureReader
self.quit = False
self.codenames = ['tabs_guard_temperature_inlet',
'tabs_floor_temperature_inlet',
'tabs_ceiling_temperature_inlet',
'tabs_cooling_temperature_inlet',
]
self.MC302 = WaterTemperatureReader()
self.MC302.start()
self.codenames = [
'tabs_cooling_temperature_inlet',
]
self.omega_temperature = TemperatureReader(['tabs_cooling_temperature_inlet',])
self.omega_temperature.daemon = True
self.omega_temperature.start()
#omega_temperature.update_values()
time.sleep(1.5)
chlist = {'tabs_guard_temperature_control': 0,
'tabs_room_temperature_control': 1,
#'tabs_ceiling_temperature_inlet': 2,
'tabs_cooling_temperature_inlet': 3}
self.loggers = {}
for key in chlist.keys():
self.loggers[key] = ValueLogger(self.omega_temperature, comp_val = 0.2, maximumtime=300,
comp_type = 'lin', channel = chlist[key])
self.loggers[key].start()
chlist = {'tabs_guard_temperature_inlet': 0,
'tabs_guard_temperature_outlet': 1,
'tabs_guard_temperature_delta': 2,
'tabs_floor_temperature_inlet': 3,
'tabs_floor_temperature_outlet': 4,
'tabs_floor_temperature_delta': 5,
'tabs_ceiling_temperature_inlet': 6,
'tabs_ceiling_temperature_outlet': 7,
'tabs_ceiling_temperature_delta': 8,
'tabs_guard_water_flow': 9,
'tabs_floor_water_flow': 10,
'tabs_ceiling_water_flow': 11,}
for key in chlist.keys():
self.loggers[ key] = ValueLogger(self.MC302, comp_val = 0.2, maximumtime=300,
comp_type = 'lin', channel = chlist[key])
self.loggers[key].start()
self.codenames = self.loggers.keys()
#livesocket = LiveSocket('tabs_temperature_logger', codenames, 2)
#livesocket.start()
sockname = 'tabs_temperatures'
self.PullSocket = DateDataPullSocket(sockname, self.codenames, timeouts=[60.0]*len(self.codenames), port = socketinfo.INFO[sockname]['port'])
self.PullSocket.start()
self.db_logger = ContinuousLogger(table='dateplots_tabs', username=credentials.user, password=credentials.passwd, measurement_codenames=self.codenames)
self.db_logger.start()
def __init__(self, ):
logging.info('MainMultilogger class started')
threading.Thread.__init__(self)
#from datalogger import TemperatureReader
self.quit = False
self.codenames = Setting_channel_list.keys()
"""['tabs_ceiling_temperature_delta',
'tabs_ceiling_temperature_deltaref',
'tabs_floor_temperature_delta',
'tabs_floor_temperature_deltaref',
'tabs_room_temperature_aircenter010',
'tabs_room_temperature_aircenter060',
'tabs_room_temperature_aircenter110',
'tabs_room_temperature_aircenter170',
'tabs_room_temperature_aircenter355',
'tabs_guard_temperature_airfloor',
'tabs_guard_temperature_airceiling',
'tabs_guard_temperature_airwallsouth',
'tabs_guard_temperature_airwallnorth',
'tabs_guard_temperature_airwalleast',
'tabs_guard_temperature_airwallwest',
]"""
self.multiplex_reader = MultiplexReader(self.codenames)
self.multiplex_reader.daemon = True
self.multiplex_reader.start()
#omega_temperature.update_values()
time.sleep(3.5)
chlist = Setting_channel_list
self.loggers = {}
for key in self.codenames:
self.loggers[key] = ValueLogger(self.multiplex_reader,
comp_val=0.5,
maximumtime=300,
comp_type='lin',
channel=chlist[key])
self.loggers[key].start()
#livesocket = LiveSocket('tabs_temperature_logger', codenames, 2)
#livesocket.start()
sockname = 'tabs_multiplexer'
self.PullSocket = DateDataPullSocket(
sockname,
self.codenames,
timeouts=[60.0] * len(self.codenames),
port=socketinfo.INFO[sockname]['port'])
self.PullSocket.start()
self.db_logger = ContinuousLogger(table='dateplots_tabs',
username=credentials.user,
password=credentials.passwd,
measurement_codenames=self.codenames)
self.db_logger.start()
def __init__(self,):
threading.Thread.__init__(self)
#from mytui import CursesTui
self.quit = False
self.codenames = ['tabs_guard_temperature_setpoint',
'tabs_floor_temperature_setpoint',
'tabs_ceiling_temperature_setpoint',
'tabs_cooling_temperature_setpoint',
]
sockname = 'tabs_setpoints'
self.PullSocket = DateDataPullSocket(sockname, self.codenames, timeouts=[60.0]*len(self.codenames), port = socketinfo.INFO[sockname]['port'])
self.PullSocket.start()
self.TUI = CursesTui(self.codenames)
self.TUI.start()
#time.sleep(5)
chlist = {'tabs_guard_temperature_setpoint': 0,
'tabs_floor_temperature_setpoint': 1,
'tabs_ceiling_temperature_setpoint': 2,
'tabs_cooling_temperature_setpoint': 3}
self.loggers = {}
for key in self.codenames:
self.loggers[key] = ValueLogger(self.TUI, comp_val = 0.2, maximumtime=60,
comp_type = 'lin', channel = chlist[key])
self.loggers[key].start()
#livesocket = LiveSocket('tabs_temperature_logger', codenames, 2)
#livesocket.start()
self.db_logger = ContinuousLogger(table='dateplots_tabs', username=credentials.user, password=credentials.passwd, measurement_codenames=self.codenames)
#print('Hostname of db logger: ' + db_logger.host)
self.db_logger.start()
def main():
"""Main function"""
chiller_port = '/dev/serial/by-id/'
chiller_port += 'usb-Prolific_Technology_Inc._USB-Serial_Controller-if00-port0'
LOG.info('Using chiller port %s', chiller_port)
reader = ChillerReader(chiller_port)
reader.start()
LOG.info('ChillerReader started')
codenames = ['sputterchamber_chiller_temperature',
'sputterchamber_chiller_flow',
'sputterchamber_chiller_temperature_ambient',
'sputterchamber_chiller_pressure',
'sputterchamber_chiller_temperature_setpoint']
LOG.debug('Using codenames %s', codenames)
loggers = {}
for i in range(0, len(codenames)):
loggers[codenames[i]] = ValueLogger(reader, comp_val=0.1, channel=i)
loggers[codenames[i]].start()
live_socket_name = 'Sputterchamber chiller'
live_socket = LiveSocket(live_socket_name, codenames, 2)
live_socket.start()
LOG.info('Live socket init and started with name "%s"', live_socket_name)
db_table = 'dateplots_sputterchamber'
db_logger = ContinuousLogger(table=db_table,
username=credentials.user,
password=credentials.passwd,
measurement_codenames=codenames)
db_logger.start()
LOG.info('ContinuousLogger init and started on table "%s"', db_table)
time.sleep(5)
while reader.isAlive():
time.sleep(0.25)
for name in codenames:
value = loggers[name].read_value()
if not math.isnan(value):
live_socket.set_point_now(name, value)
if loggers[name].read_trigged():
LOG.debug('Log value %s for codename "%s"', value, name)
db_logger.enqueue_point_now(name, value)
loggers[name].clear_trigged()
def __init__(self, ):
threading.Thread.__init__(self)
#from mytui import CursesTui
self.quit = False
self.codenames = [
'tabs_guard_temperature_setpoint',
'tabs_floor_temperature_setpoint',
'tabs_ceiling_temperature_setpoint',
'tabs_cooling_temperature_setpoint',
]
sockname = 'tabs_setpoints'
self.PullSocket = DateDataPullSocket(
sockname,
self.codenames,
timeouts=[60.0] * len(self.codenames),
port=socketinfo.INFO[sockname]['port'])
self.PullSocket.start()
self.TUI = CursesTui(self.codenames)
self.TUI.daemon = True
self.TUI.start()
#time.sleep(5)
chlist = {
'tabs_guard_temperature_setpoint': 0,
'tabs_floor_temperature_setpoint': 1,
'tabs_ceiling_temperature_setpoint': 2,
'tabs_cooling_temperature_setpoint': 3
}
self.loggers = {}
for key in self.codenames:
self.loggers[key] = ValueLogger(self.TUI,
comp_val=0.2,
maximumtime=60,
comp_type='lin',
channel=chlist[key])
self.loggers[key].start()
#livesocket = LiveSocket('tabs_temperature_logger', codenames, 2)
#livesocket.start()
self.db_logger = ContinuousLogger(table='dateplots_tabs',
username=credentials.user,
password=credentials.passwd,
measurement_codenames=self.codenames)
#print('Hostname of db logger: ' + db_logger.host)
self.db_logger.start()
def main():
LOGGER.info('main started')
cni = CNi3244_C24(0)
socket = DateDataSocket([SHORT_NAME], timeouts=1.0)
socket.start()
db_logger = ContinuousLogger(
table='dateplots_tower', username='******', password='******',
measurement_codenames=[NAME],
dsn='servcinf'
)
db_logger.start()
time.sleep(0.1)
# Main part
try:
main_measure_loop(cni, socket, db_logger)
except KeyboardInterrupt:
LOGGER.info('Keyboard Interrupt. Shutting down!')
db_logger.stop()
cni.close()
socket.stop()
def main():
"""The main method for the pressure logger"""
# Open communication to the pressure measurement unit
tpg = TPG262(port='/dev/ttyUSB0', baudrate=9600)
LOGGER.info('Initiated driver to TPG 262')
# Get a continuous logger
codenames = ['thetaprobe_pressure_loadlock', 'thetaprobe_pressure_uvgun']
db_logger = ContinuousLogger(table='dateplots_thetaprobe',
username=credentials.USERNAME,
password=credentials.PASSWORD,
measurement_codenames=codenames)
db_logger.start()
LOGGER.info('Initiated and started database logger')
livesocket = LiveSocket(codenames, 0.2)
livesocket.start()
loadlock_last = {'value': 1E20, 'time': 0}
uvgun_last = {'value': 1E20, 'time': 0}
try:
while True:
# get the values: returns:
# (value1, (status_code1, status_message1),
# value2, (status_code2, status_message2))
value_ll, code_ll, value_uv, code_uv = tpg.pressure_gauges()
livesocket.set_point_now('thetaprobe_pressure_loadlock', value_ll)
livesocket.set_point_now('thetaprobe_pressure_uvgun', value_uv)
### Load lock
if code_ll[0] in [0, 1]: # If measurement is OK or underranged
if logging_criteria(value_ll, loadlock_last):
LOGGER.info('Add value {} for load lock'.format(value_ll))
now_ll = db_logger.enqueue_point_now(
'thetaprobe_pressure_loadlock',
value_ll)
loadlock_last['value'] = value_ll
loadlock_last['time'] = now_ll
### UV gun
if code_uv[0] in [0, 1]: # If measurement is OK or underranged
if logging_criteria(value_uv, uvgun_last):
LOGGER.info('Add value {} for UV gun'.format(value_uv))
now_uv = db_logger.enqueue_point_now(
'thetaprobe_pressure_uvgun',
value_uv)
uvgun_last['value'] = value_uv
uvgun_last['time'] = now_uv
except KeyboardInterrupt:
LOGGER.info('Keyboard interrupt. Shutting down')
db_logger.stop()
livesocket.stop()
LOGGER.info('Database logger stoppped. Exiting!')
def __init__(self,):
logging.info('MainPID class started')
threading.Thread.__init__(self)
#from datalogger import TemperatureReader
self.quit = False
self.codenames = ['tabs_guard_pid_value',
'tabs_floor_pid_value',
'tabs_ceiling_pid_value',
'tabs_cooling_pid_value',
'tabs_guard_valve_heating',
'tabs_floor_valve_heating',
'tabs_ceiling_valve_heating',
'tabs_guard_valve_cooling',
'tabs_floor_valve_cooling',
'tabs_ceiling_valve_cooling',
'tabs_cooling_valve_cooling',
]
sockname = 'tabs_pids'
self.PullSocket = DateDataPullSocket(sockname, self.codenames, timeouts=[60.0]*len(self.codenames), port = socketinfo.INFO[sockname]['port'])
self.PullSocket.start()
self.PTC = PidTemperatureControl(self.codenames)
self.PTC.daemon = True
self.PTC.start()
#time.sleep(5)
chlist = {'tabs_guard_pid_value': 0,
'tabs_floor_pid_value': 1,
'tabs_ceiling_pid_value': 2,
'tabs_cooling_pid_value': 3,
'tabs_guard_valve_heating': 4,
'tabs_floor_valve_heating': 5,
'tabs_ceiling_valve_heating': 6,
'tabs_guard_valve_cooling': 7,
'tabs_floor_valve_cooling': 8,
'tabs_ceiling_valve_cooling': 9,
'tabs_cooling_valve_cooling': 10}
self.loggers = {}
for key in self.codenames:
self.loggers[key] = ValueLogger(self.PTC, comp_val = 0.10, maximumtime=60,
comp_type = 'lin', channel = chlist[key])
self.loggers[key].start()
#livesocket = LiveSocket('tabs_temperature_logger', codenames, 2)
#livesocket.start()
self.db_logger = ContinuousLogger(table='dateplots_tabs', username=credentials.user, password=credentials.passwd, measurement_codenames=self.codenames)
self.db_logger.start()
def main():
"""The main method for the pressure logger"""
# Open communication to the pressure measurement unit
tpg = TPG262(port='/dev/ttyUSB0', baudrate=9600)
LOGGER.info('Initiated driver to TPG 262')
# Get a continuous logger
codenames = ['thetaprobe_pressure_loadlock']
db_logger = ContinuousLogger(table='dateplots_thetaprobe',
username=credentials.USERNAME,
password=credentials.PASSWORD,
measurement_codenames=codenames)
db_logger.start()
LOGGER.info('Initiated and started database logger')
name = 'Thetaprobe pressure load lock and UV gun'
livesocket = LiveSocket(name, codenames, 0.2)
livesocket.start()
loadlock_last = {'value': 1E20, 'time': 0}
try:
while True:
# get the values: returns:
# (value1, (status_code1, status_message1),
# value2, (status_code2, status_message2))
try:
value_ll, code_ll = tpg.pressure_gauge(gauge=1)
except (IOError, ValueError):
LOGGER.info(
'Serial communication failed. Sleep 10 and try again.')
time.sleep(10)
continue
livesocket.set_point_now('thetaprobe_pressure_loadlock', value_ll)
### Load lock
if code_ll[0] in [0, 1]: # If measurement is OK or underranged
if logging_criteria(value_ll, loadlock_last):
LOGGER.info('Add value {} for load lock'.format(value_ll))
now_ll = db_logger.enqueue_point_now(
'thetaprobe_pressure_loadlock', value_ll)
loadlock_last['value'] = value_ll
loadlock_last['time'] = now_ll
except KeyboardInterrupt:
LOGGER.info('Keyboard interrupt. Shutting down')
db_logger.stop()
livesocket.stop()
LOGGER.info('Database logger stoppped. Exiting!')
def __init__(self,):
logging.info('MainMultilogger class started')
threading.Thread.__init__(self)
#from datalogger import TemperatureReader
self.quit = False
self.codenames = Setting_channel_list.keys()
"""['tabs_ceiling_temperature_delta',
'tabs_ceiling_temperature_deltaref',
'tabs_floor_temperature_delta',
'tabs_floor_temperature_deltaref',
'tabs_room_temperature_aircenter010',
'tabs_room_temperature_aircenter060',
'tabs_room_temperature_aircenter110',
'tabs_room_temperature_aircenter170',
'tabs_room_temperature_aircenter355',
'tabs_guard_temperature_airfloor',
'tabs_guard_temperature_airceiling',
'tabs_guard_temperature_airwallsouth',
'tabs_guard_temperature_airwallnorth',
'tabs_guard_temperature_airwalleast',
'tabs_guard_temperature_airwallwest',
]"""
self.multiplex_reader = MultiplexReader(self.codenames)
self.multiplex_reader.daemon = True
self.multiplex_reader.start()
#omega_temperature.update_values()
time.sleep(3.5)
chlist = Setting_channel_list
self.loggers = {}
for key in self.codenames:
self.loggers[key] = ValueLogger(self.multiplex_reader, comp_val = 0.5, maximumtime=300,
comp_type = 'lin', channel = chlist[key])
self.loggers[key].start()
#livesocket = LiveSocket('tabs_temperature_logger', codenames, 2)
#livesocket.start()
sockname = 'tabs_multiplexer'
self.PullSocket = DateDataPullSocket(sockname, self.codenames, timeouts=[60.0]*len(self.codenames), port = socketinfo.INFO[sockname]['port'])
self.PullSocket.start()
self.db_logger = ContinuousLogger(table='dateplots_tabs', username=credentials.user, password=credentials.passwd, measurement_codenames=self.codenames)
self.db_logger.start()
def __init__(self,):
threading.Thread.__init__(self)
# from datalogger import TemperatureReader
self.quit = False
self.codenames = [
"tabs_guard_temperature_inlet",
"tabs_floor_temperature_inlet",
"tabs_ceiling_temperature_inlet",
"tabs_cooling_temperature_inlet",
]
self.omega_temperature = TemperatureReader(self.codenames)
self.omega_temperature.start()
# omega_temperature.update_values()
time.sleep(1.5)
chlist = {
"tabs_guard_temperature_inlet": 0,
"tabs_floor_temperature_inlet": 1,
"tabs_ceiling_temperature_inlet": 2,
"tabs_cooling_temperature_inlet": 3,
}
self.loggers = {}
for key in self.codenames:
self.loggers[key] = ValueLogger(
self.omega_temperature, comp_val=0.2, maximumtime=60, comp_type="lin", channel=chlist[key]
)
self.loggers[key].start()
# livesocket = LiveSocket('tabs_temperature_logger', codenames, 2)
# livesocket.start()
sockname = "tabs_temperatures"
self.PullSocket = DateDataPullSocket(
sockname, self.codenames, timeouts=[60.0] * len(self.codenames), port=socketinfo.INFO[sockname]["port"]
)
self.PullSocket.start()
self.db_logger = ContinuousLogger(
table="dateplots_tabs",
username=credentials.user,
password=credentials.passwd,
measurement_codenames=self.codenames,
)
self.db_logger.start()
def main():
"""Main function"""
chiller_port = '/dev/serial/by-id/'
chiller_port += 'usb-Prolific_Technology_Inc._USB-Serial_Controller-if00-port0'
LOG.info('Using chiller port %s', chiller_port)
reader = ChillerReader(chiller_port)
reader.start()
LOG.info('ChillerReader started')
codenames = [
'sputterchamber_chiller_temperature', 'sputterchamber_chiller_flow',
'sputterchamber_chiller_temperature_ambient',
'sputterchamber_chiller_pressure',
'sputterchamber_chiller_temperature_setpoint'
]
LOG.debug('Using codenames %s', codenames)
loggers = {}
for i in range(0, len(codenames)):
loggers[codenames[i]] = ValueLogger(reader, comp_val=0.1, channel=i)
loggers[codenames[i]].start()
live_socket_name = 'Sputterchamber chiller'
live_socket = LiveSocket(live_socket_name, codenames, 2)
live_socket.start()
LOG.info('Live socket init and started with name "%s"', live_socket_name)
db_table = 'dateplots_sputterchamber'
db_logger = ContinuousLogger(table=db_table,
username=credentials.user,
password=credentials.passwd,
measurement_codenames=codenames)
db_logger.start()
LOG.info('ContinuousLogger init and started on table "%s"', db_table)
time.sleep(5)
while reader.isAlive():
time.sleep(0.25)
for name in codenames:
value = loggers[name].read_value()
if not math.isnan(value):
live_socket.set_point_now(name, value)
if loggers[name].read_trigged():
LOG.debug('Log value %s for codename "%s"', value, name)
db_logger.enqueue_point_now(name, value)
loggers[name].clear_trigged()
def main():
LOGGER.info('main started')
cni = CNi3244_C24(5)
socket = DateDataPullSocket(FULL_NAME, [SHORT_NAME], timeouts=1.0)
socket.start()
db_logger = ContinuousLogger(table='dateplots_tower',
username='******',
password='******',
measurement_codenames=[NAME],
dsn='servcinf')
db_logger.start()
time.sleep(0.1)
# Main part
try:
main_measure_loop(cni, socket, db_logger)
except KeyboardInterrupt:
LOGGER.info('Keyboard Interrupt. Shutting down!')
db_logger.stop()
cni.close()
socket.stop()
def __init__(self):
# Start logger
codenames = [
'B307_gasalarm_CO_051', 'B307_gasalarm_H2_051',
'B307_gasalarm_CO_055', 'B307_gasalarm_H2_055',
'B307_gasalarm_CO_059', 'B307_gasalarm_H2_059',
'B307_gasalarm_CO_061', 'B307_gasalarm_H2_061',
'B307_gasalarm_CO_42-43', 'B307_gasalarm_H2_2sal',
'B307_gasalarm_CO_932', 'B307_gasalarm_H2_932'
]
self.db_logger = ContinuousLogger(table='dateplots_b307gasalarm',
username=credentials.USERNAME,
password=credentials.PASSWORD,
measurement_codenames=codenames)
self.db_logger.start()
LOGGER.info('Logger started')
# Each value is measured about every 5 sec, so sane interval about 2
self.live_socket = LiveSocket(name='gas_alarm_307_live',
codenames=codenames)
self.live_socket.start()
LOGGER.info('Live socket started')
# Start driver
self.vortex = Vortex('/dev/ttyUSB0', 1)
LOGGER.info('Vortex driver opened')
# Init database connection
self.db_connection = MySQLdb.connect(host='servcinf-sql.fysik.dtu.dk',
user=credentials.USERNAME,
passwd=credentials.PASSWORD,
db='cinfdata')
self.db_cursor = self.db_connection.cursor()
# Initiate static information. All information about the except for
# the list of their numbers are placed in dicts because the numbering
# starts at 1.
# Detector numbers: [1, 2, 3, ..., 12]
self.detector_numbers = \
range(1, self.vortex.get_number_installed_detectors() + 1)
self.detector_info = \
{detector_num: self.vortex.detector_configuration(detector_num)
for detector_num in self.detector_numbers}
# trip_levels are the differences that are required to force a log
# The levels are set to 2 * the communication resolution
# (1000 values over the full range)
# NOTE. Since we have had a lot of noise on the CO channels, we
# increased the level to info.range * 7.0 / 1000.0 for those
#self.trip_levels = {detector_num: info.range * 2.0 / 1000.0 for
# detector_num, info in self.detector_info.items()}
self.trip_levels = {}
for detector_number, info in self.detector_info.items():
if info.unit == "PPM":
self.trip_levels[detector_number] = info.range * 7.0 / 1000.0
else:
self.trip_levels[detector_number] = info.range * 2.0 / 1000.0
# Initiate last measured values and their corresponding times
self.detector_levels_last_values = \
{detector_num: - (10 ** 9)
for detector_num in self.detector_numbers}
self.detector_levels_last_times = \
{detector_num: 0 for detector_num in self.detector_numbers}
self.detector_status_last_values = \
{detector_num: {'inhibit': False, 'status': ['OK'],
'codename': self.detector_info[detector_num].identity}
for detector_num in self.detector_numbers}
self.detector_status_last_times = \
{detector_num: 0 for detector_num in self.detector_numbers}
# Initiate variables for system power status
self.central_power_status_last_value = 'OK'
self.central_power_status_last_time = -(10**9)
# Initiate variables for system status
self.central_status_last_value = ['All OK']
self.central_status_last_time = 0
def __init__(self):
# Start logger
codenames = ['B307_gasalarm_CO_051', 'B307_gasalarm_H2_051',
'B307_gasalarm_CO_055', 'B307_gasalarm_H2_055',
'B307_gasalarm_CO_059', 'B307_gasalarm_H2_059',
'B307_gasalarm_CO_061', 'B307_gasalarm_H2_061',
'B307_gasalarm_CO_42-43', 'B307_gasalarm_H2_2sal',
'B307_gasalarm_CO_932', 'B307_gasalarm_H2_932']
self.db_logger = ContinuousLogger(table='dateplots_b307gasalarm',
username=credentials.USERNAME,
password=credentials.PASSWORD,
measurement_codenames=codenames)
self.db_logger.start()
LOGGER.info('Logger started')
# Each value is measured about every 5 sec, so sane interval about 2
self.live_socket = LiveSocket(name='gas_alarm_307_live',
codenames=codenames,
sane_interval=2.0)
self.live_socket.start()
LOGGER.info('Live socket started')
# Start driver
self.vortex = Vortex('/dev/ttyUSB0', 1)
LOGGER.info('Vortex driver opened')
# Init database connection
self.db_connection = MySQLdb.connect(
host='servcinf', user=credentials.USERNAME,
passwd=credentials.PASSWORD, db='cinfdata')
self.db_cursor = self.db_connection.cursor()
# Initiate static information. All information about the except for
# the list of their numbers are placed in dicts because the numbering
# starts at 1.
# Detector numbers: [1, 2, 3, ..., 12]
self.detector_numbers = \
range(1, self.vortex.get_number_installed_detectors() + 1)
self.detector_info = \
{detector_num: self.vortex.detector_configuration(detector_num)
for detector_num in self.detector_numbers}
# trip_levels are the differences that are required to force a log
# The levels are set to 2 * the communication resolution
# (1000 values / full range)
self.trip_levels = {detector_num: info.range * 2.0 / 1000.0 for
detector_num, info in self.detector_info.items()}
# Initiate last measured values and their corresponding times
self.detector_levels_last_values = \
{detector_num: - (10 ** 9)
for detector_num in self.detector_numbers}
self.detector_levels_last_times = \
{detector_num: 0 for detector_num in self.detector_numbers}
self.detector_status_last_values = \
{detector_num: {'inhibit': False, 'status': ['OK'],
'codename': self.detector_info[detector_num].identity}
for detector_num in self.detector_numbers}
self.detector_status_last_times = \
{detector_num: 0 for detector_num in self.detector_numbers}
# Initiate variables for system power status
self.central_power_status_last_value = 'OK'
self.central_power_status_last_time = - (10 ** 9)
# Initiate variables for system status
self.central_status_last_value = ['All OK']
self.central_status_last_time = 0
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()
if __name__ == '__main__':
logging.basicConfig(filename="logger.txt", level=logging.ERROR)
logging.basicConfig(level=logging.ERROR)
tempreader = TemperatureReader()
tempreader.daemon = True
tempreader.start()
temp_logger = ValueLogger(tempreader, comp_val=1)
#temp_logger = TemperatureLogger(tempreader)
temp_logger.start()
db_logger = ContinuousLogger(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'], 2)
livesocket.start()
db_logger.start()
time.sleep(5)
while True:
time.sleep(0.25)
t = temp_logger.read_value()
temp_bearings_logger.daemon = True
temp_bearings_logger.start()
temp_motor_logger = tp.TurboLogger(reader, 'temp_motor', maximumtime=600)
temp_motor_logger.daemon = True
temp_motor_logger.start()
# Todo: change port number
#livesocket = LiveSocket([chamber_turbo_speed', 'chamber_turbo_power'], 2)
#livesocket.start()
db_logger = ContinuousLogger(
table='dateplots_mgw',
username=credentials.user,
password=credentials.passwd,
measurement_codenames=[
'mgw_chamber_turbo_speed', 'mgw_chamber_turbo_power',
'mgw_chamber_turbo_temp_motor', 'mgw_chamber_turbo_temp_bottom',
'mgw_chamber_turbo_temp_bearings',
'mgw_chamber_turbo_temp_electronics', 'mgw_chamber_turbo_current'
])
db_logger.start()
time.sleep(5)
while mainpump.running:
ts = rotation_logger.read_value()
power = power_logger.read_value()
current = current_logger.read_value()
temp_elec = temp_electronics_logger.read_value()
temp_bottom = temp_bottom_logger.read_value()
temp_bearings = temp_bearings_logger.read_value()
temp_motor = temp_motor_logger.read_value()
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, 2)
livesocket.start()
db_logger = ContinuousLogger(
table='dateplots_volvo',
username='******',
password='******',
measurement_codenames=['volvo_pressure', 'volvo_temperature'])
db_logger.start()
while pressure.isAlive() and analog_measurement.isAlive():
time.sleep(0.25)
for name in codenames:
v = loggers[name].read_value()
socket.set_point_now(name, v)
livesocket.set_point_now(name, v)
if loggers[name].read_trigged():
print(v)
db_logger.enqueue_point_now(name, v)
loggers[name].clear_trigged()
pressurereader = PressureReader(adc_instance)
pressurereader.daemon = True
pressurereader.start()
logger = ValueLogger(pressurereader, comp_val = 0.5)
logger.start()
socket = DateDataPullSocket('hall_waterpressure',
['hall_coolingwater_pressure'], timeouts=[1.0])
socket.start()
live_socket = LiveSocket('hall_waterpressure', ['hall_coolingwater_pressure'], 2)
live_socket.start()
db_logger = ContinuousLogger(table='dateplots_hall',
username=credentials.user,
password=credentials.passwd,
measurement_codenames=['hall_coolingwater_pressure'])
db_logger.start()
time.sleep(2)
while True:
time.sleep(0.25)
p = logger.read_value()
socket.set_point_now('hall_coolingwater_pressure', p)
live_socket.set_point_now('hall_coolingwater_pressure', p)
if logger.read_trigged():
print p
db_logger.enqueue_point_now('hall_coolingwater_pressure', p)
logger.clear_trigged()
from PyExpLabSys.common.sockets import DateDataPullSocket
from PyExpLabSys.common.sockets import DataPushSocket
#from PyExpLabSys.common.sockets import LiveSocket
""" driver """
import PyExpLabSys.drivers.mks_925_pirani as mks_pirani
import PyExpLabSys.drivers.mks_pi_pc as mks_pipc
import credentials
#name = 'stm312 HPC pressure'
#codenames = ['pressure','setpoint']
#socket = DateDataPullSocket(name, codenames)
db_logger_stm312 = ContinuousLogger(
table='dateplots_stm312',
username=credentials.user,
password=credentials.passwd,
measurement_codenames=['stm312_hpc_pressure_controller', 'stm312_pirani'])
#db_logger_ocs = ContinuousLogger(table='dateplots_oldclustersource',
# username='******',
# password='******',
# measurement_codenames = ['pressure'])
class ValueLogger(object):
def __init__(self,
maximumtime=600,
comp_type='lin',
comp_val=1,
codename=None):
self.maximumtime = maximumtime
class MainDatalogger(threading.Thread):
""" Temperature reader """
def __init__(self,):
logging.info('MainDatalogger class started')
threading.Thread.__init__(self)
#from datalogger import TemperatureReader
self.quit = False
self.codenames = ['tabs_guard_temperature_inlet',
'tabs_floor_temperature_inlet',
'tabs_ceiling_temperature_inlet',
'tabs_cooling_temperature_inlet',
]
self.MC302 = WaterTemperatureReader()
self.MC302.start()
self.codenames = [
'tabs_cooling_temperature_inlet',
]
self.omega_temperature = TemperatureReader(['tabs_cooling_temperature_inlet',])
self.omega_temperature.daemon = True
self.omega_temperature.start()
#omega_temperature.update_values()
time.sleep(1.5)
chlist = {'tabs_guard_temperature_control': 0,
'tabs_room_temperature_control': 1,
#'tabs_ceiling_temperature_inlet': 2,
'tabs_cooling_temperature_inlet': 3}
self.loggers = {}
for key in chlist.keys():
self.loggers[key] = ValueLogger(self.omega_temperature, comp_val = 0.2, maximumtime=300,
comp_type = 'lin', channel = chlist[key])
self.loggers[key].start()
chlist = {'tabs_guard_temperature_inlet': 0,
'tabs_guard_temperature_outlet': 1,
'tabs_guard_temperature_delta': 2,
'tabs_floor_temperature_inlet': 3,
'tabs_floor_temperature_outlet': 4,
'tabs_floor_temperature_delta': 5,
'tabs_ceiling_temperature_inlet': 6,
'tabs_ceiling_temperature_outlet': 7,
'tabs_ceiling_temperature_delta': 8,
'tabs_guard_water_flow': 9,
'tabs_floor_water_flow': 10,
'tabs_ceiling_water_flow': 11,}
for key in chlist.keys():
self.loggers[ key] = ValueLogger(self.MC302, comp_val = 0.2, maximumtime=300,
comp_type = 'lin', channel = chlist[key])
self.loggers[key].start()
self.codenames = self.loggers.keys()
#livesocket = LiveSocket('tabs_temperature_logger', codenames, 2)
#livesocket.start()
sockname = 'tabs_temperatures'
self.PullSocket = DateDataPullSocket(sockname, self.codenames, timeouts=[60.0]*len(self.codenames), port = socketinfo.INFO[sockname]['port'])
self.PullSocket.start()
self.db_logger = ContinuousLogger(table='dateplots_tabs', username=credentials.user, password=credentials.passwd, measurement_codenames=self.codenames)
self.db_logger.start()
def run(self,):
i = 0
while not self.quit and self.omega_temperature.isAlive():
try:
#print(i)
time.sleep(1)
for name in self.loggers.keys():
v = self.loggers[name].read_value()
#livesocket.set_point_now(name, v)
if v != None and v != 0:
self.PullSocket.set_point_now(name, v)
if self.loggers[name].read_trigged():
if __name__ == '__main__':
print('Log: ', i, name, v)
self.db_logger.enqueue_point_now(name, v)
self.loggers[name].clear_trigged()
else:
if __name__ == '__main__':
print('STA: ', i, name, v)
except (KeyboardInterrupt, SystemExit):
pass
#self.omega_temperature.close()
#report error and proceed
i += 1
self.stop()
def stop(self):
self.quit = True
self.omega_temperature.stop()
self.MC302.stop()
self.db_logger.stop()
self.PullSocket.stop()
for key in self.codenames:
self.loggers[key].status['quit'] = True
name = 'stm312_pressure'
codenames = [
'stm312_hpc_baratron', 'stm312_prepump_bigturbo',
'stm312_prepump_gashandling', 'stm312_prepump_diff',
'stm312_prepump_loadlock', 'oldclustersource_prepump_aggregation',
'oldclustersource_prepump_quadrupole', 'oldclustersource_iongauge',
'oldclustersource_pirani'
]
socket = DateDataPullSocket(name, codenames, timeouts=[1.0])
socket.start()
live_socket = LiveSocket(name, codenames, 2)
live_socket.start()
db_logger = ContinuousLogger(table='dateplots_stm312',
username=credentials.user,
password=credentials.passwd,
measurement_codenames=codenames)
db_logger.start()
time.sleep(2)
while True:
time.sleep(0.25)
p = logger.read_value()
socket.set_point_now('stm312_hpc_baratron', p)
live_socket.set_point_now('stm312_hpc_baratron', p)
if logger.read_trigged():
print p
db_logger.enqueue_point_now('stm312_hpc_baratron', p)
logger.clear_trigged()
def __init__(self,):
logging.info("MainDatalogger class started")
threading.Thread.__init__(self)
# from datalogger import TemperatureReader
self.quit = False
self.codenames = [
"tabs_guard_temperature_inlet",
"tabs_floor_temperature_inlet",
"tabs_ceiling_temperature_inlet",
"tabs_cooling_temperature_inlet",
]
self.MC302 = WaterTemperatureReader()
self.MC302.start()
self.codenames = ["tabs_cooling_temperature_inlet"]
self.omega_temperature = TemperatureReader(["tabs_cooling_temperature_inlet"])
self.omega_temperature.daemon = True
self.omega_temperature.start()
# omega_temperature.update_values()
time.sleep(1.5)
chlist = {
"tabs_guard_temperature_control": 0,
"tabs_room_temperature_control": 1,
#'tabs_ceiling_temperature_inlet': 2,
"tabs_cooling_temperature_inlet": 3,
}
self.loggers = {}
for key in chlist.keys():
self.loggers[key] = ValueLogger(
self.omega_temperature, comp_val=0.2, maximumtime=300, comp_type="lin", channel=chlist[key]
)
self.loggers[key].start()
chlist = {
"tabs_guard_temperature_inlet": 0,
"tabs_guard_temperature_outlet": 1,
"tabs_guard_temperature_delta": 2,
"tabs_floor_temperature_inlet": 3,
"tabs_floor_temperature_outlet": 4,
"tabs_floor_temperature_delta": 5,
"tabs_ceiling_temperature_inlet": 6,
"tabs_ceiling_temperature_outlet": 7,
"tabs_ceiling_temperature_delta": 8,
"tabs_guard_water_flow": 9,
"tabs_floor_water_flow": 10,
"tabs_ceiling_water_flow": 11,
}
for key in chlist.keys():
self.loggers[key] = ValueLogger(
self.MC302, comp_val=0.2, maximumtime=300, comp_type="lin", channel=chlist[key]
)
self.loggers[key].start()
self.codenames = self.loggers.keys()
# livesocket = LiveSocket('tabs_temperature_logger', codenames, 2)
# livesocket.start()
sockname = "tabs_temperatures"
self.PullSocket = DateDataPullSocket(
sockname, self.codenames, timeouts=[60.0] * len(self.codenames), port=socketinfo.INFO[sockname]["port"]
)
self.PullSocket.start()
self.db_logger = ContinuousLogger(
table="dateplots_tabs",
username=credentials.user,
password=credentials.passwd,
measurement_codenames=self.codenames,
)
self.db_logger.start()
'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, 2)
live_socket.start()
db_logger = ContinuousLogger(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:
v = loggers[name].read_value()
#print 'V: ' + str(v)
socket.set_point_now(name, v)
live_socket.set_point_now(name, v)
if loggers[name].read_trigged():
print v
db_logger.enqueue_point_now(name, v)
comp_val=1.0,
comp_type='lin')
loggers[codenames[1]].start()
socket = DateDataPullSocket(unichr(0x03BC) + '-reactor NG temperature',
codenames,
timeouts=[1.0, 1.0])
socket.start()
livesocket = LiveSocket(
unichr(0x03BC) + '-reactors temperatures', codenames, 2)
livesocket.start()
db_logger = {}
db_logger[codenames[0]] = ContinuousLogger(table='dateplots_microreactorNG',
username=credentials.user_new,
password=credentials.passwd_new,
measurement_codenames=codenames)
db_logger[codenames[1]] = ContinuousLogger(table='dateplots_microreactor',
username=credentials.user_old,
password=credentials.passwd_old,
measurement_codenames=codenames)
db_logger[codenames[0]].start()
db_logger[codenames[1]].start()
while ng_measurement.isAlive():
time.sleep(0.25)
for name in codenames:
v = loggers[name].read_value()
socket.set_point_now(name, v)
livesocket.set_point_now(name, v)
class GasAlarmMonitor(object):
"""Class that monitors the gas alarm the building 312"""
def __init__(self):
# Start logger
codenames = CONF_TO_NAME.values()
self.db_logger = ContinuousLogger(table='dateplots_b312gasalarm',
username=credentials.USERNAME,
password=credentials.PASSWORD,
measurement_codenames=codenames)
self.db_logger.start()
LOGGER.info('Logger started')
# Each value is measured about every 5 sec, so sane interval about 2
self.live_socket = LiveSocket(name='gas_alarm_312_live',
codenames=codenames,
sane_interval=2.0)
self.live_socket.start()
LOGGER.info('Live socket started')
# Start driver
self.vortex = Vortex('/dev/ttyUSB0', 1)
LOGGER.info('Vortex driver opened')
# Init database connection
self.db_connection = MySQLdb.connect(host='servcinf-sql',
user=credentials.USERNAME,
passwd=credentials.PASSWORD,
db='cinfdata')
self.db_cursor = self.db_connection.cursor()
# Initiate static information. All information about the except for
# the list of their numbers are placed in dicts because the numbering
# starts at 1.
# Detector numbers: [1, 2, 3, ..., 12]
self.detector_numbers = range(
1,
self.vortex.get_number_installed_detectors() + 1)
self.detector_info = {
detector_num: self.vortex.detector_configuration(detector_num)
for detector_num in self.detector_numbers
}
pprint(self.detector_info)
# trip_levels are the differences that are required to force a log
# The levels are set to 2 * the communication resolution
# (1000 values / full range)
self.trip_levels = {
detector_num: info.range * 2.0 / 1000.0
for detector_num, info in self.detector_info.items()
}
# Initiate last measured values and their corresponding times
self.detector_levels_last_values = \
{detector_num: - (10 ** 9)
for detector_num in self.detector_numbers}
self.detector_levels_last_times = \
{detector_num: 0 for detector_num in self.detector_numbers}
self.detector_status_last_values = \
{detector_num: {'inhibit': False, 'status': ['OK'],
'codename': self.detector_info[detector_num].identity}
for detector_num in self.detector_numbers}
self.detector_status_last_times = \
{detector_num: 0 for detector_num in self.detector_numbers}
# Initiate variables for system power status
self.central_power_status_last_value = 'OK'
self.central_power_status_last_time = -(10**9)
# Initiate variables for system status
self.central_status_last_value = ['All OK']
self.central_status_last_time = 0
def close(self):
"""Close the logger and the connection to the Vortex"""
self.db_logger.stop()
LOGGER.info('Logger stopped')
self.live_socket.stop()
LOGGER.info('Live socket stopped')
self.vortex.close()
LOGGER.info('Vortex driver closed')
@staticmethod
def conf_to_codename(conf):
"""Convert the identity the sensor returns to the codename used in the
database
"""
conf = '{conf.number} {conf.identity} {conf.unit}'.format(conf=conf)
return CONF_TO_NAME[conf]
def main(self):
"""Main monitoring and logging loop"""
# Each iteration takes about 5 sec
while True:
# Log detectors
for detector_num in self.detector_numbers:
self.log_detector(detector_num)
# Log Vortex unit status (force log every 24 hours)
self.log_central_unit()
def log_detector(self, detector_num):
"""Get the levels from one detector and log if required"""
# Get detector info and levels for this detector
conf = self.detector_info[detector_num]
codename = self.conf_to_codename(conf)
LOGGER.debug('Use detector {} \'{}\''.format(detector_num, codename))
levels = self.vortex.get_detector_levels(detector_num)
LOGGER.debug('Levels read: {}'.format(levels))
# Detector level
now = time.time()
# Always send to live socket
self.live_socket.set_point_now(codename, levels.level)
print detector_num, codename, levels.level
# Force log every 10 m
time_condition = now - self.detector_levels_last_times[
detector_num] > 600
value_condition = abs(self.detector_levels_last_values[detector_num] - levels.level)\
>= self.trip_levels[detector_num]
if time_condition or value_condition:
LOGGER.debug('Send level to db trigged in time: {} or value: '
'{}'.format(time_condition, value_condition))
self.db_logger.enqueue_point(codename, (now, levels.level))
# Update last values
self.detector_levels_last_values[detector_num] = levels.level
self.detector_levels_last_times[detector_num] = now
else:
LOGGER.debug('Level logging condition false')
self.log_detector_status(detector_num, levels, conf)
def log_detector_status(self, detector_num, levels, conf):
"""Sub function to log single detector status"""
now = time.time()
# Force log every 24 hours
time_condition = now - self.detector_status_last_times[
detector_num] > 86400
status = {
'inhibit': levels.inhibit,
'status': levels.status,
'codename': conf.identity
}
value_condition = (status !=
self.detector_status_last_values[detector_num])
print detector_num, status
# Check if we should log
if time_condition or value_condition:
check_in = time_condition and not value_condition
LOGGER.info('Send detector status to db trigged on time: {} or '
'value: {}'.format(time_condition, value_condition))
query = 'INSERT INTO status_b312gasalarm '\
'(time, device, status, check_in) '\
'VALUES (FROM_UNIXTIME(%s), %s, %s, %s);'
values = (now, detector_num, json.dumps(status), check_in)
self._wake_mysql()
self.db_cursor.execute(query, values)
# Update last values
self.detector_status_last_times[detector_num] = now
self.detector_status_last_values[detector_num] = status
else:
LOGGER.debug('Detector status logging condition false')
def log_central_unit(self):
"""Log the status of the central unit"""
power_status = self.vortex.get_system_power_status().value
print "power status", power_status
now = time.time()
# Force a log once per 24 hours
time_condition = now - self.central_power_status_last_time > 86400
value_condition = self.central_power_status_last_value != power_status
LOGGER.debug('Read central power status: \'{}\''.format(power_status))
if time_condition or value_condition:
check_in = time_condition and not value_condition
LOGGER.info('Send power status to db trigged in time: {} or '
'value: {}'.format(time_condition, value_condition))
query = 'INSERT INTO status_b312gasalarm '\
'(time, device, status, check_in) '\
'VALUES (FROM_UNIXTIME(%s), %s, %s, %s);'
values = (now, 255, json.dumps(power_status), check_in)
self._wake_mysql()
self.db_cursor.execute(query, values)
# Update last values
self.central_power_status_last_time = now
self.central_power_status_last_value = power_status
else:
LOGGER.debug('Power status logging condition false')
self.log_central_unit_generel()
def log_central_unit_generel(self):
"""Log the generel status from the central"""
generel_status = self.vortex.get_system_status()
print "general status", generel_status
now = time.time()
# Force a log once per 24 hours
time_condition = now - self.central_status_last_time > 86400
value_condition = generel_status != self.central_status_last_value
LOGGER.debug(
'Read central generel status: \'{}\''.format(generel_status))
if time_condition or value_condition:
check_in = time_condition and not value_condition
LOGGER.info('Send central generel status to db trigged in time: {}'
' or value: {}'.format(time_condition,
value_condition))
query = 'INSERT INTO status_b312gasalarm '\
'(time, device, status, check_in) '\
'VALUES (FROM_UNIXTIME(%s), %s, %s, %s);'
values = (now, 254, json.dumps(generel_status), check_in)
self._wake_mysql()
self.db_cursor.execute(query, values)
# Update last values
self.central_status_last_time = now
self.central_status_last_value = generel_status
else:
LOGGER.debug('Central generel status logging confition false')
def _wake_mysql(self):
"""Send a ping via the connection and re-initialize the cursor"""
self.db_connection.ping(True)
self.db_cursor = self.db_connection.cursor()
self.trigged = True
self.last_recorded_time = time.time()
self.last_recorded_value = self.value
if __name__ == '__main__':
logging.basicConfig(filename="logger.txt", level=logging.ERROR)
logging.basicConfig(level=logging.ERROR)
datasocket = DateDataPullSocket('furnaceroom_reader',
['T1', 'T2', 'S1', 'S2'],
timeouts=[3.0, 3.0, 9999999, 99999999], port=9001)
datasocket.start()
db_logger = ContinuousLogger(table='dateplots_furnaceroom307',
username=credentials.user,
password=credentials.passwd,
measurement_codenames=['fr307_furnace_1_T',
'fr307_furnace_2_T'])
ports = {}
ports[1] = 'usb-FTDI_USB-RS485_Cable_FTWGRL9C-if00-port0'
ports[2] = 'usb-FTDI_USB-RS485_Cable_FTWGRN2W-if00-port0'
furnaces = {}
loggers = {}
for i in [1, 2]:
print i
furnaces[i] = TemperatureReader(ports[i])
furnaces[i].daemon = True
furnaces[i].start()
loggers[i] = TemperatureLogger(furnaces[i])
loggers[i].start()
def __init__(self):
# Start logger
codenames = CONF_TO_NAME.values()
self.db_logger = ContinuousLogger(table='dateplots_b312gasalarm',
username=credentials.USERNAME,
password=credentials.PASSWORD,
measurement_codenames=codenames)
self.db_logger.start()
LOGGER.info('Logger started')
# Each value is measured about every 5 sec, so sane interval about 2
self.live_socket = LiveSocket(name='gas_alarm_312_live',
codenames=codenames,
sane_interval=2.0)
self.live_socket.start()
LOGGER.info('Live socket started')
# Start driver
self.vortex = Vortex('/dev/ttyUSB0', 1)
LOGGER.info('Vortex driver opened')
# Init database connection
self.db_connection = MySQLdb.connect(host='servcinf-sql',
user=credentials.USERNAME,
passwd=credentials.PASSWORD,
db='cinfdata')
self.db_cursor = self.db_connection.cursor()
# Initiate static information. All information about the except for
# the list of their numbers are placed in dicts because the numbering
# starts at 1.
# Detector numbers: [1, 2, 3, ..., 12]
self.detector_numbers = range(
1,
self.vortex.get_number_installed_detectors() + 1)
self.detector_info = {
detector_num: self.vortex.detector_configuration(detector_num)
for detector_num in self.detector_numbers
}
pprint(self.detector_info)
# trip_levels are the differences that are required to force a log
# The levels are set to 2 * the communication resolution
# (1000 values / full range)
self.trip_levels = {
detector_num: info.range * 2.0 / 1000.0
for detector_num, info in self.detector_info.items()
}
# Initiate last measured values and their corresponding times
self.detector_levels_last_values = \
{detector_num: - (10 ** 9)
for detector_num in self.detector_numbers}
self.detector_levels_last_times = \
{detector_num: 0 for detector_num in self.detector_numbers}
self.detector_status_last_values = \
{detector_num: {'inhibit': False, 'status': ['OK'],
'codename': self.detector_info[detector_num].identity}
for detector_num in self.detector_numbers}
self.detector_status_last_times = \
{detector_num: 0 for detector_num in self.detector_numbers}
# Initiate variables for system power status
self.central_power_status_last_value = 'OK'
self.central_power_status_last_time = -(10**9)
# Initiate variables for system status
self.central_status_last_value = ['All OK']
self.central_status_last_time = 0
class MainDatalogger(threading.Thread):
""" Temperature reader """
def __init__(self,):
logging.info("MainDatalogger class started")
threading.Thread.__init__(self)
# from datalogger import TemperatureReader
self.quit = False
self.codenames = [
"tabs_guard_temperature_inlet",
"tabs_floor_temperature_inlet",
"tabs_ceiling_temperature_inlet",
"tabs_cooling_temperature_inlet",
]
self.MC302 = WaterTemperatureReader()
self.MC302.start()
self.codenames = ["tabs_cooling_temperature_inlet"]
self.omega_temperature = TemperatureReader(["tabs_cooling_temperature_inlet"])
self.omega_temperature.daemon = True
self.omega_temperature.start()
# omega_temperature.update_values()
time.sleep(1.5)
chlist = {
"tabs_guard_temperature_control": 0,
"tabs_room_temperature_control": 1,
#'tabs_ceiling_temperature_inlet': 2,
"tabs_cooling_temperature_inlet": 3,
}
self.loggers = {}
for key in chlist.keys():
self.loggers[key] = ValueLogger(
self.omega_temperature, comp_val=0.2, maximumtime=300, comp_type="lin", channel=chlist[key]
)
self.loggers[key].start()
chlist = {
"tabs_guard_temperature_inlet": 0,
"tabs_guard_temperature_outlet": 1,
"tabs_guard_temperature_delta": 2,
"tabs_floor_temperature_inlet": 3,
"tabs_floor_temperature_outlet": 4,
"tabs_floor_temperature_delta": 5,
"tabs_ceiling_temperature_inlet": 6,
"tabs_ceiling_temperature_outlet": 7,
"tabs_ceiling_temperature_delta": 8,
"tabs_guard_water_flow": 9,
"tabs_floor_water_flow": 10,
"tabs_ceiling_water_flow": 11,
}
for key in chlist.keys():
self.loggers[key] = ValueLogger(
self.MC302, comp_val=0.2, maximumtime=300, comp_type="lin", channel=chlist[key]
)
self.loggers[key].start()
self.codenames = self.loggers.keys()
# livesocket = LiveSocket('tabs_temperature_logger', codenames, 2)
# livesocket.start()
sockname = "tabs_temperatures"
self.PullSocket = DateDataPullSocket(
sockname, self.codenames, timeouts=[60.0] * len(self.codenames), port=socketinfo.INFO[sockname]["port"]
)
self.PullSocket.start()
self.db_logger = ContinuousLogger(
table="dateplots_tabs",
username=credentials.user,
password=credentials.passwd,
measurement_codenames=self.codenames,
)
self.db_logger.start()
def run(self,):
i = 0
while not self.quit and self.omega_temperature.isAlive():
try:
# print(i)
time.sleep(1)
for name in self.loggers.keys():
v = self.loggers[name].read_value()
# livesocket.set_point_now(name, v)
if v != None and v != 0:
self.PullSocket.set_point_now(name, v)
if self.loggers[name].read_trigged():
if __name__ == "__main__":
print("Log: ", i, name, v)
self.db_logger.enqueue_point_now(name, v)
self.loggers[name].clear_trigged()
else:
if __name__ == "__main__":
print("STA: ", i, name, v)
except (KeyboardInterrupt, SystemExit):
pass
# self.omega_temperature.close()
# report error and proceed
i += 1
self.stop()
def stop(self):
self.quit = True
self.omega_temperature.stop()
self.MC302.stop()
self.db_logger.stop()
self.PullSocket.stop()
for key in self.codenames:
self.loggers[key].status["quit"] = True
self.setpoint = 0
self.set_filament_voltage(0)
#self.set_bias(0)
if __name__ == '__main__':
ec = EmissionControl()
#ec.set_bias(35)
ec.start()
logger = ValueLogger(ec, comp_val = 1, comp_type='log')
logger.start()
CODENAMES = ['tof_emission_value']
db_logger = ContinuousLogger(table='dateplots_tof',
username=credentials.user,
password=credentials.passwd,
measurement_codenames=CODENAMES)
db_logger.start()
tui = emission_tui.CursesTui(ec)
tui.daemon = True
tui.start()
time.sleep(10)
while ec.running:
time.sleep(1)
value = logger.read_value()
if logger.read_trigged():
LOGGER.debug('Logged value: ' + str(value))
db_logger.enqueue_point_now('tof_emission_value', value)
logger.clear_trigged()
self.last_recorded_time = time.time()
meas_time = sqlTime()
val = "%.2f" % temp
sql = "insert into temperature_oldclustersource set time=\"" + meas_time + "\", temperature = " + val
print sql
OCSsqlInsert(sql)
if __name__ == '__main__':
quit = False
pullsocket = DateDataPullSocket('stm312 hptemp',
['stm312_hp_temperature'],
timeouts=[4.0])
pullsocket.start()
db_logger = ContinuousLogger(table='dateplots_stm312',
username=credentials.user,
password=credentials.passwd,
measurement_codenames=['stm312_hpc_temperature'])
db_logger.start()
tc_reader = omega.ISeries('/dev/ttyUSB0',
9600,
comm_stnd='rs485')
temperature_reader = Reader(tc_reader, pullsocket)
temperature_reader.start()
time.sleep(5)
hp_saver = HighPressureTemperatureSaver(temperature_reader, db_logger)
hp_saver.start()
#stm_saver = STMTemperatureSaver(stm_reader)
#stm_saver.start()
reactor_logger = ReactorLogger(maximumtime=600)
reactor_logger.start()
chamber_logger = PressureLogger(reader, 0)
buffer_logger = PressureLogger(reader, 1, maximumtime=1200)
chamber_logger.start()
buffer_logger.start()
socket = DateDataSocket(['chamber_pressure', 'buffer_pressure'], timeouts=[1.0, 1.0])
socket.start()
livesocket = LiveSocket(['chamber_pressure', 'buffer_pressure'], 2)
livesocket.start()
db_logger = ContinuousLogger(table='dateplots_mgw', username=credentials.user, password=credentials.passwd, measurement_codenames=['mgw_pressure_chamber', 'mgw_pressure_buffer','mgw_reactor_pressure'])
db_logger.start()
time.sleep(5)
while True:
c = chamber_logger.read_pressure()
b = buffer_logger.read_pressure()
r = reactor_logger.value
socket.set_point_now('chamber_pressure', c)
socket.set_point_now('buffer_pressure', b)
livesocket.set_point_now('chamber_pressure', c)
livesocket.set_point_now('buffer_pressure', b)
if reactor_logger.trigged:
print(r)
db_logger.enqueue_point_now('mgw_reactor_pressure', r)
reactor_logger.trigged = False
from PyExpLabSys.common.sockets import DataPushSocket
#from PyExpLabSys.common.sockets import LiveSocket
""" driver """
import PyExpLabSys.drivers.mks_925_pirani as mks_pirani
import PyExpLabSys.drivers.mks_pi_pc as mks_pipc
import credentials
#name = 'stm312 HPC pressure'
#codenames = ['pressure','setpoint']
#socket = DateDataPullSocket(name, codenames)
db_logger_stm312 = ContinuousLogger(table='dateplots_stm312',
username=credentials.user,
password=credentials.passwd,
measurement_codenames=['stm312_hpc_pressure_controller','stm312_pirani'])
#db_logger_ocs = ContinuousLogger(table='dateplots_oldclustersource',
# username='******',
# password='******',
# measurement_codenames = ['pressure'])
class ValueLogger(object):
def __init__(self, maximumtime=600,
comp_type='lin',
comp_val=1,
codename=None):
self.maximumtime = maximumtime
self.compare = {'type':comp_type, 'val':comp_val}
self.codename = codename
class MainMultilogger(threading.Thread):
""" Temperature reader """
def __init__(self, ):
logging.info('MainMultilogger class started')
threading.Thread.__init__(self)
#from datalogger import TemperatureReader
self.quit = False
self.codenames = Setting_channel_list.keys()
"""['tabs_ceiling_temperature_delta',
'tabs_ceiling_temperature_deltaref',
'tabs_floor_temperature_delta',
'tabs_floor_temperature_deltaref',
'tabs_room_temperature_aircenter010',
'tabs_room_temperature_aircenter060',
'tabs_room_temperature_aircenter110',
'tabs_room_temperature_aircenter170',
'tabs_room_temperature_aircenter355',
'tabs_guard_temperature_airfloor',
'tabs_guard_temperature_airceiling',
'tabs_guard_temperature_airwallsouth',
'tabs_guard_temperature_airwallnorth',
'tabs_guard_temperature_airwalleast',
'tabs_guard_temperature_airwallwest',
]"""
self.multiplex_reader = MultiplexReader(self.codenames)
self.multiplex_reader.daemon = True
self.multiplex_reader.start()
#omega_temperature.update_values()
time.sleep(3.5)
chlist = Setting_channel_list
self.loggers = {}
for key in self.codenames:
self.loggers[key] = ValueLogger(self.multiplex_reader,
comp_val=0.5,
maximumtime=300,
comp_type='lin',
channel=chlist[key])
self.loggers[key].start()
#livesocket = LiveSocket('tabs_temperature_logger', codenames, 2)
#livesocket.start()
sockname = 'tabs_multiplexer'
self.PullSocket = DateDataPullSocket(
sockname,
self.codenames,
timeouts=[60.0] * len(self.codenames),
port=socketinfo.INFO[sockname]['port'])
self.PullSocket.start()
self.db_logger = ContinuousLogger(table='dateplots_tabs',
username=credentials.user,
password=credentials.passwd,
measurement_codenames=self.codenames)
self.db_logger.start()
def run(self, ):
i = 0
while not self.quit and self.multiplex_reader.isAlive():
try:
#print(i)
time.sleep(1)
for name in self.codenames:
v = self.loggers[name].read_value()
#livesocket.set_point_now(name, v)
self.PullSocket.set_point_now(name, v)
#print(i, name, v)
if self.loggers[name].read_trigged(
) and abs(v) < 9.9E+5 and v != None:
if __name__ == '__main__':
print('Log: ', i, name, v)
#print(name, v)
self.db_logger.enqueue_point_now(name, v)
self.loggers[name].clear_trigged()
except (KeyboardInterrupt, SystemExit):
self.quit = True
pass
#self.omega_temperature.close()
#report error and proceed
i += 1
self.stop()
def stop(self):
self.quit = True
self.multiplex_reader.stop()
self.PullSocket.stop()
self.db_logger.stop()
for key in self.codenames:
self.loggers[key].status['quit'] = True
class GasAlarmMonitor(object):
"""Class that monitors the gas alarm the building 307"""
def __init__(self):
# Start logger
codenames = ['B307_gasalarm_CO_051', 'B307_gasalarm_H2_051',
'B307_gasalarm_CO_055', 'B307_gasalarm_H2_055',
'B307_gasalarm_CO_059', 'B307_gasalarm_H2_059',
'B307_gasalarm_CO_061', 'B307_gasalarm_H2_061',
'B307_gasalarm_CO_42-43', 'B307_gasalarm_H2_2sal',
'B307_gasalarm_CO_932', 'B307_gasalarm_H2_932']
self.db_logger = ContinuousLogger(table='dateplots_b307gasalarm',
username=credentials.USERNAME,
password=credentials.PASSWORD,
measurement_codenames=codenames)
self.db_logger.start()
LOGGER.info('Logger started')
# Each value is measured about every 5 sec, so sane interval about 2
self.live_socket = LiveSocket(name='gas_alarm_307_live',
codenames=codenames,
sane_interval=2.0)
self.live_socket.start()
LOGGER.info('Live socket started')
# Start driver
self.vortex = Vortex('/dev/ttyUSB0', 1)
LOGGER.info('Vortex driver opened')
# Init database connection
self.db_connection = MySQLdb.connect(
host='servcinf', user=credentials.USERNAME,
passwd=credentials.PASSWORD, db='cinfdata')
self.db_cursor = self.db_connection.cursor()
# Initiate static information. All information about the except for
# the list of their numbers are placed in dicts because the numbering
# starts at 1.
# Detector numbers: [1, 2, 3, ..., 12]
self.detector_numbers = \
range(1, self.vortex.get_number_installed_detectors() + 1)
self.detector_info = \
{detector_num: self.vortex.detector_configuration(detector_num)
for detector_num in self.detector_numbers}
# trip_levels are the differences that are required to force a log
# The levels are set to 2 * the communication resolution
# (1000 values / full range)
self.trip_levels = {detector_num: info.range * 2.0 / 1000.0 for
detector_num, info in self.detector_info.items()}
# Initiate last measured values and their corresponding times
self.detector_levels_last_values = \
{detector_num: - (10 ** 9)
for detector_num in self.detector_numbers}
self.detector_levels_last_times = \
{detector_num: 0 for detector_num in self.detector_numbers}
self.detector_status_last_values = \
{detector_num: {'inhibit': False, 'status': ['OK'],
'codename': self.detector_info[detector_num].identity}
for detector_num in self.detector_numbers}
self.detector_status_last_times = \
{detector_num: 0 for detector_num in self.detector_numbers}
# Initiate variables for system power status
self.central_power_status_last_value = 'OK'
self.central_power_status_last_time = - (10 ** 9)
# Initiate variables for system status
self.central_status_last_value = ['All OK']
self.central_status_last_time = 0
def close(self):
"""Close the logger and the connection to the Vortex"""
self.db_logger.stop()
LOGGER.info('Logger stopped')
self.live_socket.stop()
LOGGER.info('Live socket stopped')
self.vortex.close()
LOGGER.info('Vortex driver closed')
@staticmethod
def identity_to_codename(identity):
"""Convert the identity the sensor returns to the codename used in the
database
"""
identity = identity.replace(' ', '_').replace('/', '-')
return 'B307_gasalarm_{}'.format(identity)
def main(self):
"""Main monitoring and logging loop"""
# Each iteration takes about 5 sec
while True:
# Log detectors
for detector_num in self.detector_numbers:
self.log_detector(detector_num)
# Log Vortex unit status (force log every 24 hours)
self.log_central_unit()
def log_detector(self, detector_num):
"""Get the levels from one detector and log if required"""
# Get detector info and levels for this detector
conf = self.detector_info[detector_num]
codename = self.identity_to_codename(conf.identity)
LOGGER.debug('Use detector {} \'{}\''.format(detector_num, codename))
levels = self.vortex.get_detector_levels(detector_num)
LOGGER.debug('Levels read: {}'.format(levels))
# Detector level
now = time.time()
# Always send to live socket
self.live_socket.set_point_now(codename, levels.level)
# Force log every 10 m
time_condition = \
now - self.detector_levels_last_times[detector_num] > 600
value_condition = \
abs(self.detector_levels_last_values[detector_num] - levels.level)\
>= self.trip_levels[detector_num]
if time_condition or value_condition:
LOGGER.debug('Send level to db trigged in time: {} or value: '
'{}'.format(time_condition, value_condition))
self.db_logger.enqueue_point(codename, (now, levels.level))
# Update last values
self.detector_levels_last_values[detector_num] = levels.level
self.detector_levels_last_times[detector_num] = now
else:
LOGGER.debug('Level logging condition false')
self.log_detector_status(detector_num, levels, conf)
def log_detector_status(self, detector_num, levels, conf):
"""Sub function to log single detector status"""
now = time.time()
# Force log every 24 hours
time_condition = \
now - self.detector_status_last_times[detector_num] > 86400
status = {'inhibit': levels.inhibit, 'status': levels.status,
'codename': conf.identity}
value_condition = \
(status != self.detector_status_last_values[detector_num])
# Check if we should log
if time_condition or value_condition:
check_in = time_condition and not value_condition
LOGGER.info('Send detector status to db trigged on time: {} or '
'value: {}'.format(time_condition, value_condition))
query = 'INSERT INTO status_b307gasalarm '\
'(time, device, status, check_in) '\
'VALUES (FROM_UNIXTIME(%s), %s, %s, %s);'
values = (now, detector_num, json.dumps(status), check_in)
self._wake_mysql()
self.db_cursor.execute(query, values)
# Update last values
self.detector_status_last_times[detector_num] = now
self.detector_status_last_values[detector_num] = status
else:
LOGGER.debug('Detector status logging condition false')
def log_central_unit(self):
"""Log the status of the central unit"""
power_status = self.vortex.get_system_power_status().value
now = time.time()
# Force a log once per 24 hours
time_condition = now - self.central_power_status_last_time > 86400
value_condition = self.central_power_status_last_value != power_status
LOGGER.debug('Read central power status: \'{}\''.format(power_status))
if time_condition or value_condition:
check_in = time_condition and not value_condition
LOGGER.info('Send power status to db trigged in time: {} or '
'value: {}'.format(time_condition, value_condition))
query = 'INSERT INTO status_b307gasalarm '\
'(time, device, status, check_in) '\
'VALUES (FROM_UNIXTIME(%s), %s, %s, %s);'
values = (now, 255, json.dumps(power_status), check_in)
self._wake_mysql()
self.db_cursor.execute(query, values)
# Update last values
self.central_power_status_last_time = now
self.central_power_status_last_value = power_status
else:
LOGGER.debug('Power status logging condition false')
self.log_central_unit_generel()
def log_central_unit_generel(self):
"""Log the generel status from the central"""
generel_status = self.vortex.get_system_status()
now = time.time()
# Force a log once per 24 hours
time_condition = now - self.central_status_last_time > 86400
value_condition = generel_status != self.central_status_last_value
LOGGER.debug(
'Read central generel status: \'{}\''.format(generel_status))
if time_condition or value_condition:
check_in = time_condition and not value_condition
LOGGER.info('Send central generel status to db trigged in time: {}'
' or value: {}'.format(time_condition,
value_condition))
query = 'INSERT INTO status_b307gasalarm '\
'(time, device, status, check_in) '\
'VALUES (FROM_UNIXTIME(%s), %s, %s, %s);'
values = (now, 254, json.dumps(generel_status), check_in)
self._wake_mysql()
self.db_cursor.execute(query, values)
# Update last values
self.central_status_last_time = now
self.central_status_last_value = generel_status
else:
LOGGER.debug('Central generel status logging confition false')
def _wake_mysql(self):
"""Send a ping via the connection and re-initialize the cursor"""
self.db_connection.ping(True)
self.db_cursor = self.db_connection.cursor()
'stm312_prepump_bigturbo',
'stm312_prepump_gashandling',
'stm312_prepump_diff',
'stm312_prepump_loadlock',
'oldclustersource_prepump_aggregation',
'oldclustersource_prepump_quadrupole',
'oldclustersource_iongauge',
'oldclustersource_pirani']
socket = DateDataPullSocket(name, codenames, timeouts=[1.0])
socket.start()
live_socket = LiveSocket(name, codenames, 2)
live_socket.start()
db_logger = ContinuousLogger(table='dateplots_stm312',
username=credentials.user,
password=credentials.passwd,
measurement_codenames=codenames)
db_logger.start()
time.sleep(2)
while True:
time.sleep(0.25)
p = logger.read_value()
socket.set_point_now('stm312_hpc_baratron', p)
live_socket.set_point_now('stm312_hpc_baratron', p)
if logger.read_trigged():
print p
db_logger.enqueue_point_now('stm312_hpc_baratron', p)
logger.clear_trigged()
class GasAlarmMonitor(object):
"""Class that monitors the gas alarm the building 307"""
def __init__(self):
# Start logger
codenames = [
'B307_gasalarm_CO_051', 'B307_gasalarm_H2_051',
'B307_gasalarm_CO_055', 'B307_gasalarm_H2_055',
'B307_gasalarm_CO_059', 'B307_gasalarm_H2_059',
'B307_gasalarm_CO_061', 'B307_gasalarm_H2_061',
'B307_gasalarm_CO_42-43', 'B307_gasalarm_H2_2sal',
'B307_gasalarm_CO_932', 'B307_gasalarm_H2_932'
]
self.db_logger = ContinuousLogger(table='dateplots_b307gasalarm',
username=credentials.USERNAME,
password=credentials.PASSWORD,
measurement_codenames=codenames)
self.db_logger.start()
LOGGER.info('Logger started')
# Each value is measured about every 5 sec, so sane interval about 2
self.live_socket = LiveSocket(name='gas_alarm_307_live',
codenames=codenames)
self.live_socket.start()
LOGGER.info('Live socket started')
# Start driver
self.vortex = Vortex('/dev/ttyUSB0', 1)
LOGGER.info('Vortex driver opened')
# Init database connection
self.db_connection = MySQLdb.connect(host='servcinf-sql.fysik.dtu.dk',
user=credentials.USERNAME,
passwd=credentials.PASSWORD,
db='cinfdata')
self.db_cursor = self.db_connection.cursor()
# Initiate static information. All information about the except for
# the list of their numbers are placed in dicts because the numbering
# starts at 1.
# Detector numbers: [1, 2, 3, ..., 12]
self.detector_numbers = \
range(1, self.vortex.get_number_installed_detectors() + 1)
self.detector_info = \
{detector_num: self.vortex.detector_configuration(detector_num)
for detector_num in self.detector_numbers}
# trip_levels are the differences that are required to force a log
# The levels are set to 2 * the communication resolution
# (1000 values over the full range)
# NOTE. Since we have had a lot of noise on the CO channels, we
# increased the level to info.range * 7.0 / 1000.0 for those
#self.trip_levels = {detector_num: info.range * 2.0 / 1000.0 for
# detector_num, info in self.detector_info.items()}
self.trip_levels = {}
for detector_number, info in self.detector_info.items():
if info.unit == "PPM":
self.trip_levels[detector_number] = info.range * 7.0 / 1000.0
else:
self.trip_levels[detector_number] = info.range * 2.0 / 1000.0
# Initiate last measured values and their corresponding times
self.detector_levels_last_values = \
{detector_num: - (10 ** 9)
for detector_num in self.detector_numbers}
self.detector_levels_last_times = \
{detector_num: 0 for detector_num in self.detector_numbers}
self.detector_status_last_values = \
{detector_num: {'inhibit': False, 'status': ['OK'],
'codename': self.detector_info[detector_num].identity}
for detector_num in self.detector_numbers}
self.detector_status_last_times = \
{detector_num: 0 for detector_num in self.detector_numbers}
# Initiate variables for system power status
self.central_power_status_last_value = 'OK'
self.central_power_status_last_time = -(10**9)
# Initiate variables for system status
self.central_status_last_value = ['All OK']
self.central_status_last_time = 0
def close(self):
"""Close the logger and the connection to the Vortex"""
self.db_logger.stop()
LOGGER.info('Logger stopped')
self.live_socket.stop()
LOGGER.info('Live socket stopped')
self.vortex.close()
LOGGER.info('Vortex driver closed')
@staticmethod
def identity_to_codename(identity):
"""Convert the identity the sensor returns to the codename used in the
database
"""
# NOTE The identities was changed at some point, which is the reason where there
# is this manual mingling with name. The current names are:
# 'CO 51', 'H2 51', 'CO 55', 'H2 55', 'CO 59', 'H2 61', 'CO 61', 'H2 61',
# 'CO 42/43', 'H2 2 sal', 'CO 932', 'H2 932'
# and they need to be changed to the codenames in codenames (in __init__)
#first, second = identity.split(' ', 1)
#if len(second) == 2:
# second = '0' + second
#identity = first + ' ' + second
#identity = identity.replace('2 sal', '2sal').replace(' ', '_').replace('/', '-')
identity = identity.replace(' ', '_').replace('/', '-')
return 'B307_gasalarm_{}'.format(identity)
def main(self):
"""Main monitoring and logging loop"""
# Each iteration takes about 5 sec
while True:
# Log detectors
for detector_num in self.detector_numbers:
self.log_detector(detector_num)
# Log Vortex unit status (force log every 24 hours)
self.log_central_unit()
def log_detector(self, detector_num):
"""Get the levels from one detector and log if required"""
# Get detector info and levels for this detector
conf = self.detector_info[detector_num]
codename = self.identity_to_codename(conf.identity)
##### HACK HACK HACK FIXME There is a duplicate name error in the configuration
# which for now we fix here in code
#if codename == "B307_gasalarm_H2_061" and detector_num == 6:
# codename = "B307_gasalarm_H2_059"
##### HACK HACK HACK FIXME
LOGGER.debug('Use detector {} \'{}\''.format(detector_num, codename))
levels = self.vortex.get_detector_levels(detector_num)
LOGGER.debug('Levels read: {}'.format(levels))
# Detector level
now = time.time()
# Always send to live socket
self.live_socket.set_point_now(codename, levels.level)
# Force log every 10 m
time_condition = \
now - self.detector_levels_last_times[detector_num] > 600
value_condition = \
abs(self.detector_levels_last_values[detector_num] - levels.level)\
>= self.trip_levels[detector_num]
if time_condition or value_condition:
LOGGER.debug('Send level to db trigged in time: {} or value: '
'{}'.format(time_condition, value_condition))
self.db_logger.enqueue_point(codename, (now, levels.level))
# Update last values
self.detector_levels_last_values[detector_num] = levels.level
self.detector_levels_last_times[detector_num] = now
else:
LOGGER.debug('Level logging condition false')
self.log_detector_status(detector_num, levels, conf)
def log_detector_status(self, detector_num, levels, conf):
"""Sub function to log single detector status"""
now = time.time()
# Force log every 24 hours
time_condition = \
now - self.detector_status_last_times[detector_num] > 86400
status = {
'inhibit': levels.inhibit,
'status': levels.status,
'codename': conf.identity
}
##### HACK HACK HACK FIXME There is a duplicate name error in the configuration
if detector_num == 6 and status['codename'] == 'H2 61':
status['codename'] = 'H2 59'
##### HACK HACK HACK FIXME
value_condition = \
(status != self.detector_status_last_values[detector_num])
# Check if we should log
if time_condition or value_condition:
check_in = time_condition and not value_condition
LOGGER.info('Send detector status to db trigged on time: {} or '
'value: {}'.format(time_condition, value_condition))
query = 'INSERT INTO status_b307gasalarm '\
'(time, device, status, check_in) '\
'VALUES (FROM_UNIXTIME(%s), %s, %s, %s);'
values = (now, detector_num, json.dumps(status), check_in)
self._wake_mysql()
self.db_cursor.execute(query, values)
# Update last values
self.detector_status_last_times[detector_num] = now
self.detector_status_last_values[detector_num] = status
else:
LOGGER.debug('Detector status logging condition false')
def log_central_unit(self):
"""Log the status of the central unit"""
power_status = self.vortex.get_system_power_status().value
now = time.time()
# Force a log once per 24 hours
time_condition = now - self.central_power_status_last_time > 86400
value_condition = self.central_power_status_last_value != power_status
LOGGER.debug('Read central power status: \'{}\''.format(power_status))
if time_condition or value_condition:
check_in = time_condition and not value_condition
LOGGER.info('Send power status to db trigged in time: {} or '
'value: {}'.format(time_condition, value_condition))
query = 'INSERT INTO status_b307gasalarm '\
'(time, device, status, check_in) '\
'VALUES (FROM_UNIXTIME(%s), %s, %s, %s);'
values = (now, 255, json.dumps(power_status), check_in)
self._wake_mysql()
self.db_cursor.execute(query, values)
# Update last values
self.central_power_status_last_time = now
self.central_power_status_last_value = power_status
else:
LOGGER.debug('Power status logging condition false')
self.log_central_unit_generel()
def log_central_unit_generel(self):
"""Log the generel status from the central"""
generel_status = self.vortex.get_system_status()
now = time.time()
# Force a log once per 24 hours
time_condition = now - self.central_status_last_time > 86400
value_condition = generel_status != self.central_status_last_value
LOGGER.debug(
'Read central generel status: \'{}\''.format(generel_status))
if time_condition or value_condition:
check_in = time_condition and not value_condition
LOGGER.info('Send central generel status to db trigged in time: {}'
' or value: {}'.format(time_condition,
value_condition))
query = 'INSERT INTO status_b307gasalarm '\
'(time, device, status, check_in) '\
'VALUES (FROM_UNIXTIME(%s), %s, %s, %s);'
values = (now, 254, json.dumps(generel_status), check_in)
self._wake_mysql()
self.db_cursor.execute(query, values)
# Update last values
self.central_status_last_time = now
self.central_status_last_value = generel_status
else:
LOGGER.debug('Central generel status logging confition false')
def _wake_mysql(self):
"""Send a ping via the connection and re-initialize the cursor"""
self.db_connection.ping(True)
self.db_cursor = self.db_connection.cursor()
from datetime import datetime
import PyExpLabSys.drivers.cpx400dp as CPX
#from PyExpLabSys.common.sockets import DateDataPullSocket
#from PyExpLabSys.common.sockets import DataPushSocket
from PyExpLabSys.common.loggers import ContinuousLogger
import credentials
EXCCEPTION = None
log = open('error_log.txt', 'w')
#output = 'print'
#output = 'curses'
db_logger = ContinuousLogger(
table='dateplots_stm312',
username=credentials.user,
password=credentials.passwd,
measurement_codenames=['stm312_hpc_psu_voltage', 'stm312_hpc_psu_current'])
class PID(object):
"""Implementation of a PID routine
"""
def __init__(self, case=None):
"""The input parameter case is used to simplify that several
system is sharing the software, each with it own parametors."""
if case == None:
self.gain = {
'Kp': 0.15,
'Ki': 0.0025,
'Kd': 0.0,
logging.basicConfig(filename="logger.txt", level=logging.ERROR)
logging.basicConfig(level=logging.ERROR)
pc_measurement = PcClass()
pc_measurement.start()
pressure_measurement = PiraniClass()
pressure_measurement.start()
time.sleep(2)
datasocket = DateDataSocket(['pirani', 'pc'], timeouts=[1.0, 1.0])
datasocket.start()
db_logger = ContinuousLogger(table='dateplots_stm312', username='******', password='******', measurement_codenames=['stm312_pirani', 'stm312_pc'])
db_logger.start()
while True:
pirani = pressure_measurement.read_pressure()
pc = pc_measurement.read_pressure()
datasocket.set_point_now('pirani', pirani)
datasocket.set_point_now('pc', pc)
if pressure_measurement.trigged:
print(pirani)
db_logger.enqueue_point_now('stm312_pirani', pirani)
pressure_measurement.trigged = False
if pc_measurement.trigged:
print(pc)
db_logger.enqueue_point_now('stm312_pc', pc)
port=9000)
Datasocket.start()
Pushsocket = DataPushSocket('microreactor_mfc_control', action='enqueue')
Pushsocket.start()
Livesocket = LiveSocket('microreactor_mfc_control', devices)
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()
db_logger = ContinuousLogger(table='dateplots_microreactor',
username=credentials.user,
password=credentials.passwd,
measurement_codenames=['mr_reactor_pressure'])
db_logger.start()
time.sleep(5)
while True:
time.sleep(0.25)
v = Logger.read_value()
if Logger.read_trigged():
print v
db_logger.enqueue_point_now('mr_reactor_pressure', v)
Logger.clear_trigged()
temp_loggers[i] = TemperatureLogger(tempreader, i + 1)
temp_loggers[i].start()
temp_codenames = ['vhp_T_reactor_inlet',
'vhp_T_reactor_outlet',
'vhp_T_reactor_top',
'vhp_T_mass_spec',
'vhp_T_gas_lines',
'vhp_T_purifying_reactor',
'vhp_T_furnace']
socket = DateDataPullSocket('vhp', ['vhp_mass_spec_pressure'] + temp_codenames, timeouts=[1.0, 1.0, 1.0, 1.0, 1.0, 1.0, 1.0, 1.0])
socket.start()
db_logger = ContinuousLogger(table='dateplots_vhp_setup',
username=credentials.user,
password=credentials.passwd,
measurement_codenames=['vhp_mass_spec_pressure'] + temp_codenames)
db_logger.start()
time.sleep(5)
while True:
time.sleep(0.25)
for i in range(0, 7):
t = temp_loggers[i].read_value()
socket.set_point_now(temp_codenames[i], t)
if temp_loggers[i].trigged:
print t
db_logger.enqueue_point_now(temp_codenames[i], t)
temp_loggers[i].trigged = False
c = chamber_logger.read_pressure()
socket.set_point_now('vhp_mass_spec_pressure', c)
class MainPID(threading.Thread):
""" pid controller """
def __init__(self, ):
logging.info('MainPID class started')
threading.Thread.__init__(self)
#from datalogger import TemperatureReader
self.quit = False
self.codenames = [
'tabs_guard_pid_value',
'tabs_floor_pid_value',
'tabs_ceiling_pid_value',
'tabs_cooling_pid_value',
'tabs_guard_valve_heating',
'tabs_floor_valve_heating',
'tabs_ceiling_valve_heating',
'tabs_guard_valve_cooling',
'tabs_floor_valve_cooling',
'tabs_ceiling_valve_cooling',
'tabs_cooling_valve_cooling',
]
sockname = 'tabs_pids'
self.PullSocket = DateDataPullSocket(
sockname,
self.codenames,
timeouts=[60.0] * len(self.codenames),
port=socketinfo.INFO[sockname]['port'])
self.PullSocket.start()
self.PTC = PidTemperatureControl(self.codenames)
self.PTC.daemon = True
self.PTC.start()
#time.sleep(5)
chlist = {
'tabs_guard_pid_value': 0,
'tabs_floor_pid_value': 1,
'tabs_ceiling_pid_value': 2,
'tabs_cooling_pid_value': 3,
'tabs_guard_valve_heating': 4,
'tabs_floor_valve_heating': 5,
'tabs_ceiling_valve_heating': 6,
'tabs_guard_valve_cooling': 7,
'tabs_floor_valve_cooling': 8,
'tabs_ceiling_valve_cooling': 9,
'tabs_cooling_valve_cooling': 10
}
self.loggers = {}
for key in self.codenames:
self.loggers[key] = ValueLogger(self.PTC,
comp_val=0.10,
maximumtime=60,
comp_type='lin',
channel=chlist[key])
self.loggers[key].start()
#livesocket = LiveSocket('tabs_temperature_logger', codenames, 2)
#livesocket.start()
self.db_logger = ContinuousLogger(table='dateplots_tabs',
username=credentials.user,
password=credentials.passwd,
measurement_codenames=self.codenames)
self.db_logger.start()
def run(self, ):
i = 0
while not self.quit and self.PTC.isAlive():
try:
#print(i)
time.sleep(1)
for name in self.codenames:
v = self.loggers[name].read_value()
#print('Status: ', name , v)
#livesocket.set_point_now(name, v)
self.PullSocket.set_point_now(name, v)
if self.loggers[name].read_trigged():
if __name__ == '__main__':
print('Log: ', i, name, v)
#print(i, name, v)
self.db_logger.enqueue_point_now(name, v)
self.loggers[name].clear_trigged()
except (KeyboardInterrupt, SystemExit):
self.quit = True
pass
#self.PTC.stop()
#report error and proceed
i += 1
self.stop()
def stop(self):
self.quit = True
self.PTC.stop()
self.PullSocket.stop()
self.db_logger.stop()
for key in self.codenames:
self.loggers[key].status['quit'] = True
class MainPID(threading.Thread):
""" pid controller """
def __init__(self,):
logging.info('MainPID class started')
threading.Thread.__init__(self)
#from datalogger import TemperatureReader
self.quit = False
self.codenames = ['tabs_guard_pid_value',
'tabs_floor_pid_value',
'tabs_ceiling_pid_value',
'tabs_cooling_pid_value',
'tabs_guard_valve_heating',
'tabs_floor_valve_heating',
'tabs_ceiling_valve_heating',
'tabs_guard_valve_cooling',
'tabs_floor_valve_cooling',
'tabs_ceiling_valve_cooling',
'tabs_cooling_valve_cooling',
]
sockname = 'tabs_pids'
self.PullSocket = DateDataPullSocket(sockname, self.codenames, timeouts=[60.0]*len(self.codenames), port = socketinfo.INFO[sockname]['port'])
self.PullSocket.start()
self.PTC = PidTemperatureControl(self.codenames)
self.PTC.daemon = True
self.PTC.start()
#time.sleep(5)
chlist = {'tabs_guard_pid_value': 0,
'tabs_floor_pid_value': 1,
'tabs_ceiling_pid_value': 2,
'tabs_cooling_pid_value': 3,
'tabs_guard_valve_heating': 4,
'tabs_floor_valve_heating': 5,
'tabs_ceiling_valve_heating': 6,
'tabs_guard_valve_cooling': 7,
'tabs_floor_valve_cooling': 8,
'tabs_ceiling_valve_cooling': 9,
'tabs_cooling_valve_cooling': 10}
self.loggers = {}
for key in self.codenames:
self.loggers[key] = ValueLogger(self.PTC, comp_val = 0.10, maximumtime=60,
comp_type = 'lin', channel = chlist[key])
self.loggers[key].start()
#livesocket = LiveSocket('tabs_temperature_logger', codenames, 2)
#livesocket.start()
self.db_logger = ContinuousLogger(table='dateplots_tabs', username=credentials.user, password=credentials.passwd, measurement_codenames=self.codenames)
self.db_logger.start()
def run(self,):
i = 0
while not self.quit and self.PTC.isAlive():
try:
#print(i)
time.sleep(1)
for name in self.codenames:
v = self.loggers[name].read_value()
#print('Status: ', name , v)
#livesocket.set_point_now(name, v)
self.PullSocket.set_point_now(name, v)
if self.loggers[name].read_trigged():
if __name__ == '__main__':
print('Log: ', i, name, v)
#print(i, name, v)
self.db_logger.enqueue_point_now(name, v)
self.loggers[name].clear_trigged()
except (KeyboardInterrupt, SystemExit):
self.quit = True
pass
#self.PTC.stop()
#report error and proceed
i += 1
self.stop()
def stop(self):
self.quit = True
self.PTC.stop()
self.PullSocket.stop()
self.db_logger.stop()
for key in self.codenames:
self.loggers[key].status['quit'] = True
class MainTui(threading.Thread):
""" Temperature reader """
def __init__(self, ):
threading.Thread.__init__(self)
#from mytui import CursesTui
self.quit = False
self.codenames = [
'tabs_guard_temperature_setpoint',
'tabs_floor_temperature_setpoint',
'tabs_ceiling_temperature_setpoint',
'tabs_cooling_temperature_setpoint',
]
sockname = 'tabs_setpoints'
self.PullSocket = DateDataPullSocket(
sockname,
self.codenames,
timeouts=[60.0] * len(self.codenames),
port=socketinfo.INFO[sockname]['port'])
self.PullSocket.start()
self.TUI = CursesTui(self.codenames)
self.TUI.daemon = True
self.TUI.start()
#time.sleep(5)
chlist = {
'tabs_guard_temperature_setpoint': 0,
'tabs_floor_temperature_setpoint': 1,
'tabs_ceiling_temperature_setpoint': 2,
'tabs_cooling_temperature_setpoint': 3
}
self.loggers = {}
for key in self.codenames:
self.loggers[key] = ValueLogger(self.TUI,
comp_val=0.2,
maximumtime=60,
comp_type='lin',
channel=chlist[key])
self.loggers[key].start()
#livesocket = LiveSocket('tabs_temperature_logger', codenames, 2)
#livesocket.start()
self.db_logger = ContinuousLogger(table='dateplots_tabs',
username=credentials.user,
password=credentials.passwd,
measurement_codenames=self.codenames)
#print('Hostname of db logger: ' + db_logger.host)
self.db_logger.start()
def run(self):
i = 0
while not self.quit:
#print(i)
if self.TUI.isAlive():
pass
else:
print('TUI has shutdown')
self.quit = True
try:
#print(i)
time.sleep(2)
for name in self.codenames:
v = self.loggers[name].read_value()
#print('Status: ', name , v)
#livesocket.set_point_now(name, v)
self.PullSocket.set_point_now(name, v)
if self.loggers[name].read_trigged():
#if __name__ == '__main__':
# print('Log: ', i, name, v)
#print('Log: ', name, v)
self.db_logger.enqueue_point_now(name, v)
self.loggers[name].clear_trigged()
except:
print('run error')
pass
#self.TUI.stop()
#report error and proceed
i += 1
self.stop()
def stop(self):
self.quit = True
self.TUI.stop()
self.PullSocket.stop()
self.db_logger.stop()
for key in self.codenames:
self.loggers[key].status['quit'] = True
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=9001, timeouts=[5.0] * len(codenames))
socket.start()
db_logger = ContinuousLogger(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:
v = loggers[name].read_value()
socket.set_point_now(name, v)
if loggers[name].read_trigged():
print v
db_logger.enqueue_point_now(name, v)
loggers[name].clear_trigged()
Logger = ValueLogger(fc,
comp_val=1,
comp_type='log',
low_comp=0.0001,
channel=1)
Logger.start()
Sniffer_Logger = ValueLogger(fc,
comp_val=1,
comp_type='log',
low_comp=0.0001,
channel=2)
Sniffer_Logger.start()
db_logger = ContinuousLogger(table='dateplots_microreactor',
username=credentials.user,
password=credentials.passwd,
measurement_codenames=['mr_reactor_pressure'])
db_logger.start()
db_logger_sniffer = ContinuousLogger(
table='dateplots_sniffer',
username=credentials_sniffer.user,
password=credentials_sniffer.passwd,
measurement_codenames=['sniffer_chip_pressure'])
db_logger_sniffer.start()
time.sleep(5)
while True:
time.sleep(0.25)
v = Logger.read_value()
if Logger.read_trigged():
print v
self.last_recorded_value = temp
self.last_recorded_time = time.time()
meas_time = sqlTime()
val = "%.2f" % temp
sql = 'insert into temperature_oldclustersource set time="' + meas_time + '", temperature = ' + val
print sql
OCSsqlInsert(sql)
if __name__ == "__main__":
quit = False
pullsocket = DateDataPullSocket("stm312 hptemp", ["stm312_hp_temperature"], timeouts=[4.0])
pullsocket.start()
db_logger = ContinuousLogger(
table="dateplots_stm312",
username=credentials.user,
password=credentials.passwd,
measurement_codenames=["stm312_hpc_temperature"],
)
db_logger.start()
tc_reader = omega.ISeries("/dev/ttyUSB0", 9600, comm_stnd="rs485")
temperature_reader = Reader(tc_reader, pullsocket)
temperature_reader.start()
time.sleep(5)
hp_saver = HighPressureTemperatureSaver(temperature_reader, db_logger)
hp_saver.start()
# stm_saver = STMTemperatureSaver(stm_reader)
# stm_saver.start()
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, comp_val=1, comp_type='log', low_comp=0.0001, channel=2)
Sniffer_Logger.start()
db_logger = ContinuousLogger(table='dateplots_microreactor',
username=credentials.user,
password=credentials.passwd,
measurement_codenames=['mr_reactor_pressure'])
db_logger.start()
db_logger_sniffer = ContinuousLogger(table='dateplots_sniffer',
username=credentials_sniffer.user,
password=credentials_sniffer.passwd,
measurement_codenames=['sniffer_chip_pressure'])
db_logger_sniffer.start()
time.sleep(5)
while True:
time.sleep(0.25)
v = Logger.read_value()
if Logger.read_trigged():
print v
db_logger.enqueue_point_now('mr_reactor_pressure', v)
class MainTui(threading.Thread):
""" Temperature reader """
def __init__(self,):
threading.Thread.__init__(self)
#from mytui import CursesTui
self.quit = False
self.codenames = ['tabs_guard_temperature_setpoint',
'tabs_floor_temperature_setpoint',
'tabs_ceiling_temperature_setpoint',
'tabs_cooling_temperature_setpoint',
]
sockname = 'tabs_setpoints'
self.PullSocket = DateDataPullSocket(sockname, self.codenames, timeouts=[60.0]*len(self.codenames), port = socketinfo.INFO[sockname]['port'])
self.PullSocket.start()
self.TUI = CursesTui(self.codenames)
self.TUI.start()
#time.sleep(5)
chlist = {'tabs_guard_temperature_setpoint': 0,
'tabs_floor_temperature_setpoint': 1,
'tabs_ceiling_temperature_setpoint': 2,
'tabs_cooling_temperature_setpoint': 3}
self.loggers = {}
for key in self.codenames:
self.loggers[key] = ValueLogger(self.TUI, comp_val = 0.2, maximumtime=60,
comp_type = 'lin', channel = chlist[key])
self.loggers[key].start()
#livesocket = LiveSocket('tabs_temperature_logger', codenames, 2)
#livesocket.start()
self.db_logger = ContinuousLogger(table='dateplots_tabs', username=credentials.user, password=credentials.passwd, measurement_codenames=self.codenames)
#print('Hostname of db logger: ' + db_logger.host)
self.db_logger.start()
def run(self):
i = 0
while not self.quit:
#print(i)
if self.TUI.isAlive():
pass
else:
print('TUI has shutdown')
self.quit = True
try:
#print(i)
time.sleep(2)
for name in self.codenames:
v = self.loggers[name].read_value()
#print('Status: ', name , v)
#livesocket.set_point_now(name, v)
self.PullSocket.set_point_now(name, v)
if self.loggers[name].read_trigged():
#if __name__ == '__main__':
# print('Log: ', i, name, v)
#print('Log: ', name, v)
self.db_logger.enqueue_point_now(name, v)
self.loggers[name].clear_trigged()
except:
print('run error')
pass
#self.TUI.stop()
#report error and proceed
i += 1
self.stop()
def stop(self):
self.quit = True
self.TUI.stop()
self.PullSocket.stop()
self.db_logger.stop()
for key in self.codenames:
self.loggers[key].status['quit'] = True
temp_bottom_logger.daemon = True
temp_bottom_logger.start()
temp_bearings_logger = tp.TurboLogger(reader, 'temp_bearings', maximumtime=600)
temp_bearings_logger.daemon = True
temp_bearings_logger.start()
temp_motor_logger = tp.TurboLogger(reader, 'temp_motor', maximumtime=600)
temp_motor_logger.daemon = True
temp_motor_logger.start()
# Todo: change port number
#livesocket = LiveSocket([chamber_turbo_speed', 'chamber_turbo_power'], 2)
#livesocket.start()
db_logger = ContinuousLogger(table='dateplots_mgw', username=credentials.user, password=credentials.passwd, measurement_codenames=['mgw_chamber_turbo_speed', 'mgw_chamber_turbo_power', 'mgw_chamber_turbo_temp_motor', 'mgw_chamber_turbo_temp_bottom', 'mgw_chamber_turbo_temp_bearings', 'mgw_chamber_turbo_temp_electronics', 'mgw_chamber_turbo_current'])
db_logger.start()
time.sleep(5)
while mainpump.running:
ts = rotation_logger.read_value()
power = power_logger.read_value()
current = current_logger.read_value()
temp_elec = temp_electronics_logger.read_value()
temp_bottom = temp_bottom_logger.read_value()
temp_bearings = temp_bearings_logger.read_value()
temp_motor = temp_motor_logger.read_value()
#livesocket.set_point_now('chamber_turbo_speed', ts)
if rotation_logger.trigged:
db_logger.enqueue_point_now('mgw_chamber_turbo_speed', ts)
pressure_codenames = ['pvd309_main_chamber_ig',
'pvd309_main_chamber_pirani',
'pvd309_load_lock_pirani']
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
self.trigged = True
self.last_recorded_time = time.time()
self.last_recorded_value = self.pressure
logging.basicConfig(filename="logger.txt", level=logging.ERROR)
logging.basicConfig(level=logging.ERROR)
pressure_measurement = XGSClass()
pressure_measurement.start()
time.sleep(2.5)
socket = DateDataSocket(['pressure'], timeouts=[1.0])
socket.start()
#livesocket = LiveSocket(['pressure'], 2)
#livesocket.start()
db_logger = ContinuousLogger(table='dateplots_ps', username='******', password='******', measurement_codenames=['ps_chamber_pressure'])
db_logger.start()
while True:
time.sleep(0.25)
p = pressure_measurement.read_pressure()
socket.set_point_now('pressure', p)
#livesocket.set_point_now('pressure', p)
if pressure_measurement.trigged:
print(p)
db_logger.enqueue_point_now('ps_chamber_pressure', p)
pressure_measurement.trigged = False
