def test_raspberry_pi_cpu_temp_special_method_repr():
""" expect a __repr__ format """
with mock.patch('mycodo.inputs.raspi.RaspberryPiCPUTemp.get_measurement') as mock_measure:
mock_measure.side_effect = [0, 0]
rpi_cpu = RaspberryPiCPUTemp()
rpi_cpu.read()
assert "<RaspberryPiCPUTemp(temperature=0.00)>" in repr(rpi_cpu)
def test_raspberry_pi_cpu_temp_next_returns_dict():
""" next returns dict(temperature=float) """
with mock.patch('mycodo.inputs.raspi.RaspberryPiCPUTemp.get_measurement'
) as mock_measure:
mock_measure.side_effect = [67, 52]
rpi_cpu = RaspberryPiCPUTemp()
assert rpi_cpu.next() == dict(temperature=67.00)
def test_raspberry_pi_cpu_temp__iter__returns_iterator():
""" The iter methods must return an iterator in order to work properly """
with mock.patch('mycodo.inputs.raspi.RaspberryPiCPUTemp.get_measurement'
) as mock_measure:
mock_measure.side_effect = [67, 52]
rpi_cpu = RaspberryPiCPUTemp()
assert isinstance(rpi_cpu.__iter__(), Iterator)
def test_raspberry_pi_cpu_temp_special_method_str():
""" expect a __str__ format """
with mock.patch('mycodo.inputs.raspi.RaspberryPiCPUTemp.get_measurement'
) as mock_measure:
mock_measure.side_effect = [0, 0]
rpi_cpu = RaspberryPiCPUTemp(None, testing=True)
rpi_cpu.read()
assert "Temperature: 0.00" in str(rpi_cpu)
def test_raspberry_pi_cpu_temp_temperature_property():
""" verify temperature property """
with mock.patch('mycodo.inputs.raspi.RaspberryPiCPUTemp.get_measurement') as mock_measure:
mock_measure.side_effect = [67, 52]
rpi_cpu = RaspberryPiCPUTemp()
assert rpi_cpu._temperature is None
assert rpi_cpu.temperature == 67.00
assert rpi_cpu.temperature == 67.00
assert not rpi_cpu.read()
assert rpi_cpu.temperature == 52.00
def test_raspberry_pi_cpu_temp_read_updates_temp():
""" Verify that RaspberryPiCPUTemp().read() gets the average temp """
with mock.patch('mycodo.inputs.raspi.RaspberryPiCPUTemp.get_measurement') as mock_measure:
mock_measure.side_effect = [67, 52]
rpi_cpu = RaspberryPiCPUTemp()
assert rpi_cpu._temperature is None
assert not rpi_cpu.read()
assert rpi_cpu._temperature == 67.0
assert not rpi_cpu.read()
assert rpi_cpu._temperature == 52.0
def test_raspberry_pi_cpu_read_logs_unknown_errors():
""" verify that IOErrors are logged """
with LogCapture() as log_cap:
with mock.patch('mycodo.inputs.raspi.RaspberryPiCPUTemp.get_measurement', side_effect=Exception('msg')):
RaspberryPiCPUTemp().read()
expected_logs = ('mycodo.inputs.raspi', 'ERROR', 'RaspberryPiCPUTemp raised an exception when taking a reading: msg')
assert expected_logs in log_cap.actual()
def test_raspberry_pi_cpu_read_logs_ioerrors():
""" verify that IOErrors are logged """
with LogCapture() as log_cap:
with mock.patch('mycodo.inputs.raspi.RaspberryPiCPUTemp.get_measurement', side_effect=IOError('msg')):
RaspberryPiCPUTemp().read()
expected_logs = ('mycodo.inputs.raspi', 'ERROR', "RaspberryPiCPUTemp.get_measurement() method raised IOError: msg")
assert expected_logs in log_cap.actual()
def test_raspberry_pi_cpu_temp_iterates_using_in():
""" Verify that a RaspberryPiCPUTemp object can use the 'in' operator """
with mock.patch('mycodo.inputs.raspi.RaspberryPiCPUTemp.get_measurement') as mock_measure:
mock_measure.side_effect = [67, 52, 37, 45]
rpicpu = RaspberryPiCPUTemp()
expected_result_list = [dict(temperature=67.00),
dict(temperature=52.00),
dict(temperature=37.00),
dict(temperature=45.00)]
assert expected_result_list == [temp for temp in rpicpu]
AtlasPT1000Sensor(None, testing=True),
BH1750Sensor(None, None, None, None, testing=True),
BME280Sensor(None, None, testing=True),
BMP180Sensor(None, testing=True),
BMP280Sensor(None, None, testing=True),
ChirpSensor(None, None, testing=True),
DHT11Sensor(None, None, testing=True),
DHT22Sensor(None, None, testing=True),
DS18B20Sensor(None, None, testing=True),
HTU21DSensor(None, testing=True),
K30Sensor(None, testing=True),
LinuxCommand(None, 'measurement', testing=True),
MHZ16Sensor(None, testing=True),
MHZ19Sensor(None, testing=True),
MycodoRam(testing=True),
RaspberryPiCPUTemp(),
RaspberryPiGPUTemp(),
RaspberryPiCPULoad(),
RaspberryPiFreeSpace(None, testing=True),
SHT1x7xSensor(None, None, None, testing=True),
SHT2xSensor(None, None, testing=True),
SignalPWMInput(None, None, None, testing=True),
SignalRPMInput(None, None, None, None, testing=True),
TMP006Sensor(None, None, testing=True),
TSL2561Sensor(None, None, testing=True),
TSL2591Sensor(None, None, testing=True)
]
# ----------------------------
# AbstractInput
def __init__(self, ready, input_id):
threading.Thread.__init__(self)
self.logger = logging.getLogger(
"mycodo.input_{id}".format(id=input_id.split('-')[0]))
self.stop_iteration_counter = 0
self.thread_startup_timer = timeit.default_timer()
self.thread_shutdown_timer = 0
self.ready = ready
self.lock = {}
self.measurement = None
self.measurement_success = False
self.control = DaemonControl()
self.pause_loop = False
self.verify_pause_loop = True
self.sample_rate = db_retrieve_table_daemon(
Misc, entry='first').sample_rate_controller_input
self.input_id = input_id
input_dev = db_retrieve_table_daemon(
Input, unique_id=self.input_id)
self.input_dev = input_dev
self.input_name = input_dev.name
self.unique_id = input_dev.unique_id
self.i2c_bus = input_dev.i2c_bus
self.location = input_dev.location
self.power_output_id = input_dev.power_output_id
self.measurements = input_dev.measurements
self.convert_to_unit = input_dev.convert_to_unit
self.device = input_dev.device
self.interface = input_dev.interface
self.device_loc = input_dev.device_loc
self.baud_rate = input_dev.baud_rate
self.period = input_dev.period
self.resolution = input_dev.resolution
self.sensitivity = input_dev.sensitivity
self.cmd_command = input_dev.cmd_command
self.cmd_measurement = input_dev.cmd_measurement
self.cmd_measurement_units = input_dev.cmd_measurement_units
self.thermocouple_type = input_dev.thermocouple_type
self.ref_ohm = input_dev.ref_ohm
# Serial
self.pin_clock = input_dev.pin_clock
self.pin_cs = input_dev.pin_cs
self.pin_mosi = input_dev.pin_mosi
self.pin_miso = input_dev.pin_miso
# ADC
self.adc_measure = input_dev.adc_measure
self.adc_volts_min = input_dev.adc_volts_min
self.adc_volts_max = input_dev.adc_volts_max
self.adc_units_min = input_dev.adc_units_min
self.adc_units_max = input_dev.adc_units_max
self.adc_inverse_unit_scale = input_dev.adc_inverse_unit_scale
# Edge detection
self.switch_edge = input_dev.switch_edge
self.switch_bouncetime = input_dev.switch_bouncetime
self.switch_reset_period = input_dev.switch_reset_period
# PWM and RPM options
self.weighting = input_dev.weighting
self.rpm_pulses_per_rev = input_dev.rpm_pulses_per_rev
self.sample_time = input_dev.sample_time
# Server options
self.port = input_dev.port
self.times_check = input_dev.times_check
self.deadline = input_dev.deadline
# Output that will activate prior to input read
self.pre_output_id = input_dev.pre_output_id
self.pre_output_duration = input_dev.pre_output_duration
self.pre_output_during_measure = input_dev.pre_output_during_measure
self.pre_output_setup = False
self.next_measurement = time.time()
self.get_new_measurement = False
self.trigger_cond = False
self.measurement_acquired = False
self.pre_output_activated = False
self.pre_output_locked = False
self.pre_output_timer = time.time()
# Check if Pre-Output ID actually exists
output = db_retrieve_table_daemon(Output, entry='all')
for each_output in output:
if each_output.unique_id == self.pre_output_id and self.pre_output_duration:
self.pre_output_setup = True
smtp = db_retrieve_table_daemon(SMTP, entry='first')
self.smtp_max_count = smtp.hourly_max
self.email_count = 0
self.allowed_to_send_notice = True
# Set up input lock
self.input_lock = None
self.lock_file = '/var/lock/input_pre_output_{id}'.format(id=self.pre_output_id)
# Convert string I2C address to base-16 int
if self.device in LIST_DEVICES_I2C:
self.i2c_address = int(str(self.location), 16)
# Set up edge detection of a GPIO pin
if self.device == 'EDGE':
if self.switch_edge == 'rising':
self.switch_edge_gpio = GPIO.RISING
elif self.switch_edge == 'falling':
self.switch_edge_gpio = GPIO.FALLING
else:
self.switch_edge_gpio = GPIO.BOTH
# Set up analog-to-digital converter
if self.device in LIST_DEVICES_ADC:
if self.device in ['ADS1x15', 'MCP342x']:
self.adc_lock_file = "/var/lock/mycodo_adc_bus{bus}_0x{i2c:02X}.pid".format(
bus=self.i2c_bus, i2c=self.i2c_address)
elif self.device == 'MCP3008':
self.adc_lock_file = "/var/lock/mycodo_adc_uart-{clock}-{cs}-{miso}-{mosi}".format(
clock=self.pin_clock, cs=self.pin_cs, miso=self.pin_miso, mosi=self.pin_mosi)
if self.device == 'ADS1x15' and self.location:
from mycodo.devices.ads1x15 import ADS1x15Read
self.adc = ADS1x15Read(self.input_dev)
elif self.device == 'MCP3008':
from mycodo.devices.mcp3008 import MCP3008Read
self.adc = MCP3008Read(self.input_dev)
elif self.device == 'MCP342x' and self.location:
from mycodo.devices.mcp342x import MCP342xRead
self.adc = MCP342xRead(self.input_dev)
else:
self.adc = None
self.device_recognized = True
# Set up inputs or devices
if self.device in ['EDGE'] + LIST_DEVICES_ADC:
self.measure_input = None
elif self.device == 'MYCODO_RAM':
from mycodo.inputs.mycodo_ram import MycodoRam
self.measure_input = MycodoRam(self.input_dev)
elif self.device == 'RPiCPULoad':
from mycodo.inputs.raspi_cpuload import RaspberryPiCPULoad
self.measure_input = RaspberryPiCPULoad(self.input_dev)
elif self.device == 'RPi':
from mycodo.inputs.raspi import RaspberryPiCPUTemp
self.measure_input = RaspberryPiCPUTemp(self.input_dev)
elif self.device == 'RPiFreeSpace':
from mycodo.inputs.raspi_freespace import RaspberryPiFreeSpace
self.measure_input = RaspberryPiFreeSpace(self.input_dev)
elif self.device == 'AM2315':
from mycodo.inputs.am2315 import AM2315Sensor
self.measure_input = AM2315Sensor(self.input_dev)
elif self.device == 'ATLAS_EC_I2C':
from mycodo.inputs.atlas_ec import AtlasElectricalConductivitySensor
self.measure_input = AtlasElectricalConductivitySensor(self.input_dev)
elif self.device == 'ATLAS_EC_UART':
from mycodo.inputs.atlas_ec import AtlasElectricalConductivitySensor
self.measure_input = AtlasElectricalConductivitySensor(self.input_dev)
elif self.device == 'ATLAS_PH_I2C':
from mycodo.inputs.atlas_ph import AtlaspHSensor
self.measure_input = AtlaspHSensor(self.input_dev)
elif self.device == 'ATLAS_PH_UART':
from mycodo.inputs.atlas_ph import AtlaspHSensor
self.measure_input = AtlaspHSensor(self.input_dev)
elif self.device == 'ATLAS_PT1000_I2C':
from mycodo.inputs.atlas_pt1000 import AtlasPT1000Sensor
self.measure_input = AtlasPT1000Sensor(self.input_dev)
elif self.device == 'ATLAS_PT1000_UART':
from mycodo.inputs.atlas_pt1000 import AtlasPT1000Sensor
self.measure_input = AtlasPT1000Sensor(self.input_dev)
elif self.device == 'BH1750':
from mycodo.inputs.bh1750 import BH1750Sensor
self.measure_input = BH1750Sensor(self.input_dev)
elif self.device == 'BME280':
from mycodo.inputs.bme280 import BME280Sensor
self.measure_input = BME280Sensor(self.input_dev)
elif self.device == 'BMP180':
from mycodo.inputs.bmp180 import BMP180Sensor
self.measure_input = BMP180Sensor(self.input_dev)
elif self.device == 'BMP280':
from mycodo.inputs.bmp280 import BMP280Sensor
self.measure_input = BMP280Sensor(self.input_dev)
elif self.device == 'CCS811':
from mycodo.inputs.ccs811 import CCS811Sensor
self.measure_input = CCS811Sensor(self.input_dev)
elif self.device == 'CHIRP':
from mycodo.inputs.chirp import ChirpSensor
self.measure_input = ChirpSensor(self.input_dev)
elif self.device == 'COZIR_CO2':
from mycodo.inputs.cozir_co2 import COZIRSensor
self.measure_input = COZIRSensor(self.input_dev)
elif self.device == 'DHT11':
from mycodo.inputs.dht11 import DHT11Sensor
self.measure_input = DHT11Sensor(self.input_dev)
elif self.device in ['DHT22', 'AM2302']:
from mycodo.inputs.dht22 import DHT22Sensor
self.measure_input = DHT22Sensor(self.input_dev)
elif self.device == 'DS18B20':
from mycodo.inputs.ds18b20 import DS18B20Sensor
self.measure_input = DS18B20Sensor(self.input_dev)
elif self.device == 'DS18S20':
from mycodo.inputs.ds18s20 import DS18S20Sensor
self.measure_input = DS18S20Sensor(self.input_dev)
elif self.device == 'DS1822':
from mycodo.inputs.ds1822 import DS1822Sensor
self.measure_input = DS1822Sensor(self.input_dev)
elif self.device == 'DS28EA00':
from mycodo.inputs.ds28ea00 import DS28EA00Sensor
self.measure_input = DS28EA00Sensor(self.input_dev)
elif self.device == 'DS1825':
from mycodo.inputs.ds1825 import DS1825Sensor
self.measure_input = DS1825Sensor(self.input_dev)
elif self.device == 'GPIO_STATE':
from mycodo.inputs.gpio_state import GPIOState
self.measure_input = GPIOState(self.input_dev)
elif self.device == 'HDC1000':
from mycodo.inputs.hdc1000 import HDC1000Sensor
self.measure_input = HDC1000Sensor(self.input_dev)
elif self.device == 'HTU21D':
from mycodo.inputs.htu21d import HTU21DSensor
self.measure_input = HTU21DSensor(self.input_dev)
elif self.device == 'K30_UART':
from mycodo.inputs.k30 import K30Sensor
self.measure_input = K30Sensor(self.input_dev)
elif self.device == 'LinuxCommand':
from mycodo.inputs.linux_command import LinuxCommand
self.measure_input = LinuxCommand(self.input_dev)
elif self.device == 'MAX31850K':
from mycodo.inputs.max31850k import MAX31850KSensor
self.measure_input = MAX31850KSensor(self.input_dev)
elif self.device == 'MAX31855':
from mycodo.inputs.max31855 import MAX31855Sensor
self.measure_input = MAX31855Sensor(self.input_dev)
elif self.device == 'MAX31856':
from mycodo.inputs.max31856 import MAX31856Sensor
self.measure_input = MAX31856Sensor(self.input_dev)
elif self.device == 'MAX31865':
from mycodo.inputs.max31865 import MAX31865Sensor
self.measure_input = MAX31865Sensor(self.input_dev)
elif self.device == 'MH_Z16_I2C':
from mycodo.inputs.mh_z16 import MHZ16Sensor
self.measure_input = MHZ16Sensor(self.input_dev)
elif self.device == 'MH_Z16_UART':
from mycodo.inputs.mh_z16 import MHZ16Sensor
self.measure_input = MHZ16Sensor(self.input_dev)
elif self.device == 'MH_Z19_UART':
from mycodo.inputs.mh_z19 import MHZ19Sensor
self.measure_input = MHZ19Sensor(self.input_dev)
elif self.device == 'MIFLORA':
from mycodo.inputs.miflora_sensor import MifloraSensor
self.measure_input = MifloraSensor(self.input_dev)
elif self.device == 'SERVER_PING':
from mycodo.inputs.server_ping import ServerPing
self.measure_input = ServerPing(self.input_dev)
elif self.device == 'SERVER_PORT_OPEN':
from mycodo.inputs.server_port_open import ServerPortOpen
self.measure_input = ServerPortOpen(self.input_dev)
elif self.device == 'SHT1x_7x':
from mycodo.inputs.sht1x_7x import SHT1x7xSensor
self.measure_input = SHT1x7xSensor(self.input_dev)
elif self.device == 'SHT2x':
from mycodo.inputs.sht2x import SHT2xSensor
self.measure_input = SHT2xSensor(self.input_dev)
elif self.device == 'SIGNAL_PWM':
from mycodo.inputs.signal_pwm import SignalPWMInput
self.measure_input = SignalPWMInput(self.input_dev)
elif self.device == 'SIGNAL_RPM':
from mycodo.inputs.signal_rpm import SignalRPMInput
self.measure_input = SignalRPMInput(self.input_dev)
elif self.device == 'TMP006':
from mycodo.inputs.tmp006 import TMP006Sensor
self.measure_input = TMP006Sensor(self.input_dev)
elif self.device == 'TSL2561':
from mycodo.inputs.tsl2561 import TSL2561Sensor
self.measure_input = TSL2561Sensor(self.input_dev)
elif self.device == 'TSL2591':
from mycodo.inputs.tsl2591_sensor import TSL2591Sensor
self.measure_input = TSL2591Sensor(self.input_dev)
else:
self.device_recognized = False
self.logger.debug("Device '{device}' not recognized".format(
device=self.device))
raise Exception("'{device}' is not a valid device type.".format(
device=self.device))
self.edge_reset_timer = time.time()
self.input_timer = time.time()
self.running = False
self.lastUpdate = None
def __init__(self, ready, input_id):
threading.Thread.__init__(self)
self.logger = logging.getLogger(
"mycodo.input_{id}".format(id=input_id))
self.stop_iteration_counter = 0
self.thread_startup_timer = timeit.default_timer()
self.thread_shutdown_timer = 0
self.ready = ready
self.lock = {}
self.measurement = None
self.updateSuccess = False
self.input_id = input_id
self.control = DaemonControl()
self.pause_loop = False
self.verify_pause_loop = True
input_dev = db_retrieve_table_daemon(Input, device_id=self.input_id)
self.input_sel = input_dev
self.id = input_dev.id
self.unique_id = input_dev.unique_id
self.i2c_bus = input_dev.i2c_bus
self.location = input_dev.location
self.power_output_id = input_dev.power_relay_id
self.measurements = input_dev.measurements
self.device = input_dev.device
self.interface = input_dev.interface
self.device_loc = input_dev.device_loc
self.baud_rate = input_dev.baud_rate
self.period = input_dev.period
self.resolution = input_dev.resolution
self.sensitivity = input_dev.sensitivity
self.cmd_command = input_dev.cmd_command
self.cmd_measurement = input_dev.cmd_measurement
self.cmd_measurement_units = input_dev.cmd_measurement_units
self.mux_address_raw = input_dev.multiplexer_address
self.mux_bus = input_dev.multiplexer_bus
self.mux_chan = input_dev.multiplexer_channel
self.adc_chan = input_dev.adc_channel
self.adc_gain = input_dev.adc_gain
self.adc_resolution = input_dev.adc_resolution
self.adc_measure = input_dev.adc_measure
self.adc_measure_units = input_dev.adc_measure_units
self.adc_volts_min = input_dev.adc_volts_min
self.adc_volts_max = input_dev.adc_volts_max
self.adc_units_min = input_dev.adc_units_min
self.adc_units_max = input_dev.adc_units_max
self.adc_inverse_unit_scale = input_dev.adc_inverse_unit_scale
self.sht_clock_pin = input_dev.sht_clock_pin
self.sht_voltage = input_dev.sht_voltage
# Edge detection
self.switch_edge = input_dev.switch_edge
self.switch_bouncetime = input_dev.switch_bouncetime
self.switch_reset_period = input_dev.switch_reset_period
# PWM and RPM options
self.weighting = input_dev.weighting
self.rpm_pulses_per_rev = input_dev.rpm_pulses_per_rev
self.sample_time = input_dev.sample_time
# Server options
self.port = input_dev.port
self.times_check = input_dev.times_check
self.deadline = input_dev.deadline
# Output that will activate prior to input read
self.pre_output_id = input_dev.pre_relay_id
self.pre_output_duration = input_dev.pre_relay_duration
self.pre_output_setup = False
self.next_measurement = time.time()
self.get_new_measurement = False
self.trigger_cond = False
self.measurement_acquired = False
self.pre_output_activated = False
self.pre_output_timer = time.time()
output = db_retrieve_table_daemon(Output, entry='all')
for each_output in output: # Check if output ID actually exists
if each_output.id == self.pre_output_id and self.pre_output_duration:
self.pre_output_setup = True
smtp = db_retrieve_table_daemon(SMTP, entry='first')
self.smtp_max_count = smtp.hourly_max
self.email_count = 0
self.allowed_to_send_notice = True
# Convert string I2C address to base-16 int
if self.device in LIST_DEVICES_I2C:
self.i2c_address = int(str(self.location), 16)
# Set up multiplexer if enabled
if self.device in LIST_DEVICES_I2C and self.mux_address_raw:
self.mux_address_string = self.mux_address_raw
self.mux_address = int(str(self.mux_address_raw), 16)
self.mux_lock = "/var/lock/mycodo_multiplexer_0x{i2c:02X}.pid".format(
i2c=self.mux_address)
self.mux_lock = fasteners.InterProcessLock(self.mux_lock)
self.mux_lock_acquired = False
self.multiplexer = TCA9548A(self.mux_bus, self.mux_address)
else:
self.multiplexer = None
# Set up edge detection of a GPIO pin
if self.device == 'EDGE':
if self.switch_edge == 'rising':
self.switch_edge_gpio = GPIO.RISING
elif self.switch_edge == 'falling':
self.switch_edge_gpio = GPIO.FALLING
else:
self.switch_edge_gpio = GPIO.BOTH
# Lock multiplexer, if it's enabled
if self.multiplexer:
self.lock_multiplexer()
# Set up analog-to-digital converter
if self.device in ['ADS1x15', 'MCP342x'] and self.location:
self.adc_lock_file = "/var/lock/mycodo_adc_bus{bus}_0x{i2c:02X}.pid".format(
bus=self.i2c_bus, i2c=self.i2c_address)
if self.device == 'ADS1x15':
self.adc = ADS1x15Read(self.i2c_address, self.i2c_bus,
self.adc_chan, self.adc_gain)
elif self.device == 'MCP342x':
self.adc = MCP342xRead(self.i2c_address, self.i2c_bus,
self.adc_chan, self.adc_gain,
self.adc_resolution)
else:
self.adc = None
self.device_recognized = True
# Set up inputs or devices
if self.device in ['EDGE', 'ADS1x15', 'MCP342x']:
self.measure_input = None
elif self.device == 'MYCODO_RAM':
self.measure_input = MycodoRam()
elif self.device == 'RPiCPULoad':
self.measure_input = RaspberryPiCPULoad()
elif self.device == 'RPi':
self.measure_input = RaspberryPiCPUTemp()
elif self.device == 'RPiFreeSpace':
self.measure_input = RaspberryPiFreeSpace(self.location)
elif self.device == 'AM2302':
self.measure_input = DHT22Sensor(int(self.location))
elif self.device == 'AM2315':
self.measure_input = AM2315Sensor(self.i2c_bus,
power=self.power_output_id)
elif self.device == 'ATLAS_PH_I2C':
self.measure_input = AtlaspHSensor(self.interface,
i2c_address=self.i2c_address,
i2c_bus=self.i2c_bus,
sensor_sel=self.input_sel)
elif self.device == 'ATLAS_PH_UART':
self.measure_input = AtlaspHSensor(self.interface,
device_loc=self.device_loc,
baud_rate=self.baud_rate,
sensor_sel=self.input_sel)
elif self.device == 'ATLAS_PT1000_I2C':
self.measure_input = AtlasPT1000Sensor(
self.interface,
i2c_address=self.i2c_address,
i2c_bus=self.i2c_bus)
elif self.device == 'ATLAS_PT1000_UART':
self.measure_input = AtlasPT1000Sensor(self.interface,
device_loc=self.device_loc,
baud_rate=self.baud_rate)
elif self.device == 'BH1750':
self.measure_input = BH1750Sensor(self.i2c_address, self.i2c_bus,
self.resolution,
self.sensitivity)
elif self.device == 'BME280':
self.measure_input = BME280Sensor(self.i2c_address, self.i2c_bus)
elif self.device == 'BMP180':
self.measure_input = BMP180Sensor(self.i2c_bus)
elif self.device == 'BMP280':
self.measure_input = BMP280Sensor(self.i2c_address, self.i2c_bus)
elif self.device == 'CHIRP':
self.measure_input = ChirpSensor(self.i2c_address, self.i2c_bus)
elif self.device == 'DS18B20':
self.measure_input = DS18B20Sensor(self.location)
elif self.device == 'DHT11':
self.measure_input = DHT11Sensor(self.input_id,
int(self.location),
power=self.power_output_id)
elif self.device == 'DHT22':
self.measure_input = DHT22Sensor(int(self.location),
power=self.power_output_id)
elif self.device == 'GPIO_STATE':
self.measure_input = GPIOState(int(self.location))
elif self.device == 'HTU21D':
self.measure_input = HTU21DSensor(self.i2c_bus)
elif self.device == 'K30_UART':
self.measure_input = K30Sensor(self.device_loc,
baud_rate=self.baud_rate)
elif self.device == 'MH_Z16_I2C':
self.measure_input = MHZ16Sensor(self.interface,
i2c_address=self.i2c_address,
i2c_bus=self.i2c_bus)
elif self.device == 'MH_Z16_UART':
self.measure_input = MHZ16Sensor(self.interface,
device_loc=self.device_loc,
baud_rate=self.baud_rate)
elif self.device == 'MH_Z19_UART':
self.measure_input = MHZ19Sensor(self.device_loc,
baud_rate=self.baud_rate)
elif self.device == 'SHT1x_7x':
self.measure_input = SHT1x7xSensor(int(self.location),
self.sht_clock_pin,
self.sht_voltage)
elif self.device == 'SHT2x':
self.measure_input = SHT2xSensor(self.i2c_address, self.i2c_bus)
elif self.device == 'SIGNAL_PWM':
self.measure_input = SignalPWMInput(int(self.location),
self.weighting,
self.sample_time)
elif self.device == 'SIGNAL_RPM':
self.measure_input = SignalRPMInput(int(self.location),
self.weighting,
self.rpm_pulses_per_rev,
self.sample_time)
elif self.device == 'TMP006':
self.measure_input = TMP006Sensor(self.i2c_address, self.i2c_bus)
elif self.device == 'TSL2561':
self.measure_input = TSL2561Sensor(self.i2c_address, self.i2c_bus)
elif self.device == 'TSL2591':
self.measure_input = TSL2591Sensor(self.i2c_address, self.i2c_bus)
elif self.device == 'LinuxCommand':
self.measure_input = LinuxCommand(self.cmd_command,
self.cmd_measurement)
elif self.device == 'SERVER_PING':
self.measure_input = ServerPing(self.location, self.times_check,
self.deadline)
elif self.device == 'SERVER_PORT_OPEN':
self.measure_input = ServerPortOpen(self.location, self.port)
else:
self.device_recognized = False
self.logger.debug(
"Device '{device}' not recognized".format(device=self.device))
raise Exception("'{device}' is not a valid device type.".format(
device=self.device))
if self.multiplexer:
self.unlock_multiplexer()
self.edge_reset_timer = time.time()
self.input_timer = time.time()
self.running = False
self.lastUpdate = None
def test_raspberry_pi_cpu_temp_get_measurement_divs_by_1k():
""" verify the return value of get_measurement """
mocked_open = mock.mock_open(read_data='45780')
with mock.patch('mycodo.inputs.raspi.open', mocked_open, create=True):
assert RaspberryPiCPUTemp.get_measurement() == 45.78
def test_raspberry_pi_cpu_temp_read_returns_1_on_exception():
""" Verify the read() method returns true on error """
with mock.patch('mycodo.inputs.raspi.RaspberryPiCPUTemp.get_measurement', side_effect=Exception):
assert RaspberryPiCPUTemp().read()
def test_raspberry_pi_cpu_temp_raises_exception():
""" stops iteration on read() error """
with mock.patch('mycodo.inputs.raspi.RaspberryPiCPUTemp.get_measurement', side_effect=IOError):
with pytest.raises(StopIteration):
RaspberryPiCPUTemp().next()
AtlasPT1000Sensor(None, testing=True),
BH1750Sensor(None, testing=True),
BME280Sensor(None, testing=True),
BMP180Sensor(None, testing=True),
BMP280Sensor(None, testing=True),
ChirpSensor(None, testing=True),
DHT11Sensor(None, testing=True),
DHT22Sensor(None, testing=True),
DS18B20Sensor(None, testing=True),
HTU21DSensor(None, testing=True),
K30Sensor(None, testing=True),
LinuxCommand(None, testing=True),
MHZ16Sensor(None, testing=True),
MHZ19Sensor(None, testing=True),
MycodoRam(None, testing=True),
RaspberryPiCPUTemp(None, testing=True),
RaspberryPiCPULoad(None, testing=True),
RaspberryPiFreeSpace(None, testing=True),
SHT1x7xSensor(None, testing=True),
SHT2xSensor(None, testing=True),
SignalPWMInput(None, testing=True),
SignalRPMInput(None, testing=True),
TMP006Sensor(None, testing=True),
TSL2561Sensor(None, testing=True),
TSL2591Sensor(None, testing=True)
]
# ----------------------------
# AM2315 tests
# ----------------------------