def test_enqueue_point(self): """Test the continous logger by sending data with timestamps""" # Make timestamps to use number_of_points = 10 start = time.time() times = [start + increment for increment in range(number_of_points)] # Form the lists for local storage of data, for tests data1 = [] data2 = [] # Init the db_saver db_saver = ContinuousDataSaver('dateplots_dummy', 'dummy', 'dummy', ['dummy_sine_one', 'dummy_sine_two']) db_saver.start() # Save the points for now in times: value = math.sin(now) data1.append([now, value]) db_saver.save_point('dummy_sine_one', (now, value)) value = math.sin(now + math.pi) data2.append([now, value]) db_saver.save_point('dummy_sine_two', (now, value)) # Make sure the queue has been cleared while db_saver.sql_saver.queue.qsize() > 0: time.sleep(0.01) # Get the measurement code numbers from the logger codes = (db_saver.codename_translation['dummy_sine_one'], db_saver.codename_translation['dummy_sine_two']) # Check if the data has been properly written to the db for data, code in zip((data1, data2), codes): query = 'SELECT UNIX_TIMESTAMP(time), value FROM dateplots_dummy '\ 'WHERE type={} ORDER BY id DESC LIMIT {}'\ .format(code, number_of_points) CURSOR.execute(query) fetched = reversed(CURSOR.fetchall()) for point_original, point_control in zip(data, fetched): # Time is rounded, so it is only correct to within ~0.51 s assert np.isclose(point_original[0], point_control[0], atol=0.51) assert np.isclose(point_original[1], point_control[1]) db_saver.stop()
def test_enqueue_point(self): """Test the continous logger by sending data with timestamps""" # Make timestamps to use number_of_points = 10 start = time.time() times = [start + increment for increment in range(number_of_points)] # Form the lists for local storage of data, for tests data1 = [] data2 = [] # Init the db_saver db_saver = ContinuousDataSaver("dateplots_dummy", "dummy", "dummy", ["dummy_sine_one", "dummy_sine_two"]) db_saver.start() # Save the points for now in times: value = math.sin(now) data1.append([now, value]) db_saver.save_point("dummy_sine_one", (now, value)) value = math.sin(now + math.pi) data2.append([now, value]) db_saver.save_point("dummy_sine_two", (now, value)) # Make sure the queue has been cleared while db_saver.sql_saver.queue.qsize() > 0: time.sleep(0.01) # Get the measurement code numbers from the logger codes = (db_saver.codename_translation["dummy_sine_one"], db_saver.codename_translation["dummy_sine_two"]) # Check if the data has been properly written to the db for data, code in zip((data1, data2), codes): query = ( "SELECT UNIX_TIMESTAMP(time), value FROM dateplots_dummy " "WHERE type={} ORDER BY id DESC LIMIT {}".format(code, number_of_points) ) CURSOR.execute(query) fetched = reversed(CURSOR.fetchall()) for point_original, point_control in zip(data, fetched): # Time is rounded, so it is only correct to within ~0.51 s assert np.isclose(point_original[0], point_control[0], atol=0.51) assert np.isclose(point_original[1], point_control[1]) db_saver.stop()
class GasAlarmMonitor(object): """Class that monitors the gas alarm the building 312""" def __init__(self): # Start logger codenames = list(CONF_TO_NAME.values()) self.db_saver = ContinuousDataSaver( continuous_data_table='dateplots_b312gasalarm', username=credentials.USERNAME, password=credentials.PASSWORD, measurement_codenames=codenames, ) self.db_saver.start() LOGGER.info('Logger started') # Init live socket self.live_socket = LiveSocket(name='gas_alarm_312_live', codenames=codenames) self.live_socket.start() LOGGER.info('Live socket started') # Start driver self.vortex = Vortex('/dev/serial/by-id/usb-FTDI_USB-RS485_Cable_FTWGRKRA-if00-port0', 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} # 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_saver.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) # 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_saver.save_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_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 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() 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()
class GasAlarmMonitor(object): """Class that monitors the gas alarm the building 312""" def __init__(self): # Start logger codenames = list(CONF_TO_NAME.values()) self.db_saver = ContinuousDataSaver( continuous_data_table='dateplots_b312gasalarm', username=credentials.USERNAME, password=credentials.PASSWORD, measurement_codenames=codenames, ) self.db_saver.start() LOGGER.info('Logger started') # Init live socket self.live_socket = LiveSocket(name='gas_alarm_312_live', codenames=codenames) self.live_socket.start() LOGGER.info('Live socket started') # Start driver self.vortex = Vortex( '/dev/serial/by-id/usb-FTDI_USB-RS485_Cable_FTWGRKRA-if00-port0', 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 } # 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_saver.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) # 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_saver.save_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_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 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() 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()