def loop(self): if self.timer_loop > time.time(): return while self.timer_loop < time.time(): self.timer_loop += self.period last_measurement_a = self.get_last_measurement( self.select_measurement_a_device_id, self.select_measurement_a_measurement_id, max_age=self.measurement_max_age_a) if last_measurement_a: self.logger.debug("Most recent timestamp and measurement for " "Measurement A: {timestamp}, {meas}".format( timestamp=last_measurement_a[0], meas=last_measurement_a[1])) else: self.logger.debug( "Could not find a measurement in the database for " "Measurement A in the past {} seconds".format( self.measurement_max_age_a)) last_measurement_b = self.get_last_measurement( self.select_measurement_b_device_id, self.select_measurement_b_measurement_id, max_age=self.measurement_max_age_b) if last_measurement_b: self.logger.debug("Most recent timestamp and measurement for " "Measurement B: {timestamp}, {meas}".format( timestamp=last_measurement_b[0], meas=last_measurement_b[1])) else: self.logger.debug( "Could not find a measurement in the database for " "Measurement B in the past {} seconds".format( self.measurement_max_age_b)) if last_measurement_a and last_measurement_b: if self.difference_reverse_order: difference = last_measurement_b[1] - last_measurement_a[1] else: difference = last_measurement_a[1] - last_measurement_b[1] if self.difference_absolute: difference = abs(difference) self.logger.debug("Output: {}".format(difference)) write_influxdb_value( self.unique_id, self.channels_measurement[0].unit, value=difference, measure=self.channels_measurement[0].measurement, channel=0)
def loop(self): if self.timer_loop > time.time(): return while self.timer_loop < time.time(): self.timer_loop += self.period # Get last measurement for select_measurement_1 last_measurement = self.get_last_measurement( self.select_measurement_device_id, self.select_measurement_measurement_id, max_age=self.measurement_max_age) if last_measurement: self.logger.debug("Most recent timestamp and measurement for " "Measurement A: {timestamp}, {meas}".format( timestamp=last_measurement[0], meas=last_measurement[1])) else: self.logger.debug( "Could not find a measurement in the database for " "Measurement A device ID {} and measurement " "ID {} in the past {} seconds".format( self.select_measurement_device_id, self.select_measurement_measurement_id, self.measurement_max_age)) # Perform equation and save to DB here if last_measurement: equation_str = self.equation equation_str = equation_str.replace("x", str(last_measurement[1])) self.logger.debug("Equation: {} = {}".format( self.equation, equation_str)) equation_output = eval(equation_str) self.logger.debug("Output: {}".format(equation_output)) write_influxdb_value( self.unique_id, self.channels_measurement[0].unit, value=equation_output, measure=self.channels_measurement[0].measurement, channel=0) else: self.logger.debug( "A measurement could not be found within the Max Age. Not calculating." )
def post(self, unique_id, unit, channel, value): """Create a measurement""" if not utils_general.user_has_permission('edit_controllers'): abort(403) if channel < 0: abort(422, custom='channel must be >= 0') try: value = float(value) except: abort(422, custom='value does not represent a float') timestamp = None if ns_measurement.payload and 'timestamp' in ns_measurement.payload: ts = ns_measurement.payload["timestamp"] if ts is not None: if valid_date_str(ts): timestamp = datetime.datetime.strptime( ts, '%Y-%m-%dT%H:%M:%S.%fZ') else: abort(422, custom='Invalid timestamp format. Must be formatted as %Y-%m-%dT%H:%M:%S.%fZ') try: return_ = write_influxdb_value( unique_id, unit, value, channel=channel, timestamp=timestamp) if return_: abort(500) else: return {'message': 'Success'}, 200 except Exception: abort(500, message='An exception occurred', error=traceback.format_exc())
def loop(self): if self.timer_loop > time.time(): return while self.timer_loop < time.time(): self.timer_loop += self.period measure = [] for each_id_set in self.select_measurement: device_device_id = each_id_set.split(",")[0] device_measure_id = each_id_set.split(",")[1] device_measurement = get_measurement(device_measure_id) if not device_measurement: self.logger.error("Could not find Device Measurement") return conversion = db_retrieve_table_daemon( Conversion, unique_id=device_measurement.conversion_id) channel, unit, measurement = return_measurement_info( device_measurement, conversion) last_measurement = read_last_influxdb( device_device_id, unit, channel, measure=measurement, duration_sec=self.max_measure_age) if not last_measurement: self.logger.error( "Could not find measurement within the set Max Age for Device {} and Measurement {}" .format(device_device_id, device_measure_id)) if self.halt_on_missing_measure: self.logger.debug( "Instructed to halt on the first missing measurement. Halting." ) return False else: measure.append(last_measurement[1]) if len(measure) > 1: stat_mean = float(sum(measure) / float(len(measure))) stat_median = median(measure) stat_minimum = min(measure) stat_maximum = max(measure) stdev_ = stdev(measure) stdev_mean_upper = stat_mean + stdev_ stdev_mean_lower = stat_mean - stdev_ list_measurement = [ stat_mean, stat_median, stat_minimum, stat_maximum, stdev_, stdev_mean_upper, stdev_mean_lower ] for each_channel, each_measurement in self.channels_measurement.items( ): if each_measurement.is_enabled: channel, unit, measurement = return_measurement_info( each_measurement, self.channels_conversion[each_channel]) self.logger.debug( "Saving {} to channel {} with measurement {} and unit {}" .format(list_measurement[each_channel], each_channel, measurement, unit)) write_influxdb_value(self.unique_id, unit, value=list_measurement[each_channel], measure=measurement, channel=each_channel) else: self.logger.debug( "Less than 2 measurements found within Max Age. " "Calculations need at least 2 measurements. Not calculating.")
def loop(self): if self.timer_loop > time.time(): return while self.timer_loop < time.time(): self.timer_loop += self.period # Get last measurement for select_measurement_1 last_measurement_a = self.get_last_measurement( self.select_measurement_a_device_id, self.select_measurement_a_measurement_id, max_age=self.measurement_a_max_age) if last_measurement_a: self.logger.debug("Most recent timestamp and measurement for " "Measurement A: {timestamp}, {meas}".format( timestamp=last_measurement_a[0], meas=last_measurement_a[1])) else: self.logger.debug( "Could not find a measurement in the database for " "Measurement A device ID {} and measurement " "ID {} in the past {} seconds".format( self.select_measurement_a_device_id, self.select_measurement_a_measurement_id, self.measurement_a_max_age)) last_measurement_b = self.get_last_measurement( self.select_measurement_b_device_id, self.select_measurement_b_measurement_id, max_age=self.measurement_b_max_age) if last_measurement_b: self.logger.debug("Most recent timestamp and measurement for " "Measurement B: {timestamp}, {meas}".format( timestamp=last_measurement_b[0], meas=last_measurement_b[1])) else: self.logger.debug( "Could not find a measurement in the database for " "Measurement B device ID {} and measurement " "ID {} in the past {} seconds".format( self.select_measurement_b_device_id, self.select_measurement_b_measurement_id, self.measurement_b_max_age)) last_measurement_c = self.get_last_measurement( self.select_measurement_c_device_id, self.select_measurement_c_measurement_id, max_age=self.measurement_c_max_age) if last_measurement_c: self.logger.debug("Most recent timestamp and measurement for " "Measurement C: {timestamp}, {meas}".format( timestamp=last_measurement_c[0], meas=last_measurement_c[1])) else: self.logger.debug( "Could not find a measurement in the database for " "Measurement C device ID {} and measurement " "ID {} in the past {} seconds".format( self.select_measurement_c_device_id, self.select_measurement_c_measurement_id, self.measurement_c_max_age)) if last_measurement_a or last_measurement_b or last_measurement_c: if last_measurement_a: self.logger.debug("Using Measurement A") measurement_store = last_measurement_a[1] elif last_measurement_b: self.logger.debug("Using Measurement B") measurement_store = last_measurement_b[1] elif last_measurement_c: self.logger.debug("Using Measurement C") measurement_store = last_measurement_c[1] else: self.logger.debug( "Could not find a measurement in the specified time frames for Measurements A, B, or C" ) return write_influxdb_value( self.unique_id, self.channels_measurement[0].unit, value=measurement_store, measure=self.channels_measurement[0].measurement, channel=0) else: self.logger.debug( "No measurements could not be found within the Max Age.")
def download_data(self): self.logger.debug("Downloading Data") # Clear data previously stored in dictionary self.gadget.loggedDataReadout = {'Temp': {}, 'Humi': {}} # Download stored data starting from self.gadget.newestTimeStampMs self.gadget.readLoggedDataInterval( startMs=self.gadget.newestTimeStampMs) while self.running: if (not self.gadget.waitForNotifications(5) or not self.gadget.isLogReadoutInProgress()): break # Done reading data self.logger.debug("Downloaded Data") self.logger.debug("Parsing/saving data") list_timestamps_temp = [] list_timestamps_humi = [] # Store logged temperature self.logger.debug("Storing {} temperatures".format(len(self.gadget.loggedDataReadout['Temp']))) for each_ts, each_measure in self.gadget.loggedDataReadout['Temp'].items(): if not self.running: break if -40 > each_measure or each_measure > 125: continue # Temperature outside acceptable range list_timestamps_temp.append(each_ts) if self.is_enabled(0): datetime_ts = datetime.datetime.utcfromtimestamp(each_ts / 1000) measurement_single = { 0: { 'measurement': 'temperature', 'unit': 'C', 'value': each_measure } } measurement_single = parse_measurement( self.channels_conversion[0], self.channels_measurement[0], measurement_single, self.channels_measurement[0].channel, measurement_single[0]) write_influxdb_value( self.unique_id, measurement_single[0]['unit'], value=measurement_single[0]['value'], measure=measurement_single[0]['measurement'], channel=0, timestamp=datetime_ts) # Store logged humidity self.logger.debug("Storing {} humidities".format(len(self.gadget.loggedDataReadout['Humi']))) for each_ts, each_measure in self.gadget.loggedDataReadout['Humi'].items(): if not self.running: break if 0 >= each_measure or each_measure > 100: continue # Humidity outside acceptable range list_timestamps_humi.append(each_ts) if self.is_enabled(1): datetime_ts = datetime.datetime.utcfromtimestamp(each_ts / 1000) measurement_single = { 1: { 'measurement': 'humidity', 'unit': 'percent', 'value': each_measure } } measurement_single = parse_measurement( self.channels_conversion[1], self.channels_measurement[1], measurement_single, self.channels_measurement[1].channel, measurement_single[1]) write_influxdb_value( self.unique_id, measurement_single[1]['unit'], value=measurement_single[1]['value'], measure=measurement_single[1]['measurement'], channel=1, timestamp=datetime_ts) # Find common timestamps from both temperature and humidity lists list_timestamps_both = list(set(list_timestamps_temp).intersection(list_timestamps_humi)) self.logger.debug("Calculating/storing {} dewpoint and vpd".format(len(list_timestamps_both))) for each_ts in list_timestamps_both: if not self.running: break temperature = self.gadget.loggedDataReadout['Temp'][each_ts] humidity = self.gadget.loggedDataReadout['Humi'][each_ts] if (-200 > temperature or temperature > 200) or (0 > humidity or humidity > 100): continue # Measurement outside acceptable range datetime_ts = datetime.datetime.utcfromtimestamp(each_ts / 1000) # Calculate and store dew point if self.is_enabled(3) and self.is_enabled(0) and self.is_enabled(1): dewpoint = calculate_dewpoint(temperature, humidity) measurement_single = { 3: { 'measurement': 'dewpoint', 'unit': 'C', 'value': dewpoint } } measurement_single = parse_measurement( self.channels_conversion[3], self.channels_measurement[3], measurement_single, self.channels_measurement[3].channel, measurement_single[3]) write_influxdb_value( self.unique_id, measurement_single[3]['unit'], value=measurement_single[3]['value'], measure=measurement_single[3]['measurement'], channel=3, timestamp=datetime_ts) # Calculate and store vapor pressure deficit if self.is_enabled(4) and self.is_enabled(0) and self.is_enabled(1): vpd = calculate_vapor_pressure_deficit(temperature, humidity) measurement_single = { 4: { 'measurement': 'vapor_pressure_deficit', 'unit': 'Pa', 'value': vpd } } measurement_single = parse_measurement( self.channels_conversion[4], self.channels_measurement[4], measurement_single, self.channels_measurement[4].channel, measurement_single[4]) write_influxdb_value( self.unique_id, measurement_single[4]['unit'], value=measurement_single[4]['value'], measure=measurement_single[4]['measurement'], channel=4, timestamp=datetime_ts) # Download successfully finished, set newest timestamp self.gadget.newestTimeStampMs = self.gadget.tmp_newestTimeStampMs self.logger.debug("Parsed/saved data")
def loop(self): if self.timer_loop < time.time(): while self.timer_loop < time.time(): self.timer_loop += self.period measure = [] for each_id_set in self.select_measurement: device_device_id = each_id_set.split(",")[0] device_measure_id = each_id_set.split(",")[1] device_measurement = get_measurement(device_measure_id) if not device_measurement: self.logger.error("Could not find Device Measurement") return conversion = db_retrieve_table_daemon( Conversion, unique_id=device_measurement.conversion_id) channel, unit, measurement = return_measurement_info( device_measurement, conversion) last_measurement = read_last_influxdb( device_device_id, unit, channel, measure=measurement, duration_sec=self.max_measure_age) if not last_measurement: self.logger.error( "Could not find measurement within the set Max Age for Device {} and Measurement {}" .format(device_device_id, device_measure_id)) return False else: measure.append(last_measurement[1]) stat_mean = float(sum(measure) / float(len(measure))) stat_median = median(measure) stat_minimum = min(measure) stat_maximum = max(measure) stdev_ = stdev(measure) stdev_mean_upper = stat_mean + stdev_ stdev_mean_lower = stat_mean - stdev_ list_measurement = [ stat_mean, stat_median, stat_minimum, stat_maximum, stdev_, stdev_mean_upper, stdev_mean_lower ] for each_measurement in self.device_measurements.all(): if each_measurement.is_enabled: conversion = db_retrieve_table_daemon( Conversion, unique_id=each_measurement.conversion_id) channel, unit, measurement = return_measurement_info( each_measurement, conversion) write_influxdb_value(self.unique_id, unit, value=list_measurement[channel], measure=measurement, channel=0)
def loop(self): if self.timer_loop < time.time(): while self.timer_loop < time.time(): self.timer_loop += self.period # Get last measurement for select_measurement_1 last_measurement_a = self.get_last_measurement( self.select_measurement_a_device_id, self.select_measurement_a_measurement_id, max_age=self.measurement_a_max_age) if last_measurement_a: self.logger.debug( "Most recent timestamp and measurement for " "select_measurement_a: {timestamp}, {meas}".format( timestamp=last_measurement_a[0], meas=last_measurement_a[1])) else: self.logger.debug( "Could not find a measurement in the database for " "select_measurement_a device ID {} and measurement " "ID {} in the past {} seconds".format( self.select_measurement_a_device_id, self.select_measurement_a_measurement_id, self.measurement_a_max_age)) last_measurement_b = self.get_last_measurement( self.select_measurement_b_device_id, self.select_measurement_b_measurement_id, max_age=self.measurement_b_max_age) if last_measurement_b: self.logger.debug( "Most recent timestamp and measurement for " "select_measurement_b: {timestamp}, {meas}".format( timestamp=last_measurement_b[0], meas=last_measurement_b[1])) else: self.logger.debug( "Could not find a measurement in the database for " "select_measurement_b device ID {} and measurement " "ID {} in the past {} seconds".format( self.select_measurement_b_device_id, self.select_measurement_b_measurement_id, self.measurement_b_max_age)) # Perform equation and save to DB here if last_measurement_a and last_measurement_b: equation_str = self.equation equation_str = equation_str.replace("a", str(last_measurement_a[1])) equation_str = equation_str.replace("b", str(last_measurement_b[1])) self.logger.debug("Equation: {} = {}".format( self.equation, equation_str)) equation_output = eval(equation_str) self.logger.debug("Output: {}".format(equation_output)) write_influxdb_value( self.unique_id, self.channels_measurement[0].unit, value=equation_output, measure=self.channels_measurement[0].measurement, channel=0)
def download_data(self): # Clear data previously stored in dictionary self.gadget.loggedDataReadout = {'Temp': {}, 'Humi': {}} # Download stored data starting from self.gadget.newestTimeStampMs self.gadget.readLoggedDataInterval( startMs=self.gadget.newestTimeStampMs) while self.running: if (not self.gadget.waitForNotifications(5) or not self.gadget.isLogReadoutInProgress()): break # Done reading data list_timestamps_temp = [] list_timestamps_humi = [] # Store logged temperature measurement = self.device_measurements.filter( DeviceMeasurements.channel == 0).first() conversion = db_retrieve_table_daemon( Conversion, unique_id=measurement.conversion_id) for each_ts, each_measure in self.gadget.loggedDataReadout[ 'Temp'].items(): list_timestamps_temp.append(each_ts) datetime_ts = datetime.datetime.utcfromtimestamp(each_ts / 1000) if self.is_enabled(0): measurement_single = { 0: { 'measurement': 'temperature', 'unit': 'C', 'value': each_measure } } measurement_single = parse_measurement(conversion, measurement, measurement_single, measurement.channel, measurement_single[0]) write_influxdb_value( self.unique_id, measurement_single[0]['unit'], value=measurement_single[0]['value'], measure=measurement_single[0]['measurement'], channel=0, timestamp=datetime_ts) # Store logged humidity measurement = self.device_measurements.filter( DeviceMeasurements.channel == 1).first() conversion = db_retrieve_table_daemon( Conversion, unique_id=measurement.conversion_id) for each_ts, each_measure in self.gadget.loggedDataReadout[ 'Humi'].items(): list_timestamps_humi.append(each_ts) datetime_ts = datetime.datetime.utcfromtimestamp(each_ts / 1000) if self.is_enabled(1): measurement_single = { 1: { 'measurement': 'humidity', 'unit': 'percent', 'value': each_measure } } measurement_single = parse_measurement(conversion, measurement, measurement_single, measurement.channel, measurement_single[1]) write_influxdb_value( self.unique_id, measurement_single[1]['unit'], value=measurement_single[1]['value'], measure=measurement_single[1]['measurement'], channel=1, timestamp=datetime_ts) # Find common timestamps from both temperature and humidity lists list_timestamps_both = list( set(list_timestamps_temp).intersection(list_timestamps_humi)) for each_ts in list_timestamps_both: datetime_ts = datetime.datetime.utcfromtimestamp(each_ts / 1000) # Calculate and store dew point if (self.is_enabled(3) and self.is_enabled(0) and self.is_enabled(1)): measurement = self.device_measurements.filter( DeviceMeasurements.channel == 3).first() conversion = db_retrieve_table_daemon( Conversion, unique_id=measurement.conversion_id) dewpoint = calculate_dewpoint( self.gadget.loggedDataReadout['Temp'][each_ts], self.gadget.loggedDataReadout['Humi'][each_ts]) measurement_single = { 3: { 'measurement': 'dewpoint', 'unit': 'C', 'value': dewpoint } } measurement_single = parse_measurement(conversion, measurement, measurement_single, measurement.channel, measurement_single[3]) write_influxdb_value( self.unique_id, measurement_single[3]['unit'], value=measurement_single[3]['value'], measure=measurement_single[3]['measurement'], channel=3, timestamp=datetime_ts) # Calculate and store vapor pressure deficit if (self.is_enabled(4) and self.is_enabled(0) and self.is_enabled(1)): measurement = self.device_measurements.filter( DeviceMeasurements.channel == 4).first() conversion = db_retrieve_table_daemon( Conversion, unique_id=measurement.conversion_id) vpd = calculate_vapor_pressure_deficit( self.gadget.loggedDataReadout['Temp'][each_ts], self.gadget.loggedDataReadout['Humi'][each_ts]) measurement_single = { 4: { 'measurement': 'vapor_pressure_deficit', 'unit': 'Pa', 'value': vpd } } measurement_single = parse_measurement(conversion, measurement, measurement_single, measurement.channel, measurement_single[4]) write_influxdb_value( self.unique_id, measurement_single[4]['unit'], value=measurement_single[4]['value'], measure=measurement_single[4]['measurement'], channel=4, timestamp=datetime_ts) # Download successfully finished, set newest timestamp self.gadget.newestTimeStampMs = self.gadget.tmp_newestTimeStampMs
def download_data(self): # Clear data previously stored in dictionary self.gadget.loggedDataReadout = {'Temp': {}, 'Humi': {}} # Download stored data starting from self.gadget.newestTimeStampMs self.gadget.readLoggedDataInterval( startMs=self.gadget.newestTimeStampMs) while self.running: if (not self.gadget.waitForNotifications(5) or not self.gadget.isLogReadoutInProgress()): break # Done reading data list_timestamps_temp = [] list_timestamps_humi = [] # Store logged temperature measurement = self.device_measurements.filter( DeviceMeasurements.channel == 0).first() conversion = db_retrieve_table_daemon( Conversion, unique_id=measurement.conversion_id) for each_ts, each_measure in self.gadget.loggedDataReadout['Temp'].items(): list_timestamps_temp.append(each_ts) datetime_ts = datetime.datetime.utcfromtimestamp(each_ts / 1000) if self.is_enabled(0): measurement_single = { 0: { 'measurement': 'temperature', 'unit': 'C', 'value': each_measure } } measurement_single = parse_measurement( conversion, measurement, measurement_single, measurement.channel, measurement_single[0]) write_influxdb_value( self.unique_id, measurement_single[0]['unit'], value=measurement_single[0]['value'], measure=measurement_single[0]['measurement'], channel=0, timestamp=datetime_ts) # Store logged humidity measurement = self.device_measurements.filter( DeviceMeasurements.channel == 1).first() conversion = db_retrieve_table_daemon( Conversion, unique_id=measurement.conversion_id) for each_ts, each_measure in self.gadget.loggedDataReadout['Humi'].items(): list_timestamps_humi.append(each_ts) datetime_ts = datetime.datetime.utcfromtimestamp(each_ts / 1000) if self.is_enabled(1): measurement_single = { 1: { 'measurement': 'humidity', 'unit': 'percent', 'value': each_measure } } measurement_single = parse_measurement( conversion, measurement, measurement_single, measurement.channel, measurement_single[1]) write_influxdb_value( self.unique_id, measurement_single[1]['unit'], value=measurement_single[1]['value'], measure=measurement_single[1]['measurement'], channel=1, timestamp=datetime_ts) # Find common timestamps from both temperature and humidity lists list_timestamps_both = list( set(list_timestamps_temp).intersection(list_timestamps_humi)) for each_ts in list_timestamps_both: datetime_ts = datetime.datetime.utcfromtimestamp(each_ts / 1000) # Calculate and store dew point if (self.is_enabled(3) and self.is_enabled(0) and self.is_enabled(1)): measurement = self.device_measurements.filter( DeviceMeasurements.channel == 3).first() conversion = db_retrieve_table_daemon( Conversion, unique_id=measurement.conversion_id) dewpoint = calculate_dewpoint( self.gadget.loggedDataReadout['Temp'][each_ts], self.gadget.loggedDataReadout['Humi'][each_ts]) measurement_single = { 3: { 'measurement': 'dewpoint', 'unit': 'C', 'value': dewpoint } } measurement_single = parse_measurement( conversion, measurement, measurement_single, measurement.channel, measurement_single[3]) write_influxdb_value( self.unique_id, measurement_single[3]['unit'], value=measurement_single[3]['value'], measure=measurement_single[3]['measurement'], channel=3, timestamp=datetime_ts) # Calculate and store vapor pressure deficit if (self.is_enabled(4) and self.is_enabled(0) and self.is_enabled(1)): measurement = self.device_measurements.filter( DeviceMeasurements.channel == 4).first() conversion = db_retrieve_table_daemon( Conversion, unique_id=measurement.conversion_id) vpd = calculate_vapor_pressure_deficit( self.gadget.loggedDataReadout['Temp'][each_ts], self.gadget.loggedDataReadout['Humi'][each_ts]) measurement_single = { 4: { 'measurement': 'vapor_pressure_deficit', 'unit': 'Pa', 'value': vpd } } measurement_single = parse_measurement( conversion, measurement, measurement_single, measurement.channel, measurement_single[4]) write_influxdb_value( self.unique_id, measurement_single[4]['unit'], value=measurement_single[4]['value'], measure=measurement_single[4]['measurement'], channel=4, timestamp=datetime_ts) # Download successfully finished, set newest timestamp self.gadget.newestTimeStampMs = self.gadget.tmp_newestTimeStampMs
def loop(self): if self.timer_loop > time.time(): return while self.timer_loop < time.time(): self.timer_loop += self.period device_measurement = get_measurement( self.select_measurement_measurement_id) if not device_measurement: self.logger.error("Could not find Device Measurement") return past_measurements = self.get_past_measurements( self.select_measurement_device_id, self.select_measurement_measurement_id, max_age=self.max_measure_age) self.logger.debug( "Past Measurements returned: {}".format(past_measurements)) if not past_measurements: self.logger.error( "Could not find measurements within the set Max Age") return False measure = [] for each_measure in past_measurements: measure.append(each_measure[1]) if len(measure) > 1: stat_mean = float(sum(measure) / float(len(measure))) stat_median = median(measure) stat_minimum = min(measure) stat_maximum = max(measure) stdev_ = stdev(measure) stdev_mean_upper = stat_mean + stdev_ stdev_mean_lower = stat_mean - stdev_ list_measurement = [ stat_mean, stat_median, stat_minimum, stat_maximum, stdev_, stdev_mean_upper, stdev_mean_lower ] for each_channel, each_measurement in self.channels_measurement.items( ): if each_measurement.is_enabled: channel, unit, measurement = return_measurement_info( each_measurement, self.channels_conversion[each_channel]) self.logger.debug( "Saving {} to channel {} with measurement {} and " "unit {}".format(list_measurement[each_channel], each_channel, measurement, unit)) write_influxdb_value(self.unique_id, unit, value=list_measurement[each_channel], measure=measurement, channel=each_channel) else: self.logger.debug( "Less than 2 measurements found within Max Age. " "Calculations need at least 2 measurements. Not calculating.")