########################################################################### # # Copyright (c) 2021-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 dd_defs.py # # @author (last) Zoltan Miskolci # @date (last) 28-Jan-2026 # @author (original) Peter Lucia # @date (original) 22-Jun-2021 # ############################################################################ from enum import unique from aenum import extend_enum from typing import TYPE_CHECKING from .defs_base import Defs_Base from .global_vars import GlobalVariables, test_config_change from ..utils.base import DialinEnum class DD_Defs(Defs_Base): # IDE autocomplete support if TYPE_CHECKING: DDOpModes: DialinEnum DDFaultStates: DialinEnum DDFaultNVDataStates: DialinEnum DDServiceStates: DialinEnum DDInitStates: DialinEnum DDStandbyStates: DialinEnum DDPreGenDialysateStates: DialinEnum DDGenDialysateModeStates: DialinEnum DDPostGenDialysateStates: DialinEnum DDHeatDisinfectStates: DialinEnum DDHeaterCoolingStates: DialinEnum DDROPermeateStates: DialinEnum DDNotLegalStates: DialinEnum DDEventList: DialinEnum DDEventDataTypes: DialinEnum DDConcentratePumpNames:DialinEnum DDConductivitySensorNames:DialinEnum DDDialysatePumpNames:DialinEnum DDHeaterNames:DialinEnum DDLevelSensorNames:DialinEnum DDPistonPumpNames:DialinEnum DDPressureSensorNames:DialinEnum DDTemperatureSensorNames: DialinEnum DDValveNames: DialinEnum DDMonitoredVoltages: DialinEnum DDBalancingChamberStates:DialinEnum DDBalancingChamberSwitchStates:DialinEnum DDBloodLeakStates:DialinEnum DDConcentratePumpAttributes:DialinEnum DDConcentratePumpStates:DialinEnum DDDialysatePumpAttributes:DialinEnum DDDialysatePumpsStates:DialinEnum DDHeaterStartStop:DialinEnum DDHeaterAttributes:DialinEnum DDHeaterExecState:DialinEnum DDPistonPumpAttributes:DialinEnum DDValveStates: DialinEnum _properties = { # Operation / State enums 'DDOpModes': '_create_dd_operation_modes', 'DDFaultStates': '_create_dd_fault_states', 'DDFaultNVDataStates': '_create_dd_fault_nvdata_states', 'DDServiceStates': '_create_dd_service_states', 'DDInitStates': '_create_dd_init_states', 'DDStandbyStates': '_create_dd_standby_states', 'DDPreGenDialysateStates': '_create_dd_pregen_states', 'DDGenDialysateModeStates': '_create_dd_gen_states', 'DDPostGenDialysateStates': '_create_dd_postgen_states', 'DDHeatDisinfectStates': '_create_dd_heat_disinfect_states', 'DDHeaterCoolingStates': '_create_dd_heater_cooling_states', 'DDROPermeateStates': '_create_dd_ro_permeate_states', 'DDNotLegalStates': '_create_dd_not_legal_states', # Event enums 'DDEventList': '_create_dd_event_list', 'DDEventDataTypes': '_create_dd_event_data_types', # Module Names enums 'DDConcentratePumpNames': '_create_dd_concentrate_pump_names', 'DDConductivitySensorNames': '_create_dd_conductivity_sensor_names', 'DDDialysatePumpNames': '_create_dd_dialysate_pump_names', 'DDHeaterNames': '_create_dd_heater_names', 'DDLevelSensorNames': '_create_dd_level_sensor_names', 'DDPistonPumpNames': '_create_dd_piston_pump_names', 'DDPressureSensorNames': '_create_dd_pressure_sensor_names', 'DDTemperatureSensorNames': '_create_dd_temperature_sensor_names', 'DDValveNames': '_create_dd_valve_names', 'DDMonitoredVoltages': '_create_dd_monitored_voltages', # Support enums 'DDBalancingChamberStates': '_create_dd_balancing_chamber_states', 'DDBalancingChamberSwitchStates': '_create_dd_balancing_chamber_switch_states', 'DDBloodLeakStates': '_create_dd_blood_leak_states', 'DDConcentratePumpAttributes': '_create_dd_concentrate_pump_attributes', 'DDConcentratePumpStates': '_create_dd_concentrate_pump_states', 'DDDialysatePumpAttributes': '_create_dd_dialysate_pump_attributes', 'DDDialysatePumpsStates': '_create_dd_dialysate_pump_states', 'DDHeaterStartStop': '_create_dd_heater_start_stop', 'DDHeaterAttributes': '_create_dd_heater_attributes', 'DDHeaterExecState': '_create_dd_heater_exec_states', 'DDPistonPumpAttributes': '_create_dd_piston_pump_attributes', 'DDValveStates': '_create_dd_valve_states', } # ================================================== Enum Creators: Operations ================================================== def _create_dd_operation_modes(self): members = { # Official Name : Accepted strings 'MODE_FAUL': ['fault'], # Fault mode 'MODE_SERV': ['service'], # Service mode 'MODE_INIT': ['initialization'], # Initialization & POST mode 'MODE_STAN': ['standby'], # Standby mode 'MODE_PREG': ['pre-gen dialysate', 'pre-generate dialysate'], # Pre-generate Dialysate Mode 'MODE_GEND': ['generate dialysate'], # Generate Dialysate Mode 'MODE_POSG': ['post-gen dialysate', 'post-generate dialysate'], # Post-generate Dialysate Mode 'MODE_HEAT': ['heat disinfect', 'disinfect', 'heating'], # Heat Disinfect Mode 'MODE_HCOL': ['cooling'], # Cooling Mode 'MODE_ROPS': ['sampling', 'ro sampling', 'ro permeate sampling'], # RO Permeate Sample Mode 'MODE_NLEG': ['not legal'], # Not legal - an illegal mode transition occurred 'NUM_OF_DD_MODES': [], # Number of Modes for the DD } created_enum = unique(DialinEnum('DDOpModes', self.create_members(members))) created_enum._str_list = members created_enum.from_str = classmethod(self.from_str) return created_enum def _create_dd_fault_states(self): members = { # Official Name : Accepted strings 'DD_FAULT_STATE_START': ['fault start'], # DD Fault Start State 'DD_FAULT_DEENERGIZED_STATE': ['fault deenergized', 'deenergized'], # DD Fault De-energized State 'DD_FAULT_ENERGIZED_STATE': ['fault energized', 'energized'], # DD Fault Energized State 'NUM_OF_FP_FAULT_STATES': [], # Number of Fault Mode State } created_enum = unique(DialinEnum('DDFaultStates', self.create_members(members))) created_enum._str_list = members created_enum.from_str = classmethod(self.from_str) return created_enum def _create_dd_fault_nvdata_states(self): members = { # Official Name : Accepted strings 'DD_FAULT_STATE_START': ['start'], # DD fault start state 'DD_FAULT_STATE_RUN_NV_POSTS': ['running'], # DD fault run RTC and NV data management post 'DD_FAULT_STATE_COMPLETE': ['complete', 'done'], # DD fault complete 'NUM_OF_DD_FAULT_NVDATA_STATES': [], # Number of fault mode NV Data management states } created_enum = unique(DialinEnum('DDFaultNVDataStates', self.create_members(members))) created_enum._str_list = members created_enum.from_str = classmethod(self.from_str) return created_enum def _create_dd_service_states(self): members = { # Official Name : Accepted strings 'DD_SERVICE_STATE_START': ['start', 'service start'], # Start service mode state 'NUM_OF_DD_SERVICE_STATES': [], # Number of service mode states } created_enum = unique(DialinEnum('DDServiceStates', self.create_members(members))) created_enum._str_list = members created_enum.from_str = classmethod(self.from_str) return created_enum def _create_dd_init_states(self): members = { # Official Name : Accepted strings 'DD_POST_STATE_START': ['start'], # Post Generate Dialysate Start State 'DD_POST_STATE_FW_COMPATIBILITY': ['fw compatibility'], # Firmware Compatibility State 'DD_POST_STATE_FW_INTEGRITY': ['fw integrity'], # Firmware Integrity State 'DD_POST_STATE_FPGA': ['fpga'], # FPGA State 'DD_POST_STATE_NVDATAMGMT': ['nv data management', 'data management'], # Non-volatile Data Management State 'DD_POST_STATE_TEMPERATURE_SENSORS': ['temperature sensors check'], # Temperature Sensors State 'DD_POST_STATE_PRESSURES': ['pressures check'], # Pressure Sensors State 'DD_POST_STATE_DIALYSATE_PUMPS': ['dialysate pumps check'], # Dialysate Pumps State 'DD_POST_STATE_CONCENTRATE_PUMPS': ['concentrate pumps check'], # Concentrate Pumps State 'DD_POST_STATE_CONDUCTIVITY_SENSORS': ['conductivity sensors check'], # Conductivity Sensors State 'DD_POST_STATE_WATCHDOG': ['watchdog'], # Watchdog State 'DD_POST_STATE_SAFETY_SHUTDOWN': ['safety shutdown'], # Safety Shutdown State 'DD_POST_STATE_COMPLETED': ['completed', 'done'], # Post Generate Dialysate Completed State 'DD_POST_STATE_FAILED': ['failed'], # Post Generate Dialysate Fail State 'NUM_OF_DD_POST_STATES': [], # Number of Post Generate Dialysate States } created_enum = unique(DialinEnum('DDInitStates', self.create_members(members))) created_enum._str_list = members created_enum.from_str = classmethod(self.from_str) return created_enum def _create_dd_standby_states(self): members = { # Official Name : Accepted strings 'DD_STANDBY_MODE_STATE_IDLE': ['idle'], # Idle standby mode state 'DD_STANDBY_MODE_STATE_PAUSE': ['paused'], # Pause state 'NUM_OF_DD_STANDBY_MODE_STATES': [], # Number of standby mode states } created_enum = unique(DialinEnum('DDStandbyStates', self.create_members(members))) created_enum._str_list = members created_enum.from_str = classmethod(self.from_str) return created_enum def _create_dd_pregen_states(self): members = { # Official Name : Accepted strings 'DD_PRE_GEN_DIALYSATE_HYD_CHAMBER_FILL_CHECK': ['fill check', 'hydro chamber fill check'], # DD Pre-Gen Dialysate hyrochamber fill check 'DD_PRE_GEN_WET_SELF_TEST': ['self test', 'wet self test'], # DD Pre-Gen Wet Self Test 'DD_PRE_GEN_DIALYSATE_WAIT_FOR_GEND': ['wait for state transition'], # DD Pre-Gen Dialysate Wait for Gen Dialysate state transition 'NUM_OF_DD_PRE_GEN_DIALYSATE_STATES': [], # Number of Pre-Gen Dialysate mode states } created_enum = unique(DialinEnum('DDPreGenDialysateStates', self.create_members(members))) created_enum._str_list = members created_enum.from_str = classmethod(self.from_str) return created_enum def _create_dd_gen_states(self): members = { # Official Name : Accepted strings 'DD_GEND_STATE_START': ['start'], # Gen dialysate start state 'DD_GEND_DIALYSATE_BYPASS_STATE': ['dialysate delivery bypass', 'bypass'], # Gen dialysate - Bypass dialysate state 'DD_GEND_DIALYSATE_DELIVERY_STATE': ['dialysate delivery'], # Gen dialysate - deliver dialysate state 'DD_GEND_ISOLATED_UF_STATE': ['uf', 'ultrafiltration'], # Gen dialysate - Isolated ultrafiltration state 'DD_GEND_SPENT_CHAMBER_FILL_STATE': ['spent chamber fill'], # Gen dialysate - spent chamber fill state 'DD_GEND_BICARB_CHAMBER_FILL_STATE': ['bicarb chamber fill'], # Gen dialysate - bicarb chamber fill state 'DD_GEND_DIALYSATE_DELIVERY_PAUSE': ['dialysate delivery pause', 'pause'], # Gen dialysate - dialysate delivery pause state 'NUM_OF_DD_GEND_MODE_STATES': [], # Number of gen dialysate states } created_enum = unique(DialinEnum('DDGenDialysateModeStates', self.create_members(members))) created_enum._str_list = members created_enum.from_str = classmethod(self.from_str) return created_enum def _create_dd_postgen_states(self): members = { # Official Name : Accepted strings 'DD_POST_GEN_DIALYSATE_STATE_START': ['start'], # DD Post-Gen Dialysate state start 'DD_POST_GEN_DIALYSATE_STATE_COMPLETE': ['complete', 'done'], # DD Post-Gen Dialysate complete state 'NUM_OF_DD_POST_GEN_DIALYSATE_STATES': [], # Number of Post-Gen Dialysate mode states } created_enum = unique(DialinEnum('DDPostGenDialysateStates', self.create_members(members))) created_enum._str_list = members created_enum.from_str = classmethod(self.from_str) return created_enum def _create_dd_heat_disinfect_states(self): members = { # Official Name : Accepted strings 'DD_HEAT_DISINFECT_STATE_START': ['start'], # Heat disinfect, start mode state 'DD_HEAT_DISINFECT_STATE_COMPLETE': ['done', 'complete'], # Heat disinfect, complete state 'NUM_OF_DD_HEAT_DISINFECT_STATES': [] # Number of heat disinfect mode states } created_enum = unique(DialinEnum('DDHeatDisinfectStates', self.create_members(members))) created_enum._str_list = members created_enum.from_str = classmethod(self.from_str) return created_enum def _create_dd_heater_cooling_states(self): members = { # Official Name : Accepted strings 'NUM_OF_DD_HEAT_COOL_STATES': [], # Number of Heater Cooling states } created_enum = unique(DialinEnum('DDHeaterCoolingStates', self.create_members(members))) created_enum._str_list = members created_enum.from_str = classmethod(self.from_str) return created_enum def _create_dd_ro_permeate_states(self): members = { # Official Name : Accepted strings 'NUM_OF_RO_PERMEATE_STATES': [], # Number of RO Permeate states } created_enum = unique(DialinEnum('DDROPermeateStates', self.create_members(members))) created_enum._str_list = members created_enum.from_str = classmethod(self.from_str) return created_enum def _create_dd_not_legal_states(self): members = { # Official Name : Accepted strings 'NUM_OF_NOT_LEGAL_STATES': [], # Number of Not Legal states } created_enum = unique(DialinEnum('DDNotLegalStates', self.create_members(members))) created_enum._str_list = members created_enum.from_str = classmethod(self.from_str) return created_enum def _create_dd_event_list(self): members = { # Official Name : Accepted strings 'DD_EVENT_STARTUP': ['startup'], # DD startup event 'DD_EVENT_OP_MODE_CHANGE': ['op mode change', 'operation mode change'], # DD Op mode change event 'DD_EVENT_SUB_MODE_CHANGE': ['sub mode change'], # DD Op sub-mode change event 'DD_EVENT_OPERATION_STATUS': ['status', 'operation status'], # DD operation status event 'DD_EVENT_D6_LEVL_CHANGE': ['d6 level change'], # DD floater level change event 'DD_EVENT_D63_LEVL_CHANGE': ['d63 level change'], # DD bicarb level change event 'DD_EVENT_D46_LEVL_CHANGE': ['d46 level change'], # DD spent dialysate air seperation level change event 'DD_EVENT_TD_COMMUNICATION_LOSS': ['td communication loss'], # DD TD communication loss 'DD_EVENT_TEMPERATURE_DRIFT': ['temperature drift'], # DD dialysate temperature drift 'DD_EVENT_BLOOD_LEAK_ZEROING_REQUEST': ['blood leak zeroing request'], # DD blood leak zeroing request 'DD_EVENT_BLOOD_LEAK_ZEROING_REQUIRED': ['blood leak zeroing required'], # DD blood leak zeroing required 'DD_EVENT_BLOOD_LEAK_NUM_OF_SET_POINT_CHECK_FAILURES': ['blood leak check failed'], # DD blood leak number of setpoint check failures 'DD_EVENT_BLOOD_LEAK_SELF_TEST_RESULT': ['blood leak self test'], # DD blood leak self test result 'NUM_OF_DD_EVENT_IDS': [], # Total number of DD events } created_enum = unique(DialinEnum('DDEventList', self.create_members(members))) created_enum._str_list = members created_enum.from_str = classmethod(self.from_str) return created_enum def _create_dd_event_data_types(self): members = { # Official Name : Accepted strings 'EVENT_DATA_TYPE_NONE': ['none'], # No Event Data Type 'EVENT_DATA_TYPE_U32': ['u32'], # Unsigned 32bit Event Data Type 'EVENT_DATA_TYPE_S32': ['s32'], # Signed 32bit Event Data Type 'EVENT_DATA_TYPE_F32': ['f32'], # Float 32bit Event Data Type 'EVENT_DATA_TYPE_BOOL': ['bool', 'boolean'], # Boolean Event Data Type 'NUM_OF_EVENT_DATA_TYPES': [], # Number of Event Data Types } created_enum = unique(DialinEnum('DDEventDataTypes', self.create_members(members))) created_enum._str_list = members created_enum.from_str = classmethod(self.from_str) return created_enum # ================================================== Enum Creators: Names ================================================== def _create_dd_concentrate_pump_names(self): members = { # Official Name : Accepted strings 'D11_CP1_ACID': ['d11', 'acid', 'acid pump'], # Acid Concentrate Pump 'D10_CP2_BICARB': ['d10', 'bicarb', 'bicarb pump'], # Bicarbonate Concentrate Pump 'D76_UF': ['d76', 'uf pump', 'ultrafiltration pump'], # Ultrafiltration Concentrate Pump 'NUM_OF_CONCENTRATE_PUMPS': [], # Number of Concentrate Pumps } created_enum = unique(DialinEnum('DDConcentratePumpNames', self.create_members(members))) created_enum._str_list = members created_enum.from_str = classmethod(self.from_str) return created_enum def _create_dd_conductivity_sensor_names(self): members = { # Official Name : Accepted strings 'D17_COND': ['d17'], # Closed Loop Control of Dosing for D74 Conductivity Sensor 'D27_COND': ['d27'], # Closed Loop Control of Dosing for D29 Conductivity Sensor 'D29_COND': ['d29'], # Water, Bicarbonate, and Acid Collective Conductivity Sensor 'D43_COND': ['d43'], # Self Test Conductivity Sensor (not used for dialysate conductivity) 'D74_COND': ['d74'], # Water and Bicarbonate Collective Conductivity Sensor 'D98_COND': ['d98'], # D98 Conductivity Sensor 'NUM_OF_CONDUCTIVITY_SENSORS': [] # Number of Conductivity Sensors } created_enum = unique(DialinEnum('DDConductivitySensorNames', self.create_members(members))) created_enum._str_list = members created_enum.from_str = classmethod(self.from_str) return created_enum def _create_dd_dialysate_pump_names(self): members = { # Official Name : Accepted strings 'D12_PUMP': ['d12'], # Fresh Dialysate Pump 'D48_PUMP': ['d48'], # Spent Dialysate Pump 'NUM_OF_DIALYSATE_PUMPS': [], # Number of Dialysate Pumps } created_enum = unique(DialinEnum('DDDialysatePumpNames', self.create_members(members))) created_enum._str_list = members created_enum.from_str = classmethod(self.from_str) return created_enum def _create_dd_heater_names(self): members = { # Official Name : Accepted strings 'D5_HEAT': ['d5'], # Primary heater 'D45_HEAT': ['d45'], # Trimmer heater 'NUM_OF_DD_HEATERS': [], # Number of Heaters } created_enum = unique(DialinEnum('DDHeaterNames', self.create_members(members))) created_enum._str_list = members created_enum.from_str = classmethod(self.from_str) return created_enum def _create_dd_level_sensor_names(self): members = { # Official Name : Accepted strings 'D6_LEVEL': ['d6'], # floater switch low, medium and high status 'D63_LEVEL': ['d63'], # bicarb level low or high status 'D46_LEVEL': ['d46'], # Spent dialysate air separation chamber level low or high status 'D98_LEVEL': ['d98'], # D98 Conductivity Level Sensor 'NUM_OF_LEVELS': [], # Number of Level Sensors } created_enum = unique(DialinEnum('DDLevelSensorNames', self.create_members(members))) created_enum._str_list = members created_enum.from_str = classmethod(self.from_str) return created_enum def _create_dd_piston_pump_names(self): members = { # Official Name : Accepted strings 'ACID': ['d11', 'acid', 'acid pump'], # Acid piston pump 'BICARB': ['d10', 'bicarb', 'bicarb pump'], # Bicarbonate piston pump 'UF': ['d76', 'uf pump', 'ultrafiltration pump'], # Ultrafiltration piston pump 'NUM_OF_PISTON_PUMPS': [], # Number of piston pumps } created_enum = unique(DialinEnum('DDPistonPumpNames', self.create_members(members))) created_enum._str_list = members created_enum.from_str = classmethod(self.from_str) return created_enum def _create_dd_pressure_sensor_names(self): members = { # Official Name : Accepted strings 'D9_PRES': ['d9'], # Hydraulics outlet pressure (PHo/Pn) 'D66_PRES': ['d66'], # Dry Bicarb pressure (PDB/PCb) 'D51_PRES': ['d51'], # Spent Dialysate pressure (PDs) 'D18_PRES': ['d18'], # Fresh Dialysate pressure (PDf) 'D41_PRES': ['d41'], # Transmembrane pressure (Ptm) 'D87_PRES': ['d87'], # D87 Pressure Sensor 'NUM_OF_PRESSURE_SENSORS': [], # Number of pressure sensors } created_enum = unique(DialinEnum('DDPressureSensorNames', self.create_members(members))) created_enum._str_list = members created_enum.from_str = classmethod(self.from_str) return created_enum def _create_dd_temperature_sensor_names(self): members = { # Official Name : Accepted strings 'D1_TEMP': ['d1'], # Heat exchanger Inlet temperature sensor 'D78_TEMP': ['d78'], # Heat exchanger Outlet temperature sensor 'D4_TEMP': ['d4'], # Hydraulics primary heater temperature sensor 'D50_TEMP': ['d50'], # Trimmer heater temperature sensor 'D99_TEMP': ['d90'], # D98(D99) Conductivity sensor temperature value 'BRD_TEMP': ['brd', 'board'], # Barometric temperature sensor 'D16_TEMP': ['d16'], # D16(D17) Conductivity sensor temperature value 'D28_TEMP': ['d28'], # D28(D27) Conductivity sensor temperature value 'D30_TEMP': ['d30'], # D30(D29) Conductivity sensor temperature value 'D44_TEMP': ['d44'], # D44(D43) Conductivity sensor temperature value 'D75_TEMP': ['d75'], # D75(D74) Conductivity sensor temperature value 'D4_AVG_TEMP': ['d4 avg', 'd4 average'], # D4 Filtered value 'D50_AVG_TEMP': ['d50 avg', 'd50 average'], # D50 Filtered value 'D99_AVG_TEMP': ['d99 avg', 'd99 average'], # D99 Filtered value 'D28_AVG_TEMP': ['d28 avg', 'd28 average'], # D28 Filtered value 'D30_AVG_TEMP': ['d39 avg', 'd39 average'], # D30 Filtered value 'D9_TEMP': ['d9'], # D9 Pressure sensor temperature value 'D66_TEMP': ['d66'], # D66 Pressure sensor temperature value 'D51_TEMP': ['d51'], # D51 Pressure sensor temperature value 'D18_TEMP': ['d18'], # D18 Pressure sensor temperature value 'D41_TEMP': ['d41'], # D41 Pressure sensor temperature value 'D87_TEMP': ['d87'], # D87 Pressure sensor temperature value 'NUM_OF_TEMP_SENSORS': [], # Number of Temperature Sensors } created_enum = unique(DialinEnum('DDTemperatureSensorNames', self.create_members(members))) created_enum._str_list = members created_enum.from_str = classmethod(self.from_str) # Add aliases extend_enum(created_enum, 'FIRST_PRESSURE_SENSOR', created_enum.D9_TEMP.value) extend_enum(created_enum, 'LAST_PRESSURE_SENSOR', created_enum.D87_TEMP.value if GlobalVariables().HW_BETA_1_9 == True else created_enum.D41_TEMP.value) extend_enum(created_enum, 'FIRST_CONDUCTIVITY_SENSOR', created_enum.D16_TEMP.value) extend_enum(created_enum, 'LAST_CONDUCTIVITY_SENSOR', created_enum.D75_TEMP.value) extend_enum(created_enum, 'FIRST_AVERAGE_SENSOR', created_enum.D4_AVG_TEMP.value) extend_enum(created_enum, 'LAST_AVERAGE_SENSOR', created_enum.D30_AVG_TEMP.value) # Add aliases to be searchable (listed when pressed TAB) created_enum._member_names_.append('FIRST_PRESSURE_SENSOR') created_enum._member_names_.append('LAST_PRESSURE_SENSOR') created_enum._member_names_.append('FIRST_CONDUCTIVITY_SENSOR') created_enum._member_names_.append('LAST_CONDUCTIVITY_SENSOR') created_enum._member_names_.append('FIRST_AVERAGE_SENSOR') created_enum._member_names_.append('FIRST_AVERAGE_SENSOR') return created_enum def _create_dd_valve_names(self): members = { # Official Name : Accepted strings 'D14_VALV': ['d14'], # Valve Hydraulics Outlet (D14) 'D52_VALV': ['d52'], # Valve Thermal Disinfect (D52) 'D8_VALV': ['d8'], # Valve Hydraulics Bypass (D8) 'D54_VALV': ['d54'], # Valve Rinse Port (D54) 'D53_VALV': ['d53'], # Valve Drain (D53) 'D34_VALV': ['d34'], # Valve Dialyzer Bypass (D34) 'D64_VALV': ['d64'], # Valve Purge 1 (D64) 'D31_VALV': ['d31'], # Valve Pressure Test (D31) 'D65_VALV': ['d65'], # Valve DryBcarb Inlet (D65) 'D35_VALV': ['d35'], # Valve Dialyzer Inlet (D35) 'D40_VALV': ['d40'], # Valve Dialyzer Outlet (D40) 'D47_VALV': ['d47'], # Valve Dialysate Out Purge 2 (D47) 'D3_VALV': ['d3'], # Valve Hydraulics Inlet (D3) 'D80_VALV': ['d80'], # Valve Dry Bicarb (D80) 'D81_VALV': ['d81'], # Valve De-scaler (D81) 'D85_VALV': ['d85'], # Valve De-scaler (D85) 'D23_VALV': ['d23'], # Balancing chamber Valve 1 (D23) 'D19_VALV': ['d19'], # Balancing chamber Valve 2 (D19) 'D25_VALV': ['d25'], # Balancing chamber Valve 3 (D25) 'D21_VALV': ['d21'], # Balancing chamber Valve 4 (D21) 'D24_VALV': ['d24'], # Balancing chamber Valve 5 (D24) 'D20_VALV': ['d20'], # Balancing chamber Valve 6 (D20) 'D26_VALV': ['d26'], # Balancing chamber Valve 7 (D26) 'D22_VALV': ['d22'], # Balancing chamber Valve 8 (D22) 'D79_PMP_VALV': ['d79'], # D79 pump mapped to Spare Valve 0 'D83_VALV': ['d83'], # D83 De-scaler Valve mapped to Spare Valve 1 'D91_VALV': ['d91'], # D91 De-scaler Valve mapped to Spare Valve 2 'SPARE3_VALV': ['spare3'], # Spare Valve 3 'SPARE4_VALV': ['spare4'], # Spare Valve 4 'SPARE5_VALV': ['spare5'], # Spare Valve 5 'D100_VALV': ['d100'], # D100 De-scaler Valve mapped to Spare Valve 6 'SPARE7_VALV': ['spare7'], # Spare Valve 7 'NUM_OF_DD_VALVES': [], # Number of Valves for the DD } created_enum = unique(DialinEnum('DDValveNames', self.create_members(members))) created_enum._str_list = members created_enum.from_str = classmethod(self.from_str) return created_enum def _create_dd_monitored_voltages(self): members = { # Official Name : Accepted strings 'MONITORED_LINE_1_2V': ['1.2v'], # Processor voltage (1.2V) 'MONITORED_LINE_3_3V': ['3.3v'], # Logic voltage (3.3V) 'MONITORED_LINE_5V_LOGIC': ['5v'], # Logic voltage (5V) 'MONITORED_LINE_24V_1': ['24v line 1'], # Actuators voltage (24V) 'MONITORED_LINE_24V_2': ['24v line 1'], # Actuators regen voltage (24V) 'MONITORED_LINE_FPGA_VCC_V': ['fpga vcc'], # FPGA Vcc (3V) 'MONITORED_LINE_FPGA_AUX_V': ['fpga aux'], # FPGA Vaux (3V) 'MONITORED_LINE_FPGA_PVN_V': ['fpga pvn'], # FPGA Vpvn (1V) 'NUM_OF_MONITORED_VOLTAGE_LINES': [], # Number of TD operation modes } created_enum = unique(DialinEnum('DDMonitoredVoltages', self.create_members(members))) created_enum._str_list = members created_enum.from_str = classmethod(self.from_str) return created_enum # ================================================== Enum Creators: Support ================================================== def _create_dd_balancing_chamber_states(self): members = { # Official Name : Accepted strings 'BAL_CHAMBER_STATE_START': ['start'], # Initial state of balancing chamber 'BAL_CHAMBER_STATE1_FILL_START': ['state 1 fill start'], # Balancing chamber state 1 fill start state 'BAL_CHAMBER_STATE1_BICARB_ACID_DOSING_CNTRL': ['state 1 bicarb acid dosing control', 'state 1 dosing control'], # Balancing Chamber state 1 Bicarb and acid dosing control state 'BAL_CHAMBER_STATE1_FILL_END': ['state 1 fill end'], # Balancing Chamber state 1 fill end state 'BAL_CHAMBER_STATE2_FILL_START': ['state 2 fill start'], # Balancing chamber state 2 fill start state 'BAL_CHAMBER_STATE2_BICARB_ACID_DOSING_CNTRL': ['state 2 bicarb acid dosing control', 'state 2 dosing control'], # Balancing Chamber state 2 Bicarb and acid dosing control state 'BAL_CHAMBER_STATE2_FILL_END': ['state 2 fill end'], # Balancing Chamber state 2 fill end state 'NUM_OF_BAL_CHAMBER_EXEC_STATES': [], # Number of balancing chamber states } created_enum = unique(DialinEnum('DDBalancingChamberStates', self.create_members(members))) created_enum._str_list = members created_enum.from_str = classmethod(self.from_str) return created_enum def _create_dd_balancing_chamber_switch_states(self): members = { # Official Name : Accepted strings 'BAL_CHAMBER_SW_STATE1': ['state 1'], # Balancing chamber switching state 1 (V2,V5 and V3, V8 open, rest closed) 'BAL_CHAMBER_SW_STATE2': ['state 2'], # Balancing chamber switching state 2 ( V1,V6 and V4, V7 open, rest closed) 'NUM_OF_BAL_CHAMBER_SW': [], # Number of balancing chamber states } created_enum = unique(DialinEnum('DDBalancingChamberSwitchStates', self.create_members(members))) created_enum._str_list = members created_enum.from_str = classmethod(self.from_str) return created_enum def _create_dd_blood_leak_states(self): members = { # Official Name : Accepted strings 'BLOOD_LEAK_WAIT_FOR_POST_STATE': ['wait for post', 'wait'], # 'BLOOD_LEAK_CHECK_SET_POINT_STATE': ['check set point'], # 'BLOOD_LEAK_INIT_STATE': ['init'], # 'BLOOD_LEAK_CHECK_ZERO_AND_SELF_TEST_STATE': ['check zero and self test'], # 'BLOOD_LEAK_VERIFY_INTENSITY_AFTER_ZEROING_STATE': ['verify', 'verify intensity after zeroing'], # 'BLOOD_LEAK_NORMAL_STATE': ['normal'], # 'BLOOD_LEAK_RECOVER_BLOOD_DETECT_STATE': ['recover blood', 'recover blood detect'], # 'NUM_OF_BLOOD_LEAK_STATES': [], # Number of blood leak states } created_enum = unique(DialinEnum('DDBloodLeakStates', self.create_members(members))) created_enum._str_list = members created_enum.from_str = classmethod(self.from_str) return created_enum def _create_dd_concentrate_pump_attributes(self): members = { # Official Name : Accepted strings 'CURRENT_STATE': ['current state'], # Current State Concentrate Pump Attribute 'CURRENT_SET_SPEED': ['current speed'], # Current Set Speed Concentrate Pump Attribute 'MEASURED_SPEED': ['measured speed'], # Measured Speed Concentrate Pump Attribute 'TARGET_SPEED': ['target speed'], # Target Speed Concentrate Pump Attribute 'PULSE_US': ['pulse'], # Hall Sensor Pulse Width (in micro seconds) Concentrate Pump Attribute 'TARGET_REV_COUNT': ['target revolutions count', 'target rev count'], # Target Revolutions Concentrate Pump Attribute 'MEASURED_REV_COUNT': ['measured revolutions count', 'measured rev count'], # Measured Revolutions Concentrate Pump Attribute 'PARKED': ['parked'], # Parked Concentrate Pump Attribute 'PARK_FAULT': ['fault', 'park fault'], # Park Fault Concentrate Pump Attribute 'NUM_OF_D10_D11_CONCENTRATE_PUMP_ATTRIBUTES': [], # Number of Acid (D11) and Bicarbonate (D10) Concentrate Pump Attributes } created_enum = unique(DialinEnum('DDConcentratePumpAttributes', self.create_members(members))) created_enum._str_list = members created_enum.from_str = classmethod(self.from_str) return created_enum def _create_dd_concentrate_pump_states(self): members = { # Official Name : Accepted strings 'CONCENTRATE_PUMP_OFF_STATE': ['off'], # Concentrate Pump Off State 'CONCENTRATE_PUMP_RAMP_TO_TARGET_SPEED_STATE': ['ramp to target speed'], # Ramp to Target Speed Concentrate Pump State 'CONCENTRATE_PUMP_CONTROL_TARGET_SPEED_STATE': ['control target speed'], # Control Target Speed Concentrate Pump State 'NUM_OF_CONCENTRATE_PUMP_STATES': [], # Number of Concentrate Pump States } created_enum = unique(DialinEnum('DDConcentratePumpStates', self.create_members(members))) created_enum._str_list = members created_enum.from_str = classmethod(self.from_str) return created_enum def _create_dd_dialysate_pump_attributes(self): members = { # Official Name : Accepted strings 'TARGET_RPM': ['target rp,'], # Target RPM Dialysate Pump Attribute 'MEASURED_SPEED': ['measured speed'], # Measured Speed Dialysate Pump Attribute 'CURRENT_SPEED': ['current speed'], # Current Speed Dialysate Pump Attribute 'STATE': ['state'], # State to command Dialysate Pump Attribute 'TARGET_PRESSURE': ['target pressure'], # Target Pressure Dialysate Pump Attribute 'MEASURED_PRESSURE': ['measured pressure'], # Measured Pressure Dialysate Pump Attribute 'MEASURED_CURRENT': ['measured pressure'], # Measured Current Dialysate Pump Attribute 'CONTROL': ['control'], # Pump Run/Stop Control Pump Attribute 'DIRECTION_ERROR_COUNT': ['direction error count', 'error count'], # Direction Error Count Dialysate Pump Attribute 'MEASURED_DIRECTION': ['measured direction'], # Measured Direction Dialysate Pump Attribute 'NUM_OF_DIALYSATE_PUMP_ATTRIBUTES': [], # Number of Dialysate Pump Attributes } created_enum = unique(DialinEnum('DDDialysatePumpAttributes', self.create_members(members))) created_enum._str_list = members created_enum.from_str = classmethod(self.from_str) return created_enum def _create_dd_dialysate_pump_states(self): members = { # Official Name : Accepted strings 'DIALYSATE_PUMP_OFF_STATE': ['off'], # Dialysate Pump Off State 'DIALYSATE_PUMP_RAMP_UP_STATE': ['ramp up'], # Dialysate Pump Ramp Up State 'DIALYSATE_PUMP_CONTROL_TO_TARGET_STATE': ['control to target'], # Dialysate Pump Control to Target State 'NUM_OF_DIALYSATE_PUMP_STATES': [], # Number of Dialysate Pump States } created_enum = unique(DialinEnum('DDDialysatePumpsStates', self.create_members(members))) created_enum._str_list = members created_enum.from_str = classmethod(self.from_str) return created_enum def _create_dd_heater_start_stop(self): members = { # Official Name : Accepted strings 'STOP': ['stop'], 'START': ['start'], } created_enum = unique(DialinEnum('DDHeaterStartStop', self.create_members(members))) created_enum._str_list = members created_enum.from_str = classmethod(self.from_str) return created_enum def _create_dd_heater_attributes(self): members = { # Official Name : Accepted strings 'HEAT_DUTY_CYCLE': ['duty cycle'], # Heat Duty Cycle Attribute for Heaters 'HEAT_TARGET_TEMP': ['target temperature', 'target temp'], # Target Temperature Attribute for Heaters 'HEAT_STATE': ['state', 'heat state'], # State to command Attribute for Heaters 'DUTY_CYCLE_COUNT': ['duty cycle count'], # Duty Cycle Count Attribute for Heaters 'PWM_PERIOD': ['pwm', 'pwm period'], # Pulse Width Modulation Attribute for Heaters 'ADJUSTED_TARGET_TEMP': ['adjusted target temperature', 'adj target temp'], # Adjusted Target Temperature Attribute for Heaters 'TARGET_TEMP_TD': ['target temperature td', 'target temp td'], # Target Temperature Attribute for Heaters 'NUM_OF_DD_HEATER_ATTRIBUTES': [], # Number of Heater Attributes } created_enum = unique(DialinEnum('DDHeaterAttributes', self.create_members(members))) created_enum._str_list = members created_enum.from_str = classmethod(self.from_str) return created_enum def _create_dd_heater_exec_states(self): members = { # Official Name : Accepted strings 'HEATER_EXEC_STATE_OFF': ['heater off', 'off'], # Heater Execution Off State 'HEATER_EXEC_STATE_RAMP_TO_TARGET': ['ramp to target'], # Heater Execution Ramp to Target State 'HEATER_EXEC_STATE_CONTROL_TO_TARGET': ['control to target'], # Heater Execution Control to Target State 'HEATER_EXEC_STATE_CONTROL_TO_DISINFECT_TARGET': ['control to disinfect target'], # Heater Execution Control to Disinfection State 'NUM_OF_HEATERS_EXEC_STATE': [], # Number of Heater Execution States } created_enum = unique(DialinEnum('DDHeaterExecState', self.create_members(members))) created_enum._str_list = members created_enum.from_str = classmethod(self.from_str) return created_enum def _create_dd_piston_pump_attributes(self): members = { # Official Name : Accepted strings 'CONTROL_STATE': ['control', 'control state'], # Control State for the Piston Pumps 'SW_COUNTER': ['sw', 'sw counter', 'software counter'], # Software counter attribute for the Piston Pumps 'CYCLE_COUNTER': ['cycle', 'cycle counter'], # Cycle Counter for the Piston Pumps 'NUM_OF_PISTON_PUMP_ATTRIBUTES': [], # Number of Piston Pump Attributes } created_enum = unique(DialinEnum('DDPistonPumpAttributes', self.create_members(members))) created_enum._str_list = members created_enum.from_str = classmethod(self.from_str) return created_enum def _create_dd_valve_states(self): members = { # Official Name : Accepted strings 'VALVE_STATE_CLOSED': ['closed'], # Valve Closed State 'VALVE_STATE_OPEN': ['open'], # Valve Open State 'NUM_OF_VALVE_STATES': [], # Valve Open State } created_enum = unique(DialinEnum('DDValveStates', self.create_members(members))) created_enum._str_list = members created_enum.from_str = classmethod(self.from_str) return created_enum # ================================================== Creates a singleton ================================================== dd_enum_repository = DD_Defs() # Attach listener to update function test_config_change.add_listener(dd_enum_repository.update_enums)