def get_measurement(self):
""" Gets the humidity and temperature """
if not self.sensor:
self.logger.error("Input not set up")
return
self.return_dict = copy.deepcopy(measurements_dict)
temperature = None
humidity = None
dew_point = None
measurements_success = False
# Try twice to get measurement. This prevents an anomaly where
# the first measurement fails if the sensor has just been powered
# for the first time.
for _ in range(2):
dew_point, humidity, temperature = self.return_measurements()
if dew_point is not None:
measurements_success = True
break
time.sleep(2)
if measurements_success:
self.value_set(0, temperature)
self.value_set(1, humidity)
if self.is_enabled(0) and self.is_enabled(1):
self.value_set(2, dew_point)
self.value_set(3, calculate_vapor_pressure_deficit(self.value_get(0), self.value_get(1)))
return self.return_dict
else:
self.logger.debug("Could not acquire a measurement")
def get_measurement(self):
""" Gets the measurements """
if not self.sensor:
self.logger.error("Input not set up")
return
self.return_dict = copy.deepcopy(measurements_dict)
if self.is_enabled(0):
self.value_set(0, self.sensor.temperature)
if self.is_enabled(1):
self.value_set(1, self.sensor.relative_humidity)
if self.is_enabled(2):
self.value_set(2, convert_from_x_to_y_unit('hPa', 'Pa', self.sensor.pressure))
if self.is_enabled(0) and self.is_enabled(1) and self.is_enabled(3):
self.value_set(3, calculate_dewpoint(self.value_get(0), self.value_get(1)))
if self.is_enabled(4):
self.value_set(4, self.sensor.altitude)
if self.is_enabled(0) and self.is_enabled(1) and self.is_enabled(5):
self.value_set(5, calculate_vapor_pressure_deficit(self.value_get(0), self.value_get(1)))
return self.return_dict
def get_measurement(self):
"""Gets the humidity and temperature."""
if not self.HDC1000_fr or not self.HDC1000_fw:
self.logger.error(
"Error 101: Device not set up. See https://kizniche.github.io/Mycodo/Error-Codes#error-101 for more info."
)
return
self.return_dict = copy.deepcopy(measurements_dict)
if self.is_enabled(0):
self.value_set(0, self.read_temperature())
if self.is_enabled(1):
self.value_set(1, self.read_humidity())
if self.is_enabled(2) and self.is_enabled(0) and self.is_enabled(1):
self.value_set(
2, calculate_dewpoint(self.value_get(0), self.value_get(1)))
if self.is_enabled(3) and self.is_enabled(0) and self.is_enabled(1):
self.value_set(
3,
calculate_vapor_pressure_deficit(self.value_get(0),
self.value_get(1)))
return self.return_dict
def get_measurement(self):
""" Gets the humidity and temperature """
if not self.HDC1000_fr or not self.HDC1000_fw:
self.logger.error("Input not set up")
return
self.return_dict = copy.deepcopy(measurements_dict)
if self.is_enabled(0):
self.value_set(0, self.read_temperature())
if self.is_enabled(1):
self.value_set(1, self.read_humidity())
if self.is_enabled(2) and self.is_enabled(0) and self.is_enabled(1):
self.value_set(
2, calculate_dewpoint(self.value_get(0), self.value_get(1)))
if self.is_enabled(3) and self.is_enabled(0) and self.is_enabled(1):
self.value_set(
3,
calculate_vapor_pressure_deficit(self.value_get(0),
self.value_get(1)))
return self.return_dict
def get_measurement(self):
"""Measures CO2, temperature and humidity."""
if not self.sensor:
self.logger.error(
"Error 101: Device not set up. See https://kizniche.github.io/Mycodo/Error-Codes#error-101 for more info."
)
return
self.return_dict = copy.deepcopy(measurements_dict)
if self.sensor.data_available:
if self.is_enabled(0):
self.value_set(0, self.sensor.CO2)
if self.is_enabled(1):
self.value_set(1, self.sensor.temperature)
if self.is_enabled(2):
self.value_set(2, self.sensor.relative_humidity)
if self.is_enabled(3) and self.is_enabled(1) and self.is_enabled(
2):
self.value_set(
3, calculate_dewpoint(self.value_get(1),
self.value_get(2)))
if self.is_enabled(4) and self.is_enabled(1) and self.is_enabled(
2):
self.value_set(
4,
calculate_vapor_pressure_deficit(self.value_get(1),
self.value_get(2)))
return self.return_dict
def get_measurement(self):
""" Gets the measurement in units by reading the """
self.return_dict = measurements_dict.copy()
if self.is_enabled(0):
self.value_set(0, self.sensor.read_temperature())
if self.is_enabled(1):
self.value_set(1, self.sensor.read_humidity())
if self.is_enabled(2):
self.value_set(2, self.sensor.read_pressure())
if (self.is_enabled(3) and self.is_enabled(0) and self.is_enabled(1)):
self.value_set(
3, calculate_dewpoint(self.value_get(0), self.value_get(1)))
if self.is_enabled(4) and self.is_enabled(2):
self.value_set(4, calculate_altitude(self.value_get(2)))
if (self.is_enabled(5) and self.is_enabled(0) and self.is_enabled(1)):
self.value_set(
5,
calculate_vapor_pressure_deficit(self.value_get(0),
self.value_get(1)))
return self.return_dict
def get_measurement(self):
"""Gets the measurements."""
if not self.sensor:
self.logger.error("Error 101: Device not set up. See https://kizniche.github.io/Mycodo/Error-Codes#error-101 for more info.")
return
self.return_dict = copy.deepcopy(measurements_dict)
if self.is_enabled(0):
self.value_set(0, self.sensor.temperature)
if self.is_enabled(1):
self.value_set(1, self.sensor.relative_humidity)
if self.is_enabled(2):
self.value_set(2, convert_from_x_to_y_unit('hPa', 'Pa', self.sensor.pressure))
if self.is_enabled(0) and self.is_enabled(1) and self.is_enabled(3):
self.value_set(3, calculate_dewpoint(self.value_get(0), self.value_get(1)))
if self.is_enabled(4):
self.value_set(4, self.sensor.altitude)
if self.is_enabled(0) and self.is_enabled(1) and self.is_enabled(5):
self.value_set(5, calculate_vapor_pressure_deficit(self.value_get(0), self.value_get(1)))
return self.return_dict
def get_measurement(self):
self.return_dict = copy.deepcopy(measurements_dict)
url = "http://{ip}/cm?cmnd=status%2010".format(ip=self.ip_address)
r = requests.get(url)
str_json = r.text
dict_data = json.loads(str_json)
self.logger.debug("Returned Data: {}".format(dict_data))
# Convert string to datetime object
datetime_timestmp = datetime.datetime.strptime(dict_data['StatusSNS']['Time'], '%Y-%m-%dT%H:%M:%S')
if 'TempUnit' in dict_data['StatusSNS'] and dict_data['StatusSNS']['TempUnit']:
# Convert temperature to SI unit Celsius
temp_c = convert_from_x_to_y_unit(
dict_data['StatusSNS']['TempUnit'],
'C',
dict_data['StatusSNS']['AM2301']['Temperature'])
else:
temp_c = dict_data['StatusSNS']['AM2301']['Temperature']
self.value_set(0, temp_c, timestamp=datetime_timestmp)
self.value_set(1, dict_data['StatusSNS']['AM2301']['Humidity'], timestamp=datetime_timestmp)
if self.is_enabled(2) and self.is_enabled(0) and self.is_enabled(1):
dewpoint = calculate_dewpoint(self.value_get(0), self.value_get(1))
self.value_set(2, dewpoint, timestamp=datetime_timestmp)
if self.is_enabled(3) and self.is_enabled(0) and self.is_enabled(1):
vpd = calculate_vapor_pressure_deficit(self.value_get(0), self.value_get(1))
self.value_set(3, vpd, timestamp=datetime_timestmp)
return self.return_dict
def measure_sensor(self):
self.temp_temperature = 0
self.temp_humidity = 0
self.temp_dew_point = None
self.temp_vpd = None
try:
try:
self.setup()
except Exception as except_msg:
self.logger.error(
'Could not initialize sensor. Check if gpiod is running. '
'Error: {msg}'.format(msg=except_msg))
if isinstance(self.sensor_type, str):
self.sensor_type = int(self.sensor_type)
[self.temp_temperature, self.temp_humidity,
retval] = self.grovepi.dht(self.gpio, self.sensor_type)
if retval is None:
self.logger.error(
"Error reading from DHT sensor: {}".format(retval))
self.logger.info("Temp: {}, Hum: {}".format(
self.temp_temperature, self.temp_humidity))
if self.temp_humidity != 0:
self.temp_dew_point = calculate_dewpoint(
self.temp_temperature, self.temp_humidity)
self.temp_vpd = calculate_vapor_pressure_deficit(
self.temp_temperature, self.temp_humidity)
except Exception as e:
self.logger.error(
"Exception raised when taking a reading: {err}".format(err=e))
finally:
self.close()
return (self.temp_dew_point, self.temp_humidity,
self.temp_temperature)
def get_measurement(self):
""" Gets the measurement in units by reading the """
return_dict = measurements_dict.copy()
if self.is_enabled(0):
return_dict[0]['value'] = self.sensor.read_temperature()
if self.is_enabled(1):
return_dict[1]['value'] = self.sensor.read_humidity()
if self.is_enabled(2):
return_dict[2]['value'] = self.sensor.read_pressure()
if (self.is_enabled(3) and self.is_enabled(0) and self.is_enabled(1)):
return_dict[3]['value'] = calculate_dewpoint(
return_dict[0]['value'], return_dict[1]['value'])
if self.is_enabled(4) and self.is_enabled(2):
return_dict[4]['value'] = calculate_altitude(
return_dict[2]['value'])
if (self.is_enabled(5) and self.is_enabled(0) and self.is_enabled(1)):
return_dict[5]['value'] = calculate_vapor_pressure_deficit(
return_dict[0]['value'], return_dict[1]['value'])
return return_dict
def get_measurement(self):
"""Gets the measurement in units by reading the"""
if not self.sensor:
self.logger.error("Error 101: Device not set up. See https://kizniche.github.io/Mycodo/Error-Codes#error-101 for more info.")
return
self.return_dict = copy.deepcopy(measurements_dict)
if self.is_enabled(0):
self.value_set(0, self.sensor.temperature + self.temp_offset)
if self.is_enabled(1):
self.value_set(1, self.sensor.relative_humidity)
if self.is_enabled(2):
self.value_set(2, convert_from_x_to_y_unit('hPa', 'Pa', self.sensor.pressure))
if self.is_enabled(3):
self.value_set(3, self.sensor.gas)
self.logger.debug("Temp: {t}, Hum: {h}, Press: {p}, Gas: {g}".format(
t=self.value_get(0), h=self.value_get(1), p=self.value_get(2), g=self.value_get(3)))
if self.is_enabled(0) and self.is_enabled(1) and self.is_enabled(4):
self.value_set(4, calculate_dewpoint(self.value_get(0), self.value_get(1)))
if self.is_enabled(5):
self.value_set(5, self.sensor.altitude)
if self.is_enabled(0) and self.is_enabled(1) and self.is_enabled(6):
self.value_set(6, calculate_vapor_pressure_deficit(self.value_get(0), self.value_get(1)))
return self.return_dict
def get_measurement(self):
""" Measures CO2, temperature and humidity """
self.return_dict = copy.deepcopy(measurements_dict)
if self.scd.get_data_ready():
m = self.scd.read_measurement()
if m is not None:
co2 = m[0]
temperature = m[1]
humidity = m[2]
if self.is_enabled(0):
self.value_set(0, co2)
if self.is_enabled(1):
self.value_set(1, temperature)
if self.is_enabled(2):
self.value_set(2, humidity)
if self.is_enabled(3) and self.is_enabled(
1) and self.is_enabled(2):
self.value_set(
3,
calculate_dewpoint(self.value_get(1),
self.value_get(2)))
if self.is_enabled(4) and self.is_enabled(
1) and self.is_enabled(2):
self.value_set(
4,
calculate_vapor_pressure_deficit(
self.value_get(1), self.value_get(2)))
return self.return_dict
def get_measurement(self):
""" Measures CO2, temperature and humidity """
self.return_dict = copy.deepcopy(measurements_dict)
if self.scd.data_available:
co2 = self.scd.CO2
temperature = self.scd.temperature
humidity = self.scd.relative_humidity
if self.is_enabled(0):
self.value_set(0, co2)
if self.is_enabled(1):
self.value_set(1, temperature)
if self.is_enabled(2):
self.value_set(2, humidity)
if self.is_enabled(3) and self.is_enabled(1) and self.is_enabled(
2):
self.value_set(
3, calculate_dewpoint(self.value_get(1),
self.value_get(2)))
if self.is_enabled(4) and self.is_enabled(1) and self.is_enabled(
2):
self.value_set(
4,
calculate_vapor_pressure_deficit(self.value_get(1),
self.value_get(2)))
return self.return_dict
def measure_sensor(self):
self.temp_temperature = 0
self.temp_humidity = 0
self.temp_dew_point = None
self.temp_vpd = None
try:
try:
self.setup()
except Exception as except_msg:
self.logger.error(
'Could not initialize sensor. Check if gpiod is running. Error: {msg}'.format(msg=except_msg))
self.pi.write(self.gpio, self.pigpio.LOW)
time.sleep(0.017) # 17 ms
self.pi.set_mode(self.gpio, self.pigpio.INPUT)
self.pi.set_watchdog(self.gpio, 200)
time.sleep(0.2)
if self.temp_humidity != 0:
self.temp_dew_point = calculate_dewpoint(self.temp_temperature, self.temp_humidity)
self.temp_vpd = calculate_vapor_pressure_deficit(self.temp_temperature, self.temp_humidity)
except Exception as e:
self.logger.error("Exception raised when taking a reading: {err}".format(err=e))
finally:
self.close()
return (self.temp_dew_point,
self.temp_humidity,
self.temp_temperature)
def get_measurement(self):
""" Gets the humidity and temperature """
self.return_dict = measurements_dict.copy()
temperature, humidity = self.read_sensor()
if self.is_enabled(0):
self.value_set(0, temperature)
if self.is_enabled(1):
self.value_set(1, humidity)
if (self.is_enabled(2) and
self.is_enabled(0) and
self.is_enabled(1)):
self.value_set(2, calculate_dewpoint(
self.value_get(0), self.value_get(1)))
if (self.is_enabled(3) and
self.is_enabled(0) and
self.is_enabled(1)):
self.value_set(3, calculate_vapor_pressure_deficit(
self.value_get(0), self.value_get(1)))
return self.return_dict
def get_measurement(self):
if not self.sensor:
self.logger.error("Input not set up")
return
self.return_dict = copy.deepcopy(measurements_dict)
if self.is_enabled(0) or self.is_enabled(1):
temperature, relative_humidity = self.sensor.measurements
else:
temperature = 0
relative_humidity = 0
if self.is_enabled(0):
self.value_set(0, temperature)
if self.is_enabled(1):
self.value_set(1, relative_humidity)
if self.is_enabled(2) and self.is_enabled(0) and self.is_enabled(1):
self.value_set(
2, calculate_dewpoint(self.value_get(0), self.value_get(1)))
if self.is_enabled(3) and self.is_enabled(0) and self.is_enabled(1):
self.value_set(
3,
calculate_vapor_pressure_deficit(self.value_get(0),
self.value_get(1)))
return self.return_dict
def get_measurement(self):
""" Gets the measurement in units by reading the """
self.return_dict = measurements_dict.copy()
if self.is_enabled(0):
self.value_set(0, self.sensor.read_temperature())
if self.is_enabled(1):
self.value_set(1, self.sensor.read_humidity())
if (self.is_enabled(2) and self.is_enabled(0) and self.is_enabled(1)):
self.value_set(
2, calculate_dewpoint(self.value_get(0), self.value_get(1)))
if (self.is_enabled(3) and self.is_enabled(0) and self.is_enabled(1)):
self.value_set(
3,
calculate_vapor_pressure_deficit(self.value_get(0),
self.value_get(1)))
if self.heater_enable and self.heater_seconds and self.heater_measurements:
time.sleep(2)
self.measurement_count += 1
if self.measurement_count >= self.heater_measurements:
self.measurement_count = 0
self.sensor.set_heater(True)
time.sleep(self.heater_seconds)
self.sensor.set_heater(False)
return self.return_dict
def get_measurement(self):
if not self.sensor:
self.logger.error("Error 101: Device not set up. See https://kizniche.github.io/Mycodo/Error-Codes#error-101 for more info.")
return
self.return_dict = copy.deepcopy(measurements_dict)
if self.is_enabled(0) or self.is_enabled(1):
temperature, relative_humidity = self.sensor.measurements
else:
temperature = 0
relative_humidity = 0
if self.is_enabled(0):
self.value_set(0, temperature)
if self.is_enabled(1):
self.value_set(1, relative_humidity)
if self.is_enabled(2) and self.is_enabled(0) and self.is_enabled(1):
self.value_set(2, calculate_dewpoint(self.value_get(0), self.value_get(1)))
if self.is_enabled(3) and self.is_enabled(0) and self.is_enabled(1):
self.value_set(3, calculate_vapor_pressure_deficit(self.value_get(0), self.value_get(1)))
return self.return_dict
def get_measurement(self):
""" Gets the measurement in units by reading the """
self.return_dict = measurements_dict.copy()
data = self.sensor.sample(self.bus, self.i2c_address,
self.calibration_params)
if self.is_enabled(0):
self.value_set(0, data.temperature)
if self.is_enabled(1):
self.value_set(1, data.humidity)
if self.is_enabled(2):
self.value_set(2, data.pressure)
if (self.is_enabled(3) and self.is_enabled(0) and self.is_enabled(1)):
self.value_set(
3, calculate_dewpoint(self.value_get(0), self.value_get(1)))
if self.is_enabled(4) and self.is_enabled(2):
self.value_set(4, calculate_altitude(self.value_get(2)))
if (self.is_enabled(5) and self.is_enabled(0) and self.is_enabled(1)):
self.value_set(
5,
calculate_vapor_pressure_deficit(self.value_get(0),
self.value_get(1)))
return self.return_dict
def get_measurement(self):
""" Gets the humidity and temperature """
return_dict = measurements_dict.copy()
temperature, humidity = self.read()
if self.is_enabled(0):
return_dict[0]['value'] = temperature
if self.is_enabled(1):
return_dict[1]['value'] = humidity
if (self.is_enabled(2) and
self.is_enabled(0) and
self.is_enabled(1)):
return_dict[2]['value'] = calculate_dewpoint(
return_dict[0]['value'], return_dict[1]['value'])
if (self.is_enabled(3) and
self.is_enabled(0) and
self.is_enabled(1)):
return_dict[3]['value'] = calculate_vapor_pressure_deficit(
return_dict[0]['value'], return_dict[1]['value'])
return return_dict
def get_measurement(self):
return_dict = measurements_dict.copy()
url = "http://{ip}/cm?cmnd=status%2010".format(ip=self.ip_address)
r = requests.get(url)
str_json = r.text
dict_data = json.loads(str_json)
# Convert string to datetime object
datetime_timestmp = datetime.datetime.strptime(
dict_data['StatusSNS']['Time'], '%Y-%m-%dT%H:%M:%S')
# Convert temperature to SI unit Celsius
if self.is_enabled(0):
return_dict[0]['value'] = convert_from_x_to_y_unit(
'F', 'C', dict_data['StatusSNS']['AM2301']['Temperature'])
return_dict[0]['timestamp'] = datetime_timestmp
if self.is_enabled(1):
return_dict[1]['value'] = dict_data['StatusSNS']['AM2301'][
'Humidity']
return_dict[1]['timestamp'] = datetime_timestmp
if (self.is_enabled(2) and self.is_enabled(0) and self.is_enabled(1)):
return_dict[2]['value'] = calculate_dewpoint(
return_dict[0]['value'], return_dict[1]['value'])
return_dict[2]['timestamp'] = datetime_timestmp
if (self.is_enabled(3) and self.is_enabled(0) and self.is_enabled(1)):
return_dict[3]['value'] = calculate_vapor_pressure_deficit(
return_dict[0]['value'], return_dict[1]['value'])
return_dict[3]['timestamp'] = datetime_timestmp
return return_dict
def get_measurement(self):
""" Gets the measurement in units by reading the """
if not self.sensor:
self.logger.error("Input not set up")
return
self.return_dict = copy.deepcopy(measurements_dict)
data = self.sensor.sample(self.bus, self.i2c_address,
self.calibration_params)
if self.is_enabled(0):
self.value_set(0, data.temperature)
if self.is_enabled(1):
self.value_set(1, data.humidity)
if self.is_enabled(2):
self.value_set(
2, convert_from_x_to_y_unit('hPa', 'Pa', data.pressure))
if self.is_enabled(0) and self.is_enabled(1):
self.value_set(
3, calculate_dewpoint(self.value_get(0), self.value_get(1)))
if self.is_enabled(2):
self.value_set(4, calculate_altitude(self.value_get(2)))
if self.is_enabled(0) and self.is_enabled(1):
self.value_set(
5,
calculate_vapor_pressure_deficit(self.value_get(0),
self.value_get(1)))
return self.return_dict
def get_measurement(self):
""" Get measurements and store in the database """
if not self.sensor:
self.logger.error("Input not set up")
return
self.return_dict = copy.deepcopy(measurements_dict)
if self.is_enabled(0):
self.value_set(0, self.sensor.read_temperature())
if self.is_enabled(1):
self.value_set(1, self.sensor.read_humidity())
if self.is_enabled(2):
self.value_set(
2,
convert_from_x_to_y_unit('hPa', 'Pa',
self.sensor.read_pressure()))
if self.is_enabled(3) and self.is_enabled(0) and self.is_enabled(1):
self.value_set(
3, calculate_dewpoint(self.value_get(0), self.value_get(1)))
if self.is_enabled(4) and self.is_enabled(2):
self.value_set(4, calculate_altitude(self.value_get(2)))
if self.is_enabled(5) and self.is_enabled(0) and self.is_enabled(1):
self.value_set(
5,
calculate_vapor_pressure_deficit(self.value_get(0),
self.value_get(1)))
return self.return_dict
def get_measurement(self):
""" Gets the humidity and temperature """
if not self.sht2x:
self.logger.error("Input not set up")
return
self.return_dict = copy.deepcopy(measurements_dict)
for _ in range(2):
try:
# Send temperature measurement command
# 0xF3(243) NO HOLD master
self.sht2x.write_byte(self.i2c_address, 0xF3)
time.sleep(0.5)
# Read data back, 2 bytes
# Temp MSB, Temp LSB
data0 = self.sht2x.read_byte(self.i2c_address)
data1 = self.sht2x.read_byte(self.i2c_address)
temperature = -46.85 + ((
(data0 * 256 + data1) * 175.72) / 65536.0)
# Send humidity measurement command
# 0xF5(245) NO HOLD master
self.sht2x.write_byte(self.i2c_address, 0xF5)
time.sleep(0.5)
# Read data back, 2 bytes
# Humidity MSB, Humidity LSB
data0 = self.sht2x.read_byte(self.i2c_address)
data1 = self.sht2x.read_byte(self.i2c_address)
humidity = -6 + (((data0 * 256 + data1) * 125.0) / 65536.0)
if self.is_enabled(0):
self.value_set(0, temperature)
if self.is_enabled(1):
self.value_set(1, humidity)
if self.is_enabled(2) and self.is_enabled(
0) and self.is_enabled(1):
self.value_set(
2,
calculate_dewpoint(self.value_get(0),
self.value_get(1)))
if self.is_enabled(3) and self.is_enabled(
0) and self.is_enabled(1):
self.value_set(
3,
calculate_vapor_pressure_deficit(
self.value_get(0), self.value_get(1)))
return self.return_dict
except Exception as e:
self.logger.exception(
"Exception when taking a reading: {err}".format(err=e))
# Send soft reset and try a second read
self.sht2x.write_byte(self.i2c_address, 0xFE)
time.sleep(0.1)
def get_measurement(self):
""" Gets the humidity and temperature """
return_dict = measurements_dict.copy()
if not self.pi.connected: # Check if pigpiod is running
self.logger.error("Could not connect to pigpiod."
"Ensure it is running and try again.")
return None, None, None
self.htu_reset()
# wtreg = 0xE6
# rdreg = 0xE7
rdtemp = 0xE3
rdhumi = 0xE5
handle = self.pi.i2c_open(self.i2c_bus, self.i2c_address) # open i2c bus
self.pi.i2c_write_byte(handle, rdtemp) # send read temp command
time.sleep(0.055) # readings take up to 50ms, lets give it some time
(_, byte_array) = self.pi.i2c_read_device(handle, 3) # vacuum up those bytes
self.pi.i2c_close(handle) # close the i2c bus
t1 = byte_array[0] # most significant byte msb
t2 = byte_array[1] # least significant byte lsb
temp_reading = (t1 * 256) + t2 # combine both bytes into one big integer
temp_reading = float(temp_reading)
temperature = ((temp_reading / 65536) * 175.72) - 46.85 # formula from datasheet
handle = self.pi.i2c_open(self.i2c_bus, self.i2c_address) # open i2c bus
self.pi.i2c_write_byte(handle, rdhumi) # send read humi command
time.sleep(0.055) # readings take up to 50ms, lets give it some time
(_, byte_array) = self.pi.i2c_read_device(handle, 3) # vacuum up those bytes
self.pi.i2c_close(handle) # close the i2c bus
h1 = byte_array[0] # most significant byte msb
h2 = byte_array[1] # least significant byte lsb
humi_reading = (h1 * 256) + h2 # combine both bytes into one big integer
humi_reading = float(humi_reading)
uncomp_humidity = ((humi_reading / 65536) * 125) - 6 # formula from datasheet
humidity = ((25 - temperature) * -0.15) + uncomp_humidity
if self.is_enabled(0):
return_dict[0]['value'] = temperature
if self.is_enabled(1):
return_dict[1]['value'] = humidity
if (self.is_enabled(2) and
self.is_enabled(0) and
self.is_enabled(1)):
return_dict[2]['value'] = calculate_dewpoint(
return_dict[0]['value'], return_dict[1]['value'])
if (self.is_enabled(3) and
self.is_enabled(0) and
self.is_enabled(1)):
return_dict[3]['value'] = calculate_vapor_pressure_deficit(
return_dict[0]['value'], return_dict[1]['value'])
return return_dict
def get_measurement(self):
if not self.sensor:
self.logger.error("Error 101: Device not set up. See https://kizniche.github.io/Mycodo/Error-Codes#error-101 for more info.")
return
self.return_dict = copy.deepcopy(measurements_dict)
temperature = None
humidity = None
success = False
for _ in range(3): # Three attempts
try:
temperature, humidity = self.sensor.read_temperature_humidity()
except OSError as e:
self.logger.debug("OSError: {}".format(e))
self.logger.debug("Attempting reset of sensor and another measurement")
try:
self.sensor.reset()
try:
temperature, humidity = self.sensor.read_temperature_humidity()
except Exception as e:
self.logger.debug("Measurement unsuccessful after reset")
except Exception:
self.logger.debug("Reset command unsuccessful")
if None in [temperature, humidity] or math.isnan(temperature) or math.isnan(humidity):
self.logger.debug("One not a number: Temperature: {}, Humidity: {}".format(temperature, humidity))
else:
success = True
break
time.sleep(0.1)
if not success:
self.logger.debug("Could not obtain measurements after 3 tries")
return
if self.is_enabled(0):
self.value_set(0, temperature)
if self.is_enabled(1):
self.value_set(1, humidity)
if self.is_enabled(2) and self.is_enabled(0) and self.is_enabled(1):
self.value_set(2, calculate_dewpoint(self.value_get(0), self.value_get(1)))
if self.is_enabled(3) and self.is_enabled(0) and self.is_enabled(1):
self.value_set(3, calculate_vapor_pressure_deficit(self.value_get(0), self.value_get(1)))
if self.heater_enable and self.heater_seconds and self.heater_measurements:
time.sleep(2)
self.measurement_count += 1
if self.measurement_count >= self.heater_measurements:
self.measurement_count = 0
self.sensor.set_heater(True)
time.sleep(self.heater_seconds)
self.sensor.set_heater(False)
return self.return_dict
def get_measurement(self):
""" Gets the humidity and temperature """
self.return_dict = measurements_dict.copy()
if not self.pi.connected: # Check if pigpiod is running
self.logger.error("Could not connect to pigpiod."
"Ensure it is running and try again.")
return None, None, None
self.htu_reset()
# wtreg = 0xE6
# rdreg = 0xE7
rdtemp = 0xE3
rdhumi = 0xE5
handle = self.pi.i2c_open(self.i2c_bus, self.i2c_address) # open i2c bus
self.pi.i2c_write_byte(handle, rdtemp) # send read temp command
time.sleep(0.055) # readings take up to 50ms, lets give it some time
(_, byte_array) = self.pi.i2c_read_device(handle, 3) # vacuum up those bytes
self.pi.i2c_close(handle) # close the i2c bus
t1 = byte_array[0] # most significant byte msb
t2 = byte_array[1] # least significant byte lsb
temp_reading = (t1 * 256) + t2 # combine both bytes into one big integer
temp_reading = float(temp_reading)
temperature = ((temp_reading / 65536) * 175.72) - 46.85 # formula from datasheet
handle = self.pi.i2c_open(self.i2c_bus, self.i2c_address) # open i2c bus
self.pi.i2c_write_byte(handle, rdhumi) # send read humi command
time.sleep(0.055) # readings take up to 50ms, lets give it some time
(_, byte_array) = self.pi.i2c_read_device(handle, 3) # vacuum up those bytes
self.pi.i2c_close(handle) # close the i2c bus
h1 = byte_array[0] # most significant byte msb
h2 = byte_array[1] # least significant byte lsb
humi_reading = (h1 * 256) + h2 # combine both bytes into one big integer
humi_reading = float(humi_reading)
uncomp_humidity = ((humi_reading / 65536) * 125) - 6 # formula from datasheet
humidity = ((25 - temperature) * -0.15) + uncomp_humidity
if self.is_enabled(0):
self.set_value(0, temperature)
if self.is_enabled(1):
self.set_value(1, humidity)
if (self.is_enabled(2) and
self.is_enabled(0) and
self.is_enabled(1)):
self.set_value(2, calculate_dewpoint(
self.get_value(0), self.get_value(1)))
if (self.is_enabled(3) and
self.is_enabled(0) and
self.is_enabled(1)):
self.set_value(3, calculate_vapor_pressure_deficit(
self.get_value(0), self.get_value(1)))
return self.return_dict
def get_measurement(self):
""" Gets the measurement in units by reading the """
self.return_dict = measurements_dict.copy()
if self.is_enabled(0):
self.value_set(0, self.sensor.read_temperature())
if self.is_enabled(1):
self.value_set(1, self.sensor.read_humidity())
if self.is_enabled(2):
self.value_set(2, self.sensor.read_pressure())
if (self.is_enabled(3) and
self.is_enabled(0) and
self.is_enabled(1)):
dewpoint = calculate_dewpoint(
self.value_get(0), self.value_get(1))
self.value_set(3, dewpoint)
if self.is_enabled(4) and self.is_enabled(2):
altitude = calculate_altitude(self.value_get(2))
self.value_set(4, altitude)
if (self.is_enabled(5) and
self.is_enabled(0) and
self.is_enabled(1)):
vpd = calculate_vapor_pressure_deficit(
self.value_get(0), self.value_get(1))
self.value_set(5, vpd)
try:
now = time.time()
if now > self.timer:
self.timer = now + 80
# "B" designates this data belonging to the BME280
string_send = 'B,{},{},{}'.format(
self.value_get(1),
self.value_get(2),
self.value_get(0))
self.lock_acquire(self.lock_file, timeout=10)
if self.locked[self.lock_file]:
try:
self.serial_send = self.serial.Serial(self.serial_device, 9600)
self.serial_send.write(string_send.encode())
time.sleep(4)
finally:
self.lock_release(self.lock_file)
self.ttn_serial_error = False
except Exception as e:
if not self.ttn_serial_error:
# Only send this error once if it continually occurs
self.logger.error("TTN: Could not send serial: {}".format(e))
self.ttn_serial_error = True
return self.return_dict
def get_measurement(self):
""" Obtain and return the measurements """
return_dict = measurements_dict.copy()
if not self.initialized:
self.initialize()
if not self.connected:
self.connect()
if self.connected:
try:
# Download stored data
if self.download_stored_data:
self.download_data()
# Set logging interval if not already set
if ('logger_interval_ms' in self.device_information
and self.logging_interval_ms != self.device_information['logger_interval_ms']):
self.set_logging_interval()
# Get battery percent charge
if self.is_enabled(2):
return_dict[2]['value'] = self.gadget.readBattery()
# Get temperature and humidity last so their timestamp in the
# database will be the most accurate
if self.is_enabled(0):
return_dict[0]['value'] = self.gadget.readTemperature()
if self.is_enabled(1):
return_dict[1]['value'] = self.gadget.readHumidity()
except self.btle.BTLEDisconnectError:
logging.error("Disconnected")
return
except Exception:
logging.exception("Unknown Error")
return
finally:
self.disconnect()
if (self.is_enabled(3) and
self.is_enabled(0) and
self.is_enabled(1)):
return_dict[3]['value'] = calculate_dewpoint(
return_dict[0]['value'], return_dict[1]['value'])
if (self.is_enabled(4) and
self.is_enabled(0) and
self.is_enabled(1)):
return_dict[4]['value'] = calculate_vapor_pressure_deficit(
return_dict[0]['value'], return_dict[1]['value'])
return return_dict
def get_measurement(self):
""" Gets the humidity and temperature """
return_dict = measurements_dict.copy()
for _ in range(2):
try:
# Send temperature measurement command
# 0xF3(243) NO HOLD master
self.sht2x.write_byte(self.i2c_address, 0xF3)
time.sleep(0.5)
# Read data back, 2 bytes
# Temp MSB, Temp LSB
data0 = self.sht2x.read_byte(self.i2c_address)
data1 = self.sht2x.read_byte(self.i2c_address)
temperature = -46.85 + (((data0 * 256 + data1) * 175.72) / 65536.0)
# Send humidity measurement command
# 0xF5(245) NO HOLD master
self.sht2x.write_byte(self.i2c_address, 0xF5)
time.sleep(0.5)
# Read data back, 2 bytes
# Humidity MSB, Humidity LSB
data0 = self.sht2x.read_byte(self.i2c_address)
data1 = self.sht2x.read_byte(self.i2c_address)
humidity = -6 + (((data0 * 256 + data1) * 125.0) / 65536.0)
if self.is_enabled(0):
return_dict[0]['value'] = temperature
if self.is_enabled(1):
return_dict[1]['value'] = humidity
if (self.is_enabled(2) and
self.is_enabled(0) and
self.is_enabled(1)):
return_dict[2]['value'] = calculate_dewpoint(
return_dict[0]['value'], return_dict[1]['value'])
if (self.is_enabled(3) and
self.is_enabled(0) and
self.is_enabled(1)):
return_dict[3]['value'] = calculate_vapor_pressure_deficit(
return_dict[0]['value'], return_dict[1]['value'])
return return_dict
except Exception as e:
self.logger.exception(
"Exception when taking a reading: {err}".format(err=e))
# Send soft reset and try a second read
self.sht2x.write_byte(self.i2c_address, 0xFE)
time.sleep(0.1)
def get_measurement(self):
""" Gets the measurement in units by reading the """
if not self.sensor:
self.logger.error("Input not set up")
return
self.return_dict = copy.deepcopy(measurements_dict)
if not self.sensor.get_sensor_data():
self.logger.error("Sensor get_sensor_data() returned False.")
return
if self.is_enabled(0):
self.value_set(0, self.sensor.data.temperature)
if self.is_enabled(1):
self.value_set(1, self.sensor.data.humidity)
if self.is_enabled(2):
self.value_set(
2,
convert_from_x_to_y_unit('hPa', 'Pa',
self.sensor.data.pressure))
if self.is_enabled(3):
if self.sensor.data.heat_stable:
self.value_set(3, self.sensor.data.gas_resistance)
else:
self.logger.error("Sensor heat unstable")
self.logger.debug("Temp: {t}, Hum: {h}, Press: {p}, Gas: {g}".format(
t=self.value_get(0),
h=self.value_get(1),
p=self.value_get(2),
g=self.value_get(3)))
if self.is_enabled(0) and self.is_enabled(1) and self.is_enabled(4):
self.value_set(
4, calculate_dewpoint(self.value_get(0), self.value_get(1)))
if self.is_enabled(2) and self.is_enabled(5):
self.value_set(5, calculate_altitude(self.value_get(2)))
if self.is_enabled(0) and self.is_enabled(1) and self.is_enabled(6):
self.value_set(
6,
calculate_vapor_pressure_deficit(self.value_get(0),
self.value_get(1)))
return self.return_dict
def get_measurement(self):
""" Gets the measurement in units by reading the """
return_dict = measurements_dict.copy()
if self.is_enabled(0):
return_dict[0]['value'] = self.sensor.read_temperature()
if self.is_enabled(1):
return_dict[1]['value'] = self.sensor.read_humidity()
if self.is_enabled(2):
return_dict[2]['value'] = self.sensor.read_pressure()
if (self.is_enabled(3) and
self.is_enabled(0) and
self.is_enabled(1)):
return_dict[3]['value'] = calculate_dewpoint(
return_dict[0]['value'], return_dict[1]['value'])
if self.is_enabled(4) and self.is_enabled(2):
return_dict[4]['value'] = calculate_altitude(return_dict[2]['value'])
if (self.is_enabled(5) and
self.is_enabled(0) and
self.is_enabled(1)):
return_dict[5]['value'] = calculate_vapor_pressure_deficit(
return_dict[0]['value'], return_dict[1]['value'])
try:
now = time.time()
if now > self.timer:
self.timer = now + 80
# "B" designates this data belonging to the BME280
string_send = 'B,{},{},{}'.format(
return_dict[1]['value'],
return_dict[2]['value'],
return_dict[0]['value'])
self.lock_setup()
self.serial_send = self.serial.Serial(self.serial_device, 9600)
self.serial_send.write(string_send.encode())
time.sleep(4)
self.lock_release()
self.ttn_serial_error = False
except:
if not self.ttn_serial_error:
# Only send this error once if it continually occurs
self.logger.error("TTN: Could not send serial")
self.ttn_serial_error = True
return return_dict
def get_measurement(self):
""" Gets the humidity and temperature """
return_dict = measurements_dict.copy()
for _ in range(2):
try:
# Send temperature measurement command
# 0xF3(243) NO HOLD master
self.sht2x.write_byte(self.i2c_address, 0xF3)
time.sleep(0.5)
# Read data back, 2 bytes
# Temp MSB, Temp LSB
data0 = self.sht2x.read_byte(self.i2c_address)
data1 = self.sht2x.read_byte(self.i2c_address)
temperature = -46.85 + ((
(data0 * 256 + data1) * 175.72) / 65536.0)
# Send humidity measurement command
# 0xF5(245) NO HOLD master
self.sht2x.write_byte(self.i2c_address, 0xF5)
time.sleep(0.5)
# Read data back, 2 bytes
# Humidity MSB, Humidity LSB
data0 = self.sht2x.read_byte(self.i2c_address)
data1 = self.sht2x.read_byte(self.i2c_address)
humidity = -6 + (((data0 * 256 + data1) * 125.0) / 65536.0)
if self.is_enabled(0):
return_dict[0]['value'] = temperature
if self.is_enabled(1):
return_dict[1]['value'] = humidity
if (self.is_enabled(2) and self.is_enabled(0)
and self.is_enabled(1)):
return_dict[2]['value'] = calculate_dewpoint(
return_dict[0]['value'], return_dict[1]['value'])
if (self.is_enabled(3) and self.is_enabled(0)
and self.is_enabled(1)):
return_dict[3]['value'] = calculate_vapor_pressure_deficit(
return_dict[0]['value'], return_dict[1]['value'])
return return_dict
except Exception as e:
self.logger.exception(
"Exception when taking a reading: {err}".format(err=e))
# Send soft reset and try a second read
self.sht2x.write_byte(self.i2c_address, 0xFE)
time.sleep(0.1)
def measure_sensor(self):
self.temp_temperature = None
self.temp_humidity = None
self.temp_dew_point = None
self.temp_vpd = None
initialized = False
try:
self.close()
time.sleep(0.2)
self.setup()
time.sleep(0.2)
initialized = True
except Exception as except_msg:
self.logger.error(
"Could not initialize sensor. Check if it's connected "
"properly and pigpiod is running. Error: {msg}".format(
msg=except_msg))
if initialized:
try:
self.pi.write(self.gpio, self.pigpio.LOW)
time.sleep(0.017) # 17 ms
self.pi.set_mode(self.gpio, self.pigpio.INPUT)
self.pi.set_watchdog(self.gpio, 200)
time.sleep(0.2)
if (self.temp_humidity is not None and
self.temp_temperature is not None):
self.temp_dew_point = calculate_dewpoint(
self.temp_temperature, self.temp_humidity)
self.temp_vpd = calculate_vapor_pressure_deficit(
self.temp_temperature, self.temp_humidity)
except Exception as e:
self.logger.exception(
"Exception when taking a reading: {err}".format(
err=e))
finally:
self.close()
def get_measurement(self):
return_dict = measurements_dict.copy()
url = "http://{ip}/cm?cmnd=status%2010".format(ip=self.ip_address)
r = requests.get(url)
str_json = r.text
dict_data = json.loads(str_json)
# Convert string to datetime object
datetime_timestmp = datetime.datetime.strptime(
dict_data['StatusSNS']['Time'], '%Y-%m-%dT%H:%M:%S')
# Convert temperature to SI unit Celsius
if self.is_enabled(0):
return_dict[0]['value'] = convert_from_x_to_y_unit(
'F', 'C', dict_data['StatusSNS']['AM2301']['Temperature'])
return_dict[0]['timestamp'] = datetime_timestmp
if self.is_enabled(1):
return_dict[1]['value'] = dict_data['StatusSNS']['AM2301']['Humidity']
return_dict[1]['timestamp'] = datetime_timestmp
if (self.is_enabled(2) and
self.is_enabled(0) and
self.is_enabled(1)):
return_dict[2]['value'] = calculate_dewpoint(
return_dict[0]['value'], return_dict[1]['value'])
return_dict[2]['timestamp'] = datetime_timestmp
if (self.is_enabled(3) and
self.is_enabled(0) and
self.is_enabled(1)):
return_dict[3]['value'] = calculate_vapor_pressure_deficit(
return_dict[0]['value'], return_dict[1]['value'])
return_dict[3]['timestamp'] = datetime_timestmp
return return_dict
def calculate_math(self):
measurement_dict = {}
if self.math_type == 'average':
device_measurement = self.device_measurements.filter(
DeviceMeasurements.channel == 0).first()
if device_measurement:
conversion = db_retrieve_table_daemon(
Conversion, unique_id=device_measurement.conversion_id)
else:
conversion = None
channel, unit, measurement = return_measurement_info(
device_measurement, conversion)
success, measure = self.get_measurements_from_str(self.inputs)
if success:
average = float(sum(measure) / float(len(measure)))
measurement_dict = {
channel: {
'measurement': measurement,
'unit': unit,
'value': average
}
}
elif measure:
self.logger.error(measure)
else:
self.error_not_within_max_age()
elif self.math_type == 'average_single':
device_id = self.inputs.split(',')[0]
measurement_id = self.inputs.split(',')[1]
device_measurement = db_retrieve_table_daemon(
DeviceMeasurements, unique_id=measurement_id)
if device_measurement:
conversion = db_retrieve_table_daemon(
Conversion, unique_id=device_measurement.conversion_id)
else:
conversion = None
channel, unit, measurement = return_measurement_info(
device_measurement, conversion)
try:
last_measurements = read_past_influxdb(
device_id,
unit,
measurement,
channel,
self.max_measure_age)
if last_measurements:
measure_list = []
for each_set in last_measurements:
if len(each_set) == 2:
measure_list.append(each_set[1])
average = sum(measure_list) / float(len(measure_list))
measurement_dict = {
channel: {
'measurement': measurement,
'unit': unit,
'value': average
}
}
else:
self.error_not_within_max_age()
except Exception as msg:
self.logger.exception("average_single Error: {err}".format(err=msg))
elif self.math_type == 'difference':
device_measurement = self.device_measurements.filter(
DeviceMeasurements.channel == 0).first()
if device_measurement:
conversion = db_retrieve_table_daemon(
Conversion, unique_id=device_measurement.conversion_id)
else:
conversion = None
channel, unit, measurement = return_measurement_info(
device_measurement, conversion)
success, measure = self.get_measurements_from_str(self.inputs)
if success:
if self.difference_reverse_order:
difference = measure[1] - measure[0]
else:
difference = measure[0] - measure[1]
if self.difference_absolute:
difference = abs(difference)
measurement_dict = {
channel: {
'measurement': measurement,
'unit': unit,
'value': difference
}
}
elif measure:
self.logger.error(measure)
else:
self.error_not_within_max_age()
elif self.math_type == 'equation':
device_measurement = self.device_measurements.filter(
DeviceMeasurements.channel == 0).first()
if device_measurement:
conversion = db_retrieve_table_daemon(
Conversion, unique_id=device_measurement.conversion_id)
else:
conversion = None
channel, unit, measurement = return_measurement_info(
device_measurement, conversion)
success, measure = self.get_measurements_from_str(self.inputs)
if success:
replaced_str = self.equation.replace('x', str(measure[0]))
equation_output = eval(replaced_str)
measurement_dict = {
channel: {
'measurement': measurement,
'unit': unit,
'value': float(equation_output)
}
}
elif measure:
self.logger.error(measure)
else:
self.error_not_within_max_age()
elif self.math_type == 'redundancy':
list_order = self.order_of_use.split(';')
measurement_success = False
for each_id_measurement_id in list_order:
device_id = each_id_measurement_id.split(',')[0]
measurement_id = each_id_measurement_id.split(',')[1]
device_measurement = self.device_measurements.filter(
DeviceMeasurements.channel == 0).first()
if device_measurement:
conversion = db_retrieve_table_daemon(
Conversion, unique_id=device_measurement.conversion_id)
else:
conversion = None
channel, unit, measurement = return_measurement_info(
device_measurement, conversion)
try:
success_measure, measure = self.get_measurements_from_id(
device_id, measurement_id)
if success_measure:
measurement_dict = {
channel: {
'measurement': measurement,
'unit': unit,
'value': float(measure[1]),
'timestamp': measure[0],
}
}
measurement_success = True
break
except Exception as msg:
self.logger.exception("redundancy Error: {err}".format(err=msg))
if not measurement_success:
self.error_not_within_max_age()
elif self.math_type == 'statistics':
success, measure = self.get_measurements_from_str(self.inputs)
if success:
# Perform some math
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():
conversion = db_retrieve_table_daemon(
Conversion, unique_id=each_measurement.conversion_id)
channel, unit, measurement = return_measurement_info(
each_measurement, conversion)
measurement_dict[channel] = {
'measurement': measurement,
'unit': unit,
'value': list_measurement[channel]
}
elif measure:
self.logger.error(measure)
else:
self.error_not_within_max_age()
elif self.math_type == 'verification':
device_measurement = self.device_measurements.filter(
DeviceMeasurements.channel == 0).first()
if device_measurement:
conversion = db_retrieve_table_daemon(
Conversion, unique_id=device_measurement.conversion_id)
else:
conversion = None
channel, unit, measurement = return_measurement_info(
device_measurement, conversion)
success, measure = self.get_measurements_from_str(self.inputs)
if (success and
max(measure) - min(measure) <
self.max_difference):
difference = max(measure) - min(measure)
measurement_dict = {
channel: {
'measurement': measurement,
'unit': unit,
'value': difference
}
}
elif measure:
self.logger.error(measure)
else:
self.error_not_within_max_age()
elif self.math_type == 'humidity':
pressure_pa = 101325
critical_error = False
if self.pressure_pa_id and self.pressure_pa_measure_id:
success_pa, pressure = self.get_measurements_from_id(
self.pressure_pa_id, self.pressure_pa_measure_id)
if success_pa:
pressure_pa = int(pressure[1])
# Pressure must be in Pa, convert if not
if db_retrieve_table_daemon(DeviceMeasurements, unique_id=self.pressure_pa_measure_id):
measurement = db_retrieve_table_daemon(DeviceMeasurements, unique_id=self.pressure_pa_measure_id)
else:
self.logger.error("Could not find pressure measurement")
measurement = None
critical_error = True
if measurement and measurement.unit != 'Pa':
for each_conv in db_retrieve_table_daemon(Conversion, entry='all'):
if (each_conv.convert_unit_from == measurement.unit and
each_conv.convert_unit_to == 'Pa'):
pressure_pa = convert_units(
each_conv.unique_id, pressure_pa)
else:
self.logger.error(
"Could not find conversion for unit "
"{unit} to Pa (Pascals)".format(
unit=measurement.unit))
critical_error = True
success_dbt, dry_bulb_t = self.get_measurements_from_id(
self.dry_bulb_t_id, self.dry_bulb_t_measure_id)
success_wbt, wet_bulb_t = self.get_measurements_from_id(
self.wet_bulb_t_id, self.wet_bulb_t_measure_id)
if success_dbt and success_wbt:
dbt_kelvin = float(dry_bulb_t[1])
wbt_kelvin = float(wet_bulb_t[1])
if db_retrieve_table_daemon(DeviceMeasurements, unique_id=self.dry_bulb_t_measure_id):
measurement = db_retrieve_table_daemon(DeviceMeasurements, unique_id=self.dry_bulb_t_measure_id)
else:
self.logger.error("Could not find pressure measurement")
measurement = None
critical_error = True
if measurement and measurement.unit != 'K':
conversion_found = False
for each_conv in db_retrieve_table_daemon(Conversion, entry='all'):
if (each_conv.convert_unit_from == measurement.unit and
each_conv.convert_unit_to == 'K'):
dbt_kelvin = convert_units(
each_conv.unique_id, dbt_kelvin)
conversion_found = True
if not conversion_found:
self.logger.error(
"Could not find conversion for unit "
"{unit} to K (Kelvin)".format(
unit=measurement.unit))
critical_error = True
if db_retrieve_table_daemon(DeviceMeasurements, unique_id=self.dry_bulb_t_measure_id):
measurement = db_retrieve_table_daemon(DeviceMeasurements, unique_id=self.dry_bulb_t_measure_id)
else:
self.logger.error("Could not find pressure measurement")
measurement = None
critical_error = True
if measurement and measurement.unit != 'K':
conversion_found = False
for each_conv in db_retrieve_table_daemon(Conversion, entry='all'):
if (each_conv.convert_unit_from == measurement.unit and
each_conv.convert_unit_to == 'K'):
wbt_kelvin = convert_units(
each_conv.unique_id, wbt_kelvin)
conversion_found = True
if not conversion_found:
self.logger.error(
"Could not find conversion for unit "
"{unit} to K (Kelvin)".format(
unit=measurement.unit))
critical_error = True
# Convert temperatures to Kelvin (already done above)
# dbt_kelvin = celsius_to_kelvin(dry_bulb_t_c)
# wbt_kelvin = celsius_to_kelvin(wet_bulb_t_c)
psypi = None
try:
if not critical_error:
psypi = SI.state(
"DBT", dbt_kelvin, "WBT", wbt_kelvin, pressure_pa)
else:
self.logger.error(
"One or more critical errors prevented the "
"humidity from being calculated")
except TypeError as err:
self.logger.error("TypeError: {msg}".format(msg=err))
if psypi:
percent_relative_humidity = psypi[2] * 100
# Ensure percent humidity stays within 0 - 100 % range
if percent_relative_humidity > 100:
percent_relative_humidity = 100
elif percent_relative_humidity < 0:
percent_relative_humidity = 0
# Dry bulb temperature: psypi[0])
# Wet bulb temperature: psypi[5])
specific_enthalpy = float(psypi[1])
humidity = float(percent_relative_humidity)
specific_volume = float(psypi[3])
humidity_ratio = float(psypi[4])
list_measurement = [
specific_enthalpy,
humidity,
specific_volume,
humidity_ratio
]
for each_measurement in self.device_measurements.all():
conversion = db_retrieve_table_daemon(
Conversion, unique_id=each_measurement.conversion_id)
channel, unit, measurement = return_measurement_info(
each_measurement, conversion)
measurement_dict[channel] = {
'measurement': measurement,
'unit': unit,
'value': list_measurement[channel]
}
else:
self.error_not_within_max_age()
elif self.math_type == 'vapor_pressure_deficit':
vpd_pa = None
critical_error = False
success_dbt, temperature = self.get_measurements_from_id(
self.unique_id_1, self.unique_measurement_id_1)
success_wbt, humidity = self.get_measurements_from_id(
self.unique_id_2, self.unique_measurement_id_2)
if success_dbt and success_wbt:
vpd_temperature_celsius = float(temperature[1])
vpd_humidity_percent = float(humidity[1])
if db_retrieve_table_daemon(
DeviceMeasurements,
unique_id=self.unique_measurement_id_1):
measurement = db_retrieve_table_daemon(
DeviceMeasurements,
unique_id=self.unique_measurement_id_1)
else:
self.logger.error("Could not find temperature measurement")
measurement = None
critical_error = True
if measurement and measurement.unit != 'C':
conversion_found = False
for each_conv in db_retrieve_table_daemon(Conversion, entry='all'):
if (each_conv.convert_unit_from == measurement.unit and
each_conv.convert_unit_to == 'C'):
vpd_temperature_celsius = convert_units(
each_conv.unique_id, vpd_temperature_celsius)
conversion_found = True
if not conversion_found:
self.logger.error(
"Could not find conversion for unit "
"{unit} to C (Celsius)".format(
unit=measurement.unit))
critical_error = True
if db_retrieve_table_daemon(
DeviceMeasurements,
unique_id=self.unique_measurement_id_2):
measurement = db_retrieve_table_daemon(
DeviceMeasurements,
unique_id=self.unique_measurement_id_2)
else:
self.logger.error("Could not find humidity measurement")
measurement = None
critical_error = True
if measurement and measurement.unit != 'percent':
conversion_found = False
for each_conv in db_retrieve_table_daemon(Conversion, entry='all'):
if (each_conv.convert_unit_from == measurement.unit and
each_conv.convert_unit_to == 'percent'):
vpd_humidity_percent = convert_units(
each_conv.unique_id, vpd_humidity_percent)
conversion_found = True
if not conversion_found:
self.logger.error(
"Could not find conversion for unit "
"{unit} to percent (%)".format(
unit=measurement.unit))
critical_error = True
try:
if not critical_error:
vpd_pa = calculate_vapor_pressure_deficit(
vpd_temperature_celsius, vpd_humidity_percent)
else:
self.logger.error(
"One or more critical errors prevented the "
"vapor pressure deficit from being calculated")
except TypeError as err:
self.logger.error("TypeError: {msg}".format(msg=err))
if vpd_pa:
measure = self.device_measurements.first()
conversion = db_retrieve_table_daemon(
Conversion, unique_id=measure.conversion_id)
channel, unit, measurement = return_measurement_info(
measure, conversion)
measurement_dict[channel] = {
'measurement': measurement,
'unit': unit,
'value': vpd_pa
}
else:
self.error_not_within_max_age()
else:
self.logger.error("Unknown math type: {type}".format(type=self.math_type))
# Finally, add measurements to influxdb
add_measurements_influxdb(self.unique_id, measurement_dict)
def get_measurement(self):
""" Gets the humidity and temperature """
return_dict = measurements_dict.copy()
temperature = None
humidity = None
dew_point = None
measurements_success = False
# Ensure if the power pin turns off, it is turned back on
if (self.power_output_id and
db_retrieve_table_daemon(Output, unique_id=self.power_output_id) and
self.control.output_state(self.power_output_id) == 'off'):
self.logger.error(
'Sensor power output {rel} detected as being off. '
'Turning on.'.format(rel=self.power_output_id))
self.start_sensor()
time.sleep(2)
# Try twice to get measurement. This prevents an anomaly where
# the first measurement fails if the sensor has just been powered
# for the first time.
for _ in range(2):
dew_point, humidity, temperature = self.return_measurements()
if dew_point is not None:
measurements_success = True
break
time.sleep(2)
# Measurement failure, power cycle the sensor (if enabled)
# Then try two more times to get a measurement
if self.power_output_id and not measurements_success:
self.stop_sensor()
time.sleep(2)
self.start_sensor()
for _ in range(2):
dew_point, humidity, temperature = self.return_measurements()
if dew_point is not None:
measurements_success = True
break
time.sleep(2)
if measurements_success:
if self.is_enabled(0):
return_dict[0]['value'] = temperature
if self.is_enabled(1):
return_dict[1]['value'] = humidity
if (self.is_enabled(2) and
self.is_enabled(0) and
self.is_enabled(1)):
return_dict[2]['value'] = calculate_dewpoint(
return_dict[0]['value'], return_dict[1]['value'])
if (self.is_enabled(3) and
self.is_enabled(0) and
self.is_enabled(1)):
return_dict[3]['value'] = calculate_vapor_pressure_deficit(
return_dict[0]['value'], return_dict[1]['value'])
return return_dict
else:
self.logger.debug("Could not acquire a measurement")
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
