def __init__(self, input_dev):
self.cmd_send = None
self.ph_sensor_uart = None
self.ph_sensor_i2c = None
self.interface = input_dev.interface
if self.interface == 'FTDI':
from mycodo.devices.atlas_scientific_ftdi import AtlasScientificFTDI
self.ph_sensor_ftdi = AtlasScientificFTDI(
input_dev.ftdi_location)
elif self.interface == 'UART':
from mycodo.devices.atlas_scientific_uart import AtlasScientificUART
self.ph_sensor_uart = AtlasScientificUART(
input_dev.uart_location,
baudrate=input_dev.baud_rate)
elif self.interface == 'I2C':
from mycodo.devices.atlas_scientific_i2c import AtlasScientificI2C
self.ph_sensor_i2c = AtlasScientificI2C(
i2c_address=int(str(input_dev.i2c_location), 16),
i2c_bus=input_dev.i2c_bus)
self.board_version, self.board_info = self.get_board_version()
if self.board_version == 0:
logger.error("Unable to retrieve device info (this indicates the "
"device was not properly initialized or connected)")
else:
# TODO: Change back to debug
logger.error("Device Info: {info}".format(info=self.board_info))
logger.error("Detected Version: {ver}".format(ver=self.board_version))
def __init__(self, input_dev):
self.cmd_send = None
self.ph_sensor_uart = None
self.ph_sensor_i2c = None
self.interface = input_dev.interface
if self.interface == 'FTDI':
from mycodo.devices.atlas_scientific_ftdi import AtlasScientificFTDI
self.ph_sensor_ftdi = AtlasScientificFTDI(input_dev.ftdi_location)
elif self.interface == 'UART':
from mycodo.devices.atlas_scientific_uart import AtlasScientificUART
self.ph_sensor_uart = AtlasScientificUART(
input_dev.uart_location, baudrate=input_dev.baud_rate)
elif self.interface == 'I2C':
from mycodo.devices.atlas_scientific_i2c import AtlasScientificI2C
self.ph_sensor_i2c = AtlasScientificI2C(i2c_address=int(
str(input_dev.i2c_location), 16),
i2c_bus=input_dev.i2c_bus)
self.measurement, self.board_version, self.firmware_version = self.get_board_version(
)
if self.board_version == 0:
logger.error("Atlas Scientific board initialization unsuccessful. "
"Unable to retrieve device info (this indicates the "
"device was not properly initialized or connected)")
else:
# TODO: Change back to debug
logger.info(
"Atlas Scientific board initialization success. "
"Measurement: {meas}, Board: {brd}, Firmware: {fw}".format(
meas=self.measurement,
brd=self.board_version,
fw=self.firmware_version))
def initialize_sensor(self):
from mycodo.devices.atlas_scientific_ftdi import AtlasScientificFTDI
from mycodo.devices.atlas_scientific_i2c import AtlasScientificI2C
from mycodo.devices.atlas_scientific_uart import AtlasScientificUART
if self.interface == 'FTDI':
self.atlas_sensor_ftdi = AtlasScientificFTDI(self.ftdi_location)
elif self.interface == 'UART':
self.atlas_sensor_uart = AtlasScientificUART(self.uart_location)
elif self.interface == 'I2C':
self.atlas_sensor_i2c = AtlasScientificI2C(
i2c_address=self.i2c_address, i2c_bus=self.i2c_bus)
def initialize_sensor(self):
from mycodo.devices.atlas_scientific_ftdi import AtlasScientificFTDI
from mycodo.devices.atlas_scientific_i2c import AtlasScientificI2C
from mycodo.devices.atlas_scientific_uart import AtlasScientificUART
if self.interface == 'FTDI':
self.logger = logging.getLogger(
"mycodo.inputs.atlas_electrical_conductivity_ftdi_{ftdi}".format(
ftdi=self.ftdi_location))
self.atlas_sensor_ftdi = AtlasScientificFTDI(self.ftdi_location)
elif self.interface == 'UART':
self.logger = logging.getLogger(
"mycodo.inputs.atlas_electrical_conductivity_uart_{uart}".format(
uart=self.uart_location))
self.atlas_sensor_uart = AtlasScientificUART(self.uart_location)
elif self.interface == 'I2C':
self.logger = logging.getLogger(
"mycodo.inputs.atlas_electrical_conductivity_i2c_{bus}_{add}".format(
bus=self.i2c_bus, add=self.i2c_address))
self.atlas_sensor_i2c = AtlasScientificI2C(
i2c_address=self.i2c_address, i2c_bus=self.i2c_bus)
def connect_atlas_ezo_pump(selected_output):
atlas_command = None
if selected_output.interface == 'FTDI':
atlas_command = AtlasScientificFTDI(selected_output.ftdi_location)
elif selected_output.interface == 'I2C':
atlas_command = AtlasScientificI2C(i2c_address=int(
str(selected_output.location), 16),
i2c_bus=selected_output.i2c_bus)
elif selected_output.interface == 'UART':
atlas_command = AtlasScientificUART(
selected_output.location, baudrate=selected_output.baud_rate)
return atlas_command
def initialize_sensor(self):
if self.interface == 'FTDI':
from mycodo.devices.atlas_scientific_ftdi import AtlasScientificFTDI
self.ftdi_location = self.input_dev.ftdi_location
self.atlas_sensor = AtlasScientificFTDI(self.ftdi_location)
elif self.interface == 'UART':
from mycodo.devices.atlas_scientific_uart import AtlasScientificUART
self.uart_location = self.input_dev.uart_location
self.atlas_sensor = AtlasScientificUART(self.uart_location)
elif self.interface == 'I2C':
from mycodo.devices.atlas_scientific_i2c import AtlasScientificI2C
self.i2c_address = int(str(self.input_dev.i2c_location), 16)
self.i2c_bus = self.input_dev.i2c_bus
self.atlas_sensor = AtlasScientificI2C(
i2c_address=self.i2c_address, i2c_bus=self.i2c_bus)
def setup_output(self):
if self.interface == 'FTDI':
from mycodo.devices.atlas_scientific_ftdi import AtlasScientificFTDI
self.atlas_command = AtlasScientificFTDI(self.output.ftdi_location)
elif self.interface == 'I2C':
from mycodo.devices.atlas_scientific_i2c import AtlasScientificI2C
self.atlas_command = AtlasScientificI2C(
i2c_address=int(str(self.output.i2c_location), 16),
i2c_bus=self.output.i2c_bus)
elif self.interface == 'UART':
from mycodo.devices.atlas_scientific_uart import AtlasScientificUART
self.atlas_command = AtlasScientificUART(
self.output.uart_location, baudrate=self.output.baud_rate)
else:
self.logger.error("Unknown interface: {}".format(self.interface))
def setup_output(self):
if self.output_interface == 'FTDI':
from mycodo.devices.atlas_scientific_ftdi import AtlasScientificFTDI
self.ftdi_location = self.output.ftdi_location
self.atlas_command = AtlasScientificFTDI(self.ftdi_location)
elif self.output_interface == 'I2C':
from mycodo.devices.atlas_scientific_i2c import AtlasScientificI2C
self.i2c_address = int(str(self.output.i2c_location), 16)
self.i2c_bus = self.output.i2c_bus
self.atlas_command = AtlasScientificI2C(
i2c_address=self.i2c_address, i2c_bus=self.i2c_bus)
elif self.output_interface == 'UART':
from mycodo.devices.atlas_scientific_uart import AtlasScientificUART
self.uart_location = self.output.uart_location
self.output_baud_rate = self.output.baud_rate
self.atlas_command = AtlasScientificUART(
self.uart_location, baudrate=self.output_baud_rate)
def setup_atlas_device(atlas_device):
if atlas_device.interface == 'FTDI':
from mycodo.devices.atlas_scientific_ftdi import AtlasScientificFTDI
atlas_device = AtlasScientificFTDI(atlas_device.ftdi_location)
elif atlas_device.interface == 'UART':
from mycodo.devices.atlas_scientific_uart import AtlasScientificUART
atlas_device = AtlasScientificUART(atlas_device.uart_location,
baudrate=atlas_device.baud_rate)
elif atlas_device.interface == 'I2C':
from mycodo.devices.atlas_scientific_i2c import AtlasScientificI2C
atlas_device = AtlasScientificI2C(i2c_address=int(
str(atlas_device.i2c_location), 16),
i2c_bus=atlas_device.i2c_bus)
else:
logger.error("Unrecognized interface: {}".format(
atlas_device.interface))
return
return atlas_device
def initialize_sensor(self):
from mycodo.devices.atlas_scientific_ftdi import AtlasScientificFTDI
from mycodo.devices.atlas_scientific_i2c import AtlasScientificI2C
from mycodo.devices.atlas_scientific_uart import AtlasScientificUART
if self.interface == 'FTDI':
self.logger = logging.getLogger(
"mycodo.inputs.atlas_pt1000_ftdi_{ftdi}".format(
ftdi=self.ftdi_location))
self.atlas_sensor_ftdi = AtlasScientificFTDI(self.ftdi_location)
elif self.interface == 'UART':
self.logger = logging.getLogger(
"mycodo.inputs.atlas_pt1000_uart_{uart}".format(
uart=self.uart_location))
self.atlas_sensor_uart = AtlasScientificUART(self.uart_location)
elif self.interface == 'I2C':
self.logger = logging.getLogger(
"mycodo.inputs.atlas_pt1000_i2c_{bus}_{add}".format(
bus=self.i2c_bus, add=self.i2c_address))
self.atlas_sensor_i2c = AtlasScientificI2C(
i2c_address=self.i2c_address, i2c_bus=self.i2c_bus)
else:
self.logger = logging.getLogger("mycodo.inputs.atlas_pt1000")
class InputModule(AbstractInput):
"""A sensor support class that monitors the Atlas Scientific sensor ORP"""
def __init__(self, input_dev, testing=False):
super(InputModule, self).__init__(input_dev,
testing=testing,
name=__name__)
self.atlas_sensor_ftdi = None
self.atlas_sensor_uart = None
self.atlas_sensor_i2c = None
self.ftdi_location = None
self.uart_location = None
self.i2c_address = None
self.i2c_bus = None
# Initialize custom options
self.temperature_comp_meas_device_id = None
self.temperature_comp_meas_measurement_id = None
self.max_age = None
# Set custom options
self.setup_custom_options(INPUT_INFORMATION['custom_options'],
input_dev)
if not testing:
self.input_dev = input_dev
self.interface = input_dev.interface
if self.temperature_comp_meas_measurement_id:
self.atlas_command = AtlasScientificCommand(self.input_dev)
try:
self.initialize_sensor()
except Exception:
self.logger.exception("Exception while initializing sensor")
# Throw out first measurement of Atlas Scientific sensor, as it may be prone to error
self.get_measurement()
def initialize_sensor(self):
from mycodo.devices.atlas_scientific_ftdi import AtlasScientificFTDI
from mycodo.devices.atlas_scientific_i2c import AtlasScientificI2C
from mycodo.devices.atlas_scientific_uart import AtlasScientificUART
if self.interface == 'FTDI':
self.ftdi_location = self.input_dev.ftdi_location
self.atlas_sensor_ftdi = AtlasScientificFTDI(self.ftdi_location)
elif self.interface == 'UART':
self.uart_location = self.input_dev.uart_location
self.atlas_sensor_uart = AtlasScientificUART(self.uart_location)
elif self.interface == 'I2C':
self.i2c_address = int(str(self.input_dev.i2c_location), 16)
self.i2c_bus = self.input_dev.i2c_bus
self.atlas_sensor_i2c = AtlasScientificI2C(
i2c_address=self.i2c_address, i2c_bus=self.i2c_bus)
def get_measurement(self):
""" Gets the sensor's ORP measurement via UART/I2C """
orp = None
self.return_dict = measurements_dict.copy()
# 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:
self.logger.debug(
"Latest temperature used to calibrate: {temp}".format(
temp=last_measurement[1]))
ret_value, ret_msg = self.atlas_command.calibrate(
'temperature', set_amount=last_measurement[1])
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 UART
if self.interface == 'FTDI':
if self.atlas_sensor_ftdi.setup:
lines = self.atlas_sensor_ftdi.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]):
orp = float(lines[0])
self.logger.debug(
'Value[0] is float: {val}'.format(val=orp))
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]):
orp = 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:
orp = lines[0]
self.logger.error(
'Value[0] is not float or "check probe": '
'{val}'.format(val=orp))
else:
self.logger.error('FTDI device is not set up.'
'Check the log for errors.')
# Read sensor via UART
elif 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]):
orp = float(lines[0])
self.logger.debug(
'Value[0] is float: {val}'.format(val=orp))
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]):
orp = 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:
orp = lines[0]
self.logger.error(
'Value[0] is not float or "check probe": '
'{val}'.format(val=orp))
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':
orp = float(ec_str)
else:
self.logger.error(
'I2C device is not set up. Check the log for errors.')
self.value_set(0, orp)
return self.return_dict
class InputModule(AbstractInput):
"""A sensor support class that monitors the Atlas Scientific sensor DO"""
def __init__(self, input_dev, testing=False):
super(InputModule, self).__init__(input_dev,
testing=testing,
name=__name__)
self.atlas_sensor_ftdi = None
self.atlas_sensor_uart = None
self.atlas_sensor_i2c = None
self.ftdi_location = None
self.uart_location = None
self.i2c_address = None
self.i2c_bus = None
if not testing:
self.interface = input_dev.interface
self.calibrate_sensor_measure = input_dev.calibrate_sensor_measure
self.max_age = None
if input_dev.custom_options:
for each_option in input_dev.custom_options.split(';'):
option = each_option.split(',')[0]
value = each_option.split(',')[1]
if option == 'max_age':
self.max_age = int(value)
try:
self.initialize_sensor()
except Exception:
self.logger.exception("Exception while initializing sensor")
def initialize_sensor(self):
from mycodo.devices.atlas_scientific_ftdi import AtlasScientificFTDI
from mycodo.devices.atlas_scientific_i2c import AtlasScientificI2C
from mycodo.devices.atlas_scientific_uart import AtlasScientificUART
if self.interface == 'FTDI':
self.ftdi_location = self.input_dev.ftdi_location
self.atlas_sensor_ftdi = AtlasScientificFTDI(self.ftdi_location)
elif self.interface == 'UART':
self.uart_location = self.input_dev.uart_location
self.atlas_sensor_uart = AtlasScientificUART(self.uart_location)
elif self.interface == 'I2C':
self.i2c_address = int(str(self.input_dev.i2c_location), 16)
self.i2c_bus = self.input_dev.i2c_bus
self.atlas_sensor_i2c = AtlasScientificI2C(
i2c_address=self.i2c_address, i2c_bus=self.i2c_bus)
def get_measurement(self):
""" Gets the sensor's DO measurement via UART/I2C """
do = None
self.return_dict = measurements_dict.copy()
# Read sensor via UART
if self.interface == 'FTDI':
if self.atlas_sensor_ftdi.setup:
lines = self.atlas_sensor_ftdi.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]):
do = float(lines[0])
self.logger.debug(
'Value[0] is float: {val}'.format(val=do))
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]):
do = 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:
do = lines[0]
self.logger.error(
'Value[0] is not float or "check probe": '
'{val}'.format(val=do))
else:
self.logger.error('FTDI device is not set up.'
'Check the log for errors.')
# Read sensor via UART
elif 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]):
do = float(lines[0])
self.logger.debug(
'Value[0] is float: {val}'.format(val=do))
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]):
do = 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:
do = lines[0]
self.logger.error(
'Value[0] is not float or "check probe": '
'{val}'.format(val=do))
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':
do = float(ec_str)
else:
self.logger.error(
'I2C device is not set up. Check the log for errors.')
self.value_set(0, do)
return self.return_dict
class AtlasScientificCommand:
"""
Class to handle issuing commands to the Atlas Scientific sensor boards
"""
def __init__(self, input_dev):
self.cmd_send = None
self.ph_sensor_uart = None
self.ph_sensor_i2c = None
self.interface = input_dev.interface
if self.interface == 'FTDI':
from mycodo.devices.atlas_scientific_ftdi import AtlasScientificFTDI
self.ph_sensor_ftdi = AtlasScientificFTDI(
input_dev.ftdi_location)
elif self.interface == 'UART':
from mycodo.devices.atlas_scientific_uart import AtlasScientificUART
self.ph_sensor_uart = AtlasScientificUART(
input_dev.uart_location,
baudrate=input_dev.baud_rate)
elif self.interface == 'I2C':
from mycodo.devices.atlas_scientific_i2c import AtlasScientificI2C
self.ph_sensor_i2c = AtlasScientificI2C(
i2c_address=int(str(input_dev.i2c_location), 16),
i2c_bus=input_dev.i2c_bus)
self.board_version, self.board_info = self.get_board_version()
if self.board_version == 0:
logger.error("Unable to retrieve device info (this indicates the "
"device was not properly initialized or connected)")
else:
# TODO: Change back to debug
logger.error("Device Info: {info}".format(info=self.board_info))
logger.error("Detected Version: {ver}".format(ver=self.board_version))
def get_board_version(self):
"""Return the board version of the Atlas Scientific pH sensor"""
info = None
try:
if self.interface == 'FTDI':
info = self.ph_sensor_ftdi.query('i')
elif self.interface == 'UART':
info = self.ph_sensor_uart.query('i')
elif self.interface == 'I2C':
info = self.ph_sensor_i2c.query('i')
except TypeError:
logger.exception("Unable to determine board version of Atlas sensor")
return 0, None
# Check first letter of info response
# "P" indicates a legacy board version
if info is None:
return 0, None
elif info is list:
for each_line in info:
if each_line == 'P':
return 1, each_line # Older board version
elif ',' in each_line and len(each_line.split(',')) == 3:
return 2, each_line # Newer board version
return 0, None
def calibrate(self, command, temperature=None, custom_cmd=None):
"""
Determine and send the correct command to an Atlas Scientific sensor,
based on the board version
"""
# Formulate command based on calibration step and board version.
# Legacy boards requires a different command than recent boards.
# Some commands are not necessary for recent boards and will not
# generate a response.
err = 1
msg = "Default message"
if command == 'temperature' and temperature is not None:
if self.board_version == 1:
err, msg = self.send_command(temperature)
elif self.board_version == 2:
err, msg = self.send_command('T,{temp}'.format(temp=temperature))
elif command == 'clear_calibration':
if self.board_version == 1:
err, msg = self.send_command('X')
self.send_command('L0')
elif self.board_version == 2:
err, msg = self.send_command('Cal,clear')
elif command == 'continuous':
if self.board_version == 1:
err, msg = self.send_command('C')
elif self.board_version == 2:
err, msg = self.send_command('C,1')
elif command == 'low':
if self.board_version == 1:
err, msg = self.send_command('F')
elif self.board_version == 2:
err, msg = self.send_command('Cal,low,4.00')
elif command == 'mid':
if self.board_version == 1:
err, msg = self.send_command('S')
elif self.board_version == 2:
err, msg = self.send_command('Cal,mid,7.00')
elif command == 'high':
if self.board_version == 1:
err, msg = self.send_command('T')
elif self.board_version == 2:
err, msg = self.send_command('Cal,high,10.00')
elif command == 'end':
if self.board_version == 1:
err, msg = self.send_command('E')
elif self.board_version == 2:
err, msg = self.send_command('C,0')
elif custom_cmd:
err, msg = self.send_command(custom_cmd)
return err, msg
def send_command(self, cmd_send):
""" Send the command (if not None) and return the response """
try:
return_value = "No message"
if cmd_send is not None:
if self.interface == 'FTDI':
return_value = self.ph_sensor_ftdi.query(cmd_send)
elif self.interface == 'UART':
return_value = self.ph_sensor_uart.query(cmd_send)
elif self.interface == 'I2C':
return_value = self.ph_sensor_i2c.query(cmd_send)
time.sleep(0.1)
return 0, return_value
else:
return 1, "No command given"
except Exception as err:
logger.error("{cls} raised an exception while communicating with "
"the board: {err}".format(cls=type(self).__name__,
err=err))
return 1, err
def setup_atlas_ph_measure(input_id):
"""
Acquire a measurement from the Atlas Scientific pH input and return it
Used during calibration to display the current pH to the user
"""
if not utils_general.user_has_permission('edit_controllers'):
return redirect(url_for('routes_page.page_atlas_ph_calibrate'))
selected_input = Input.query.filter_by(unique_id=input_id).first()
ph = None
error = None
if selected_input.interface == 'FTDI':
ph_input_ftdi = AtlasScientificFTDI(selected_input.ftdi_location)
lines = ph_input_ftdi.query('R')
logger.debug("All Lines: {lines}".format(lines=lines))
if 'check probe' in lines:
error = '"check probe" returned from input'
elif not lines:
error = 'Nothing returned from input'
elif str_is_float(lines[0]):
ph = lines[0]
logger.debug('Value[0] is float: {val}'.format(val=ph))
else:
error = 'Value[0] is not float or "check probe": {val}'.format(
val=lines[0])
elif selected_input.interface == 'UART':
ph_input_uart = AtlasScientificUART(selected_input.uart_location,
baudrate=selected_input.baud_rate)
lines = ph_input_uart.query('R')
logger.debug("All Lines: {lines}".format(lines=lines))
if 'check probe' in lines:
error = '"check probe" returned from input'
elif not lines:
error = 'Nothing returned from input'
elif str_is_float(lines[0]):
ph = lines[0]
logger.debug('Value[0] is float: {val}'.format(val=ph))
else:
error = 'Value[0] is not float or "check probe": {val}'.format(
val=lines[0])
elif selected_input.interface == 'I2C':
ph_input_i2c = AtlasScientificI2C(i2c_address=int(
str(selected_input.i2c_location), 16),
i2c_bus=selected_input.i2c_bus)
ph_status, ph_str = ph_input_i2c.query('R')
if ph_status == 'error':
error = "Input read unsuccessful: {err}".format(err=ph_str)
elif ph_status == 'success':
ph = ph_str
if error:
logger.error(error)
return error, 204
else:
return ph
class AtlasScientificCommand:
"""
Class to handle issuing commands to the Atlas Scientific sensor boards
"""
def __init__(self, input_dev):
self.cmd_send = None
self.ph_sensor_uart = None
self.ph_sensor_i2c = None
self.interface = input_dev.interface
self.init_error = None
if self.interface == 'FTDI':
from mycodo.devices.atlas_scientific_ftdi import AtlasScientificFTDI
self.ph_sensor_ftdi = AtlasScientificFTDI(input_dev.ftdi_location)
elif self.interface == 'UART':
from mycodo.devices.atlas_scientific_uart import AtlasScientificUART
self.ph_sensor_uart = AtlasScientificUART(
input_dev.uart_location, baudrate=input_dev.baud_rate)
elif self.interface == 'I2C':
from mycodo.devices.atlas_scientific_i2c import AtlasScientificI2C
self.ph_sensor_i2c = AtlasScientificI2C(i2c_address=int(
str(input_dev.i2c_location), 16),
i2c_bus=input_dev.i2c_bus)
(self.measurement, self.board_version,
self.firmware_version) = self.get_board_version()
if self.board_version == 0:
error_msg = "Atlas Scientific board initialization unsuccessful. " \
"Unable to retrieve device info (this indicates the " \
"device was not properly initialized or connected)"
logger.error(error_msg)
self.init_error = error_msg
else:
logger.debug(
"Atlas Scientific board initialization success. "
"Measurement: {meas}, Board: {brd}, Firmware: {fw}".format(
meas=self.measurement,
brd=self.board_version,
fw=self.firmware_version))
def get_sensor_measurement(self):
return self.measurement
def get_board_version(self):
"""Return the board version of the Atlas Scientific pH sensor"""
info = None
try:
if self.interface == 'FTDI':
info = self.ph_sensor_ftdi.query('i')
elif self.interface == 'UART':
info = self.ph_sensor_uart.query('i')
elif self.interface == 'I2C':
info = self.ph_sensor_i2c.query('i')
except TypeError:
logger.exception(
"Unable to determine board version of Atlas sensor")
return None, 0, None
# Check first letter of info response
# "P" indicates a legacy board version
if info is None:
return None, 0, None
elif isinstance(info, tuple):
if info[0] == 'error':
return None, 0, None
for each_line in info:
if each_line == 'P':
return 'NA', 1, each_line # Older board version
elif ',' in each_line and len(each_line.split(',')) == 3:
info_split = each_line.split(',')
measurement = info_split[1]
firmware = info_split[2]
return measurement, 2, firmware # Newer board version
return None, 0, None
def calibrate(self, command, set_amount=None, custom_cmd=None):
"""
Determine and send the correct command to an Atlas Scientific sensor,
based on the board version
"""
# Formulate command based on calibration step and board version.
# Legacy boards requires a different command than recent boards.
# Some commands are not necessary for recent boards and will not
# generate a response.
err = 1
msg = "Default message"
if self.init_error:
msg = self.init_error
# Atlas EC
if command == 'ec_dry':
if self.board_version == 2:
err, msg = self.send_command('cal,dry')
elif command == 'ec_low':
if self.board_version == 2:
err, msg = self.send_command(
'cal,low,{uS}'.format(uS=set_amount))
elif command == 'ec_high':
if self.board_version == 2:
err, msg = self.send_command(
'cal,high,{uS}'.format(uS=set_amount))
# Atlas pH
elif command == 'temperature' and set_amount is not None:
if self.board_version == 1:
err, msg = self.send_command(set_amount)
elif self.board_version == 2:
err, msg = self.send_command(
'T,{temp}'.format(temp=set_amount))
elif command == 'clear_calibration':
if self.board_version == 1:
err, msg = self.send_command('X')
self.send_command('L0')
elif self.board_version == 2:
err, msg = self.send_command('Cal,clear')
elif command == 'continuous':
if self.board_version == 1:
err, msg = self.send_command('C')
elif self.board_version == 2:
err, msg = self.send_command('C,1')
elif command == 'low':
if self.board_version == 1:
err, msg = self.send_command('F')
elif self.board_version == 2:
err, msg = self.send_command('Cal,low,4.00')
elif command == 'mid':
if self.board_version == 1:
err, msg = self.send_command('S')
elif self.board_version == 2:
err, msg = self.send_command('Cal,mid,7.00')
elif command == 'high':
if self.board_version == 1:
err, msg = self.send_command('T')
elif self.board_version == 2:
err, msg = self.send_command('Cal,high,10.00')
elif command == 'calibrated': # Not implemented. This queries whether there is a stored calibration
if self.board_version == 1:
err = 'success'
msg = 'Calibrated query not implemented on board version 1 (assume it was successfully calibrated)'
elif self.board_version == 2:
err, msg = self.send_command('Cal,?')
elif command == 'end':
if self.board_version == 1:
err, msg = self.send_command('E')
elif self.board_version == 2:
err, msg = self.send_command('C,0')
elif custom_cmd:
err, msg = self.send_command(custom_cmd)
return err, msg
def send_command(self, cmd_send):
""" Send the command (if not None) and return the response """
try:
return_value = "No message"
if cmd_send is not None:
if self.interface == 'FTDI':
return_value = self.ph_sensor_ftdi.query(cmd_send)
elif self.interface == 'UART':
return_value = self.ph_sensor_uart.query(cmd_send)
elif self.interface == 'I2C':
return_value = self.ph_sensor_i2c.query(cmd_send)
time.sleep(0.1)
return 0, return_value
else:
return 1, "No command given"
except Exception as err:
logger.error("{cls} raised an exception while communicating with "
"the board: {err}".format(cls=type(self).__name__,
err=err))
return 1, err
class InputModule(AbstractInput):
"""A sensor support class that monitors the Atlas Scientific sensor pH"""
def __init__(self, input_dev, testing=False):
super(InputModule, self).__init__()
self.logger = logging.getLogger("mycodo.inputs.atlas_ph")
self.atlas_sensor_ftdi = None
self.atlas_sensor_uart = None
self.atlas_sensor_i2c = None
self.ftdi_location = None
self.uart_location = None
self.i2c_address = None
self.i2c_bus = None
if not testing:
self.logger = logging.getLogger(
"mycodo.inputs.atlas_ph_{id}".format(id=input_dev.unique_id.split('-')[0]))
self.input_dev = input_dev
self.interface = input_dev.interface
self.calibrate_sensor_measure = input_dev.calibrate_sensor_measure
self.max_age = None
if input_dev.custom_options:
for each_option in input_dev.custom_options.split(';'):
option = each_option.split(',')[0]
value = each_option.split(',')[1]
if option == 'max_age':
self.max_age = int(value)
try:
self.initialize_sensor()
except Exception:
self.logger.exception("Exception while initializing sensor")
def initialize_sensor(self):
from mycodo.devices.atlas_scientific_ftdi import AtlasScientificFTDI
from mycodo.devices.atlas_scientific_i2c import AtlasScientificI2C
from mycodo.devices.atlas_scientific_uart import AtlasScientificUART
if self.interface == 'FTDI':
self.ftdi_location = self.input_dev.ftdi_location
self.logger = logging.getLogger(
"mycodo.inputs.atlas_ph_ftdi_{ftdi}".format(
ftdi=self.ftdi_location))
self.atlas_sensor_ftdi = AtlasScientificFTDI(self.ftdi_location)
elif self.interface == 'UART':
self.uart_location = self.input_dev.uart_location
self.logger = logging.getLogger(
"mycodo.inputs.atlas_ph_uart_{uart}".format(
uart=self.uart_location))
self.atlas_sensor_uart = AtlasScientificUART(self.uart_location)
elif self.interface == 'I2C':
self.i2c_address = int(str(self.input_dev.i2c_location), 16)
self.logger = logging.getLogger(
"mycodo.inputs.atlas_ph_i2c_{bus}_{add}".format(
bus=self.i2c_bus, add=self.i2c_address))
self.i2c_bus = self.input_dev.i2c_bus
self.atlas_sensor_i2c = AtlasScientificI2C(
i2c_address=self.i2c_address, i2c_bus=self.i2c_bus)
def get_measurement(self):
""" Gets the sensor's pH measurement via UART/I2C """
ph = None
return_dict = measurements_dict.copy()
# Calibrate the pH measurement based on a temperature measurement
if (self.calibrate_sensor_measure and
',' in self.calibrate_sensor_measure):
self.logger.debug("pH sensor set to calibrate temperature")
device_id = self.calibrate_sensor_measure.split(',')[0]
measurement_id = self.calibrate_sensor_measure.split(',')[1]
device_measurement = self.device_measurements.filter(
DeviceMeasurements.unique_id == measurement_id).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)
last_measurement = read_last_influxdb(
device_id,
measurement.unit,
measurement.measurement,
measurement.channel,
self.max_age)
if last_measurement:
self.logger.debug(
"Latest temperature used to calibrate: {temp}".format(
temp=last_measurement[1]))
atlas_command = AtlasScientificCommand(self.input_dev)
ret_value, ret_msg = atlas_command.calibrate(
'temperature', temperature=last_measurement[1])
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
if self.interface == 'FTDI':
if self.atlas_sensor_ftdi.setup:
lines = self.atlas_sensor_ftdi.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]):
ph = float(lines[0])
self.logger.debug(
'Value[0] is float: {val}'.format(val=ph))
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]):
ph = 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:
ph = lines[0]
self.logger.error(
'Value[0] is not float or "check probe": '
'{val}'.format(val=ph))
else:
self.logger.error('FTDI device is not set up.'
'Check the log for errors.')
# Read sensor via UART
elif 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]):
ph = float(lines[0])
self.logger.debug(
'Value[0] is float: {val}'.format(val=ph))
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]):
ph = 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:
ph = lines[0]
self.logger.error(
'Value[0] is not float or "check probe": '
'{val}'.format(val=ph))
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:
ph_status, ph_str = self.atlas_sensor_i2c.query('R')
if ph_status == 'error':
self.logger.error(
"Sensor read unsuccessful: {err}".format(
err=ph_str))
elif ph_status == 'success':
ph = float(ph_str)
else:
self.logger.error(
'I2C device is not set up. Check the log for errors.')
return_dict[0]['value'] = ph
return return_dict
class InputModule(AbstractInput):
""" A sensor support class that monitors the PT1000's temperature """
def __init__(self, input_dev, testing=False):
super(InputModule, self).__init__(input_dev,
testing=testing,
name=__name__)
self.atlas_sensor_ftdi = None
self.atlas_sensor_uart = None
self.atlas_sensor_i2c = None
if not testing:
self.input_dev = input_dev
self.interface = input_dev.interface
try:
self.initialize_sensor()
except Exception:
self.logger.exception("Exception while initializing sensor")
# Throw out first measurement of Atlas Scientific sensor, as it may be prone to error
self.get_measurement()
def initialize_sensor(self):
from mycodo.devices.atlas_scientific_ftdi import AtlasScientificFTDI
from mycodo.devices.atlas_scientific_i2c import AtlasScientificI2C
from mycodo.devices.atlas_scientific_uart import AtlasScientificUART
if self.interface == 'FTDI':
self.ftdi_location = self.input_dev.ftdi_location
self.atlas_sensor_ftdi = AtlasScientificFTDI(self.ftdi_location)
elif self.interface == 'UART':
self.uart_location = self.input_dev.uart_location
self.atlas_sensor_uart = AtlasScientificUART(self.uart_location)
elif self.interface == 'I2C':
self.i2c_address = int(str(self.input_dev.i2c_location), 16)
self.i2c_bus = self.input_dev.i2c_bus
self.atlas_sensor_i2c = AtlasScientificI2C(
i2c_address=self.i2c_address, i2c_bus=self.i2c_bus)
def get_measurement(self):
""" Gets the Atlas PT1000's temperature in Celsius """
temp = None
self.return_dict = measurements_dict.copy()
if self.interface == 'FTDI':
if self.atlas_sensor_ftdi.setup:
lines = self.atlas_sensor_ftdi.query('R')
self.logger.debug("All Lines: {lines}".format(lines=lines))
if 'check probe' in lines:
self.logger.error('"check probe" returned from sensor')
elif isinstance(lines, list):
if str_is_float(lines[0]):
temp = float(lines[0])
self.logger.debug(
'Value[0] is float: {val}'.format(val=temp))
elif str_is_float(lines):
temp = float(lines)
self.logger.debug('Value is float: {val}'.format(val=temp))
else:
self.logger.error('Unknown value: {val}'.format(val=lines))
else:
self.logger.error('FTDI device is not set up. '
'Check the log for errors.')
elif self.interface == 'UART':
if self.atlas_sensor_uart.setup:
lines = self.atlas_sensor_uart.query('R')
self.logger.debug("All Lines: {lines}".format(lines=lines))
if 'check probe' in lines:
self.logger.error('"check probe" returned from sensor')
elif str_is_float(lines[0]):
temp = float(lines[0])
self.logger.debug(
'Value[0] is float: {val}'.format(val=temp))
else:
self.logger.error(
'Value[0] is not float or "check probe": '
'{val}'.format(val=lines[0]))
else:
self.logger.error('UART device is not set up. '
'Check the log for errors.')
elif self.interface == 'I2C':
if self.atlas_sensor_i2c.setup:
temp_status, temp_str = self.atlas_sensor_i2c.query('R')
if temp_status == 'error':
self.logger.error(
"Sensor read unsuccessful: {err}".format(err=temp_str))
elif temp_status == 'success':
temp = float(temp_str)
else:
self.logger.error('I2C device is not set up.'
'Check the log for errors.')
if temp == -1023: # Erroneous measurement
return
self.value_set(0, temp)
return self.return_dict
class InputModule(AbstractInput):
""" A sensor support class that monitors the PT1000's temperature """
def __init__(self, input_dev, testing=False):
super(InputModule, self).__init__()
self.logger = logging.getLogger("mycodo.inputs.atlas_pt1000")
self.atlas_sensor_ftdi = None
self.atlas_sensor_uart = None
self.atlas_sensor_i2c = None
if not testing:
self.logger = logging.getLogger(
"mycodo.inputs.atlas_pt1000_{id}".format(id=input_dev.unique_id.split('-')[0]))
self.interface = input_dev.interface
if self.interface == 'FTDI':
self.ftdi_location = input_dev.ftdi_location
elif self.interface == 'UART':
self.uart_location = input_dev.uart_location
elif self.interface == 'I2C':
self.i2c_address = int(str(input_dev.i2c_location), 16)
self.i2c_bus = input_dev.i2c_bus
self.initialize_sensor()
def initialize_sensor(self):
from mycodo.devices.atlas_scientific_ftdi import AtlasScientificFTDI
from mycodo.devices.atlas_scientific_i2c import AtlasScientificI2C
from mycodo.devices.atlas_scientific_uart import AtlasScientificUART
if self.interface == 'FTDI':
self.logger = logging.getLogger(
"mycodo.inputs.atlas_pt1000_ftdi_{ftdi}".format(
ftdi=self.ftdi_location))
self.atlas_sensor_ftdi = AtlasScientificFTDI(self.ftdi_location)
elif self.interface == 'UART':
self.logger = logging.getLogger(
"mycodo.inputs.atlas_pt1000_uart_{uart}".format(
uart=self.uart_location))
self.atlas_sensor_uart = AtlasScientificUART(self.uart_location)
elif self.interface == 'I2C':
self.logger = logging.getLogger(
"mycodo.inputs.atlas_pt1000_i2c_{bus}_{add}".format(
bus=self.i2c_bus, add=self.i2c_address))
self.atlas_sensor_i2c = AtlasScientificI2C(
i2c_address=self.i2c_address, i2c_bus=self.i2c_bus)
else:
self.logger = logging.getLogger("mycodo.inputs.atlas_pt1000")
def get_measurement(self):
""" Gets the Atlas PT1000's temperature in Celsius """
temp = None
return_dict = measurements_dict.copy()
if self.interface == 'FTDI':
if self.atlas_sensor_ftdi.setup:
lines = self.atlas_sensor_ftdi.query('R')
self.logger.debug("All Lines: {lines}".format(lines=lines))
if 'check probe' in lines:
self.logger.error('"check probe" returned from sensor')
elif isinstance(lines, list):
if str_is_float(lines[0]):
temp = float(lines[0])
self.logger.debug(
'Value[0] is float: {val}'.format(val=temp))
elif str_is_float(lines):
temp = float(lines)
self.logger.debug(
'Value is float: {val}'.format(val=temp))
else:
self.logger.error(
'Unknown value: {val}'.format(val=lines))
else:
self.logger.error('FTDI device is not set up. '
'Check the log for errors.')
elif self.interface == 'UART':
if self.atlas_sensor_uart.setup:
lines = self.atlas_sensor_uart.query('R')
self.logger.debug("All Lines: {lines}".format(lines=lines))
if 'check probe' in lines:
self.logger.error('"check probe" returned from sensor')
elif str_is_float(lines[0]):
temp = float(lines[0])
self.logger.debug(
'Value[0] is float: {val}'.format(val=temp))
else:
self.logger.error(
'Value[0] is not float or "check probe": '
'{val}'.format(val=lines[0]))
else:
self.logger.error('UART device is not set up. '
'Check the log for errors.')
elif self.interface == 'I2C':
if self.atlas_sensor_i2c.setup:
temp_status, temp_str = self.atlas_sensor_i2c.query('R')
if temp_status == 'error':
self.logger.error(
"Sensor read unsuccessful: {err}".format(
err=temp_str))
elif temp_status == 'success':
temp = float(temp_str)
else:
self.logger.error('I2C device is not set up.'
'Check the log for errors.')
return_dict[0]['value'] = temp
return return_dict
def initialize_sensor(self):
from mycodo.devices.atlas_scientific_ftdi import AtlasScientificFTDI
from mycodo.devices.atlas_scientific_i2c import AtlasScientificI2C
from mycodo.devices.atlas_scientific_uart import AtlasScientificUART
if self.interface == 'FTDI':
self.ftdi_location = self.input_dev.ftdi_location
self.atlas_sensor = AtlasScientificFTDI(self.ftdi_location)
elif self.interface == 'UART':
self.uart_location = self.input_dev.uart_location
self.atlas_sensor = AtlasScientificUART(self.uart_location)
elif self.interface == 'I2C':
self.i2c_address = int(str(self.input_dev.i2c_location), 16)
self.i2c_bus = self.input_dev.i2c_bus
self.atlas_sensor = AtlasScientificI2C(
i2c_address=self.i2c_address, i2c_bus=self.i2c_bus)
if self.is_enabled(0):
self.atlas_sensor.query('O,TV,1')
self.logger.debug("Enabling Total Volume measurement")
else:
self.atlas_sensor.query('O,TV,0')
self.logger.debug("Disabling Total Volume measurement")
if self.is_enabled(1):
self.atlas_sensor.query('O,FR,1')
self.logger.debug("Enabling Flow Rate measurement")
else:
self.atlas_sensor.query('O,FR,0')
self.logger.debug("Disabling Flow Rate measurement")
if self.flow_meter_type:
if self.flow_meter_type == 'non-atlas':
if ';' in self.custom_k_values:
list_k_values = self.custom_k_values.split(';')
self.atlas_sensor.query('K,clear')
self.logger.debug("Cleared K Values")
for each_k in list_k_values:
if ',' in each_k:
self.atlas_sensor.query('K,{}'.format(each_k))
self.logger.debug("Set K Value: {}".format(each_k))
else:
self.logger.error(
"Improperly-formatted K-value: {}".format(
each_k))
elif ',' in self.custom_k_values:
self.atlas_sensor.query('K,clear')
self.logger.debug("Cleared K Values")
self.atlas_sensor.query('K,{}'.format(
self.custom_k_values))
self.logger.debug("Set K Value: {}".format(
self.custom_k_values))
else:
self.logger.error(
"Improperly-formatted K-value: {}".format(
self.custom_k_values))
self.atlas_sensor.query('Vp,{}'.format(
self.custom_k_value_time_base))
self.logger.debug("Set Custom Time Base: {}".format(
self.custom_k_value_time_base))
else:
self.atlas_sensor.query('Set,{}'.format(self.flow_meter_type))
self.logger.debug("Set Flow Meter: {}".format(
self.flow_meter_type))
if self.flow_rate_unit:
self.atlas_sensor.query('Frp,{}'.format(self.flow_rate_unit))
self.logger.debug("Set Flow Rate: l/{}".format(
self.flow_rate_unit))
if self.internal_resistor and self.internal_resistor != 'atlas':
self.atlas_sensor.query('P,{}'.format(int(self.internal_resistor)))
if self.internal_resistor == '0':
self.logger.debug("Internal Resistor disabled")
else:
self.logger.debug("Internal Resistor set: {} K".format(
self.internal_resistor))
class InputModule(AbstractInput):
"""A sensor support class that monitors the Atlas Scientific sensor ElectricalConductivity"""
def __init__(self, input_dev, testing=False):
super(InputModule, self).__init__()
self.logger = logging.getLogger("mycodo.inputs.atlas_ec")
self.atlas_sensor_ftdi = None
self.atlas_sensor_uart = None
self.atlas_sensor_i2c = None
if not testing:
self.logger = logging.getLogger(
"mycodo.inputs.atlas_ec_{id}".format(
id=input_dev.unique_id.split('-')[0]))
self.interface = input_dev.interface
if self.interface == 'FTDI':
self.ftdi_location = input_dev.ftdi_location
elif self.interface == 'UART':
self.uart_location = input_dev.uart_location
elif self.interface == 'I2C':
self.i2c_address = int(str(input_dev.i2c_location), 16)
self.i2c_bus = input_dev.i2c_bus
try:
self.initialize_sensor()
except Exception:
self.logger.exception("Exception while initializing sensor")
def initialize_sensor(self):
from mycodo.devices.atlas_scientific_ftdi import AtlasScientificFTDI
from mycodo.devices.atlas_scientific_i2c import AtlasScientificI2C
from mycodo.devices.atlas_scientific_uart import AtlasScientificUART
if self.interface == 'FTDI':
self.logger = logging.getLogger(
"mycodo.inputs.atlas_electrical_conductivity_ftdi_{ftdi}".format(
ftdi=self.ftdi_location))
self.atlas_sensor_ftdi = AtlasScientificFTDI(self.ftdi_location)
elif self.interface == 'UART':
self.logger = logging.getLogger(
"mycodo.inputs.atlas_electrical_conductivity_uart_{uart}".format(
uart=self.uart_location))
self.atlas_sensor_uart = AtlasScientificUART(self.uart_location)
elif self.interface == 'I2C':
self.logger = logging.getLogger(
"mycodo.inputs.atlas_electrical_conductivity_i2c_{bus}_{add}".format(
bus=self.i2c_bus, add=self.i2c_address))
self.atlas_sensor_i2c = AtlasScientificI2C(
i2c_address=self.i2c_address, i2c_bus=self.i2c_bus)
def get_measurement(self):
""" Gets the sensor's Electrical Conductivity measurement via UART/I2C """
electrical_conductivity = None
return_dict = measurements_dict.copy()
# Read sensor via UART
if self.interface == 'FTDI':
if self.atlas_sensor_ftdi.setup:
lines = self.atlas_sensor_ftdi.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('FTDI device is not set up.'
'Check the log for errors.')
# Read sensor via UART
elif 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.')
return_dict[0]['value'] = electrical_conductivity
return return_dict
