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 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_temp_data(self): """Get the temperature, from onboard or off.""" from anyleaf import OffBoard from anyleaf import OnBoard last_measurement = None if self.temperature_comp_meas_measurement_id: last_measurement = self.get_last_measurement( self.temperature_comp_meas_device_id, self.temperature_comp_meas_measurement_id, max_age=self.max_age) if last_measurement and len(last_measurement) > 1: device_measurement = get_measurement( self.temperature_comp_meas_measurement_id) conversion = db_retrieve_table_daemon( Conversion, unique_id=device_measurement.conversion_id) _, unit, _ = return_measurement_info( device_measurement, conversion) if unit != "C": out_value = convert_from_x_to_y_unit( unit, "C", last_measurement[1]) else: out_value = last_measurement[1] return OffBoard(out_value) else: return OnBoard()
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 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): 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): """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): 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) 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') # Convert temperature to SI unit Celsius if self.is_enabled(0): if ('TempUnit' in dict_data['StatusSNS'] and dict_data['StatusSNS']['TempUnit']): temp_c = convert_from_x_to_y_unit( dict_data['StatusSNS']['TempUnit'], 'C', dict_data['StatusSNS']['DS18B20']['Temperature']) else: temp_c = dict_data['StatusSNS']['DS18B20']['Temperature'] self.value_set(0, temp_c, timestamp=datetime_timestmp) return self.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): """ 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): 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 = 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): temp_c = convert_from_x_to_y_unit( 'F', 'C', dict_data['StatusSNS']['AM2301']['Temperature']) self.set_value(0, temp_c, timestamp=datetime_timestmp) if self.is_enabled(1): humidity = dict_data['StatusSNS']['AM2301']['Humidity'] self.set_value(1, humidity, timestamp=datetime_timestmp) if (self.is_enabled(2) and self.is_enabled(0) and self.is_enabled(1)): dewpoint = calculate_dewpoint( self.get_value(0), self.get_value(1)) self.set_value(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.get_value(0), self.get_value(1)) self.set_value(3, vpd, timestamp=datetime_timestmp) return self.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) 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_temp_data(self): """Get the temperature.""" if self.temperature_comp_meas_measurement_id: self.logger.debug("Temperature corrections will be applied") last_measurement = self.get_last_measurement( self.temperature_comp_meas_device_id, self.temperature_comp_meas_measurement_id, max_age=self.max_age) if last_measurement and len(last_measurement) > 1: device_measurement = get_measurement( self.temperature_comp_meas_measurement_id) conversion = db_retrieve_table_daemon( Conversion, unique_id=device_measurement.conversion_id) _, unit, _ = return_measurement_info(device_measurement, conversion) if unit != "C": out_value = convert_from_x_to_y_unit( unit, "C", last_measurement[1]) else: out_value = last_measurement[1] self.logger.debug( "Latest temperature: {temp} C".format(temp=out_value)) else: self.logger.error( "Temperature measurement not found within the " "past {} seconds".format(self.max_age)) out_value = None else: self.logger.debug("No temperature corrections applied") out_value = None return out_value
def get_measurement(self): """Gets the sensor's ORP measurement.""" if not self.atlas_device.setup: self.logger.error( "Error 101: Device not set up. See https://kizniche.github.io/Mycodo/Error-Codes#error-101 for more info." ) return orp = None self.return_dict = copy.deepcopy(measurements_dict) # Compensate measurement based on a temperature measurement if self.temperature_comp_meas_measurement_id and self.atlas_command: self.logger.debug("pH sensor set to calibrate temperature") last_measurement = self.get_last_measurement( self.temperature_comp_meas_device_id, self.temperature_comp_meas_measurement_id, max_age=self.max_age) if last_measurement and len(last_measurement) > 1: device_measurement = get_measurement( self.temperature_comp_meas_measurement_id) conversion = db_retrieve_table_daemon( Conversion, unique_id=device_measurement.conversion_id) _, unit, _ = return_measurement_info(device_measurement, conversion) if unit != "C": out_value = convert_from_x_to_y_unit( unit, "C", last_measurement[1]) else: out_value = last_measurement[1] self.logger.debug( "Latest temperature used to calibrate: {temp}".format( temp=out_value)) ret_value, ret_msg = self.atlas_command.calibrate( 'temperature', set_amount=out_value) time.sleep(0.5) self.logger.debug("Calibration returned: {val}, {msg}".format( val=ret_value, msg=ret_msg)) else: self.logger.error( "Calibration measurement not found within the past {} seconds" .format(self.max_age)) # Read device atlas_status, atlas_return = self.atlas_device.query('R') self.logger.debug("Device Returned: {}: {}".format( atlas_status, atlas_return)) if atlas_status == 'error': self.logger.error( "Sensor read unsuccessful: {err}".format(err=atlas_return)) return # Parse device return data if self.interface in ['FTDI', 'UART']: # Find float value in list float_value = None for each_split in atlas_return: if str_is_float(each_split): float_value = each_split break if 'check probe' in atlas_return: self.logger.error('"check probe" returned from sensor') elif str_is_float(float_value): orp = float(float_value) self.logger.debug('Found float value: {val}'.format(val=orp)) else: self.logger.error( 'Value or "check probe" not found in list: {val}'.format( val=atlas_return)) elif self.interface == 'I2C': orp = float(atlas_return) self.value_set(0, orp) return self.return_dict
def get_measurement(self): """Gets the sensor's Electrical Conductivity measurement""" if not self.atlas_device.setup: self.logger.error("Error 101: Device not set up. See https://kizniche.github.io/Mycodo/Error-Codes#error-101 for more info.") return return_string = None self.return_dict = copy.deepcopy(measurements_dict) # Compensate measurement based on a temperature measurement if self.temperature_comp_meas_measurement_id and self.atlas_command: self.logger.debug("pH sensor set to calibrate temperature") last_measurement = self.get_last_measurement( self.temperature_comp_meas_device_id, self.temperature_comp_meas_measurement_id, max_age=self.max_age) if last_measurement and len(last_measurement) > 1: device_measurement = get_measurement( self.temperature_comp_meas_measurement_id) conversion = db_retrieve_table_daemon( Conversion, unique_id=device_measurement.conversion_id) _, unit, _ = return_measurement_info( device_measurement, conversion) if unit != "C": out_value = convert_from_x_to_y_unit( unit, "C", last_measurement[1]) else: out_value = last_measurement[1] self.logger.debug( "Latest temperature used to calibrate: {temp}".format( temp=out_value)) ret_value, ret_msg = self.atlas_command.calibrate( 'temperature', set_amount=out_value) time.sleep(0.5) self.logger.debug("Calibration returned: {val}, {msg}".format( val=ret_value, msg=ret_msg)) else: self.logger.error( "Calibration measurement not found within the past " "{} seconds".format(self.max_age)) # Read device atlas_status, atlas_return = self.atlas_device.query('R') self.logger.debug("Device Returned: {}: {}".format(atlas_status, atlas_return)) if atlas_status == 'error': self.logger.error("Sensor read unsuccessful: {err}".format(err=atlas_return)) return # Parse device return data if self.interface in ['FTDI', 'UART']: # Check for "check probe" for each_split in atlas_return: if 'check probe' in each_split: self.logger.error('"check probe" returned from sensor') return # Find float value in list for each_split in atlas_return: if "," in each_split or str_is_float(each_split): return_string = each_split break elif self.interface == 'I2C': return_string = atlas_return if return_string and ',' in return_string: # Multiple values returned index_place = 0 return_list = return_string.split(',') if (self.is_enabled(0) and len(return_list) > index_place and str_is_float(return_list[index_place])): self.value_set(0, float(return_list[index_place])) index_place += 1 if (self.is_enabled(1) and len(return_list) > index_place and str_is_float(return_list[index_place])): self.value_set(1, float(return_list[index_place])) index_place += 1 if (self.is_enabled(2) and len(return_list) > index_place and str_is_float(return_list[index_place])): self.value_set(2, float(return_list[index_place])) index_place += 1 if (self.is_enabled(3) and len(return_list) > index_place and str_is_float(return_list[index_place])): self.value_set(3, float(return_list[index_place])) elif str_is_float(return_string): # Single value returned if self.is_enabled(0): self.value_set(0, float(return_string)) elif self.is_enabled(1): self.value_set(1, float(return_string)) elif self.is_enabled(2): self.value_set(2, float(return_string)) elif self.is_enabled(3): self.value_set(3, float(return_string)) return self.return_dict
def loop(self): if self.timer_loop > time.time(): return while self.timer_loop < time.time(): self.timer_loop += self.period temp_c = None hum_percent = None vpd_pa = None last_measurement_temp = self.get_last_measurement( self.select_measurement_temperature_c_device_id, self.select_measurement_temperature_c_measurement_id, max_age=self.max_measure_age_temperature_c) if last_measurement_temp: device_measurement = get_measurement( self.select_measurement_temperature_c_measurement_id) conversion = db_retrieve_table_daemon( Conversion, unique_id=device_measurement.conversion_id) channel, unit, measurement = return_measurement_info( device_measurement, conversion) temp_c = convert_from_x_to_y_unit(unit, 'C', last_measurement_temp[1]) last_measurement_hum = self.get_last_measurement( self.select_measurement_humidity_device_id, self.select_measurement_humidity_measurement_id, max_age=self.max_measure_age_humidity) if last_measurement_hum: device_measurement = get_measurement( self.select_measurement_humidity_measurement_id) conversion = db_retrieve_table_daemon( Conversion, unique_id=device_measurement.conversion_id) channel, unit, measurement = return_measurement_info( device_measurement, conversion) hum_percent = convert_from_x_to_y_unit(unit, 'percent', last_measurement_hum[1]) if temp_c and hum_percent: measurement_dict = copy.deepcopy(measurements_dict) try: vpd_pa = calculate_vapor_pressure_deficit(temp_c, hum_percent) except TypeError as err: self.logger.error("Error: {msg}".format(msg=err)) if vpd_pa: dev_measurement = self.channels_measurement[0] channel, unit, measurement = return_measurement_info( dev_measurement, self.channels_conversion[0]) vpd_store = convert_from_x_to_y_unit('Pa', unit, vpd_pa) measurement_dict[0] = { 'measurement': measurement, 'unit': unit, 'value': vpd_store } # Add measurement(s) to influxdb if measurement_dict: self.logger.debug( "Adding measurements to InfluxDB with ID {}: {}".format( self.unique_id, measurement_dict)) add_measurements_influxdb(self.unique_id, measurement_dict) else: self.logger.debug( "No measurements to add to InfluxDB with ID {}".format( self.unique_id)) else: self.logger.debug( "Could not acquire both temperature and humidity measurements." )
def get_measurement(self): """ Gets the sensor's ORP measurement """ if not self.atlas_device.setup: self.logger.error("Input not set up") return orp = None self.return_dict = copy.deepcopy(measurements_dict) # Compensate measurement based on a temperature measurement if self.temperature_comp_meas_measurement_id and self.atlas_command: self.logger.debug("pH sensor set to calibrate temperature") device_measurement = get_measurement( self.temperature_comp_meas_measurement_id) conversion = db_retrieve_table_daemon( Conversion, unique_id=device_measurement.conversion_id) channel, unit, measurement = return_measurement_info( device_measurement, conversion) last_measurement = self.get_last_measurement( self.temperature_comp_meas_device_id, self.temperature_comp_meas_measurement_id, max_age=self.max_age) out_value = convert_from_x_to_y_unit(unit, "C", last_measurement[1]) if last_measurement: self.logger.debug( "Latest temperature used to calibrate: {temp}".format( temp=out_value)) ret_value, ret_msg = self.atlas_command.calibrate( 'temperature', set_amount=out_value) time.sleep(0.5) self.logger.debug("Calibration returned: {val}, {msg}".format( val=ret_value, msg=ret_msg)) else: self.logger.error( "Calibration measurement not found within the past {} seconds" .format(self.max_age)) # Read sensor via FTDI or UART if self.interface in ['FTDI', 'UART']: orp_status, orp_list = self.atlas_device.query('R') if orp_list: self.logger.debug( "Returned list: {lines}".format(lines=orp_list)) # Find float value in list float_value = None for each_split in orp_list: if str_is_float(each_split): float_value = each_split break if 'check probe' in orp_list: self.logger.error('"check probe" returned from sensor') elif str_is_float(float_value): orp = float(float_value) self.logger.debug('Found float value: {val}'.format(val=orp)) else: self.logger.error( 'Value or "check probe" not found in list: {val}'.format( val=orp_list)) # Read sensor via I2C elif self.interface == 'I2C': ec_status, ec_str = self.atlas_device.query('R') if ec_status == 'error': self.logger.error( "Sensor read unsuccessful: {err}".format(err=ec_str)) elif ec_status == 'success': orp = float(ec_str) self.value_set(0, orp) return self.return_dict
def get_measurement(self): """ Gets the sensor's Electrical Conductivity measurement """ if not self.atlas_device.setup: self.logger.error("Input not set up") return return_string = None self.return_dict = copy.deepcopy(measurements_dict) # Compensate measurement based on a temperature measurement if self.temperature_comp_meas_measurement_id and self.atlas_command: self.logger.debug("pH sensor set to calibrate temperature") device_measurement = get_measurement( self.temperature_comp_meas_measurement_id) conversion = db_retrieve_table_daemon( Conversion, unique_id=device_measurement.conversion_id) channel, unit, measurement = return_measurement_info( device_measurement, conversion) last_measurement = self.get_last_measurement( self.temperature_comp_meas_device_id, self.temperature_comp_meas_measurement_id, max_age=self.max_age) out_value = convert_from_x_to_y_unit(unit, "C", last_measurement[1]) if last_measurement: self.logger.debug( "Latest temperature used to calibrate: {temp}".format( temp=out_value)) ret_value, ret_msg = self.atlas_command.calibrate( 'temperature', set_amount=out_value) time.sleep(0.5) self.logger.debug("Calibration returned: {val}, {msg}".format( val=ret_value, msg=ret_msg)) else: self.logger.error( "Calibration measurement not found within the past " "{} seconds".format(self.max_age)) # Read sensor via FTDI or UART if self.interface in ['FTDI', 'UART']: ec_status, ec_list = self.atlas_device.query('R') if ec_list: self.logger.debug("Return list: '{}'".format(ec_list)) # Check for "check probe" for each_split in ec_list: if 'check probe' in each_split: self.logger.error('"check probe" returned from sensor') return # Find float value in list for each_split in ec_list: if "," in each_split or str_is_float(each_split): return_string = each_split break # Read sensor via I2C elif self.interface == 'I2C': ec_status, return_string = self.atlas_device.query('R') if ec_status == 'error': self.logger.error("Sensor read unsuccessful: {err}".format( err=return_string)) self.logger.debug("Return string: '{}'".format(return_string)) if ',' in return_string: # Multiple values returned index_place = 0 return_list = return_string.split(',') if (self.is_enabled(0) and len(return_list) > index_place and str_is_float(return_list[index_place])): self.value_set(0, float(return_list[index_place])) index_place += 1 if (self.is_enabled(1) and len(return_list) > index_place and str_is_float(return_list[index_place])): self.value_set(1, float(return_list[index_place])) index_place += 1 if (self.is_enabled(2) and len(return_list) > index_place and str_is_float(return_list[index_place])): self.value_set(2, float(return_list[index_place])) index_place += 1 if (self.is_enabled(3) and len(return_list) > index_place and str_is_float(return_list[index_place])): self.value_set(3, float(return_list[index_place])) elif str_is_float(return_string): # Single value returned if self.is_enabled(0): self.value_set(0, float(return_string)) elif self.is_enabled(1): self.value_set(1, float(return_string)) elif self.is_enabled(2): self.value_set(2, float(return_string)) elif self.is_enabled(3): self.value_set(3, float(return_string)) return self.return_dict
def run_function(self): temp_wet_k = None temp_dry_k = None pressure_pa = 101325 if (self.select_measurement_pressure_pa_device_id and self.select_measurement_pressure_pa_measurement_id and self.max_measure_age_pressure_pa): device_measurement = get_measurement( self.select_measurement_pressure_pa_measurement_id) conversion = db_retrieve_table_daemon( Conversion, unique_id=device_measurement.conversion_id) channel, unit, measurement = return_measurement_info( device_measurement, conversion) last_measurement_pa = self.get_last_measurement( self.select_measurement_pressure_pa_device_id, self.select_measurement_pressure_pa_measurement_id, max_age=self.max_measure_age_pressure_pa) if last_measurement_pa: pressure_pa = convert_from_x_to_y_unit(unit, 'Pa', last_measurement_pa[1]) last_measurement_wet = self.get_last_measurement( self.select_measurement_temp_wet_c_device_id, self.select_measurement_temp_wet_c_measurement_id, max_age=self.max_measure_age_temp_wet_c) if last_measurement_wet: device_measurement = get_measurement( self.select_measurement_temp_wet_c_measurement_id) conversion = db_retrieve_table_daemon( Conversion, unique_id=device_measurement.conversion_id) channel, unit, measurement = return_measurement_info( device_measurement, conversion) temp_wet_k = convert_from_x_to_y_unit(unit, 'K', last_measurement_wet[1]) last_measurement_dry = self.get_last_measurement( self.select_measurement_temp_dry_c_device_id, self.select_measurement_temp_dry_c_measurement_id, max_age=self.max_measure_age_temp_dry_c) if last_measurement_dry: device_measurement = get_measurement( self.select_measurement_temp_dry_c_measurement_id) conversion = db_retrieve_table_daemon( Conversion, unique_id=device_measurement.conversion_id) channel, unit, measurement = return_measurement_info( device_measurement, conversion) temp_dry_k = convert_from_x_to_y_unit(unit, 'K', last_measurement_dry[1]) if temp_wet_k and temp_dry_k: measurements = copy.deepcopy(measurements_dict) psypi = None try: psypi = SI.state("DBT", temp_dry_k, "WBT", temp_wet_k, pressure_pa) except TypeError as err: self.logger.error("TypeError: {msg}".format(msg=err)) if not psypi: self.logger.error( "Could not calculate humidity from wet/dry bulbs") return 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]) self.logger.debug("Dry Temp: {dtk}, " "Wet Temp: {wtk}, " "Pressure: {pres}," "Humidity: {rh}".format(dtk=temp_dry_k, wtk=temp_wet_k, pres=pressure_pa, rh=humidity)) list_measurement = [ humidity, humidity_ratio, specific_enthalpy, specific_volume ] for each_measurement in self.device_measurements.all(): if each_measurement.is_enabled: conversion = db_retrieve_table_daemon( Conversion, unique_id=each_measurement.conversion_id) channel, unit, measurement = return_measurement_info( each_measurement, conversion) measurements[channel] = { 'measurement': measurement, 'unit': unit, 'value': list_measurement[channel] } # Add measurement(s) to influxdb if measurements: self.logger.debug( "Adding measurements to InfluxDB with ID {}: {}".format( self.unique_id, measurements)) add_measurements_influxdb(self.unique_id, measurements) else: self.logger.debug( "No measurements to add to InfluxDB with ID {}".format( self.unique_id))