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