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))
