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