########################################################################### # # Copyright (c) 2020-2024 Diality Inc. - All Rights Reserved. # # THIS CODE MAY NOT BE COPIED OR REPRODUCED IN ANY FORM, IN PART OR IN # WHOLE, WITHOUT THE EXPLICIT PERMISSION OF THE COPYRIGHT OWNER. # # @file td_defs.py # # @author (last) Zoltan Miskolci # @date (last) 13-Jan-2026 # @author (original) Peter Lucia # @date (original) 04-Dec-2020 # ############################################################################ from aenum import extend_enum from typing import TYPE_CHECKING from .global_vars import GlobalVariables, test_config_change from ..utils.base import DialinEnum class TD_Defs: # IDE autocomplete support if TYPE_CHECKING: TDOpModes: DialinEnum TDFaultStates: DialinEnum TDServiceStates: DialinEnum TDInitStates: DialinEnum TDStandbyStates: DialinEnum TDTreatmentParamStates: DialinEnum TDPreTreatmentModesStates: DialinEnum TDTreatmentStates: DialinEnum TDPostTreatmentStates: DialinEnum TDNotLegalStates: DialinEnum TDPreTreatmentPrimeStates: DialinEnum TDDialysisStates: DialinEnum TDTreatmentParameters: DialinEnum TDEventList: DialinEnum TDEventDataTypes: DialinEnum TDAirPumpNames:DialinEnum TDAirTrapValveNames:DialinEnum TDAirTrapLevelSensorNames:DialinEnum TDAirBubbleDetectorNames:DialinEnum TDEjectorNames:DialinEnum TDPressureSensorNames:DialinEnum TDTemperatureSensorNames: DialinEnum TDSwitchNames:DialinEnum TDValveNames: DialinEnum TDMonitoredVoltages: DialinEnum TDAirPumpAttributes: DialinEnum TDAirTrapLevelSensorAttributes: DialinEnum TDAirTrapState: DialinEnum TDBloodFlowMotorAttributes: DialinEnum TDAirBubbleDetectorAttributes: DialinEnum TDEjectorAttributes: DialinEnum TDPressureSensorAttributes: DialinEnum TDSwitchStatus: DialinEnum TDValvePositions: DialinEnum TDValveStates: DialinEnum _properties = { # Operation / State enums 'TDOpModes': '_create_td_op_modes', 'TDFaultStates': '_create_td_fault_states', 'TDServiceStates': '_create_td_service_states', 'TDInitStates': '_create_td_init_states', 'TDStandbyStates': '_create_td_standby_states', 'TDTreatmentParamStates': '_create_td_treatment_param_states', 'TDPreTreatmentModesStates': '_create_td_pre_treatment_modes_states', 'TDTreatmentStates': '_create_td_treatment_states', 'TDPostTreatmentStates': '_create_td_post_treatment_states', 'TDNotLegalStates': '_create_td_not_legal_states', 'TDPreTreatmentPrimeStates': '_create_td_pre_treatment_prime_states', 'TDDialysisStates': '_create_td_dialysis_states', 'TDTreatmentParameters': '_create_td_treatment_parameters', # Event enums 'TDEventList': '_create_td_event_list', 'TDEventDataTypes': '_create_td_event_data_types', # Module Names enums 'TDAirPumpNames': '_create_td_air_pump_names', 'TDAirTrapValveNames': '_create_td_air_trap_valve_names', 'TDAirTrapLevelSensorNames': '_create_td_air_trap_level_sensor_names', 'TDAirBubbleDetectorNames': '_create_td_air_bubble_detector_names', 'TDEjectorNames': '_create_td_ejector_names', 'TDPressureSensorNames': '_create_td_pressure_sensor_names', 'TDTemperatureSensorNames': '_create_td_temperature_sensor_names', 'TDSwitchNames': '_create_td_switch_names', 'TDValveNames': '_create_td_valve_names', 'TDMonitoredVoltages': '_create_td_monitored_voltages', # Support enums 'TDAirPumpAttributes': '_create_td_air_pump_attributes', 'TDAirTrapLevelSensorAttributes': '_create_td_air_trap_level_sensor_attributes', 'TDAirTrapState': '_create_td_air_trap_state', 'TDBloodFlowMotorAttributes': '_create_td_blood_flow_motor_attributes', 'TDAirBubbleDetectorAttributes': '_create_td_air_bubble_detector_attributes', 'TDEjectorAttributes': '_create_td_ejector_attributes', 'TDPressureSensorAttributes': '_create_td_pressure_sensor_attributes', 'TDSwitchStatus': '_create_td_switch_status', 'TDValvePositions': '_create_td_valve_positions', 'TDValveStates': '_create_td_valve_states', } def __init__(self): self.update_enums() def __getattr__(self, name) -> DialinEnum: if name in self._properties: enum = getattr(self, self._properties[name])() setattr(self, name, enum) return enum raise AttributeError(name) def update_enums(self) -> None: for prop in self._properties: self.__dict__.pop(prop, None) self.__getattr__(prop) # ================================================== Enum Creators: Operations ================================================== def _create_td_op_modes(self): members = { 'MODE_FAUL': 0, # Fault mode 'MODE_SERV': 1, # Service mode 'MODE_INIT': 2, # Initialization & POST mode 'MODE_STAN': 3, # Standby mode 'MODE_TPAR': 4, # Treatment Parameters mode 'MODE_PRET': 5, # Pre-Treatment mode 'MODE_TREA': 6, # Treatment mode 'MODE_POST': 7, # Post-Treatment mode 'MODE_NLEG': 8, # Not legal - an illegal mode transition occurred 'NUM_OF_MODES': 9, # Number of TD operation modes } return DialinEnum('TDOpModes', members) def _create_td_fault_states(self): members = { 'TD_FAULT_ENERGIZED_STATE': 0, # TD fault mode energized state 'TD_FAULT_DEENERGIZED_STATE': 1, # TD fault mode deenergized state 'NUM_OF_TD_FAULT_STATES': 2, # Number of fault mode states } return DialinEnum('TDFaultStates', members) def _create_td_service_states(self): members = { 'TD_SERVICE_STATE_START': 0, # Start service mode state 'NUM_OF_TD_SERVICE_STATES': 1, # Number of service mode states } return DialinEnum('TDServiceStates', members) def _create_td_init_states(self): members = { 'POST_STATE_START': 0, # Start initialize & POST mode state 'POST_STATE_FW_INTEGRITY': 1, # Run firmware integrity test state 'POST_STATE_NVDATAMGMT': 2, # Run NV Data Mgmt. test state 'POST_STATE_WATCHDOG': 3, # Run watchdog test state 'POST_STATE_SAFETY_SHUTDOWN': 4, # Run safety shutdown test state 'POST_STATE_BLOOD_FLOW': 5, # Run blood flow test state 'POST_STATE_VALVES': 6, # Run valves test state 'POST_STATE_SYRINGE_PUMP': 7, # Run syringe pump test state 'POST_STATE_PRES_OCCL': 8, # Run pressure occlusion state 'POST_STATE_ALARM_AUDIO': 9, # Run alarm audio test state 'POST_STATE_ALARM_LAMP': 10, # Run alarm lamp test state 'POST_STATE_TEMPERATURES': 11, # Run temperatures POST state 'POST_STATE_FANS': 12, # Run fans POST state 'POST_STATE_STUCK_BUTTON': 13, # Run stuck button test state 'POST_STATE_UI_POST': 14, # Check whether UI passed its POST tests 'POST_STATE_FW_COMPATIBILITY': 15, # Run firmware compatibility test state 'POST_STATE_FPGA': 16, # Run FPGA test state 'POST_STATE_COMPLETED': 17, # POST self-tests completed state 'POST_STATE_FAILED': 18, # POST self-tests failed state 'NUM_OF_POST_STATES': 19, # Number of initialize & POST mode states } return DialinEnum('TDInitStates', members) def _create_td_standby_states(self): members = { 'STANDBY_START_STATE': 0, # Start standby (home actuators). 'STANDBY_WAIT_FOR_TREATMENT_STATE': 1, # Wait for treatment. 'STANDBY_WAIT_FOR_DISINFECT_STATE': 2, # Wait for UI to send disinfect option. 'STANDBY_WAIT_FOR_DG_CLEANING_MODE_CMD_RESPONSE_STATE': 3, # Wait for DG cleaning mode command response state. 'STANDBY_WAIT_FOR_DG_CLEANING_MODE_TO_START_STATE': 4, # Wait for DG cleaning mode to start state. 'STANDBY_CLEANING_MODE_IN_PROGRESS_STATE': 5, # Cleaning mode in progress state. 'NUM_OF_STANDBY_STATES': 6, # Number of standby states (sub-modes). } return DialinEnum('TDStandbyStates', members) def _create_td_treatment_param_states(self): members = { 'TD_TREATMENT_PARAMS_MODE_STATE_WAIT_4_UI_2_SEND': 0, # Wait for UI to send treatment params mode state 'TD_TREATMENT_PARAMS_MODE_STATE_WAIT_4_UI_2_CONFIRM': 1, # Wait for UI to confirm treatment params mode state 'NUM_OF_TD_TREATMENT_PARAMS_MODE_STATES': 2, # Number of treatment params mode states } return DialinEnum('TDTreatmentParamStates', members) def _create_td_pre_treatment_modes_states(self): members = { 'TD_PRE_TREATMENT_WATER_SAMPLE_STATE': 0, # Water sample state 'TD_PRE_TREATMENT_SELF_TEST_CONSUMABLE_STATE': 1, # Consumable self-tests state 'TD_PRE_TREATMENT_SELF_TEST_NO_CART_STATE': 2, # No cartridge self-tests state 'TD_PRE_TREATMENT_CART_INSTALL_STATE': 3, # Consumable and cartridge installation state 'TD_PRE_TREATMENT_SELF_TEST_DRY_STATE': 4, # Self-tests when the cartridge is dry state 'TD_PRE_TREATMENT_PRIME_STATE': 5, # Prime blood and dialysate circuits and run wet self-tests state 'TD_PRE_TREATMENT_RECIRCULATE_STATE': 6, # Re-circulate blood and dialysate circuits state 'TD_PRE_TREATMENT_PATIENT_CONNECTION_STATE': 7, # Patient connection state 'NUM_OF_TD_PRE_TREATMENT_STATES': 8, # Number of pre-treatment mode states } return DialinEnum('TDPreTreatmentModesStates', members) def _create_td_treatment_states(self): members = { 'TREATMENT_START_STATE': 0, # Start treatment - initialize treatment and go to blood prime state 'TREATMENT_BLOOD_PRIME_STATE': 1, # Prime blood-side of dialyzer with gradual ramp for 1 min. while dialyzer is bypassed. No dialysis or UF taking place. No treatment time. 'TREATMENT_DIALYSIS_STATE': 2, # Perform dialysis. Deliver UF as prescribed. 'TREATMENT_PAUSED_STATE': 3, # Treatment paused. All pumps off. Dializer bypassed 'TREATMENT_RINSEBACK_STATE': 4, # Perform rinseback with saline. Dialyzer bypassed. Dialysate recirculating 'TREATMENT_RECIRC_STATE': 5, # Recirculate saline and dialysate while patient disconnected. Blood lines open and shunted. Dialyzer is bypassed 'TREATMENT_END_STATE': 6, # Dialysis has ended. Blood pump slowed. Dialyzer is bypassed. Dialysate is recirculated. User can rinseback 'TREATMENT_ISO_UF_STATE': 7, # Isolated ultrafiltration. No dialysate flow. Ultrafiltration only. 'TREATMENT_SALINE_BOLUS_STATE': 8, # Deliver a saline bolus. Blood pump draws from saline bag. Dialyzer bypassed. 'TREATMENT_DIALYSATE_PAUSED_STATE': 9, # No dialysate flow. Dialyzer bypassed. 'NUM_OF_TREATMENT_STATES': 10, # Number of treatment states (sub-modes) } return DialinEnum('TDTreatmentStates', members) def _create_td_post_treatment_states(self): members = { 'TD_POST_TREATMENT_DRAIN_RESERVOIRS_STATE': 0, # Drain reservoirs state 'TD_POST_TREATMENT_PATIENT_DISCONNECTION_STATE': 1, # Patient disconnection state 'TD_POST_TREATMENT_DISPOSABLE_REMOVAL_STATE': 2, # Disposable removal state 'TD_POST_TREATMENT_VERIFY_STATE': 3, # Verify cartridge removed, syringe removed, and reservoirs drained state 'NUM_OF_TD_POST_TREATMENT_STATES': 4, # Number of post-treatment mode states } return DialinEnum('TDPostTreatmentStates', members) def _create_td_not_legal_states(self): members = { 'NUM_OF_NOT_LEGAL_STATES': 0, # Number of Not Legal states } return DialinEnum('TDNotLegalStates', members) def _create_td_event_list(self): members = { 'TD_EVENT_STARTUP': 0, # TD startup event 'TD_EVENT_OP_MODE_CHANGE': 1, # TD Op mode change event 'TD_EVENT_SUB_MODE_CHANGE': 2, # TD Op sub-mode change event 'TD_EVENT_DRY_SELF_TEST_CARTRIDGE_RESULT': 3, # TD dry self test cartridge result 'TD_EVENT_DRY_SELF_TEST_PRESSURE_RESULT': 4, # TD dry self test pressure result 'TD_EVENT_WET_SELF_TEST_DISPLACEMENT_RESULT': 5, # TD wet self test displacement result 'TD_EVENT_CPU_RAM_ERROR_STATUS': 6, # TD CPU RAM error status 'TD_EVENT_CAL_RECORD_UPDATE': 7, # TD new calibration record updated 'TD_EVENT_SYSTEM_RECORD_UPDATE': 8, # TD new system record has been updated 'TD_EVENT_SERVICE_UPDATE': 9, # TD new service record has been updated 'TD_EVENT_USAGE_INFO_UPDATE': 10, # TD new usage information has been updated 'TD_EVENT_SW_CONFIG_UPDATE': 11, # TD new software configuration has been updated 'TD_EVENT_BUTTON': 12, # TD button pressed/released 'TD_EVENT_SAFETY_LINE': 13, # TD safety line pulled/released 'TD_EVENT_SUB_STATE_CHANGE': 14, # TD Op sub-state change event 'TD_EVENT_RSRVR_UF_RATE': 15, # TD ultrafiltration measured and expected rates 'TD_EVENT_OPERATION_STATUS': 16, # TD operation status event. 'TD_EVENT_AIR_TRAP_FILL': 17, # TD initiated an air trap fill (opened VBT briefly). 'TD_EVENT_AIR_TRAP_LOWER': 18, # TD started/stopped an air trap lower level operation 'TD_EVENT_AIR_PUMP_ON_OFF': 19, # TD turned air pump on or off. 'TD_EVENT_DRY_SELF_TEST_PRESSURE_DECAY_WAIT_PERIOD': 20, # TD dry self test pressure decay wait period 'TD_EVENT_INSTIT_RECORD_UPDATE': 21, # TD new institutional record has been updated. 'TD_EVENT_VALVE_POS_CHANGE': 22, # TD pinch valve position change 'TD_EVENT_VALVE_HOMED_POS_SETTING': 23, # TD pinch valve homed encoder positions for A/B/C 'NUM_OF_EVENT_IDS': 24, # Total number of TD events } return DialinEnum('TDEventList', members) def _create_td_event_data_types(self): members = { 'EVENT_DATA_TYPE_NONE': 0, # No Event Data Type 'EVENT_DATA_TYPE_U32': 1, # Unsigned 32bit Event Data Type 'EVENT_DATA_TYPE_S32': 2, # Signed 32bit Event Data Type 'EVENT_DATA_TYPE_F32': 3, # Float 32bit Event Data Type 'EVENT_DATA_TYPE_BOOL': 4, # Boolean Event Data Type 'NUM_OF_EVENT_DATA_TYPES': 5, # Number of Event Data Types } return DialinEnum('TDEventDataTypes', members) # ================================================== Enum Creators: Operations Sub-Modes ================================================== def _create_td_pre_treatment_prime_states(self): members = { 'TD_PRIME_WAIT_FOR_USER_START_STATE': 0, # Wait for user to start prime state 'TD_PRIME_SALINE_SETUP_STATE': 1, # Saline setup state 'TD_PRIME_SALINE_PURGE_AIR_STATE': 2, # Saline purge air state 'TD_PRIME_SALINE_CIRC_BLOOD_CIRCUIT_STATE': 3, # Circulate blood circuit state 'TD_PRIME_RESERVOIR_ONE_FILL_COMPLETE_STATE': 4, # Wait for reservoir 1 fill complete 'TD_PRIME_DIALYSATE_DIALYZER_STATE': 5, # Dialysate dialyzer fluid path state 'TD_PRIME_SALINE_DIALYZER_SETUP_STATE': 6, # Saline dialyzer setup state 'TD_PRIME_SALINE_DIALYZER_STATE': 7, # Saline dialyzer fluid path state 'TD_PRIME_RESERVOIR_TWO_FILL_COMPLETE_STATE': 8, # Wait for reservoir 2 fill complete 'TD_PRIME_DIALYSATE_BYPASS_STATE': 9, # Dialysate bypass fluid path state 'TD_PRIME_WET_SELF_TESTS_STATE': 10, # Perform wet self-tests after priming complete 'TD_PRIME_PAUSE': 11, # Prime pause state, waits to be resumed 'TD_PRIME_COMPLETE': 12, # Prime complete state 'NUM_OF_TD_PRIME_STATES': 13, # Number of prime sub-mode states } return DialinEnum('TDPreTreatmentPrimeStates', members) def _create_td_dialysis_states(self): members = { 'DIALYSIS_UF_STATE': 0, # Ultrafiltration state of the dialysis sub-mode state machine 'DIALYSIS_UF_PAUSED_STATE': 1, # Ultrafiltration Paused state of the dialysis sub-mode state machine 'NUM_OF_DIALYSIS_STATES': 2, # Number of dialysis sub-mode states } return DialinEnum('TDDialysisStates', members) def _create_td_treatment_parameters(self): members = { 'TREATMENT_PARAM_BLOOD_FLOW': 0, # Blood flow rate (in mL/min) 'TREATMENT_PARAM_DIALYSATE_FLOW': 1, # Dialysate flow rate (in mL/min) 'TREATMENT_PARAM_TREATMENT_DURATION': 2, # Treatment duration (in minutes) 'TREATMENT_PARAM_SALINE_BOLUS_VOLUME': 3, # Saline bolus volume (in mL) 'TREATMENT_PARAM_HEPARIN_STOP_TIME': 4, # Heparin stop time (in minutes) 'TREATMENT_PARAM_HEPARIN_TYPE': 5, # Heparin type (enum) 'TREATMENT_PARAM_ACID_CONCENTRATE': 6, # Acid concentrate type (enum) 'TREATMENT_PARAM_BICARB_CONCENTRATE': 7, # Bicarbonate concentrate type (enum) 'TREATMENT_PARAM_DIALYZER_TYPE': 8, # Dialysate type (enum) 'TREATMENT_PARAM_BP_MEAS_INTERVAL': 9, # Blood pressure measurement interval (in minutes) 'TREATMENT_PARAM_RINSEBACK_FLOW_RATE': 10, # Rinseback flow rate (in mL/min) 'TREATMENT_PARAM_RINSEBACK_VOLUME': 11, # Rinseback volume (in mL) 'TREATMENT_PARAM_ART_PRES_LIMIT_WINDOW': 12, # Arterial pressure alarm limit window (in mmHg) 'TREATMENT_PARAM_VEN_PRES_LIMIT_WINDOW': 13, # Venous pressure alarm limit window (in mmHg) 'TREATMENT_PARAM_VEN_PRES_LIMIT_ASYMMETRIC': 14, # Venous pressure alarm limit asymmetric (in mmHg) 'TREATMENT_PARAM_TMP_PRES_LIMIT_WINDOW': 15, # TMP alarm limit window (in mmHg) 'TREATMENT_PARAM_DIALYSATE_TEMPERATURE': 16, # Dialysate temperature (in degC) 'TREATMENT_PARAM_HEPARIN_DISPENSE_RATE': 17, # Heparin dispense rate (in mL/hr) 'TREATMENT_PARAM_HEPARIN_BOLUS_VOLUME': 18, # Heparin bolus volume (in mL) 'TREATMENT_PARAM_UF_VOLUME': 19, # Ultrafiltration volume (in liters) - provided separately by UI 'NUM_OF_TREATMENT_PARAMS': 20, # Total number of treatment parameters } return DialinEnum('TDTreatmentParameters', members) # ================================================== Enum Creators: Names ================================================== def _create_td_air_pump_names(self): members = { 'H12_AIR_PUMP': 0, # TD Air Pump 'NUM_OF_AIR_PUMPS': 1, # Number of TD Air pumps } return DialinEnum('TDAirPumpNames', members) def _create_td_air_trap_valve_names(self): members = { 'H13_VALV': 0, # Air trap intake valve 'H20_VALV': 1, # Air trap outlet valve 'NUM_OF_AIR_TRAP_VALVES': 2, # Number of Air Trap Valves } return DialinEnum('TDAirTrapValveNames', members) def _create_td_air_trap_level_sensor_names(self): members = { 'H17_LEVEL': 0, # Lower Level Sensor 'H16_LEVEL': 1, # Upper Level Sensor 'NUM_OF_AIR_TRAP_LEVEL_SENSORS': 2, # Number of TD Air Trap Level Sensors } return DialinEnum('TDAirTrapLevelSensorNames', members) def _create_td_air_bubble_detector_names(self): members = { 'H18_ADV': 0, # H18 Air Bubble Detector Venous 'NUM_OF_AIR_BUBBLE_DETECTORS': 1, # Number of Air Bubble Detectors } return DialinEnum('TDAirBubbleDetectorNames', members) def _create_td_ejector_names(self): members = { 'H5_MOTOR': 0, # TD Ejector Motor 'NUM_OF_EJECTOR_MOTORS': 1, # Number of Ejector Motors } return DialinEnum('TDEjectorNames', members) def _create_td_pressure_sensor_names(self): members = { 'H2_PRES': 0, # Arterial Pressure Sensor 'H14_PRES': 1, # Venous Pressure Sensor 'H23_PRES': 2, # Barometric Pressure Sensor 'NUM_OF_PRESSURE_SENSORS': 3, # Number of Pressure Sensors } return DialinEnum('TDPressureSensorNames', members) def _create_td_temperature_sensor_names(self): members = { 'H23_TEMP': 0, # Barometric temperature Sensor 'NUM_OF_TEMPERATURE_SENSORS': 1, # Number of temperature Sensors } return DialinEnum('TDTemperatureSensorNames', members) def _create_td_switch_names(self): members = { 'H9_FRONT_DOOR': 0, # Front Door Switch for TD 'NUM_OF_DOORS_AND_SWITCHES': 1, # Number of Doors and Switches } return DialinEnum('TDSwitchNames', members) def _create_td_valve_names(self): members = { 'H1_VALV': 0, # H1 Valve for TD 'H19_VALV': 1, # H19 Valve for TD 'NUM_OF_TD_VALVES': 2, # Number of Valves for the TD } return DialinEnum('TDValveNames', members) def _create_td_monitored_voltages(self): members = { 'MONITORED_LINE_1_2V': 0, # Processor voltage (1.2V) 'MONITORED_LINE_3_3V': 1, # Logic voltage (3.3V) 'MONITORED_LINE_5V_LOGIC': 2, # Logic voltage (5V) 'MONITORED_LINE_5V_SENSORS': 3, # Sensors voltage (5V) 'MONITORED_LINE_24V': 4, # Actuators voltage (24V) 'MONITORED_LINE_24V_REGEN': 5, # Actuators regen voltage (24V) 'MONITORED_LINE_FPGA_REF_V': 6, # FPGA ADC reference voltage (1V) 'MONITORED_LINE_PBA_REF_V': 7, # PBA ADC reference voltage (3V) 'MONITORED_LINE_FPGA_VCC_V': 8, # FPGA Vcc (3V) 'MONITORED_LINE_FPGA_AUX_V': 9, # FPGA Vaux (3V) 'MONITORED_LINE_FPGA_PVN_V': 10, # FPGA Vpvn (1V) 'NUM_OF_MONITORED_VOLTAGE_LINES': 11, # Number of TD operation modes } return DialinEnum('TDMonitoredVoltages', members) # ================================================== Enum Creators: Support ================================================== def _create_td_air_pump_attributes(self): members = { 'STATE': 0, # TD Air Pump State to command attribute 'POWER': 1, # TD Air Pump Power attribute 'NUM_OF_AIR_PUMP_ATTRIBUTES': 2, # Number of Air Pump attributes } return DialinEnum('TDAirPumpAttributes', members) def _create_td_air_trap_level_sensor_attributes(self): members = { 'LEVEL': 0, # Level attribute for Air Trap Level Sensor 'RAW': 1, # Raw reading attribute for Air Trap Level Sensor 'NUM_OF_AIR_TRAP_LEVEL_SENSOR_ATTRIBUTES': 2, # Number of Air Trap Level Sensor attributes } return DialinEnum('TDAirTrapLevelSensorAttributes', members) def _create_td_air_trap_state(self): members = { 'STATE_CLOSED': 0, # Closed state for Air Trap 'STATE_OPEN': 1, # Open state for Air Trap } return DialinEnum('TDAirTrapState', members) def _create_td_blood_flow_motor_attributes(self): members = { 'SET_BLOOD_FLOW_RATE': 0, # Set Blood Flow Rate for Blood Flow Motor 'MEASURED_BLOOD_FLOW_RATE': 1, # Measured Blood Flow Rate for Blood Flow Motor 'MEASURED_BLOOD_PUMP_ROTOR_SPEED': 2, # Measured Bloop Pump Rotor Speed for Blood Flow Motor 'MEASURED_BLOOD_PUMP_SPEED': 3, # Measured Blood Pump Speed for Blood Flow Motor 'MEASURED_BLOOD_PUMP_TORQUE': 4, # Measured Blood Pump torque 'SET_RPM': 5, # Set Revolutions per minute for Blood Flow Motor 'ROTOR_COUNT': 6, # Rotor Count for Blood Flow Motor 'PRES_BLOOD_FLOW_RATE': 7, # Pressure Blood Flow Rate for Blood Flow Motor 'ROTOR_HALL_STATE': 8, # Rotor Hall State for Blood Flow Motor 'NUM_OF_BLOOD_FLOW_MOTOR_ATTRIBUTES': 9, # Number of Blood Flow Motor Attributes } return DialinEnum('TDBloodFlowMotorAttributes', members) def _create_td_air_bubble_detector_attributes(self): members = { 'STATUS': 0, # Status of the Air Bubble Detector 'STATE': 1, # State of the Air Bubble Detector 'NUM_OF_AIR_BUBBLE_DETECTOR_ATTRIBUTES': 2, # Number of Air Bubble Detector Attributes } return DialinEnum('TDAirBubbleDetectorAttributes', members) def _create_td_ejector_attributes(self): members = { 'STATE': 0, # Ejector State to command 'SET_SPEED': 1, # Ejector Set Speed 'OPT_SNSR_RETRACT': 2, # Ejector optical sensor retract 'OPT_SNSR_ENGAGE': 3, # Ejector optical sensor engage 'NUM_OF_EJECTOR_ATTRIBUTES': 4, # Number of Ejector Attributes } return DialinEnum('TDEjectorAttributes', members) def _create_td_pressure_sensor_attributes(self): members = { 'PRES': 0, # Pressure attribute of pressure sensor 'LONG_FILTERED_PRESSURE': 1, # Long Filtered Pressure attribute of pressure sensor 'PRES_LIMIT_MIN': 2, # Pressure Minimum Limit attribute of pressure sensor 'PRES_LIMIT_MAX': 3, # Pressure Maximum Limit attribute of pressure sensor 'NUM_OF_PRESSURE_ATTRIBUTES': 4, # Number of Pressure Sensor Attributes } return DialinEnum('TDPressureSensorAttributes', members) def _create_td_switch_status(self): members = { 'CLOSED': 0, # Closed State of the TD Switch 'OPEN': 1, # Open State of the TD Switch } return DialinEnum('TDSwitchStatus', members) def _create_td_valve_positions(self): members = { 'VALVE_POSITION_NOT_IN_POSITION': 0, # Valve not in Position 'VALVE_POSITION_A_INSERT_EJECT': 1, # Insert/Eject Valve Position 'VALVE_POSITION_B_OPEN': 2, # Open Valve Position 'VALVE_POSITION_C_CLOSE': 3, # Closed Valve Position 'VALVE_POSITION_C_PARTIAL_CLOSE': 4, # Partial Close Valve Position } return DialinEnum('TDValvePositions', members) def _create_td_valve_states(self): members = { 'VALVE_STATE_WAIT_FOR_POST': 0, # Waiting for POST Valve State 'VALVE_STATE_RESET_VALVE': 1, # Valve state reset valve. 'VALVE_STATE_RESET_ENCODER': 2, # Valve state reset encoder. 'VALVE_STATE_ENABLE_VALVE': 3, # Valve state enable valve. 'VALVE_STATE_HOMING_NOT_STARTED': 4, # Valve state homing not started. 'VALVE_STATE_HOMING_FIND_ENERGIZED_EDGE': 5, # Valve state homing find energized edge. 'VALVE_STATE_HOMING_FIND_DEENERGIZED_EDGE': 6, # Valve state homing find. 'VALVE_STATE_IDLE': 7, # Idle Valve State. 'VALVE_STATE_IN_TRANSITION': 8, # Valve state in transition. } return DialinEnum('TDValveStates', members) # ================================================== Creates a singleton ================================================== td_enum_repository = TD_Defs() # Attach listener to update function test_config_change.add_listener(td_enum_repository.update_enums)