def __update_exit_reader(self):
"""Update exit reader state."""
if self.__exit_reader is not None:
# Update card reader.
self.__exit_reader.update()
if self.__exit_reader.reader_state == CardReaderState.STOP:
message = "Card reader {}; State {}; Port {}."\
.format(self.__exit_reader.serial_number, \
self.__exit_reader.reader_state, \
self.__exit_reader.port_name)
GlobalErrorHandler.log_hardware_malfunction(
self.__logger, message)
self.__exit_reader.init()
if self.__exit_reader.reader_state == CardReaderState.NONE:
message = "Card reader {}; State {}."\
.format(self.__exit_reader.serial_number, self.__entry_reader.reader_state)
GlobalErrorHandler.log_hardware_malfunction(
self.__logger, message)
self.__exit_reader.init()
def analog_read(self, pin):
"""Write the analog input pin.
Parameters
----------
pin : str
Pin index.
value : int
Value for the output pin.
Returns
-------
int
State of the pin.
"""
if self.is_gpio_off(pin):
return False
if self.is_gpio_nothing(pin):
raise ValueError("Pin can not be None or empty string.")
value = 0.0
state = {"value": value, "min": 0.0, "max": 10.0}
# Local GPIO.
if self.is_gpio_local(pin):
# Read device analog inputs.
request = self.__black_island.generate_request("GetAnalogInputs")
irr_response = self.__modbus_rtu_clients[0].execute(request)
if irr_response is not None:
if not irr_response.isError():
self.__AI = irr_response.registers
else:
GlobalErrorHandler.log_hardware_malfunction(
self.__logger,
"GPIO: {} @ {} malfunctioning, check modbus cables and connections."
.format(pin, self))
else:
GlobalErrorHandler.log_hardware_malfunction(
self.__logger,
"GPIO: {} @ {} malfunctioning, check modbus cables and connections."
.format(pin, self))
value = self.__AI[self._gpio_map[pin]]
value = l_scale(value, [0, 50000], [0, 10])
state["value"] = value
# self.__logger.debug("analog_read({}, {})".format(self.model, pin))
else:
raise ValueError("Pin does not exists in pin map.")
return state
def analog_write(self, pin, value):
"""Write the analog input pin.
Parameters
----------
pin : str
Pin index.
value : int
Value for the output pin.
Returns
-------
int
State of the pin.
"""
if self.is_gpio_off(pin):
return False
if self.is_gpio_nothing(pin):
raise ValueError("Pin can not be None or empty string.")
response = False
# Local GPIO.
if self.is_gpio_local(pin):
value = l_scale(value, [0, 10], [0, 50000])
value = int(value)
self.__AO[self._gpio_map[pin]] = value
# Write device analog outputs.
request = self.__black_island\
.generate_request("SetAnalogOutputs", SetAnalogOutputs=self.__AO)
hrw_response = self.__modbus_rtu_clients[0].execute(request)
if hrw_response is not None:
if not hrw_response.isError():
response = True
else:
GlobalErrorHandler.log_hardware_malfunction(
self.__logger,
"GPIO: {} @ {} malfunctioning, check modbus cables and connections."
.format(pin, self))
else:
GlobalErrorHandler.log_hardware_malfunction(
self.__logger,
"GPIO: {} @ {} malfunctioning, check modbus cables and connections."
.format(pin, self))
# self.__logger.debug("analog_write({}, {}, {})".format(self.model, pin, value))
else:
raise ValueError("Pin does not exists in pin map.")
return response
def get_temp(self):
"""Get temperature.
Returns:
float: Value of the temperature.
"""
value = 0.0
# TODO: Split the device.
try:
request = self.generate_request("Temperature")
response = self._controller.execute_mb_request(request, self.uart)
if response is not None:
if not response.isError():
value = response.registers[0] / 10
# Dump good value.
self.__last_good_measurement = value
# Reset the counter.
self.__unsuccessful_times = 0
else:
self.__unsuccessful_times += 1
value = self.__last_good_measurement
else:
self.__unsuccessful_times += 1
value = self.__last_good_measurement
except Exception:
self.__unsuccessful_times += 1
value = self.__last_good_measurement
if self.__unsuccessful_times >= self.__unsuccessful_times_limit:
GlobalErrorHandler.log_hardware_malfunction(
self.__logger,
"Device: {}; ID: {}; Can not read the temperature value.".
format(self.name, request.unit_id))
return value
def get_setpoint_temp(self):
"""Get mode.
Returns:
int: Value of the mode of the air camber.
"""
value = None
try:
request = self.generate_request("GetTemperatureSetpoint")
response = self._controller.execute_mb_request(request, self.uart)
if response is not None:
if not response.isError():
value = response.registers[0]
else:
GlobalErrorHandler.log_hardware_malfunction(
self.__logger,
"Device: {}; ID: {}; Response error.".format(
self.name, request.unit_id))
else:
GlobalErrorHandler.log_hardware_malfunction(
self.__logger,
"Device: {}; ID: {}; Invalid response.".format(
self.name, request.unit_id))
except Exception:
GlobalErrorHandler.log_hardware_malfunction(
self.__logger,
"Device: {}; ID: {}; Can not read the mode.".format(
self.name, request.unit_id))
return value
def get_alarms(self):
"""Get alarm bit.
Returns:
bool: Value of the alarm.
"""
value = False
try:
request = self.generate_request("GlobalAlarm")
response = self._controller.execute_mb_request(request, self.uart)
if response is not None:
if not response.isError():
value = response.registers[0] != 0
else:
GlobalErrorHandler.log_hardware_malfunction(
self.__logger,
"Device: {}; ID: {}; Response error.".format(
self.name, request.unit_id))
else:
GlobalErrorHandler.log_hardware_malfunction(
self.__logger,
"Device: {}; ID: {}; Invalid response.".format(
self.name, request.unit_id))
except Exception:
GlobalErrorHandler.log_hardware_malfunction(
self.__logger,
"Device: {}; ID: {}; Can not read the temperature value.".
format(self.name, request.unit_id))
return value
def set_fresh_air(self, setpiont):
"""Set fresh air of the air chamber.
Args:
setpiont (float): Percentage
Returns:
int: Value of the mode of the air camber.
"""
# get the value.
local_setpiont = setpiont
# Filter the minimum.
if local_setpiont < 0:
local_setpiont = 0
# Filter the maximum.
if local_setpiont > 100:
local_setpiont = 100
# Divide by 10 to get in nominal.
local_setpiont = local_setpiont / 10.0
# Take only integer part without rounding.
local_setpiont = int(local_setpiont)
value = None
try:
request = self.generate_request("FreshAir")
response = self._controller.execute_mb_request(
request, FreshAir=local_setpiont)
if response is not None:
if not response.isError():
value = response.registers[0]
else:
GlobalErrorHandler.log_hardware_malfunction(
self.__logger,
"Device: {}; ID: {}; Response error.".format(
self.name, request.unit_id))
else:
GlobalErrorHandler.log_hardware_malfunction(
self.__logger,
"Device: {}; ID: {}; Invalid response.".format(
self.name, request.unit_id))
except Exception:
GlobalErrorHandler.log_hardware_malfunction(
self.__logger,
"Device: {}; ID: {}; Can not read the mode.".format(
self.name, request.unit_id))
return value
def set_mode(self, mode):
"""Set mode of the air chamber.
Args:
mode (int): Mode of the chamber.
Returns:
int: Value of the mode of the air camber.
"""
value = None
try:
request = self.generate_request("SetMode")
response = self._controller.execute_mb_request(request,
SetMode=mode)
if response is not None:
if not response.isError():
value = response.registers[0]
else:
GlobalErrorHandler.log_hardware_malfunction(
self.__logger,
"Device: {}; ID: {}; Response error.".format(
self.name, request.unit_id))
else:
GlobalErrorHandler.log_hardware_malfunction(
self.__logger,
"Device: {}; ID: {}; Invalid response.".format(
self.name, request.unit_id))
except Exception:
GlobalErrorHandler.log_hardware_malfunction(
self.__logger,
"Device: {}; ID: {}; Can not read the mode.".format(
self.name, request.unit_id))
return value
def get_fresh_air(self):
"""Get fresh air.
Returns:
int: Value of the mode of the air camber.
"""
value = None
try:
request = self.generate_request("FreshAir")
response = self._controller.execute_mb_request(request, self.uart)
if response is not None:
if not response.isError():
value = response.registers[0]
# Multiply
value = value * 10.0
else:
GlobalErrorHandler.log_hardware_malfunction(
self.__logger,
"Device: {}; ID: {}; Response error.".format(
self.name, request.unit_id))
else:
GlobalErrorHandler.log_hardware_malfunction(
self.__logger,
"Device: {}; ID: {}; Invalid response.".format(
self.name, request.unit_id))
except Exception:
GlobalErrorHandler.log_hardware_malfunction(
self.__logger,
"Device: {}; ID: {}; Can not read the fresh air value.".format(
self.name, request.unit_id))
return value
def update(self):
"""Update the valve state.
"""
if self._state.is_state(ValveState.Prepare):
delta_pos = self.target_position - self.current_position
if delta_pos == 0:
self.__stop()
self._state.set_state(ValveState.Wait)
return
time_to_move = self.__to_time(abs(delta_pos))
self.__logger.debug("Time: {}".format(time_to_move))
self.__move_timer.expiration_time = time_to_move
self.__move_timer.update_last_time()
if delta_pos > 0:
self.__open_valve()
elif delta_pos < 0:
self.__close_valve()
self._state.set_state(ValveState.Execute)
elif self._state.is_state(ValveState.Execute):
self.__move_timer.update()
if self.__move_timer.expired:
self.__move_timer.clear()
self.__stop()
self._current_position = self.target_position
self._state.set_state(ValveState.Wait)
cw_limit_state = False # self.__get_close_limit()
ccw_limit_state = False # self.__get_open_limit()
if cw_limit_state or ccw_limit_state:
self.__stop()
GlobalErrorHandler.log_hardware_limit(
self.__logger,
"{} has raised end position.".format(self.name))
self._current_position = self.target_position
self._state.set_state(ValveState.Wait)
elif self._state.is_state(ValveState.Calibrate):
# Wait to start.
if self.__calibration_state.is_state(CalibrationState.NONE):
self.__calibration_state.set_state(CalibrationState.OpenValve)
self.__stop()
# Open the valve.
if self.__calibration_state.is_state(CalibrationState.OpenValve):
self.__stop()
self.__open_valve()
self.__calibration_state.set_state(CalibrationState.EnsureOpen)
self.__limit_timer.update_last_time()
# Wait until it si open at 100%.
if self.__calibration_state.is_state(CalibrationState.EnsureOpen):
# Get CCW limit switch state.
ccw_limit_state = self.__get_open_limit()
if ccw_limit_state:
self.__t0 = time.time()
self.__calibration_state.set_state(
CalibrationState.CloseValve)
# Prevent with timer,
# if the valve is not reacting properly.
self.__limit_timer.update()
if self.__limit_timer.expired:
self.__limit_timer.clear()
self.__calibration_state.set_state(CalibrationState.Error)
# Close the valve.
if self.__calibration_state.is_state(CalibrationState.CloseValve):
self.__stop()
self.__close_valve()
self.__calibration_state.set_state(
CalibrationState.EnsureClose)
self.__limit_timer.update_last_time()
# Wait until it si open at 100%.
if self.__calibration_state.is_state(CalibrationState.EnsureClose):
# Get CW limit switch state.
cw_limit_state = self.__get_close_limit()
if cw_limit_state:
self.__t1 = time.time()
self.__calibration_state.set_state(
CalibrationState.YouDoTheMath)
# Prevent with timer,
# if the valve is not reacting properly.
self.__limit_timer.update()
if self.__limit_timer.expired:
self.__limit_timer.clear()
self.__calibration_state.set_state(CalibrationState.Error)
# Make calculations.
if self.__calibration_state.is_state(
CalibrationState.YouDoTheMath):
self.__stop()
self.__dt = self.__t1 - self.__t0
self._state.set_state(ValveState.Wait)
# Close the valve.
if self.__calibration_state.is_state(CalibrationState.Error):
GlobalErrorHandler.log_hardware_malfunction(
self.__logger,
"The valve {} can not calibrated.".format(self.name))
self._state.set_state(ValveState.Wait)
def digital_write(self, pin, value):
"""Write the digital output pin.
Parameters
----------
pin : str
Pin index.
value : int
Value for the output pin.
Returns
-------
mixed
State of the pin.
"""
response = False
state = False
if self.is_gpio_off(pin):
return False
if self.is_gpio_nothing(pin):
raise ValueError("Pin can not be None or empty string.")
# Make is bool.
state = bool(value)
# Inversion
if self.is_gpio_inverted(pin):
state = not state
# Local GPIO.
if self.is_gpio_local(pin):
gpio = self._gpio_map[pin]
self.__DORO[gpio] = state
# Write device digital & relay outputs.
request = self.__black_island.generate_request(
"SetRelays", SetRelays=self.__DORO)
cw_response = self.__modbus_rtu_clients[0].execute(request)
if cw_response is not None:
if not cw_response.isError():
response = True
else:
GlobalErrorHandler.log_hardware_malfunction(
self.__logger,
"GPIO: {} @ {} malfunctioning, check modbus cables and connections."
.format(pin, self))
else:
GlobalErrorHandler.log_hardware_malfunction(
self.__logger,
"GPIO: {} @ {} malfunctioning, check modbus cables and connections."
.format(pin, self))
# self.__logger.debug("digital_write({}, {}, {})".format(self.model, pin, value))
# Remote GPIO.
elif self.is_gpio_remote(pin):
remote_gpio = self.parse_remote_gpio(pin)
write_response = self.__modbus_rtu_clients[
remote_gpio["uart"]].write_coil(remote_gpio["io_reg"] +
remote_gpio["io_index"],
state,
unit=remote_gpio["mb_id"])
if not write_response.isError():
response = True
else:
raise ValueError("Pin does not exists in pin map.")
return response
def digital_read(self, pin):
"""Read the digital input pin.
Args:
pin (int): Pin index.
Returns:
int: State of the pin.
"""
if self.is_gpio_off(pin):
return False
if self.is_gpio_nothing(pin):
raise ValueError("Pin can not be None or empty string.")
response = False
# Local GPIO.
if self.is_gpio_local(pin):
# Read device digital inputs.
request = self.__black_island.generate_request("GetDigitalInputs")
di_response = self.__modbus_rtu_clients[0].execute(request)
if di_response is not None:
if not di_response.isError():
self.__DI = di_response.bits
else:
GlobalErrorHandler.log_hardware_malfunction(
self.__logger,
"GPIO: {} @ {} malfunctioning, check modbus cables and connections."
.format(pin, self))
else:
GlobalErrorHandler.log_hardware_malfunction(
self.__logger,
"GPIO: {} @ {} malfunctioning, check modbus cables and connections."
.format(pin, self))
response = self.__DI[self._gpio_map[pin]]
# Inversion
if self.is_gpio_inverted(pin):
response = not response
# Remote GPIO.
elif self.is_gpio_remote(pin):
remote_gpio = self.parse_remote_gpio(pin)
if not remote_gpio["uart"] in self.__modbus_rtu_clients:
GlobalErrorHandler.log_missing_resource(
"Missing MODBUS-RTU UART{} interface".format(
remote_gpio["uart"]))
return False
read_response = self.self.__modbus_rtu_clients[
remote_gpio["uart"]].read_discrete_inputs(
remote_gpio["io_reg"],
remote_gpio["io_index"] + 1,
unit=remote_gpio["mb_id"])
if not read_response.isError():
response = read_response.bits[remote_gpio["io_index"]]
# Inversion
if self.is_gpio_inverted(pin):
response = not response
else:
GlobalErrorHandler.log_missing_resource(
"Pin does not exists in pin map.")
return response
