def get_measurement(self):
""" Measures temperature and humidity """
# Resetting these values ensures old measurements aren't mistaken for new measurements
return_dict = measurements_dict.copy()
# Actual input measurement code
try:
humidity = self.random.randint(0, 100)
temperature = self.random.randint(0, 50)
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'])
return return_dict
except Exception as msg:
self.logger.error("Exception: {}".format(msg))
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):
""" 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 get_measurement(self):
""" Measures temperature and humidity """
# Resetting these values ensures old measurements aren't mistaken for new measurements
self._dewpoint = None
self._humidity = None
self._temperature = None
dewpoint = None
humidity = None
temperature = None
# Actual input measurement code
try:
humidity = self.random.randint(0, 100)
temperature = self.random.randint(0, 50)
dewpoint = calculate_dewpoint(temperature, humidity)
except Exception as msg:
self.logger.error("Exception: {}".format(msg))
# Unit conversions
# A conversion may be specified for each measurement
# Humidity is returned as %, but may be converted to another unit (e.g. decimal)
humidity = convert_units('humidity', '%', self.convert_to_unit,
humidity)
# Temperature is returned as C, but may be converted to another unit (e.g. K, F)
temperature = convert_units('temperature', 'C', self.convert_to_unit,
temperature)
# Dewpoint is returned as C, but may be converted to another unit (e.g. K, F)
dewpoint = convert_units('dewpoint', 'C', self.convert_to_unit,
dewpoint)
return humidity, temperature, dewpoint
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()
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):
""" 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 """
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 """
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 temperature and humidity """
# Resetting these values ensures old measurements aren't mistaken for new measurements
self.return_dict = measurements_dict.copy()
# Actual input measurement code
try:
humidity = self.random.randint(0, 100)
temperature = self.random.randint(0, 50)
self.logger.info("This INFO message will always be displayed. "
"Acquiring measurements...")
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)):
dewpoint = calculate_dewpoint(self.value_get(0),
self.value_get(1))
self.value_set(2, dewpoint)
self.logger.debug(
"This DEBUG message will only be displayed if the Debug "
"option is enabled. {}".format(self.return_dict))
return self.return_dict
except Exception as msg:
self.logger.error("Exception: {}".format(msg))
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 measurement in units by reading the """
self._altitude = None
self._dew_point = None
self._humidity = None
self._pressure = None
self._temperature = None
temperature = convert_units(
'temperature', 'C', self.convert_to_unit,
self.sensor.read_temperature())
pressure_pa = self.sensor.read_pressure()
pressure = convert_units(
'pressure', 'Pa', self.convert_to_unit,
pressure_pa)
alt = convert_units(
'altitude', 'm', self.convert_to_unit,
altitude(pressure_pa))
humidity = convert_units(
'humidity', 'percent', self.convert_to_unit,
self.sensor.read_humidity())
dew_pt = convert_units(
'dewpoint', 'C', self.convert_to_unit,
calculate_dewpoint(temperature, humidity))
return alt, dew_pt, humidity, pressure, temperature
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 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 """
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):
""" 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):
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):
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 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 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):
"""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):
"""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):
""" 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):
""" 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):
"""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 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):
""" Gets the humidity and temperature """
self._dew_point = None
self._humidity = None
self._temperature = None
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
dew_pt = calculate_dewpoint(temperature, humidity)
# Check for conversions
dew_pt = convert_units('dewpoint', 'C', self.convert_to_unit, dew_pt)
temperature = convert_units('temperature', 'C', self.convert_to_unit,
temperature)
humidity = convert_units('humidity', 'percent', self.convert_to_unit,
humidity)
return dew_pt, humidity, temperature
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 return_measurements(self):
# Retry measurement if CRC fails
for num_measure in range(3):
humidity, temperature = self.am.data()
if humidity is None:
self.logger.debug(
"Measurement {num} returned failed CRC".format(
num=num_measure))
pass
else:
dew_pt = calculate_dewpoint(temperature, humidity)
return dew_pt, humidity, temperature
time.sleep(2)
self.logger.error("All measurements returned failed CRC")
return None, None, None
def get_measurement(self):
""" Gets the measurements """
return_dict = measurements_dict.copy()
if self.is_enabled(0):
return_dict[0]['value'] = self.sensor.read_CO2()
if self.is_enabled(1):
return_dict[1]['value'] = self.sensor.read_temperature()
if self.is_enabled(2):
return_dict[2]['value'] = self.sensor.read_humidity()
if (self.is_enabled(3) and
self.is_enabled(1) and
self.is_enabled(2)):
return_dict[3]['value'] = calculate_dewpoint(
return_dict[1]['value'], return_dict[2]['value'])
return return_dict
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 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
