Index: leahi_dialin/common/dd_defs.py =================================================================== diff -u -r5f16af73fb80a76c6dc767661f11a8f3508770a1 -r27d9de42c0111c7f369cc335889fe6b988d09cc8 --- leahi_dialin/common/dd_defs.py (.../dd_defs.py) (revision 5f16af73fb80a76c6dc767661f11a8f3508770a1) +++ leahi_dialin/common/dd_defs.py (.../dd_defs.py) (revision 27d9de42c0111c7f369cc335889fe6b988d09cc8) @@ -319,47 +319,47 @@ # ================================================== Enum Creators: Events ================================================== @unique class DDEventList(DialinEnum): - DD_EVENT_STARTUP = 0 # DD startup event - DD_EVENT_OP_MODE_CHANGE = 1 # DD Op mode change event - DD_EVENT_SUB_MODE_CHANGE = 2 # DD Op sub-mode change event - DD_EVENT_OPERATION_STATUS = 3 # DD operation status event - DD_EVENT_D6_LEVL_CHANGE = 4 # DD floater level change event - DD_EVENT_D63_LEVL_CHANGE = 5 # DD bicarb upper level change event - DD_EVENT_D98_LEVL_CHANGE = 6 # DD bicarb lower level change event - DD_EVENT_D46_LEVL_CHANGE = 7 # DD spent dialysate air seperation level change event - DD_EVENT_TD_COMMUNICATION_LOSS = 8 # DD TD communication loss - DD_EVENT_TEMPERATURE_DRIFT = 9 # DD dialysate temperature drift - DD_EVENT_BLOOD_LEAK_ZEROING_REQUEST = 10 # DD blood leak zeroing request - DD_EVENT_BLOOD_LEAK_ZEROING_REQUIRED = 11 # DD blood leak zeroing required - DD_EVENT_BLOOD_LEAK_NUM_OF_SET_POINT_CHECK_FAILURES = 12 # DD blood leak number of setpoint check failures - DD_EVENT_CPU_RAM_ERROR_STATUS = 13 # DD CPU RAM error - DD_EVENT_BLOOD_LEAK_SELF_TEST_RESULT = 14 # DD blood leak self test result - DD_EVENT_BC_SWITCH_ONLY_MODE_CHANGE = 15 # DD Balancing Chamber Switching Only status event - DD_EVENT_BC_FILL_STATE_CHANGE = 16 # Balancing chamber state switch event - DD_EVENT_HEATER_STATE_CHANGE = 17 # DD heater state change event - DD_EVENT_DRY_BICART_STATE_CHANGE = 18 # DD Dry Bicart State change event - NUM_OF_DD_EVENT_IDS = 19 # Total number of DD events + STARTUP = 0 # DD startup event + OP_MODE_CHANGE = 1 # DD Op mode change event + SUB_MODE_CHANGE = 2 # DD Op sub-mode change event + OPERATION_STATUS = 3 # DD operation status event + D6_LEVL_CHANGE = 4 # DD floater level change event + D63_LEVL_CHANGE = 5 # DD bicarb upper level change event + D98_LEVL_CHANGE = 6 # DD bicarb lower level change event + D46_LEVL_CHANGE = 7 # DD spent dialysate air seperation level change event + TD_COMMUNICATION_LOSS = 8 # DD TD communication loss + TEMPERATURE_DRIFT = 9 # DD dialysate temperature drift + BLOOD_LEAK_ZEROING_REQUEST = 10 # DD blood leak zeroing request + BLOOD_LEAK_ZEROING_REQUIRED = 11 # DD blood leak zeroing required + BLOOD_LEAK_NUM_OF_SET_POINT_CHECK_FAILURES = 12 # DD blood leak number of setpoint check failures + CPU_RAM_ERROR_STATUS = 13 # DD CPU RAM error + BLOOD_LEAK_SELF_TEST_RESULT = 14 # DD blood leak self test result + BC_SWITCH_ONLY_MODE_CHANGE = 15 # DD Balancing Chamber Switching Only status event + BC_FILL_STATE_CHANGE = 16 # Balancing chamber state switch event + HEATER_STATE_CHANGE = 17 # DD heater state change event + DRY_BICART_STATE_CHANGE = 18 # DD Dry Bicart State change event + NUM_OF_DD_EVENT_IDS = 19 # Total number of DD events DDEventList._str_list = { # Official Name : Accepted strings - 'DD_EVENT_STARTUP': ['startup'], - 'DD_EVENT_OP_MODE_CHANGE': ['op mode change', 'operation mode change'], - 'DD_EVENT_SUB_MODE_CHANGE': ['sub mode change'], - 'DD_EVENT_OPERATION_STATUS': ['status', 'operation status'], - 'DD_EVENT_D6_LEVL_CHANGE': ['d6 level change'], - 'DD_EVENT_D63_LEVL_CHANGE': ['d63 level change'], - 'DD_EVENT_D46_LEVL_CHANGE': ['d46 level change'], - 'DD_EVENT_TD_COMMUNICATION_LOSS': ['td communication loss'], - 'DD_EVENT_TEMPERATURE_DRIFT': ['temperature drift'], - 'DD_EVENT_BLOOD_LEAK_ZEROING_REQUEST': ['blood leak zeroing request'], - 'DD_EVENT_BLOOD_LEAK_ZEROING_REQUIRED': ['blood leak zeroing required'], - 'DD_EVENT_BLOOD_LEAK_NUM_OF_SET_POINT_CHECK_FAILURES': ['blood leak check failed'], - 'DD_EVENT_BLOOD_LEAK_SELF_TEST_RESULT': ['blood leak self test'], - 'DD_EVENT_CPU_RAM_ERROR_STATUS': ['cpu ram error status', 'cpu error status', 'ram error status', 'memory error status'], - 'DD_EVENT_BC_SWITCH_ONLY_MODE_CHANGE': ['bc switch only change'], - 'DD_EVENT_BC_FILL_STATE_CHANGE': ['bc state change'], - 'DD_EVENT_HEATER_STATE_CHANGE': ['heater state change'], - 'DD_EVENT_DRY_BICART_STATE_CHANGE': ['dry bicart state change'], + 'STARTUP': ['startup'], + 'OP_MODE_CHANGE': ['op mode change', 'operation mode change'], + 'SUB_MODE_CHANGE': ['sub mode change'], + 'OPERATION_STATUS': ['status', 'operation status'], + 'D6_LEVL_CHANGE': ['d6 level change'], + 'D63_LEVL_CHANGE': ['d63 level change'], + 'D46_LEVL_CHANGE': ['d46 level change'], + 'TD_COMMUNICATION_LOSS': ['td communication loss'], + 'TEMPERATURE_DRIFT': ['temperature drift'], + 'BLOOD_LEAK_ZEROING_REQUEST': ['blood leak zeroing request'], + 'BLOOD_LEAK_ZEROING_REQUIRED': ['blood leak zeroing required'], + 'BLOOD_LEAK_NUM_OF_SET_POINT_CHECK_FAILURES': ['blood leak check failed'], + 'BLOOD_LEAK_SELF_TEST_RESULT': ['blood leak self test'], + 'CPU_RAM_ERROR_STATUS': ['cpu ram error status', 'cpu error status', 'ram error status', 'memory error status'], + 'BC_SWITCH_ONLY_MODE_CHANGE': ['bc switch only change'], + 'BC_FILL_STATE_CHANGE': ['bc state change'], + 'HEATER_STATE_CHANGE': ['heater state change'], + 'DRY_BICART_STATE_CHANGE': ['dry bicart state change'], 'NUM_OF_DD_EVENT_IDS': [], } @@ -737,24 +737,24 @@ @unique class DDBloodLeakStates(DialinEnum): - BLOOD_LEAK_WAIT_FOR_POST_STATE = 0 # - BLOOD_LEAK_CHECK_SET_POINT_STATE = 1 # - BLOOD_LEAK_INIT_STATE = 2 # - BLOOD_LEAK_CHECK_ZERO_AND_SELF_TEST_STATE = 3 # - BLOOD_LEAK_VERIFY_INTENSITY_AFTER_ZEROING_STATE = 4 # - BLOOD_LEAK_NORMAL_STATE = 5 # - BLOOD_LEAK_RECOVER_BLOOD_DETECT_STATE = 6 # - NUM_OF_BLOOD_LEAK_STATES = 7 # Number of blood leak states + WAIT_FOR_POST_STATE = 0 # + CHECK_SET_POINT_STATE = 1 # + INIT_STATE = 2 # + CHECK_ZERO_AND_SELF_TEST_STATE = 3 # + VERIFY_INTENSITY_AFTER_ZEROING_STATE = 4 # + NORMAL_STATE = 5 # + RECOVER_BLOOD_DETECT_STATE = 6 # + NUM_OF_BLOOD_LEAK_STATES = 7 # Number of blood leak states DDBloodLeakStates._str_list = { # 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'], + 'WAIT_FOR_POST_STATE': ['wait for post', 'wait'], + 'CHECK_SET_POINT_STATE': ['check set point'], + 'INIT_STATE': ['init'], + 'CHECK_ZERO_AND_SELF_TEST_STATE': ['check zero and self test'], + 'VERIFY_INTENSITY_AFTER_ZEROING_STATE': ['verify', 'verify intensity after zeroing'], + 'NORMAL_STATE': ['normal'], + 'RECOVER_BLOOD_DETECT_STATE': ['recover blood', 'recover blood detect'], 'NUM_OF_BLOOD_LEAK_STATES': [], } Index: leahi_dialin/common/fp_defs.py =================================================================== diff -u -r5f16af73fb80a76c6dc767661f11a8f3508770a1 -r27d9de42c0111c7f369cc335889fe6b988d09cc8 --- leahi_dialin/common/fp_defs.py (.../fp_defs.py) (revision 5f16af73fb80a76c6dc767661f11a8f3508770a1) +++ leahi_dialin/common/fp_defs.py (.../fp_defs.py) (revision 27d9de42c0111c7f369cc335889fe6b988d09cc8) @@ -236,76 +236,76 @@ # FPPreGenPermeateStates.FP_PRE_GENP_INLET_PRES_CHECK sub states @unique class FPInletPresCheckStates(DialinEnum): - INLET_PRES_CHECK_IN_PROGRESS = 0 # Inlet Pressure Check in progress state - INLET_PRES_CHECK_PAUSED = 1 # Inlet Pressure Check paused state + IN_PROGRESS = 0 # Inlet Pressure Check in progress state + PAUSED = 1 # Inlet Pressure Check paused state NUM_OF_INLET_PRES_CHECK_STATES = 2 # Number of Inlet Pressure Check states FPInletPresCheckStates._str_list = { # Official Name : Accepted strings - 'INLET_PRES_CHECK_IN_PROGRESS': ['start', 'in progress', 'running'], - 'INLET_PRES_CHECK_PAUSED': ['paused'], + 'IN_PROGRESS': ['start', 'in progress', 'running'], + 'PAUSED': ['paused'], 'NUM_OF_INLET_PRES_CHECK_STATES': [], } # FPPreGenPermeateStates.FP_PRE_GENP_FILTER_FLUSH sub states @unique class FPFilterFlushStates(DialinEnum): - FILTER_FLUSH_IN_PROGRESS = 0 # Filter Flush in progress state - FILTER_FLUSH_PAUSED = 1 # Filter Flush paused state + IN_PROGRESS = 0 # Filter Flush in progress state + PAUSED = 1 # Filter Flush paused state NUM_OF_FILTER_FLUSH_STATES = 2 # Number of filter flush states FPFilterFlushStates._str_list = { # Official Name : Accepted strings - 'FILTER_FLUSH_IN_PROGRESS': ['start', 'in progress', 'running'], - 'FILTER_FLUSH_PAUSED': ['paused'], + 'IN_PROGRESS': ['start', 'in progress', 'running'], + 'PAUSED': ['paused'], 'NUM_OF_FILTER_FLUSH_STATES': [], } # FPPreGenPermeateStates.FP_PRE_GENP_PERMEATE_FLUSH sub states @unique class FPPermeateFlushStates(DialinEnum): - PERM_FLUSH_IN_PROGRESS = 0 # Permeate Flush in progress state - PERM_FLUSH_PAUSED = 1 # Permeate Flush paused state + IN_PROGRESS = 0 # Permeate Flush in progress state + PAUSED = 1 # Permeate Flush paused state NUM_OF_PERM_FLUSH_STATES = 2 # Number of permeate flush states FPPermeateFlushStates._str_list = { # Official Name : Accepted strings - 'PERM_FLUSH_IN_PROGRESS': ['start', 'in progress', 'running'], - 'PERM_FLUSH_PAUSED': ['paused'], + 'IN_PROGRESS': ['start', 'in progress', 'running'], + 'PAUSED': ['paused'], 'NUM_OF_PERM_FLUSH_STATES': [], } # FPPreGenPermeateStates.FP_PRE_GENP_CONCENTRATE_FLUSH sub states @unique class FPConcentrateFlushStates(DialinEnum): - CONC_FLUSH_IN_PROGRESS = 0 # Concentrate Flush in progress state - CONC_FLUSH_PAUSED = 1 # Concentrate Flush paused state + IN_PROGRESS = 0 # Concentrate Flush in progress state + PAUSED = 1 # Concentrate Flush paused state NUM_OF_CONC_FLUSH_STATES = 2 # Number of Concentrate flush states FPConcentrateFlushStates._str_list = { # Official Name : Accepted strings - 'CONC_FLUSH_IN_PROGRESS': ['start', 'in progress', 'running'], - 'CONC_FLUSH_PAUSED': ['paused'], + 'IN_PROGRESS': ['start', 'in progress', 'running'], + 'PAUSED': ['paused'], 'NUM_OF_CONC_FLUSH_STATES': [], } # FPPreGenPDefStates.FP_PRE_GENP_DEF_FLUSH sub states @unique class FPDefFlushStates(DialinEnum): - FILTER_FLUSH_DEF_DYNAMIC_PRESSURE_CHECK = 0 # Filter Flush in dynamic pressure state - FILTER_FLUSH_DEF_STATIC_PRESSURE_CHECK = 1 # Filter flush in sttaic pressure check - FILTER_FLUSH_DEF_PAUSED = 2 # Filter Flush paused state - NUM_OF_FILTER_FLUSH_DEF_STATES = 3 # Number of filter flush states + DYNAMIC_PRESSURE_CHECK = 0 # Filter Flush in dynamic pressure state + STATIC_PRESSURE_CHECK = 1 # Filter flush in sttaic pressure check + PAUSED = 2 # Filter Flush paused state + NUM_OF_FILTER_FLUSH_DEF_STATES = 3 # Number of filter flush states FPDefFlushStates._str_list = { # Official Name : Accepted strings - 'FILTER_FLUSH_DEF_DYNAMIC_PRESSURE_CHECK': ['dynamic', 'dynamic pressure check'], - 'FILTER_FLUSH_DEF_STATIC_PRESSURE_CHECK': ['static', 'static pressure check'], - 'FILTER_FLUSH_DEF_PAUSED': ['paused'], + 'DYNAMIC_PRESSURE_CHECK': ['dynamic', 'dynamic pressure check'], + 'STATIC_PRESSURE_CHECK': ['static', 'static pressure check'], + 'PAUSED': ['paused'], 'NUM_OF_PERM_FLUSH_STATES': [], } @@ -314,33 +314,34 @@ # ================================================== Enum Creators: Events ================================================== @unique class FPEventList(DialinEnum): - FP_EVENT_STARTUP = 0 # FP startup event - FP_EVENT_OP_MODE_CHANGE = 1 # FP Op mode change event - FP_EVENT_SUB_MODE_CHANGE = 2 # FP Op sub-mode change event - FP_EVENT_PRE_GEN_RO_SET_PWM = 3 # FP gen permeate ro set pwm event - FP_EVENT_GENP_BOOST_SET_PWM = 4 # FP gen permeate boost set pwm event - FP_EVENT_GENP_CHANGE = 5 # FP gen permeate state change - FP_EVENT_PRE_GEN_CHANGE = 6 # FP pre gen state change - FP_EVENT_PRE_GEN_DEF_CHANGE = 7 # FP defeatured pre gen state change - FP_EVENT_GENP_DEF_CHANGE = 8 # FP defeatured gen permeate state change - FP_EVENT_FAULT_ALARM_TRIGGER = 9 # FP event for alarms that would trigger - FP_EVENT_P25_LEVL_CHANGE = 10 # FP floater level change event - FP_EVENT_OPERATION_STATUS = 11 # FP operation status event - NUM_OF_FP_EVENT_IDS = 12 # Number of FP events + STARTUP = 0 # FP startup event + OP_MODE_CHANGE = 1 # FP Op mode change event + SUB_MODE_CHANGE = 2 # FP Op sub-mode change event + PRE_GEN_RO_SET_PWM = 3 # FP gen permeate ro set pwm event + GENP_BOOST_SET_PWM = 4 # FP gen permeate boost set pwm event + GENP_CHANGE = 5 # FP gen permeate state change + PRE_GEN_CHANGE = 6 # FP pre gen state change + PRE_GEN_DEF_CHANGE = 7 # FP defeatured pre gen state change + GENP_DEF_CHANGE = 8 # FP defeatured gen permeate state change + FAULT_ALARM_TRIGGER = 9 # FP event for alarms that would trigger + P25_LEVL_CHANGE = 10 # FP floater level change event + OPERATION_STATUS = 11 # FP operation status event + NUM_OF_FP_EVENT_IDS = 12 # Number of FP events FPEventList._str_list = { # Official Name : Accepted strings - 'FP_EVENT_STARTUP': ['startup'], - 'FP_EVENT_OP_MODE_CHANGE': ['op mode change'], - 'FP_EVENT_SUB_MODE_CHANGE': ['sub mode change'], - 'FP_EVENT_PRE_GEN_RO_SET_PWM': ['ro pump set pwm'], - 'FP_EVENT_GENP_BOOST_SET_PWM': ['boost pump set pwm'], - 'FP_EVENT_GENP_CHANGE': ['generate permeate change', 'genp change'], - 'FP_EVENT_PRE_GEN_CHANGE': ['pre-generate permeate change', 'pre-genp change'], - 'FP_EVENT_PRE_GEN_DEF_CHANGE': ['defeatured pre-generate permeate change', 'def pre-genp change'], - 'FP_EVENT_GENP_DEF_CHANGE': ['defeatured generate permeate change', 'def genp change'], - 'FP_EVENT_FAULT_ALARM_TRIGGER': ['alarm', 'alarm trigger', 'fault alarm trigger'], - 'FP_EVENT_OPERATION_STATUS': ['operation status', 'status', 'op status', 'operation status change', 'status change', 'op status change'], + 'STARTUP': ['startup'], + 'OP_MODE_CHANGE': ['op mode change'], + 'SUB_MODE_CHANGE': ['sub mode change'], + 'PRE_GEN_RO_SET_PWM': ['ro pump set pwm'], + 'GENP_BOOST_SET_PWM': ['boost pump set pwm'], + 'GENP_CHANGE': ['generate permeate change', 'genp change'], + 'PRE_GEN_CHANGE': ['pre-generate permeate change', 'pre-genp change'], + 'PRE_GEN_DEF_CHANGE': ['defeatured pre-generate permeate change', 'def pre-genp change'], + 'GENP_DEF_CHANGE': ['defeatured generate permeate change', 'def genp change'], + 'FAULT_ALARM_TRIGGER': ['alarm', 'alarm trigger', 'fault alarm trigger'], + 'P25_LEVL_CHANGE': ['p25', 'level change'], + 'OPERATION_STATUS': ['operation status', 'status', 'op status', 'operation status change', 'status change', 'op status change'], 'NUM_OF_FP_EVENT_IDS': [], } @@ -557,20 +558,20 @@ @unique class FPFloaterLevels(DialinEnum): - LEVEL_STATE_EMPTY = 0 # Empty level for the FP Floater Level Sensors - LEVEL_STATE_LOW = 1 # Low level for the FP Floater Level Sensors - LEVEL_STATE_MEDIUM = 2 # Medium level for the FP Floater Level Sensors - LEVEL_STATE_HIGH = 3 # High level for the FP Floater Level Sensors - LEVEL_STATE_ILLEGAL = 4 # Illegal level for FP Floater Level Sensor (indicates investigation) - NUM_OF_LEVEL_STATES = 5 # Number of Level States + EMPTY = 0 # Empty level for the FP Floater Level Sensors + LOW = 1 # Low level for the FP Floater Level Sensors + MEDIUM = 2 # Medium level for the FP Floater Level Sensors + HIGH = 3 # High level for the FP Floater Level Sensors + ILLEGAL = 4 # Illegal level for FP Floater Level Sensor (indicates investigation) + NUM_OF_LEVEL_STATES = 5 # Number of Level States FPFloaterLevels._str_list = { # Official Name : Accepted strings - 'LEVEL_STATE_EMPTY': ['empty'], - 'LEVEL_STATE_LOW': ['low'], - 'LEVEL_STATE_MEDIUM': ['medium'], - 'LEVEL_STATE_HIGH': ['high'], - 'LEVEL_STATE_ILLEGAL': ['illegal'], + 'EMPTY': ['empty'], + 'LOW': ['low'], + 'MEDIUM': ['medium'], + 'HIGH': ['high'], + 'ILLEGAL': ['illegal'], 'NUM_OF_LEVEL_STATES': [], } @@ -623,32 +624,32 @@ @unique class FPROPumpStates(DialinEnum): - PUMP_OFF_STATE = 0 # Pump Offline State - PUMP_CONTROL_TO_TARGET_FLOW_STATE = 1 # RO pump control to target flow state - PUMP_CONTROL_TO_TARGET_PRESSURE_STATE = 2 # RO pump control to max pressure state. - PUMP_OPEN_LOOP_STATE = 3 # RO pump open loop state. - NUM_OF_RO_PUMP_STATES = 4 # Number of RO pump states + OFF_STATE = 0 # Pump Offline State + CONTROL_TO_TARGET_FLOW_STATE = 1 # RO pump control to target flow state + CONTROL_TO_TARGET_PRESSURE_STATE = 2 # RO pump control to max pressure state. + OPEN_LOOP_STATE = 3 # RO pump open loop state. + NUM_OF_RO_PUMP_STATES = 4 # Number of RO pump states FPROPumpStates._str_list = { # Official Name : Accepted strings - 'PUMP_OFF_STATE': ['closed', 'off', 'inactive', 'offline'], - 'PUMP_CONTROL_TO_TARGET_FLOW_STATE': ['flow', 'target to flow', 'to flow'], - 'PUMP_CONTROL_TO_TARGET_PRESSURE_STATE': ['pressure', 'target to pressure', 'to pressure', 'pres'], - 'PUMP_OPEN_LOOP_STATE': ['open', 'open loop', 'on'], + 'OFF_STATE': ['closed', 'off', 'inactive', 'offline'], + 'CONTROL_TO_TARGET_FLOW_STATE': ['flow', 'target to flow', 'to flow'], + 'CONTROL_TO_TARGET_PRESSURE_STATE': ['pressure', 'target to pressure', 'to pressure', 'pres'], + 'OPEN_LOOP_STATE': ['open', 'open loop', 'on'], 'NUM_OF_RO_PUMP_STATES': [], } @unique class FPValveStates(DialinEnum): - VALVE_STATE_CLOSED = 0 # Valve Closed State - VALVE_STATE_OPEN = 1 # Valve Open State + CLOSED = 0 # Valve Closed State + OPEN = 1 # Valve Open State NUM_OF_VALVE_STATES = 2 # Number of valve states FPValveStates._str_list = { # Official Name : Accepted strings - 'VALVE_STATE_CLOSED': ['closed', 'off'], - 'VALVE_STATE_OPEN': ['open', 'on'], + 'CLOSED': ['closed', 'off'], + 'OPEN': ['open', 'on'], 'NUM_OF_VALVE_STATES': [], } Index: leahi_dialin/common/td_defs.py =================================================================== diff -u -r99005b6f96d49ad13fa01a44889579c386dc803a -r27d9de42c0111c7f369cc335889fe6b988d09cc8 --- leahi_dialin/common/td_defs.py (.../td_defs.py) (revision 99005b6f96d49ad13fa01a44889579c386dc803a) +++ leahi_dialin/common/td_defs.py (.../td_defs.py) (revision 27d9de42c0111c7f369cc335889fe6b988d09cc8) @@ -82,165 +82,161 @@ # TDOpModes.MODE_INIT sub states @unique class TDInitStates(DialinEnum): - 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 + START = 0 # Start initialize & POST mode state + FW_INTEGRITY = 1 # Run firmware integrity test state + NVDATAMGMT = 2 # Run NV Data Mgmt. test state + WATCHDOG = 3 # Run watchdog test state + SAFETY_SHUTDOWN = 4 # Run safety shutdown test state + BLOOD_FLOW = 5 # Run blood flow test state + VALVES = 6 # Run valves test state + SYRINGE_PUMP = 7 # Run syringe pump test state + PRES_OCCL = 8 # Run pressure occlusion state + ALARM_AUDIO = 9 # Run alarm audio test state + ALARM_LAMP = 10 # Run alarm lamp test state + TEMPERATURES = 11 # Run temperatures POST state + FANS = 12 # Run fans POST state + STUCK_BUTTON = 13 # Run stuck button test state + UI_POST = 14 # Check whether UI passed its POST tests + FW_COMPATIBILITY = 15 # Run firmware compatibility test state + FPGA = 16 # Run FPGA test state + COMPLETED = 17 # POST self-tests completed state + FAILED = 18 # POST self-tests failed state + NUM_OF_POST_STATES = 19 # Number of initialize & POST mode states TDInitStates._str_list = { # Official Name : Accepted strings - 'POST_STATE_START': ['start'], - 'POST_STATE_FW_INTEGRITY': ['fw integrity'], - 'POST_STATE_NVDATAMGMT': ['nv data management', 'data management'], - 'POST_STATE_WATCHDOG': ['watchdog'], - 'POST_STATE_SAFETY_SHUTDOWN': ['safety shutdown'], - 'POST_STATE_BLOOD_FLOW': ['blood flow', 'blood flow test'], - 'POST_STATE_VALVES': ['valves', 'valves test'], - 'POST_STATE_SYRINGE_PUMP': ['syringe pump', 'syringe pump test', 'heparin test'], - 'POST_STATE_PRES_OCCL': ['pressure', 'pressure occlusion', 'pres occl'], - 'POST_STATE_ALARM_AUDIO': ['alarm audio', 'alarm audio test'], - 'POST_STATE_ALARM_LAMP': ['alarm lamp', 'alarm lamp test'], - 'POST_STATE_TEMPERATURES': ['temperatures'], - 'POST_STATE_FANS': ['fans'], - 'POST_STATE_STUCK_BUTTON': ['button', 'button stuck', 'stuck button test'], - 'POST_STATE_UI_POST': ['ui post'], - 'POST_STATE_FW_COMPATIBILITY': ['fw compatibility'], - 'POST_STATE_FPGA': ['fpga'], - 'POST_STATE_COMPLETED': ['completed'], - 'POST_STATE_FAILED': ['failed'], + 'START': ['start'], + 'FW_INTEGRITY': ['fw integrity'], + 'NVDATAMGMT': ['nv data management', 'data management'], + 'WATCHDOG': ['watchdog'], + 'SAFETY_SHUTDOWN': ['safety shutdown'], + 'BLOOD_FLOW': ['blood flow', 'blood flow test'], + 'VALVES': ['valves', 'valves test'], + 'SYRINGE_PUMP': ['syringe pump', 'syringe pump test', 'heparin test'], + 'PRES_OCCL': ['pressure', 'pressure occlusion', 'pres occl'], + 'ALARM_AUDIO': ['alarm audio', 'alarm audio test'], + 'ALARM_LAMP': ['alarm lamp', 'alarm lamp test'], + 'TEMPERATURES': ['temperatures'], + 'FANS': ['fans'], + 'STUCK_BUTTON': ['button', 'button stuck', 'stuck button test'], + 'UI_POST': ['ui post'], + 'FW_COMPATIBILITY': ['fw compatibility'], + 'FPGA': ['fpga'], + 'COMPLETED': ['completed'], + 'FAILED': ['failed'], 'NUM_OF_POST_STATES': [], } # TDOpModes.MODE_STAN sub states @unique class TDStandbyStates(DialinEnum): - 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). + START_STATE = 0 # Start standby (home actuators). + WAIT_FOR_TREATMENT_STATE = 1 # Wait for treatment. + WAIT_FOR_DISINFECT_STATE = 2 # Wait for UI to send disinfect option. + WAIT_FOR_DG_CLEANING_MODE_CMD_RESPONSE_STATE = 3 # Wait for DG cleaning mode command response state. + WAIT_FOR_DG_CLEANING_MODE_TO_START_STATE = 4 # Wait for DG cleaning mode to start state. + CLEANING_MODE_IN_PROGRESS_STATE = 5 # Cleaning mode in progress state. + NUM_OF_STANDBY_STATES = 6 # Number of standby states (sub-modes). TDStandbyStates._str_list = { # Official Name : Accepted strings - 'STANDBY_START_STATE': ['start'], - 'STANDBY_WAIT_FOR_TREATMENT_STATE': ['wait for treatment'], - 'STANDBY_WAIT_FOR_DISINFECT_STATE': ['wait for disinfect', 'wait for heat disinfect'], - 'STANDBY_WAIT_FOR_DG_CLEANING_MODE_CMD_RESPONSE_STATE': ['wait for cleaning command response'], - 'STANDBY_WAIT_FOR_DG_CLEANING_MODE_TO_START_STATE': ['wait for cleaning to start'], - 'STANDBY_CLEANING_MODE_IN_PROGRESS_STATE': ['cleaning mode in progress', 'cleaning in progress'], + 'START_STATE': ['start'], + 'WAIT_FOR_TREATMENT_STATE': ['wait for treatment'], + 'WAIT_FOR_DISINFECT_STATE': ['wait for disinfect', 'wait for heat disinfect'], + 'WAIT_FOR_DG_CLEANING_MODE_CMD_RESPONSE_STATE': ['wait for cleaning command response'], + 'WAIT_FOR_DG_CLEANING_MODE_TO_START_STATE': ['wait for cleaning to start'], + 'CLEANING_MODE_IN_PROGRESS_STATE': ['cleaning mode in progress', 'cleaning in progress'], 'NUM_OF_STANDBY_STATES': [], } # TDOpModes.MODE_TPAR sub states @unique class TDTreatmentParamStates(DialinEnum): - 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 + WAIT_4_UI_2_SEND = 0 # Wait for UI to send 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 TDTreatmentParamStates._str_list = { # Official Name : Accepted strings - 'TD_TREATMENT_PARAMS_MODE_STATE_WAIT_4_UI_2_SEND': ['send'], - 'TD_TREATMENT_PARAMS_MODE_STATE_WAIT_4_UI_2_CONFIRM': ['confirm'], + 'WAIT_4_UI_2_SEND': ['send'], + 'WAIT_4_UI_2_CONFIRM': ['confirm'], 'NUM_OF_TD_TREATMENT_PARAMS_MODE_STATES': [], } # TDOpModes.MODE_PRET sub states @unique class TDPreTreatmentModesStates(DialinEnum): - 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_CONFIRM_RX_STATE = 7 # User reviews and confirms prescription ( Confirm Rx ) - TD_PRE_TREATMENT_PATIENT_CONNECTION_STATE = 8 # Patient connection state - NUM_OF_TD_PRE_TREATMENT_STATES = 9 # Number of pre-treatment mode states + TUBING_SET_INSTALL_STATE = 0 # Tube set install state + SELF_TEST_DRY_STATE = 1 # Self-tests when the cartridge is dry state + PRIME_STATE = 2 # Prime blood and dialysate circuits and run wet self-tests state + RECIRCULATE_STATE = 3 # Re-circulate blood and dialysate circuits state + CONFIRM_RX_STATE = 4 # User reviews and confirms prescription ( Confirm Rx ) + HEPARIN_SETUP_STATE = 5 # Heparin setup state + PATIENT_CONNECTION_STATE = 6 # Patient connection state + NUM_OF_TD_PRE_TREATMENT_STATES = 7 # Number of pre-treatment mode states TDPreTreatmentModesStates._str_list = { # Official Name : Accepted strings - 'TD_PRE_TREATMENT_WATER_SAMPLE_STATE': ['water sample'], - 'TD_PRE_TREATMENT_SELF_TEST_CONSUMABLE_STATE': ['self test consumable'], - 'TD_PRE_TREATMENT_SELF_TEST_NO_CART_STATE': ['self test no cartridge'], - 'TD_PRE_TREATMENT_CART_INSTALL_STATE': ['cartridge install'], - 'TD_PRE_TREATMENT_SELF_TEST_DRY_STATE': ['self test dry', 'dry self test'], - 'TD_PRE_TREATMENT_PRIME_STATE': ['prime', 'blood priming', 'priming'], - 'TD_PRE_TREATMENT_RECIRCULATE_STATE': ['recirculate'], - 'TD_PRE_TREATMENT_CONFIRM_RX_STATE': ['confirm rx', 'rx'], - 'TD_PRE_TREATMENT_PATIENT_CONNECTION_STATE': ['patient connect'], + 'TUBING_SET_INSTALL_STATE': ['tubing set install', 'cartridge install'], + 'SELF_TEST_DRY_STATE': ['self test dry', 'dry self test'], + 'PRIME_STATE': ['prime', 'blood priming', 'priming'], + 'RECIRCULATE_STATE': ['recirculate'], + 'CONFIRM_RX_STATE': ['confirm rx', 'rx'], + 'HEPARIN_SETUP_STATE': ['heparin setup'], + 'PATIENT_CONNECTION_STATE': ['patient connect'], 'NUM_OF_TD_PRE_TREATMENT_STATES': [], } # TDOpModes.MODE_TREA sub states @unique class TDTreatmentStates(DialinEnum): - 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) + START_STATE = 0 # Start treatment - initialize treatment and go to blood prime state + 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. + DIALYSIS_STATE = 2 # Perform dialysis. Deliver UF as prescribed. + PAUSED_STATE = 3 # Treatment paused. All pumps off. Dializer bypassed + RINSEBACK_STATE = 4 # Perform rinseback with saline. Dialyzer bypassed. Dialysate recirculating + RECIRC_STATE = 5 # Recirculate saline and dialysate while patient disconnected. Blood lines open and shunted. Dialyzer is bypassed + END_STATE = 6 # Dialysis has ended. Blood pump slowed. Dialyzer is bypassed. Dialysate is recirculated. User can rinseback + ISO_UF_STATE = 7 # Isolated ultrafiltration. No dialysate flow. Ultrafiltration only. + SALINE_BOLUS_STATE = 8 # Deliver a saline bolus. Blood pump draws from saline bag. Dialyzer bypassed. + DIALYSATE_PAUSED_STATE = 9 # No dialysate flow. Dialyzer bypassed. + NUM_OF_TREATMENT_STATES = 10 # Number of treatment states (sub-modes) TDTreatmentStates._str_list = { # Official Name : Accepted strings - 'TREATMENT_START_STATE': ['start'], - 'TREATMENT_BLOOD_PRIME_STATE': ['blood prime', 'priming'], - 'TREATMENT_DIALYSIS_STATE': ['dialysis'], - 'TREATMENT_PAUSED_STATE': ['paused'], - 'TREATMENT_RINSEBACK_STATE': ['rinseback'], - 'TREATMENT_RECIRC_STATE': ['recirc', 'recirculate'], - 'TREATMENT_END_STATE': ['end'], - 'TREATMENT_ISO_UF_STATE': ['iso uf', 'isolated uf', 'isolated ultrafiltration'], - 'TREATMENT_SALINE_BOLUS_STATE': ['saline bolus', 'deliver saline bolus'], - 'TREATMENT_DIALYSATE_PAUSED_STATE': ['dialysate paused'], + 'START_STATE': ['start'], + 'BLOOD_PRIME_STATE': ['blood prime', 'priming'], + 'DIALYSIS_STATE': ['dialysis'], + 'PAUSED_STATE': ['paused'], + 'RINSEBACK_STATE': ['rinseback'], + 'RECIRC_STATE': ['recirc', 'recirculate'], + 'END_STATE': ['end'], + 'ISO_UF_STATE': ['iso uf', 'isolated uf', 'isolated ultrafiltration'], + 'SALINE_BOLUS_STATE': ['saline bolus', 'deliver saline bolus'], + 'DIALYSATE_PAUSED_STATE': ['dialysate paused'], 'NUM_OF_TREATMENT_STATES': [], } # TDOpModes.MODE_POST sub states @unique class TDPostTreatmentStates(DialinEnum): - 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 + DRAIN_RESERVOIRS_STATE = 0 # Drain reservoirs state + PATIENT_DISCONNECTION_STATE = 1 # Patient disconnection state + DISPOSABLE_REMOVAL_STATE = 2 # Disposable removal state + 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 TDPostTreatmentStates._str_list = { # Official Name : Accepted strings - 'TD_POST_TREATMENT_DRAIN_RESERVOIRS_STATE': ['drain reservoirs'], - 'TD_POST_TREATMENT_PATIENT_DISCONNECTION_STATE': ['patient disconnect'], - 'TD_POST_TREATMENT_DISPOSABLE_REMOVAL_STATE': ['disposable removal'], - 'TD_POST_TREATMENT_VERIFY_STATE': ['verify'], + 'DRAIN_RESERVOIRS_STATE': ['drain reservoirs'], + 'PATIENT_DISCONNECTION_STATE': ['patient disconnect'], + 'DISPOSABLE_REMOVAL_STATE': ['disposable removal'], + 'VERIFY_STATE': ['verify'], 'NUM_OF_TD_POST_TREATMENT_STATES': [], } @@ -258,158 +254,158 @@ # ================================================== Enum Creators: Operations Lvl 3 ================================================== -# TDPreTreatmentModesStates.TD_PRE_TREATMENT_WATER_SAMPLE_STATE sub states +# TDPreTreatmentModesStates.WATER_SAMPLE_STATE sub states @unique class TDPreTreaSampleWaterStates(DialinEnum): - SAMPLE_WATER_SETUP_STATE = 0 # Sample water setup (flush filter) state - SAMPLE_WATER_STATE = 1 # Sample water state, receiving sample water commands from the user - SAMPLE_WATER_COMPLETE_STATE = 2 # Sample water complete state - NUM_OF_SAMPLE_WATER_STATES = 3 # Number of fault mode NV Data management states + SETUP_STATE = 0 # Sample water setup (flush filter) state + STATE = 1 # Sample water state, receiving sample water commands from the user + COMPLETE_STATE = 2 # Sample water complete state + NUM_OF_SAMPLE_WATER_STATES = 3 # Number of fault mode NV Data management states TDPreTreaSampleWaterStates._str_list = { # Official Name : Accepted strings - 'SAMPLE_WATER_SETUP_STATE': ['setup'], - 'SAMPLE_WATER_STATE': ['running', 'sampling'], - 'SAMPLE_WATER_COMPLETE_STATE': ['complete', 'done'], + 'SETUP_STATE': ['setup'], + 'STATE': ['running', 'sampling'], + 'COMPLETE_STATE': ['complete', 'done'], 'NUM_OF_SAMPLE_WATER_STATES': [], } -# TDPreTreatmentModesStates.TD_PRE_TREATMENT_SELF_TEST_CONSUMABLE_STATE sub states +# TDPreTreatmentModesStates.SELF_TEST_CONSUMABLE_STATE sub states @unique class TDPreTreaConsumableSelfTestStates(DialinEnum): - CONSUMABLE_SELF_TESTS_INSTALL_STATE = 0 # Consumable self-tests install state - CONSUMABLE_SELF_TESTS_PRIME_STATE = 1 # Consumable self-tests prime concentrate lines state - CONSUMABLE_SELF_TESTS_BICARB_PUMP_CHECK_STATE = 2 # Consumable self-tests bicarbonate concentrate pump check state - CONSUMABLE_SELF_TESTS_ACID_PUMP_CHECK_STATE = 3 # Consumable self-tests acid concentrate pump check state - CONSUMABLE_SELF_TESTS_COMPLETE_STATE = 4 # Consumable self-tests complete state - NUM_OF_CONSUMABLE_SELF_TESTS_STATES = 5 # Number of consumable install sub-mode states + INSTALL_STATE = 0 # Consumable self-tests install state + PRIME_STATE = 1 # Consumable self-tests prime concentrate lines state + BICARB_PUMP_CHECK_STATE = 2 # Consumable self-tests bicarbonate concentrate pump check state + ACID_PUMP_CHECK_STATE = 3 # Consumable self-tests acid concentrate pump check state + COMPLETE_STATE = 4 # Consumable self-tests complete state + NUM_OF_CONSUMABLE_SELF_TESTS_STATES = 5 # Number of consumable install sub-mode states TDPreTreaConsumableSelfTestStates._str_list = { # Official Name : Accepted strings - 'CONSUMABLE_SELF_TESTS_INSTALL_STATE': ['install', 'installing'], - 'CONSUMABLE_SELF_TESTS_PRIME_STATE': ['prime', 'priming'], - 'CONSUMABLE_SELF_TESTS_BICARB_PUMP_CHECK_STATE': ['bicarb', 'bicarb pump check'], - 'CONSUMABLE_SELF_TESTS_ACID_PUMP_CHECK_STATE': ['acid', 'acid pump check'], - 'CONSUMABLE_SELF_TESTS_COMPLETE_STATE': ['complete', 'done'], + 'INSTALL_STATE': ['install', 'installing'], + 'PRIME_STATE': ['prime', 'priming'], + 'BICARB_PUMP_CHECK_STATE': ['bicarb', 'bicarb pump check'], + 'ACID_PUMP_CHECK_STATE': ['acid', 'acid pump check'], + 'COMPLETE_STATE': ['complete', 'done'], 'NUM_OF_CONSUMABLE_SELF_TESTS_STATES': [], } -# TDPreTreatmentModesStates.TD_PRE_TREATMENT_SELF_TEST_NO_CART_STATE sub states +# TDPreTreatmentModesStates.SELF_TEST_NO_CART_STATE sub states @unique class TDPreTreaNoCartSelfTestStates(DialinEnum): - NO_CART_SELF_TESTS_WAIT_FOR_DOOR_CLOSE_STATE = 0 # Wait for door to be closed before running self-tests - NO_CART_SELF_TESTS_PRESSURE_CHECKS_STATE = 1 # No cartridge pressure sensors self-test state - NO_CART_SELF_TESTS_HOME_VALVES_STATE = 2 # No cartridge home valves state - NO_CART_SELF_TESTS_HOME_SYRINGE_PUMP_STATE = 3 # No cartridge home syringe pump state - NO_CART_SELF_TESTS_PUMPS_STATE = 4 # No cartridge self-test for blood pump, dialysate in pump, dialysate out pump state - NO_CART_SELF_TESTS_HOME_IDLE_STATE = 5 # Wait for valves and pumps finish homing state - NO_CART_SELF_TESTS_STOPPED_STATE = 6 # No cart self-test stopped state - NO_CART_SELF_TESTS_COMPLETE_STATE = 7 # No cartridge self-test complete state - NUM_OF_NO_CART_SELF_TESTS_STATES = 8 # Number of no cartridge self-tests states + WAIT_FOR_DOOR_CLOSE_STATE = 0 # Wait for door to be closed before running self-tests + PRESSURE_CHECKS_STATE = 1 # No cartridge pressure sensors self-test state + HOME_VALVES_STATE = 2 # No cartridge home valves state + HOME_SYRINGE_PUMP_STATE = 3 # No cartridge home syringe pump state + PUMPS_STATE = 4 # No cartridge self-test for blood pump, dialysate in pump, dialysate out pump state + HOME_IDLE_STATE = 5 # Wait for valves and pumps finish homing state + STOPPED_STATE = 6 # No cart self-test stopped state + COMPLETE_STATE = 7 # No cartridge self-test complete state + NUM_OF_NO_CART_SELF_TESTS_STATES = 8 # Number of no cartridge self-tests states TDPreTreaNoCartSelfTestStates._str_list = { # Official Name : Accepted strings - 'NO_CART_SELF_TESTS_WAIT_FOR_DOOR_CLOSE_STATE': ['wait for front door to close', 'wait for door close'], - 'NO_CART_SELF_TESTS_PRESSURE_CHECKS_STATE': ['pressure checks'], - 'NO_CART_SELF_TESTS_HOME_VALVES_STATE': ['home valves'], - 'NO_CART_SELF_TESTS_HOME_SYRINGE_PUMP_STATE': ['home srynge pump'], - 'NO_CART_SELF_TESTS_PUMPS_STATE': ['test pumps'], - 'NO_CART_SELF_TESTS_HOME_IDLE_STATE': ['home idle', 'wait for homing'], - 'NO_CART_SELF_TESTS_STOPPED_STATE': ['stop'], - 'NO_CART_SELF_TESTS_PUMPS_STATE': ['test pumps'], - 'NO_CART_SELF_TESTS_COMPLETE_STATE': ['complete', 'done'], + 'WAIT_FOR_DOOR_CLOSE_STATE': ['wait for front door to close', 'wait for door close'], + 'PRESSURE_CHECKS_STATE': ['pressure checks'], + 'HOME_VALVES_STATE': ['home valves'], + 'HOME_SYRINGE_PUMP_STATE': ['home srynge pump'], + 'PUMPS_STATE': ['test pumps'], + 'HOME_IDLE_STATE': ['home idle', 'wait for homing'], + 'STOPPED_STATE': ['stop'], + 'PUMPS_STATE': ['test pumps'], + 'COMPLETE_STATE': ['complete', 'done'], 'NUM_OF_NO_CART_SELF_TESTS_STATES': [], } -# TDPreTreatmentModesStates.TD_PRE_TREATMENT_SELF_TEST_DRY_STATE sub states +# TDPreTreatmentModesStates.SELF_TEST_DRY_STATE sub states @unique class TDPreTreaDrySelfTestStates(DialinEnum): - DRY_SELF_TESTS_WAIT_FOR_DOOR_CLOSE_STATE = 0 # Wait for door to close before executing self-tests - DRY_SELF_TESTS_USED_TUBING_CHECK_STATE = 1 # Used tubing check dry self-test state - DRY_SELF_TESTS_TUBING_LOADED_CHECK_STATE = 2 # Tubing loaded check dry self-test state - DRY_SELF_TESTS_TUBING_SET_AUTHENTICATION_STATE = 3 # Tubing set authentication state - DRY_SELF_TESTS_SYRINGE_PUMP_SEEK_STATE = 4 # Syringe pump seek state - DRY_SELF_TESTS_PRESSURE_SENSORS_NORMAL_SETUP_STATE = 5 # Pressure sensor normal setup state - DRY_SELF_TESTS_PRESSURE_VENOUS_SETUP_STATE = 6 # Venous pressure sensor dry self-test setup valves and pump state - DRY_SELF_TESTS_VENOUS_PRESSURE_STABILIZATION_STATE = 7 # Venous pressure verify pressure stability state - DRY_SELF_TESTS_VENOUS_PRESSURE_LEAK_CHECK_STATE = 8 # Venous pressure leak check state - DRY_SELF_TESTS_VENOUS_PRESSURE_RELIEF_STATE = 9 # Venous pressure relief state - DRY_SELF_TESTS_PRESSURE_ARTERIAL_SETUP_STATE = 10 # Arterial pressure sensor dry self-test setup valves and pump state - DRY_SELF_TESTS_ARTERIAL_PRESSURE_STABILIZATION_STATE = 11 # Arterial pressure verify pressure stability state - DRY_SELF_TESTS_ARTERIAL_PRESSURE_LEAK_CHECK_STATE = 12 # Arterial pressure leak check state - DRY_SELF_TESTS_ARTERIAL_PRESSURE_RELIEF_STATE = 13 # Arterial pressure relief state - DRY_SELF_TESTS_SYRINGE_PRIME_STATE = 14 # Prime syringe pump state - DRY_SELF_TESTS_SYRINGE_PUMP_OCCLUSION_CHECK_STATE = 15 # Occlusion detection state - DRY_SELF_TESTS_COMPLETE_STATE = 16 # Dry self-test complete state - DRY_SELF_TESTS_STOPPED_STATE = 17 # Dry self-test stopped state - NUM_OF_DRY_SELF_TESTS_STATES = 18 # Number of dry self-tests states + WAIT_FOR_DOOR_CLOSE_STATE = 0 # Wait for door to close before executing self-tests + USED_TUBING_CHECK_STATE = 1 # Used tubing check dry self-test state + TUBING_LOADED_CHECK_STATE = 2 # Tubing loaded check dry self-test state + TUBING_SET_AUTHENTICATION_STATE = 3 # Tubing set authentication state + SYRINGE_PUMP_SEEK_STATE = 4 # Syringe pump seek state + PRESSURE_SENSORS_NORMAL_SETUP_STATE = 5 # Pressure sensor normal setup state + PRESSURE_VENOUS_SETUP_STATE = 6 # Venous pressure sensor dry self-test setup valves and pump state + VENOUS_PRESSURE_STABILIZATION_STATE = 7 # Venous pressure verify pressure stability state + VENOUS_PRESSURE_LEAK_CHECK_STATE = 8 # Venous pressure leak check state + VENOUS_PRESSURE_RELIEF_STATE = 9 # Venous pressure relief state + PRESSURE_ARTERIAL_SETUP_STATE = 10 # Arterial pressure sensor dry self-test setup valves and pump state + ARTERIAL_PRESSURE_STABILIZATION_STATE = 11 # Arterial pressure verify pressure stability state + ARTERIAL_PRESSURE_LEAK_CHECK_STATE = 12 # Arterial pressure leak check state + ARTERIAL_PRESSURE_RELIEF_STATE = 13 # Arterial pressure relief state + SYRINGE_PRIME_STATE = 14 # Prime syringe pump state + SYRINGE_PUMP_OCCLUSION_CHECK_STATE = 15 # Occlusion detection state + COMPLETE_STATE = 16 # Dry self-test complete state + STOPPED_STATE = 17 # Dry self-test stopped state + NUM_OF_DRY_SELF_TESTS_STATES = 18 # Number of dry self-tests states TDPreTreaDrySelfTestStates._str_list = { # Official Name : Accepted strings - 'DRY_SELF_TESTS_WAIT_FOR_DOOR_CLOSE_STATE': ['wait for front door to close', 'wait for door close'], - 'DRY_SELF_TESTS_USED_TUBING_CHECK_STATE': ['used tubing check'], - 'DRY_SELF_TESTS_TUBING_LOADED_CHECK_STATE': ['tubing loaded check'], - 'DRY_SELF_TESTS_TUBING_SET_AUTHENTICATION_STATE': ['tubing set authentication', 'tubing authentication'], - 'DRY_SELF_TESTS_SYRINGE_PUMP_SEEK_STATE': ['srynge pump seek', 'pump seek'], - 'DRY_SELF_TESTS_PRESSURE_SENSORS_NORMAL_SETUP_STATE': ['pressure sensors normal setup'], - 'DRY_SELF_TESTS_PRESSURE_VENOUS_SETUP_STATE': ['pressure venous setup', 'venous setup'], - 'DRY_SELF_TESTS_VENOUS_PRESSURE_STABILIZATION_STATE': ['venous pressure stabilization'], - 'DRY_SELF_TESTS_VENOUS_PRESSURE_LEAK_CHECK_STATE': ['venous pressure leak check'], - 'DRY_SELF_TESTS_VENOUS_PRESSURE_RELIEF_STATE': ['venous pressure relief'], - 'DRY_SELF_TESTS_PRESSURE_ARTERIAL_SETUP_STATE': ['pressure arterial setup', 'arterial setup'], - 'DRY_SELF_TESTS_ARTERIAL_PRESSURE_STABILIZATION_STATE': ['arterial pressure stabilization'], - 'DRY_SELF_TESTS_ARTERIAL_PRESSURE_LEAK_CHECK_STATE': ['arterial pressure leak check'], - 'DRY_SELF_TESTS_ARTERIAL_PRESSURE_RELIEF_STATE': ['arterial pressure relief'], - 'DRY_SELF_TESTS_PRESSURE_SENSORS_NORMAL_STATE': ['presusre normal', 'pressure readings'], - 'DRY_SELF_TESTS_SYRINGE_PRIME_STATE': ['srynge prime'], - 'DRY_SELF_TESTS_SYRINGE_PUMP_OCCLUSION_CHECK_STATE': ['srynge pump occlusion check', 'srynge pump check'], - 'DRY_SELF_TESTS_COMPLETE_STATE': ['complete', 'done'], - 'DRY_SELF_TESTS_STOPPED_STATE': ['stop'], + 'WAIT_FOR_DOOR_CLOSE_STATE': ['wait for front door to close', 'wait for door close'], + 'USED_TUBING_CHECK_STATE': ['used tubing check'], + 'TUBING_LOADED_CHECK_STATE': ['tubing loaded check'], + 'TUBING_SET_AUTHENTICATION_STATE': ['tubing set authentication', 'tubing authentication'], + 'SYRINGE_PUMP_SEEK_STATE': ['srynge pump seek', 'pump seek'], + 'PRESSURE_SENSORS_NORMAL_SETUP_STATE': ['pressure sensors normal setup'], + 'PRESSURE_VENOUS_SETUP_STATE': ['pressure venous setup', 'venous setup'], + 'VENOUS_PRESSURE_STABILIZATION_STATE': ['venous pressure stabilization'], + 'VENOUS_PRESSURE_LEAK_CHECK_STATE': ['venous pressure leak check'], + 'VENOUS_PRESSURE_RELIEF_STATE': ['venous pressure relief'], + 'PRESSURE_ARTERIAL_SETUP_STATE': ['pressure arterial setup', 'arterial setup'], + 'ARTERIAL_PRESSURE_STABILIZATION_STATE': ['arterial pressure stabilization'], + 'ARTERIAL_PRESSURE_LEAK_CHECK_STATE': ['arterial pressure leak check'], + 'ARTERIAL_PRESSURE_RELIEF_STATE': ['arterial pressure relief'], + 'PRESSURE_SENSORS_NORMAL_STATE': ['presusre normal', 'pressure readings'], + 'SYRINGE_PRIME_STATE': ['srynge prime'], + 'SYRINGE_PUMP_OCCLUSION_CHECK_STATE': ['srynge pump occlusion check', 'srynge pump check'], + 'COMPLETE_STATE': ['complete', 'done'], + 'STOPPED_STATE': ['stop'], 'NUM_OF_DRY_SELF_TESTS_STATES': [], } -# TDPreTreatmentModesStates.TD_PRE_TREATMENT_PRIME_STATE sub states +# TDPreTreatmentModesStates.PRIME_STATE sub states unique class TDPreTreaPrimeStates(DialinEnum): - 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 + WAIT_FOR_USER_START_STATE = 0 # Wait for user to start prime state + SALINE_SETUP_STATE = 1 # Saline setup state + SALINE_PURGE_AIR_STATE = 2 # Saline purge air state + SALINE_CIRC_BLOOD_CIRCUIT_STATE = 3 # Circulate blood circuit state + RESERVOIR_ONE_FILL_COMPLETE_STATE = 4 # Wait for reservoir 1 fill complete + DIALYSATE_DIALYZER_STATE = 5 # Dialysate dialyzer fluid path state + SALINE_DIALYZER_SETUP_STATE = 6 # Saline dialyzer setup state + SALINE_DIALYZER_STATE = 7 # Saline dialyzer fluid path state + RESERVOIR_TWO_FILL_COMPLETE_STATE = 8 # Wait for reservoir 2 fill complete + DIALYSATE_BYPASS_STATE = 9 # Dialysate bypass fluid path state + WET_SELF_TESTS_STATE = 10 # Perform wet self-tests after priming complete + PAUSE = 11 # Prime pause state, waits to be resumed + COMPLETE = 12 # Prime complete state + NUM_OF_TD_PRIME_STATES = 13 # Number of prime sub-mode states TDPreTreaPrimeStates._str_list = { # Official Name : Accepted strings - 'TD_PRIME_WAIT_FOR_USER_START_STATE': ['wait for user', 'wait for user to start'], - 'TD_PRIME_SALINE_SETUP_STATE': ['saline setup', 'saline bolus setup'], - 'TD_PRIME_SALINE_PURGE_AIR_STATE': ['saline purge air', 'saline bolus air purge'], - 'TD_PRIME_SALINE_CIRC_BLOOD_CIRCUIT_STATE': ['saline circulate blood', 'saline bolus circulate blood'], - 'TD_PRIME_RESERVOIR_ONE_FILL_COMPLETE_STATE': ['reservoir 1 fill complete'], - 'TD_PRIME_DIALYSATE_DIALYZER_STATE': ['dialysate dialyzer', 'dialyzer setup'], - 'TD_PRIME_SALINE_DIALYZER_SETUP_STATE': ['fill dialyzer with saline bolus', 'saline dialyzer setup'], - 'TD_PRIME_SALINE_DIALYZER_STATE': ['saline dialyzer'], - 'TD_PRIME_RESERVOIR_TWO_FILL_COMPLETE_STATE': ['reservoir 2 fill complete'], - 'TD_PRIME_DIALYSATE_BYPASS_STATE': ['dialysate bypass'], - 'TD_PRIME_WET_SELF_TESTS_STATE': ['wet self tests'], - 'TD_PRIME_PAUSE': ['prime paused', 'priming paused'], - 'TD_PRIME_COMPLETE': ['prime completed', 'priming completed'], + 'WAIT_FOR_USER_START_STATE': ['wait for user', 'wait for user to start'], + 'SALINE_SETUP_STATE': ['saline setup', 'saline bolus setup'], + 'SALINE_PURGE_AIR_STATE': ['saline purge air', 'saline bolus air purge'], + 'SALINE_CIRC_BLOOD_CIRCUIT_STATE': ['saline circulate blood', 'saline bolus circulate blood'], + 'RESERVOIR_ONE_FILL_COMPLETE_STATE': ['reservoir 1 fill complete'], + 'DIALYSATE_DIALYZER_STATE': ['dialysate dialyzer', 'dialyzer setup'], + 'SALINE_DIALYZER_SETUP_STATE': ['fill dialyzer with saline bolus', 'saline dialyzer setup'], + 'SALINE_DIALYZER_STATE': ['saline dialyzer'], + 'RESERVOIR_TWO_FILL_COMPLETE_STATE': ['reservoir 2 fill complete'], + 'DIALYSATE_BYPASS_STATE': ['dialysate bypass'], + 'WET_SELF_TESTS_STATE': ['wet self tests'], + 'PAUSE': ['prime paused', 'priming paused'], + 'COMPLETE': ['prime completed', 'priming completed'], 'NUM_OF_TD_PRIME_STATES': [], } -# TDPreTreatmentModesStates.TD_PRE_TREATMENT_RECIRCULATE_STATE sub states +# TDPreTreatmentModesStates.RECIRCULATE_STATE sub states @unique class TDPreTreaRecircStates(DialinEnum): PRE_TREATMENT_RECIRC_STATE = 0 # Pre-treatment recirculate state @@ -424,43 +420,43 @@ } -# TDPreTreatmentModesStates.TD_PRE_TREATMENT_PATIENT_CONNECTION_STATE sub states +# TDPreTreatmentModesStates.PATIENT_CONNECTION_STATE sub states @unique class TDPreTreaPatientConnectStates(DialinEnum): - PRE_TREATMENT_PAT_CONN_WAIT_FOR_UF_VOL_STATE = 0 # Pre-treatment patient connect wait for UF volume setting state - PRE_TREATMENT_PAT_CONN_WAIT_FOR_DLZR_INVERT_STATE = 1 # Pre-treatment patient connect wait for dialyzer inverted state - PRE_TREATMENT_PAT_CONN_WAIT_FOR_USER_CONFIRM_STATE = 2 # Pre-treatment patient connect wait for user confirm state - PRE_TREATMENT_PAT_CONN_WAIT_FOR_TREATMENT_START_STATE = 3 # Pre-treatment patient connect wait for treatment start state - NUM_OF_PRE_TREATMENT_PAT_CONN_STATES = 4 # Number of pre-treatment patient connect states + WAIT_FOR_UF_VOL_STATE = 0 # Pre-treatment patient connect wait for UF volume setting state + WAIT_FOR_DLZR_INVERT_STATE = 1 # Pre-treatment patient connect wait for dialyzer inverted state + WAIT_FOR_USER_CONFIRM_STATE = 2 # Pre-treatment patient connect wait for user confirm state + WAIT_FOR_TREATMENT_START_STATE = 3 # Pre-treatment patient connect wait for treatment start state + NUM_OF_PRE_TREATMENT_PAT_CONN_STATES = 4 # Number of pre-treatment patient connect states TDPreTreaPatientConnectStates._str_list = { # Official Name : Accepted strings - 'PRE_TREATMENT_PAT_CONN_WAIT_FOR_UF_VOL_STATE': ['ultrafiltration volume', 'uf volume'], - 'PRE_TREATMENT_PAT_CONN_WAIT_FOR_DLZR_INVERT_STATE': ['dialyzer invert', 'invert'], - 'PRE_TREATMENT_PAT_CONN_WAIT_FOR_USER_CONFIRM_STATE': ['user confirm', 'confirm'], - 'PRE_TREATMENT_PAT_CONN_WAIT_FOR_TREATMENT_START_STATE': ['start'], + 'WAIT_FOR_UF_VOL_STATE': ['ultrafiltration volume', 'uf volume'], + 'WAIT_FOR_DLZR_INVERT_STATE': ['dialyzer invert', 'invert'], + 'WAIT_FOR_USER_CONFIRM_STATE': ['user confirm', 'confirm'], + 'WAIT_FOR_TREATMENT_START_STATE': ['start'], 'NUM_OF_PRE_TREATMENT_PAT_CONN_STATES': [], } -# TDTreatmentStates.TREATMENT_BLOOD_PRIME_STATE sub states +# TDTreatmentStates.BLOOD_PRIME_STATE sub states @unique class TDTreaBloodPrimeStates(DialinEnum): - BLOOD_PRIME_RAMP_STATE = 0 # Ramp state of the blood prime sub-mode state machine - BLOOD_PRIME_RUN_STATE = 1 # Run state of the blood prime sub-mode state machine - BLOOD_PRIME_PAUSED_STATE = 2 # Paused state of the blood prime sub-mode state machine + RAMP_STATE = 0 # Ramp state of the blood prime sub-mode state machine + RUN_STATE = 1 # Run state of the blood prime sub-mode state machine + PAUSED_STATE = 2 # Paused state of the blood prime sub-mode state machine NUM_OF_BLOOD_PRIME_STATES = 3 # Number of blood prime sub-mode states TDTreaBloodPrimeStates._str_list = { # Official Name : Accepted strings - 'BLOOD_PRIME_RAMP_STATE': ['ramp', 'ramping'], - 'BLOOD_PRIME_RUN_STATE': ['running', 'priming'], - 'BLOOD_PRIME_PAUSED_STATE': ['paused'], + 'RAMP_STATE': ['ramp', 'ramping'], + 'RUN_STATE': ['running', 'priming'], + 'PAUSED_STATE': ['paused'], 'NUM_OF_BLOOD_PRIME_STATES': [], } -# TDTreatmentStates.TREATMENT_DIALYSIS_STATE sub states +# TDTreatmentStates.DIALYSIS_STATE sub states @unique class TDTreaDialysisStates(DialinEnum): DIALYSIS_UF_STATE = 0 # Ultrafiltration state of the dialysis sub-mode state machine @@ -475,70 +471,70 @@ } -# TDTreatmentStates.TREATMENT_PAUSED_STATE sub states +# TDTreatmentStates.PAUSED_STATE sub states @unique class TDTreaPausedStates(DialinEnum): - TREATMENT_PAUSED_RECIRC_STATE = 0 # Dialysate and Blood re-circulation state of the treatment paused sub-mode state machine - TREATMENT_PAUSED_RECIRC_DIALYSATE_ONLY_STATE = 1 # Re-circulate Dialysate only state of the treatment paused sub-mode state machine - TREATMENT_PAUSED_RECIRC_BLOOD_ONLY_STATE = 2 # Re-circulate Blood only state of the treatment paused sub-mode state machine - TREATMENT_PAUSED_NO_RECIRC_STATE = 3 # No re-circulation state of the treatment paused sub-mode state machine - TREATMENT_PAUSED_RECOVER_BLOOD_DETECT_STATE = 4 # Treatment paused recover blood detect state - NUM_OF_TREATMENT_PAUSED_STATES = 5 # Number of treatment paused sub-mode states + RECIRC_STATE = 0 # Dialysate and Blood re-circulation state of the treatment paused sub-mode state machine + RECIRC_DIALYSATE_ONLY_STATE = 1 # Re-circulate Dialysate only state of the treatment paused sub-mode state machine + RECIRC_BLOOD_ONLY_STATE = 2 # Re-circulate Blood only state of the treatment paused sub-mode state machine + NO_RECIRC_STATE = 3 # No re-circulation state of the treatment paused sub-mode state machine + RECOVER_BLOOD_DETECT_STATE = 4 # Treatment paused recover blood detect state + NUM_OF_TREATMENT_PAUSED_STATES = 5 # Number of treatment paused sub-mode states TDTreaPausedStates._str_list = { # Official Name : Accepted strings - 'TREATMENT_PAUSED_RECIRC_STATE': ['recirc'], - 'TREATMENT_PAUSED_RECIRC_DIALYSATE_ONLY_STATE': ['recirc dialysate only'], - 'TREATMENT_PAUSED_RECIRC_BLOOD_ONLY_STATE': ['recirc blood only'], - 'TREATMENT_PAUSED_NO_RECIRC_STATE': ['no recirc'], - 'TREATMENT_PAUSED_RECOVER_BLOOD_DETECT_STATE': ['recover blood detect'], + 'RECIRC_STATE': ['recirc'], + 'RECIRC_DIALYSATE_ONLY_STATE': ['recirc dialysate only'], + 'RECIRC_BLOOD_ONLY_STATE': ['recirc blood only'], + 'NO_RECIRC_STATE': ['no recirc'], + 'RECOVER_BLOOD_DETECT_STATE': ['recover blood detect'], 'NUM_OF_TREATMENT_PAUSED_STATES': [], } -# TDTreatmentStates.TREATMENT_RINSEBACK_STATE sub states +# TDTreatmentStates.RINSEBACK_STATE sub states @unique class TDTreaRinsebackStates(DialinEnum): - RINSEBACK_STOP_INIT_STATE = 0 # Start state (stopped) of the rinseback sub-mode state machine - RINSEBACK_RUN_STATE = 1 # Rinseback running state of the rinseback sub-mode state machine - RINSEBACK_PAUSED_STATE = 2 # Rinseback paused state of the rinseback sub-mode state machine - RINSEBACK_STOP_STATE = 3 # Rinseback stopped (done) state of the rinseback sub-mode state machine - RINSEBACK_RUN_ADDITIONAL_STATE = 4 # Additional rinseback volume (10 mL) state of the rinseback sub-mode state machine - RINSEBACK_RECONNECT_PATIENT_STATE = 5 # Rinseback patient reconnect state of the rinseback sub-mode state machine - NUM_OF_RINSEBACK_STATES = 6 # Number of rinseback sub-mode states + STOP_INIT_STATE = 0 # Start state (stopped) of the rinseback sub-mode state machine + RUN_STATE = 1 # Rinseback running state of the rinseback sub-mode state machine + PAUSED_STATE = 2 # Rinseback paused state of the rinseback sub-mode state machine + STOP_STATE = 3 # Rinseback stopped (done) state of the rinseback sub-mode state machine + RUN_ADDITIONAL_STATE = 4 # Additional rinseback volume (10 mL) state of the rinseback sub-mode state machine + RECONNECT_PATIENT_STATE = 5 # Rinseback patient reconnect state of the rinseback sub-mode state machine + NUM_OF_RINSEBACK_STATES = 6 # Number of rinseback sub-mode states TDTreaRinsebackStates._str_list = { # Official Name : Accepted strings - 'RINSEBACK_STOP_INIT_STATE': ['start', 'stop init'], - 'RINSEBACK_RUN_STATE': ['run'], - 'RINSEBACK_PAUSED_STATE': ['paused'], - 'RINSEBACK_STOP_STATE': ['stop'], - 'RINSEBACK_RUN_ADDITIONAL_STATE': ['run additional'], - 'RINSEBACK_RECONNECT_PATIENT_STATE': ['reconnect patient'], + 'STOP_INIT_STATE': ['start', 'stop init'], + 'RUN_STATE': ['run'], + 'PAUSED_STATE': ['paused'], + 'STOP_STATE': ['stop'], + 'RUN_ADDITIONAL_STATE': ['run additional'], + 'RECONNECT_PATIENT_STATE': ['reconnect patient'], 'NUM_OF_RINSEBACK_STATES': [], } -# TDTreatmentStates.TREATMENT_RECIRC_STATE sub states +# TDTreatmentStates.RECIRC_STATE sub states @unique class TDTreaRecircStates(DialinEnum): - TREATMENT_RECIRC_DISCONNECT_PATIENT_STATE = 0 # Disconnect patient state of the treatment re-circulate sub-mode state machine - TREATMENT_RECIRC_RECIRC_STATE = 1 # Re-circulate Dialysate state of the treatment re-circulate sub-mode state machine - TREATMENT_RECIRC_STOPPED_STATE = 2 # Stopped state of the treatment re-circulate sub-mode state machine - TREATMENT_RECIRC_RECONNECT_PATIENT_STATE = 3 # Reconnect patient state of the treatment re-circulate sub-mode state machine - NUM_OF_TREATMENT_RECIRC_STATES = 4 # Number of treatment re-circulate sub-mode states + DISCONNECT_PATIENT_STATE = 0 # Disconnect patient state of the treatment re-circulate sub-mode state machine + RECIRC_STATE = 1 # Re-circulate Dialysate state of the treatment re-circulate sub-mode state machine + STOPPED_STATE = 2 # Stopped state of the treatment re-circulate sub-mode state machine + RECONNECT_PATIENT_STATE = 3 # Reconnect patient state of the treatment re-circulate sub-mode state machine + NUM_OF_TREATMENT_RECIRC_STATES = 4 # Number of treatment re-circulate sub-mode states TDTreaRecircStates._str_list = { # Official Name : Accepted strings - 'TREATMENT_RECIRC_DISCONNECT_PATIENT_STATE': ['disconnect patient'], - 'TREATMENT_RECIRC_RECIRC_STATE': ['run', 'recirc'], - 'TREATMENT_RECIRC_STOPPED_STATE': ['paused', 'stopped'], - 'TREATMENT_RECIRC_RECONNECT_PATIENT_STATE': ['reconnect patient'], + 'DISCONNECT_PATIENT_STATE': ['disconnect patient'], + 'RECIRC_STATE': ['run', 'recirc'], + 'STOPPED_STATE': ['paused', 'stopped'], + 'RECONNECT_PATIENT_STATE': ['reconnect patient'], 'NUM_OF_TREATMENT_RECIRC_STATES': [], } -# TDTreatmentStates.TREATMENT_SALINE_BOLUS_STATE sub states +# TDTreatmentStates.SALINE_BOLUS_STATE sub states @unique class TDTreaBolusStates(DialinEnum): SALINE_BOLUS_STATE_IDLE = 0 # No saline bolus delivery is in progress @@ -558,183 +554,204 @@ # TDTreatmentStates. sub states @unique class TDTreaHeparinStates(DialinEnum): - HEPARIN_STATE_OFF = 0 # No heparin delivery is in progress - HEPARIN_STATE_STOPPED = 1 # Heparin delivery stopped by alarm or not yet started - HEPARIN_STATE_PAUSED = 2 # Heparin delivery paused - HEPARIN_STATE_INITIAL_BOLUS = 3 # Initial heparin bolus delivery in progress - HEPARIN_STATE_DISPENSING = 4 # Gradual heparin dispensing in progress - HEPARIN_STATE_COMPLETED = 5 # Heparin delivery stopped due to the set stop time before treatment end - HEPARIN_STATE_EMPTY = 6 # Heparin Syringe empty - NUM_OF_HEPARIN_STATES = 7 # Number of saline bolus states + OFF = 0 # No heparin delivery is in progress + STOPPED = 1 # Heparin delivery stopped by alarm or not yet started + PAUSED = 2 # Heparin delivery paused + INITIAL_BOLUS = 3 # Initial heparin bolus delivery in progress + DISPENSING = 4 # Gradual heparin dispensing in progress + COMPLETED = 5 # Heparin delivery stopped due to the set stop time before treatment end + EMPTY = 6 # Heparin Syringe empty + NUM_OF_HEPARIN_STATES = 7 # Number of heparin states TDTreaHeparinStates._str_list = { # Official Name : Accepted strings - 'DIALYSIS_UF_STATE': ['ultrafiltration state'], - 'DIALYSIS_UF_PAUSED_STATE': ['paused', 'ultrafiltration paused'], - 'NUM_OF_DIALYSIS_STATES': [], + 'OFF': [], + 'STOPPED': [], + 'PAUSED': [], + 'INITIAL_BOLUS': [], + 'DISPENSING': [], + 'COMPLETED': [], + 'EMPTY': [], + 'NUM_OF_HEPARIN_STATES': [], } + # Syringe pump states @unique class TDTreaSyringePumpStates(DialinEnum): - SYRINGE_PUMP_INIT_STATE = 0 # Syringe pump initialize state - SYRINGE_PUMP_OFF_STATE = 1 # Syringe pump off state - SYRINGE_PUMP_RETRACT_STATE = 2 # Syringe pump retract state - SYRINGE_PUMP_PRELOAD_STATE = 3 # Syringe pump preload state - SYRINGE_PUMP_SEEK_STATE = 4 # Syringe pump seek state - SYRINGE_PUMP_PRIME_STATE = 5 # Syringe pump prime state - SYRINGE_PUMP_HEP_BOLUS_STATE = 6 # Syringe pump bolus state - SYRINGE_PUMP_HEP_CONTINUOUS_STATE = 7 # Syringe pump continuous state - SYRINGE_PUMP_CONFIG_FORCE_SENSOR_STATE = 8 # Syringe pump configure force sensor state + INIT_STATE = 0 # Syringe pump initialize state + OFF_STATE = 1 # Syringe pump off state + RETRACT_STATE = 2 # Syringe pump retract state + PRELOAD_STATE = 3 # Syringe pump preload state + SEEK_STATE = 4 # Syringe pump seek state + PRIME_STATE = 5 # Syringe pump prime state + HEP_BOLUS_STATE = 6 # Syringe pump bolus state + HEP_CONTINUOUS_STATE = 7 # Syringe pump continuous state + CONFIG_FORCE_SENSOR_STATE = 8 # Syringe pump configure force sensor state + NUM_OF_SYRINGE_PUMP_STATES = 9 # Number of syringe pump states +TDTreaSyringePumpStates._str_list = { + # Official Name : Accepted strings + 'INIT_STATE': ['init'], + 'OFF_STATE': ['off'], + 'RETRACT_STATE': ['retract'], + 'PRELOAD_STATE': ['preload'], + 'SEEK_STATE': ['seek'], + 'PRIME_STATE': ['prime'], + 'HEP_BOLUS_STATE': ['hep bolus', 'heparin start', 'heparin bolus'], + 'HEP_CONTINUOUS_STATE': ['hep continuous', 'heparin continuous', 'heparin resume'], + 'CONFIG_FORCE_SENSOR_STATE': ['config force sensor'], + 'NUM_OF_SYRINGE_PUMP_STATES': [], +} -# TDTreatmentStates.TREATMENT_END_STATE sub states + +# TDTreatmentStates.END_STATE sub states @unique class TDTreaEndStates(DialinEnum): - TREATMENT_END_WAIT_FOR_RINSEBACK_STATE = 0 # Wait for rinseback state of the treatment end sub-mode state machine - TREATMENT_END_PAUSED_STATE = 1 # Paused state of the treatment end sub-mode state machine - NUM_OF_TREATMENT_END_STATES = 2 # Number of treatment end sub-mode states + WAIT_FOR_RINSEBACK_STATE = 0 # Wait for rinseback state of the treatment end sub-mode state machine + PAUSED_STATE = 1 # Paused state of the treatment end sub-mode state machine + NUM_OF_TREATMENT_END_STATES = 2 # Number of treatment end sub-mode states TDTreaEndStates._str_list = { # Official Name : Accepted strings - 'TREATMENT_END_WAIT_FOR_RINSEBACK_STATE': ['wait for rinseback'], - 'TREATMENT_END_PAUSED_STATE': ['paused'], + 'WAIT_FOR_RINSEBACK_STATE': ['wait for rinseback'], + 'PAUSED_STATE': ['paused'], 'NUM_OF_TREATMENT_END_STATES': [], } # ================================================== Enum Creators: Operations Lvl 4 ================================================== -# TDPreTreatmentModesStates.TD_PRE_TREATMENT_WATER_SAMPLE_STATE.SAMPLE_WATER_STATE sub states +# TDPreTreatmentModesStates.WATER_SAMPLE_STATE.SAMPLE_WATER_STATE sub states @unique class TDPreTreaSamplWaterUserActionStates(DialinEnum): - REQUESTED_USER_ACTION_SAMPLE_WATER_STOP = 0 # User requests to stop sample water - REQUESTED_USER_ACTION_SAMPLE_WATER_START = 1 # User requests to start sample water + STOP = 0 # User requests to stop sample water + START = 1 # User requests to start sample water NUM_OF_REQUESTED_SAMPLE_WATER_USER_ACTIONS = 2 # Number of requested sample water user actions TDPreTreaSamplWaterUserActionStates._str_list = { # Official Name : Accepted strings - 'REQUESTED_USER_ACTION_SAMPLE_WATER_STOP': ['stop', 'sample water stop'], - 'REQUESTED_USER_ACTION_SAMPLE_WATER_START': ['start', 'sample water start'], + 'STOP': ['stop', 'sample water stop'], + 'START': ['start', 'sample water start'], 'NUM_OF_REQUESTED_SAMPLE_WATER_USER_ACTIONS': [], } -# TDPreTreatmentModesStates.TDPreTreaPrimeStates.TD_PRIME_WET_SELF_TESTS_STATE sub states +# TDPreTreatmentModesStates.TDPreTreaPrimeStates.WET_SELF_TESTS_STATE sub states @unique class TDWetSelfTestsStates(DialinEnum): - WET_SELF_TESTS_START_STATE = 0 # Wet self-tests starting state. - WET_SELF_TESTS_BUBBLE_CHECK_SETUP_STATE = 1 # Setup for wet air bubble self-test state. - WET_SELF_TESTS_BUBBLE_CHECK_STATE = 2 # Wet self-test air bubble detectors state. - WET_SELF_TESTS_PRIME_CHECK_STATE = 3 # Prime check wet self-tests state, checks for primed patient lines. - WET_SELF_TESTS_BLOOD_LEAK_DETECTOR_DEBUBBLE_STATE = 4 # Blood leak detector debubble state. - WET_SELF_TESTS_BLOOD_LEAK_DETECTOR_STATE = 5 # Blood leak detector self-test state. - WET_SELF_TESTS_FIRST_DISPLACEMENT_SETUP_STATE = 6 # Setup valve and start dialysate pump for first displacement. - WET_SELF_TESTS_FIRST_DISPLACEMENT_STATE = 7 # Fill reservoir 2 with 100 mL of dialysate from reservoir 1 state. - WET_SELF_TESTS_FIRST_DISPLACEMENT_VERIFY_STATE = 8 # After first displacement completed verify state. - WET_SELF_TESTS_SECOND_DISPLACEMENT_SETUP_STATE = 9 # Setup valve and start dialysate pump for second displacement. - WET_SELF_TESTS_SECOND_DISPLACEMENT_STATE = 10 # Fill reservoir 1 with 300 mL of dialysate from reservoir 2 state. - WET_SELF_TESTS_SECOND_DISPLACEMENT_VERIFY_STATE = 11 # After first displacement completed verify state. - WET_SELF_TESTS_STOPPED_STATE = 12 # Wet self-test stopped state. - WET_SELF_TESTS_COMPLETE_STATE = 13 # Wet self-test complete state. - NUM_OF_WET_SELF_TESTS_STATES = 14 # Number of wet self-tests states. + START_STATE = 0 # Wet self-tests starting state. + BUBBLE_CHECK_SETUP_STATE = 1 # Setup for wet air bubble self-test state. + BUBBLE_CHECK_STATE = 2 # Wet self-test air bubble detectors state. + PRIME_CHECK_STATE = 3 # Prime check wet self-tests state, checks for primed patient lines. + BLOOD_LEAK_DETECTOR_DEBUBBLE_STATE = 4 # Blood leak detector debubble state. + BLOOD_LEAK_DETECTOR_STATE = 5 # Blood leak detector self-test state. + FIRST_DISPLACEMENT_SETUP_STATE = 6 # Setup valve and start dialysate pump for first displacement. + FIRST_DISPLACEMENT_STATE = 7 # Fill reservoir 2 with 100 mL of dialysate from reservoir 1 state. + FIRST_DISPLACEMENT_VERIFY_STATE = 8 # After first displacement completed verify state. + SECOND_DISPLACEMENT_SETUP_STATE = 9 # Setup valve and start dialysate pump for second displacement. + SECOND_DISPLACEMENT_STATE = 10 # Fill reservoir 1 with 300 mL of dialysate from reservoir 2 state. + SECOND_DISPLACEMENT_VERIFY_STATE = 11 # After first displacement completed verify state. + STOPPED_STATE = 12 # Wet self-test stopped state. + COMPLETE_STATE = 13 # Wet self-test complete state. + NUM_OF_WET_SELF_TESTS_STATES = 14 # Number of wet self-tests states. TDWetSelfTestsStates._str_list = { # Official Name : Accepted strings - 'WET_SELF_TESTS_START_STATE': ['start'], - 'WET_SELF_TESTS_BUBBLE_CHECK_SETUP_STATE': ['bubble check setup', 'air bubble check setup'], - 'WET_SELF_TESTS_BUBBLE_CHECK_STATE': ['bubble check', 'air bubble check'], - 'WET_SELF_TESTS_PRIME_CHECK_STATE': ['prime check'], - 'WET_SELF_TESTS_BLOOD_LEAK_DETECTOR_DEBUBBLE_STATE': ['blood leak detector debubble'], - 'WET_SELF_TESTS_BLOOD_LEAK_DETECTOR_STATE': ['blood leak detector'], - 'WET_SELF_TESTS_FIRST_DISPLACEMENT_SETUP_STATE': ['first displacement setup'], - 'WET_SELF_TESTS_FIRST_DISPLACEMENT_STATE': ['first displacement', 'first displacement running'], - 'WET_SELF_TESTS_FIRST_DISPLACEMENT_VERIFY_STATE': ['first displacement verify'], - 'WET_SELF_TESTS_SECOND_DISPLACEMENT_SETUP_STATE': ['second displacement setup'], - 'WET_SELF_TESTS_SECOND_DISPLACEMENT_STATE': ['second displacement', 'second displacement running'], - 'WET_SELF_TESTS_SECOND_DISPLACEMENT_VERIFY_STATE': ['second displacement verify'], - 'WET_SELF_TESTS_STOPPED_STATE': ['stopped', 'paused'], - 'WET_SELF_TESTS_COMPLETE_STATE': ['complete', 'done'], + 'START_STATE': ['start'], + 'BUBBLE_CHECK_SETUP_STATE': ['bubble check setup', 'air bubble check setup'], + 'BUBBLE_CHECK_STATE': ['bubble check', 'air bubble check'], + 'PRIME_CHECK_STATE': ['prime check'], + 'BLOOD_LEAK_DETECTOR_DEBUBBLE_STATE': ['blood leak detector debubble'], + 'BLOOD_LEAK_DETECTOR_STATE': ['blood leak detector'], + 'FIRST_DISPLACEMENT_SETUP_STATE': ['first displacement setup'], + 'FIRST_DISPLACEMENT_STATE': ['first displacement', 'first displacement running'], + 'FIRST_DISPLACEMENT_VERIFY_STATE': ['first displacement verify'], + 'SECOND_DISPLACEMENT_SETUP_STATE': ['second displacement setup'], + 'SECOND_DISPLACEMENT_STATE': ['second displacement', 'second displacement running'], + 'SECOND_DISPLACEMENT_VERIFY_STATE': ['second displacement verify'], + 'STOPPED_STATE': ['stopped', 'paused'], + 'COMPLETE_STATE': ['complete', 'done'], 'NUM_OF_WET_SELF_TESTS_STATES': [], } -# TDTreatmentStates.TREATMENT_BLOOD_PRIME_STATE.BLOOD_PRIME_RUN_STATE sub states +# TDTreatmentStates.BLOOD_PRIME_STATE.BLOOD_PRIME_RUN_STATE sub states @unique class TDTreaBloodPrimeUserActionStates(DialinEnum): - REQUESTED_USER_ACTION_BLOOD_PRIME_PAUSE = 0 # User requests to pause blood prime operation - REQUESTED_USER_ACTION_BLOOD_PRIME_RESUME = 1 # User requests to resume blood prime operation + PAUSE = 0 # User requests to pause blood prime operation + RESUME = 1 # User requests to resume blood prime operation NUM_OF_REQUESTED_BLOOD_PRIME_USER_ACTIONS = 2 # Number of requested blood prime user actions TDTreaBloodPrimeUserActionStates._str_list = { # Official Name : Accepted strings - 'REQUESTED_USER_ACTION_BLOOD_PRIME_PAUSE': ['stop', 'pause'], - 'REQUESTED_USER_ACTION_BLOOD_PRIME_RESUME': ['run', 'resume'], + 'PAUSE': ['stop', 'pause'], + 'RESUME': ['run', 'resume'], 'NUM_OF_REQUESTED_BLOOD_PRIME_USER_ACTIONS': [], } # TDTreatmentStates.TDTreaRinsebackStates.RINSEBACK_RUN_STATE sub states @unique class TDTreaRinsebackUserActionStates(DialinEnum): - REQUESTED_USER_ACTION_RINSEBACK_CONFIRM_START = 0 # User confirms saline bag clamped, connected to end of arterial line, un-clamped, and ready to start rinseback operation - REQUESTED_USER_ACTION_RINSEBACK_INCREASE_RATE = 1 # User requests increase in rinseback flow rate - REQUESTED_USER_ACTION_RINSEBACK_DECREASE_RATE = 2 # User requests decrease in rinseback flow rate - REQUESTED_USER_ACTION_RINSEBACK_PAUSE = 3 # User requests to pause rinseback operation - REQUESTED_USER_ACTION_RINSEBACK_RESUME = 4 # User requests to resume rinseback operation - REQUESTED_USER_ACTION_RINSEBACK_END = 5 # User requests to end the rinseback operation - REQUESTED_USER_ACTION_RINSEBACK_ADDITIONAL = 6 # User requests an additional 10 mL of rinseback volume - REQUESTED_USER_ACTION_RINSEBACK_CONFIRM_DISCONNECT = 7 # User confirms patient disconnected, saline bag clamped, re-connected to VBA, un-clamped, and lines shunted to start re-circulation - REQUESTED_USER_ACTION_RINSEBACK_END_TREATMENT = 8 # User requests to end treatment - REQUESTED_USER_ACTION_RINSEBACK_BACK_TO_TREATMENT = 9 # User requests to return to treatment - NUM_OF_REQUESTED_RINSEBACK_USER_ACTIONS = 10 # Number of requested rinseback user actions + CONFIRM_START = 0 # User confirms saline bag clamped, connected to end of arterial line, un-clamped, and ready to start rinseback operation + INCREASE_RATE = 1 # User requests increase in rinseback flow rate + DECREASE_RATE = 2 # User requests decrease in rinseback flow rate + PAUSE = 3 # User requests to pause rinseback operation + RESUME = 4 # User requests to resume rinseback operation + END = 5 # User requests to end the rinseback operation + ADDITIONAL = 6 # User requests an additional 10 mL of rinseback volume + CONFIRM_DISCONNECT = 7 # User confirms patient disconnected, saline bag clamped, re-connected to VBA, un-clamped, and lines shunted to start re-circulation + END_TREATMENT = 8 # User requests to end treatment + BACK_TO_TREATMENT = 9 # User requests to return to treatment + NUM_OF_REQUESTED_RINSEBACK_USER_ACTIONS = 10 # Number of requested rinseback user actions TDTreaRinsebackUserActionStates._str_list = { # Official Name : Accepted strings - 'REQUESTED_USER_ACTION_RINSEBACK_CONFIRM_START': ['start', 'confirm start'], - 'REQUESTED_USER_ACTION_RINSEBACK_INCREASE_RATE': ['increase rate', 'increase rinseback flow rate'], - 'REQUESTED_USER_ACTION_RINSEBACK_DECREASE_RATE': ['decrease rate', 'decrease rinseback flow rate'], - 'REQUESTED_USER_ACTION_RINSEBACK_PAUSE': ['pause', 'paused'], - 'REQUESTED_USER_ACTION_RINSEBACK_RESUME': ['resume', 'resume rinseback'], - 'REQUESTED_USER_ACTION_RINSEBACK_END': ['end', 'end rinseback'], - 'REQUESTED_USER_ACTION_RINSEBACK_ADDITIONAL': ['additional rinseback', 'additional 10ml', 'extra 10ml'], - 'REQUESTED_USER_ACTION_RINSEBACK_CONFIRM_DISCONNECT': ['confirm disconnect', 'confirm patient disconnect'], - 'REQUESTED_USER_ACTION_RINSEBACK_END_TREATMENT': ['end treatment'], - 'REQUESTED_USER_ACTION_RINSEBACK_BACK_TO_TREATMENT': ['back to treatment'], + 'CONFIRM_START': ['start', 'confirm start'], + 'INCREASE_RATE': ['increase rate', 'increase rinseback flow rate'], + 'DECREASE_RATE': ['decrease rate', 'decrease rinseback flow rate'], + 'PAUSE': ['pause', 'paused'], + 'RESUME': ['resume', 'resume rinseback'], + 'END': ['end', 'end rinseback'], + 'ADDITIONAL': ['additional rinseback', 'additional 10ml', 'extra 10ml'], + 'CONFIRM_DISCONNECT': ['confirm disconnect', 'confirm patient disconnect'], + 'END_TREATMENT': ['end treatment'], + 'BACK_TO_TREATMENT': ['back to treatment'], 'NUM_OF_REQUESTED_RINSEBACK_USER_ACTIONS': [], } # TDTreatmentStates.TDTreaRinsebackStates.RINSEBACK_RUN_STATE sub states @unique class TDTreaRecircUserActionStates(DialinEnum): - REQUESTED_USER_ACTION_TX_RECIRC_RECONNECT = 0 # User requests to re-connect to system (stop re-circulating, clamp arterial and venous lines) - REQUESTED_USER_ACTION_TX_RECIRC_CONFIRM_RECONNECT = 1 # User confirms patient connected, lines un-shunted to return to treatment - REQUESTED_USER_ACTION_TX_RECIRC_RESUME_RC = 2 # User requests to resume re-circulation - REQUESTED_USER_ACTION_TX_RECIRC_END_TREATMENT = 3 # User requests to end treatment - REQUESTED_USER_ACTION_TX_RECIRC_CONFIRM_DISCONNECT = 4 # User confirms patient disconnected, lines shunted to begin re-circulation - NUM_OF_REQUESTED_TX_RECIRC_USER_ACTIONS = 5 # Number of requested treatment re-circ user actions + RECONNECT = 0 # User requests to re-connect to system (stop re-circulating, clamp arterial and venous lines) + CONFIRM_RECONNECT = 1 # User confirms patient connected, lines un-shunted to return to treatment + RESUME_RC = 2 # User requests to resume re-circulation + END_TREATMENT = 3 # User requests to end treatment + CONFIRM_DISCONNECT = 4 # User confirms patient disconnected, lines shunted to begin re-circulation + NUM_OF_REQUESTED_TX_RECIRC_USER_ACTIONS = 5 # Number of requested treatment re-circ user actions TDTreaRecircUserActionStates._str_list = { # Official Name : Accepted strings - 'REQUESTED_USER_ACTION_TX_RECIRC_RECONNECT': ['reconnect to system'], - 'REQUESTED_USER_ACTION_TX_RECIRC_CONFIRM_RECONNECT': ['confirm patient reconnect'], - 'REQUESTED_USER_ACTION_TX_RECIRC_RESUME_RC': ['resume', 'resume recirculation'], - 'REQUESTED_USER_ACTION_TX_RECIRC_END_TREATMENT': ['end treatment', 'request end treatment'], - 'REQUESTED_USER_ACTION_TX_RECIRC_CONFIRM_DISCONNECT': ['confirm patient disconnect'], + 'RECONNECT': ['reconnect to system'], + 'CONFIRM_RECONNECT': ['confirm patient reconnect'], + 'RESUME_RC': ['resume', 'resume recirculation'], + 'END_TREATMENT': ['end treatment', 'request end treatment'], + 'CONFIRM_DISCONNECT': ['confirm patient disconnect'], 'NUM_OF_REQUESTED_TX_RECIRC_USER_ACTIONS': [], } # TDTreatmentStates.TDTreaRinsebackStates.RINSEBACK_RUN_STATE sub states @unique class TDTreaEndUserActionStates(DialinEnum): - REQUESTED_USER_ACTION_TX_END_RINSEBACK_START = 0 # User requests to re-connect to system (stop re-circulating, clamp arterial and venous lines) - NUM_OF_REQUESTED_TX_END_USER_ACTIONS = 1 # Number of requested treatment re-circ user actions + RINSEBACK_START = 0 # User requests to re-connect to system (stop re-circulating, clamp arterial and venous lines) + NUM_OF_REQUESTED_TX_END_USER_ACTIONS = 1 # Number of requested treatment re-circ user actions TDTreaEndUserActionStates._str_list = { # Official Name : Accepted strings - 'REQUESTED_USER_ACTION_TX_END_RINSEBACK_START': ['start', 'end rinseback start'], + 'RINSEBACK_START': ['start', 'end rinseback start'], 'NUM_OF_REQUESTED_TX_END_USER_ACTIONS': [], } @@ -743,63 +760,63 @@ # ================================================== Enum Creators: Events ================================================== @unique class TDEventList(DialinEnum): - 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_TUBESET_RESULT = 3 # TD dry self test cartridge result - TD_EVENT_TUBING_SET_BARCODE_SCAN_REQUEST = 4 # TD tubing set barcode scan request - TD_EVENT_TUBING_SET_BARCODE_SCAN_AUTHENTICATED = 5 # TD tubing set barcode scan authenticated - TD_EVENT_DRY_SELF_TEST_PRESSURE_RESULT = 6 # TD dry self test pressure result - TD_EVENT_WET_SELF_TEST_DISPLACEMENT_RESULT = 7 # TD wet self test displacement result - TD_EVENT_CPU_RAM_ERROR_STATUS = 8 # TD CPU RAM error status - TD_EVENT_CAL_RECORD_UPDATE = 9 # TD new calibration record updated - TD_EVENT_SYSTEM_RECORD_UPDATE = 10 # TD new system record has been updated - TD_EVENT_SERVICE_UPDATE = 11 # TD new service record has been updated - TD_EVENT_USAGE_INFO_UPDATE = 12 # TD new usage information has been updated - TD_EVENT_SW_CONFIG_UPDATE = 13 # TD new software configuration has been updated - TD_EVENT_BUTTON = 14 # TD button pressed/released - TD_EVENT_SAFETY_LINE = 15 # TD safety line pulled/released - TD_EVENT_SUB_STATE_CHANGE = 16 # TD Op sub-state change event - TD_EVENT_RSRVR_UF_RATE = 17 # TD ultrafiltration measured and expected rates - TD_EVENT_OPERATION_STATUS = 18 # TD aggregated opmode, submode, and substate event. - TD_EVENT_AIR_TRAP_FILL = 19 # TD started/stopped an air trap fill operation. - TD_EVENT_AIR_TRAP_LOWER = 20 # TD started/stopped an air trap lower level operation. - TD_EVENT_AIR_PUMP_ON_OFF = 21 # TD turned air pump on/off. - TD_EVENT_INSTIT_RECORD_UPDATE = 22 # TD new institutional record has been updated. - TD_EVENT_VALVE_POS_CHANGE = 23 # TD pinch valve position change - TD_EVENT_VALVE_HOMED_POS_SETTING = 24 # TD pinch valve homed encoder positions for A/B/C. - TD_EVENT_SYRINGE_PUMP_STATE = 25 # TD syringe pump state change event - NUM_OF_EVENT_IDS = 26 # Total number of TD events + STARTUP = 0 # TD startup event + OP_MODE_CHANGE = 1 # TD Op mode change event + SUB_MODE_CHANGE = 2 # TD Op sub-mode change event + DRY_SELF_TEST_TUBESET_RESULT = 3 # TD dry self test cartridge result + TUBING_SET_BARCODE_SCAN_REQUEST = 4 # TD tubing set barcode scan request + TUBING_SET_BARCODE_SCAN_AUTHENTICATED = 5 # TD tubing set barcode scan authenticated + DRY_SELF_TEST_PRESSURE_RESULT = 6 # TD dry self test pressure result + WET_SELF_TEST_DISPLACEMENT_RESULT = 7 # TD wet self test displacement result + CPU_RAM_ERROR_STATUS = 8 # TD CPU RAM error status + CAL_RECORD_UPDATE = 9 # TD new calibration record updated + SYSTEM_RECORD_UPDATE = 10 # TD new system record has been updated + SERVICE_UPDATE = 11 # TD new service record has been updated + USAGE_INFO_UPDATE = 12 # TD new usage information has been updated + SW_CONFIG_UPDATE = 13 # TD new software configuration has been updated + BUTTON = 14 # TD button pressed/released + SAFETY_LINE = 15 # TD safety line pulled/released + SUB_STATE_CHANGE = 16 # TD Op sub-state change event + RSRVR_UF_RATE = 17 # TD ultrafiltration measured and expected rates + OPERATION_STATUS = 18 # TD aggregated opmode, submode, and substate event. + AIR_TRAP_FILL = 19 # TD started/stopped an air trap fill operation. + AIR_TRAP_LOWER = 20 # TD started/stopped an air trap lower level operation. + AIR_PUMP_ON_OFF = 21 # TD turned air pump on/off. + INSTIT_RECORD_UPDATE = 22 # TD new institutional record has been updated. + VALVE_POS_CHANGE = 23 # TD pinch valve position change + VALVE_HOMED_POS_SETTING = 24 # TD pinch valve homed encoder positions for A/B/C. + SYRINGE_PUMP_STATE = 25 # TD syringe pump state change event + NUM_OF_EVENT_IDS = 26 # Total number of TD events TDEventList._str_list = { # Official Name : Accepted strings - 'TD_EVENT_STARTUP': ['startup'], - 'TD_EVENT_OP_MODE_CHANGE': ['op mode change', 'operation mode change'], - 'TD_EVENT_SUB_MODE_CHANGE': ['sub mode change'], - 'TD_EVENT_DRY_SELF_TEST_TUBESET_RESULT': ['dry self test tubeset result'], - 'TD_EVENT_TUBING_SET_BARCODE_SCAN_REQUEST': ['barcode authentication request'], - 'TD_EVENT_TUBING_SET_BARCODE_SCAN_AUTHENTICATED': ['barcode authentication result'], - 'TD_EVENT_DRY_SELF_TEST_PRESSURE_RESULT': ['dry self test pressure result'], - 'TD_EVENT_WET_SELF_TEST_DISPLACEMENT_RESULT': ['wet self test displacement result'], - 'TD_EVENT_CPU_RAM_ERROR_STATUS': ['cpu ram error'], - 'TD_EVENT_CAL_RECORD_UPDATE': ['cal record update', 'calibration record update'], - 'TD_EVENT_SYSTEM_RECORD_UPDATE': ['system record update'], - 'TD_EVENT_SERVICE_UPDATE': ['service update', 'service record update'], - 'TD_EVENT_USAGE_INFO_UPDATE': ['usage info update'], - 'TD_EVENT_SW_CONFIG_UPDATE': ['sw config update', 'software config update'], - 'TD_EVENT_BUTTON': ['button', 'button press', 'button release'], - 'TD_EVENT_SAFETY_LINE': ['safety line'], - 'TD_EVENT_SUB_STATE_CHANGE': ['sub state change'], - 'TD_EVENT_RSRVR_UF_RATE': ['rsrvr uf rate', 'ultrafiltration rate change'], - 'TD_EVENT_OPERATION_STATUS': ['operation status'], - 'TD_EVENT_AIR_TRAP_FILL': ['air trap fill'], - 'TD_EVENT_AIR_TRAP_LOWER': ['air trap lower'], - 'TD_EVENT_AIR_PUMP_ON_OFF': ['air pump', 'air pump on', 'air pump off'], - 'TD_EVENT_DRY_SELF_TEST_PRESSURE_DECAY_WAIT_PERIOD': ['dry self test pressure decay wait period'], - 'TD_EVENT_INSTIT_RECORD_UPDATE': ['instit record update', 'institutional record update'], - 'TD_EVENT_VALVE_POS_CHANGE': ['valve position change', 'valve pos change'], - 'TD_EVENT_VALVE_HOMED_POS_SETTING': ['valve homed to positions'], - 'TD_EVENT_SYRINGE_PUMP_STATE': ['syringe pump state'], + 'STARTUP': ['startup'], + 'OP_MODE_CHANGE': ['op mode change', 'operation mode change'], + 'SUB_MODE_CHANGE': ['sub mode change'], + 'DRY_SELF_TEST_TUBESET_RESULT': ['dry self test tubeset result'], + 'TUBING_SET_BARCODE_SCAN_REQUEST': ['barcode authentication request'], + 'TUBING_SET_BARCODE_SCAN_AUTHENTICATED': ['barcode authentication result'], + 'DRY_SELF_TEST_PRESSURE_RESULT': ['dry self test pressure result'], + 'WET_SELF_TEST_DISPLACEMENT_RESULT': ['wet self test displacement result'], + 'CPU_RAM_ERROR_STATUS': ['cpu ram error'], + 'CAL_RECORD_UPDATE': ['cal record update', 'calibration record update'], + 'SYSTEM_RECORD_UPDATE': ['system record update'], + 'SERVICE_UPDATE': ['service update', 'service record update'], + 'USAGE_INFO_UPDATE': ['usage info update'], + 'SW_CONFIG_UPDATE': ['sw config update', 'software config update'], + 'BUTTON': ['button', 'button press', 'button release'], + 'SAFETY_LINE': ['safety line'], + 'SUB_STATE_CHANGE': ['sub state change'], + 'RSRVR_UF_RATE': ['rsrvr uf rate', 'ultrafiltration rate change'], + 'OPERATION_STATUS': ['operation status'], + 'AIR_TRAP_FILL': ['air trap fill'], + 'AIR_TRAP_LOWER': ['air trap lower'], + 'AIR_PUMP_ON_OFF': ['air pump', 'air pump on', 'air pump off'], + 'DRY_SELF_TEST_PRESSURE_DECAY_WAIT_PERIOD': ['dry self test pressure decay wait period'], + 'INSTIT_RECORD_UPDATE': ['instit record update', 'institutional record update'], + 'VALVE_POS_CHANGE': ['valve position change', 'valve pos change'], + 'VALVE_HOMED_POS_SETTING': ['valve homed to positions'], + 'SYRINGE_PUMP_STATE': ['syringe pump state'], 'NUM_OF_EVENT_IDS': [], } @@ -891,6 +908,18 @@ @unique +class TDBloodPumpNames(DialinEnum): + H4_MOTOR = 0 # TD Blood Pump + NUM_OF_BLOOD_PUMPS = 1 # Number of Blood Pumps + +TDBloodPumpNames._str_list = { + # Official Name : Accepted strings + 'H4_MOTOR': ['h4', 'blood pump', 'blood flow motor'], + 'NUM_OF_BLOOD_PUMPS': [], +} + + +@unique class TDEjectorNames(DialinEnum): H5_MOTOR = 0 # TD Ejector Motor NUM_OF_EJECTOR_MOTORS = 1 # Number of Ejector Motors @@ -943,6 +972,18 @@ @unique +class TDSyringePumpNames(DialinEnum): + H10_PUMP = 0 # TD Syringe Pump + NUM_OF_SYRINGE_PUMPS = 1 # Number of Syringe Pumps + +TDSyringePumpNames._str_list = { + # Official Name : Accepted strings + 'H10_PUMP': ['h10', 'syringe pump'], + 'NUM_OF_SYRINGE_PUMPS': [], +} + + +@unique class TDValveNames(DialinEnum): H1_VALV = 0 # H1 Valve for TD H19_VALV = 1 # H19 Valve for TD @@ -1015,15 +1056,15 @@ class TDAirPumpStates(DialinEnum): - AIR_PUMP_STATE_INIT = 0 # Air Pump Initialize state - AIR_PUMP_STATE_OFF = 1 # Air Pump Off state - AIR_PUMP_STATE_ON = 2 # Air Pump On state + INIT = 0 # Air Pump Initialize state + OFF = 1 # Air Pump Off state + ON = 2 # Air Pump On state NUM_OF_AIR_PUMP_STATES = 3 # Number of air pump states TDAirPumpStates._str_list = { - 'AIR_PUMP_STATE_INIT': ['init'], - 'AIR_PUMP_STATE_OFF': ['off'], - 'AIR_PUMP_STATE_ON': ['on'], + 'INIT': ['init'], + 'OFF': ['off'], + 'ON': ['on'], 'NUM_OF_AIR_PUMP_STATES ': [] } @@ -1118,28 +1159,28 @@ @unique class TDEjectorStates(DialinEnum): - EJECTOR_STATE_INIT = 0 # Ejector Initial (un-homed) state - EJECTOR_STATE_HOMING = 1 # Ejector Homing state - EJECTOR_STATE_RETRACTED = 2 # Ejector Retracted state - EJECTOR_STATE_EXTENDED = 3 # Ejector Extended state - EJECTOR_STATE_RETRACTING = 4 # Ejector Retracting state - EJECTOR_STATE_EXTENDING = 5 # Ejector Extending state - EJECTOR_STATE_DIR_CHANGE_STOP = 6 # Ejector Direction Change Stop state - EJECTOR_STATE_RETRACT_BACKOFF = 7 # Ejector Backing Off Retracted state - EJECTOR_STATE_ABORT = 8 # Ejector abort state - NUM_OF_EJECTOR_STATES = 9 # Number of ejector states + INIT = 0 # Ejector Initial (un-homed) state + HOMING = 1 # Ejector Homing state + RETRACTED = 2 # Ejector Retracted state + EXTENDED = 3 # Ejector Extended state + RETRACTING = 4 # Ejector Retracting state + EXTENDING = 5 # Ejector Extending state + DIR_CHANGE_STOP = 6 # Ejector Direction Change Stop state + RETRACT_BACKOFF = 7 # Ejector Backing Off Retracted state + ABORT = 8 # Ejector abort state + NUM_OF_EJECTOR_STATES = 9 # Number of ejector states TDEjectorStates._str_list = { # Official Name : Accepted strings - 'EJECTOR_STATE_INIT': ['init'], - 'EJECTOR_STATE_HOMING': ['homing'], - 'EJECTOR_STATE_RETRACTED': ['retracted'], - 'EJECTOR_STATE_EXTENDED': ['extended'], - 'EJECTOR_STATE_RETRACTING': ['retracting'], - 'EJECTOR_STATE_EXTENDING': ['extending'], - 'EJECTOR_STATE_DIR_CHANGE_STOP': ['dir chage stop', 'direction change stop'], - 'EJECTOR_STATE_RETRACT_BACKOFF': ['retract backoff', 'backing off'], - 'EJECTOR_STATE_ABORT': ['abort'], + 'INIT': ['init'], + 'HOMING': ['homing'], + 'RETRACTED': ['retracted'], + 'EXTENDED': ['extended'], + 'RETRACTING': ['retracting'], + 'EXTENDING': ['extending'], + 'DIR_CHANGE_STOP': ['dir chage stop', 'direction change stop'], + 'RETRACT_BACKOFF': ['retract backoff', 'backing off'], + 'ABORT': ['abort'], 'NUM_OF_EJECTOR_STATES': [], } @@ -1175,6 +1216,7 @@ 'NUM_OF_SWITCH_STATES': [], } + # Syringe pump operations @unique class TDSyringePumpStates(DialinEnum): @@ -1239,56 +1281,56 @@ # ================================================== Enum Creators: Treatment Parameters ================================================== @unique class TDTreatmentParameters(DialinEnum): - TREATMENT_PARAM_TREATMENT_MODALITY = 0 # Treatment modality type (enum) - TREATMENT_PARAM_HDF_DILUTION = 1 # HDF dilution (enum) - TREATMENT_PARAM_BLOOD_FLOW = 2 # Blood flow rate (in mL/min) - TREATMENT_PARAM_DIALYSATE_FLOW = 3 # Dialysate flow rate (in mL/min) - TREATMENT_PARAM_TREATMENT_DURATION = 4 # Treatment duration (in minutes) - TREATMENT_PARAM_HEPARIN_DELIVERY_DURATION = 5 # Heparin delivery duration (in minutes) - TREATMENT_PARAM_HEPARIN_TYPE = 6 # Heparin type (enum) - TREATMENT_PARAM_DRY_BICARB_CART_SIZE = 7 # Dry bicarb cartrideg size (enum) - TREATMENT_PARAM_SODIUM = 8 # Sodium concentrate (mEq/L) - TREATMENT_PARAM_BICARB_CONCENTRATE = 9 # Bicarbonate concentrate (mEq/L) - TREATMENT_PARAM_DIALYZER_TYPE = 10 # Dialysate type (enum) - TREATMENT_PARAM_FLUID_BOLUS_VOLUME = 11 # Fluid bolus volume (in mL) - TREATMENT_PARAM_BP_MEAS_INTERVAL = 12 # Blood pressure measurement interval (in minutes) - TREATMENT_PARAM_PRIME_RINSEBACK_VOLUME = 13 # Prime rinseback volume (in mL) - TREATMENT_PARAM_HEPATITIS_B = 14 # Hepatitis B status (enum) - TREATMENT_PARAM_ACID_CONCENTRATE = 15 # Acid concentrate type (enum) - TREATMENT_PARAM_SUBST_FLUID_VOLUME = 16 # Substitution fluid volume (in liters) - TREATMENT_PARAM_HEPARIN_BOLUS_VOLUME = 17 # Heparin bolus volume (in mL) - TREATMENT_PARAM_HEPARIN_DELIVERY_RATE = 18 # Heparin delivery rate (in mL/hr) - TREATMENT_PARAM_DIALYSATE_TEMPERATURE = 19 # Dialysate temperature (in degC) - TREATMENT_PARAM_ACID_CONCENTRATE_CONV_FACTOR = 20 # Acid concentrate conversion factor - TREATMENT_PARAM_PRE_WEIGHT = 21 # Weight of patient prior to treatment - TREATMENT_PARAM_EST_TARGET_WEIGHT = 22 # Estimated target weight of patient post treatment - TREATMENT_PARAM_UF_VOLUME = 23 # Ultrafiltration volume (in liters) - provided separately by UI - NUM_OF_TREATMENT_PARAMS = 24 # Total number of treatment parameters + TREATMENT_MODALITY = 0 # Treatment modality type (enum) + HDF_DILUTION = 1 # HDF dilution (enum) + BLOOD_FLOW = 2 # Blood flow rate (in mL/min) + DIALYSATE_FLOW = 3 # Dialysate flow rate (in mL/min) + TREATMENT_DURATION = 4 # Treatment duration (in minutes) + HEPARIN_DELIVERY_DURATION = 5 # Heparin delivery duration (in minutes) + HEPARIN_TYPE = 6 # Heparin type (enum) + DRY_BICARB_CART_SIZE = 7 # Dry bicarb cartrideg size (enum) + SODIUM = 8 # Sodium concentrate (mEq/L) + BICARB_CONCENTRATE = 9 # Bicarbonate concentrate (mEq/L) + DIALYZER_TYPE = 10 # Dialysate type (enum) + FLUID_BOLUS_VOLUME = 11 # Fluid bolus volume (in mL) + BP_MEAS_INTERVAL = 12 # Blood pressure measurement interval (in minutes) + PRIME_RINSEBACK_VOLUME = 13 # Prime rinseback volume (in mL) + HEPATITIS_B = 14 # Hepatitis B status (enum) + ACID_CONCENTRATE = 15 # Acid concentrate type (enum) + SUBST_FLUID_VOLUME = 16 # Substitution fluid volume (in liters) + HEPARIN_BOLUS_VOLUME = 17 # Heparin bolus volume (in mL) + HEPARIN_DELIVERY_RATE = 18 # Heparin delivery rate (in mL/hr) + DIALYSATE_TEMPERATURE = 19 # Dialysate temperature (in degC) + ACID_CONCENTRATE_CONV_FACTOR = 20 # Acid concentrate conversion factor + PRE_WEIGHT = 21 # Weight of patient prior to treatment + EST_TARGET_WEIGHT = 22 # Estimated target weight of patient post treatment + UF_VOLUME = 23 # Ultrafiltration volume (in liters) - provided separately by UI + NUM_OF_TREATMENT_PARAMS = 24 # Total number of treatment parameters TDTreatmentParameters._str_list = { # Official Name : Accepted strings - 'TREATMENT_PARAM_TREATMENT_MODALITY': ['treatment modality', 'treatment type'], - 'TREATMENT_PARAM_HDF_DILUTION': ['hdf dilution'], - 'TREATMENT_PARAM_BLOOD_FLOW': ['blood flow', 'blood flow rate'], - 'TREATMENT_PARAM_DIALYSATE_FLOW': ['sialysate flow', 'dialysate flow rate'], - 'TREATMENT_PARAM_TREATMENT_DURATION': ['treatment duration'], - 'TREATMENT_PARAM_HEPARIN_DELIVERY_DURATION': ['heparin delivery duration', 'heparin duration'], - 'TREATMENT_PARAM_HEPARIN_TYPE': ['heparin', 'heparin type'], - 'TREATMENT_PARAM_ACID_CONCENTRATE': ['acid', 'acid concentrate'], - 'TREATMENT_PARAM_BICARB_CONCENTRATE': ['bicarb', 'bicarb concentrate'], - 'TREATMENT_PARAM_DIALYZER_TYPE': ['dialyzer', 'dialyzer type'], - 'TREATMENT_PARAM_FLUID_BOLUS_VOLUME': ['fluid bolus volume', 'fluid bolus'], - 'TREATMENT_PARAM_BP_MEAS_INTERVAL': ['blood pressure measure interval', 'bp measure interval'], - 'TREATMENT_PARAM_PRIME_RINSEBACK_VOLUME': ['rinseback volume', 'prime rinseback volume'], - 'TREATMENT_PARAM_HEPATITIS_B': ['hepatitis', 'hepatitis b'], - 'TREATMENT_PARAM_SUBST_FLUID_VOLUME': ['subst fluid volume', 'substitute fluid volume'], - 'TREATMENT_PARAM_HEPARIN_BOLUS_VOLUME': ['heparin volume'], - 'TREATMENT_PARAM_HEPARIN_DELIVERY_RATE': ['heparin delivery rate'], - 'TREATMENT_PARAM_DIALYSATE_TEMPERATURE': ['dialysate temperature'], - 'TREATMENT_PARAM_ACID_CONCENTRATE_CONV_FACTOR': ['acid concentrate conv factor', 'acid concentrate conversion factor'], - 'TREATMENT_PARAM_PRE_WEIGHT': ['pre weight'], - 'TREATMENT_PARAM_EST_TARGET_WEIGHT': ['est target weight', 'target weight', 'estimated target weight'], - 'TREATMENT_PARAM_UF_VOLUME': ['uf volume', 'ultrafiltration volume'], + 'TREATMENT_MODALITY': ['treatment modality', 'treatment type'], + 'HDF_DILUTION': ['hdf dilution'], + 'BLOOD_FLOW': ['blood flow', 'blood flow rate'], + 'DIALYSATE_FLOW': ['sialysate flow', 'dialysate flow rate'], + 'TREATMENT_DURATION': ['treatment duration'], + 'HEPARIN_DELIVERY_DURATION': ['heparin delivery duration', 'heparin duration'], + 'HEPARIN_TYPE': ['heparin', 'heparin type'], + 'ACID_CONCENTRATE': ['acid', 'acid concentrate'], + 'BICARB_CONCENTRATE': ['bicarb', 'bicarb concentrate'], + 'DIALYZER_TYPE': ['dialyzer', 'dialyzer type'], + 'FLUID_BOLUS_VOLUME': ['fluid bolus volume', 'fluid bolus'], + 'BP_MEAS_INTERVAL': ['blood pressure measure interval', 'bp measure interval'], + 'PRIME_RINSEBACK_VOLUME': ['rinseback volume', 'prime rinseback volume'], + 'HEPATITIS_B': ['hepatitis', 'hepatitis b'], + 'SUBST_FLUID_VOLUME': ['subst fluid volume', 'substitute fluid volume'], + 'HEPARIN_BOLUS_VOLUME': ['heparin volume'], + 'HEPARIN_DELIVERY_RATE': ['heparin delivery rate'], + 'DIALYSATE_TEMPERATURE': ['dialysate temperature'], + 'ACID_CONCENTRATE_CONV_FACTOR': ['acid concentrate conv factor', 'acid concentrate conversion factor'], + 'PRE_WEIGHT': ['pre weight'], + 'EST_TARGET_WEIGHT': ['est target weight', 'target weight', 'estimated target weight'], + 'UF_VOLUME': ['uf volume', 'ultrafiltration volume'], 'NUM_OF_TREATMENT_PARAMS': [], } Index: leahi_dialin/common/td_defs_proxy.py =================================================================== diff -u -rfe9a2e5c8668b55697314061af7da4cc70b96931 -r27d9de42c0111c7f369cc335889fe6b988d09cc8 --- leahi_dialin/common/td_defs_proxy.py (.../td_defs_proxy.py) (revision fe9a2e5c8668b55697314061af7da4cc70b96931) +++ leahi_dialin/common/td_defs_proxy.py (.../td_defs_proxy.py) (revision 27d9de42c0111c7f369cc335889fe6b988d09cc8) @@ -21,104 +21,102 @@ class TD_Defs(): # Operation Modes - Lvl 1 - TDOpModes = td_defs.TDOpModes + TDOpModes = td_defs.TDOpModes # Operation Modes - Lvl 2 - TDFaultStates = td_defs.TDFaultStates - TDServiceStates = td_defs.TDServiceStates - TDInitStates = td_defs.TDInitStates - TDStandbyStates = td_defs.TDStandbyStates - TDTreatmentParamStates = td_defs.TDTreatmentParamStates - TDPreTreatmentModesStates = td_defs.TDPreTreatmentModesStates - TDTreatmentStates = td_defs.TDTreatmentStates - TDPostTreatmentStates = td_defs.TDPostTreatmentStates - TDNotLegalStates = td_defs.TDNotLegalStates + TDFaultStates = td_defs.TDFaultStates + TDServiceStates = td_defs.TDServiceStates + TDInitStates = td_defs.TDInitStates + TDStandbyStates = td_defs.TDStandbyStates + TDTreatmentParamStates = td_defs.TDTreatmentParamStates + TDPreTreatmentModesStates = td_defs.TDPreTreatmentModesStates + TDTreatmentStates = td_defs.TDTreatmentStates + TDPostTreatmentStates = td_defs.TDPostTreatmentStates + TDNotLegalStates = td_defs.TDNotLegalStates # Operation Modes - Lvl 3 # Pre-treatment - TDPreTreaSampleWaterStates = td_defs.TDPreTreaSampleWaterStates - TDPreTreaConsumableSelfTestStates = td_defs.TDPreTreaConsumableSelfTestStates - TDPreTreaNoCartSelfTestStates = td_defs.TDPreTreaNoCartSelfTestStates - TDPreTreaDrySelfTestStates = td_defs.TDPreTreaDrySelfTestStates - TDPreTreaPrimeStates = td_defs.TDPreTreaPrimeStates - TDPreTreaRecircStates = td_defs.TDPreTreaRecircStates - TDPreTreaPatientConnectStates = td_defs.TDPreTreaPatientConnectStates + TDPreTreaSampleWaterStates = td_defs.TDPreTreaSampleWaterStates + TDPreTreaConsumableSelfTestStates = td_defs.TDPreTreaConsumableSelfTestStates + TDPreTreaNoCartSelfTestStates = td_defs.TDPreTreaNoCartSelfTestStates + TDPreTreaDrySelfTestStates = td_defs.TDPreTreaDrySelfTestStates + TDPreTreaPrimeStates = td_defs.TDPreTreaPrimeStates + TDPreTreaRecircStates = td_defs.TDPreTreaRecircStates + TDPreTreaPatientConnectStates = td_defs.TDPreTreaPatientConnectStates # Treatment - TDTreaBloodPrimeStates = td_defs.TDTreaBloodPrimeStates - TDTreaDialysisStates = td_defs.TDTreaDialysisStates - TDTreaPausedStates = td_defs.TDTreaPausedStates - TDTreaRinsebackStates = td_defs.TDTreaRinsebackStates - TDTreaRecircStates = td_defs.TDTreaRecircStates - TDTreaBolusStates = td_defs.TDTreaBolusStates - TDTreaHeparinStates = td_defs.TDTreaHeparinStates - TDTreaEndStates = td_defs.TDTreaEndStates + TDTreaBloodPrimeStates = td_defs.TDTreaBloodPrimeStates + TDTreaDialysisStates = td_defs.TDTreaDialysisStates + TDTreaPausedStates = td_defs.TDTreaPausedStates + TDTreaRinsebackStates = td_defs.TDTreaRinsebackStates + TDTreaRecircStates = td_defs.TDTreaRecircStates + TDTreaBolusStates = td_defs.TDTreaBolusStates + TDTreaHeparinStates = td_defs.TDTreaHeparinStates + TDTreaEndStates = td_defs.TDTreaEndStates # Operation Modes - Lvl 4 - TDPreTreaSamplWaterUserActionStates = td_defs.TDPreTreaSamplWaterUserActionStates - TDWetSelfTestsStates = td_defs.TDWetSelfTestsStates - TDTreaBloodPrimeUserActionStates = td_defs.TDTreaBloodPrimeUserActionStates - TDTreaRinsebackUserActionStates = td_defs.TDTreaRinsebackUserActionStates - TDTreaRecircUserActionStates = td_defs.TDTreaRecircUserActionStates - TDTreaEndUserActionStates = td_defs.TDTreaEndUserActionStates + TDPreTreaSamplWaterUserActionStates = td_defs.TDPreTreaSamplWaterUserActionStates + TDWetSelfTestsStates = td_defs.TDWetSelfTestsStates + TDTreaBloodPrimeUserActionStates = td_defs.TDTreaBloodPrimeUserActionStates + TDTreaRinsebackUserActionStates = td_defs.TDTreaRinsebackUserActionStates + TDTreaRecircUserActionStates = td_defs.TDTreaRecircUserActionStates + TDTreaEndUserActionStates = td_defs.TDTreaEndUserActionStates # Events - TDEventList = td_defs.TDEventList - DataTypes = generic_defs.DataTypes + TDEventList = td_defs.TDEventList + DataTypes = generic_defs.DataTypes # Sensor Names - TDAirPumpNames = td_defs.TDAirPumpNames - TDAirTrapValveNames = td_defs.TDAirTrapValveNames - TDAirTrapLevelSensorNames = td_defs.TDAirTrapLevelSensorNames - TDAirBubbleDetectorNames = td_defs.TDAirBubbleDetectorNames - TDBatteryRegisterNames = td_defs.TDBatteryRegisterNames - TDBloodPumpNames = td_defs.TDBloodPumpNames - TDEjectorNames = td_defs.TDEjectorNames - TDPressureSensorNames = td_defs.TDPressureSensorNames - TDTemperatureSensorNames = td_defs.TDTemperatureSensorNames - TDSwitchNames = td_defs.TDSwitchNames - TDSyringePumpNames = td_defs.TDSyringePumpNames - TDValveNames = td_defs.TDValveNames - TDMonitoredVoltages = td_defs.TDMonitoredVoltages + TDAirPumpNames = td_defs.TDAirPumpNames + TDAirTrapValveNames = td_defs.TDAirTrapValveNames + TDAirTrapLevelSensorNames = td_defs.TDAirTrapLevelSensorNames + TDAirBubbleDetectorNames = td_defs.TDAirBubbleDetectorNames + TDBatteryRegisterNames = td_defs.TDBatteryRegisterNames + TDBloodPumpNames = td_defs.TDBloodPumpNames + TDEjectorNames = td_defs.TDEjectorNames + TDPressureSensorNames = td_defs.TDPressureSensorNames + TDTemperatureSensorNames = td_defs.TDTemperatureSensorNames + TDSwitchNames = td_defs.TDSwitchNames + TDSyringePumpNames = td_defs.TDSyringePumpNames + TDValveNames = td_defs.TDValveNames + TDMonitoredVoltages = td_defs.TDMonitoredVoltages # Sensor Attributes - TDAirPumpAttributes = td_defs.TDAirPumpAttributes - TDAirPumpStates = td_defs.TDAirPumpStates - TDAirTrapLevelSensorAttributes = td_defs.TDAirTrapLevelSensorAttributes - TDAirTrapState = td_defs.TDAirTrapState - TDBloodFlowMotorAttributes = td_defs.TDBloodFlowMotorAttributes - TDAirBubbleDetectorAttributes = td_defs.TDAirBubbleDetectorAttributes - TDEjectorAttributes = td_defs.TDEjectorAttributes - TDEjectorStates = td_defs.TDEjectorStates - TDPressureSensorAttributes = td_defs.TDPressureSensorAttributes - TDSwitchStatus = td_defs.TDSwitchStatus - TDSyringePumpStates = td_defs.TDSyringePumpStates - TDValvePositions = td_defs.TDValvePositions - TDValveStates = td_defs.TDValveStates + TDAirPumpAttributes = td_defs.TDAirPumpAttributes + TDAirPumpStates = td_defs.TDAirPumpStates + TDAirTrapLevelSensorAttributes = td_defs.TDAirTrapLevelSensorAttributes + TDAirTrapState = td_defs.TDAirTrapState + TDBloodFlowMotorAttributes = td_defs.TDBloodFlowMotorAttributes + TDAirBubbleDetectorAttributes = td_defs.TDAirBubbleDetectorAttributes + TDEjectorAttributes = td_defs.TDEjectorAttributes + TDEjectorStates = td_defs.TDEjectorStates + TDPressureSensorAttributes = td_defs.TDPressureSensorAttributes + TDSwitchStatus = td_defs.TDSwitchStatus + TDSyringePumpStates = td_defs.TDSyringePumpStates + TDValvePositions = td_defs.TDValvePositions + TDValveStates = td_defs.TDValveStates # Support - TDTreatmentParameters = td_defs.TDTreatmentParameters - TDTreatmentModalityTypes = td_defs.TDTreatmentModalityTypes - TDTreatmentHDFDilution = td_defs.TDTreatmentHDFDilution + TDTreatmentParameters = td_defs.TDTreatmentParameters + TDTreatmentModalityTypes = td_defs.TDTreatmentModalityTypes + TDTreatmentHDFDilution = td_defs.TDTreatmentHDFDilution # Alarms - AlarmLampPatterns = generic_defs.AlarmLampPatterns - AlarmPriorities = generic_defs.AlarmPriorities - AlarmProperties = generic_defs.AlarmProperties - AlarmResponseButtons = generic_defs.AlarmResponseButtons + AlarmLampPatterns = generic_defs.AlarmLampPatterns + AlarmPriorities = generic_defs.AlarmPriorities + AlarmProperties = generic_defs.AlarmProperties + AlarmResponseButtons = generic_defs.AlarmResponseButtons # Records - RecordTypes = generic_defs.RecordTypes - SystemRecordFields = generic_defs.SystemRecordFields - ServiceRecordFields = generic_defs.ServiceRecordFields - CalibrationRecordFields = generic_defs.get_calibration_record_fields() - InstitutionalRecordFields = generic_defs.InstitutionalRecordFields - UsageInformationRecordFields = generic_defs.UsageInformationRecordFields + RecordTypes = generic_defs.RecordTypes + TDSystemRecordFields = td_defs.TDSystemRecordFields + TDServiceRecordFields = td_defs.TDServiceRecordFields + TDCalibrationRecordFields = td_defs.get_calibration_record_fields() + TDInstitutionalRecordBasicFields = td_defs.TDInstitutionalRecordBasicFields + TDInstitutionalRecordAdvancedFields = td_defs.TDInstitutionalRecordAdvancedFields + TDInstitutionalRecordAdditionalFields = td_defs.TDInstitutionalRecordAdditionalFields + TDUsageInformationRecordFields = td_defs.TDUsageInformationRecordFields # Record support - CalibRecordAccelerometerFields = generic_defs.CalibRecordAccelerometerFields - CalibRecordBloodLeakFields = generic_defs.CalibRecordBloodLeakFields - CalibRecordConcentrateFields = generic_defs.CalibRecordConcentrateFields - CalibRecordSensorFields = generic_defs.CalibRecordSensorFields td_enum_repository = TD_Defs() Index: leahi_dialin/dd/modules/blood_leak.py =================================================================== diff -u -rd0dedd8e720be5de357176ffb095484ec082c830 -r27d9de42c0111c7f369cc335889fe6b988d09cc8 --- leahi_dialin/dd/modules/blood_leak.py (.../blood_leak.py) (revision d0dedd8e720be5de357176ffb095484ec082c830) +++ leahi_dialin/dd/modules/blood_leak.py (.../blood_leak.py) (revision 27d9de42c0111c7f369cc335889fe6b988d09cc8) @@ -17,6 +17,7 @@ # Module imports from logging import Logger from enum import unique +import time from typing import Union # Project imports @@ -90,18 +91,20 @@ # Initialize all the embedded mode commands self.blood_leak_emb_mode_cmds[cmd] = '' + self.handler_execution_times = [] + # ============================================================ Properties ============================================================ @property - def blood_leak_detected(self) -> bool: + def blood_leak_status(self) -> bool: """ The Blood Leak Detected Status """ return self._blood_leak_detected - @blood_leak_detected.setter - def blood_leak_detected(self, value: bool): + @blood_leak_status.setter + def blood_leak_status(self, value: bool): self._blood_leak_detected = value @@ -244,6 +247,7 @@ @param message: published blood leak status message @return: None """ + start = time.perf_counter() msg_list =[] msg_list.append((type(self).blood_leak_status, DataTypes.BOOL)) msg_list.append((type(self).blood_leak_state, DataTypes.U32)) @@ -258,6 +262,7 @@ self.process_into_vars(decoder_list = msg_list, message = message) self.dd_blood_leak_status_timestamp = timestamp + self.handler_execution_times.append((timestamp, message, time.perf_counter() - start)) @publish(['msg_id_dd_send_blood_leak_emb_mode_response', 'blood_leak_emb_mode_cmd_response', Index: leahi_dialin/dd/modules/events.py =================================================================== diff -u -r6caa49d072aceb2655d605de5d2eea52ab1a8911 -r27d9de42c0111c7f369cc335889fe6b988d09cc8 --- leahi_dialin/dd/modules/events.py (.../events.py) (revision 6caa49d072aceb2655d605de5d2eea52ab1a8911) +++ leahi_dialin/dd/modules/events.py (.../events.py) (revision 27d9de42c0111c7f369cc335889fe6b988d09cc8) @@ -107,7 +107,7 @@ msg_list = [] msg_list.append((event_id, DataTypes.U32)) - if event_enum is dd_enum_repository.DDEventList.DD_EVENT_OPERATION_STATUS: + if event_enum is dd_enum_repository.DDEventList.OPERATION_STATUS: msg_list.append((data_typ_1, DataTypes.U32)) # It's not used in operation status case msg_list.append((op_mode, DataTypes.U08)) msg_list.append((sub_mode, DataTypes.U08)) @@ -131,15 +131,15 @@ event_tuple = (current_timestamp, event_enum.name, data_1.value, data_2.value) # Update event data from integer to name if it's op mode change - if event_enum is dd_enum_repository.DDEventList.DD_EVENT_OP_MODE_CHANGE: + if event_enum is dd_enum_repository.DDEventList.OP_MODE_CHANGE: data_1 = dd_enum_repository.DDOpModes(data_1.value).name data_2 = dd_enum_repository.DDOpModes(data_2.value).name event_tuple = (current_timestamp, event_enum.name, data_1.value, data_2.value) # Check if the event state name is sub mode change. - elif event_enum is dd_enum_repository.DDEventList.DD_EVENT_SUB_MODE_CHANGE: + elif event_enum is dd_enum_repository.DDEventList.SUB_MODE_CHANGE: # Get the Op Mode Change messages - op_modes_list = self._event_dictionary[dd_enum_repository.DDEventList.DD_EVENT_OP_MODE_CHANGE.name] + op_modes_list = self._event_dictionary[dd_enum_repository.DDEventList.OP_MODE_CHANGE.name] # If there are Op mode change messages, use it to determine the operation mode for the current submode change # Index description: @@ -149,7 +149,7 @@ # 3: Current Op / Sub Mode if len(op_modes_list) != 0: # Get the Sub Mode Change messages - sub_mode_list = self._event_dictionary[dd_enum_repository.DDEventList.DD_EVENT_SUB_MODE_CHANGE.name] + sub_mode_list = self._event_dictionary[dd_enum_repository.DDEventList.SUB_MODE_CHANGE.name] last_op_mode_message = op_modes_list[-1] # Check if this is not the very first Sub Mode Change message @@ -180,7 +180,7 @@ # to identify the Op Modes for the Sub Modes else: # Get the Operation Status Change messages - op_status_list = self._event_dictionary[dd_enum_repository.DDEventList.DD_EVENT_OPERATION_STATUS.name] + op_status_list = self._event_dictionary[dd_enum_repository.DDEventList.OPERATION_STATUS.name] data_2_found = False event_1_op_mode = self.UNKNOWN_STATE @@ -220,8 +220,8 @@ # Update the tuple event_tuple = (current_timestamp, event_enum.name, data_1.value, data_2.value) - elif event_enum is dd_enum_repository.DDEventList.DD_EVENT_OPERATION_STATUS: - op_mode_enum, sub_mode_enum, state_enum, _ = self._operation_status_match(op_mode=op_mode, sub_mode=sub_mode, state=sub_state) + elif event_enum is dd_enum_repository.DDEventList.OPERATION_STATUS: + op_mode_enum, sub_mode_enum, state_enum, _ = self._operation_status_match(op_mode=op_mode.value, sub_mode=sub_mode.value, state=sub_state.value) event_tuple = (current_timestamp, op_mode_enum, sub_mode_enum, state_enum) # Update event dictionary @@ -291,17 +291,21 @@ return list_of_events - def _operation_status_match(self, op_mode: int, sub_mode: int=None, state:int=None, sub_state: int=None) -> Tuple[DialinEnum, Union[DialinEnum, int], Union[DialinEnum, int], Union[DialinEnum, int]]: + def _operation_status_match(self, op_mode: int, sub_mode: int=None, state:int=None, sub_state: int=None, debug: bool=False) -> Tuple[DialinEnum, Union[DialinEnum, int], Union[DialinEnum, int], Union[DialinEnum, int]]: """ Convert operation status values to enums. :param op_mode: (Integer) The operation mode value :param sub_mode: (Integer) The operation sub mode value :param state: (Integer) The operation state value :param sub_state: (Integer) The operation sub state value + :param debug: (Boolean) Print debug data or not :return: Returns the DialinEnum for each provied mode/state, or the original integer value if no enum is found """ op_mode_enum = dd_enum_repository.DDOpModes(op_mode) + if debug: + print(f'\nDebug op_mode: {op_mode}') + print(f'Debug op_mode_enum: {op_mode_enum}') sub_mode_enum = None state_enum = None sub_state_enum = None @@ -310,15 +314,24 @@ sub_mode_enum = sub_mode else: sub_mode_enum = self._op_mode_2_sub_mode[op_mode_enum.name](sub_mode) + if debug: + print(f'Debug sub_mode: {sub_mode}') + print(f'Debug sub_mode_enum: {sub_mode_enum}') if state is not None: - if sub_mode_enum.name not in self._sub_mode_2_states: + if sub_mode_enum.name not in self._sub_mode_2_states or len(self._sub_mode_2_states[sub_mode_enum.name]) < state: state_enum = state else: state_enum = self._sub_mode_2_states[sub_mode_enum.name](state) + if debug: + print(f'Debug state: {state}') + print(f'Debug state_enum: {state_enum}') if sub_state is not None: if state_enum.name not in self._state_2_sub_states: sub_state_enum = sub_state else: sub_state_enum = self._state_2_sub_states[state_enum.name](sub_state) + if debug: + print(f'Debug sub_state: {sub_state}') + print(f'Debug sub_state_enum: {sub_state_enum}') return op_mode_enum, sub_mode_enum, state_enum, sub_state_enum Index: leahi_dialin/fp/modules/events.py =================================================================== diff -u -r6caa49d072aceb2655d605de5d2eea52ab1a8911 -r27d9de42c0111c7f369cc335889fe6b988d09cc8 --- leahi_dialin/fp/modules/events.py (.../events.py) (revision 6caa49d072aceb2655d605de5d2eea52ab1a8911) +++ leahi_dialin/fp/modules/events.py (.../events.py) (revision 27d9de42c0111c7f369cc335889fe6b988d09cc8) @@ -108,7 +108,7 @@ msg_list = [] msg_list.append((event_id, DataTypes.U32)) - if event_enum is fp_enum_repository.FPEventList.FP_EVENT_OPERATION_STATUS: + if event_enum is fp_enum_repository.FPEventList.OPERATION_STATUS: msg_list.append((data_typ_1, DataTypes.U32)) # It's not used in operation status case msg_list.append((op_mode, DataTypes.U08)) msg_list.append((sub_mode, DataTypes.U08)) @@ -134,15 +134,15 @@ # Check if the event state name is operation mode change. If it is, get the name of the operation modes # from the op modes enum class - if event_enum is fp_enum_repository.FPEventList.FP_EVENT_OP_MODE_CHANGE: + if event_enum is fp_enum_repository.FPEventList.OP_MODE_CHANGE: data_1 = fp_enum_repository.FPOpModes(data_1.value).name data_2 = fp_enum_repository.FPOpModes(data_2.value).name event_tuple = (current_timestamp, event_enum.name, data_1.value, data_2.value) # Check if the event state name is sub mode change. - elif event_enum is fp_enum_repository.FPEventList.FP_EVENT_SUB_MODE_CHANGE: + elif event_enum is fp_enum_repository.FPEventList.SUB_MODE_CHANGE: # Get the Op Mode Change messages - op_modes_list = self._event_dictionary[fp_enum_repository.FPEventList.FP_EVENT_OP_MODE_CHANGE.name] + op_modes_list = self._event_dictionary[fp_enum_repository.FPEventList.OP_MODE_CHANGE.name] # If there are Op mode change messages, use it to determine the operation mode for the current submode change # Index description: @@ -152,7 +152,7 @@ # 3: Current Op / Sub Mode if len(op_modes_list) != 0: # Get the Sub Mode Change messages - sub_mode_list = self._event_dictionary[fp_enum_repository.FPEventList.FP_EVENT_SUB_MODE_CHANGE.name] + sub_mode_list = self._event_dictionary[fp_enum_repository.FPEventList.SUB_MODE_CHANGE.name] last_op_mode_message = op_modes_list[-1] # Check if this is not the very first Sub Mode Change message @@ -183,7 +183,7 @@ # to identify the Op Modes for the Sub Modes else: # Get the Operation Status Change messages - op_status_list = self._event_dictionary[fp_enum_repository.FPEventList.FP_EVENT_OPERATION_STATUS.name] + op_status_list = self._event_dictionary[fp_enum_repository.FPEventList.OPERATION_STATUS.name] data_2_found = False event_1_op_mode = self.UNKNOWN_STATE @@ -223,8 +223,8 @@ # Update the tuple event_tuple = (current_timestamp, event_enum.name, data_1.value, data_2.value) - elif event_enum is fp_enum_repository.FPEventList.FP_EVENT_OPERATION_STATUS: - op_mode_enum, sub_mode_enum, state_enum, _ = self._operation_status_match(op_mode=op_mode, sub_mode=sub_mode, state=sub_state) + elif event_enum is fp_enum_repository.FPEventList.OPERATION_STATUS: + op_mode_enum, sub_mode_enum, state_enum, _ = self._operation_status_match(op_mode=op_mode.value, sub_mode=sub_mode.value, state=sub_state.value) event_tuple = (current_timestamp, op_mode_enum, sub_mode_enum, state_enum) # Update event dictionary @@ -294,17 +294,21 @@ return list_of_events - def _operation_status_match(self, op_mode: int, sub_mode: int=None, state:int=None, sub_state: int=None) -> Tuple[DialinEnum, Union[DialinEnum, int], Union[DialinEnum, int], Union[DialinEnum, int]]: + def _operation_status_match(self, op_mode: int, sub_mode: int=None, state:int=None, sub_state: int=None, debug: bool=False) -> Tuple[DialinEnum, Union[DialinEnum, int], Union[DialinEnum, int], Union[DialinEnum, int]]: """ Convert operation status values to enums. :param op_mode: (Integer) The operation mode value :param sub_mode: (Integer) The operation sub mode value :param state: (Integer) The operation state value :param sub_state: (Integer) The operation sub state value + :param debug: (Boolean) Print debug data or not :return: Returns the DialinEnum for each provied mode/state, or the original integer value if no enum is found """ op_mode_enum = fp_enum_repository.FPOpModes(op_mode) + if debug: + print(f'\nDebug op_mode: {op_mode}') + print(f'Debug op_mode_enum: {op_mode_enum}') sub_mode_enum = None state_enum = None sub_state_enum = None @@ -313,15 +317,24 @@ sub_mode_enum = sub_mode else: sub_mode_enum = self._op_mode_2_sub_mode[op_mode_enum.name](sub_mode) + if debug: + print(f'Debug sub_mode: {sub_mode}') + print(f'Debug sub_mode_enum: {sub_mode_enum}') if state is not None: - if sub_mode_enum.name not in self._sub_mode_2_states: + if sub_mode_enum.name not in self._sub_mode_2_states or len(self._sub_mode_2_states[sub_mode_enum.name]) < state: state_enum = state else: state_enum = self._sub_mode_2_states[sub_mode_enum.name](state) + if debug: + print(f'Debug state: {state}') + print(f'Debug state_enum: {state_enum}') if sub_state is not None: if state_enum.name not in self._state_2_sub_states: sub_state_enum = sub_state else: sub_state_enum = self._state_2_sub_states[state_enum.name](sub_state) + if debug: + print(f'Debug sub_state: {sub_state}') + print(f'Debug sub_state_enum: {sub_state_enum}') return op_mode_enum, sub_mode_enum, state_enum, sub_state_enum Index: leahi_dialin/fp/modules/levels.py =================================================================== diff -u -r6caa49d072aceb2655d605de5d2eea52ab1a8911 -r27d9de42c0111c7f369cc335889fe6b988d09cc8 --- leahi_dialin/fp/modules/levels.py (.../levels.py) (revision 6caa49d072aceb2655d605de5d2eea52ab1a8911) +++ leahi_dialin/fp/modules/levels.py (.../levels.py) (revision 27d9de42c0111c7f369cc335889fe6b988d09cc8) @@ -52,7 +52,7 @@ self.fp_levels_timestamp = 0 #: The timestamp of the last message self.fp_levels = { - fp_enum_repository.FPFloaterLevelSensorNames.P25_LEVEL.name: fp_enum_repository.FPFloaterLevels.LEVEL_STATE_EMPTY.value + fp_enum_repository.FPFloaterLevelSensorNames.P25_LEVEL.name: fp_enum_repository.FPFloaterLevels.EMPTY.value } self.handler_execution_times = [] Index: leahi_dialin/fp/modules/ro_pump.py =================================================================== diff -u -r6caa49d072aceb2655d605de5d2eea52ab1a8911 -r27d9de42c0111c7f369cc335889fe6b988d09cc8 --- leahi_dialin/fp/modules/ro_pump.py (.../ro_pump.py) (revision 6caa49d072aceb2655d605de5d2eea52ab1a8911) +++ leahi_dialin/fp/modules/ro_pump.py (.../ro_pump.py) (revision 27d9de42c0111c7f369cc335889fe6b988d09cc8) @@ -51,7 +51,7 @@ self.ro_pump_timestamp = 0.0 #: The timestamp of the last message self.ro_pump = { fp_enum_repository.FPROPumpNames.P12_PUMP.name: { - fp_enum_repository.FPPumpAttributes.STATE.name: fp_enum_repository.FPROPumpStates.PUMP_OFF_STATE.value, + fp_enum_repository.FPPumpAttributes.STATE.name: fp_enum_repository.FPROPumpStates.OFF_STATE.value, fp_enum_repository.FPPumpAttributes.DUTY_CYCLE.name: 0, fp_enum_repository.FPPumpAttributes.FB_DUTY_CYCLE.name: 0, fp_enum_repository.FPPumpAttributes.SPEED.name: 0.0, Index: leahi_dialin/fp/modules/valves.py =================================================================== diff -u -r6caa49d072aceb2655d605de5d2eea52ab1a8911 -r27d9de42c0111c7f369cc335889fe6b988d09cc8 --- leahi_dialin/fp/modules/valves.py (.../valves.py) (revision 6caa49d072aceb2655d605de5d2eea52ab1a8911) +++ leahi_dialin/fp/modules/valves.py (.../valves.py) (revision 27d9de42c0111c7f369cc335889fe6b988d09cc8) @@ -54,14 +54,14 @@ self.fp_valves_states_timestamp = 0.0 #: The timestamp of the last message self.valve_states_all = 0x0000 #: States of all the vales in binary format self.valves_sensed_states = OrderedDict() #: The Valve's Sensed State data in dictionary format - self.m4_valv = {"id": fp_enum_repository.FPValveNames.M4_VALV.value, "state": fp_enum_repository.FPValveStates.VALVE_STATE_CLOSED.value } #: The M4 valve's value - self.m12_valv = {"id": fp_enum_repository.FPValveNames.M12_VALV.value, "state": fp_enum_repository.FPValveStates.VALVE_STATE_CLOSED.value } #: The M12 valve's value - self.p11_valv = {"id": fp_enum_repository.FPValveNames.P11_VALV.value, "state": fp_enum_repository.FPValveStates.VALVE_STATE_CLOSED.value } #: The P11 valve's value - self.p33_valv = {"id": fp_enum_repository.FPValveNames.P33_VALV.value, "state": fp_enum_repository.FPValveStates.VALVE_STATE_CLOSED.value } #: The P33 valve's value - self.p34_valv = {"id": fp_enum_repository.FPValveNames.P34_VALV.value, "state": fp_enum_repository.FPValveStates.VALVE_STATE_CLOSED.value } #: The P34 valve's value - self.p37_valv = {"id": fp_enum_repository.FPValveNames.P37_VALV.value, "state": fp_enum_repository.FPValveStates.VALVE_STATE_CLOSED.value } #: The P37 valve's value - self.p39_valv = {"id": fp_enum_repository.FPValveNames.P39_VALV.value, "state": fp_enum_repository.FPValveStates.VALVE_STATE_CLOSED.value } #: The P39 valve's value - self.p6_valv = {"id": fp_enum_repository.FPValveNames.P6_VALV.value, "state": fp_enum_repository.FPValveStates.VALVE_STATE_CLOSED.value } #: The P6 valve's value + self.m4_valv = {"id": fp_enum_repository.FPValveNames.M4_VALV.value, "state": fp_enum_repository.FPValveStates.CLOSED.value } #: The M4 valve's value + self.m12_valv = {"id": fp_enum_repository.FPValveNames.M12_VALV.value, "state": fp_enum_repository.FPValveStates.CLOSED.value } #: The M12 valve's value + self.p11_valv = {"id": fp_enum_repository.FPValveNames.P11_VALV.value, "state": fp_enum_repository.FPValveStates.CLOSED.value } #: The P11 valve's value + self.p33_valv = {"id": fp_enum_repository.FPValveNames.P33_VALV.value, "state": fp_enum_repository.FPValveStates.CLOSED.value } #: The P33 valve's value + self.p34_valv = {"id": fp_enum_repository.FPValveNames.P34_VALV.value, "state": fp_enum_repository.FPValveStates.CLOSED.value } #: The P34 valve's value + self.p37_valv = {"id": fp_enum_repository.FPValveNames.P37_VALV.value, "state": fp_enum_repository.FPValveStates.CLOSED.value } #: The P37 valve's value + self.p39_valv = {"id": fp_enum_repository.FPValveNames.P39_VALV.value, "state": fp_enum_repository.FPValveStates.CLOSED.value } #: The P39 valve's value + self.p6_valv = {"id": fp_enum_repository.FPValveNames.P6_VALV.value, "state": fp_enum_repository.FPValveStates.CLOSED.value } #: The P6 valve's value #: States of all the vales in list format self.valve_states_enum = {} Index: leahi_dialin/td/modules/ejector.py =================================================================== diff -u -r6caa49d072aceb2655d605de5d2eea52ab1a8911 -r27d9de42c0111c7f369cc335889fe6b988d09cc8 --- leahi_dialin/td/modules/ejector.py (.../ejector.py) (revision 6caa49d072aceb2655d605de5d2eea52ab1a8911) +++ leahi_dialin/td/modules/ejector.py (.../ejector.py) (revision 27d9de42c0111c7f369cc335889fe6b988d09cc8) @@ -52,7 +52,7 @@ self.h5_motor = { td_enum_repository.TDEjectorNames.H5_MOTOR.name: { - td_enum_repository.TDEjectorAttributes.STATE.name: td_enum_repository.TDEjectorStates.EJECTOR_STATE_INIT.value, + td_enum_repository.TDEjectorAttributes.STATE.name: td_enum_repository.TDEjectorStates.INIT.value, td_enum_repository.TDEjectorAttributes.SET_SPEED.name: 0.0, td_enum_repository.TDEjectorAttributes.OPT_SNSR_RETRACT.name: 0, # H25 Optical Sensor td_enum_repository.TDEjectorAttributes.OPT_SNSR_ENGAGE.name: 0 # H24 Optical Sensor Index: leahi_dialin/td/modules/events.py =================================================================== diff -u -r6caa49d072aceb2655d605de5d2eea52ab1a8911 -r27d9de42c0111c7f369cc335889fe6b988d09cc8 --- leahi_dialin/td/modules/events.py (.../events.py) (revision 6caa49d072aceb2655d605de5d2eea52ab1a8911) +++ leahi_dialin/td/modules/events.py (.../events.py) (revision 27d9de42c0111c7f369cc335889fe6b988d09cc8) @@ -63,27 +63,25 @@ td_enum_repository.TDOpModes.MODE_NLEG.name: td_enum_repository.TDNotLegalStates } # Dictionary of the sub-mode as key and the state enum class as the value - self._sub_mode_2_states = {td_enum_repository.TDPreTreatmentModesStates.TD_PRE_TREATMENT_WATER_SAMPLE_STATE.name: td_enum_repository.TDPreTreaSampleWaterStates, - td_enum_repository.TDPreTreatmentModesStates.TD_PRE_TREATMENT_SELF_TEST_NO_CART_STATE.name: td_enum_repository.TDPreTreaNoCartSelfTestStates, - td_enum_repository.TDPreTreatmentModesStates.TD_PRE_TREATMENT_SELF_TEST_DRY_STATE.name: td_enum_repository.TDPreTreaDrySelfTestStates, - td_enum_repository.TDPreTreatmentModesStates.TD_PRE_TREATMENT_PRIME_STATE.name: td_enum_repository.TDPreTreaPrimeStates, - td_enum_repository.TDPreTreatmentModesStates.TD_PRE_TREATMENT_RECIRCULATE_STATE.name: td_enum_repository.TDPreTreaRecircStates, - td_enum_repository.TDPreTreatmentModesStates.TD_PRE_TREATMENT_PATIENT_CONNECTION_STATE.name: td_enum_repository.TDPreTreaPatientConnectStates, - td_enum_repository.TDTreatmentStates.TREATMENT_BLOOD_PRIME_STATE.name: td_enum_repository.TDTreaBloodPrimeStates, - td_enum_repository.TDTreatmentStates.TREATMENT_DIALYSIS_STATE.name:td_enum_repository.TDTreaDialysisStates, - td_enum_repository.TDTreatmentStates.TREATMENT_PAUSED_STATE.name:td_enum_repository.TDTreaPausedStates, - td_enum_repository.TDTreatmentStates.TREATMENT_RINSEBACK_STATE.name:td_enum_repository.TDTreaRinsebackStates, - td_enum_repository.TDTreatmentStates.TREATMENT_RECIRC_STATE.name:td_enum_repository.TDTreaRecircStates, - td_enum_repository.TDTreatmentStates.TREATMENT_END_STATE.name:td_enum_repository.TDTreaEndStates, - td_enum_repository.TDTreatmentStates.TREATMENT_SALINE_BOLUS_STATE.name:td_enum_repository.TDTreaBolusStates } + self._sub_mode_2_states = {td_enum_repository.TDPreTreatmentModesStates.SELF_TEST_DRY_STATE.name: td_enum_repository.TDPreTreaDrySelfTestStates, + td_enum_repository.TDPreTreatmentModesStates.PRIME_STATE.name: td_enum_repository.TDPreTreaPrimeStates, + td_enum_repository.TDPreTreatmentModesStates.RECIRCULATE_STATE.name: td_enum_repository.TDPreTreaRecircStates, + td_enum_repository.TDPreTreatmentModesStates.PATIENT_CONNECTION_STATE.name: td_enum_repository.TDPreTreaPatientConnectStates, + td_enum_repository.TDTreatmentStates.BLOOD_PRIME_STATE.name: td_enum_repository.TDTreaBloodPrimeStates, + td_enum_repository.TDTreatmentStates.DIALYSIS_STATE.name:td_enum_repository.TDTreaDialysisStates, + td_enum_repository.TDTreatmentStates.PAUSED_STATE.name:td_enum_repository.TDTreaPausedStates, + td_enum_repository.TDTreatmentStates.RINSEBACK_STATE.name:td_enum_repository.TDTreaRinsebackStates, + td_enum_repository.TDTreatmentStates.RECIRC_STATE.name:td_enum_repository.TDTreaRecircStates, + td_enum_repository.TDTreatmentStates.END_STATE.name:td_enum_repository.TDTreaEndStates, + td_enum_repository.TDTreatmentStates.SALINE_BOLUS_STATE.name:td_enum_repository.TDTreaBolusStates } # Dictionary of the state as key and the sub state enum class as the value - self._state_2_sub_states = {td_enum_repository.TDPreTreaSampleWaterStates.SAMPLE_WATER_STATE.name: td_enum_repository.TDPreTreaSamplWaterUserActionStates, - td_enum_repository.TDPreTreaPrimeStates.TD_PRIME_WET_SELF_TESTS_STATE.name: td_enum_repository.TDWetSelfTestsStates, - td_enum_repository.TDTreaBloodPrimeStates.BLOOD_PRIME_RUN_STATE.name: td_enum_repository.TDTreaBloodPrimeUserActionStates, - td_enum_repository.TDTreaRinsebackStates.RINSEBACK_RUN_STATE.name: td_enum_repository.TDTreaRinsebackUserActionStates, - td_enum_repository.TDTreaRecircStates.TREATMENT_RECIRC_RECIRC_STATE.name: td_enum_repository.TDTreaRecircUserActionStates, - td_enum_repository.TDTreaEndStates.TREATMENT_END_WAIT_FOR_RINSEBACK_STATE.name: td_enum_repository.TDTreaEndUserActionStates } + self._state_2_sub_states = {td_enum_repository.TDPreTreaSampleWaterStates.STATE.name: td_enum_repository.TDPreTreaSamplWaterUserActionStates, + td_enum_repository.TDPreTreaPrimeStates.WET_SELF_TESTS_STATE.name: td_enum_repository.TDWetSelfTestsStates, + td_enum_repository.TDTreaBloodPrimeStates.RUN_STATE.name: td_enum_repository.TDTreaBloodPrimeUserActionStates, + td_enum_repository.TDTreaRinsebackStates.RUN_STATE.name: td_enum_repository.TDTreaRinsebackUserActionStates, + td_enum_repository.TDTreaRecircStates.RECIRC_STATE.name: td_enum_repository.TDTreaRecircUserActionStates, + td_enum_repository.TDTreaEndStates.WAIT_FOR_RINSEBACK_STATE.name: td_enum_repository.TDTreaEndUserActionStates } # Loop through the list of the TD events enums and initial the event dictionary. Each event is a key in the # dictionary and the value is a list. @@ -119,39 +117,43 @@ msg_list = [] msg_list.append((event_id, DataTypes.U32)) - if event_enum is td_enum_repository.TDEventList.TD_EVENT_OPERATION_STATUS: - msg_list.append((data_typ_1, DataTypes.U32)) # It's not used in operation status case - msg_list.append((op_mode, DataTypes.U08)) - msg_list.append((sub_mode, DataTypes.U08)) - msg_list.append((state, DataTypes.U08)) - msg_list.append((sub_state, DataTypes.U08)) - msg_list.append((data_typ_2, DataTypes.U32)) - msg_list.append((data_2, 'data_typ_2')) - else: - msg_list.append((data_typ_1, DataTypes.U32)) - msg_list.append((data_1, 'data_typ_1')) - msg_list.append((data_typ_2, DataTypes.U32)) - msg_list.append((data_2, 'data_typ_2')) self.process_into_vars(decoder_list = msg_list, message = message) # Convert the event ID to enum event_enum = td_enum_repository.TDEventList(event_id.value) + msg_list_2 = [] + if event_enum is td_enum_repository.TDEventList.OPERATION_STATUS: + msg_list_2.append((data_typ_1, DataTypes.U32)) # It's not used in operation status case + msg_list_2.append((op_mode, DataTypes.U08)) + msg_list_2.append((sub_mode, DataTypes.U08)) + msg_list_2.append((state, DataTypes.U08)) + msg_list_2.append((sub_state, DataTypes.U08)) + msg_list_2.append((data_typ_2, DataTypes.U32)) + msg_list_2.append((data_2, 'data_typ_2')) + else: + msg_list_2.append((data_typ_1, DataTypes.U32)) + msg_list_2.append((data_1, 'data_typ_1')) + msg_list_2.append((data_typ_2, DataTypes.U32)) + msg_list_2.append((data_2, 'data_typ_2')) + + self.process_into_vars(decoder_list = msg_list_2, message = message, start_from_byte = DataTypes.U32.size()) + # Get the current timestamp and create a tuple of the current events current_timestamp = datetime.now().astimezone().strftime('%Y-%m-%d %H:%M:%S.%f') event_tuple = (current_timestamp, event_enum.name, data_1.value, data_2.value) # Check if the event state name is operation mode change. If it is, get the name of the operation modes # from the op modes enum class - if event_enum is td_enum_repository.TDEventList.TD_EVENT_OP_MODE_CHANGE: + if event_enum is td_enum_repository.TDEventList.OP_MODE_CHANGE: data_1 = td_enum_repository.TDOpModes(data_1.value).name data_2 = td_enum_repository.TDOpModes(data_2.value).name event_tuple = (current_timestamp, event_enum.name, data_1.value, data_2.value) # Check if the event state name is sub mode change. - elif event_enum is td_enum_repository.TDEventList.TD_EVENT_SUB_MODE_CHANGE: + elif event_enum is td_enum_repository.TDEventList.SUB_MODE_CHANGE: # Get the Op Mode Change messages - op_modes_list = self._event_dictionary[td_enum_repository.TDEventList.TD_EVENT_OP_MODE_CHANGE.name] + op_modes_list = self._event_dictionary[td_enum_repository.TDEventList.OP_MODE_CHANGE.name] # If there are Op mode change messages, use it to determine the operation mode for the current submode change # Index description: @@ -161,7 +163,7 @@ # 3: Current Op / Sub Mode if len(op_modes_list) != 0: # Get the Sub Mode Change messages - sub_mode_list = self._event_dictionary[td_enum_repository.TDEventList.TD_EVENT_SUB_MODE_CHANGE.name] + sub_mode_list = self._event_dictionary[td_enum_repository.TDEventList.SUB_MODE_CHANGE.name] last_op_mode_message = op_modes_list[-1] # Check if this is not the very first Sub Mode Change message @@ -192,7 +194,7 @@ # to identify the Op Modes for the Sub Modes else: # Get the Operation Status Change messages - op_status_list = self._event_dictionary[td_enum_repository.TDEventList.TD_EVENT_OPERATION_STATUS.name] + op_status_list = self._event_dictionary[td_enum_repository.TDEventList.OPERATION_STATUS.name] data_2_found = False event_1_op_mode = self.UNKNOWN_STATE @@ -232,8 +234,8 @@ # Update the tuple event_tuple = (current_timestamp, event_enum.name, data_1.value, data_2.value) - elif event_enum is td_enum_repository.TDEventList.TD_EVENT_OPERATION_STATUS: - op_mode_enum, sub_mode_enum, state_enum, _ = self._operation_status_match(op_mode=op_mode, sub_mode=sub_mode, state=sub_state) + elif event_enum is td_enum_repository.TDEventList.OPERATION_STATUS: + op_mode_enum, sub_mode_enum, state_enum, _ = self._operation_status_match(op_mode=op_mode.value, sub_mode=sub_mode.value, state=sub_state.value) event_tuple = (current_timestamp, op_mode_enum, sub_mode_enum, state_enum) # Update event dictionary @@ -303,17 +305,21 @@ return list_of_events - def _operation_status_match(self, op_mode: int, sub_mode: int=None, state:int=None, sub_state: int=None) -> Tuple[DialinEnum, Union[DialinEnum, int], Union[DialinEnum, int], Union[DialinEnum, int]]: + def _operation_status_match(self, op_mode: int, sub_mode: int=None, state:int=None, sub_state: int=None, debug: bool=False) -> Tuple[DialinEnum, Union[DialinEnum, int], Union[DialinEnum, int], Union[DialinEnum, int]]: """ Convert operation status values to enums. :param op_mode: (Integer) The operation mode value :param sub_mode: (Integer) The operation sub mode value :param state: (Integer) The operation state value :param sub_state: (Integer) The operation sub state value + :param debug: (Boolean) Print debug data or not :return: Returns the DialinEnum for each provied mode/state, or the original integer value if no enum is found """ op_mode_enum = td_enum_repository.TDOpModes(op_mode) + if debug: + print(f'\nDebug op_mode: {op_mode}') + print(f'Debug op_mode_enum: {op_mode_enum}') sub_mode_enum = None state_enum = None sub_state_enum = None @@ -322,15 +328,24 @@ sub_mode_enum = sub_mode else: sub_mode_enum = self._op_mode_2_sub_mode[op_mode_enum.name](sub_mode) + if debug: + print(f'Debug sub_mode: {sub_mode}') + print(f'Debug sub_mode_enum: {sub_mode_enum}') if state is not None: - if sub_mode_enum.name not in self._sub_mode_2_states: + if sub_mode_enum.name not in self._sub_mode_2_states or len(self._sub_mode_2_states[sub_mode_enum.name]) < state: state_enum = state else: state_enum = self._sub_mode_2_states[sub_mode_enum.name](state) + if debug: + print(f'Debug state: {state}') + print(f'Debug state_enum: {state_enum}') if sub_state is not None: if state_enum.name not in self._state_2_sub_states: sub_state_enum = sub_state else: sub_state_enum = self._state_2_sub_states[state_enum.name](sub_state) + if debug: + print(f'Debug sub_state: {sub_state}') + print(f'Debug sub_state_enum: {sub_state_enum}') return op_mode_enum, sub_mode_enum, state_enum, sub_state_enum Index: leahi_dialin/td/modules/syringe_pump.py =================================================================== diff -u -rd0dedd8e720be5de357176ffb095484ec082c830 -r27d9de42c0111c7f369cc335889fe6b988d09cc8 --- leahi_dialin/td/modules/syringe_pump.py (.../syringe_pump.py) (revision d0dedd8e720be5de357176ffb095484ec082c830) +++ leahi_dialin/td/modules/syringe_pump.py (.../syringe_pump.py) (revision 27d9de42c0111c7f369cc335889fe6b988d09cc8) @@ -16,6 +16,7 @@ # Module imports from logging import Logger +import time from typing import Union # Project imports @@ -64,14 +65,15 @@ self.h10_pump_adc_dac_status = 0 self.h10_pump_adc_read_counter = 0 self.td_syringe_pump_timestamp = 0.0 #: The timestamp of the syringe pump message + self.handler_execution_times = [] # ============================================================ Properties ============================================================ @property def h10_pump_state(self) -> TDTreaSyringePumpStates: """ - The Srynge Pump State + The Syringe Pump State """ return self._h10_pump_state @@ -264,6 +266,7 @@ @param message: published syringe pump data message @return: None """ + start = time.perf_counter() msg_list = [] msg_list.append((type(self).h10_pump_state, DataTypes.U32)) msg_list.append((type(self).heparin_state, DataTypes.U32)) @@ -282,9 +285,9 @@ self.process_into_vars(decoder_list = msg_list, message = message) self.td_syringe_pump_timestamp = timestamp + self.handler_execution_times.append((timestamp, message, time.perf_counter() - start)) - # ============================================================ Overrides and Requests ============================================================ def cmd_syringe_pump_operation(self, operation: int = TDSyringePumpStates.STOP.value, rate: float = 0.0, Index: leahi_dialin/td/proxies/ui_proxy.py =================================================================== diff -u -r99a91733f7775005505b9f0671863392526cc1d4 -r27d9de42c0111c7f369cc335889fe6b988d09cc8 --- leahi_dialin/td/proxies/ui_proxy.py (.../ui_proxy.py) (revision 99a91733f7775005505b9f0671863392526cc1d4) +++ leahi_dialin/td/proxies/ui_proxy.py (.../ui_proxy.py) (revision 27d9de42c0111c7f369cc335889fe6b988d09cc8) @@ -21,8 +21,8 @@ # Project imports from leahi_dialin.common.constants import ACCEPTED from leahi_dialin.common.generic_defs import DataTypes -from leahi_dialin.common.msg_ids import MsgIds from leahi_dialin.common.msg_defs import RequestRejectReasons +from leahi_dialin.common.msg_ids import MsgIds from leahi_dialin.common.override_templates import cmd_generic_override from leahi_dialin.protocols.CAN import CanMessenger, CanChannels from leahi_dialin.utils.abstract_classes import AbstractSubSystem @@ -53,7 +53,7 @@ function = self._handler_tx_parameters_val_resp_sync) self.can_interface.register_receiving_publication_function(channel_id = CanChannels.td_to_ui_ch_id, - message_id = MsgIds.MSG_ID_TD_RESP_ULTRAFILTRATION_VOLUME_TO_VALIDATE.value, + message_id = MsgIds.MSG_ID_TD_TREATMENT_UF_VOLUME_VALIDATE_RESPONSE.value, function = self._handler_uf_val_resp_sync) self.can_interface.register_receiving_publication_function(channel_id = CanChannels.td_to_ui_ch_id, @@ -441,15 +441,16 @@ can_interface = self.can_interface) - def cmd_send_ui_initiate_treatment(self, modularity: int, accepted:int = ACCEPTED ) -> None: + def cmd_send_ui_initiate_treatment(self, modality: int=0, accepted:int = ACCEPTED ) -> None: """ Constructs and sends a UI initiate treatment message. - :param accepted: (int) the acceptance value + :param modality: (int) The treatment modality, HD = 0, HDF = 1, HD with HDF cartridge = 2 + :param accepted: (int) The acceptance value :return: none """ payload = integer_to_bytearray(accepted) - payload += integer_to_bytearray(modularity) + payload += integer_to_bytearray(modality) cmd_generic_override(payload = payload, reset = None, @@ -474,7 +475,7 @@ cmd_generic_override(payload = payload, reset = None, channel_id = CanChannels.ui_to_td_ch_id, - msg_id = MsgIds.MSG_ID_UI_TREATMENT_PARAMS_CONFIRMED, + msg_id = MsgIds.MSG_ID_TD_VALIDATED_TREATMENT_PARAMS, entity_name = 'UI Confirm Treatment Parameters', override_text = 'N/A', logger = self.logger, @@ -516,7 +517,7 @@ cmd_generic_override(payload = payload, reset = None, channel_id = CanChannels.ui_to_td_ch_id, - msg_id = MsgIds.MSG_ID_UI_ULTRAFILTRATION_VOLUME_TO_VALIDATE, + msg_id = MsgIds.MSG_ID_UI_TREATMENT_UF_VOLUME_VALIDATE_REQUEST, entity_name = 'Validate UI Ultrafiltration Volume', override_text = 'N/A', logger = self.logger,