Index: leahi_dialin/common/dd_defs.py =================================================================== diff -u -r862daa5b6357ddaba02aa7d1fb9d0952e4a16e6f -rd0dedd8e720be5de357176ffb095484ec082c830 --- leahi_dialin/common/dd_defs.py (.../dd_defs.py) (revision 862daa5b6357ddaba02aa7d1fb9d0952e4a16e6f) +++ leahi_dialin/common/dd_defs.py (.../dd_defs.py) (revision d0dedd8e720be5de357176ffb095484ec082c830) @@ -316,47 +316,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': [], } @@ -734,24 +734,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 -r9c1ee405a484654486ee23393f0b8e6b33a17154 -rd0dedd8e720be5de357176ffb095484ec082c830 --- leahi_dialin/common/fp_defs.py (.../fp_defs.py) (revision 9c1ee405a484654486ee23393f0b8e6b33a17154) +++ leahi_dialin/common/fp_defs.py (.../fp_defs.py) (revision d0dedd8e720be5de357176ffb095484ec082c830) @@ -230,76 +230,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': [], } @@ -308,33 +308,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': [], } @@ -551,20 +552,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': [], } @@ -617,31 +618,31 @@ @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 -rf6b3070973f4211a2b3330426ffecc49055fd43a -rd0dedd8e720be5de357176ffb095484ec082c830 --- leahi_dialin/common/td_defs.py (.../td_defs.py) (revision f6b3070973f4211a2b3330426ffecc49055fd43a) +++ leahi_dialin/common/td_defs.py (.../td_defs.py) (revision d0dedd8e720be5de357176ffb095484ec082c830) @@ -78,161 +78,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_TUBING_SET_INSTALL_STATE = 0 # Tube set install state - TD_PRE_TREATMENT_SELF_TEST_DRY_STATE = 1 # Self-tests when the cartridge is dry state - TD_PRE_TREATMENT_PRIME_STATE = 2 # Prime blood and dialysate circuits and run wet self-tests state - TD_PRE_TREATMENT_RECIRCULATE_STATE = 3 # Re-circulate blood and dialysate circuits state - TD_PRE_TREATMENT_CONFIRM_RX_STATE = 4 # User reviews and confirms prescription ( Confirm Rx ) - TD_PRE_TREATMENT_HEPARIN_SETUP_STATE = 5 # Heparin setup state - TD_PRE_TREATMENT_PATIENT_CONNECTION_STATE = 6 # Patient connection state - NUM_OF_TD_PRE_TREATMENT_STATES = 7 # 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_TUBING_SET_INSTALL_STATE': ['tubing set install', '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_HEPARIN_SETUP_STATE': ['heparin setup'], - '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': [], } @@ -253,150 +253,150 @@ # TDPreTreatmentModesStates.TD_PRE_TREATMENT_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 @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 @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 @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 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': [], } @@ -419,35 +419,35 @@ # TDPreTreatmentModesStates.TD_PRE_TREATMENT_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 @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': [], } @@ -470,62 +470,62 @@ # TDTreatmentStates.TREATMENT_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 @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 @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': [], } @@ -550,47 +550,68 @@ # 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 @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': [], } @@ -600,133 +621,133 @@ # TDPreTreatmentModesStates.TD_PRE_TREATMENT_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 @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 @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': [], } @@ -735,63 +756,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': [], } @@ -883,6 +904,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 @@ -935,6 +968,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 @@ -1007,15 +1052,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 ': [] } @@ -1110,28 +1155,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': [], } @@ -1167,6 +1212,7 @@ 'NUM_OF_SWITCH_STATES': [], } + # Syringe pump operations @unique class TDSyringePumpStates(DialinEnum): @@ -1231,56 +1277,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/dd/modules/blood_leak.py =================================================================== diff -u -rba415df9f8e76d6b0f21e8f69ba99346e42f7b09 -rd0dedd8e720be5de357176ffb095484ec082c830 --- leahi_dialin/dd/modules/blood_leak.py (.../blood_leak.py) (revision ba415df9f8e76d6b0f21e8f69ba99346e42f7b09) +++ leahi_dialin/dd/modules/blood_leak.py (.../blood_leak.py) (revision d0dedd8e720be5de357176ffb095484ec082c830) @@ -75,7 +75,7 @@ self.dd_blood_leak_status_timestamp = 0.0 #: The timestamp of the last Blood Leak data message self.dd_blood_leak_emb_mode_response_timestamp = 0.0 #: The timestamp of the last Emb Mode response message self.blood_leak_status = False - self.blood_leak_state = dd_enum_repository.DDBloodLeakStates.BLOOD_LEAK_INIT_STATE + self.blood_leak_state = dd_enum_repository.DDBloodLeakStates.INIT_STATE self.blood_leak_error_persistent_ctr = 0 self.blood_leak_serial_comm_state = 0 self.blood_leak_intensity = 0 @@ -85,6 +85,7 @@ self.blood_leak_upper_range_drift_status = 0 self.blood_leak_time_elapsed_since_last_drift_zero_ms = 0 + self.blood_leak_emb_mode_cmds = {} for cmd in EmbModeCommands.__members__: # Initialize all the embedded mode commands self.blood_leak_emb_mode_cmds[cmd] = '' Index: leahi_dialin/dd/modules/events.py =================================================================== diff -u -r3b0a81ce7a7bee195a26fdcb9f1ad387088fb26d -rd0dedd8e720be5de357176ffb095484ec082c830 --- leahi_dialin/dd/modules/events.py (.../events.py) (revision 3b0a81ce7a7bee195a26fdcb9f1ad387088fb26d) +++ leahi_dialin/dd/modules/events.py (.../events.py) (revision d0dedd8e720be5de357176ffb095484ec082c830) @@ -103,7 +103,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)) @@ -127,15 +127,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: @@ -145,7 +145,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 @@ -176,7 +176,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 @@ -216,7 +216,7 @@ # 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: + 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) Index: leahi_dialin/fp/modules/events.py =================================================================== diff -u -r3b0a81ce7a7bee195a26fdcb9f1ad387088fb26d -rd0dedd8e720be5de357176ffb095484ec082c830 --- leahi_dialin/fp/modules/events.py (.../events.py) (revision 3b0a81ce7a7bee195a26fdcb9f1ad387088fb26d) +++ leahi_dialin/fp/modules/events.py (.../events.py) (revision d0dedd8e720be5de357176ffb095484ec082c830) @@ -105,7 +105,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)) @@ -131,15 +131,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: @@ -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[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 @@ -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[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 @@ -220,7 +220,7 @@ # 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: + 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) Index: leahi_dialin/fp/modules/levels.py =================================================================== diff -u -rba415df9f8e76d6b0f21e8f69ba99346e42f7b09 -rd0dedd8e720be5de357176ffb095484ec082c830 --- leahi_dialin/fp/modules/levels.py (.../levels.py) (revision ba415df9f8e76d6b0f21e8f69ba99346e42f7b09) +++ leahi_dialin/fp/modules/levels.py (.../levels.py) (revision d0dedd8e720be5de357176ffb095484ec082c830) @@ -51,7 +51,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 } Index: leahi_dialin/fp/modules/ro_pump.py =================================================================== diff -u -rba415df9f8e76d6b0f21e8f69ba99346e42f7b09 -rd0dedd8e720be5de357176ffb095484ec082c830 --- leahi_dialin/fp/modules/ro_pump.py (.../ro_pump.py) (revision ba415df9f8e76d6b0f21e8f69ba99346e42f7b09) +++ leahi_dialin/fp/modules/ro_pump.py (.../ro_pump.py) (revision d0dedd8e720be5de357176ffb095484ec082c830) @@ -50,7 +50,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 -rba415df9f8e76d6b0f21e8f69ba99346e42f7b09 -rd0dedd8e720be5de357176ffb095484ec082c830 --- leahi_dialin/fp/modules/valves.py (.../valves.py) (revision ba415df9f8e76d6b0f21e8f69ba99346e42f7b09) +++ leahi_dialin/fp/modules/valves.py (.../valves.py) (revision d0dedd8e720be5de357176ffb095484ec082c830) @@ -53,14 +53,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 -r43f69b19f03145572d88f5f3c0cc739503c6d647 -rd0dedd8e720be5de357176ffb095484ec082c830 --- leahi_dialin/td/modules/ejector.py (.../ejector.py) (revision 43f69b19f03145572d88f5f3c0cc739503c6d647) +++ leahi_dialin/td/modules/ejector.py (.../ejector.py) (revision d0dedd8e720be5de357176ffb095484ec082c830) @@ -51,7 +51,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 -r3b0a81ce7a7bee195a26fdcb9f1ad387088fb26d -rd0dedd8e720be5de357176ffb095484ec082c830 --- leahi_dialin/td/modules/events.py (.../events.py) (revision 3b0a81ce7a7bee195a26fdcb9f1ad387088fb26d) +++ leahi_dialin/td/modules/events.py (.../events.py) (revision d0dedd8e720be5de357176ffb095484ec082c830) @@ -61,25 +61,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_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. @@ -120,7 +120,7 @@ event_enum = td_enum_repository.TDEventList(event_id.value) msg_list_2 = [] - if event_enum is td_enum_repository.TDEventList.TD_EVENT_OPERATION_STATUS: + 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)) @@ -142,14 +142,14 @@ # 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: @@ -159,7 +159,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 @@ -190,7 +190,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 @@ -230,7 +230,7 @@ # 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: + 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) Index: leahi_dialin/td/modules/syringe_pump.py =================================================================== diff -u -r37b10a13237bfde8838547a83f8dcc3f8818bf0d -rd0dedd8e720be5de357176ffb095484ec082c830 --- leahi_dialin/td/modules/syringe_pump.py (.../syringe_pump.py) (revision 37b10a13237bfde8838547a83f8dcc3f8818bf0d) +++ leahi_dialin/td/modules/syringe_pump.py (.../syringe_pump.py) (revision d0dedd8e720be5de357176ffb095484ec082c830) @@ -49,38 +49,38 @@ message_id = MsgIds.MSG_ID_TD_SYRINGE_PUMP_DATA.value, function = self._handler_syringe_pump_data) - self.syringe_pump_state = TDTreaSyringePumpStates.SYRINGE_PUMP_INIT_STATE - self.heparin_state = TDTreaHeparinStates.HEPARIN_STATE_OFF - self.syringe_pump_set_rate_ml_hr = 0.0 - self.syringe_pump_meas_rate_ml_hr = 0.0 - self.syringe_pump_position = 0 - self.syringe_pump_volume_ml = 0.0 - self.syringe_pump_safety_volume_ml = 0.0 - self.syringe_pump_home_v = 0.0 - self.syringe_pump_switch_v = 0.0 - self.syringe_pump_force_v = 0.0 - self.syringe_pump_status = TDSyringePumpStates.STOP - self.syringe_pump_encoder_status = 0 - self.syringe_pump_adc_dac_status = 0 - self.syringe_pump_adc_read_counter = 0 + self.h10_pump_state = TDTreaSyringePumpStates.INIT_STATE + self.heparin_state = TDTreaHeparinStates.OFF + self.h10_pump_set_rate_ml_hr = 0.0 + self.h10_pump_meas_rate_ml_hr = 0.0 + self.h10_pump_position = 0 + self.h10_pump_volume_ml = 0.0 + self.h10_pump_safety_volume_ml = 0.0 + self.h10_pump_home_v = 0.0 + self.h10_pump_switch_v = 0.0 + self.h10_pump_force_v = 0.0 + self.h10_pump_status = TDSyringePumpStates.STOP + self.h10_pump_encoder_status = 0 + 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 # ============================================================ Properties ============================================================ @property - def syringe_pump_state(self) -> TDTreaSyringePumpStates: + def h10_pump_state(self) -> TDTreaSyringePumpStates: """ The Srynge Pump State """ - return self._syringe_pump_state + return self._h10_pump_state - @syringe_pump_state.setter - def syringe_pump_state(self, value: Union[int, DialinEnum]): + @h10_pump_state.setter + def h10_pump_state(self, value: Union[int, DialinEnum]): if isinstance(value, int): - self._syringe_pump_state = TDTreaSyringePumpStates(value) + self._h10_pump_state = TDTreaSyringePumpStates(value) else: - self._syringe_pump_state = value + self._h10_pump_state = value @property @@ -99,162 +99,163 @@ @property - def syringe_pump_set_rate_ml_hr(self) -> float: + def h10_pump_set_rate_ml_hr(self) -> float: """ The Set Syringe Pump rate """ - return self._syringe_pump_set_rate_ml_hr + return self._h10_pump_set_rate_ml_hr - @syringe_pump_set_rate_ml_hr.setter - def syringe_pump_set_rate_ml_hr(self, value): - self._syringe_pump_set_rate_ml_hr = value + @h10_pump_set_rate_ml_hr.setter + def h10_pump_set_rate_ml_hr(self, value): + self._h10_pump_set_rate_ml_hr = value @property - def syringe_pump_meas_rate_ml_hr(self) -> float: + def h10_pump_meas_rate_ml_hr(self) -> float: """ The Measured Syringe Pump rate """ - return self._syringe_pump_meas_rate_ml_hr + return self._h10_pump_meas_rate_ml_hr - @syringe_pump_meas_rate_ml_hr.setter - def syringe_pump_meas_rate_ml_hr(self, value): - self._syringe_pump_meas_rate_ml_hr = value + @h10_pump_meas_rate_ml_hr.setter + def h10_pump_meas_rate_ml_hr(self, value): + self._h10_pump_meas_rate_ml_hr = value @property - def syringe_pump_position(self) -> int: + def h10_pump_position(self) -> int: """ The Syringe Pump position """ - return self._syringe_pump_position + return self._h10_pump_position - @syringe_pump_position.setter - def syringe_pump_position(self, value): - self._syringe_pump_position = value + @h10_pump_position.setter + def h10_pump_position(self, value): + self._h10_pump_position = value @property - def syringe_pump_volume_ml(self) -> float: + def h10_pump_volume_ml(self) -> float: """ The Syringe Pump volume delivered in ml """ - return self._syringe_pump_volume_ml + return self._h10_pump_volume_ml - @syringe_pump_volume_ml.setter - def syringe_pump_volume_ml(self, value): - self._syringe_pump_volume_ml = value + @h10_pump_volume_ml.setter + def h10_pump_volume_ml(self, value): + self._h10_pump_volume_ml = value @property - def syringe_pump_safety_volume_ml(self) -> float: + def h10_pump_safety_volume_ml(self) -> float: """ The Syringe Pump safety volume reading """ - return self._syringe_pump_safety_volume_ml + return self._h10_pump_safety_volume_ml - @syringe_pump_safety_volume_ml.setter - def syringe_pump_safety_volume_ml(self, value): - self._syringe_pump_safety_volume_ml = value + @h10_pump_safety_volume_ml.setter + def h10_pump_safety_volume_ml(self, value): + self._h10_pump_safety_volume_ml = value @property - def syringe_pump_home_v(self) -> float: + def h10_pump_home_v(self) -> float: """ The Syringe Pump home voltage reading """ - return self._syringe_pump_home_v + return self._h10_pump_home_v - @syringe_pump_home_v.setter - def syringe_pump_home_v(self, value): - self._syringe_pump_home_v = value + @h10_pump_home_v.setter + def h10_pump_home_v(self, value): + self._h10_pump_home_v = value @property - def syringe_pump_switch_v(self) -> float: + def h10_pump_switch_v(self) -> float: """ The Syringe Pump switch voltage reading """ - return self._syringe_pump_switch_v + return self._h10_pump_switch_v - @syringe_pump_switch_v.setter - def syringe_pump_switch_v(self, value): - self._syringe_pump_switch_v = value + @h10_pump_switch_v.setter + def h10_pump_switch_v(self, value): + self._h10_pump_switch_v = value @property - def syringe_pump_force_v(self) -> float: + def h10_pump_force_v(self) -> float: """ The Syringe Pump force voltage reading """ - return self._syringe_pump_force_v + return self._h10_pump_force_v - @syringe_pump_force_v.setter - def syringe_pump_force_v(self, value): - self._syringe_pump_force_v = value + @h10_pump_force_v.setter + def h10_pump_force_v(self, value): + self._h10_pump_force_v = value @property - def syringe_pump_status(self) -> TDSyringePumpStates: + def h10_pump_status(self) -> TDSyringePumpStates: """ The Syringe Pump status """ - return self._syringe_pump_status + return self._h10_pump_status - @syringe_pump_status.setter - def syringe_pump_status(self, value: Union[int, DialinEnum]): + @h10_pump_status.setter + def h10_pump_status(self, value: Union[int, DialinEnum]): if isinstance(value, int): - self._syringe_pump_status = TDSyringePumpStates(value) + self._h10_pump_status = TDSyringePumpStates(value) else: - self._syringe_pump_status = value + self._h10_pump_status = value @property - def syringe_pump_encoder_status(self) -> int: + def h10_pump_encoder_status(self) -> int: """ The Syringe Pump encoder status """ - return self._syringe_pump_encoder_status + return self._h10_pump_encoder_status - @syringe_pump_encoder_status.setter - def syringe_pump_encoder_status(self, value): - self._syringe_pump_encoder_status = value + @h10_pump_encoder_status.setter + def h10_pump_encoder_status(self, value): + self._h10_pump_encoder_status = value @property - def syringe_pump_adc_dac_status(self) -> int: + def h10_pump_adc_dac_status(self) -> int: """ The Syringe Pump ADC & DAC status """ - return self._syringe_pump_adc_dac_status + return self._h10_pump_adc_dac_status - @syringe_pump_adc_dac_status.setter - def syringe_pump_adc_dac_status(self, value): - self._syringe_pump_adc_dac_status = value + @h10_pump_adc_dac_status.setter + def h10_pump_adc_dac_status(self, value): + self._h10_pump_adc_dac_status = value @property - def syringe_pump_adc_read_counter(self) -> int: + def h10_pump_adc_read_counter(self) -> int: """ The Syringe Pump ADC read counter """ - return self._syringe_pump_adc_read_counter + return self._h10_pump_adc_read_counter - @syringe_pump_adc_read_counter.setter - def syringe_pump_adc_read_counter(self, value): - self._syringe_pump_adc_read_counter = value + @h10_pump_adc_read_counter.setter + def h10_pump_adc_read_counter(self, value): + self._h10_pump_adc_read_counter = value # ============================================================ Handlers ============================================================ - @publish(["td_syringe_pump_timestamp", - "syringe_pump_state", "syringe_pump_set_rate_ml_hr", - "syringe_pump_meas_rate_ml_hr", "syringe_pump_position", - "syringe_pump_volume_ml", "syringe_pump_home_v", - "syringe_pump_switch_v", "syringe_pump_force_v", - "heparin_state", "syringe_pump_safety_volume_ml", - "syringe_pump_status", "syringe_pump_encoder_status", - "syringe_pump_adc_dac_status", "syringe_pump_adc_read_counter"]) + @publish([MsgIds.MSG_ID_TD_SYRINGE_PUMP_DATA.name, + "h10_pump_state", "h10_pump_set_rate_ml_hr", + "h10_pump_meas_rate_ml_hr", "h10_pump_position", + "h10_pump_volume_ml", "h10_pump_home_v", + "h10_pump_switch_v", "h10_pump_force_v", + "heparin_state", "h10_pump_safety_volume_ml", + "h10_pump_status", "h10_pump_encoder_status", + "h10_pump_adc_dac_status", "h10_pump_adc_read_counter", + "td_syringe_pump_timestamp"]) def _handler_syringe_pump_data(self, message, timestamp=0.0): """ Handles published syringe pump data messages. Syringe pump data are captured @@ -264,20 +265,20 @@ @return: None """ msg_list = [] - msg_list.append((type(self).syringe_pump_state, DataTypes.U32)) - msg_list.append((type(self).heparin_state, DataTypes.U32)) - msg_list.append((type(self).syringe_pump_set_rate_ml_hr, DataTypes.F32)) - msg_list.append((type(self).syringe_pump_meas_rate_ml_hr, DataTypes.F32)) - msg_list.append((type(self).syringe_pump_position, DataTypes.U32)) - msg_list.append((type(self).syringe_pump_volume_ml, DataTypes.F32)) - msg_list.append((type(self).syringe_pump_home_v, DataTypes.F32)) - msg_list.append((type(self).syringe_pump_switch_v, DataTypes.F32)) - msg_list.append((type(self).syringe_pump_force_v, DataTypes.F32)) - msg_list.append((type(self).syringe_pump_safety_volume_ml, DataTypes.F32)) - msg_list.append((type(self).syringe_pump_status, DataTypes.U08)) - msg_list.append((type(self).syringe_pump_encoder_status, DataTypes.U08)) - msg_list.append((type(self).syringe_pump_adc_dac_status, DataTypes.U08)) - msg_list.append((type(self).syringe_pump_adc_read_counter, DataTypes.U08)) + msg_list.append((type(self).h10_pump_state, DataTypes.U32)) + msg_list.append((type(self).heparin_state, DataTypes.U32)) + msg_list.append((type(self).h10_pump_set_rate_ml_hr, DataTypes.F32)) + msg_list.append((type(self).h10_pump_meas_rate_ml_hr, DataTypes.F32)) + msg_list.append((type(self).h10_pump_position, DataTypes.U32)) + msg_list.append((type(self).h10_pump_volume_ml, DataTypes.F32)) + msg_list.append((type(self).h10_pump_home_v, DataTypes.F32)) + msg_list.append((type(self).h10_pump_switch_v, DataTypes.F32)) + msg_list.append((type(self).h10_pump_force_v, DataTypes.F32)) + msg_list.append((type(self).h10_pump_safety_volume_ml, DataTypes.F32)) + msg_list.append((type(self).h10_pump_status, DataTypes.U08)) + msg_list.append((type(self).h10_pump_encoder_status, DataTypes.U08)) + msg_list.append((type(self).h10_pump_adc_dac_status, DataTypes.U08)) + msg_list.append((type(self).h10_pump_adc_read_counter, DataTypes.U08)) self.process_into_vars(decoder_list = msg_list, message = message) self.td_syringe_pump_timestamp = timestamp @@ -307,12 +308,12 @@ @return: 1 if successful, zero otherwise Syringe pump operation IDs: - SYRINGE_PUMP_OP_STOP = 0 - SYRINGE_PUMP_OP_RETRACT = 1 - SYRINGE_PUMP_OP_SEEK = 2 - SYRINGE_PUMP_OP_PRIME = 3 - SYRINGE_PUMP_OP_BOLUS = 4 - SYRINGE_PUMP_OP_CONTINUOUS = 5 + STOP = 0 + RETRACT = 1 + SEEK = 2 + PRIME = 3 + BOLUS = 4 + CONTINUOUS = 5 """ op = integer_to_bytearray(operation) rat = float_to_bytearray(rate)