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_i2c import AtlasScientificI2C
from mycodo.devices.atlas_scientific_uart import AtlasScientificUART
if self.interface == 'UART':
self.atlas_sensor_uart = AtlasScientificUART(
self.device_loc, baudrate=self.baud_rate)
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.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 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 __init__(self, interface, device_loc=None, baud_rate=None,
i2c_address=None, i2c_bus=None, sensor_sel=None):
super(AtlaspHSensor, self).__init__()
self._ph = 0
self.interface = interface
self.sensor_sel = sensor_sel
if self.interface == 'UART':
self.atlas_sensor_uart = AtlasScientificUART(device_loc,
baudrate=baud_rate)
elif self.interface == 'I2C':
self.atlas_sensor_i2c = AtlasScientificI2C(
i2c_address=i2c_address, i2c_bus=i2c_bus)
def initialize_sensor(self):
from mycodo.devices.atlas_scientific_i2c import AtlasScientificI2C
from mycodo.devices.atlas_scientific_uart import AtlasScientificUART
if self.interface == 'UART':
self.logger = logging.getLogger(
"mycodo.inputs.atlas_ph_{uart}".format(uart=self.device_loc))
self.atlas_sensor_uart = AtlasScientificUART(self.device_loc)
elif self.interface == 'I2C':
self.logger = logging.getLogger(
"mycodo.inputs.atlas_ph_{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 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 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 == 'UART':
ph_input_uart = AtlasScientificUART(
selected_input.device_loc, 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.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
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 __init__(self, sensor_sel):
self.cmd_send = None
self.ph_sensor_uart = None
self.ph_sensor_i2c = None
self.interface = sensor_sel.interface
if self.interface == 'UART':
self.ph_sensor_uart = AtlasScientificUART(
sensor_sel.device_loc, baudrate=sensor_sel.baud_rate)
elif self.interface == 'I2C':
self.ph_sensor_i2c = AtlasScientificI2C(
i2c_address=sensor_sel.i2c_address, i2c_bus=sensor_sel.i2c_bus)
self.board_version, self.board_info = self.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:
logger.debug("Device Info: {info}".format(info=self.board_info))
logger.debug(
"Detected Version: {ver}".format(ver=self.board_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.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))
