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.")
