def get_measurement(self): """ Gets the pwm """ self._frequency = None self._pulse_width = None self._duty_cycle = None pi = self.pigpio.pi() if not 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 read_pwm = ReadPWM(pi, self.gpio, self.pigpio, self.weighting) time.sleep(self.sample_time) frequency = convert_units( 'frequency', 'Hz', self.convert_to_unit, read_pwm.frequency()) pulse_width = int(read_pwm.pulse_width() + 0.5) duty_cycle = read_pwm.duty_cycle() read_pwm.cancel() pi.stop() duty_cycle = convert_units( 'duty_cycle', 'percent', self.convert_to_unit, duty_cycle) return frequency, pulse_width, duty_cycle
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): """ 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): """ 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 measurement in units by reading the BMP180/085 """ time.sleep(2) temperature = convert_units('temperature', 'C', self.convert_to_unit, self.bmp.read_temperature()) pressure = convert_units('pressure', 'Pa', self.convert_to_unit, self.bmp.read_pressure()) altitude = convert_units('altitude', 'm', self.convert_to_unit, self.bmp.read_altitude()) return temperature, pressure, altitude
def get_measurement(self): """ Gets the humidity and temperature """ self._dew_point = None self._humidity = None self._temperature = None dew_point = None humidity = None temperature = None 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) dew_point = calculate_dewpoint(temperature, humidity) return dew_point, humidity, temperature 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) dew_point = convert_units( 'dewpoint', 'C', self.convert_to_unit, dew_point) temperature = convert_units( 'temperature', 'C', self.convert_to_unit, temperature) humidity = convert_units( 'humidity', 'percent', self.convert_to_unit, humidity) return dew_point, humidity, temperature
def get_measurement(self): """ Gets the measurement in units by reading the """ self._temperature = None self._temperature_die = None temp = self.sensor.readThermocoupleTemp() temp = convert_units( 'temperature', 'C', self.convert_to_unit, temp) temp_die = self.sensor.readJunctionTemp() temp_die = convert_units( 'temperature_die', 'C', self.convert_to_unit, temp_die) return temp, temp_die
def get_measurement(self): """ Gets the measurement in units by reading the """ self._temperature = None self._temperature_die = None temp = self.sensor.readTempC() temp = convert_units( 'temperature', 'C', self.convert_to_unit, temp) temp_die = self.sensor.readInternalC() temp_die = convert_units( 'temperature_die', 'C', self.convert_to_unit, temp_die) return temp, temp_die
def get_measurement(self): """ Gets the TMP006's temperature in Celsius """ self._temperature_die = None self._temperature_object = None self.sensor.begin() temperature_die = convert_units('temperature_die', 'C', self.convert_to_unit, self.sensor.readDieTempC()) temperature_object = convert_units('temperature_object', 'C', self.convert_to_unit, self.sensor.readObjTempC()) return temperature_die, temperature_object
def math_sum_single(self, measurement_dict): (device_id, math_dev_measurement, math_unit, measure_channel, measure_unit, measure_measurement) = self.return_single_measure_info() try: return_value = sum_past_seconds(device_id, measure_unit, measure_channel, self.max_measure_age, measure=measure_measurement) if math_dev_measurement.conversion_id: return_value = convert_units( math_dev_measurement.conversion_id, return_value) if return_value: measurement_dict = { math_dev_measurement.channel: { 'measurement': measure_measurement, 'unit': math_unit, 'value': return_value } } else: self.error_not_within_max_age() except Exception as msg: self.logger.exception("sum_single Error: {err}".format(err=msg)) return measurement_dict
def get_measurement(self): """ Gets the DS18B20's temperature in Celsius """ self._temperature = None temperature = None n = 2 for i in range(n): try: temperature = self.sensor.get_temperature() break except Exception as e: if i == n: self.logger.exception( "{cls} raised an exception when taking a reading: " "{err}".format(cls=type(self).__name__, err=e)) time.sleep(1) if temperature == 85: self.logger.error( "Measurement returned 85 C, " "Indicating an issue communicating with the sensor.") return None elif temperature is not None and -55 > temperature > 125: self.logger.error( "Measurement outside the expected range of -55 C to 125 C: " "{temp} C".format(temp=self._temperature)) return None temperature = convert_units('temperature', 'C', self.convert_to_unit, temperature) return temperature
def get_measurement(self): """ Gets the sensor's Electrical Conductivity measurement via UART/I2C """ self._electrical_conductivity = None electrical_conductivity = None # Read sensor via UART if self.interface == 'UART': if self.atlas_sensor_uart.setup: lines = self.atlas_sensor_uart.query('R') if lines: self.logger.debug("All Lines: {lines}".format(lines=lines)) # 'check probe' indicates an error reading the sensor if 'check probe' in lines: self.logger.error('"check probe" returned from sensor') # if a string resembling a float value is returned, this # is out measurement value elif str_is_float(lines[0]): electrical_conductivity = float(lines[0]) self.logger.debug('Value[0] is float: {val}'.format( val=electrical_conductivity)) else: # During calibration, the sensor is put into # continuous mode, which causes a return of several # values in one string. If the return value does # not represent a float value, it is likely to be a # string of several values. This parses and returns # the first value. if str_is_float(lines[0].split(b'\r')[0]): electrical_conductivity = lines[0].split(b'\r')[0] # Lastly, this is called if the return value cannot # be determined. Watchthe output in the GUI to see # what it is. else: electrical_conductivity = lines[0] self.logger.error( 'Value[0] is not float or "check probe": ' '{val}'.format(val=electrical_conductivity)) else: self.logger.error('UART device is not set up.' 'Check the log for errors.') # Read sensor via I2C elif self.interface == 'I2C': if self.atlas_sensor_i2c.setup: ec_status, ec_str = self.atlas_sensor_i2c.query('R') if ec_status == 'error': self.logger.error( "Sensor read unsuccessful: {err}".format(err=ec_str)) elif ec_status == 'success': electrical_conductivity = float(ec_str) else: self.logger.error( 'I2C device is not set up. Check the log for errors.') electrical_conductivity = convert_units('electrical_conductivity', 'μS_cm', self.convert_to_unit, electrical_conductivity) return electrical_conductivity
def get_measurement(self): """ Gets the MH-Z16's CO2 concentration in ppmv via UART""" self._co2 = None co2 = None if self.interface == 'UART': if not self.serial_device: # Don't measure if device isn't validated return None self.ser.flushInput() time.sleep(1) self.ser.write( bytearray( [0xff, 0x01, 0x86, 0x00, 0x00, 0x00, 0x00, 0x00, 0x79])) time.sleep(.01) resp = self.ser.read(9) if len(resp) != 0: high = resp[2] low = resp[3] co2 = (high * 256) + low elif self.interface == 'I2C': self.write_register(self.FCR, 0x07) self.send(self.cmd_measure) try: co2 = self.parse(self.receive()) except Exception: co2 = None co2 = convert_units('co2', 'ppm', self.convert_to_unit, co2) return co2
def get_measurement(self, silent=False): """ Gets the MH-Z19's CO2 concentration in ppmv via UART""" self._co2 = None co2 = None if not self.serial_device: # Don't measure if device isn't validated return None self.ser.flushInput() self.ser.write( bytearray([0xff, 0x01, 0x86, 0x00, 0x00, 0x00, 0x00, 0x00, 0x79])) time.sleep(.01) resp = self.ser.read(9) if resp[0] != 0xff or resp[1] != 0x86: self.logger.error("Bad checksum") elif len(resp) >= 4: high = resp[2] low = resp[3] co2 = (high * 256) + low else: self.logger.error("Bad response") co2 = convert_units('co2', 'ppm', self.convert_to_unit, co2) return co2
def get_measurement(self): """ Gets the revolutions """ self._revolutions = None pi = self.pigpio.pi() if not pi.connected: # Check if pigpiod is running self.logger.error("Could not connect to pigpiod." "Ensure it is running and try again.") return None read_revolutions = ReadRPM(pi, self.gpio, self.pigpio, self.rpm_pulses_per_rev, self.weighting) time.sleep(self.sample_time) rpm = read_revolutions.RPM() if rpm: rpm = int(rpm + 0.5) rpm = convert_units('revolutions', 'RPM', self.convert_to_unit, rpm) read_revolutions.cancel() pi.stop() if rpm: return rpm elif rpm == 0: return 0 else: return None
def get_measurement(self): """ Gets the measurement in units by reading the """ self._temperature = None temp = self.sensor.readTemp(self.thermocouple_type, self.ref_ohm) temp = convert_units('temperature', 'C', self.convert_to_unit, temp) return temp
def get_measurement(self): """ Gets the CO2, VOC, and temperature """ self._co2 = None self._voc = None self._temperature = None temperature = convert_units('temperature', 'C', self.convert_to_unit, self.sensor.calculateTemperature()) if not self.sensor.readData(): co2 = convert_units('co2', 'ppm', self.convert_to_unit, self.sensor.geteCO2()) voc = convert_units('voc', 'ppb', self.convert_to_unit, self.sensor.getTVOC()) return co2, voc, temperature else: return None, None, None
def get_measurement(self): """ Gets the free space """ f = os.statvfs(self.path) disk_space = (f.f_bsize * f.f_bavail) / 1000000.0 disk_space = convert_units('disk_space', 'MB', self.convert_to_unit, disk_space) return disk_space
def get_measurement(self): """ Gets the light, moisture, and temperature """ self._lux = None self._moisture = None self._temperature = None lux = self.filter_average('lux', measurement=self.light()) lux = convert_units( 'light', 'lux', self.convert_to_unit, lux) moisture = self.moist() temperature = convert_units( 'temperature', 'C', self.convert_to_unit, self.temp() / 10.0) return lux, moisture, temperature
def get_measurement(self): """ Calls the vcgencmd in a subprocess and reads the GPU temperature """ gputempstr = subprocess.check_output( ('/opt/vc/bin/vcgencmd', 'measure_temp')) # example output: temp=42.8'C temperature = float(gputempstr.split('=')[1].split("'")[0]) temperature = convert_units('temperature', 'C', self.convert_to_unit, temperature) return temperature
def get_measurement(self): """ Gets the TSL2591's lux """ full, ir = self.tsl.get_full_luminosity() # read raw values (full spectrum and ir spectrum) # convert raw values to lux (and convert to user-selected unit, if necessary) lux = convert_units( 'light', 'lux', self.convert_to_unit, self.tsl.calculate_lux(full, ir)) return lux
def get_measurement(self): """ Gets the humidity and temperature """ self._dew_point = None self._humidity = None self._temperature = None temperature = convert_units('temperature', 'C', self.convert_to_unit, self.sht_sensor.read_t()) humidity = self.sht_sensor.read_rh() dew_point = self.sht_sensor.read_dew_point(temperature, humidity) dew_point = convert_units('dewpoint', 'C', self.convert_to_unit, dew_point) humidity = convert_units('humidity', 'percent', self.convert_to_unit, humidity) return dew_point, humidity, temperature
def get_measurement(self): """ Gets the measurement in units by reading the """ self._altitude = None self._pressure = None self._temperature = None temperature = convert_units( 'temperature', 'C', self.convert_to_unit, self.read_temperature()) pressure_pa = self.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)) return temperature, pressure, alt
def get_measurement(self): """ Gets the humidity and temperature """ self._dew_point = None self._humidity = None self._temperature = None temperature = self.read_temperature() humidity = self.read_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 is_measurement_unit(self, unit_from, unit_to, value): """ Converts value from one measurement to another """ if unit_from != unit_to: for each_conv in db_retrieve_table_daemon(Conversion, entry='all'): if (each_conv.convert_unit_from == unit_from and each_conv.convert_unit_to == unit_to): return_value = convert_units(each_conv.unique_id, value) return return_value, 'success' else: self.logger.error( "Could not find conversion for unit " "{unit_from} to {unit_to}".format(unit_from=unit_from, unit_to=unit_to)) return None, 'error'
def get_measurement(self): """ Gets the measurement in units by reading resource """ self._disk_space = None disk_space = None try: disk_space = resource.getrusage( resource.RUSAGE_SELF).ru_maxrss / float(1000) except Exception: pass disk_space = convert_units('disk_space', 'MB', self.convert_to_unit, disk_space) return disk_space
def get_measurement(self): """ Gets the BH1750's lux """ self._lux = None if self.resolution == 0: lux = self.measure_low_res() elif self.resolution == 1: lux = self.measure_high_res() elif self.resolution == 2: lux = self.measure_high_res2() else: return None lux = convert_units('light', 'lux', self.convert_to_unit, lux) return lux
def get_measurement(self): """ Gets the humidity and temperature """ self._dew_point = None self._humidity = None self._temperature = None # 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: dew_point = convert_units('dewpoint', 'C', self.convert_to_unit, dew_point) temperature = convert_units('temperature', 'C', self.convert_to_unit, temperature) humidity = convert_units('humidity', 'percent', self.convert_to_unit, humidity) return dew_point, humidity, temperature # success - no errors 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: 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: dew_point = convert_units('dewpoint', 'C', self.convert_to_unit, dew_point) temperature = convert_units('temperature', 'C', self.convert_to_unit, temperature) humidity = convert_units('humidity', 'percent', self.convert_to_unit, humidity) return dew_point, humidity, temperature # success time.sleep(2) self.logger.debug("Could not acquire a measurement") return None, None, None
def get_measurement(self): """ Gets the Raspberry pi's temperature in Celsius by reading the temp file and div by 1000 """ # import psutil # import resource # open_files_count = 0 # for proc in psutil.process_iter(): # if proc.open_files(): # open_files_count += 1 # self.logger.info("Open files: {of}".format(of=open_files_count)) # soft, hard = resource.getrlimit(resource.RLIMIT_NOFILE) # self.logger.info("LIMIT: Soft: {sft}, Hard: {hrd}".format(sft=soft, hrd=hard)) with open('/sys/class/thermal/thermal_zone0/temp') as cpu_temp_file: temperature = convert_units('temperature', 'C', self.convert_to_unit, float(cpu_temp_file.read()) / 1000) return temperature
def get_measurement(self): """ Gets the DS18S20's temperature in Celsius """ self._temperature = None temperature = None n = 2 for i in range(n): try: temperature = self.sensor.get_temperature() break except Exception as e: if i == n: self.logger.exception( "{cls} raised an exception when taking a reading: " "{err}".format(cls=type(self).__name__, err=e)) time.sleep(1) temperature = convert_units('temperature', 'C', self.convert_to_unit, temperature) return temperature
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)