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