Index: leahi-dialin/common/__init__.py =================================================================== diff -u -r07db7b5f01ad17d60c190e21574e1ed0552535ff -r12b82879196778f6c83d08751652177ea0fcbf5e --- leahi-dialin/common/__init__.py (.../__init__.py) (revision 07db7b5f01ad17d60c190e21574e1ed0552535ff) +++ leahi-dialin/common/__init__.py (.../__init__.py) (revision 12b82879196778f6c83d08751652177ea0fcbf5e) @@ -2,6 +2,6 @@ from .alarm_priorities import * from .msg_defs import * from .prs_defs import * -from .hd_defs import * -from .dg_defs import * +from .td_defs import * +from .dd_defs import * from .ui_defs import * Index: leahi-dialin/common/alarm_defs.py =================================================================== diff -u -r07db7b5f01ad17d60c190e21574e1ed0552535ff -r12b82879196778f6c83d08751652177ea0fcbf5e --- leahi-dialin/common/alarm_defs.py (.../alarm_defs.py) (revision 07db7b5f01ad17d60c190e21574e1ed0552535ff) +++ leahi-dialin/common/alarm_defs.py (.../alarm_defs.py) (revision 12b82879196778f6c83d08751652177ea0fcbf5e) @@ -21,326 +21,61 @@ @unique class AlarmList(AlarmEnum): ALARM_ID_NO_ALARM = 0 - ALARM_ID_HD_STUCK_BUTTON_TEST_FAILED = 1 - ALARM_ID_HD_FPGA_POST_TEST_FAILED = 2 - ALARM_ID_DG_FPGA_POST_TEST_FAILED = 3 - ALARM_ID_HD_WATCHDOG_POST_TEST_FAILED = 4 - ALARM_ID_DG_WATCHDOG_POST_TEST_FAILED = 5 - ALARM_ID_HD_UI_COMM_POST_FAILED = 6 - ALARM_ID_HD_RTC_BATTERY_LOW = 7 - ALARM_ID_HD_ACCELEROMETER_SELF_TEST_FAILURE = 8 - ALARM_ID_DG_ACCELEROMETER_SELF_TEST_FAILURE = 9 - ALARM_ID_HD_BLOOD_LEAK_SENSOR_EMBEDDED_MODE_FAILURE = 10 - ALARM_ID_HD_DIALYSATE_TEMP_BELOW_TARGET_TEMP = 11 - ALARM_ID_HD_INTEGRITY_POST_TEST_FAILED = 12 - ALARM_ID_DG_INTEGRITY_POST_TEST_FAILED = 13 - ALARM_ID_DG_INVALID_USAGE_RECORD_CRC = 14 - ALARM_ID_HD_DIALYSATE_TEMP_ABOVE_SAFETY_TEMP = 15 - ALARM_ID_HD_ALARM_AUDIO_SELF_TEST_FAILURE = 16 - ALARM_ID_HD_UI_POST_TIMEOUT = 17 - ALARM_ID_HD_CAN_MESSAGE_NOT_ACKED_BY_DG = 18 - ALARM_ID_HD_DIALYSATE_TEMP_ABOVE_TARGET_TEMP = 19 - ALARM_ID_DG_COND_SENSORS_INVALID_CAL_RECORD = 20 - ALARM_ID_DG_DRAIN_LINE_VOLUME_INVALID_CAL_RECORD = 21 - ALARM_ID_DG_RESERVOIRS_INVALID_CAL_RECORD = 22 - ALARM_ID_DG_ACID_CONCENTRATE_INVALID_CAL_RECORD = 23 - ALARM_ID_DG_BICARB_CONCENTRATE_INVALID_CAL_RECORD = 24 - ALARM_ID_DG_ACCELEROMETERS_INVALID_CAL_RECORD = 25 - ALARM_ID_HD_ACCELEROMETERS_INVALID_CAL_RECORD = 26 - ALARM_ID_HD_BLOOD_LEAK_SENSOR_ZERO_SEQUENCE_FAILED = 27 - ALARM_ID_DG_TWO_WIRE_SENSORS_FPGA_FAULT = 28 - ALARM_ID_HD_HEPARIN_FORCE_SENSOR_INVALID_CAL_RECORD = 29 - ALARM_ID_HD_SOFTWARE_FAULT = 30 - ALARM_ID_HD_BLOOD_PUMP_MC_CURRENT_CHECK = 31 - ALARM_ID_HD_BLOOD_PUMP_OFF_CHECK = 32 - ALARM_ID_HD_BLOOD_PUMP_MC_DIRECTION_CHECK = 33 - ALARM_ID_HD_BLOOD_PUMP_ROTOR_SPEED_CHECK = 34 - ALARM_ID_HD_DIAL_IN_PUMP_MC_CURRENT_CHECK = 35 - ALARM_ID_HD_DIAL_IN_PUMP_OFF_CHECK = 36 - ALARM_ID_HD_DIAL_IN_PUMP_MC_DIRECTION_CHECK = 37 - ALARM_ID_HD_DIAL_IN_PUMP_ROTOR_SPEED_CHECK = 38 - ALARM_ID_HD_DIAL_OUT_PUMP_MC_CURRENT_CHECK = 39 - ALARM_ID_HD_DIAL_OUT_PUMP_OFF_CHECK = 40 - ALARM_ID_HD_DIAL_OUT_PUMP_MC_DIRECTION_CHECK = 41 - ALARM_ID_HD_DIAL_OUT_PUMP_ROTOR_SPEED_CHECK = 42 - ALARM_ID_DG_MAIN_PRIMARY_HEATER_FPGA_FAULT = 43 - ALARM_ID_HD_UI_COMM_TIMEOUT = 44 - ALARM_ID_HD_COMM_TOO_MANY_BAD_CRCS = 45 - ALARM_ID_HD_CAN_MESSAGE_NOT_ACKED_BY_UI = 46 - ALARM_ID_DG_MAX_RO_PUMP_PWM_EXCEEDED = 47 - ALARM_ID_HD_UF_VOLUME_ACCURACY_ERROR = 48 - ALARM_ID_HD_FPGA_COMM_TIMEOUT = 49 - ALARM_ID_DG_VALVE_CONTROL_FAILURE = 50 - ALARM_ID_HD_BLOOD_PUMP_MOTOR_SPEED_CHECK = 51 - ALARM_ID_HD_DIAL_IN_PUMP_MOTOR_SPEED_CHECK = 52 - ALARM_ID_HD_DIAL_OUT_PUMP_MOTOR_SPEED_CHECK = 53 - ALARM_ID_HD_CRITICAL_DATA_ERROR = 54 - ALARM_ID_DG_CRITICAL_DATA_ERROR = 55 - ALARM_ID_HD_ACCELEROMETER_FAILURE = 56 - ALARM_ID_DG_ACCELEROMETER_FAILURE = 57 - ALARM_ID_HD_VALVE_HOMING_FAILED = 58 - ALARM_ID_HD_VALVE_TRANSITION_TIMEOUT = 59 - ALARM_ID_HD_VALVE_NOT_FUNCTIONAL = 60 - ALARM_ID_HD_VALVE_CURRENT_OUT_OF_RANGE = 61 - ALARM_ID_HD_VALVE_POSITION_OUT_OF_RANGE = 62 - ALARM_ID_HD_SYRINGE_PUMP_PRIME_TIMEOUT = 63 - ALARM_ID_DG_BARO_PRESSURE_OUT_OF_RANGE = 64 - ALARM_ID_HD_DG_COMMAND_INVALID_PARAMETER_FAULT = 65 - ALARM_ID_HD_BLOOD_LEAK_SENSOR_SET_POINT_SET_FAILURE = 66 - ALARM_ID_HD_BP_OCCLUSION_SELF_TEST_FAILURE = 67 - ALARM_ID_HD_ACTIVE_RESERVOIR_RECIRCULATION_OUT_OF_RANGE = 68 - ALARM_ID_HD_BLOOD_LEAK_INVALID_CAL_RECORD = 69 - ALARM_ID_HD_ARTERIAL_PRESSURE_SELF_TEST_FAILURE = 70 - ALARM_ID_HD_VENOUS_PRESSURE_SELF_TEST_FAILURE = 71 - ALARM_ID_HD_NEW_LOAD_CELL_DATA_MESSAGE_NOT_RECEIVE = 72 - ALARM_ID_HD_NEW_DIALYSATE_TEMP_DATA_MESSAGE_NOT_RECEIVE = 73 - ALARM_ID_DG_INLET_UV_REACTOR_ON_WITH_NO_FLOW = 74 - ALARM_ID_HD_SYRINGE_PUMP_SELF_TEST_FAILURE = 75 - ALARM_ID_HD_VOLTAGE_OUT_OF_RANGE = 76 - ALARM_ID_DG_VOLTAGE_OUT_OF_RANGE = 77 - ALARM_ID_HD_SYRINGE_PUMP_ENCODER_DIRECTION_ERROR = 78 - ALARM_ID_HD_SYRINGE_PUMP_CONTROLLER_DIRECTION_ERROR = 79 - ALARM_ID_HD_SYRINGE_PUMP_FAULT = 80 - ALARM_ID_HD_SYRINGE_PUMP_OVER_TRAVEL_ERROR = 81 - ALARM_ID_HD_SYRINGE_PUMP_DAC_WRITE_ERROR = 82 - ALARM_ID_HD_SYRINGE_PUMP_RUNNING_WHILE_BP_OFF_ERROR = 83 - ALARM_ID_DG_SET_RTC_YEAR_INVALID = 84 - ALARM_ID_HD_PUMP_TRACK_LATCH_OPENED = 85 - ALARM_ID_HD_SET_RTC_YEAR_INVALID = 86 - ALARM_ID_DG_HEATING_INVALID_CAL_RECORD = 87 - ALARM_ID_DG_CONC_PUMP_HALL_SENSOR_OUT_OF_RANGE = 88 - ALARM_ID_DG_OUTLET_UV_REACTOR_ON_WITH_NO_FLOW = 89 - ALARM_ID_DG_LOAD_CELL_A1_B1_FPGA_FAULT = 90 - ALARM_ID_HD_DIALYSATE_FLOW_DATA_NOT_RECEIVE = 91 - ALARM_ID_DG_TEMPERATURE_SENSORS_INVALID_CAL_RECORD = 92 - ALARM_ID_DG_OUTLET_PRIMARY_CONDUCTIVITY_OUT_OF_RANGE = 93 - ALARM_ID_DG_PRESSURE_OUT_OF_RANGE = 94 - ALARM_ID_DG_WATCHDOG_EXPIRED = 95 - ALARM_ID_DG_INLET_WATER_TEMPERATURE_IN_HIGH_RANGE = 96 - ALARM_ID_DG_FILL_CONDUCTIVITY_OUT_OF_RANGE = 97 - ALARM_ID_HD_BATTERY_COMM_FAULT = 98 - ALARM_ID_HD_SYRINGE_PUMP_STALL = 99 - ALARM_ID_DG_COND_SENSORS_INVALID_TEMP_COMP_CAL_RECORD = 100 - ALARM_ID_UI_POST_HD_COMM = 101 - ALARM_ID_DG_HEAT_DISINFECT_TEMP_GRAD_OUT_OF_RANGE = 102 - ALARM_ID_HD_NVDATAMGMT_CAL_GROUP_RECORD_CRC_INVALID = 103 - ALARM_ID_HD_AIR_TRAP_ILLEGAL_LEVELS = 104 - ALARM_ID_DG_NVDATAMGMT_CAL_GROUP_RECORD_CRC_INVALID = 105 - ALARM_ID_DG_FLOW_SENSORS_INVALID_CAL_RECORD = 106 - ALARM_ID_HD_DG_RESTARTED_FAULT = 107 - ALARM_ID_HD_SYRINGE_PUMP_FPGA_ADC_FAULT = 108 - ALARM_ID_HD_SYRINGE_PUMP_VOLUME_ERROR = 109 - ALARM_ID_HD_SYRINGE_PUMP_SPEED_ERROR = 110 - ALARM_ID_HD_SYRINGE_PUMP_NOT_STOPPED_ERROR = 111 - ALARM_ID_DG_LOAD_CELL_A2_B2_FPGA_FAULT = 112 - ALARM_ID_DG_DRAIN_PUMP_CURRENT_OUT_OF_RANGE = 113 - ALARM_ID_HD_VENOUS_BUBBLE_SELF_TEST_FAILURE = 114 - ALARM_ID_DG_TEMPERATURE_SENSOR_OUT_OF_RANGE = 115 - ALARM_ID_HD_UI_SDCARD_FAILURE = 116 - ALARM_ID_DG_CAN_MESSAGE_NOT_ACKED = 117 - ALARM_ID_DG_RTC_CONFIG_ERROR = 118 - ALARM_ID_DG_RTC_BATTERY_LOW = 119 - ALARM_ID_HD_PRE_TREATMENT_WET_PRIME_TEST_FAILURE = 120 - ALARM_ID_DG_MAIN_PRIMARY_HEATER_VOLTAGE_OUT_OF_RANGE = 121 - ALARM_ID_DG_SMALL_PRIMARY_HEATER_VOLTAGE_OUT_OF_RANGE = 122 - ALARM_ID_DG_TRIMMER_HEATER_VOLTAGE_OUT_OF_RANGE = 123 - ALARM_ID_HD_END_OF_TREATMENT_HIGH = 124 - ALARM_ID_HD_TREATMENT_STOPPED_NO_RINSEBACK = 125 - ALARM_ID_HD_BLOOD_LEAK_DETECTED = 126 - ALARM_ID_HD_VENOUS_PRESSURE_LOW = 127 - ALARM_ID_HD_VENOUS_BUBBLE_DETECTED = 128 - ALARM_ID_HD_BLOOD_LEAK_RECOVERING_PLEASE_WAIT = 129 - ALARM_ID_HD_VENOUS_PRESSURE_HIGH = 130 - ALARM_ID_HD_ARTERIAL_PRESSURE_LOW = 131 - ALARM_ID_HD_ARTERIAL_PRESSURE_HIGH = 132 - ALARM_ID_DG_FLUID_LEAK_DETECTED = 133 - ALARM_ID_HD_FLUID_LEAK_DETECTED = 134 - ALARM_ID_HD_SHOCK = 135 - ALARM_ID_DG_SHOCK = 136 - ALARM_ID_HD_EXCESSIVE_TILT = 137 - ALARM_ID_DG_EXCESSIVE_TILT = 138 - ALARM_ID_HD_AC_POWER_LOST = 139 - ALARM_ID_HD_DG_COMM_TIMEOUT = 140 - ALARM_ID_HD_AIR_TRAP_FILL_DURING_TREATMENT = 141 - ALARM_ID_HD_OCCLUSION_BLOOD_PUMP = 142 - ALARM_ID_DG_DIALYSATE_TEMPERATURE_SENSORS_OUT_OF_RANGE = 143 - ALARM_ID_DG_CLEANING_MODE_INLET_WATER_COND_TOO_HIGH = 144 - ALARM_ID_DG_ACID_CONDUCTIVITY_OUT_OF_RANGE = 145 - ALARM_ID_DG_RTC_OR_TIMER_ACCURACY_FAILURE = 146 - ALARM_ID_DG_CREATING_DIALYSATE_PLEASE_WAIT = 147 - ALARM_ID_DG_CLEANING_MODE_INLET_WATER_TEMP_TOO_HIGH = 148 - ALARM_ID_HD_WATCHDOG_EXPIRED = 149 - ALARM_ID_DG_INLET_WATER_CONDUCTIVITY_IN_HIGH_RANGE = 150 - ALARM_ID_DG_INLET_WATER_CONDUCTIVITY_IN_LOW_RANGE = 151 - ALARM_ID_DG_INLET_WATER_PRESSURE_IN_LOW_RANGE = 152 - ALARM_ID_HD_PRIME_COMPLETED_HIGH = 153 - ALARM_ID_DG_CLEANING_MODE_INLET_WATER_COND_TOO_LOW = 154 - ALARM_ID_HD_NEW_RESERVOIRS_DATA_MESSAGE_NOT_RECEIVE = 155 - ALARM_ID_HD_DG_NEW_OPERATION_MODE_MESSAGE_NOT_RECEIVE = 156 - ALARM_ID_DG_CHEM_DISINFECT_PRIME_ACID_LINE_TIME_OUT = 157 - ALARM_ID_DG_INLET_WATER_TEMPERATURE_IN_LOW_RANGE = 158 - ALARM_ID_DG_CHEM_DISINFECT_FLUSH_REMOVE_ACID = 159 - ALARM_ID_HD_BLOOD_PUMP_ROTOR_SPEED_TOO_HIGH = 160 - ALARM_ID_DG_COMM_TOO_MANY_BAD_CRCS = 161 - ALARM_ID_DG_FPGA_CLOCK_SPEED_CHECK_FAILURE = 162 - ALARM_ID_HD_LOAD_CELL_ACCELERATION_RES_1_ALARM = 163 - ALARM_ID_HD_LOAD_CELL_ACCELERATION_RES_2_ALARM = 164 - ALARM_ID_HD_TREATMENT_RINSEBACK_TIMEOUT_ALARM = 165 - ALARM_ID_TEST_ALARM_NO_BLOOD_RECIRC_CLR_TOP_ONLY = 166 - ALARM_ID_HD_CARTRIDGE_DOOR_OPENED = 167 - ALARM_ID_TEST_ALARM_NO_DIAL_RECIRC_CLR_TOP_ONLY = 168 - ALARM_ID_DG_DIALYSATE_FLOW_RATE_OUT_OF_MAX_RANGE = 169 - ALARM_ID_HD_SYRINGE_PUMP_SYRINGE_EMPTY = 170 - ALARM_ID_HD_SYRINGE_PUMP_OCCLUSION = 171 - ALARM_ID_HD_SYRINGE_PUMP_NOT_ENOUGH_HEPARIN_ALARM = 172 - ALARM_ID_HD_RTC_CONFIG_ERROR = 173 - ALARM_ID_HD_RTC_OR_TIMER_ACCURACY_FAILURE = 174 - ALARM_ID_HD_PUMP_DIRECTION_STATUS_ERROR = 175 - ALARM_ID_TEST_ALARM_NO_RECIRC_CLR_TOP_ONLY = 176 - ALARM_ID_DG_SOFTWARE_FAULT = 177 - ALARM_ID_HD_COMM_TIMEOUT = 178 - ALARM_ID_DG_FPGA_COMM_TIMEOUT = 179 - ALARM_ID_DG_RO_FLOW_RATE_OUT_OF_MAX_RANGE = 180 - ALARM_ID_DG_LOAD_CELLS_TARE_WEIGHT_OUT_OF_RANGE = 181 - ALARM_ID_DG_LOAD_CELLS_INVALID_CAL_RECORD = 182 - ALARM_ID_DG_INVALID_LOAD_CELL_VALUE = 183 - ALARM_ID_DG_INLET_UV_REACTOR_NOT_HEALTHY = 184 - ALARM_ID_DG_FAN_RPM_OUT_OF_RANGE = 185 - ALARM_ID_DG_CONCENTRATE_PUMP_FAULT = 186 - ALARM_ID_DG_CP1_SPEED_CONTROL_ERROR = 187 - ALARM_ID_DG_CP2_SPEED_CONTROL_ERROR = 188 - ALARM_ID_DG_DRAIN_PUMP_RPM_OUT_OF_RANGE = 189 - ALARM_ID_DG_DRAIN_PUMP_OFF_FAULT = 190 - ALARM_ID_DG_FLOW_RATE_OUT_OF_UPPER_RANGE = 191 - ALARM_ID_DG_FLOW_RATE_OUT_OF_LOWER_RANGE = 192 - ALARM_ID_HD_PARTIAL_OCCLUSION_BLOOD_PUMP = 193 - ALARM_ID_DG_RO_PUMP_DUTY_CYCLE_OUT_OF_RANGE = 194 - ALARM_ID_DG_RO_PUMP_PRESSURE_OUT_OF_RANGE = 195 - ALARM_ID_DG_CPI_CPO_SENSORS_FPGA_FAULT = 196 - ALARM_ID_DG_CD1_CD2_SENSORS_FPGA_FAULT = 197 - ALARM_ID_DG_RO_FLOW_TOO_LOW_WHILE_PRIMARY_HEATER_IS_ON = 198 - ALARM_ID_DG_DIALYSATE_FLOW_TOO_LOW_WHILE_TRIMMER_HEATER_IS_ON = 199 - ALARM_ID_DG_THERMISTORS_TEMPERATURE_OUT_OF_RANGE = 200 - ALARM_ID_HD_PRE_TREATMENT_WET_FLOW_TEST_FAILURE = 201 - ALARM_ID_HD_PRE_TREATMENT_DRY_PRESSURE_NORMAL_TEST_FAILURE = 202 - ALARM_ID_DG_FILL_CONDUCTIVITIES_INVALID_CAL_RECORD = 203 - ALARM_ID_DG_RO_REJECTION_RATIO_OUT_OF_RANGE = 204 - ALARM_ID_DG_CONDUCTIVITY_SENSOR_FAULT = 205 - ALARM_ID_DG_DIALYSATE_FILL_OUT_OF_TIME = 206 - ALARM_ID_DG_FLOW_METER_CHECK_FAILURE = 207 - ALARM_ID_HD_VENOUS_LINE_OCCLUSION = 208 - ALARM_ID_DG_DRAIN_CIRCULATION_LINE_TIMEOUT = 209 - ALARM_ID_HD_BATTERY_PACK_ERROR_DETECTED = 210 - ALARM_ID_HD_BLOOD_SITTING_WARNING = 211 - ALARM_ID_HD_END_OF_TREATMENT_ALARM = 212 - ALARM_ID_HD_PRIME_COMPLETED_MEDIUM = 213 - ALARM_ID_AVAILABLE_30 = 214 - ALARM_ID_AVAILABLE_31 = 215 - ALARM_ID_HD_END_TREATMENT_TIMEOUT_ALARM = 216 - ALARM_ID_AVAILABLE_32 = 217 - ALARM_ID_HD_SYRINGE_DETECTED = 218 - ALARM_ID_HD_SYRINGE_PUMP_SYRINGE_REMOVED = 219 - ALARM_ID_DG_THD_SENSORS_FPGA_FAULT = 220 - ALARM_ID_HD_EMPTY_SALINE_BAG = 221 - ALARM_ID_HD_OCCLUSION_SENSOR_FPGA_FAULT = 222 - ALARM_ID_HD_ARTERIAL_SENSOR_FPGA_FAULT = 223 - ALARM_ID_HD_TREATMENT_STOPPED_BY_USER = 224 - ALARM_ID_HD_END_OF_TREATMENT_WARNING = 225 - ALARM_ID_HD_PRIME_COMPLETED_LOW_PRIORITY = 226 - ALARM_ID_AVAILABLE_15 = 227 - ALARM_ID_HD_PRIME_SALINE_PURGE_AIR_TIME_OUT = 228 - ALARM_ID_HD_PRIME_DIALYSATE_DIALYZER_TIME_OUT = 229 - ALARM_ID_HD_PRIME_DIALYSATE_BYPASS_TIME_OUT = 230 - ALARM_ID_HD_PRE_TREATMENT_DRY_PRESSURE_TEST_FAILURE = 231 - ALARM_ID_HD_PRE_TREATMENT_WET_LC_TEST_FAILURE = 232 - ALARM_ID_DG_BAROMETRIC_SENSOR_COEFFS_BAD_CRC = 233 - ALARM_ID_DG_INLET_WATER_PRESSURE_IN_HIGH_RANGE = 234 - ALARM_ID_HD_TREATMENT_STOPPED_AFTER_RINSEBACK = 235 - ALARM_ID_HD_INSTALL_NEW_CARTRIDGE = 236 - ALARM_ID_AVAILABLE_13 = 237 - ALARM_ID_HD_NO_CARTRIDGE_LOADED = 238 - ALARM_ID_HD_CARTRIDGE_REMOVAL_FAILURE = 239 - ALARM_ID_DG_BICARB_CONDUCTIVITY_OUT_OF_RANGE = 240 - ALARM_ID_DG_RESERVOIR_DRAIN_TIMEOUT = 241 - ALARM_ID_DG_RESERVOIR_FILL_TIMEOUT = 242 - ALARM_ID_DG_RESERVOIR_LEAK_TIMEOUT = 243 - ALARM_ID_DG_CLEANING_MODE_TEMP_SENSORS_DIFF_OUT_OF_RANGE = 244 - ALARM_ID_DG_HEAT_DISINFECT_TARGET_TEMP_TIMEOUT = 245 - ALARM_ID_DG_CLEANING_MODE_COND_SENSORS_OUT_OF_RANGE = 246 - ALARM_ID_AVAILABLE_7 = 247 - ALARM_ID_DG_CHEM_DISINFECT_TARGET_TEMP_OUT_OF_RANGE = 248 - ALARM_ID_DG_CHEM_DISINFECT_TARGET_COND_OUT_OF_RANGE = 249 - ALARM_ID_DG_CHEM_DISINFECT_INSERT_ACID = 250 - ALARM_ID_HD_INVALID_SYSTEM_RECORD_CRC = 251 - ALARM_ID_HD_INVALID_SERVICE_RECORD_CRC = 252 - ALARM_ID_DG_INVALID_SYSTEM_RECORD_CRC = 253 - ALARM_ID_DG_INVALID_SERVICE_RECORD_CRC = 254 - ALARM_ID_HD_UI_COMPATIBILITY_ERROR = 255 - ALARM_ID_HD_DISINFECT_CHEM_FLUSH = 256 - ALARM_ID_HD_INVALID_INSTITUTIONAL_RECORD_CRC = 257 - ALARM_ID_HD_UI_POST_FAILURE_OS_VERSION = 258 - ALARM_ID_HD_TEMPERATURES_OUT_OF_RANGE = 259 - ALARM_ID_HD_UI_POST_FAILURE_SHASUM = 260 - ALARM_ID_HD_UI_POST_FAILURE_CANBUS = 261 - ALARM_ID_HD_UI_POST_FAILURE_DISPLAY = 262 - ALARM_ID_HD_UI_POST_FAILURE_TOUCH = 263 - ALARM_ID_HD_UI_POST_FAILURE_SDCARD = 264 - ALARM_ID_HD_UI_POST_FAILURE_RTC = 265 - ALARM_ID_HD_UI_POST_FAILURE_WIFI = 266 - ALARM_ID_HD_UI_POST_FAILURE_BLUETOOTH = 267 - ALARM_ID_HD_UI_POST_FAILURE_ETHERNET = 268 - ALARM_ID_HD_UI_POST_FAILURE_SOUND = 269 - ALARM_ID_HD_SAFETY_SHUTDOWN_POST_TEST_FAILED = 270 - ALARM_ID_DG_SAFETY_SHUTDOWN_POST_TEST_FAILED = 271 - ALARM_ID_HD_FAN_RPM_OUT_OF_RANGE = 272 - ALARM_ID_AVAILABLE_10 = 273 - ALARM_ID_DG_INACTIVE_RESERVOIR_WEIGHT_OUT_OF_RANGE = 274 - ALARM_ID_HD_ARTERIAL_PRESSURE_OUT_OF_RANGE = 275 - ALARM_ID_HD_VENOUS_PRESSURE_OUT_OF_RANGE = 276 - ALARM_ID_HD_BP_OCCLUSION_OUT_OF_RANGE = 277 - ALARM_ID_HD_ACTIVE_RESERVOIR_WEIGHT_OUT_OF_RANGE = 278 - ALARM_ID_DG_DIALYSATE_DRAIN_TIME_OUT = 279 - ALARM_ID_DG_DRAIN_PUMP_DIRECTION_INVALID = 280 - ALARM_ID_DG_ACID_BOTTLE_LOW_VOLUME = 281 - ALARM_ID_DG_BICARB_BOTTLE_LOW_VOLUME = 282 - ALARM_ID_DG_LOAD_CELL_WEIGHT_OUT_OF_RANGE = 283 - ALARM_ID_DG_LOAD_CELL_PRIMARY_BACKUP_DRIFT_OUT_OF_RANGE = 284 - ALARM_ID_HD_RO_PERMEATE_SAMPLE = 285 - ALARM_ID_DG_CONCENTRATE_CAP_NOT_IN_PROPER_POSITION = 286 - ALARM_ID_HD_FPGA_CLOCK_SPEED_CHECK_FAILURE = 287 - ALARM_ID_HD_LOAD_CELL_PRIMARY_BACKUP_DRIFT_OUT_OF_RANGE = 288 - ALARM_ID_DG_DIALYSATE_CAP_NOT_IN_PROPER_POSITION = 289 - ALARM_ID_HD_VENOUS_SENSOR_FPGA_FAULT = 290 - ALARM_ID_HD_DISINFECT_FLUSH = 291 - ALARM_ID_HD_DISINFECT_HEAT = 292 - ALARM_ID_HD_DISINFECT_CHEM = 293 - ALARM_ID_HD_DISINFECT_HEAT_COOL = 294 - ALARM_ID_HD_UI_POST_FAILURE_CLOUDSYNC = 295 - ALARM_ID_DG_TDI_SENSORS_FPGA_FAULT = 296 - ALARM_ID_DG_TRO_SENSORS_FPGA_FAULT = 297 - ALARM_ID_DG_BARO_SENSOR_FPGA_FAULT = 298 - ALARM_ID_DG_INVALID_SERIAL_NUMBER = 299 - ALARM_ID_HD_INVALID_SERIAL_NUMBER = 300 - ALARM_ID_DG_RO_PERMEATE_SAMPLE_REMOVE_DIA_CAP = 301 - ALARM_ID_DG_CPU_RAM_ERROR = 302 - ALARM_ID_DG_DRAIN_PUMP_DIRECTION_FPGA_FAULT = 303 - ALARM_ID_HD_INVALID_USAGE_RECORD_CRC = 304 - ALARM_ID_HD_CPU_RAM_ERROR = 305 - ALARM_ID_AVAILABLE_50 = 306 - ALARM_ID_HD_AC_POWER_LOST_IN_TREATMENT = 307 - ALARM_ID_DG_CPI_COND_SENSOR_INVALID_CHAR = 308 - ALARM_ID_DG_CPO_COND_SENSOR_INVALID_CHAR = 309 - ALARM_ID_DG_CD1_COND_SENSOR_INVALID_CHAR = 310 - ALARM_ID_DG_CD2_COND_SENSOR_INVALID_CHAR = 311 - ALARM_ID_HD_DIAL_IN_FLOW_CHECK_FAILURE = 312 - ALARM_ID_DG_CLEANING_MODE_INLET_WATER_TEMP_TOO_LOW = 313 - ALARM_ID_DG_CLEANING_MODE_INLET_WATER_PRESSURE_TOO_HIGH = 314 - ALARM_ID_DG_CLEANING_MODE_INLET_WATER_PRESSURE_TOO_LOW = 315 - ALARM_ID_AVAILABLE_20 = 316 - ALARM_ID_AVAILABLE_21 = 317 - ALARM_ID_AVAILABLE_2 = 318 - ALARM_ID_DG_CHEM_DISINFECT_FLUSH_FLUSH_SAMPLE = 319 - ALARM_ID_DG_CHEM_DISINFECT_FLUSH_SAMPLE_TIMEOUT = 320 - ALARM_ID_DG_OUTLET_UV_REACTOR_NOT_HEALTHY = 321 - ALARM_ID_HD_UI_POST_FAILURE_INVALID_YEAR = 322 - ALARM_ID_HD_UI_POST_FAILURE_SETTINGS_BAD = 323 + ALARM_ID_TD_SOFTWARE_FAULT = 1 + ALARM_ID_DD_SOFTWARE_FAULT = 2 + ALARM_ID_RO_SOFTWARE_FAULT = 3 + ALARM_ID_TD_FPGA_POST_TEST_FAILED = 4 + ALARM_ID_TD_WATCHDOG_POST_TEST_FAILED = 5 + ALARM_ID_TD_UI_COMM_POST_FAILED = 6 + ALARM_ID_TD_FPGA_CLOCK_SPEED_CHECK_FAILURE = 7 + ALARM_ID_TD_FPGA_COMM_TIMEOUT = 8 + ALARM_ID_TD_UI_COMM_TIMEOUT = 9 + ALARM_ID_TD_DD_COMM_TIMEOUT = 10 + ALARM_ID_TD_COMM_TOO_MANY_BAD_CRCS = 11 + ALARM_ID_TD_CAN_MESSAGE_NOT_ACKED_BY_UI = 12 + ALARM_ID_TD_CAN_MESSAGE_NOT_ACKED_BY_DD = 13 + ALARM_ID_TD_CRITICAL_DATA_ERROR = 14 + ALARM_ID_DD_CRITICAL_DATA_ERROR = 15 + ALARM_ID_TD_WATCHDOG_EXPIRED = 16 + ALARM_ID_DD_WATCHDOG_EXPIRED = 17 + ALARM_ID_DD_COMM_TOO_MANY_BAD_CRCS = 18 + ALARM_ID_DD_CAN_MESSAGE_NOT_ACKED_BY_RO = 19 + ALARM_ID_DD_CAN_MESSAGE_NOT_ACKED_BY_TD = 20 + ALARM_ID_DD_FPGA_POST_TEST_FAILED = 21 + ALARM_ID_DD_FPGA_CLOCK_SPEED_CHECK_FAILURE = 22 + ALARM_ID_DD_FPGA_COMM_TIMEOUT = 23 + ALARM_ID_TD_ALARM_AUDIO_SELF_TEST_FAILURE = 24 + ALARM_ID_DD_VALVE_CONTROL_FAILURE = 25 + ALARM_ID_TD_ARTERIAL_SENSOR_TIMEOUT_FAULT = 26 + ALARM_ID_TD_VENOUS_SENSOR_TIMEOUT_FAULT = 27 + ALARM_ID_DD_HYD_OUTLET_PRES_TIMEOUT_FAULT = 28 + ALARM_ID_DD_BIBAG_PRES_TIMEOUT_FAULT = 29 + ALARM_ID_DD_SPENT_DIALYSATE_PRES_TIMEOUT_FAULT = 30 + ALARM_ID_DD_FRESH_DIALYSATE_PRES_TIMEOUT_FAULT = 31 + ALARM_ID_DD_TRANSMEMB_PRES_TIMEOUT_FAULT = 32 + ALARM_ID_TD_VOLTAGE_OUT_OF_RANGE = 33 + ALARM_ID_TD_AC_POWER_LOST = 34 + ALARM_ID_TD_AC_POWER_LOST_IN_TREATMENT = 35 + ALARM_ID_DD_CD1_SENSOR_FPGA_FAULT = 36 + ALARM_ID_DD_CD2_SENSOR_FPGA_FAULT = 37 + ALARM_ID_DD_CD3_SENSOR_FPGA_FAULT = 38 + ALARM_ID_DD_CD4_SENSOR_FPGA_FAULT = 39 + ALARM_ID_TD_VENOUS_BUBBLE_DETECTED = 40 + ALARM_ID_TD_CARTRIDGE_DOOR_OPENED = 41 + ALARM_ID_TD_STUCK_BUTTON_TEST_FAILED = 42 + ALARM_ID_TD_ARTERIAL_PRESSURE_LOW = 43 + ALARM_ID_TD_ARTERIAL_PRESSURE_HIGH = 44 + ALARM_ID_TD_ARTERIAL_PRESSURE_OUT_OF_RANGE = 45 + ALARM_ID_TD_ARTERIAL_PRESSURE_SELF_TEST_FAILURE = 46 + ALARM_ID_TD_VENOUS_PRESSURE_LOW = 47 + ALARM_ID_TD_VENOUS_PRESSURE_HIGH = 48 + ALARM_ID_TD_VENOUS_PRESSURE_OUT_OF_RANGE = 49 + ALARM_ID_TD_VENOUS_PRESSURE_SELF_TEST_FAILURE = 50 + ALARM_ID_TD_PRE_TREATMENT_DRY_PRESSURE_TEST_FAILURE = 51 + ALARM_ID_TD_AIR_TRAP_FILL_DURING_TREATMENT = 52 + ALARM_ID_TD_AIR_TRAP_ILLEGAL_LEVELS = 53 + ALARM_ID_TD_PINCH_VALVE_FAULT = 54 + ALARM_ID_TD_VALVE_HOMING_FAILED = 55 + ALARM_ID_TD_VALVE_TRANSITION_TIMEOUT = 56 + NUM_OF_ALARM_IDS = 57 + Index: leahi-dialin/common/alarm_priorities.py =================================================================== diff -u -r07db7b5f01ad17d60c190e21574e1ed0552535ff -r12b82879196778f6c83d08751652177ea0fcbf5e --- leahi-dialin/common/alarm_priorities.py (.../alarm_priorities.py) (revision 07db7b5f01ad17d60c190e21574e1ed0552535ff) +++ leahi-dialin/common/alarm_priorities.py (.../alarm_priorities.py) (revision 12b82879196778f6c83d08751652177ea0fcbf5e) @@ -24,3 +24,37 @@ ALARM_PRIORITY_MEDIUM = 2 # Medium priority alarm ALARM_PRIORITY_HIGH = 3 # High priority alarm NUM_OF_ALARM_PRIORITIES = 4 # Total number of alarm priorities + +class AlarmPriority: + ALARM_HIGH = 3 + ALARM_MED = 2 + ALARM_LOW = 1 + ALARM_NONE = 0 + + +class AlarmFlags: + ALARM_STATE_FLAG_BIT_POS_SYSTEM_FAULT = 0 + ALARM_STATE_FLAG_BIT_POS_STOP = 1 + ALARM_STATE_FLAG_BIT_POS_NO_CLEAR = 2 + ALARM_STATE_FLAG_BIT_POS_NO_RESUME = 3 + ALARM_STATE_FLAG_BIT_POS_NO_RINSEBACK = 4 + ALARM_STATE_FLAG_BIT_POS_NO_END_TREATMENT = 5 + ALARM_STATE_FLAG_BIT_POS_NO_NEW_TREATMENT = 6 + ALARM_STATE_FLAG_BIT_POS_USER_MUST_ACK = 7 + ALARM_STATE_FLAG_BIT_POS_ALARMS_TO_ESCALATE = 8 + ALARM_STATE_FLAG_BIT_POS_ALARMS_SILENCED = 9 + ALARM_STATE_FLAG_BIT_POS_LAMP_ON = 10 + ALARM_STATE_FLAG_BIT_POS_UNUSED_1 = 11 + ALARM_STATE_FLAG_BIT_POS_UNUSED_2 = 12 + ALARM_STATE_FLAG_BIT_POS_UNUSED_3 = 13 + ALARM_STATE_FLAG_BIT_POS_UNUSED_4 = 14 + ALARM_STATE_FLAG_BIT_POS_TOP_CONDITION = 15 + + +class AlarmDataTypes: + ALARM_DATA_TYPE_NONE = 0 # No data given. + ALARM_DATA_TYPE_U32 = 1 # Alarm data is unsigned 32-bit integer type. + ALARM_DATA_TYPE_S32 = 2 # Alarm data is signed 32-bit integer type. + ALARM_DATA_TYPE_F32 = 3 # Alarm data is 32-bit floating point type. + ALARM_DATA_TYPE_BOOL = 4 # Alarm data is 32-bit boolean type. + NUM_OF_ALARM_DATA_TYPES = 5 # Total number of alarm data types. Index: leahi-dialin/common/dd_defs.py =================================================================== diff -u --- leahi-dialin/common/dd_defs.py (revision 0) +++ leahi-dialin/common/dd_defs.py (revision 12b82879196778f6c83d08751652177ea0fcbf5e) @@ -0,0 +1,327 @@ +########################################################################### +# +# Copyright (c) 2021-2024 Diality Inc. - All Rights Reserved. +# +# THIS CODE MAY NOT BE COPIED OR REPRODUCED IN ANY FORM, IN PART OR IN +# WHOLE, WITHOUT THE EXPLICIT PERMISSION OF THE COPYRIGHT OWNER. +# +# @file dd_defs.py +# +# @author (last) Dara Navaei +# @date (last) 08-Feb-2024 +# @author (original) Peter Lucia +# @date (original) 22-Jun-2021 +# +############################################################################ +from enum import unique +from ..utils.base import DialinEnum + + +@unique +class DDOpModes(DialinEnum): + DD_MODE_FAUL = 0 + DD_MODE_SERV = 1 + DD_MODE_INIT = 2 + DD_MODE_STAN = 3 + DD_MODE_GEND = 4 + DD_MODE_HEAT = 5 + DD_MODE_HCOL = 6 + DD_MODE_ROPS = 7 + DD_MODE_NLEG = 8 + NUM_OF_DD_MODES = 9 + +@unique +class DGInitStates(DialinEnum): + DG_POST_STATE_START = 0 + DG_POST_STATE_FW_COMPATIBILITY = 1 + DG_POST_STATE_FW_INTEGRITY = 2 + DG_POST_STATE_FPGA = 3 + DG_POST_STATE_RTC = 4 + DG_POST_STATE_NVDATAMGMT = 5 + DG_POST_STATE_TEMPERATURE_SENSORS = 6 + DG_POST_STATE_ACCELEROMETER = 7 + DG_POST_STATE_PRESSURES = 8 + DG_POST_STATE_RO_PUMP = 9 + DG_POST_STATE_DRAIN_PUMP = 10 + DG_POST_STATE_CONCENTRATE_PUMPS = 11 + DG_POST_STATE_CONDUCTIVITY_SENSORS = 12 + DG_POST_STATE_RESERVOIRS = 13 + DG_POST_STATE_UV_REACTORS = 14 + DG_POST_STATE_THERMISTORS = 15 + DG_POST_STATE_FANS = 16 + DG_POST_STATE_DIALYSATE_FLOW_SENSOR = 17 + DG_POST_STATE_WATCHDOG = 18 + DG_POST_STATE_SAFETY_SHUTDOWN = 19 + DG_POST_STATE_LOAD_CELL = 20 + DG_POST_STATE_COMPLETED = 21 + DG_POST_STATE_FAILED = 22 + NUM_OF_DG_POST_STATES = 23 + + +@unique +class DGFaultStates(DialinEnum): + DG_FAULT_STATE_START = 0 # DG fault start state + DG_FAULT_STATE_RUN_NV_POSTS = 1 # DG fault run RTC and NV data management post + DG_FAULT_STATE_COMPLETE = 2 # DG fault complete + NUM_OF_DG_FAULT_STATES = 3 # Number of fault mode states + +@unique +class DGSoloStates(DialinEnum): + DG_SOLO_STANDBY_STATE_START = 0 + DG_SOLO_IDLE_STATE = 1 + NUM_OF_DG_SOLO_STANDBY_STATES = 2 + + +@unique +class DGStandByModeStates(DialinEnum): + DG_STANDBY_MODE_STATE_IDLE = 0 # Idle standby mode state + DG_STANDBY_MODE_STATE_FLUSH_FILTER = 1 # Sample water flush filter state + DG_STANDBY_MODE_STATE_FLUSH_FILTER_IDLE = 2 # Sample water flush filter idle state + DG_STANDBY_MODE_STATE_SAMPLE_WATER = 3 # Sample water state + DG_STANDBY_MODE_STATE_PAUSE = 4 # Pause state + NUM_OF_DG_STANDBY_MODE_STATES = 5 # Number of standby mode states + + +@unique +class DGGenIdleModeStates(DialinEnum): + DG_GEN_IDLE_MODE_STATE_START = 0 + DG_GEN_IDLE_MODE_STATE_FLUSH_WATER = 1 + DG_GEN_IDLE_MODE_STATE_HANDLE_BAD_FILL = 2 + NUM_OF_DG_GEN_IDLE_MODE_STATES = 3 + + +@unique +class DGGenIdleModeBadFillSubStates(DialinEnum): + DG_HANDLE_BAD_FILL_STATE_START = 0 + DG_HANDLE_BAD_FILL_STATE_FIRST_DRAIN = 1 + DG_HANDLE_BAD_FILL_STATE_FLUSH_FILL = 2 + DG_HANDLE_BAD_FILL_STATE_SECOND_DRAIN = 3 + DG_HANDLE_BAD_FILL_STATE_REFILL = 4 + NUM_OF_DG_HANDLE_BAD_FILL_STATES = 6 + + +@unique +class DGFillModeStates(DialinEnum): + DG_FILL_MODE_STATE_TEST_INLET_WATER = 0 # Test inlet water quality state + DG_FILL_MODE_STATE_PRIME_CONCENTRATE_LINES = 1 # Prime the acid and bicarb concentrate lines + DG_FILL_MODE_STATE_FLUSH_BUBBLES = 2 # Flush the bubbles in the lines state + DG_FILL_MODE_STATE_TEST_BICARB_CONDUCTIVITY = 3 # Test the conductivity range of the bicarb concentrate state + DG_FILL_MODE_STATE_TEST_ACID_CONDUCTIVITY = 4 # Test the conductivity range of the acid concentrate state + DG_FILL_MODE_STATE_PRODUCE_DIALYSATE = 5 # Dialysate production state + DG_FILL_MODE_STATE_DELIVER_DIALYSATE = 6 # Dialysate deliver state + DG_FILL_MODE_STATE_PAUSED = 7 # Dialysate generation pause state + NUM_OF_DG_FILL_MODE_STATES = 8 # Number of fill mode states + + +@unique +class DGDrainModeStates(DialinEnum): + DG_DRAIN_STATE_START = 0 # Start drain mode state + DG_DRAIN_STATE_DRAIN = 1 # Drain drain mode state + DG_DRAIN_STATE_TARE = 2 # Tare drain mode state + DG_DRAIN_STATE_RINSE = 3 + NUM_OF_DG_DRAIN_STATES = 4 # Number of drain mode states + + +@unique +class DGFlushStates(DialinEnum): + DG_FLUSH_STATE_START = 0 + DG_FLUSH_STATE_DRAIN_R1 = 1 + DG_FLUSH_STATE_DRAIN_R2 = 2 + DG_FLUSH_STATE_FLUSH_DRAIN = 3 + DG_FLUSH_STATE_FLUSH_DIALYSATE = 4 + DG_FLUSH_STATE_FLUSH_CONCENTRATE_STRAWS = 5 + DG_FLUSH_STATE_FLUSH_R1_TO_R2 = 6 + DG_FLUSH_STATE_FLUSH_R2_AND_DRAIN_R1 = 7 + DG_FLUSH_STATE_FLUSH_CIRCULATION_DRAIN_LINE = 8 + DG_FLUSH_STATE_FLUSH_CIRCULATION = 9 + DG_FLUSH_STATE_FLUSH_WITH_FRESH_WATER = 10 + DG_FLUSH_STATE_CANCEL_BASIC_PATH = 11 + DG_FLUSH_STATE_CANCEL_WATER_PATH = 12 + DG_FLUSH_STATE_COMPLETE = 13 + NUM_OF_DG_FLUSH_STATES = 14 + + +@unique +class DGFlushUIStates(DialinEnum): + FLUSH_UI_STATE_NOT_RUNNING = 0 + FLUSH_UI_STATE_NOT_DRAIN_DEVICE = 1 + FLUSH_UI_STATE_NOT_FLUSH_RESERVOIRS = 2 + FLUSH_UI_STATE_NOT_DRAIN_RESERVOIRS = 3 + FLUSH_UI_STATE_NOT_FLUSH_RECIRCULATION_PATH = 4 + FLUSH_UI_STATE_NOT_CANCEL_FLUSH = 5 + FLUSH_UI_STATE_NOT_COMPLETE = 6 + NUM_OF_FLUSH_UI_STATES = 7 + + +@unique +class DGHeatDisinfectStates(DialinEnum): + DG_HEAT_DISINFECT_STATE_START = 0 # Heat disinfect, start mode state + DG_HEAT_DISINFECT_STATE_DRAIN_R1 = 1 # Heat disinfect, drain R1 state + DG_HEAT_DISINFECT_STATE_DRAIN_R2 = 2 # Heat disinfect, drain R2 state + DG_HEAT_DISINFECT_STATE_FLUSH_DRAIN = 3 # Heat disinfect, flush drain state + DG_HEAT_DISINFECT_STATE_FLUSH_CIRCULATION = 4 # Heat disinfect, flush circulation state + DG_HEAT_DISINFECT_STATE_FLUSH_R1_AND_R2 = 5 # Heat disinfect, flush R1 and R2 state + DG_HEAT_DISINFECT_STATE_FLUSH_R2_AND_DRAIN_R1 = 6 # Heat disinfect, flush R2 and drain R1 state + DG_HEAT_DISINFECT_STATE_FLUSH_DRAIN_R2 = 7 # Heat disinfect, flush drain R2 state + DG_HEAT_DISINFECT_STATE_FLUSH_DRAIN_R1 = 8 # Heat disinfect, flush drain R1 state + DG_HEAT_DISINFECT_STATE_FILL_WITH_WATER = 9 # Heat disinfect, fill with water state + DG_HEAT_DISINFECT_STATE_DISINFECT_R1_TO_R2 = 10 # Heat disinfect, disinfect R1 to R2 state + DG_HEAT_DISINFECT_STATE_PREPARE_FOR_HOT_WATER_TRANSITION = 11 # Heat disinfect, prepare for hot water transition + DG_HEAT_DISINFECT_STATE_FILL_R2_WITH_HOT_WATER = 12 # Heat disinfect, fill R2 with hot water state + DG_HEAT_DISINFECT_STATE_DISINFECT_R2_TO_R1 = 13 # Heat disinfect, disinfect R2 to R1 state + DG_HEAT_DISINFECT_STATE_COOL_DOWN_HEATERS = 14 # Heat disinfect, cool down heaters state + DG_HEAT_DISINFECT_STATE_MIX_DRAIN_R1 = 15 # Heat disinfect, mix drain R1 state + DG_HEAT_DISINFECT_STATE_MIX_DRAIN_R2 = 16 # Heat disinfect, mix drain R2 state + DG_HEAT_DISINFECT_STATE_CANCEL_BASIC_PATH = 17 # Heat disinfect, cancel mode basic path state + DG_HEAT_DISINFECT_STATE_CANCEL_WATER_PATH = 18 # Heat disinfect, cancel mode water path state + DG_HEAT_DISINFECT_STATE_COMPLETE = 19 # Heat disinfect, complete state + DG_NELSON_HEAT_DISINFECT_STATE_FILL_R1_WITH_WATER = 20 # Heat disinfect, Nelson support state + NUM_OF_DG_HEAT_DISINFECT_STATES = 21 # Number of heat disinfect mode states + + +@unique +class DGHeatDisinfectUIStates(DialinEnum): + HEAT_DISINFECT_UI_STATE_NOT_RUNNING = 0 + HEAT_DISINFECT_UI_STATE_FLUSH_BEFORE_DISINFECT = 1 + HEAT_DISINFECT_UI_STATE_HEAT_UP_WATER = 2 + HEAT_DISINFECT_UI_STATE_DISINFECT_RESERVOIR_1 = 3 + HEAT_DISINFECT_UI_STATE_TRANSITION_HOT_WATER = 4 + HEAT_DISINFECT_UI_STATE_DISINFECT_RESERVOIR_2 = 5 + HEAT_DISINFECT_UI_STATE_COOL_DOWN_DEVICE = 6 + HEAT_DISINFECT_UI_STATE_FLUSH_AFTER_DISINFECT = 7 + HEAT_DISINFECT_UI_STATE_CANCEL_DISINFECT = 8 + HEAT_DISINFECT_UI_STATE_COMPLETE = 9 + NUM_OF_HEAT_DISINFECT_UI_STATES = 10 + + +@unique +class DGHeatDisinfectActiveCoolStates(DialinEnum): + DG_HEAT_DISINFECT_ACTIVE_COOL_STATE_START = 0 + DG_HEAT_DISINFECT_ACTIVE_COOL_MIX_DRAIN_R1_STATE = 1 + DG_HEAT_DISINFECT_ACTIVE_COOL_MIX_DRAIN_R2_STATE = 2 + DG_HEAT_DISINFECT_ACTIVE_COOL_FILL_R1_STATE = 3 + DG_HEAT_DISINFECT_ACTIVE_COOL_FILL_R2_STATE = 4 + DG_HEAT_DISINFECT_ACTIVE_COOL_DRAIN_R2_FILL_R1_TO_R2_STATE = 5 + DG_HEAT_DISINFECT_ACTIVE_COOL_DRAIN_R1_FILL_R2_TO_R1_STATE = 6 + DG_HEAT_DISINFECT_ACTIVE_COOL_DRAIN_R1_STATE = 7 + DG_HEAT_DISINFECT_ACTIVE_COOL_DRAIN_R2_STATE = 8 + DG_HEAT_DISINFECT_ACTIVE_COOL_CANCEL_WATER_PATH_STATE = 9 + DG_HEAT_DISINFECT_ACTIVE_COOL_CANCEL_BASIC_PATH_STATE = 10 + DG_HEAT_DISINFECT_ACTIVE_COOL_STATE_COMPLETE = 11 + + +@unique +class DGChemicalDisinfectStates(DialinEnum): + DG_CHEM_DISINFECT_STATE_START = 0 + DG_CHEM_DISINFECT_STATE_DRAIN_R1 = 1 + DG_CHEM_DISINFECT_STATE_DRAIN_R2 = 2 + DG_CHEM_DISINFECT_STATE_FLUSH_DRAIN = 3 + DG_CHEM_DISINFECT_STATE_DEPRIME_ACID_LINE = 4 + DG_CHEM_DISINFECT_STATE_FLUSH_CIRCULATION = 5 + DG_CHEM_DISINFECT_STATE_PRIME_DISINFECTANT = 6 + DG_CHEM_DISINFECT_STATE_DISINFECTANT_FLUSH = 7 + DG_CHEM_DISINFECT_STATE_FILL_WITH_DISINFECTANT = 8 + DG_CHEM_DISINFECT_STATE_DISINFECT_R1_TO_R2 = 9 + DG_CHEM_DISINFECT_STATE_PARTIAL_DRAIN_R1_FILL_R2_TO_R1 = 10 + DG_CHEM_DISINFECT_STATE_DISINFECT_R2_TO_R1 = 11 + DG_CHEM_DISINFECT_STATE_PARTIAL_DRAIN_R2_FILL_R1_TO_R2 = 12 + DG_CHEM_DISINFECT_STATE_CANCEL_BASIC_PATH = 13 + DG_CHEM_DISINFECT_STATE_CANCEL_WATER_PATH = 14 + DG_CHEM_DISINFECT_STATE_COMPLETE = 15 + NUM_OF_DG_CHEM_DISINFECT_STATES = 16 + + +@unique +class DGChemDisinfectFlushStates(DialinEnum): + DG_CHEM_DISINFECT_FLUSH_STATE_START = 0 + DG_CHEM_DISINFECT_FLUSH_STATE_DRAIN_R1 = 1 + DG_CHEM_DISINFECT_FLUSH_STATE_DRAIN_R2 = 2 + DG_CHEM_DISINFECT_FLUSH_STATE_FLUSH_DRAIN = 3 + DG_CHEM_DISINFECT_FLUSH_STATE_FLUSH_DISINFECTANT_LINE = 4 + DG_CHEM_DISINFECT_FLUSH_STATE_FLUSH_UF = 5 + DG_CHEM_DISINFECT_FLUSH_STATE_FLUSH_R2_TO_R1_DRAIN_R1 = 6 + DG_CHEM_DISINFECT_FLUSH_STATE_FLUSH_R1_TO_R2_DRAIN_R2 = 7 + DG_CHEM_DISINFECT_FLUSH_STATE_SAMPLE_FLUSH_R1_TO_R2_DRAIN_R2 = 8 + DG_CHEM_DISINFECT_FLUSH_STATE_CANCEL_BASIC_PATH = 9 + DG_CHEM_DISINFECT_FLUSH_STATE_CANCEL_WATER_PATH = 10 + DG_CHEM_DISINFECT_FLUSH_STATE_COMPLETE = 11 + NUM_OF_DG_CHEM_DISINFECT_FLUSH_STATES = 12 + + +@unique +class DGChemDisinfectFlushUIStates(DialinEnum): + CHEM_DISINFECT_FLUSH_UI_STATE_NOT_RUNNING = 0 + CHEM_DISINFECT_FLUSH_UI_STATE_FLUSH_AFTER_DISINFECT = 1 + CHEM_DISINFECT_FLUSH_UI_STATE_CANCEL_FLUSH = 2 + CHEM_DISINFECT_FLUSH_UI_STATE_COMPLETE = 3 + NUM_OF_CHEM_DISINFECT_FLUSH_UI_STATES = 4 + + +@unique +class DGChemDisinfectUIStates(DialinEnum): + CHEM_DISINFECT_UI_STATE_NOT_RUNNING = 0 + CHEM_DISINFECT_UI_STATE_FLUSH_BEFORE_DISINFECT = 1 + CHEM_DISINFECT_UI_STATE_MIX_WATER_AND_ACID = 2 + CHEM_DISINFECT_UI_STATE_REMOVE_ACID = 3 + CHEM_DISINFECT_UI_STATE_DISINFECT_DEVICE = 4 + CHEM_DISINFECT_UI_STATE_FLUSH_AFTER_DISINFECT = 5 + CHEM_DISINFECT_UI_STATE_CANCEL_DISINFECT = 6 + CHEM_DISINFECT_UI_STATE_COMPLETE = 7 + NUM_OF_CHEM_DISINFECT_UI_STATES = 8 + + +@unique +class DGROPermeateSampleStates(DialinEnum): + DG_RO_PERM_SAMPLE_STATE_START = 0 + DG_RO_PERM_SAMPLE_STATE_DRAIN_R1 = 1 + DG_RO_PERM_SAMPLE_STATE_DRAIN_R2 = 2 + DG_RO_PERM_SAMPLE_STATE_FLUSH_DRAIN = 3 + DG_RO_PERM_SAMPLE_STATE_FLUSH_DIALYSATE = 4 + DG_RO_PERM_SAMPLE_STATE_FLUSH_CONCENTRATE_STRAWS = 5 + DG_RO_PERM_SAMPLE_STATE_FLUSH_R2_TO_R1_AND_DRAIN_R1 = 6 + DG_RO_PERM_SAMPLE_STATE_COLLECT_SAMPLE = 7 + DG_RO_PERM_SAMPLE_STATE_CANCEL_BASIC_PATH = 8 + DG_RO_PERM_SAMPLE_STATE_CANCEL_WATER_PATH = 9 + DG_RO_PERM_SAMPLE_STATE_COMPLETE = 10 + NUM_OF_DG_RO_PERM_STATES = 11 + + +@unique +class DGEventList(DialinEnum): + DG_EVENT_STARTUP = 0 # DG startup event + DG_EVENT_OP_MODE_CHANGE = 1 # DG Op mode change event + DG_EVENT_SUB_MODE_CHANGE = 2 # DG Op sub-mode change event + DG_EVENT_CONCENTRATE_CAP_SWITCH_CHANGE = 3 # DG concentrate cap switch change + DG_EVENT_DIALYSATE_CAP_SWITCH_CHANGE = 4 # DG dialysate cap switch change + DG_EVENT_CPU_RAM_ERROR_STATUS = 5 # DG processor RAM error + DG_EVENT_CAL_RECORD_UPDATE = 6 # DG new calibration record updated + DG_EVENT_SYSTEM_RECORD_UPDATE = 7 # DG new system record has been updated + DG_EVENT_SERVICE_UPDATE = 8 # DG new service record has been updated + DG_EVENT_USAGE_INFO_UPDATE = 9 # DG new usage information has been updated + DG_EVENT_SW_CONFIG_UPDATE = 10 # DG new software configuration has been updated + DG_EVENT_SCHEDULED_RUNS_UPDATE = 11 # DG new scheduled runs information has been updated + DG_EVENT_HEATERS_INFO_UPDATE = 12 # DG new heaters information has been updated + DG_EVENT_AVG_DIALYSATE_FILL_COND_VALUES = 13 # DG average dialysate fill conductivity values + DG_EVENT_RESERVOIR_FILL_VALUES = 14 # DG reservoir fill base reservoir weight and filled volume values + DG_EVENT_OPERATION_STATUS = 15 # DG operation status event + DG_EVENT_TEMPERATURE_DRIFT = 16 # DG temperature drift event + DG_EVENT_BICARB_CHECK_RESULT = 17 # DG bicarb check result + DG_EVENT_ACID_CHECK_RESULT = 18 # DG acid check result + DG_EVENT_COND1_VS_COND2_DIFF_RESULT = 19 # DG CD1 (acid) vs. CD2 (bicarb) different result + NUM_OF_DG_EVENT_IDS = 20 # Total number of DG events + + +@unique +class DGEventDataType(DialinEnum): + EVENT_DATA_TYPE_NONE = 0 + EVENT_DATA_TYPE_U32 = 1 + EVENT_DATA_TYPE_S32 = 2 + EVENT_DATA_TYPE_F32 = 3 + EVENT_DATA_TYPE_BOOL = 4 + NUM_OF_EVENT_DATA_TYPES = 5 + + +@unique +class DGServiceModesStates(DialinEnum): + DG_SERVICE_STATE_START = 0 # Start service mode state + NUM_OF_DG_SERVICE_STATES = 1 # Number of service mode states Fisheye: Tag 12b82879196778f6c83d08751652177ea0fcbf5e refers to a dead (removed) revision in file `leahi-dialin/common/dg_defs.py'. Fisheye: No comparison available. Pass `N' to diff? Fisheye: Tag 12b82879196778f6c83d08751652177ea0fcbf5e refers to a dead (removed) revision in file `leahi-dialin/common/hd_defs.py'. Fisheye: No comparison available. Pass `N' to diff? Index: leahi-dialin/common/msg_defs.py =================================================================== diff -u -r07db7b5f01ad17d60c190e21574e1ed0552535ff -r12b82879196778f6c83d08751652177ea0fcbf5e --- leahi-dialin/common/msg_defs.py (.../msg_defs.py) (revision 07db7b5f01ad17d60c190e21574e1ed0552535ff) +++ leahi-dialin/common/msg_defs.py (.../msg_defs.py) (revision 12b82879196778f6c83d08751652177ea0fcbf5e) @@ -18,89 +18,8 @@ from .msg_ids import MsgIds -# Define msg ids that are not yet added to common but are needed in leahi-dialin - -@unique -class MsgIdsDialin(DialinEnum): - - MSG_DIALIN_ID_HD_SERIAL_NUMBER_RESPONSE = 0x87 - MSG_DIALIN_ID_DG_SERIAL_NUMBER_RESPONSE = 0x88 - MSG_DIALIN_ID_UI_SYSTEM_USAGE_REQUEST = 0x89 - MSG_DIALIN_ID_HD_SYSTEM_USAGE_RESPONSE = 0x8A - MSG_DIALIN_ID_DG_SYSTEM_USAGE_RESPONSE = 0x8C - MSG_DIALIN_ID_HD_FLUID_LEAK_STATE_DETECTOR_OVERRIDE = 0x8047 - MSG_DIALIN_ID_HD_VALVES_POSITION_COUNT_OVERRIDE = 0x8058 - MSG_DIALIN_ID_HD_DISINFECT_STATE = 0x7E - MSG_DIALIN_ID_HD_VERSION_REQUEST = 0x9E - MSG_DIALIN_ID_UI_POST_REPORT_VERSION = 0x9F - - ACK_NOT_REQUIRED = [ - MsgIds.MSG_ID_ALARM_STATUS_DATA.value, - MsgIds.MSG_ID_ALARM_TRIGGERED.value, - MsgIds.MSG_ID_ALARM_CLEARED.value, - MsgIds.MSG_ID_BLOOD_FLOW_DATA.value, - MsgIds.MSG_ID_DIALYSATE_FLOW_DATA.value, - MsgIds.MSG_ID_PRESSURE_OCCLUSION_DATA.value, - MsgIds.MSG_ID_RTC_EPOCH_DATA.value, - MsgIds.MSG_ID_DIALYSATE_OUT_FLOW_DATA.value, - MsgIds.MSG_ID_LOAD_CELL_READINGS_DATA.value, - MsgIds.MSG_ID_TREATMENT_TIME_DATA.value, - MsgIds.MSG_ID_POWER_OFF_WARNING.value, - MsgIds.MSG_ID_TREATMENT_STATE_DATA.value, - MsgIds.MSG_ID_RO_PUMP_DATA.value, - MsgIds.MSG_ID_DG_PRESSURES_DATA.value, - MsgIds.MSG_ID_DRAIN_PUMP_DATA.value, - MsgIds.MSG_ID_HD_OP_MODE_DATA.value, - MsgIds.MSG_ID_DG_OP_MODE_DATA.value, - MsgIds.MSG_ID_DG_RESERVOIRS_DATA.value, - MsgIds.MSG_ID_DG_VALVES_STATES_DATA.value, - MsgIds.MSG_ID_DG_HEATERS_DATA.value, - MsgIds.MSG_ID_DG_TEMPERATURE_DATA.value, - MsgIds.MSG_ID_SALINE_BOLUS_DATA.value, - MsgIds.MSG_ID_DG_CONDUCTIVITY_DATA.value, - MsgIds.MSG_ID_HD_ACCELEROMETER_DATA.value, - MsgIds.MSG_ID_DG_ACCELEROMETER_DATA.value, - MsgIds.MSG_ID_DG_HEAT_DISINFECT_DATA.value, - MsgIds.MSG_ID_HD_VALVES_DATA.value, - MsgIds.MSG_ID_HD_AIR_TRAP_DATA.value, - MsgIds.MSG_ID_ALARM_CONDITION_CLEARED.value, - MsgIds.MSG_ID_DG_CONCENTRATE_PUMP_DATA.value, - MsgIds.MSG_ID_HD_PRIMING_STATUS_DATA.value, - MsgIds.MSG_ID_DG_UV_REACTORS_DATA.value, - MsgIds.MSG_ID_DG_THERMISTORS_DATA.value, - MsgIds.MSG_ID_DG_FANS_DATA.value, - MsgIds.MSG_ID_HD_TREATMENT_STOP_TIMER_DATA.value, - MsgIds.MSG_ID_HD_HEPARIN_DATA.value, - MsgIds.MSG_ID_HD_RINSEBACK_PROGRESS.value, - MsgIds.MSG_ID_HD_BLOOD_PRIME_PROGRESS_DATA.value, - MsgIds.MSG_ID_HD_RECIRC_PROGRESS_DATA.value, - MsgIds.MSG_ID_PRE_TREATMENT_STATE_DATA.value, - MsgIds.MSG_ID_DG_FILTER_FLUSH_PROGRESS_DATA.value, - MsgIds.MSG_ID_HD_NO_CART_SELF_TEST_PROGRESS_DATA.value, - MsgIds.MSG_ID_HD_DRY_SELF_TEST_PROGRESS_DATA.value, - MsgIds.MSG_ID_HD_SYRINGE_PUMP_DATA.value, - MsgIds.MSG_ID_HD_FLUID_LEAK_STATE_DATA.value, - MsgIds.MSG_ID_DG_FLUID_LEAK_STATE_DATA.value, - MsgIds.MSG_ID_HD_BLOOD_LEAK_DATA.value, - MsgIds.MSG_ID_HD_POST_TREATMENT_STATE_DATA.value, - MsgIds.MSG_ID_DG_FLUSH_DATA.value, - MsgIds.MSG_ID_HD_VOLTAGES_DATA.value, - MsgIds.MSG_ID_HD_ALARM_INFORMATION_DATA.value, - MsgIds.MSG_ID_DG_HEAT_DISINFECT_TIME_DATA.value, - MsgIds.MSG_ID_DG_CHEM_DISINFECT_TIME_DATA.value, - MsgIds.MSG_ID_DG_VOLTAGES_DATA.value, - MsgIds.MSG_ID_DG_CHEM_DISINFECT_DATA.value, - MsgIds.MSG_ID_HD_BUBBLES_DATA.value, - MsgIds.MSG_ID_HD_TEMPERATURES_DATA.value, - MsgIds.MSG_ID_DG_SWITCHES_DATA.value, - MsgIds.MSG_ID_HD_SWITCHES_DATA.value, - MsgIds.MSG_ID_HD_FANS_DATA.value, - MsgIds.MSG_ID_DG_ALARM_INFO_DATA.value, - MsgIds.MSG_ID_HD_RESERVOIRS_DATA.value, - MsgIds.MSG_ID_DG_CPLD_STATUS_DATA.value, - MsgIds.MSG_ID_DG_DIALIN_CHECK_IN.value, - MsgIds.MSG_ID_HD_DIALIN_CHECK_IN.value + ] @@ -124,51 +43,37 @@ REQUEST_REJECT_REASON_UF_NOT_PAUSED = 15 REQUEST_REJECT_REASON_SALINE_BOLUS_IN_PROGRESS = 16 REQUEST_REJECT_REASON_PARAM_OUT_OF_RANGE = 17 - REQUEST_REJECT_REASON_HEPARIN_PRESTOP_EXCEEDS_DURATION = 18 - REQUEST_REJECT_REASON_DG_FILTER_FLUSH_HAS_BEEN_EXPIRED = 19 - REQUEST_REJECT_REASON_AVAILABLE_2 = 20 - REQUEST_REJECT_REASON_SALINE_MAX_VOLUME_REACHED = 21 - REQUEST_REJECT_REASON_SALINE_BOLUS_NOT_IN_PROGRESS = 22 - REQUEST_REJECT_REASON_ACTION_DISABLED_IN_CURRENT_STATE = 23 - REQUEST_REJECT_REASON_ALARM_IS_ACTIVE = 24 - REQUEST_REJECT_REASON_INVALID_COMMAND = 25 - REQUEST_REJECT_REASON_TREATMENT_IS_COMPLETED = 26 - REQUEST_REJECT_REASON_ADDL_RINSEBACK_MAX_VOLUME_REACHED = 27 - REQUEST_REJECT_REASON_DIALYZER_NOT_INVERTED = 28 - REQUEST_REJECT_REASON_NO_PATIENT_CONNECTION_CONFIRM = 29 - REQUEST_REJECT_REASON_HEPARIN_PAUSE_INVALID_IN_THIS_STATE = 30 - REQUEST_REJECT_REASON_HEPARIN_NOT_PAUSED = 31 - REQUEST_REJECT_REASON_DG_COMM_LOST = 32 - REQUEST_REJECT_REASON_DRAIN_NOT_COMPLETE = 33 - REQUEST_REJECT_REASON_DG_NOT_IN_STANDBY_IDLE_STATE = 34 - REQUEST_REJECT_REASON_INVALID_REQUEST_FORMAT = 35 - REQUEST_REJECT_REASON_INVALID_DATE_OR_TIME = 36 - REQUEST_REJECT_REASON_TREATMENT_IN_PROGRESS = 37 - REQUEST_REJECT_REASON_BATTERY_IS_NOT_CHARGED = 38 - REQUEST_REJECT_REASON_RINSEBACK_NOT_COMPLETED = 39 - REQUEST_REJECT_REASON_RESERVOIR_ONE_IS_NOT_READY = 40 - REQUEST_REJECT_REASON_PUMP_TRACK_NOT_CLOSED = 41 - REQUEST_REJECT_REASON_DOOR_NOT_CLOSED = 42 - REQUEST_REJECT_REASON_SYRINGE_NOT_PRESENT = 43 - REQUEST_REJECT_REASON_DG_DIALYSATE_CAP_OPEN = 44 - REQUEST_REJECT_REASON_DG_CONCENTRATE_CAP_OPEN = 45 - REQUEST_REJECT_REASON_DG_DISINFECT_HAS_BEEN_EXPIRED = 46 - REQUEST_REJECT_REASON_DG_SERVICE_IS_DUE = 47 - REQUEST_REJECT_REASON_HD_SERVICE_IS_DUE = 48 - REQUEST_REJECT_REASON_DG_CHEM_FLUSH_NOT_COMPLETED = 49 - REQUEST_REJECT_REASON_DG_RO_FILTER_TEMPERATURE_OUT_OF_RANGE = 50 - REQUEST_REJECT_REASON_DG_INCOMPATIBLE = 51 - REQUEST_REJECT_REASON_HEPARIN_PRESTOP_WITH_NO_DISPENSE = 52 - REQUEST_REJECT_REASON_DIALYZER_REPRIME_IN_PROGRESS = 53 - REQUEST_REJECT_REASON_DG_RO_ONLY_MODE_DG_BUSY = 54 - REQUEST_REJECT_REASON_DG_RO_ONLY_MODE_INVALID_PARAMETER = 55 - REQUEST_REJECT_REASON_DG_RO_ONLY_MODE_INVALID_PAYLOAD_LENGTH = 56 - REQUEST_REJECT_REASON_TREATMENT_CANNOT_BE_RESUMED = 57 - REQUEST_REJECT_REASON_EXCEEDS_MAXIMUM_HEPARIN_VOLUME = 58 - REQUEST_REJECT_REASON_CHEM_DISINFECT_NOT_ENABLED_INST_CONFIG = 59 - NUM_OF_REQUEST_REJECT_REASONS = 60 + REQUEST_REJECT_REASON_FILTER_FLUSH_HAS_BEEN_EXPIRED = 18 + REQUEST_REJECT_REASON_SALINE_MAX_VOLUME_REACHED = 19 + REQUEST_REJECT_REASON_SALINE_BOLUS_NOT_IN_PROGRESS = 20 + REQUEST_REJECT_REASON_ACTION_DISABLED_IN_CURRENT_STATE = 21 + REQUEST_REJECT_REASON_ALARM_IS_ACTIVE = 22 + REQUEST_REJECT_REASON_INVALID_COMMAND = 23 + REQUEST_REJECT_REASON_TREATMENT_IS_COMPLETED = 24 + REQUEST_REJECT_REASON_ADDL_RINSEBACK_MAX_VOLUME_REACHED = 25 + REQUEST_REJECT_REASON_DIALYZER_NOT_INVERTED = 26 + REQUEST_REJECT_REASON_NO_PATIENT_CONNECTION_CONFIRM = 27 + REQUEST_REJECT_REASON_DD_COMM_LOST = 28 + REQUEST_REJECT_REASON_DD_NOT_IN_STANDBY_IDLE_STATE = 29 + REQUEST_REJECT_REASON_INVALID_REQUEST_FORMAT = 30 + REQUEST_REJECT_REASON_INVALID_DATE_OR_TIME = 31 + REQUEST_REJECT_REASON_TREATMENT_IN_PROGRESS = 32 + REQUEST_REJECT_REASON_BATTERY_IS_NOT_CHARGED = 33 + REQUEST_REJECT_REASON_RINSEBACK_NOT_COMPLETED = 34 + REQUEST_REJECT_REASON_DOOR_NOT_CLOSED = 35 + REQUEST_REJECT_REASON_DD_DIALYSATE_CAP_OPEN = 36 + REQUEST_REJECT_REASON_DD_CONCENTRATE_CAP_OPEN = 37 + REQUEST_REJECT_REASON_DISINFECT_HAS_BEEN_EXPIRED = 38 + REQUEST_REJECT_REASON_DD_SERVICE_IS_DUE = 39 + REQUEST_REJECT_REASON_TD_SERVICE_IS_DUE = 40 + REQUEST_REJECT_REASON_RO_FILTER_TEMPERATURE_OUT_OF_RANGE = 41 + REQUEST_REJECT_REASON_DD_INCOMPATIBLE = 42 + REQUEST_REJECT_REASON_DIALYZER_REPRIME_IN_PROGRESS = 43 + REQUEST_REJECT_REASON_RO_ONLY_MODE_DD_BUSY = 44 + REQUEST_REJECT_REASON_RO_ONLY_MODE_INVALID_PARAMETER = 45 + REQUEST_REJECT_REASON_RO_ONLY_MODE_INVALID_PAYLOAD_LENGTH = 46 + REQUEST_REJECT_REASON_TREATMENT_CANNOT_BE_RESUMED = 47 - class MsgFieldPositions: # Generic response msg field byte positions (where 32-bit data fields are used) START_POS_FIELD_1 = 6 # Hardcoded for now to avoid cyclic import issue. See protocols.CAN.DenaliMessage class Index: leahi-dialin/common/msg_ids.py =================================================================== diff -u -r07db7b5f01ad17d60c190e21574e1ed0552535ff -r12b82879196778f6c83d08751652177ea0fcbf5e --- leahi-dialin/common/msg_ids.py (.../msg_ids.py) (revision 07db7b5f01ad17d60c190e21574e1ed0552535ff) +++ leahi-dialin/common/msg_ids.py (.../msg_ids.py) (revision 12b82879196778f6c83d08751652177ea0fcbf5e) @@ -21,498 +21,126 @@ @unique class MsgIds(DialinEnum): MSG_ID_UNUSED = 0x0 - MSG_ID_OFF_BUTTON_PRESS_REQUEST = 0x1 - MSG_ID_ALARM_STATUS_DATA = 0x2 - MSG_ID_ALARM_TRIGGERED = 0x3 - MSG_ID_ALARM_CLEARED = 0x4 - MSG_ID_BLOOD_FLOW_DATA = 0x5 - MSG_ID_UI_POST_TX_NEXT_REQUEST = 0x6 - MSG_ID_UI_CHECK_IN = 0x7 - MSG_ID_DIALYSATE_FLOW_DATA = 0x8 - MSG_ID_PRESSURE_OCCLUSION_DATA = 0x9 - MSG_ID_RTC_EPOCH_DATA = 0xA - MSG_ID_DIALYSATE_OUT_FLOW_DATA = 0xB - MSG_ID_LOAD_CELL_READINGS_DATA = 0xC - MSG_ID_TREATMENT_TIME_DATA = 0xD - MSG_ID_POWER_OFF_WARNING = 0xE - MSG_ID_TREATMENT_STATE_DATA = 0xF - MSG_ID_USER_UF_PAUSE_RESUME_REQUEST = 0x10 - MSG_ID_USER_UF_SETTINGS_CHANGE_REQUEST = 0x11 - MSG_ID_USER_SALINE_BOLUS_REQUEST = 0x12 - MSG_ID_USER_UF_SETTINGS_CHANGE_RESPONSE = 0x13 - MSG_ID_USER_SALINE_BOLUS_RESPONSE = 0x14 - MSG_ID_USER_CONFIRM_UF_SETTINGS_CHANGE_REQUEST = 0x15 - MSG_ID_USER_TREATMENT_TIME_CHANGE_REQUEST = 0x16 - MSG_ID_USER_BLOOD_DIAL_RATE_CHANGE_REQUEST = 0x17 - MSG_ID_USER_BLOOD_DIAL_RATE_CHANGE_RESPONSE = 0x18 - MSG_ID_SET_DG_DIALYSATE_TEMP_TARGETS = 0x19 - MSG_ID_TREATMENT_PARAM_CHANGE_RANGES_DATA = 0x1A - MSG_ID_USER_TREATMENT_TIME_CHANGE_RESPONSE = 0x1B - MSG_ID_FW_VERSIONS_REQUEST = 0x1C - MSG_ID_HD_VERSION_REPONSE = 0x1D - MSG_ID_DG_VERSION_REPONSE = 0x1E - MSG_ID_RO_PUMP_DATA = 0x1F - MSG_ID_DG_PRESSURES_DATA = 0x20 - MSG_ID_DG_SWITCH_RESERVOIR_CMD_REQUEST = 0x21 - MSG_ID_DG_FILL_CMD_REQUEST = 0x22 - MSG_ID_DG_DRAIN_CMD_REQUEST = 0x23 - MSG_ID_DRAIN_PUMP_DATA = 0x24 - MSG_ID_HD_OP_MODE_DATA = 0x25 - MSG_ID_STARTING_STOPPING_TREATMENT_CMD_REQUEST = 0x26 - MSG_ID_DG_OP_MODE_DATA = 0x27 - MSG_ID_DG_RESERVOIRS_DATA = 0x28 - MSG_ID_DG_SAMPLE_WATER_CMD_REQUEST = 0x29 - MSG_ID_DG_VALVES_STATES_DATA = 0x2A - MSG_ID_HD_START_STOP_TRIMMER_HEATER_CMD_REQUEST = 0x2B - MSG_ID_DG_HEATERS_DATA = 0x2C - MSG_ID_DG_TEMPERATURE_DATA = 0x2D - MSG_ID_USER_UF_SETTINGS_CHANGE_CONFIRMATION_RESPONSE = 0x2E - MSG_ID_SALINE_BOLUS_DATA = 0x2F - MSG_ID_DG_START_STOP_HEAT_DISINFECT_CMD_REQUEST = 0x30 - MSG_ID_DG_CONDUCTIVITY_DATA = 0x31 - MSG_ID_USER_ALARM_SILENCE_REQUEST = 0x32 - MSG_ID_HD_ACCELEROMETER_DATA = 0x33 - MSG_ID_DG_ACCELEROMETER_DATA = 0x34 - MSG_ID_UI_NEW_TREATMENT_PARAMS_REQUEST = 0x35 - MSG_ID_HD_NEW_TREATMENT_PARAMS_RESPONSE = 0x36 - MSG_ID_DG_HEAT_DISINFECT_DATA = 0x37 - MSG_ID_UI_INITIATE_TREATMENT_REQUEST = 0x38 - MSG_ID_HD_INITIATE_TREATMENT_RESPONSE = 0x39 - MSG_ID_HD_VALVES_DATA = 0x3A - MSG_ID_UI_USER_CONFIRM_TREATMENT_PARAMS_REQUEST = 0x3B - MSG_ID_UI_START_PRIME_REQUEST = 0x3C - MSG_ID_HD_START_PRIME_RESPONSE = 0x3D - MSG_ID_HD_AIR_TRAP_DATA = 0x3E - MSG_ID_ALARM_CONDITION_CLEARED = 0x3F - MSG_ID_UI_ALARM_USER_ACTION_REQUEST = 0x40 - MSG_ID_USER_UF_PAUSE_RESUME_RESPONSE = 0x41 - MSG_ID_DG_CONCENTRATE_PUMP_DATA = 0x42 - MSG_ID_HD_PRIMING_STATUS_DATA = 0x43 - MSG_ID_DG_UV_REACTORS_DATA = 0x44 - MSG_ID_DG_THERMISTORS_DATA = 0x45 - MSG_ID_UI_PRESSURE_LIMITS_CHANGE_REQUEST = 0x46 - MSG_ID_HD_PRESSURE_LIMITS_CHANGE_RESPONSE = 0x47 - MSG_ID_DG_FANS_DATA = 0x48 - MSG_ID_HD_TREATMENT_STOP_TIMER_DATA = 0x49 - MSG_ID_UI_PATIENT_DISCONNECTION_CONFIRM_REQUEST = 0x4A - MSG_ID_UI_HEPARIN_PAUSE_RESUME_REQUEST = 0x4B - MSG_ID_HD_HEPARIN_PAUSE_RESUME_RESPONSE = 0x4C - MSG_ID_HD_HEPARIN_DATA = 0x4D - MSG_ID_UI_SET_ALARM_AUDIO_VOLUME_LEVEL_CMD_REQUEST = 0x4E - MSG_ID_UI_SET_UF_VOLUME_PARAMETER_REQUEST = 0x4F - MSG_ID_HD_SET_UF_VOLUME_PARAMETER_RESPONSE = 0x50 - MSG_ID_DG_COMMAND_RESPONSE = 0x51 - MSG_ID_UI_RINSEBACK_CMD_REQUEST = 0x52 - MSG_ID_HD_RINSEBACK_CMD_RESPONSE = 0x53 - MSG_ID_UI_RECIRC_CMD_REQUEST = 0x54 - MSG_ID_HD_RECIRC_CMD_RESPONSE = 0x55 - MSG_ID_HD_RINSEBACK_PROGRESS = 0x56 - MSG_ID_UI_TX_END_CMD_REQUEST = 0x57 - MSG_ID_HD_TX_END_CMD_RESPONSE = 0x58 - MSG_ID_HD_BLOOD_PRIME_PROGRESS_DATA = 0x59 - MSG_ID_HD_RECIRC_PROGRESS_DATA = 0x5A - MSG_ID_DG_CHANGE_VALVE_SETTING_CMD_REQUEST = 0x5B - MSG_ID_PRE_TREATMENT_STATE_DATA = 0x5C - MSG_ID_UI_SAMPLE_WATER_CMD_REQUEST = 0x5D - MSG_ID_HD_SAMPLE_WATER_CMD_RESPONSE = 0x5E - MSG_ID_UI_SAMPLE_WATER_RESULT = 0x5F - MSG_ID_DG_FILTER_FLUSH_PROGRESS_DATA = 0x60 - MSG_ID_HD_NO_CART_SELF_TEST_PROGRESS_DATA = 0x61 - MSG_ID_UI_INSTALLATION_CONFIRM_REQUEST = 0x62 - MSG_ID_HD_DRY_SELF_TEST_PROGRESS_DATA = 0x63 - MSG_ID_UI_PATIENT_CONNECTION_BEGIN_REQUEST = 0x64 - MSG_ID_HD_PATIENT_CONNECTION_BEGIN_RESPONSE = 0x65 - MSG_ID_UI_PATIENT_CONNECTION_CONFIRM_REQUEST = 0x66 - MSG_ID_HD_PATIENT_CONNECTION_CONFIRM_RESPONSE = 0x67 - MSG_ID_UI_CONSUMABLE_INSTALL_CONFIRM_REQUEST = 0x68 - MSG_ID_HD_SYRINGE_PUMP_DATA = 0x69 - MSG_ID_HD_FLUID_LEAK_STATE_DATA = 0x6A - MSG_ID_DG_FLUID_LEAK_STATE_DATA = 0x6B - MSG_ID_HD_BLOOD_LEAK_DATA = 0x6C - MSG_ID_UI_HD_SET_RTC_REQUEST = 0x6D - MSG_ID_HD_UI_SET_RTC_RESPONSE = 0x6E - MSG_ID_UI_DG_SET_RTC_REQUEST = 0x6F - MSG_ID_DG_UI_SET_RTC_RESPONSE = 0x70 - MSG_ID_UI_START_TREATMENT_REQUEST = 0x71 - MSG_ID_HD_START_TREATMENT_RESPONSE = 0x72 - MSG_ID_UI_DISPOSABLE_REMOVAL_CONFIRM_REQUEST = 0x73 - MSG_ID_HD_DISPOSABLE_REMOVAL_CONFIRM_RESPONSE = 0x74 - MSG_ID_UI_TREATMENT_LOG_DATA_REQUEST = 0x75 - MSG_ID_HD_TREATMENT_LOG_DATA_RESPONSE = 0x76 - MSG_ID_HD_POST_TREATMENT_STATE_DATA = 0x77 - MSG_ID_DG_START_STOP_CHEM_DISINFECT = 0x78 - MSG_ID_DG_START_STOP_FLUSH_CMD_REQUEST = 0x79 - MSG_ID_DG_FLUSH_DATA = 0x7A - MSG_ID_HD_VOLTAGES_DATA = 0x7B - MSG_ID_HD_ALARM_AUDIO_VOLUME_SET_RESPONSE = 0x7C - MSG_ID_HD_ALARM_INFORMATION_DATA = 0x7D - MSG_ID_HD_POST_TX_NEXT_CMD_RESPONSE = 0x7E - MSG_ID_UI_DISINFECT_REQUEST = 0x7F - MSG_ID_HD_DISINFECT_RESPONSE = 0x80 - MSG_ID_DG_SEND_SERVICE_SCHEDULE_DATA_TO_HD = 0x81 - MSG_ID_HD_REQUEST_SERVICE_RECORD_FROM_HD = 0x82 - MSG_ID_DG_PARK_CONCENTRATE_PUMPS_CMD_REQUEST = 0x83 - MSG_ID_DG_HEAT_DISINFECT_TIME_DATA = 0x84 - MSG_ID_DG_CHEM_DISINFECT_TIME_DATA = 0x85 - MSG_ID_DG_VOLTAGES_DATA = 0x86 - MSG_ID_DG_CHEM_DISINFECT_DATA = 0x87 - MSG_ID_DG_SERIAL_NUMBER_RESPONSE = 0x88 - MSG_ID_UI_SERVICE_INFO_REQUEST = 0x89 - MSG_ID_HD_SERVICE_SCHEDULE_DATA = 0x8A - MSG_ID_HD_USAGE_DATA = 0x8B - MSG_ID_DG_SERVICE_SCHEDULE_DATA_TO_UI = 0x8C - MSG_ID_DG_USAGE_DATA = 0x8D - MSG_ID_HD_POST_SINGLE_TEST_RESULT = 0x8E - MSG_ID_HD_POST_FINAL_TEST_RESULT = 0x8F - MSG_ID_DG_POST_SINGLE_TEST_RESULT = 0x90 - MSG_ID_DG_POST_FINAL_TEST_RESULT = 0x91 - MSG_ID_UI_POST_FINAL_TEST_RESULT = 0x92 - MSG_ID_HD_BUBBLES_DATA = 0x93 - MSG_ID_HD_TREATMENT_LOG_PERIODIC_DATA = 0x94 - MSG_ID_HD_TREATMENT_LOG_ALARM_EVENT = 0x95 - MSG_ID_HD_TREATMENT_LOG_EVENT = 0x96 - MSG_ID_UI_ACTIVE_ALARMS_LIST_REQUEST = 0x97 - MSG_ID_HD_ACTIVE_ALARMS_LIST_REQUEST_RESPONSE = 0x98 - MSG_ID_HD_SERIAL_NUMBER_RESPONSE = 0x99 - MSG_ID_HD_SET_STANDBY_DISINFECT_SUB_MODE_REQUEST = 0x9A - MSG_ID_HD_SET_STANDBY_DISINFECT_SUB_MODE_RESPONSE = 0x9B - MSG_ID_HD_DG_POST_RESULT_REQUEST = 0x9C - MSG_ID_HD_TEMPERATURES_DATA = 0x9D - MSG_ID_HD_UI_VERSION_INFO_REQUEST = 0x9E - MSG_ID_UI_VERSION_INFO_RESPONSE = 0x9F - MSG_ID_HD_USAGE_INFO_REQUEST = 0xA0 - MSG_ID_DG_SWITCHES_DATA = 0xA1 - MSG_ID_HD_SWITCHES_DATA = 0xA2 - MSG_ID_HD_FANS_DATA = 0xA3 - MSG_ID_HD_EVENT = 0xA4 - MSG_ID_DG_EVENT = 0xA5 - MSG_ID_HD_SET_SERVICE_TIME_REQUEST = 0xA6 - MSG_ID_DG_ALARM_INFO_DATA = 0xA7 - MSG_ID_HD_RESERVOIRS_DATA = 0xA8 - MSG_ID_HD_DG_CONCENTRATE_MIXING_RATIOS_REQUEST = 0xA9 - MSG_ID_DG_CONCENTRATE_MIXING_RATIOS_DATA = 0xAA - MSG_ID_DG_SCHEDULED_RUNS_DATA = 0xAB - MSG_ID_DG_SET_SERVICE_TIME_REQUEST = 0xAC - MSG_ID_UI_INSTALLATION_CONFIRM_RESPONSE = 0xAD - MSG_ID_DG_FILL_MODE_DATA = 0xAE - MSG_ID_DG_GEN_IDLE_DATA = 0xAF - MSG_ID_UI_SERVICE_MODE_REQUEST = 0xB0 - MSG_ID_HD_RESPONSE_SERVICE_MODE_REQUEST = 0xB1 - MSG_ID_HD_REQUEST_UI_FINAL_POST_RESULT = 0xB2 - MSG_ID_DG_FLOW_SENSORS_DATA = 0xB3 - MSG_ID_DG_RESPONSE_SERVICE_MODE_REQUEST = 0xB4 - MSG_ID_HD_DG_ALARMS_REQUEST = 0xB5 - MSG_ID_HD_DG_SERVICE_MODE_REQUEST = 0xB6 - MSG_ID_DG_RTC_EPOCH_DATA = 0xB7 - MSG_ID_HD_DG_USAGE_INFO_REQUEST = 0xB8 - MSG_ID_UI_HD_RESET_IN_SERVICE_MODE_REQUEST = 0xB9 - MSG_ID_HD_UI_CONFIRMATION_REQUEST = 0xBA - MSG_ID_UI_CONFIRMATION_RESULT_RESPONSE = 0xBB - MSG_ID_UI_SET_DG_RO_MODE = 0xBC - MSG_ID_DG_CPLD_STATUS_DATA = 0xBD - MSG_ID_HD_BATTERY_MANAGEMENT_DATA = 0xBE - MSG_ID_HD_BATTERY_STATUS_DATA = 0xBF - MSG_ID_DG_CHEM_DISINFECT_FLUSH_DATA = 0xC0 - MSG_ID_DG_CHEM_DISINFECT_FLUSH_TIME_DATA = 0xC1 - MSG_ID_DG_START_STOP_CHEM_DISINFECT_FLUSH = 0xC2 - MSG_ID_DG_RO_ONLY_MODE_STATUS_REQUEST = 0xC3 - MSG_ID_DG_RO_ONLY_MODE_STATUS_RESPONSE = 0xC4 - MSG_ID_DG_HEAT_DISINFECT_ACTIVE_COOL_DATA = 0xC5 - MSG_ID_DG_START_STOP_HEAT_DISINFECT_ACTIVE_COOL = 0xC6 - MSG_ID_HD_AIR_PUMP_DATA = 0xC7 - MSG_ID_HD_SEND_CHEM_FLUSH_SAMPLE_PASS_FAIL_TO_DG = 0xC8 - MSG_ID_DG_START_STOP_RO_PERMEATE_SAMPLE_MODE_CMD_REQUEST = 0xC9 - MSG_ID_DG_RO_PERMEATE_SAMPLE_DATA = 0xCA - MSG_ID_HD_SEND_RO_PERMEATE_SAMPLE_DISPENSE_REQUEST_TO_DG = 0xCB - MSG_ID_DG_SEND_RO_PERMEATE_SAMPLE_DISPENSE_READY_TO_HD = 0xCD - MSG_ID_DG_DRAIN_MODE_DATA = 0xCE - MSG_ID_UI_INSTITUTIONAL_RECORD_REQUEST = 0xCF - MSG_ID_HD_INSTITUTIONAL_RECORD_RESPONSE = 0xD0 + MSG_ID_ALARM_STATUS_DATA = 0x1 + MSG_ID_ALARM_TRIGGERED = 0x2 + MSG_ID_ALARM_CLEARED = 0x3 + MSG_ID_ALARM_CONDITION_CLEARED = 0x4 + MSG_ID_USER_ALARM_SILENCE_REQUEST = 0x5 + MSG_ID_UI_ALARM_USER_ACTION_REQUEST = 0x6 + MSG_ID_TD_ALARM_INFORMATION_DATA = 0x7 + MSG_ID_DD_ALARM_INFO_DATA = 0x8 + MSG_ID_UI_ACTIVE_ALARMS_LIST_REQUEST = 0x9 + MSG_ID_TD_ACTIVE_ALARMS_LIST_REQUEST_RESPONSE = 0xA + MSG_ID_UI_SET_ALARM_AUDIO_VOLUME_LEVEL_CMD_REQUEST = 0xB + MSG_ID_TD_ALARM_AUDIO_VOLUME_SET_RESPONSE = 0xC + MSG_ID_FW_VERSIONS_REQUEST = 0xD + MSG_ID_TD_VERSION_REPONSE = 0xE + MSG_ID_DD_VERSION_REPONSE = 0xF + MSG_ID_UI_CHECK_IN = 0x10 + MSG_ID_TD_POWER_OFF_WARNING = 0x11 + MSG_ID_TD_OP_MODE_DATA = 0x12 + MSG_ID_DD_OP_MODE_DATA = 0x13 + MSG_ID_DD_COMMAND_RESPONSE = 0x14 + MSG_ID_TD_UI_VERSION_INFO_REQUEST = 0x15 + MSG_ID_UI_VERSION_INFO_RESPONSE = 0x16 + MSG_ID_TD_EVENT = 0x17 + MSG_ID_DD_EVENT = 0x18 + MSG_ID_TD_DD_ALARMS_REQUEST = 0x19 + MSG_ID_UI_TD_RESET_IN_SERVICE_MODE_REQUEST = 0x1A + MSG_ID_DD_VALVES_STATES_DATA = 0x1B + MSG_ID_DD_PRESSURES_DATA = 0x1C + MSG_ID_TD_VOLTAGES_DATA = 0x1D + MSG_ID_TD_BUBBLES_DATA = 0x1E + MSG_ID_DD_CONDUCTIVITY_DATA = 0x1F + MSG_ID_TD_AIR_PUMP_DATA = 0x20 + MSG_ID_TD_SWITCHES_DATA = 0x21 + MSG_ID_POWER_OFF_WARNING = 0x22 + MSG_ID_OFF_BUTTON_PRESS_REQUEST = 0x23 + MSG_ID_PRESSURE_DATA = 0x24 + MSG_ID_TD_AIR_TRAP_DATA = 0x25 + MSG_ID_TD_VALVES_DATA = 0x26 - MSG_ID_CAN_ERROR_COUNT = 0x999 MSG_ID_TESTER_LOGIN_REQUEST = 0x8000 - MSG_ID_DIAL_OUT_FLOW_SET_PT_OVERRIDE = 0x8001 - MSG_ID_OFF_BUTTON_STATE_OVERRIDE = 0x8002 - MSG_ID_STOP_BUTTON_STATE_OVERRIDE = 0x8003 - MSG_ID_ALARM_LAMP_PATTERN_OVERRIDE = 0x8004 - MSG_ID_WATCHDOG_TASK_CHECKIN_OVERRIDE = 0x8005 - MSG_ID_ALARM_STATE_OVERRIDE = 0x8006 - MSG_ID_ALARM_TIME_OVERRIDE = 0x8007 - MSG_ID_BLOOD_FLOW_SET_PT_OVERRIDE = 0x8008 - MSG_ID_BLOOD_FLOW_MEAS_OVERRIDE = 0x8009 - MSG_ID_BLOOD_PUMP_MC_MEAS_SPEED_OVERRIDE = 0x800A - MSG_ID_BLOOD_PUMP_MC_MEAS_CURR_OVERRIDE = 0x800B - MSG_ID_BLOOD_FLOW_SEND_INTERVAL_OVERRIDE = 0x800C - MSG_ID_TREATMENT_TIME_REMAINING_OVERRIDE = 0x800D - MSG_ID_BLOOD_PUMP_MEAS_SPEED_OVERRIDE = 0x800E - MSG_ID_BLOOD_PUMP_MEAS_ROTOR_SPEED_OVERRIDE = 0x800F - MSG_ID_DIAL_IN_FLOW_SET_PT_OVERRIDE = 0x8010 - MSG_ID_DIAL_IN_FLOW_MEAS_OVERRIDE = 0x8011 - MSG_ID_DIAL_IN_PUMP_MC_MEAS_SPEED_OVERRIDE = 0x8012 - MSG_ID_DIAL_IN_PUMP_MC_MEAS_CURR_OVERRIDE = 0x8013 - MSG_ID_DIAL_IN_FLOW_SEND_INTERVAL_OVERRIDE = 0x8014 - MSG_ID_DIAL_IN_PUMP_MEAS_SPEED_OVERRIDE = 0x8015 - MSG_ID_DIAL_IN_PUMP_MEAS_ROTOR_SPEED_OVERRIDE = 0x8016 - MSG_ID_PRESSURE_ARTERIAL_OVERRIDE = 0x8017 - MSG_ID_PRESSURE_VENOUS_OVERRIDE = 0x8018 - MSG_ID_OCCLUSION_BLOOD_PUMP_OVERRIDE = 0x8019 - MSG_ID_BLOOD_ROTOR_COUNT_OVERRIDE = 0x801A - MSG_ID_HD_AIR_PUMP_SET_STATE = 0x801B - MSG_ID_PRES_OCCL_SEND_INTERVAL_OVERRIDE = 0x801C - MSG_ID_SET_RTC_DATE_TIME = 0x801D - MSG_ID_DIAL_OUT_FLOW_SEND_INTERVAL_OVERRIDE = 0x801E - MSG_ID_DIAL_OUT_UF_REF_VOLUME_OVERRIDE = 0x801F - MSG_ID_DIAL_OUT_UF_MEAS_VOLUME_OVERRIDE = 0x8020 - MSG_ID_DIAL_OUT_PUMP_MC_MEAS_SPEED_OVERRIDE = 0x8021 - MSG_ID_DIAL_OUT_PUMP_MC_MEAS_CURR_OVERRIDE = 0x8022 - MSG_ID_DIAL_OUT_PUMP_MEAS_SPEED_OVERRIDE = 0x8023 - MSG_ID_DIAL_OUT_PUMP_MEAS_ROTOR_SPEED_OVERRIDE = 0x8024 - MSG_ID_DIAL_OUT_LOAD_CELL_WEIGHT_OVERRIDE = 0x8025 - MSG_ID_HD_SAFETY_SHUTDOWN_OVERRIDE = 0x8026 - MSG_ID_HD_ACCEL_OVERRIDE = 0x8027 - MSG_ID_HD_ACCEL_MAX_OVERRIDE = 0x8028 - MSG_ID_HD_ACCEL_SEND_INTERVAL_OVERRIDE = 0x8029 - MSG_ID_HD_SYRINGE_PUMP_SEND_INTERVAL_OVERRIDE = 0x802A - MSG_ID_HD_SYRINGE_PUMP_OPERATION_REQUEST = 0x802B - MSG_ID_HD_SYRINGE_PUMP_MEASURED_RATE_OVERRIDE = 0x802C - MSG_ID_HD_SET_PARAMETER_TREATMENT_PARAMETER = 0x802D - MSG_ID_HD_VALVES_HOME = 0x802E - MSG_ID_HD_VALVES_POSITION_OVERRIDE = 0x802F - MSG_ID_HD_VALVES_SET_AIR_TRAP_VALVE = 0x8030 - MSG_ID_HD_VALVES_SET_PWM_OVERRIDE = 0x8031 - MSG_ID_HD_AIR_TRAP_SEND_INTERVAL_OVERRIDE = 0x8032 - MSG_ID_HD_AIR_TRAP_LEVEL_SENSOR_OVERRIDE = 0x8033 - MSG_ID_HD_SOFTWARE_RESET_REQUEST = 0x8034 - MSG_ID_HD_GET_SW_CONFIG_RECORD = 0x8035 - MSG_ID_HD_SET_SW_CONFIG_RECORD = 0x8036 - MSG_ID_BLOOD_PUMP_HOME_CMD = 0x8037 - MSG_ID_DIAL_IN_PUMP_HOME_CMD = 0x8038 - MSG_ID_DIAL_OUT_PUMP_HOME_CMD = 0x8039 - MSG_ID_SUPER_CLEAR_ALARMS_CMD = 0x803A - MSG_ID_HD_SYRINGE_PUMP_MEASURED_FORCE_OVERRIDE = 0x803B - MSG_ID_HD_SYRINGE_PUMP_SYRINGE_DETECT_OVERRIDE = 0x803C - MSG_ID_HD_SET_CALIBRATION_RECORD = 0x803D - MSG_ID_HD_GET_CALIBRATION_RECORD = 0x803E - MSG_ID_HD_SEND_CALIBRATION_RECORD = 0x803F - MSG_ID_HD_SET_SYSTEM_RECORD = 0x8040 - MSG_ID_HD_GET_SYSTEM_RECORD = 0x8041 - MSG_ID_HD_SEND_SYSTEM_RECORD = 0x8042 - MSG_ID_HD_GET_SERVICE_RECORD = 0x8043 - MSG_ID_HD_SET_SERVICE_RECORD = 0x8044 - MSG_ID_HD_SEND_SERVICE_RECORD = 0x8045 - MSG_ID_HD_SET_OP_MODE_REQUEST = 0x8046 - MSG_ID_HD_FLUID_LEAK_SEND_INTERVAL_OVERRIDE = 0x8047 - MSG_ID_HD_FLUID_LEAK_STATE_OVERRIDE = 0x8048 - MSG_ID_HD_SYRINGE_PUMP_MEASURED_HOME_OVERRIDE = 0x8049 - MSG_ID_HD_SYRINGE_PUMP_MEASURED_POSITION_OVERRIDE = 0x804A - MSG_ID_HD_SYRINGE_PUMP_MEASURED_VOLUME_OVERRIDE = 0x804B - MSG_ID_HD_BLOOD_LEAK_DATA_SEND_INTERVAL_OVERRIDE = 0x804C - MSG_ID_HD_BLOOD_LEAK_STATUS_OVERRIDE = 0x804D - MSG_ID_HD_BLOOD_LEAK_ZERO_REQUEST = 0x804E - MSG_ID_HD_MONITORED_VOLTAGES_SEND_INTERVAL_OVERRIDE = 0x8050 - MSG_ID_HD_MONITORED_VOLTAGES_OVERRIDE = 0x8051 - MSG_ID_HD_ALARM_INFO_SEND_INTERVAL_OVERRIDE = 0x8052 - MSG_ID_HD_ALARM_AUDIO_VOLUME_LEVEL_OVERRIDE = 0x8053 - MSG_ID_HD_ALARM_AUDIO_CURRENT_HG_OVERRIDE = 0x8054 - MSG_ID_HD_ALARM_AUDIO_CURRENT_LG_OVERRIDE = 0x8055 - MSG_ID_HD_ALARM_BACKUP_AUDIO_CURRENT_OVERRIDE = 0x8056 - MSG_ID_HD_VALVES_CURRENT_OVERRIDE = 0x8057 - MSG_ID_HD_VALVES_POSITION_COUNT_OVERRIDE = 0x8058 - MSG_ID_HD_SYRINGE_PUMP_STATUS_OVERRIDE = 0x8059 - MSG_ID_HD_SYRINGE_PUMP_ENCODER_STATUS_OVERRIDE = 0x805A - MSG_ID_HD_SYRINGE_PUMP_ADC_DAC_STATUS_OVERRIDE = 0x805B - MSG_ID_HD_SYRINGE_PUMP_ADC_READ_COUNTER_OVERRIDE = 0x805C - MSG_ID_HD_BUBBLES_DATA_SEND_INTERVAL_OVERRIDE = 0x805D - MSG_ID_HD_BUBBLE_STATUS_OVERRIDE = 0x805E - MSG_ID_HD_BLOOD_PRIME_VOLUME_OVERRIDE = 0x805F - MSG_ID_HD_BUBBLE_SELF_TEST_REQUEST = 0x8060 - MSG_ID_HD_AIR_PUMP_PUBLISH_INTERVAL_OVERRIDE = 0x8061 - MSG_ID_HD_SWITCHES_STATUS_OVERRIDE = 0x8062 - MSG_ID_HD_SWITCHES_PUBLISH_INTERVAL_OVERRIDE = 0x8063 - MSG_ID_HD_BATTERY_REMAINING_CAP_MWH_OVERRIDE = 0x8064 - MSG_ID_HD_TEMPERATURES_VALUE_OVERRIDE = 0x8065 - MSG_ID_HD_TEMPERATURES_PUBLISH_INTERVAL_OVERRIDE = 0x8066 - MSG_ID_HD_FANS_PUBLISH_INTERVAL_OVERRIDE = 0x8067 - MSG_ID_HD_FANS_RPM_OVERRIDE = 0x8068 - MSG_ID_HD_RINSEBACK_VOLUME_OVERRIDE = 0x8069 - MSG_ID_HD_SEND_SW_CONFIG_RECORD = 0x806A - MSG_ID_HD_ALARM_STATUS_PUBLISH_INTERVAL_OVERRIDE = 0x806B - MSG_ID_HD_TREATMENT_TIME_DATA_PUBLISH_INTERVAL_OVERRIDE = 0x806C - MSG_ID_HD_TREATMENT_RANGES_PUBLISH_INTERVAL_OVERRIDE = 0x806D - MSG_ID_HD_TREATMENT_STOP_DATA_PUBLISH_INTERVAL_OVERRIDE = 0x806E - MSG_ID_HD_BLOOD_PRIME_DATA_PUBLISH_INTERVAL_OVERRIDE = 0x806F - MSG_ID_HD_RINSEBACK_DATA_PUBLISH_INTERVAL_OVERRIDE = 0x8070 - MSG_ID_HD_STANDBY_DATA_PUBLISH_INTERVAL_OVERRIDE = 0x8071 - MSG_ID_HD_OP_MODE_DATA_PUBLISH_INTERVAL_OVERRIDE = 0x8072 - MSG_ID_HD_PRE_TREATMENT_DATA_PUBLISH_INTERVAL_OVERRIDE = 0x8073 - MSG_ID_HD_TREATMENT_DATA_PUBLISH_INTERVAL_OVERRIDE = 0x8074 - MSG_ID_HD_POST_TREATMENT_DATA_PUBLISH_INTERVAL_OVERRIDE = 0x8075 - MSG_ID_HD_BLOCK_MESSAGE_TRANSMISSION = 0x8076 - MSG_ID_HD_SYRINGE_PUMP_FORCE_SENSOR_DAC_CALIBRATE = 0x8077 - MSG_ID_HD_STOP_RTC_CLOCK = 0x8078 - MSG_ID_HD_FANS_DUTY_CYCLE_OVERRIDE = 0x8079 - MSG_ID_HD_SYRINGE_PUMP_HEPARIN_BOLUS_TARGET_RATE_OVERRIDE = 0x807A - MSG_ID_HD_REQ_CURRENT_TREATMENT_PARAMETERS = 0x807B - MSG_ID_HD_RES_CURRENT_TREATMENT_PARAMETERS = 0x807C - MSG_ID_HD_SET_FANS_RPM_ALARM_START_TIME_OFFSET = 0x807D - MSG_ID_HD_GET_USAGE_INFO_RECORD = 0x807E - MSG_ID_HD_SET_USAGE_INFO_RECORD = 0x807F - MSG_ID_HD_SEND_USAGE_INFO_RECORD = 0x8080 - MSG_ID_HD_SET_BLOOD_LEAK_2_EMB_MODE = 0x8081 - MSG_ID_HD_SET_BLOOD_LEAK_EMB_MODE_COMMAND = 0x8082 - MSG_ID_HD_SEND_BLOOD_LEAK_EMB_MODE_RESPONSE = 0x8083 - MSG_ID_HD_SEND_ALARMS_COMMAND = 0x8084 - MSG_ID_HD_BLOOD_PUMP_SET_PWM = 0x8085 - MSG_ID_HD_DIAL_IN_SET_PWM = 0x8086 - MSG_ID_HD_DIAL_OUT_SET_PWM = 0x8087 - MSG_ID_HD_DIALYSATE_INLET_PUMP_ROTOR_COUNT_OVERRIDE = 0x8088 - MSG_ID_HD_NV_RECORD_CRC_OVERRIDE = 0x8089 - MSD_ID_HD_RTC_CTL_REG1_STATUS_OVERRIDE = 0x808A - MSD_ID_HD_RTC_CTL_REG3_STATUS_OVERRIDE = 0x808B - MSG_ID_HD_BATTERY_STATUS_OVERRIDE = 0x808C - MSG_ID_HD_BATTERY_CHARGER_STATUS_OVERRIDE = 0x808D - MSG_ID_HD_BATTERY_COMM_STATUS_OVERRIDE = 0x808E - MSG_ID_HD_DIAL_IN_PUMP_HARD_STOP = 0x808F - MSG_ID_HD_DIAL_OUT_PUMP_HARD_STOP = 0x8090 - MSG_ID_HD_BLOOD_PUMP_HARD_STOP = 0x8091 - MSG_ID_HD_DIALIN_CHECK_IN = 0x8092 - MSG_ID_HD_ENABLE_VENOUS_BUBBLE_ALARM_DETECTION = 0x8093 - MSG_ID_HD_GET_TEST_CONFIGURATION = 0x8094 - MSG_ID_HD_SEND_TEST_CONFIGURATION = 0x8095 - MSG_ID_HD_RESET_ALL_TEST_CONFIGURATIONS = 0x8096 - MSG_ID_HD_SET_TEST_CONFIGURATION = 0x8097 - MSG_ID_HD_SIGNAL_RECOVER_FROM_FAULT_MODE = 0x8098 - MSG_ID_HD_RAM_STATUS_OVERRIDE = 0x8099 - MSG_ID_HD_VALVES_STATES_PUBLISH_INTERVAL_OVERRIDE = 0x809A - MSG_ID_HD_CAN_RECEIVE_ACK_MESSAGE_OVERRIDE = 0x809B - MSG_ID_HD_RECIRULATION_PCT_OVERRIDE = 0x809C - MSG_ID_HD_RAW_AIR_TRAP_LEVEL_SENSOR_OVERRIDE = 0x809D - MSG_ID_HD_GET_INSTITUTIONAL_RECORD = 0x809E - MSG_ID_HD_SET_INSTITUTIONAL_RECORD = 0x809F - MSG_ID_HD_SEND_INSTITUTIONAL_RECORD = 0x80A0 - MSG_ID_HD_PARTIAL_OCCLUSION_BLOOD_PUMP_OVERRIDE = 0x80A1 - MSG_ID_HD_PARTIAL_OCCL_BLOOD_PUMP_BASELINE_OVERRIDE = 0x80A2 + MSG_ID_TD_SOFTWARE_RESET_REQUEST = 0x8001 + MSG_ID_TD_SEND_TEST_CONFIGURATION = 0x8002 + MSG_ID_TD_BUBBLE_OVERRIDE_REQUEST = 0x8003 + MSG_ID_TD_VOLTAGE_PUBLISH_INTERVAL_OVERRIDE_REQUEST = 0x8004 + MSG_ID_TD_VOLTAGE_OVERRIDE_REQUEST = 0x8005 + MSG_ID_TD_BUBBLE_PUBLISH_INTERVAL_OVERRIDE_REQUEST = 0x8006 + MSG_ID_TD_PRESSURE_OVERRIDE_REQUEST = 0x8007 + MSG_ID_TD_AIR_PUMP_SET_STATE_REQUEST = 0x8008 + MSG_ID_TD_AIR_PUMP_PUBLISH_INTERVAL_OVERRIDE_REQUEST = 0x8009 + MSG_ID_TD_SWITCHES_PUBLISH_INTERVAL_OVERRIDE_REQUEST = 0x800A + MSG_ID_TD_SWITCH_STATE_OVERRIDE_REQUEST = 0x800B + MSG_ID_TD_OFF_BUTTON_OVERRIDE_REQUEST = 0x800C + MSG_ID_TD_STOP_BUTTON_OVERRIDE_REQUEST = 0x800D + MSG_ID_TD_ALARM_LAMP_PATTERN_OVERRIDE_REQUEST = 0x800E + MSG_ID_TD_ALARM_AUDIO_LEVEL_OVERRIDE_REQUEST = 0x800F + MSG_ID_TD_ALARM_AUDIO_CURRENT_HG_OVERRIDE_REQUEST = 0x8010 + MSG_ID_TD_ALARM_AUDIO_CURRENT_LG_OVERRIDE_REQUEST = 0x8011 + MSG_ID_TD_BACKUP_ALARM_AUDIO_CURRENT_OVERRIDE_REQUEST = 0x8012 + MSG_ID_TD_PRESSURE_PUBLISH_INTERVAL_OVERRIDE_REQUEST = 0x8013 + MSG_ID_TD_AIR_TRAP_LEVEL_OVERRIDE_REQUEST = 0x8014 + MSG_ID_TD_AIR_TRAP_LEVEL_RAW_OVERRIDE_REQUEST = 0x8015 + MSG_ID_TD_AIR_TRAP_PUBLISH_INTERVAL_OVERRIDE_REQUEST = 0x8016 + MSG_ID_TD_2_WAY_VALVE_SET_STATE_REQUEST = 0x8017 + MSG_ID_TD_ROTARY_PINCH_VALVE_SET_POS_REQUEST = 0x8018 + MSG_ID_TD_ROTARY_PINCH_VALVE_STATUS_OVERRIDE_REQUEST = 0x8019 + MSG_ID_TD_ROTARY_PINCH_VALVE_POSITION_OVERRIDE_REQUEST = 0x801A + MSG_ID_TD_VALVES_PUBLISH_INTERVAL_OVERRIDE_REQUEST = 0x801B + MSG_ID_TD_ALARM_STATUS_PUBLISH_INTERVAL_OVERRIDE_REQUEST = 0x801C + MSG_ID_TD_ALARM_INFO_PUBLISH_INTERVAL_OVERRIDE_REQUEST = 0x801D + MSG_ID_TD_ALARM_START_TIME_OVERRIDE_REQUEST = 0x801E + MSG_ID_TD_ALARM_CLEAR_ALL_ALARMS_REQUEST = 0x801F + MSG_ID_TD_WATCHDOG_OVERRIDE_REQUEST = 0x8020 + MSG_ID_TD_ALARM_STATE_OVERRIDE_REQUEST = 0x8021 + MSG_ID_TD_SAFETY_SHUTDOWN_OVERRIDE_REQUEST = 0x8022 + MSG_ID_TD_PINCH_VALVE_SET_POSITION_REQUEST = 0x8023 + MSG_ID_TD_PINCH_VALVE_HOME_REQUEST = 0x8024 - MSG_ID_DG_TESTER_LOGIN_REQUEST = 0xA000 - MSG_ID_DG_ALARM_STATE_OVERRIDE = 0xA001 - MSG_ID_DG_WATCHDOG_TASK_CHECKIN_OVERRIDE = 0xA002 - MSG_ID_DG_SET_RTC_DATE_TIME = 0xA004 - MSG_ID_LOAD_CELL_OVERRIDE = 0xA005 - MSG_ID_PRESSURE_OVERRIDE = 0xA006 - MSG_ID_PRESSURE_SEND_INTERVAL_OVERRIDE = 0xA007 - MSG_ID_DG_HD_COMMUNICATION_STATUS_OVERRIDE = 0xA008 - MSG_ID_DG_SET_PRIMARY_AND_TRIMMER_HEATERS_TARGET_TEMP = 0xA009 - MSG_ID_RO_PUMP_SEND_INTERVAL_OVERRIDE = 0xA00A - MSG_ID_DRAIN_PUMP_SET_RPM = 0xA00B - MSG_ID_DRAIN_PUMP_SEND_INTERVAL_OVERRIDE = 0xA00C - MSG_ID_LOAD_CELL_SEND_INTERVAL_OVERRIDE = 0xA00D - MSG_ID_VALVE_STATE_OVERRIDE = 0xA00E - MSG_ID_DG_VALVES_STATES_PUBLISH_INTERVAL_OVERRIDE = 0xA00F - MSG_ID_TEMPERATURE_SENSORS_VALUE_OVERRIDE = 0xA010 - MSG_ID_START_STOP_PRIMARY_HEATER = 0xA011 - MSG_ID_TEMPERATURE_SENSORS_PUBLISH_INTERVAL_OVERRIDE = 0xA012 - MSG_ID_HEATERS_PUBLISH_INTERVAL_ORVERRIDE = 0xA013 - MSG_ID_DG_SAFETY_SHUTDOWN_OVERRIDE = 0xA014 - MSG_ID_CONDUCTIVITY_OVERRIDE = 0xA015 - MSG_ID_CONDUCTIVITY_PUBLISH_INTERVAL_OVERRIDE = 0xA016 - MSG_ID_DG_ACCEL_OVERRIDE = 0xA017 - MSG_ID_DG_ACCEL_MAX_OVERRIDE = 0xA018 - MSG_ID_DG_ACCEL_SEND_INTERVAL_OVERRIDE = 0xA019 - MSG_ID_DG_MONITORED_VOLTAGES_SEND_INTERVAL_OVERRIDE = 0xA01A - MSG_ID_DG_MONITORED_VOLTAGES_OVERRIDE = 0xA01B - MSG_ID_DRAIN_PUMP_TARGET_OUTLET_FLOW = 0xA01C - MSG_ID_DG_SWITCHES_STATUS_OVERRIDE = 0xA01D - MSG_ID_DG_SWITCHES_PUBLISH_INTERVAL_OVERRIDE = 0xA01E - MSG_ID_DG_OP_MODE_PUBLISH_INTERVAL_OVERRIDE = 0xA01F - MSG_ID_DG_BLOCK_MESSAGE_TRANSMISSION = 0xA020 - MSG_ID_MEASURED_FLOW_SENSORS_OVERRIDE = 0xA021 - MSG_ID_DG_SOFTWARE_RESET_REQUEST = 0xA022 - MSG_ID_DG_CONCENTRATE_PUMP_MEASURED_SPEED_OVERRIDE = 0xA023 - MSG_ID_CONCENTRATE_PUMP_TARGET_SPEED_OVERRIDE = 0xA024 - MSG_ID_UV_REACTORS_DATA_PUBLISH_INTERVAL_OVERRIDE = 0xA025 - MSG_ID_CONCENTRATE_PUMP_STATE_CHANGE_REQUEST = 0xA026 - MSG_ID_CONCENTRATE_PUMP_PUBLISH_INTERVAL_OVERRIDE = 0xA027 - MSG_ID_DG_START_STOP_UV_REACTORS = 0xA028 - MSG_ID_DG_REQUEST_CALIBRATION_DATA = 0xA029 - MSG_ID_DG_FANS_DATA_PUBLISH_INTERVAL_OVERRIDE = 0xA02A - MSG_ID_DG_UV_REACTORS_HEALTH_OVERRIDE = 0xA02C - MSG_ID_DG_THERMISTORS_DATA_PUBLISH_INTERVAL_OVERRIDE = 0xA02D - MSG_ID_DG_THERMISTORS_VALUE_OVERRIDE = 0xA02E - MSG_ID_DG_RO_PUMP_DUTY_CYCLE_OVERRIDE = 0xA02F - MSG_ID_DG_VALVES_SENSED_STATE_OVERRIDE = 0xA030 - MSG_ID_DG_SET_RO_PUMP_TARGET_FLOW = 0xA031 - MSG_ID_DG_RO_PUMP_TARGET_PRESSURE_OVERRIDE = 0xA032 - MSG_ID_DG_SET_CALIBRATION_RECORD = 0xA033 - MSG_ID_DG_GET_CALIBRATION_RECORD = 0xA034 - MSG_ID_DG_SEND_CALIBRATION_RECORD = 0xA035 - MSG_ID_DG_SET_SYSTEM_RECORD = 0xA036 - MSG_ID_DG_GET_SYSTEM_RECORD = 0xA037 - MSG_ID_DG_SEND_SYSTEM_RECORD = 0xA038 - MSG_ID_DG_GET_SERVICE_RECORD = 0xA039 - MSG_ID_DG_SET_SERVICE_RECORD = 0xA03A - MSG_ID_DG_SEND_SERVICE_RECORD = 0xA03B - MSG_ID_DG_GET_SCHEDULED_RUNS_RECORD = 0xA03C - MSG_ID_DG_SET_SCHEDULED_RUNS_RECORD = 0xA03D - MSG_ID_DG_SEND_SCHEDULED_RUNS_RECORD = 0xA03E - MSG_ID_DG_FLUID_LEAK_SEND_INTERVAL_OVERRIDE = 0xA03F - MSG_ID_DG_FLUID_LEAK_STATE_DETECTOR_OVERRIDE = 0xA040 - MSG_ID_DG_RUN_MODE_FILL_FOR_CAL_CHECK = 0xA041 - MSG_ID_FILTER_FLUSH_TIME_PERIOD_OVERRIDE = 0xA042 - MSG_ID_DG_FANS_RPM_OVERRIDE = 0xA043 - MSG_ID_FLOW_DATA_PUBLISH_INTERVAL_OVERRIDE = 0xA044 - MSG_ID_DG_STOP_RTC_CLOCK = 0xA045 - MSG_ID_DG_DRAIN_PUMP_MEASURED_RPM_OVERRIDE = 0xA046 - MSG_ID_DG_SUPER_CLEAR_ALARMS_CMD = 0xA047 - MSG_ID_DG_ALARM_INFO_SEND_INTERVAL_OVERRIDE = 0xA048 - MSG_ID_DG_START_STOP_TRIMMER_HEATER_CMD = 0xA049 - MSG_ID_DG_GET_SW_CONFIG_RECORD = 0xA04A - MSG_ID_DG_SET_SW_CONFIG_RECORD = 0xA04B - MSG_ID_DG_SEND_SW_CONFIG_RECORD = 0xA04C - MSG_ID_DG_FANS_DUTY_CYCLE_OVERRIDE = 0xA04D - MSG_ID_DG_USED_ACID_VOLUME_ML_OVERRIDE = 0xA04E - MSG_ID_DG_SET_FANS_RPM_ALARM_START_TIME_OFFSET = 0xA04F - MSG_ID_DG_USED_BICARB_VOLUME_ML_OVERRIDE = 0xA050 - MSG_ID_FILL_MODE_DATA_PUBLISH_INTERVAL_OVERRIDE = 0xA051 - MSG_ID_DG_GEN_IDLE_PUBLISH_INTERVAL_OVERRIDE = 0xA052 - MSG_ID_DG_GET_USAGE_INFO_RECORD = 0xA053 - MSG_ID_DG_SET_USAGE_INFO_RECORD = 0xA054 - MSG_ID_DG_SEND_USAGE_INFO_RECORD = 0xA055 - MSG_ID_DG_SET_OP_MODE_REQUEST = 0xA056 - MSG_ID_DG_RESERVOIR_TARE_REQUEST = 0xA057 - MSG_ID_MSG_AVAILABLE_10 = 0xA058 - MSG_ID_DG_DRAIN_PUMP_CURRENT_OVERRIDE = 0xA059 - MSG_ID_DG_DRAIN_PUMP_DIRECTION_OVERRIDE = 0xA05A - MSG_ID_DG_RO_FEEDBACK_VOLTAGE_OVERRIDE = 0xA05B - MSG_ID_DG_DIALYSATE_FILL_INTEGRATED_VOLUME_OVERRIDE = 0xA05C - MSG_ID_DG_NV_RECORD_CRC_OVERRIDE = 0xA05D - MSG_ID_DG_CONC_PUMP_PARK_STATUS_OVERRIDE = 0xA05E - MSG_ID_DG_CONC_PUMP_PARK_FAULT_STATUS_OVERRIDE = 0xA05F - MSG_ID_DG_CONC_PUMP_PARK_COMMAND = 0xA060 - MSG_ID_DG_HEATERS_DUTY_CYCLE_OVERRIDE = 0xA061 - MSD_ID_DG_RTC_CTL_REG1_STATUS_OVERRIDE = 0xA062 - MSD_ID_DG_RTC_CTL_REG3_STATUS_OVERRIDE = 0xA063 - MSG_ID_DG_NELSON_DISINFECT_SUPPORT = 0xA064 - MSG_ID_DG_SET_DIALYSATE_MIXING_RATIOS = 0xA065 - MSG_ID_DG_SET_TEST_CONFIGURATION = 0xA066 - MSG_ID_DG_GET_TEST_CONFIGURATION = 0xA067 - MSG_ID_DG_SEND_TEST_CONFIGURATION = 0xA068 - MSG_ID_DG_RESET_ALL_TEST_CONFIGURATIONS = 0xA069 - MSG_ID_DG_DIALIN_CHECK_IN = 0xA06A - MSG_ID_DG_GET_LOAD_CELLS_TARE_VALUES = 0xA06B - MSG_ID_DG_SET_LOAD_CELLS_TARE_VALUES = 0xA06C - MSG_ID_DG_SEND_LOAD_CELLS_TARE_VALUES = 0xA06D - MSG_ID_DG_SET_COND_SENSOR_CAL_TABLE = 0xA06E - MSG_ID_DG_SIGNAL_RECOVER_FROM_FAULT_MODE = 0xA06F - MSG_ID_DG_DRAIN_MODE_BROADCAST_INTERVAL_OVERRIDE = 0xA070 - MSG_ID_DG_DIALIN_RO_ONLY_MODE_STATUS_REQUEST = 0xA071 - MSG_ID_DG_RAM_STATUS_OVERRIDE = 0xA072 - MSG_ID_DG_CAN_RECEIVE_ACK_MESSAGE_OVERRIDE = 0xA073 - MSG_ID_DG_RESERVOIR_BROADCAST_INTERVAL_OVERRIDE = 0xA074 - MSG_ID_DG_STATE_TIMER_77C_OVERRIDE = 0xA075 - MSG_ID_DG_STATE_TIMER_82C_OVERRIDE = 0xA076 - MSG_ID_DG_CHEM_DISINFECT_ACID_OVERRIDE = 0xA077 - MSG_ID_HD_DEBUG_EVENT = 0xFFF1 - MSG_ID_DG_DEBUG_EVENT = 0xFFF2 - MSG_ID_ACK_MESSAGE_THAT_REQUIRES_ACK = 0xFFFF + MSG_ID_DD_TESTER_LOGIN_REQUEST = 0xA000 + MSG_ID_DD_SOFTWARE_RESET_REQUEST = 0xA001 + MSG_ID_DD_SEND_TEST_CONFIGURATION = 0xA002 + MSG_ID_DD_VALVE_PUBLISH_INTERVAL_OVERRIDE_REQUEST = 0xA003 + MSG_ID_DD_VALVE_STATE_OVERRIDE_REQUEST = 0xA004 + MSG_ID_DD_VALVE_SENSED_STATE_OVERRIDE_REQUEST = 0xA005 + MSG_ID_DD_PRESSURE_SENSOR_READINGS_OVERRIDE_REQUEST = 0xA006 + MSG_ID_DD_PRESSURE_SENSOR_TEMPERATURE_OVERRIDE_REQUEST = 0xA007 + MSG_ID_DD_PRESSURE_SENSOR_READ_COUNTER_OVERRIDE_REQUEST = 0xA008 + MSG_ID_DD_PRESSURE_SENSOR_ERROR_COUNTER_OVERRIDE_REQUEST = 0xA009 + MSG_ID_DD_PRESSURE_SENSOR_PUBLISH_INTERVAL_OVERRIDE_REQUEST = 0xA00A + MSG_ID_DD_PRESSURE_SENSOR_FILTER_READINGS_OVERRIDE_REQUEST = 0xA00B + MSG_ID_DD_PRESSURE_SENSOR_FILTER_TEMPERATURE_OVERRIDE_REQUEST = 0xA00C + MSG_ID_DD_CONDUCTIVITY_SENSOR_READINGS_OVERRIDE_REQUEST = 0xA00D + MSG_ID_DD_CONDUCTIVITY_SENSOR_TEMPERATURE_OVERRIDE_REQUEST = 0xA00E + MSG_ID_DD_CONDUCTIVITY_SENSOR_READ_COUNTER_OVERRIDE_REQUEST = 0xA00F + MSG_ID_DD_CONDUCTIVITY_SENSOR_ERROR_COUNTER_OVERRIDE_REQUEST = 0xA010 + MSG_ID_DD_CONDUCTIVITY_SENSOR_PUBLISH_INTERVAL_OVERRIDE_REQUEST = 0xA011 + MSG_ID_DD_CONCENTRATE_PUMP_PUBLISH_INTERVAL_OVERRIDE_REQUEST = 0xA012 + MSG_ID_DD_CONCENTRATE_PUMP_TARGET_SPEED_OVERRIDE_REQUEST = 0xA013 + MSG_ID_DD_CONCENTRATE_PUMP_MEASURED_SPEED_OVERRIDE_REQUEST = 0xA014 + MSG_ID_DD_CONCENTRATE_PUMP_PARKED_OVERRIDE_REQUEST = 0xA015 + MSG_ID_DD_CONCENTRATE_PUMP_PARK_FAULT_OVERRIDE_REQUEST = 0xA016 + MSG_ID_DD_CONCENTRATE_PUMP_PARK_REQUEST_OVERRIDE_REQUEST = 0xA017 + MSG_ID_DD_TEMPERATURE_SENSOR_PUBLISH_INTERVAL_OVERRIDE_REQUEST = 0xA018 + MSG_ID_DD_TEMPERATURE_SENSOR_MEASURED_TEMPERATURE_OVERRIDE_REQUEST = 0xA019 + MSG_ID_DD_TEMPERATURE_SENSOR_READ_COUNTER_OVERRIDE_REQUEST = 0xA01A + MSG_ID_DD_TEMPERATURE_SENSOR_BARO_READ_COUNTER_OVERRIDE_REQUEST = 0xA01B + MSG_ID_DD_TEMPERATURE_SENSOR_BARO_CRC_OVERRIDE_REQUEST = 0xA01C + MSG_ID_DD_DIALYSATE_PUMPS_PUBLISH_INTERVAL_OVERRIDE_REQUEST = 0xA01D + MSG_ID_DD_DIALYSATE_PUMPS_TARGET_SPEED_OVERRIDE_REQUEST = 0xA01E + MSG_ID_DD_DIALYSATE_PUMPS_MEASURED_SPEED_OVERRIDE_REQUEST = 0xA01F + MSG_ID_DD_DIALYSATE_PUMPS_TARGET_PRESSURE_OVERRIDE_REQUEST = 0xA020 + MSG_ID_DD_DIALYSATE_PUMPS_MEASURED_CURRENT_OVERRIDE_REQUEST = 0xA021 + MSG_ID_DD_DIALYSATE_PUMPS_MEASURED_DIRECTION_OVERRIDE_REQUEST = 0xA022 + MSG_ID_DD_HEATERS_PUBLISH_INTERVAL_OVERRIDE_REQUEST = 0xA023 + MSG_ID_DD_HEATERS_DUTY_CYCLE_OVERRIDE_REQUEST = 0xA024 + MSG_ID_DD_LEVELS_PUBLISH_INTERVAL_OVERRIDE_REQUEST = 0xA025 + MSG_ID_DD_LEVELS_STATUS_OVERRIDE_REQUEST = 0xA026 + + MSG_ID_TD_DEBUG_EVENT = 0xFFF1 + MSG_ID_DD_DEBUG_EVENT = 0xFFF2 + + MSG_ID_ACK_MESSAGE_THAT_REQUIRES_ACK = 0xFFFF Fisheye: Tag 12b82879196778f6c83d08751652177ea0fcbf5e refers to a dead (removed) revision in file `leahi-dialin/common/prs_defs.py'. Fisheye: No comparison available. Pass `N' to diff? Index: leahi-dialin/common/td_defs.py =================================================================== diff -u --- leahi-dialin/common/td_defs.py (revision 0) +++ leahi-dialin/common/td_defs.py (revision 12b82879196778f6c83d08751652177ea0fcbf5e) @@ -0,0 +1,433 @@ +########################################################################### +# +# Copyright (c) 2020-2024 Diality Inc. - All Rights Reserved. +# +# THIS CODE MAY NOT BE COPIED OR REPRODUCED IN ANY FORM, IN PART OR IN +# WHOLE, WITHOUT THE EXPLICIT PERMISSION OF THE COPYRIGHT OWNER. +# +# @file td_defs.py +# +# @author (last) Vinayakam Mani +# @date (last) 10-May-2024 +# @author (original) Peter Lucia +# @date (original) 04-Dec-2020 +# +############################################################################ +from enum import unique +from ..utils.base import DialinEnum + + +@unique +class TDOpModes(DialinEnum): + MODE_FAUL = 0 # Fault mode + MODE_SERV = 1 # Service mode + MODE_INIT = 2 # Initialization & POST mode + MODE_STAN = 3 # Standby mode + MODE_TPAR = 4 # Treatment Parameters mode + MODE_PRET = 5 # Pre-Treatment mode + MODE_TREA = 6 # Treatment mode + MODE_POST = 7 # Post-Treatment mode + MODE_NLEG = 8 # Not legal - an illegal mode transition occurred + NUM_OF_MODES = 9 # Number of HD operation modes + + +@unique +class HDStandbyStates(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). + +@unique +class HDInitStates(DialinEnum): + POST_STATE_START = 0 # Start initialize & POST mode state + POST_STATE_FW_INTEGRITY = 1 # Run firmware integrity test state + POST_STATE_RTC = 2 # Run RTC test state + POST_STATE_NVDATAMGMT = 3 # Run NV Data Mgmt. test state + POST_STATE_WATCHDOG = 4 # Run watchdog test state + POST_STATE_SAFETY_SHUTDOWN = 5 # Run safety shutdown test state + POST_STATE_BLOOD_FLOW = 6 # Run blood flow test state + POST_STATE_DIALYSATE_INLET_FLOW = 7 # Run dialysate inlet flow test state + POST_STATE_DIALYSATE_OUTLET_FLOW = 8 # Run dialysate outlet flow test state + POST_STATE_BLOOD_LEAK = 9 # Run blood leak sensor test state + POST_STATE_VALVES = 10 # Run valves test state + POST_STATE_SYRINGE_PUMP = 11 # Run syringe pump test state + POST_STATE_PRES_OCCL = 12 # Run pressure occlusion state + POST_STATE_ALARM_AUDIO = 13 # Run alarm audio test state + POST_STATE_ALARM_LAMP = 14 # Run alarm lamp test state + POST_STATE_ACCELEROMETER = 15 # Run Accelerometer test state + POST_STATE_TEMPERATURES = 16 # Run temperatures POST state + POST_STATE_FANS = 17 # Run fans POST state + POST_STATE_STUCK_BUTTON = 18 # Run stuck button test state + POST_STATE_UI_POST = 19 # Check whether UI passed its POST tests + POST_STATE_FW_COMPATIBILITY = 20 # Run firmware compatibility test state + POST_STATE_FPGA = 21 # Run FPGA test state + POST_STATE_COMPLETED = 22 # POST self-tests completed state + POST_STATE_FAILED = 23 # POST self-tests failed state + NUM_OF_POST_STATES = 24 # Number of initialize & POST mode states + +@unique +class PreTreatmentSubModes(DialinEnum): + HD_PRE_TREATMENT_WATER_SAMPLE_STATE = 0 # Water sample state + HD_PRE_TREATMENT_SELF_TEST_CONSUMABLE_STATE = 1 # Consumable self-tests state + HD_PRE_TREATMENT_SELF_TEST_NO_CART_STATE = 2 # No cartridge self-tests state + HD_PRE_TREATMENT_CART_INSTALL_STATE = 3 # Consumable and cartridge installation state + HD_PRE_TREATMENT_SELF_TEST_DRY_STATE = 4 # Self-tests when the cartridge is dry state + HD_PRE_TREATMENT_PRIME_STATE = 5 # Prime blood and dialysate circuits and run wet self-tests state + HD_PRE_TREATMENT_RECIRCULATE_STATE = 6 # Re-circulate blood and dialysate circuits state + HD_PRE_TREATMENT_PATIENT_CONNECTION_STATE = 7 # Patient connection state + NUM_OF_HD_PRE_TREATMENT_STATES = 8 # Number of pre-treatment mode states + + +@unique +class PreTreatmentSampleWaterStates(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 sample water sub-mode states + + +@unique +class PreTreatmentConsumableSelfTestStates(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 + + +@unique +class PreTreatmentNoCartSelfTestStates(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 + + +@unique +class PreTreatmentWetSelfTestStates(DialinEnum): + WET_SELF_TESTS_START_STATE = 0 + WET_SELF_TESTS_BUBBLE_CHECK_SETUP_STATE = 1 + WET_SELF_TESTS_BUBBLE_CHECK_STATE = 2 + WET_SELF_TESTS_PRIME_CHECK_STATE = 3 + WET_SELF_TESTS_BLOOD_LEAK_DETECTOR_DEBUBBLE_STATE = 4 + WET_SELF_TESTS_BLOOD_LEAK_DETECTOR_STATE = 5 + WET_SELF_TESTS_FIRST_DISPLACEMENT_SETUP_STATE = 6 + WET_SELF_TESTS_FIRST_DISPLACEMENT_STATE = 7 + WET_SELF_TESTS_FIRST_DISPLACEMENT_VERIFY_STATE = 8 + WET_SELF_TESTS_SECOND_DISPLACEMENT_SETUP_STATE = 9 + WET_SELF_TESTS_SECOND_DISPLACEMENT_STATE = 10 + WET_SELF_TESTS_SECOND_DISPLACEMENT_VERIFY_STATE = 11 + WET_SELF_TESTS_STOPPED_STATE = 12 + WET_SELF_TESTS_COMPLETE_STATE = 13 + +@unique +class HDPreTreatmentReservoirMgmtStates(DialinEnum): + PRE_TREATMENT_RESERVOIR_MGMT_START_STATE = 0 # Wait for signal to start drain and fill reservoirs + PRE_TREATMENT_RESERVOIR_MGMT_DRAIN_CMD_STATE = 1 # Command DG to start draining reservoir + PRE_TREATMENT_RESERVOIR_MGMT_DRAIN_CMD_RESP_STATE = 2 # After sending drain command, process DG drain command response + PRE_TREATMENT_RESERVOIR_MGMT_START_FILL_STATE = 3 # Command DG to start filling reservoir + PRE_TREATMENT_RESERVOIR_MGMT_FILL_CMD_RESP_STATE = 4 # After sending fill command, process DG fill command response + PRE_TREATMENT_RESERVOIR_MGMT_FILL_COMPLETE_STATE = 5 # Reservoir fill has completed + PRE_TREATMENT_RESERVOIR_MGMT_REQUEST_RESERVOIR_SWITCH_STATE = 6 # Command DG to switch (toggle) reservoirs + PRE_TREATMENT_RESERVOIR_MGMT_WAIT_FOR_RESERVOIR_SWITCH_STATE = 7 # After sending switch command, process DG fill command response + PRE_TREATMENT_RESERVOIR_MGMT_COMPLETE_STATE = 8 # Pre-treatment reservoir management complete state + NUM_OF_PRE_TREATMENT_RESERVOIR_MGMT_STATES = 9 # Number of pre-treatments reservoir mgmt. states + +# Heparin states +@unique +class HeparinStates(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 + + +# Syringe pump states +@unique +class SyringePumpStates(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 + + +# Syringe pump operations +@unique +class SyringePumpOperations(DialinEnum): + SYRINGE_PUMP_OP_STOP = 0 # Stop syringe pump + SYRINGE_PUMP_OP_RETRACT = 1 # Retract syringe pump + SYRINGE_PUMP_OP_SEEK = 2 # Seek plunger + SYRINGE_PUMP_OP_PRIME = 3 # Prime Heparin line + SYRINGE_PUMP_OP_BOLUS = 4 # Deliver Heparin bolus of set volume over 5 minutes + SYRINGE_PUMP_OP_CONTINUOUS = 5 # Continuous dispense of Heparin at set rate + + +@unique +class PostTreatmentStates(DialinEnum): + HD_POST_TREATMENT_DRAIN_RESERVOIRS_STATE = 0 # Drain reservoirs state + HD_POST_TREATMENT_PATIENT_DISCONNECTION_STATE = 1 # Patient disconnection state + HD_POST_TREATMENT_DISPOSABLE_REMOVAL_STATE = 2 # Disposable removal state + HD_POST_TREATMENT_VERIFY_STATE = 3 # Verify cartridge removed, syringe removed, and reservoirs drained state + NUM_OF_HD_POST_TREATMENT_STATES = 4 # Number of post-treatment mode states + + +@unique +class PreTreatmentCartridgeInstallStates(DialinEnum): + CARTRIDGE_INSTALL_STATE = 0 # Pre-treatment Cartridge Install state. + NUM_OF_CARTRIDGE_INSTALL_STATES = 1 # Number of pre-treatment Cartridge Install states. + + +@unique +class PreTreatmentDrySelfTestsStates(DialinEnum): + """ + The HD Pre-Treatment dry self test states + """ + DRY_SELF_TESTS_START_STATE = 0 # Dry self-tests starting state + DRY_SELF_TESTS_WAIT_FOR_DOOR_CLOSE_STATE = 1 # Wait for door to close before executing self-tests + DRY_SELF_TESTS_USED_CARTRIDGE_CHECK_STATE = 2 # Used cartridge check dry self-test state + DRY_SELF_TESTS_CARTRIDGE_LOADED_CHECK_STATE = 3 # Cartridge loaded check dry self-test state + DRY_SELF_TESTS_SYRINGE_PUMP_SEEK_STATE = 4 # Seek syringe pumps state + DRY_SELF_TESTS_PRESSURE_SENSORS_NORMAL_SETUP_STATE = 5 # Pressure sensor setup state. + DRY_SELF_TESTS_PRESSURE_SENSORS_VENOUS_SETUP_STATE = 6 # Venous pressure sensor dry self-test setup valves and pump state + DRY_SELF_TESTS_PRESSURE_SENSORS_VENOUS = 7 # Venous pressure sensor dry self-test + DRY_SELF_TESTS_PRESSURE_SENSORS_ARTERIAL_SETUP_STATE = 8 # Arterial pressure sensor dry self-test setup valves and pump state + DRY_SELF_TESTS_PRESSURE_SENSORS_ARTERIAL = 9 # Arterial pressure sensor dry self-test + DRY_SELF_TESTS_PRESSURE_SENSORS_DECAY_STATE = 10 # Pressure sensors verify pressure loss state + DRY_SELF_TESTS_PRESSURE_SENSORS_STABILITY_STATE = 11 # Pressure sensors verify pressure stability state + DRY_SELF_TESTS_PRESSURE_SENSORS_NORMAL_STATE = 12 # Pressure sensors verify normal pressure readings state + DRY_SELF_TESTS_SYRINGE_PUMP_PRIME_STATE = 13 # Prime syringe pump state + DRY_SELF_TESTS_SYRINGE_PUMP_OCCLUSION_DETECTION_STATE = 14 # Occlusion detection state + DRY_SELF_TESTS_STOPPED_STATE = 15 # Dry self-test stopped state + DRY_SELF_TESTS_COMPLETE_STATE = 16 # Dry self-test complete state + NUM_OF_DRY_SELF_TESTS_STATES = 17 # Number of dry self-tests states + + +@unique +class PreTreatmentPrimeStates(DialinEnum): + HD_PRIME_WAIT_FOR_USER_START_STATE = 0 # Wait for user to start prime state + HD_PRIME_SALINE_SETUP_STATE = 1 # Saline setup state + HD_PRIME_SALINE_PURGE_AIR_STATE = 2 # Saline purge air state + HD_PRIME_SALINE_CIRC_BLOOD_CIRCUIT_STATE = 3 # Circulate blood circuit state + HD_PRIME_RESERVOIR_ONE_FILL_COMPLETE_STATE = 4 # Wait for reservoir 1 fill complete + HD_PRIME_DIALYSATE_DIALYZER_STATE = 5 # Dialysate dialyzer fluid path state + HD_PRIME_SALINE_DIALYZER_SETUP_STATE = 6 # Saline dialyzer setup state + HD_PRIME_SALINE_DIALYZER_STATE = 7 # Saline dialyzer fluid path state + HD_PRIME_RESERVOIR_TWO_FILL_COMPLETE_STATE = 8 # Wait for reservoir 2 fill complete + HD_PRIME_DIALYSATE_BYPASS_STATE = 9 # Dialysate bypass fluid path state + HD_PRIME_WET_SELF_TESTS_STATE = 10 # Perform wet self-tests after priming complete + HD_PRIME_PAUSE = 11 # Prime pause state, waits to be resumed + HD_PRIME_COMPLETE = 12 # Prime complete state + NUM_OF_HD_PRIME_STATES = 13 # Number of prime sub-mode states + + +@unique +class PreTreatmentRecircStates(DialinEnum): + PRE_TREATMENT_RECIRC_STATE = 0 # Pre-treatment recirculate state + PRE_TREATMENT_RECIRC_STOPPED_STATE = 1 # Pre-treatment recirculate stopped state + NUM_OF_PRE_TREATMENT_RECIRC_STATES = 2 # Number of pre-treatment recirculate states + + +@unique +class TreatmentRecircStates(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 + + +@unique +class PreTreatmentPatientConnectionStates(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 + + +@unique +class TreatmentParametersStates(DialinEnum): + HD_TREATMENT_PARAMS_MODE_STATE_WAIT_4_UI_2_SEND = 0 # Wait for UI to send treatment params mode state + HD_TREATMENT_PARAMS_MODE_STATE_WAIT_4_UI_2_CONFIRM = 1 # Wait for UI to confirm treatment params mode state + NUM_OF_HD_TREATMENT_PARAMS_MODE_STATES = 2 # Number of treatment params mode states + + +@unique +class TreatmentStates(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 Heparin as prescribed. Deliver UF as prescribed. Handle saline boluses as requested + TREATMENT_STOP_STATE = 3 # Treatment stopped. 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 + NUM_OF_TREATMENT_STATES = 7 # Number of treatment states (sub-modes) + +@unique +class TreatmentBloodPrimeStates(DialinEnum): + BLOOD_PRIME_RAMP_STATE = 0 # Ramp state of the blood prime sub-mode state machine + NUM_OF_BLOOD_PRIME_STATES = 1 # Number of blood prime sub-mode states + +@unique +class TreatmentDialysisStates(DialinEnum): + DIALYSIS_START_STATE = 0 # Start state of dialysis sub-mode state machine + DIALYSIS_UF_STATE = 1 # Ultrafiltration state of the dialysis sub-mode state machine + DIALYSIS_SALINE_BOLUS_STATE = 2 # Saline bolus state of the dialysis sub-mode state machine + NUM_OF_DIALYSIS_STATES = 3 # Number of dialysis sub-mode states + +@unique +class TreatmentStopStates(DialinEnum): + TREATMENT_STOP_RECIRC_STATE = 0 # Dialysate and Blood re-circulation state of the treatment stop sub-mode state machine + TREATMENT_STOP_RECIRC_DIALYSATE_ONLY_STATE = 1 # Re-circulate Dialysate only state of the treatment re-circulate sub-mode state machine + TREATMENT_STOP_RECIRC_BLOOD_ONLY_STATE = 2 # Re-circulate Blood only state of the treatment re-circulate sub-mode state machine + TREATMENT_STOP_NO_RECIRC_STATE = 3 # No re-circulation state of the treatment stop sub-mode state machine + NUM_OF_TREATMENT_STOP_STATES = 4 # Number of treatment stop sub-mode states + +@unique +class TreatmentRinsebackStates(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 reconnect patient state of the rinseback sub-mode state machine + NUM_OF_RINSEBACK_STATES = 6 # Number of rinseback sub-mode states + +@unique +class TreatmentRecircStates(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 + +@unique +class TreatmentEndStates(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 + +@unique +class HDFaultStates(DialinEnum): + HD_FAULT_STATE_START = 0 # Start fault state + HD_FAULT_STATE_RUN_NV_POSTS = 1 # HD fault run NV posts state + HD_FAULT_STATE_COMPLETE = 2 # HD fault run complete state + NUM_OF_HD_FAULT_STATES = 3 # Number of fault mode states + +@unique +class HDEventList(DialinEnum): + HD_EVENT_STARTUP = 0 # HD startup event + HD_EVENT_OP_MODE_CHANGE = 1 # HD Op mode change event + HD_EVENT_SUB_MODE_CHANGE = 2 # HD Op sub-mode change event + HD_EVENT_DRY_SELF_TEST_CARTRIDGE_RESULT = 3 # HD dry self test cartridge result + HD_EVENT_DRY_SELF_TEST_PRESSURE_RESULT = 4 # HD dry self test pressure result + HD_EVENT_WET_SELF_TEST_DISPLACEMENT_RESULT = 5 # HD wet self test displacement result + HD_EVENT_CPU_RAM_ERROR_STATUS = 6 # HD CPU RAM error status + HD_EVENT_CAL_RECORD_UPDATE = 7 # HD new calibration record updated + HD_EVENT_SYSTEM_RECORD_UPDATE = 8 # HD new system record has been updated + HD_EVENT_SERVICE_UPDATE = 9 # HD new service record has been updated + HD_EVENT_USAGE_INFO_UPDATE = 10 # HD new usage information has been updated + HD_EVENT_SW_CONFIG_UPDATE = 11 # HD new software configuration has been updated + HD_EVENT_BUTTON = 12 # HD button pressed/released + HD_EVENT_SAFETY_LINE = 13 # HD safety line pulled/released + HD_EVENT_RSRVR_1_LOAD_CELL_START_VALUES = 14 # HD reservoir 1 load cells start values + HD_EVENT_RSRVR_1_LOAD_CELL_END_VALUES = 15 # HD reservoir 2 load cells end values + HD_EVENT_RSRVR_2_LOAD_CELL_START_VALUES = 16 # HD reservoir 2 load cells start values + HD_EVENT_RSRVR_2_LOAD_CELL_END_VALUES = 17 # HD reservoir 2 load cells end values + HD_EVENT_SUB_STATE_CHANGE = 18 # HD Op sub-state change event + HD_EVENT_SYRINGE_PUMP_STATE = 19 # HD syringe pump state change event + HD_EVENT_OCCLUSION_BASELINE = 20 # HD event occlusion baseline event + HD_EVENT_RSRVR_UF_VOLUME_AND_TIME = 21 # HD ultrafiltration volume and time for a reservoir use + HD_EVENT_RSRVR_UF_RATE = 22 # HD ultrafiltration measured and expected rates + HD_EVENT_OPERATION_STATUS = 23 # HD operation status event. + HD_EVENT_AIR_TRAP_FILL = 24 # HD initiated an air trap fill (opened VBT briefly). + HD_EVENT_AIR_PUMP_ON_OFF = 25 # HD turned air pump on or off. + HD_EVENT_BLOOD_LEAK_SELF_TEST_RESULT = 26 # HD Blood leak self test result. + HD_EVENT_BLOOD_LEAK_NUM_OF_SET_POINT_CHECK_FAILURES = 27 # HD blood leak number of setpoint check failures + HD_EVENT_DRY_SELF_TEST_PRESSURE_DECAY_WAIT_PERIOD = 28 # HD dry self test pressure decay wait period + HD_EVENT_INSTIT_RECORD_UPDATE = 29 # HD new institutional record has been updated. + HD_EVENT_PARTIAL_OCCLUSION_BASELINE = 30 # HD event partial occlusion baseline event + NUM_OF_EVENT_IDS = 31 # Total number of HD events + +@unique +class HDEventDataType(DialinEnum): + EVENT_DATA_TYPE_NONE = 0 + EVENT_DATA_TYPE_U32 = 1 + EVENT_DATA_TYPE_S32 = 2 + EVENT_DATA_TYPE_F32 = 3 + EVENT_DATA_TYPE_BOOL = 4 + NUM_OF_EVENT_DATA_TYPES = 5 + +@unique +class UFStates(DialinEnum): + UF_PAUSED_STATE = 0 # Paused state of the ultrafiltration state machine + UF_RUNNING_STATE = 1 # Running state of the ultrafiltration state machine + NUM_OF_UF_STATES = 2 # Number of ultrafiltration states + +@unique +class SalineBolusStates(DialinEnum): + SALINE_BOLUS_STATE_IDLE = 0 # No saline bolus delivery is in progress + SALINE_BOLUS_STATE_WAIT_FOR_PUMPS_STOP = 1 # Wait for pumps to stop before starting bolus + SALINE_BOLUS_STATE_IN_PROGRESS = 2 # A saline bolus delivery is in progress + SALINE_BOLUS_STATE_MAX_DELIVERED = 3 # Maximum saline bolus volume reached - no more saline bolus deliveries allowed + NUM_OF_SALINE_BOLUS_STATES = 4 # Number of saline bolus states + +@unique +class TreatmentParameters(DialinEnum): + TREATMENT_PARAM_BLOOD_FLOW_RATE_ML_MIN = 0 + TREATMENT_PARAM_DIALYSATE_FLOW_RATE_ML_MIN = 1 + TREATMENT_PARAM_TREATMENT_DURATION_MIN = 2 + TREATMENT_PARAM_HEPARIN_PRESTOP_MIN = 3 + TREATMENT_PARAM_SALINE_BOLUS_VOLUME_ML = 4 + TREATMENT_PARAM_ACID_CONCENTRATE = 5 + TREATMENT_PARAM_BICARB_CONCENTRATE = 6 + TREATMENT_PARAM_DIALYZER_TYPE = 7 + TREATMENT_PARAM_HEPARIN_TYPE = 8 + TREATMENT_PARAM_BLOOD_PRESSURE_MEAS_INTERVAL_MIN = 9 + TREATMENT_PARAM_RINSEBACK_FLOW_RATE_ML_MIN = 10 + TREATMENT_PARAM_ART_PRES_LIMIT_WINDOW = 11 + TREATMENT_PARAM_VEN_PRES_LIMIT_WINDOW = 12 + TREATMENT_PARAM_VEN_PRES_LIMIT_ASYMMETRIC = 13 + TREATMENT_PARAM_HEPARIN_DISPENSE_RATE_ML_HR = 14 + TREATMENT_PARAM_HEPARIN_BOLUS_VOLUME_ML = 15 + TREATMENT_PARAM_DIALYSATE_TEMPERATURE_C = 16 + TREATMENT_PARAM_UF_VOLUME_L = 17 + NUM_OF_TREATMENT_PARAMS = 18 + +class Acid_Concentrates(DialinEnum): + ACID_CONC_TYPE_FRESENIUS_08_1251_1 = 0 + ACID_CONC_TYPE_FRESENIUS_08_2251_0 = 1 + ACID_CONC_TYPE_FRESENIUS_08_3251_9 = 2 + NUM_OF_ACID_CONC_TYPES = 3 + +class Bicarb_Concentrates(DialinEnum): + BICARB_CONC_TYPE_FRESENIUS_CENTRISOL = 0 + NUM_OF_BICARB_CONC_TYPES = 1 + +@unique +class PowerOffCommands(DialinEnum): + """ + power off commands enum + """ + PW_COMMAND_OPEN = 0 + PW_TIMEOUT_CLOSE = 1 + PW_REJECT_SHOW = 2 Index: leahi-dialin/dd/__init__.py =================================================================== diff -u --- leahi-dialin/dd/__init__.py (revision 0) +++ leahi-dialin/dd/__init__.py (revision 12b82879196778f6c83d08751652177ea0fcbf5e) @@ -0,0 +1 @@ \ No newline at end of file Index: leahi-dialin/dd/conductivity_sensors.py =================================================================== diff -u --- leahi-dialin/dd/conductivity_sensors.py (revision 0) +++ leahi-dialin/dd/conductivity_sensors.py (revision 12b82879196778f6c83d08751652177ea0fcbf5e) @@ -0,0 +1 @@ \ No newline at end of file Index: leahi-dialin/dd/dialysate_delivery.py =================================================================== diff -u --- leahi-dialin/dd/dialysate_delivery.py (revision 0) +++ leahi-dialin/dd/dialysate_delivery.py (revision 12b82879196778f6c83d08751652177ea0fcbf5e) @@ -0,0 +1 @@ \ No newline at end of file Index: leahi-dialin/dd/pressure_sensors.py =================================================================== diff -u --- leahi-dialin/dd/pressure_sensors.py (revision 0) +++ leahi-dialin/dd/pressure_sensors.py (revision 12b82879196778f6c83d08751652177ea0fcbf5e) @@ -0,0 +1 @@ \ No newline at end of file Index: leahi-dialin/dd/td_proxy.py =================================================================== diff -u --- leahi-dialin/dd/td_proxy.py (revision 0) +++ leahi-dialin/dd/td_proxy.py (revision 12b82879196778f6c83d08751652177ea0fcbf5e) @@ -0,0 +1 @@ \ No newline at end of file Index: leahi-dialin/dd/valves.py =================================================================== diff -u --- leahi-dialin/dd/valves.py (revision 0) +++ leahi-dialin/dd/valves.py (revision 12b82879196778f6c83d08751652177ea0fcbf5e) @@ -0,0 +1 @@ \ No newline at end of file Index: leahi-dialin/ro/__init__.py =================================================================== diff -u --- leahi-dialin/ro/__init__.py (revision 0) +++ leahi-dialin/ro/__init__.py (revision 12b82879196778f6c83d08751652177ea0fcbf5e) @@ -0,0 +1 @@ \ No newline at end of file Index: leahi-dialin/ro/reverse_osmosis.py =================================================================== diff -u --- leahi-dialin/ro/reverse_osmosis.py (revision 0) +++ leahi-dialin/ro/reverse_osmosis.py (revision 12b82879196778f6c83d08751652177ea0fcbf5e) @@ -0,0 +1 @@ \ No newline at end of file Index: leahi-dialin/td/__init__.py =================================================================== diff -u --- leahi-dialin/td/__init__.py (revision 0) +++ leahi-dialin/td/__init__.py (revision 12b82879196778f6c83d08751652177ea0fcbf5e) @@ -0,0 +1 @@ \ No newline at end of file Index: leahi-dialin/td/air_pump.py =================================================================== diff -u --- leahi-dialin/td/air_pump.py (revision 0) +++ leahi-dialin/td/air_pump.py (revision 12b82879196778f6c83d08751652177ea0fcbf5e) @@ -0,0 +1,140 @@ +########################################################################### +# +# Copyright (c) 2022-2024 Diality Inc. - All Rights Reserved. +# +# THIS CODE MAY NOT BE COPIED OR REPRODUCED IN ANY FORM, IN PART OR IN +# WHOLE, WITHOUT THE EXPLICIT PERMISSION OF THE COPYRIGHT OWNER. +# +# @file air_pump.py +# +# @author (last) Micahel Garthwaite +# @date (last) 10-Mar-2023 +# @author (original) Micahel Garthwaite +# @date (original) 01-Nov-2024 +# +############################################################################ + +import struct +from logging import Logger + +from .constants import RESET, NO_RESET +from ..common.msg_defs import MsgIds, MsgFieldPositions +from ..protocols.CAN import DenaliMessage, DenaliChannels +from ..utils.base import AbstractSubSystem, publish +from ..utils.checks import check_broadcast_interval_override_ms +from ..utils.conversions import integer_to_bytearray + + +class TDAirPump(AbstractSubSystem): + """ + TDAirPump + + Treatment Delivery (TD) Dialin API sub-class for air pump related commands. + """ + + def __init__(self, can_interface, logger: Logger): + """ + + @param can_interface: Denali Can Messenger object + """ + super().__init__() + self.can_interface = can_interface + self.logger = logger + + if self.can_interface is not None: + channel_id = DenaliChannels.td_sync_broadcast_ch_id + msg_id = MsgIds.MSG_ID_TD_AIR_PUMP_DATA.value + self.can_interface.register_receiving_publication_function(channel_id, msg_id, + self._handler_air_pump_sync) + + self.air_pump_state = 0 + self.td_air_pump_timestamp = 0.0 + + @publish(["td_air_pump_timestamp", "air_pump_state"]) + def _handler_air_pump_sync(self, message, timestamp=0.0): + """ + Handles published air pump data messages. + + @param message: published air pump data message as: air pump state + @return: None + """ + aps = struct.unpack('i', bytearray( + message['message'][MsgFieldPositions.START_POS_FIELD_1:MsgFieldPositions.END_POS_FIELD_1])) + + self.air_pump_state = aps[0] + self.td_air_pump_timestamp = timestamp + + def cmd_air_pump_set_state(self, state: int) -> int: + """ + Constructs and sends the air pump set state command. + AIR_PUMP_STATE_INIT = 0, ///< Air Pump Initialize state + AIR_PUMP_STATE_OFF, ///< Air Pump Off state + AIR_PUMP_STATE_ON, ///< Air Pump On state + NUM_OF_AIR_PUMP_STATES, ///< Number of air pump states + + Constraints: + Must be logged into TD. + + """ + + idx = integer_to_bytearray(state) + payload = idx + + message = DenaliMessage.build_message(channel_id=DenaliChannels.dialin_to_td_ch_id, + message_id=MsgIds.MSG_ID_TD_AIR_PUMP_SET_STATE_REQUEST.value, + payload=payload) + + self.logger.debug("setting air pump state to" + str(state)) + + # Send message + received_message = self.can_interface.send(message) + + # If there is content... + if received_message is not None: + # response payload is OK or not OK + return received_message['message'][DenaliMessage.PAYLOAD_START_INDEX] + else: + self.logger.debug("Timeout!!!!") + return False + + def cmd_air_pump_data_broadcast_interval_override(self, ms: int, reset: int = NO_RESET) -> int: + """ + Constructs and sends the air pump data broadcast interval override command + Constraints: + Must be logged into TD. + Given interval must be non-zero and a multiple of the TD general task interval (50 ms). + + @param ms: integer - interval (in ms) to override with + @param reset: integer - 1 to reset a previous override, 0 to override + @return: 1 if successful, zero otherwise + """ + + if not check_broadcast_interval_override_ms(ms): + return False + + rst = integer_to_bytearray(reset) + mis = integer_to_bytearray(ms) + payload = rst + mis + + message = DenaliMessage.build_message(channel_id=DenaliChannels.dialin_to_td_ch_id, + message_id=MsgIds.MSG_ID_TD_AIR_PUMP_PUBLISH_INTERVAL_OVERRIDE_REQUEST.value, + payload=payload) + + self.logger.debug("override TD air pump data broadcast interval") + + # Send message + received_message = self.can_interface.send(message) + + # If there is content... + if received_message is not None: + if reset == RESET: + str_res = "reset back to normal: " + else: + str_res = str(ms) + " ms: " + self.logger.debug("Air pump data broadcast interval overridden to " + str_res + + str(received_message['message'][DenaliMessage.PAYLOAD_START_INDEX])) + # response payload is OK or not OK + return received_message['message'][DenaliMessage.PAYLOAD_START_INDEX] + else: + self.logger.debug("Timeout!!!!") + return False Index: leahi-dialin/td/alarms.py =================================================================== diff -u --- leahi-dialin/td/alarms.py (revision 0) +++ leahi-dialin/td/alarms.py (revision 12b82879196778f6c83d08751652177ea0fcbf5e) @@ -0,0 +1,1020 @@ +########################################################################### +# +# Copyright (c) 2020-2024 Diality Inc. - All Rights Reserved. +# +# THIS CODE MAY NOT BE COPIED OR REPRODUCED IN ANY FORM, IN PART OR IN +# WHOLE, WITHOUT THE EXPLICIT PERMISSION OF THE COPYRIGHT OWNER. +# +# @file alarms.py +# +# @author (last) Michael Garthwaite +# @date (last) 04-Oct-2023 +# @author (original) Peter Lucia +# @date (original) 02-Apr-2020 +# +############################################################################ +import struct +from logging import Logger +from enum import unique +from ..utils.base import DialinEnum + +from .constants import RESET, NO_RESET +from ..common.msg_defs import MsgIds, MsgFieldPositions +from ..common.td_defs import HDEventDataType +from ..protocols.CAN import DenaliMessage, DenaliChannels +from ..utils.base import AbstractSubSystem, publish +from ..utils.checks import check_broadcast_interval_override_ms +from ..utils.conversions import integer_to_bytearray, float_to_bytearray + + +class HDAlarms(AbstractSubSystem): + """ + HD interface containing alarm related commands. + """ + + # Alarm lamp patterns + HD_ALARM_LAMP_PATTERN_OFF = 0 + HD_ALARM_LAMP_PATTERN_OK = 1 + HD_ALARM_LAMP_PATTERN_FAULT = 2 + HD_ALARM_LAMP_PATTERN_HIGH = 3 + HD_ALARM_LAMP_PATTERN_MEDIUM = 4 + HD_ALARM_LAMP_PATTERN_LOW = 5 + HD_ALARM_LAMP_PATTERN_MANUAL = 6 + + # Alarm priority states + HD_ALARM_STATE_NONE = 0 + HD_ALARM_STATE_LOW = 1 + HD_ALARM_STATE_MEDIUM = 2 + HD_ALARM_STATE_HIGH = 3 + + # Alarm response buttons + @unique + class AlarmResponseButtons(DialinEnum): + HD_ALARM_RESPONSE_BUTTON_RESUME = 0 + HD_ALARM_RESPONSE_BUTTON_RINSEBACK = 1 + HD_ALARM_RESPONSE_BUTTON_END_TREATMENT = 2 + NUM_OF_HD_ALARM_RESPONSE_BUTTONS = 3 + + # Alarm status message field positions + START_POS_ALARM_STATE = DenaliMessage.PAYLOAD_START_INDEX + END_POS_ALARM_STATE = START_POS_ALARM_STATE + 4 + START_POS_ALARM_TOP = END_POS_ALARM_STATE + END_POS_ALARM_TOP = START_POS_ALARM_TOP + 4 + START_POS_ALARM_ESCALATES_IN = END_POS_ALARM_TOP + END_POS_ALARM_ESCALATES_IN = START_POS_ALARM_ESCALATES_IN + 4 + START_POS_ALARM_SILENCE_EXPIRES_IN = END_POS_ALARM_ESCALATES_IN + END_POS_ALARM_SILENCE_EXPIRES_IN = START_POS_ALARM_SILENCE_EXPIRES_IN + 4 + START_POS_ALARMS_FLAGS = END_POS_ALARM_SILENCE_EXPIRES_IN + END_POS_ALARMS_FLAGS = START_POS_ALARMS_FLAGS + 2 + + def __init__(self, can_interface, logger: Logger): + """ + @param can_interface: Denali Can Messenger object + """ + super().__init__() + self.can_interface = can_interface + self.logger = logger + + if self.can_interface is not None: + channel_id = DenaliChannels.hd_alarm_broadcast_ch_id + msg_id = MsgIds.MSG_ID_ALARM_STATUS_DATA.value + self.can_interface.register_receiving_publication_function(channel_id, msg_id, + self._handler_alarms_status_sync) + + channel_id = DenaliChannels.hd_alarm_broadcast_ch_id + msg_id = MsgIds.MSG_ID_ALARM_TRIGGERED.value + self.can_interface.register_receiving_publication_function(channel_id, msg_id, + self._handler_alarm_trigger) + msg_id = MsgIds.MSG_ID_ALARM_CLEARED.value + self.can_interface.register_receiving_publication_function(channel_id, msg_id, + self._handler_alarm_clear) + msg_id = MsgIds.MSG_ID_ALARM_CONDITION_CLEARED.value + self.can_interface.register_receiving_publication_function(channel_id, msg_id, + self._handler_alarm_condition_clear) + channel_id = DenaliChannels.hd_sync_broadcast_ch_id + msg_id = MsgIds.MSG_ID_HD_ALARM_INFORMATION_DATA.value + self.can_interface.register_receiving_publication_function(channel_id, msg_id, + self._handler_alarm_information_sync) + + self.hd_alarm_status_timestamp = 0.0 + self.hd_alarm_triggered_timestamp = 0.0 + self.hd_alarm_cleared_timestamp = 0.0 + self.hd_alarm_clr_condition_timestamp = 0.0 + self.hd_alarm_information_timestamp = 0.0 + # composite alarm status based on latest HD alarm status broadcast message + self.alarms_priority_state = 0 + self.alarm_top = 0 + self.alarms_silence_expires_in = 0 + self.alarms_escalates_in = 0 + self.alarms_flags = 0 + + # alarm states based on received HD alarm activation and alarm clear messages + self.alarm_states = [False] * 500 + # alarm condition states based on received HD alarm activation and clear condition messages + self.alarm_conditions = [False] * 500 + # alarm priorities based on received HD alarm activation messages + self.alarm_priorities = [0] * 500 + # alarm ranks based on received HD alarm activation messages + self.alarm_ranks = [0] * 500 + # alarm clear top only flags based on received HD alarm activation messages + self.alarm_clear_top_only_flags = [False] * 500 + # alarm debug data on alarm triggered message + self.alarm_data = [0, 0] * 500 + + # alarm information + self.alarm_data_type = dict() + self.alarm_volume = 0 + self.alarm_audio_curr_hg = 0.0 + self.alarm_audio_curr_lg = 0.0 + self.alarm_backup_audio_curr = 0.0 + self.safety_shutdown_active = False + self.ac_power_lost = False + self.alarm_table_button_blockers = [False] * self.AlarmResponseButtons.NUM_OF_HD_ALARM_RESPONSE_BUTTONS.value + self.alarm_state_button_blockers = [False] * self.AlarmResponseButtons.NUM_OF_HD_ALARM_RESPONSE_BUTTONS.value + + # Loop through the list of the event data type enum and update the dictionary + for data_type in HDEventDataType: + event_data_type = HDEventDataType(data_type).name + struct_unpack_type = None + + # If U32 is in the data type enum (i.e. EVENT_DATA_TYPE_U32), then the key is the enum and the value is + # the corresponding format in the python struct + if 'U32' in event_data_type or 'BOOL' in event_data_type or 'NONE' in event_data_type: + struct_unpack_type = 'I' + elif 'S32' in event_data_type: + struct_unpack_type = 'i' + elif 'F32' in event_data_type: + struct_unpack_type = 'f' + + self.alarm_data_type[event_data_type] = struct_unpack_type + + def get_current_alarms_state(self): + """ + Gets the current alarms state. + + @return: (int) the current alarms state. + """ + return self.alarms_priority_state + + def get_alarm_states(self): + """ + Gets all states for all alarms + + @return: List of booleans of size 500 + """ + return self.alarm_states + + def get_alarm_response_button_table_blocker_states(self): + """ + Gets the states (T/F) of the alarm response buttons blocked by alarm table properties. + + @return: List of booleans of size 3 (for resume, rinseback and end treatment buttons) + """ + return self.alarm_table_button_blockers + + def get_alarm_response_button_state_blocker_states(self): + """ + Gets the states (T/F) of the alarm response buttons blocked by state properties. + + @return: List of booleans of size 3 (for resume, rinseback and end treatment buttons) + """ + return self.alarm_state_button_blockers + + def get_alarm_conditions(self): + """ + Gets all alarm condition states for all alarms + + @return: List of booleans of size 500 + """ + return self.alarm_conditions + + def get_alarm_state(self, alarm_id): + """ + Gets alarm state for given alarm + + @return: Alarm state + """ + return self.alarm_states[alarm_id] + + def get_alarm_priority(self, alarm_id): + """ + Gets alarm priority for given alarm. + 0=None + 1=Low + 2=Medium + 3=High + + @return: Alarm priority + """ + return self.alarm_priorities[alarm_id] + + def get_alarm_rank(self, alarm_id): + """ + Gets alarm rank for given alarm + + @return: Alarm rank + """ + return self.alarm_ranks[alarm_id] + + def get_alarm_clear_top_only(self, alarm_id): + """ + Gets clear top only property for given alarm + + @return: Clear top only property (T/F) + """ + return self.alarm_clear_top_only_flags[alarm_id] + + def get_alarms_top(self): + """ + Gets the top alarm + + @return: (int) the top alarm + """ + return self.alarm_top + + def get_alarms_silence_expires_in(self): + """ + Gets the remaining time the alarms will be silenced (s) + + @return: (int) how long until the alarm silence expires + """ + return self.alarms_silence_expires_in + + def get_alarms_escalates_in(self): + """ + Gets the alarms escalates in time (s) + + @return: (int) how long until the alarm escalates + """ + return self.alarms_escalates_in + + def get_alarms_flags(self): + """ + Gets the alarms flags + + Extract each flag from the flags int using bit-masking. E.g. + + System Fault = result & 1 + Stop = result & 2 + No Clear = result & 4 + No Resume = result & 8 + No Rinseback = result & 16 + No End Treatment = result & 32 + No New Treatment = result & 64 + User Must ACK = result & 128 + Alarms to Escalate = result & 256 + Alarms Silenced = result & 512 + Alarm Lamp On = result & 1024 + TBD = result & 2048 + No Blood Recirc = result & 4096 + No Dialysate Recirc = result & 8192 + No Minimize = result & 16384 + Condition Detected = result & 32768 + + @return: (int) The alarms flags value + """ + return self.alarms_flags + + def get_alarm_volume(self): + """ + Gets the alarm audio volume level. + + @return: (int) current alarm audio volume (1..5) + """ + return self.alarm_volume + + def get_alarm_audio_current_hg(self): + """ + Gets the alarm audio current - high gain. + + @return: (float) alarm audio current - high gain (in mA) + """ + return self.alarm_audio_curr_hg + + def get_alarm_audio_current_lg(self): + """ + Gets the alarm audio current - low gain. + + @return: (float) alarm audio current - low gain (in mA) + """ + return self.alarm_audio_curr_lg + + def get_alarm_backup_audio_current(self): + """ + Gets the alarm backup audio current. + + @return: (float) alarm backup audio current (in mA) + """ + return self.alarm_backup_audio_curr + + def get_safety_shutdown_activated(self): + """ + Gets the state of the HD safety shutdown signal. + + @return: (bool) safety shutdown line is activated (T/F) + """ + return self.safety_shutdown_active + + def get_ac_power_lost(self): + """ + Gets the state of the HD a/c power loss signal. + + @return: (bool) a/c power is lost (T/F) + """ + return self.ac_power_lost + + def get_alarm_flag_system_fault(self) -> bool: + """ + Gets the alarm flag system fault. + + @return: (bool) Alarm flag system fault (T/F) + """ + return (self.alarms_flags & 1) > 0 + + def get_alarm_flag_stop(self) -> bool: + """ + Gets the alarm flag no clear. + + @return: (bool) Alarm flag no clear (T/F) + """ + return (self.alarms_flags & 2) > 0 + + def get_alarm_flag_no_clear(self) -> bool: + """ + Gets the alarm flag no clear. + + @return: (bool) Alarm flag no clear (T/F) + """ + return (self.alarms_flags & 4) > 0 + + def get_alarm_flag_no_resume(self) -> bool: + """ + Gets the alarm flag no resume. + + @return: (bool) Alarm flag no resume (T/F) + """ + return (self.alarms_flags & 8) > 0 + + def get_alarm_flag_no_rinseback(self) -> bool: + """ + Gets the alarm flag no rinseback. + + @return: (bool) Alarm flag no rinseback (T/F) + """ + return (self.alarms_flags & 16) > 0 + + def get_alarm_flag_no_end_treatment(self) -> bool: + """ + Gets the alarm flag no end treatment. + + @return: (bool) Alarm flag no end treatment (T/F) + """ + return (self.alarms_flags & 32) > 0 + + def get_alarm_flag_no_new_treatment(self) -> bool: + """ + Gets the alarm flag no new treatment. + + @return: (bool) Alarm flag no new treatment (T/F) + """ + return (self.alarms_flags & 64) > 0 + + def get_alarm_flag_okay_button_only(self) -> bool: + """ + Gets the alarm flag Ok button only. + + @return: (bool) Alarm flag Ok button only (T/F) + """ + return (self.alarms_flags & 128) > 0 + + def get_alarm_flag_alarm_to_escalate(self) -> bool: + """ + Gets the alarm flag to escalate. + + @return: (bool) Alarm flag indicating an active alarm is due to escalate (T/F) + """ + return (self.alarms_flags & 256) > 0 + + def get_alarm_flag_is_alarm_silenced(self) -> bool: + """ + Gets the alarm flag alarm silence + + @return: (bool) Alarm flag indicating alarms are currently silenced (T/F) + """ + return (self.alarms_flags & 512) > 0 + + def get_alarm_flag_lamp_on(self) -> bool: + """ + Gets the alarm flag lamp on. + + @return: (bool) Alarm lamp on (T/F) + """ + return (self.alarms_flags & 1024) > 0 + + def get_alarm_flag_no_blood_recirculation(self) -> bool: + """ + Gets the alarm flag no blood recirculation. + + @return: (bool) Alarm lamp on (T/F) + """ + return (self.alarms_flags & 4096) > 0 + + def get_alarm_flag_no_dialysate_recirculation(self) -> bool: + """ + Gets the alarm flag no dialysate recirculation. + + @return: (bool) Alarm lamp on (T/F) + """ + return (self.alarms_flags & 8192) > 0 + + def get_alarm_flag_no_minimize(self) -> bool: + """ + Gets the alarm flag no minimize. + + @return: (bool) Alarm cannot be minimized (T/F) + """ + return (self.alarms_flags & 16384) > 0 + + def get_alarm_flag_top_condition(self) -> bool: + """ + Gets the alarm flag top condition. + + @return: (bool) Top Alarm's condition is still being detected + """ + + return (self.alarms_flags & 32768) > 0 + + def clear_dialin_alarms(self): + """ + Clears the alarms states in Dialin. + + @return: none + """ + for x in range(500): + self.alarm_states[x] = False + + def get_alarm_data(self, alarm_id) -> list: + """ + Gets the alarm data fields for the requested alarm id + + @return: the alarm data fields for the requested alarm id + """ + return self.alarm_data[alarm_id] + + @publish(["hd_alarm_status_timestamp", "alarms_priority_state", "alarm_top", "alarms_silence_expires_in", "alarms_escalates_in", "alarms_flags"]) + def _handler_alarms_status_sync(self, message, timestamp=0.0): + """ + Handles published alarms status messages. alarms status data are captured + for reference. + + @param message: published alarm status data message + @return: none + """ + self.alarms_priority_state = struct.unpack('i', bytearray(message['message'][MsgFieldPositions.START_POS_FIELD_1:MsgFieldPositions.END_POS_FIELD_1]))[0] + self.alarm_top = struct.unpack('i', bytearray(message['message'][MsgFieldPositions.START_POS_FIELD_2:MsgFieldPositions.END_POS_FIELD_2]))[0] + self.alarms_escalates_in = struct.unpack('i', bytearray(message['message'][MsgFieldPositions.START_POS_FIELD_3:MsgFieldPositions.END_POS_FIELD_3]))[0] + self.alarms_silence_expires_in = struct.unpack('i', bytearray(message['message'][MsgFieldPositions.START_POS_FIELD_4:MsgFieldPositions.END_POS_FIELD_4]))[0] + self.alarms_flags = struct.unpack('H', bytearray(message['message'][MsgFieldPositions.START_POS_FIELD_5:MsgFieldPositions.START_POS_FIELD_5+2]))[0] + + self.hd_alarm_status_timestamp = timestamp + + @publish(["hd_alarm_triggered_timestamp", "alarm_states", "alarm_conditions", "alarm_data", + "alarm_priorities", "alarm_ranks", "alarm_clear_top_only_flags"]) + def _handler_alarm_trigger(self, message, timestamp=0.0): + """ + Handles published HD alarm activation messages. + + @param message: published HD alarm activation message + @return: none + """ + self.logger.debug("Alarm activated!") + alarm_id = struct.unpack('i', bytearray(message['message'][MsgFieldPositions.START_POS_FIELD_1:MsgFieldPositions.END_POS_FIELD_1])) + + data_typ_1 = struct.unpack('i', bytearray(message['message'][MsgFieldPositions.START_POS_FIELD_2:MsgFieldPositions.END_POS_FIELD_2])) + # Get the corresponding structure format + struct_data_type_1 = self.alarm_data_type[HDEventDataType(data_typ_1[0]).name] + # Get the data value by unpacking the data type + data_1 = struct.unpack(struct_data_type_1, bytearray(message['message'][MsgFieldPositions.START_POS_FIELD_3:MsgFieldPositions.END_POS_FIELD_3])) + + data_typ_2 = struct.unpack('i', bytearray(message['message'][MsgFieldPositions.START_POS_FIELD_4:MsgFieldPositions.END_POS_FIELD_4])) + # Get the corresponding structure format + struct_data_type_2 = self.alarm_data_type[HDEventDataType(data_typ_2[0]).name] + # Get the data value by unpacking the data type + data_2 = struct.unpack(struct_data_type_2, bytearray(message['message'][MsgFieldPositions.START_POS_FIELD_5:MsgFieldPositions.END_POS_FIELD_5])) + + priority = struct.unpack('i', bytearray(message['message'][MsgFieldPositions.START_POS_FIELD_6:MsgFieldPositions.END_POS_FIELD_6])) + rank = struct.unpack('i', bytearray(message['message'][MsgFieldPositions.START_POS_FIELD_7:MsgFieldPositions.END_POS_FIELD_7])) + clr_top_only = struct.unpack('i', bytearray(message['message'][MsgFieldPositions.START_POS_FIELD_8:MsgFieldPositions.END_POS_FIELD_8])) + + self.logger.debug("Alarm ID: %d %d %d" % (alarm_id[0], data_1[0], data_2[0])) + self.alarm_states[alarm_id[0]] = True + self.alarm_conditions[alarm_id[0]] = True + self.alarm_priorities[alarm_id[0]] = priority[0] + self.alarm_ranks[alarm_id[0]] = rank[0] + self.alarm_clear_top_only_flags[alarm_id[0]] = clr_top_only[0] + self.alarm_data[alarm_id[0]] = [data_1[0], data_2[0]] + self.hd_alarm_triggered_timestamp = timestamp + + @publish(["hd_alarm_cleared_timestamp", "alarm_states", "alarm_conditions"]) + def _handler_alarm_clear(self, message, timestamp=0.0): + """ + Handles published HD alarm clear messages. + + @param message: published HD alarm clear message + @return: none + """ + alarm_id = struct.unpack('i', bytearray(message['message'][MsgFieldPositions.START_POS_FIELD_1:MsgFieldPositions.END_POS_FIELD_1])) + self.alarm_states[alarm_id[0]] = False + self.alarm_conditions[alarm_id[0]] = False + self.hd_alarm_cleared_timestamp = timestamp + + @publish(["hd_alarm_clr_condition_timestamp", "alarm_conditions", "alarm_conditions"]) + def _handler_alarm_condition_clear(self, message, timestamp=0.0): + """ + Handles published HD alarm clear alarm condition messages. + + @param message: published HD alarm clear alarm condition message + @return: none + """ + alarm_id = struct.unpack('i', bytearray(message['message'][MsgFieldPositions.START_POS_FIELD_1:MsgFieldPositions.END_POS_FIELD_1])) + self.alarm_conditions[alarm_id[0]] = False + self.hd_alarm_clr_condition_timestamp = timestamp + + @publish(["hd_alarm_information_timestamp", "alarm_volume", "alarm_audio_curr_hg", "alarm_audio_curr_lg", "alarm_backup_audio_curr", + "safety_shutdown_active", "ac_power_lost", "alarm_table_button_blockers", "alarm_state_button_blockers"]) + def _handler_alarm_information_sync(self, message, timestamp=0.0): + """ + Handles published HD alarm information broadcast messages. + + @param message: published HD alarm information message + @return: none + """ + + vol = struct.unpack('i', bytearray( + message['message'][MsgFieldPositions.START_POS_FIELD_1:MsgFieldPositions.END_POS_FIELD_1])) + ach = struct.unpack('f', bytearray( + message['message'][MsgFieldPositions.START_POS_FIELD_2:MsgFieldPositions.END_POS_FIELD_2])) + acl = struct.unpack('f', bytearray( + message['message'][MsgFieldPositions.START_POS_FIELD_3:MsgFieldPositions.END_POS_FIELD_3])) + bac = struct.unpack('f', bytearray( + message['message'][MsgFieldPositions.START_POS_FIELD_4:MsgFieldPositions.END_POS_FIELD_4])) + saf = struct.unpack('i', bytearray( + message['message'][MsgFieldPositions.START_POS_FIELD_5:MsgFieldPositions.END_POS_FIELD_5])) + acp = struct.unpack('i', bytearray( + message['message'][MsgFieldPositions.START_POS_FIELD_6:MsgFieldPositions.END_POS_FIELD_6])) + trs = struct.unpack('B', bytearray( + message['message'][MsgFieldPositions.START_POS_FIELD_7:MsgFieldPositions.START_POS_FIELD_7+1])) + trb = struct.unpack('B', bytearray( + message['message'][MsgFieldPositions.START_POS_FIELD_7+1:MsgFieldPositions.START_POS_FIELD_7+2])) + tet = struct.unpack('B', bytearray( + message['message'][MsgFieldPositions.START_POS_FIELD_7+2:MsgFieldPositions.START_POS_FIELD_7+3])) + srs = struct.unpack('B', bytearray( + message['message'][MsgFieldPositions.START_POS_FIELD_7+3:MsgFieldPositions.START_POS_FIELD_7+4])) + srb = struct.unpack('B', bytearray( + message['message'][MsgFieldPositions.START_POS_FIELD_7+4:MsgFieldPositions.START_POS_FIELD_7+5])) + set = struct.unpack('B', bytearray( + message['message'][MsgFieldPositions.START_POS_FIELD_7+5:MsgFieldPositions.START_POS_FIELD_7+6])) + + self.alarm_volume = vol[0] + self.alarm_audio_curr_hg = ach[0] + self.alarm_audio_curr_lg = acl[0] + self.alarm_backup_audio_curr = bac[0] + self.safety_shutdown_active = True if saf[0] == 1 else False + self.ac_power_lost = True if acp[0] == 1 else False + self.alarm_table_button_blockers[self.AlarmResponseButtons.HD_ALARM_RESPONSE_BUTTON_RESUME.value] = True if trs[0] == 1 else False + self.alarm_table_button_blockers[self.AlarmResponseButtons.HD_ALARM_RESPONSE_BUTTON_RINSEBACK.value] = True if trb[0] else False + self.alarm_table_button_blockers[self.AlarmResponseButtons.HD_ALARM_RESPONSE_BUTTON_END_TREATMENT.value] = True if tet[0] else False + self.alarm_state_button_blockers[self.AlarmResponseButtons.HD_ALARM_RESPONSE_BUTTON_RESUME.value] = True if srs[0] else False + self.alarm_state_button_blockers[self.AlarmResponseButtons.HD_ALARM_RESPONSE_BUTTON_RINSEBACK.value] = True if srb[0] else False + self.alarm_state_button_blockers[self.AlarmResponseButtons.HD_ALARM_RESPONSE_BUTTON_END_TREATMENT.value] = True if set[0] else False + self.hd_alarm_information_timestamp = timestamp + + def cmd_clear_all_alarms(self) -> int: + """ + Constructs and sends the clear all active alarms command. + This will clear even non-recoverable alarms. + Constraints: + Must be logged into HD. + + @return: 1 if successful, zero otherwise + """ + + key = integer_to_bytearray(-758926171) # 0xD2C3B4A5 + payload = key + + message = DenaliMessage.build_message(channel_id=DenaliChannels.dialin_to_hd_ch_id, + message_id=MsgIds.MSG_ID_SUPER_CLEAR_ALARMS_CMD.value, + payload=payload) + + # Send message + received_message = self.can_interface.send(message) + + # If there is content... + if received_message is not None: + self.logger.debug("All alarms cleared.") + # response payload is OK or not OK + return 1 == received_message['message'][DenaliMessage.PAYLOAD_START_INDEX] + return False + + def cmd_resend_all_alarms(self) -> int: + """ + Constructs and sends the re-send all active alarms command. + This will allow Dialin to get caught up with HD alarms that were triggered prior to connection. + Constraints: + Must be logged into HD. + + @return: 1 if successful, zero otherwise + """ + + message = DenaliMessage.build_message(channel_id=DenaliChannels.dialin_to_hd_ch_id, + message_id=MsgIds.MSG_ID_HD_SEND_ALARMS_COMMAND.value) + + # Send message + received_message = self.can_interface.send(message) + + # If there is content... + if received_message is not None: + self.logger.debug("Command to re-send all active HD alarms acknowledged.") + # response payload is OK or not OK + return 1 == received_message['message'][DenaliMessage.PAYLOAD_START_INDEX] + return False + + def cmd_alarm_state_override(self, alarm: int, state: int, reset: int = NO_RESET) -> int: + """ + Constructs and sends the alarm state override command + Constraints: + Must be logged into HD. + Given alarm must be valid. + If inactivating alarm, given alarm must be recoverable (clearable). + + @param alarm: integer - ID of alarm to override + @param state: integer - 1 for alarm active, 0 for alarm inactive + @param reset: integer - 1 to reset a previous override, 0 to override + @return: 1 if successful, zero otherwise + """ + + rst = integer_to_bytearray(reset) + sta = integer_to_bytearray(state) + alm = integer_to_bytearray(alarm) + payload = rst + sta + alm + + message = DenaliMessage.build_message(channel_id=DenaliChannels.dialin_to_hd_ch_id, + message_id=MsgIds.MSG_ID_ALARM_STATE_OVERRIDE.value, + payload=payload) + + # Send message + received_message = self.can_interface.send(message) + + # If there is content... + if received_message is not None: + # self.logger.debug(received_message) + if reset == RESET: + str_res = "reset back to normal" + else: + str_res = ("active" if state != 0 else "inactive") + self.logger.debug("Alarm " + str(alarm) + " " + str_res + ": " + + str(received_message['message'][DenaliMessage.PAYLOAD_START_INDEX])) + # response payload is OK or not OK + return received_message['message'][DenaliMessage.PAYLOAD_START_INDEX] + else: + self.logger.debug("Timeout!!!!") + return False + + def cmd_alarm_time_override(self, alarm: int, time_ms: int, reset: int = NO_RESET) -> int: + """ + Constructs and sends the alarm time override command + Constraints: + Must be logged into HD. + Given alarm must be valid. + + @param alarm: integer - ID of alarm to override + @param time_ms: integer - time (in ms) since alarm was activated + @param reset: integer - 1 to reset a previous override, 0 to override + @return: 1 if successful, zero otherwise + """ + + rst = integer_to_bytearray(reset) + ms = integer_to_bytearray(time_ms) + alm = integer_to_bytearray(alarm) + payload = rst + ms + alm + + message = DenaliMessage.build_message(channel_id=DenaliChannels.dialin_to_hd_ch_id, + message_id=MsgIds.MSG_ID_ALARM_TIME_OVERRIDE.value, + payload=payload) + + self.logger.debug("override alarm time since activated") + + # Send message + received_message = self.can_interface.send(message) + + # If there is content... + if received_message is not None: + # self.logger.debug(received_message) + if reset == RESET: + str_res = "reset back to normal" + else: + str_res = str(time_ms) + self.logger.debug("Alarm time since activated overridden to " + str_res + " ms: " + + str(received_message['message'][DenaliMessage.PAYLOAD_START_INDEX])) + # response payload is OK or not OK + return received_message['message'][DenaliMessage.PAYLOAD_START_INDEX] + else: + self.logger.debug("Timeout!!!!") + return False + + def cmd_alarm_lamp_pattern_override(self, pattern: int, reset: int = NO_RESET) -> int: + """ + Constructs and sends the alarm lamp pattern override command. + Constraints: + Must be logged into HD. + Given pattern must be one of the patterns listed below. + + @param pattern: integer - ID of alarm lamp pattern to override with + @param reset: integer - 1 to reset a previous override, 0 to override + @return: 1 if successful, zero otherwise + + Patterns: \n + 0 = off \n + 1 = ok \n + 2 = fault \n + 3 = high \n + 4 = medium \n + 5 = low \n + 6 = manual + """ + rst = integer_to_bytearray(reset) + pat = integer_to_bytearray(pattern) + payload = rst + pat + + message = DenaliMessage.build_message(channel_id=DenaliChannels.dialin_to_hd_ch_id, + message_id=MsgIds.MSG_ID_ALARM_LAMP_PATTERN_OVERRIDE.value, + payload=payload) + + self.logger.debug("Override Alarm Lamp Pattern") + + # Send message + received_message = self.can_interface.send(message) + + # If there is content... + if received_message is not None: + self.logger.debug(received_message) + if reset == RESET: + str_pat = "reset back to normal" + elif pattern == self.HD_ALARM_LAMP_PATTERN_OFF: + str_pat = "off" + elif pattern == self.HD_ALARM_LAMP_PATTERN_OK: + str_pat = "ok" + elif pattern == self.HD_ALARM_LAMP_PATTERN_FAULT: + str_pat = "fault" + elif pattern == self.HD_ALARM_LAMP_PATTERN_HIGH: + str_pat = "high" + elif pattern == self.HD_ALARM_LAMP_PATTERN_MEDIUM: + str_pat = "medium" + elif pattern == self.HD_ALARM_LAMP_PATTERN_LOW: + str_pat = "low" + else: + str_pat = "manual" + self.logger.debug("Alarm lamp pattern overridden to " + str_pat + ":" + + str(received_message['message'][DenaliMessage.PAYLOAD_START_INDEX])) + # response payload is OK or not OK + return received_message['message'][DenaliMessage.PAYLOAD_START_INDEX] + else: + self.logger.debug("Timeout!!!!") + return False + + def cmd_alarm_info_broadcast_interval_override(self, ms: int = 1000, reset: int = NO_RESET): + """ + Constructs and sends the alarm information broadcast interval override command + Constraints: + Must be logged into HD. + Given interval must be non-zero and a multiple of the HD general task interval (50 ms). + + @param ms: integer - interval (in ms) to override with + @param reset: integer - 1 to reset a previous override, 0 to override + @return: 1 if successful, zero otherwise + """ + + if not check_broadcast_interval_override_ms(ms): + return False + + rst = integer_to_bytearray(reset) + mis = integer_to_bytearray(ms) + payload = rst + mis + + message = DenaliMessage.build_message(channel_id=DenaliChannels.dialin_to_hd_ch_id, + message_id=MsgIds.MSG_ID_HD_ALARM_INFO_SEND_INTERVAL_OVERRIDE.value, + payload=payload) + + self.logger.debug("override alarm information broadcast interval") + + # Send message + received_message = self.can_interface.send(message) + + # If there is content... + if received_message is not None: + if reset == RESET: + str_res = "reset back to normal: " + else: + str_res = str(ms) + " ms: " + self.logger.debug("Alarm information broadcast interval overridden to " + str_res + + str(received_message['message'][DenaliMessage.PAYLOAD_START_INDEX])) + # response payload is OK or not OK + return received_message['message'][DenaliMessage.PAYLOAD_START_INDEX] + else: + self.logger.debug("Timeout!!!!") + return False + + def cmd_alarm_status_broadcast_interval_override(self, ms: int = 250, reset: int = NO_RESET): + """ + Constructs and sends the alarm status broadcast interval override command + Constraints: + Must be logged into HD. + Given interval must be non-zero and a multiple of the HD general task interval (50 ms). + + @param ms: integer - interval (in ms) to override with + @param reset: integer - 1 to reset a previous override, 0 to override + @return: 1 if successful, zero otherwise + """ + + if not check_broadcast_interval_override_ms(ms): + return False + + rst = integer_to_bytearray(reset) + mis = integer_to_bytearray(ms) + payload = rst + mis + + message = DenaliMessage.build_message(channel_id=DenaliChannels.dialin_to_hd_ch_id, + message_id=MsgIds.MSG_ID_HD_ALARM_STATUS_PUBLISH_INTERVAL_OVERRIDE.value, + payload=payload) + + self.logger.debug("override alarm status broadcast interval") + + # Send message + received_message = self.can_interface.send(message) + + # If there is content... + if received_message is not None: + if reset == RESET: + str_res = "reset back to normal: " + else: + str_res = str(ms) + " ms: " + self.logger.debug("Alarm status broadcast interval overridden to " + str_res + + str(received_message['message'][DenaliMessage.PAYLOAD_START_INDEX])) + # response payload is OK or not OK + return received_message['message'][DenaliMessage.PAYLOAD_START_INDEX] + else: + self.logger.debug("Timeout!!!!") + return False + + def cmd_alarm_audio_volume_override(self, volume: int = 5, reset: int = NO_RESET): + """ + Constructs and sends the alarm audio volume override command + Constraints: + Must be logged into HD. + Given volume must be an integer between 1 and 5. + + @param volume: integer - alarm audio volume level (1..5) + @param reset: integer - 1 to reset a previous override, 0 to override + @return: 1 if successful, zero otherwise + """ + + rst = integer_to_bytearray(reset) + vol = integer_to_bytearray(volume) + payload = rst + vol + + message = DenaliMessage.build_message(channel_id=DenaliChannels.dialin_to_hd_ch_id, + message_id=MsgIds.MSG_ID_HD_ALARM_AUDIO_VOLUME_LEVEL_OVERRIDE.value, + payload=payload) + + self.logger.debug("override alarm audio volume level") + + # Send message + received_message = self.can_interface.send(message) + + # If there is content... + if received_message is not None: + if reset == RESET: + str_res = "reset back to normal: " + else: + str_res = str(volume) + ": " + self.logger.debug("Alarm audio volume level overridden to " + str_res + + str(received_message['message'][DenaliMessage.PAYLOAD_START_INDEX])) + # response payload is OK or not OK + return received_message['message'][DenaliMessage.PAYLOAD_START_INDEX] + else: + self.logger.debug("Timeout!!!!") + return False + + def cmd_alarm_audio_current_hg_override(self, current: float = 0.0, reset: int = NO_RESET): + """ + Constructs and sends the alarm audio current (high gain) override command + Constraints: + Must be logged into HD. + + @param current: float - current (in mA) for high gain alarm audio + @param reset: integer - 1 to reset a previous override, 0 to override + @return: 1 if successful, zero otherwise + """ + + rst = integer_to_bytearray(reset) + cur = float_to_bytearray(current) + payload = rst + cur + + message = DenaliMessage.build_message(channel_id=DenaliChannels.dialin_to_hd_ch_id, + message_id=MsgIds.MSG_ID_HD_ALARM_AUDIO_CURRENT_HG_OVERRIDE.value, + payload=payload) + + self.logger.debug("override alarm audio high gain current") + + # Send message + received_message = self.can_interface.send(message) + + # If there is content... + if received_message is not None: + if reset == RESET: + str_res = "reset back to normal: " + else: + str_res = str(current) + " mA: " + self.logger.debug("Alarm audio high gain current overridden to " + str_res + + str(received_message['message'][DenaliMessage.PAYLOAD_START_INDEX])) + # response payload is OK or not OK + return received_message['message'][DenaliMessage.PAYLOAD_START_INDEX] + else: + self.logger.debug("Timeout!!!!") + return False + + def cmd_alarm_audio_current_lg_override(self, current: float = 0.0, reset: int = NO_RESET): + """ + Constructs and sends the alarm audio current (low gain) override command + Constraints: + Must be logged into HD. + + @param current: float - current (in mA) for low gain alarm audio + @param reset: integer - 1 to reset a previous override, 0 to override + @return: 1 if successful, zero otherwise + """ + + rst = integer_to_bytearray(reset) + cur = float_to_bytearray(current) + payload = rst + cur + + message = DenaliMessage.build_message(channel_id=DenaliChannels.dialin_to_hd_ch_id, + message_id=MsgIds.MSG_ID_HD_ALARM_AUDIO_CURRENT_LG_OVERRIDE.value, + payload=payload) + + self.logger.debug("override alarm audio high gain current") + + # Send message + received_message = self.can_interface.send(message) + + # If there is content... + if received_message is not None: + if reset == RESET: + str_res = "reset back to normal: " + else: + str_res = str(current) + " mA: " + self.logger.debug("Alarm audio low gain current overridden to " + str_res + + str(received_message['message'][DenaliMessage.PAYLOAD_START_INDEX])) + # response payload is OK or not OK + return received_message['message'][DenaliMessage.PAYLOAD_START_INDEX] + else: + self.logger.debug("Timeout!!!!") + return False + + def cmd_alarm_backup_audio_current_override(self, current: float = 0.0, reset: int = NO_RESET): + """ + Constructs and sends the backup alarm audio current override command + Constraints: + Must be logged into HD. + + @param current: float - current (in mA) for backup alarm audio + @param reset: integer - 1 to reset a previous override, 0 to override + @return: 1 if successful, zero otherwise + """ + + rst = integer_to_bytearray(reset) + cur = float_to_bytearray(current) + payload = rst + cur + + message = DenaliMessage.build_message(channel_id=DenaliChannels.dialin_to_hd_ch_id, + message_id=MsgIds.MSG_ID_HD_ALARM_BACKUP_AUDIO_CURRENT_OVERRIDE.value, + payload=payload) + + self.logger.debug("override alarm backup audio current") + + # Send message + received_message = self.can_interface.send(message) + + # If there is content... + if received_message is not None: + if reset == RESET: + str_res = "reset back to normal: " + else: + str_res = str(current) + " mA: " + self.logger.debug("Alarm backup audio current overridden to " + str_res + + str(received_message['message'][DenaliMessage.PAYLOAD_START_INDEX])) + # response payload is OK or not OK + return received_message['message'][DenaliMessage.PAYLOAD_START_INDEX] + else: + self.logger.debug("Timeout!!!!") + return False Index: leahi-dialin/td/bubble_detector.py =================================================================== diff -u --- leahi-dialin/td/bubble_detector.py (revision 0) +++ leahi-dialin/td/bubble_detector.py (revision 12b82879196778f6c83d08751652177ea0fcbf5e) @@ -0,0 +1,170 @@ +########################################################################### +# +# Copyright (c) 2021-2024 Diality Inc. - All Rights Reserved. +# +# THIS CODE MAY NOT BE COPIED OR REPRODUCED IN ANY FORM, IN PART OR IN +# WHOLE, WITHOUT THE EXPLICIT PERMISSION OF THE COPYRIGHT OWNER. +# +# @file air_bubbles.py +# +# @author (last) Sean Nash +# @date (last) 04-May-2023 +# @author (original) Peman Montazemi +# @date (original) 18-May-2021 +# +############################################################################ +import struct +from logging import Logger + +from .constants import RESET, NO_RESET +from ..common.msg_defs import MsgIds, MsgFieldPositions +from ..protocols.CAN import DenaliMessage, DenaliChannels +from ..utils.base import AbstractSubSystem, publish +from ..utils.conversions import integer_to_bytearray + + +class TDBubbleDectector(AbstractSubSystem): + """ + TDAirBubbles + + Treatment Delivery (TD) Dialin API sub-class for air bubbles related commands. + ADA: Air bubble Detector Arterial + ADV: Air bubble Detector Venous + """ + + # Air bubble detectors + ADV = 0 # Air bubble Detector Venous + + # Air bubble detectors status + BUBBLE_DETECTED_STATUS = 0 # Air bubble detected + FLUID_DETECTED_STATUS = 1 # Fluid (no air bubble) detected + + # Air bubble detectors state machine states + AIR_BUBBLE_NORMAL_STATE = 0 # Normal state + AIR_BUBBLE_SELF_TEST_STATE = 1 # Self-test state + + def __init__(self, can_interface, logger: Logger): + """ + + @param can_interface: Denali Can Messenger object + """ + super().__init__() + self.can_interface = can_interface + self.logger = logger + + if self.can_interface is not None: + channel_id = DenaliChannels.td_sync_broadcast_ch_id + msg_id = MsgIds.MSG_ID_TD_BUBBLES_DATA.value + self.can_interface.register_receiving_publication_function(channel_id, msg_id, + self._handler_air_bubbles_data_sync) + + self.td_air_bubbles_timestamp = 0.0 + # Initialize status of ADV air bubble detectors to fluid (no air bubble) detected + self.air_bubbles_status = [self.FLUID_DETECTED_STATUS] + + # Initialize state of ADV air bubble detectors state machine to normal + self.air_bubbles_state = [self.AIR_BUBBLE_NORMAL_STATE] + + @publish(["td_air_bubbles_timestamp", "air_bubbles_status", "air_bubbles_state"]) + def _handler_air_bubbles_data_sync(self, message, timestamp=0.0): + """ + Handles published air bubbles data messages. Air bubble status and state are captured + for ADV detector. + + @param message: published air bubbles data message as: ADV status, ADV state + @return: None + """ + + adv_status = struct.unpack('i', bytearray( + message['message'][MsgFieldPositions.START_POS_FIELD_1:MsgFieldPositions.END_POS_FIELD_1])) + adv_state = struct.unpack('i', bytearray( + message['message'][MsgFieldPositions.START_POS_FIELD_2:MsgFieldPositions.END_POS_FIELD_2])) + + self.air_bubbles_status = [adv_status[0]] + self.air_bubbles_state = [adv_state[0]] + self.td_air_bubbles_timestamp = timestamp + + def cmd_air_bubble_status_override(self, status: int, index: int, reset: int = NO_RESET) -> int: + """ + Constructs and sends the air bubble detector status override command + Constraints: + Must be logged into TD. + Given detector must be one of the detectors listed below. + + @param status: unsigned int - status (0=air bubble, 1=fluid) to override detector with + @param index: integer - 0 for ADV status override + @param reset: integer - 1 to reset a previous override, 0 to override + @return: 1 if successful, zero otherwise + """ + + rst = integer_to_bytearray(reset) + i = integer_to_bytearray(index) + stat = integer_to_bytearray(status) + payload = rst + stat + i + + message = DenaliMessage.build_message(channel_id=DenaliChannels.dialin_to_td_ch_id, + message_id=MsgIds.MSG_ID_TD_BUBBLE_OVERRIDE_REQUEST.value, + payload=payload) + + if index == self.ADV: + self.logger.debug("Override air bubble detector ADV status value") + + # Send message + received_message = self.can_interface.send(message) + + # If there is content... + if received_message is not None: + # response payload is OK or not OK + return received_message['message'][DenaliMessage.PAYLOAD_START_INDEX] + else: + self.logger.debug("Timeout!!!!") + return False + + def cmd_air_bubbles_data_broadcast_interval_override(self, ms: int, reset: int = NO_RESET) -> int: + """ + Constructs and sends the air bubbles data broadcast interval override command + Constraints: + Must be logged into TD. + Given interval must be positive non-zero and a multiple of the TD priority task interval (50 ms). + + @param ms: integer - interval (in ms) to override with + @param reset: integer - 1 to reset a previous override, 0 to override + @return: 1 if successful, zero otherwise + """ + + if ms > 0 and ms % 50 == 0: + rst = integer_to_bytearray(reset) + mis = integer_to_bytearray(ms) + payload = rst + mis + + message = DenaliMessage.build_message(channel_id=DenaliChannels.dialin_to_td_ch_id, + message_id=MsgIds.MSG_ID_TD_BUBBLE_PUBLISH_INTERVAL_OVERRIDE_REQUEST.value, + payload=payload) + + self.logger.debug("Override TD air bubbles data broadcast interval to"+str(ms)+"ms") + + # Send message + received_message = self.can_interface.send(message) + + # If there is content... + if received_message is not None: + if reset == RESET: + str_res = "reset back to normal: " + else: + str_res = str(ms) + " ms: " + self.logger.debug("Air bubbles data broadcast interval overridden to " + str_res + + str(received_message['message'][DenaliMessage.PAYLOAD_START_INDEX])) + # response payload is OK or not OK + return received_message['message'][DenaliMessage.PAYLOAD_START_INDEX] + else: + self.logger.debug("Timeout!!!!") + return False + elif ms <= 0: + self.logger.debug("ms must be positive non-zero.") + return False + elif ms % 50 != 0: + self.logger.debug("ms must be a multiple of 50.") + return False + else: + self.logger.debug("ms must be an integer.") + return False \ No newline at end of file Index: leahi-dialin/td/buttons.py =================================================================== diff -u --- leahi-dialin/td/buttons.py (revision 0) +++ leahi-dialin/td/buttons.py (revision 12b82879196778f6c83d08751652177ea0fcbf5e) @@ -0,0 +1,157 @@ +########################################################################### +# +# Copyright (c) 2020-2024 Diality Inc. - All Rights Reserved. +# +# THIS CODE MAY NOT BE COPIED OR REPRODUCED IN ANY FORM, IN PART OR IN +# WHOLE, WITHOUT THE EXPLICIT PERMISSION OF THE COPYRIGHT OWNER. +# +# @file buttons.py +# +# @author (last) Micahel Garthwaite +# @date (last) 05-Nov-2024 +# @author (original) Peter Lucia +# @date (original) 14-Oct-2024 +# +############################################################################ +import struct +from logging import Logger + +from .constants import RESET, NO_RESET +from ..common.msg_defs import MsgIds, MsgFieldPositions +from ..protocols.CAN import DenaliMessage, DenaliCanMessenger, DenaliChannels +from ..utils.base import AbstractSubSystem, publish +from ..utils.conversions import integer_to_bytearray, byte_to_bytearray + + +class TDButtons(AbstractSubSystem): + """ + Treatment Delivery (TD) Dialin API sub-class for button related commands. + """ + + def __init__(self, can_interface: DenaliCanMessenger, logger: Logger): + """ + TD_Buttons constructor + + @param can_interface: the Denali CAN interface object + """ + + super().__init__() + self.can_interface = can_interface + self.logger = logger + self.poweroff_timeout_expired = False + + if self.can_interface is not None: + self.can_interface.register_receiving_publication_function(DenaliChannels.td_to_ui_ch_id, + MsgIds.MSG_ID_OFF_BUTTON_PRESS_REQUEST.value, + self._handler_poweroff_timeout_occurred) + self.td_power_off_timestamp = 0.0 + + def reset_poweroff_timeout_expired(self): + """ + Resets the dialin poweroff timeout flag to False + + @return: None + """ + + self.poweroff_timeout_expired = False + + @publish(['td_power_off_timestamp', "poweroff_timeout_expired"]) + def _handler_poweroff_timeout_occurred(self, message, timestamp=0.0): + """ + Poweroff timeout occurred handler + + @param message: The poweroff timeout occurred message string + @return: None + """ + if len(message["message"]) < 16: + self.logger.debug("Poweroff message id detected, but was the wrong length.") + return + + mode = struct.unpack('h', bytearray( + message["message"][MsgFieldPositions.START_POS_FIELD_1: MsgFieldPositions.START_POS_FIELD_1 + 2])) + + if len(mode) > 0: + self.poweroff_timeout_expired = bool(mode[0]) + self.td_power_off_timestamp = timestamp + + def cmd_off_button_override(self, state: int, reset: int = NO_RESET) -> int: + """ + Constructs and sends the Off button override command + See TD/App/Controllers/Buttons.c + Constraints: + Must be logged into TD. + Given state must be a 0 or 1. + + @param state: integer - 1 to override off button to "pressed", 0 to "released" + @param reset: integer - 1 to reset a previous override, 0 to override + @return: 1 if successful, zero otherwise + """ + + rst = integer_to_bytearray(reset) + sta = integer_to_bytearray(state) + payload = rst + sta + + message = DenaliMessage.build_message(channel_id=DenaliChannels.dialin_to_td_ch_id, + message_id=MsgIds.MSG_ID_TD_OFF_BUTTON_OVERRIDE_REQUEST.value, + payload=payload) + + self.logger.debug("override off button") + + # Send message + received_message = self.can_interface.send(message) + + # If there is content... + if received_message is not None: + if reset == RESET: + str_res = "reset back to normal" + else: + str_res = ("pressed" if state != 0 else "released") + + self.logger.debug("Off button overridden to " + str_res + ":" + + str(received_message['message'][DenaliMessage.PAYLOAD_START_INDEX])) + # response payload is OK or not OK + return received_message['message'][DenaliMessage.PAYLOAD_START_INDEX] + else: + self.logger.debug("Timeout!!!!") + return False + + def cmd_stop_button_override(self, state: int, reset: int = NO_RESET) -> int: + """ + Constructs and sends the Stop button override command + See TD/App/Controllers/Buttons.c + Constraints: + Must be logged into TD. + Given state must be a 0 or 1. + + @param state: integer - 1 to override stop button to "pressed", 0 to "released" + @param reset: integer - 1 to reset a previous override, 0 to override + @return: 1 if successful, zero otherwise + """ + + rst = integer_to_bytearray(reset) + sta = integer_to_bytearray(state) + payload = rst + sta + + message = DenaliMessage.build_message(channel_id=DenaliChannels.dialin_to_td_ch_id, + message_id=MsgIds.MSG_ID_TD_STOP_BUTTON_OVERRIDE_REQUEST.value, + payload=payload) + + self.logger.debug("override stop button") + + # Send message + received_message = self.can_interface.send(message) + + # If there is content... + if received_message is not None: + if reset == RESET: + str_res = "reset back to normal" + else: + str_res = ("pressed" if state != 0 else "released") + self.logger.debug("Stop button overridden to " + str_res + ":" + + str(received_message['message'][DenaliMessage.PAYLOAD_START_INDEX])) + + # response payload is OK or not OK + return received_message["message"][DenaliMessage.PAYLOAD_START_INDEX] + else: + self.logger.debug("Timeout!!!!") + return False Index: leahi-dialin/td/dd_proxy.py =================================================================== diff -u --- leahi-dialin/td/dd_proxy.py (revision 0) +++ leahi-dialin/td/dd_proxy.py (revision 12b82879196778f6c83d08751652177ea0fcbf5e) @@ -0,0 +1 @@ \ No newline at end of file Index: leahi-dialin/td/pressure_sensors.py =================================================================== diff -u --- leahi-dialin/td/pressure_sensors.py (revision 0) +++ leahi-dialin/td/pressure_sensors.py (revision 12b82879196778f6c83d08751652177ea0fcbf5e) @@ -0,0 +1,155 @@ +########################################################################### +# +# Copyright (c) 2020-2024 Diality Inc. - All Rights Reserved. +# +# THIS CODE MAY NOT BE COPIED OR REPRODUCED IN ANY FORM, IN PART OR IN +# WHOLE, WITHOUT THE EXPLICIT PERMISSION OF THE COPYRIGHT OWNER. +# +# @file pressure_occlusion.py +# +# @author (last) Vinayakam Mani +# @date (last) 02-May-2024 +# @author (original) Peter Lucia +# @date (original) 02-Apr-2020 +# +############################################################################ +import struct +from logging import Logger + +from .constants import RESET, NO_RESET +from ..common.msg_defs import MsgIds, MsgFieldPositions +from ..protocols.CAN import DenaliMessage, DenaliChannels +from ..utils.base import AbstractSubSystem, publish +from ..utils.checks import check_broadcast_interval_override_ms +from ..utils.conversions import integer_to_bytearray, float_to_bytearray + + +class TDPressureOcclusion(AbstractSubSystem): + """ + Treatment Delivery (TD) Dialin API sub-class for pressure related commands. + """ + + def __init__(self, can_interface, logger: Logger): + """ + TDPressureOcclusion constructor + + """ + super().__init__() + self.can_interface = can_interface + self.logger = logger + + if self.can_interface is not None: + channel_id = DenaliChannels.td_sync_broadcast_ch_id + msg_id = MsgIds.MSG_ID_PRESSURE_DATA.value + self.can_interface.register_receiving_publication_function(channel_id, msg_id, + self._handler_pressure_occlusion_sync) + + self.td_pressure_occlusion_timestamp = 0.0 + self.arterial_pressure = 0.0 + self.venous_pressure = 0.0 + self.arterial_long_filtered_pressure = 0.0 + self.venous_long_filtered_pressure = 0.0 + self.blood_pump_occlusion = 0 + self.pressure_limits_state = 0 + self.arterial_pressure_limit_min = 0 + self.arterial_pressure_limit_max = 0 + self.venous_pressure_limit_min = 0 + self.venous_pressure_limit_max = 0 + + @publish([ + "td_pressure_occlusion_timestamp", + "arterial_pressure", + "venous_pressure", + "blood_pump_occlusion", + "pressure_limits_state", + "arterial_pressure_limit_min", + "arterial_pressure_limit_max", + "venous_pressure_limit_min", + "venous_pressure_limit_max", + "arterial_long_filtered_pressure", + "venous_long_filtered_pressure", + ]) + def _handler_pressure_occlusion_sync(self, message, timestamp=0.0): + """ + Handles published pressure & occlusion data messages. Pressure data are captured + for reference. + + @param message: published pressure & occlusion data message + @return: none + """ + + art = struct.unpack('f', bytearray( + message['message'][MsgFieldPositions.START_POS_FIELD_1:MsgFieldPositions.END_POS_FIELD_1])) + ven = struct.unpack('f', bytearray( + message['message'][MsgFieldPositions.START_POS_FIELD_2:MsgFieldPositions.END_POS_FIELD_2])) + bp = struct.unpack('i', bytearray( + message['message'][MsgFieldPositions.START_POS_FIELD_3:MsgFieldPositions.END_POS_FIELD_3])) + pls = struct.unpack('i', bytearray( + message['message'][MsgFieldPositions.START_POS_FIELD_4:MsgFieldPositions.END_POS_FIELD_4])) + apl = struct.unpack('i', bytearray( + message['message'][MsgFieldPositions.START_POS_FIELD_5:MsgFieldPositions.END_POS_FIELD_5])) + apu = struct.unpack('i', bytearray( + message['message'][MsgFieldPositions.START_POS_FIELD_6:MsgFieldPositions.END_POS_FIELD_6])) + vpl = struct.unpack('i', bytearray( + message['message'][MsgFieldPositions.START_POS_FIELD_7:MsgFieldPositions.END_POS_FIELD_7])) + vpu = struct.unpack('i', bytearray( + message['message'][MsgFieldPositions.START_POS_FIELD_8:MsgFieldPositions.END_POS_FIELD_8])) + lfa = struct.unpack('f', bytearray( + message['message'][MsgFieldPositions.START_POS_FIELD_9:MsgFieldPositions.END_POS_FIELD_9])) + lfv = struct.unpack('f', bytearray( + message['message'][MsgFieldPositions.START_POS_FIELD_10:MsgFieldPositions.END_POS_FIELD_10])) + + self.arterial_pressure = art[0] + self.venous_pressure = ven[0] + self.blood_pump_occlusion = bp[0] + self.pressure_limits_state = pls[0] + self.arterial_pressure_limit_min = apl[0] + self.arterial_pressure_limit_max = apu[0] + self.venous_pressure_limit_min = vpl[0] + self.venous_pressure_limit_max = vpu[0] + self.arterial_long_filtered_pressure = lfa[0] + self.venous_long_filtered_pressure = lfv[0] + self.td_pressure_occlusion_timestamp = timestamp + + def cmd_pressure_sensor_override(self, pressure: float, sensor: int, reset: int = NO_RESET) -> int: + """ + Constructs and sends the measured arterial pressure override command + PRESSURE_SENSOR_ARTERIAL = 0 ///< Arterial blood line pressure sensor + PRESSURE_SENSOR_VENOUS = 1 ///< Vensous blood line pressure sensor + Constraints: + Must be logged into TD. + + @param pressure: float - measured arterial pressure (in mmHg) to override with + @param sensor: bool - switch between filtered override and raw override + @param reset: integer - 1 to reset a previous override, 0 to override + @return: 1 if successful, zero otherwise + """ + + rst = integer_to_bytearray(reset) + sen = integer_to_bytearray(sensor) + prs = float_to_bytearray(pressure) + payload = rst + prs + sen + + message = DenaliMessage.build_message(channel_id=DenaliChannels.dialin_to_TD_ch_id, + message_id=MsgIds.MSG_ID_TD_PRESSURE_OVERRIDE_REQUEST.value, + payload=payload) + + self.logger.debug("override pressure sensor") + + # Send message + received_message = self.can_interface.send(message) + + # If there is content...S + if received_message is not None: + if reset == RESET: + str_res = "reset back to normal. " + else: + str_res = str(pres) + " mmHg. " + self.logger.debug("pressure (measured)) overridden to " + str_res + + str(received_message['message'][DenaliMessage.PAYLOAD_START_INDEX])) + # response payload is OK or not OK + return received_message['message'][DenaliMessage.PAYLOAD_START_INDEX] + else: + self.logger.debug("Timeout!!!!") + return False + Index: leahi-dialin/td/switches.py =================================================================== diff -u --- leahi-dialin/td/switches.py (revision 0) +++ leahi-dialin/td/switches.py (revision 12b82879196778f6c83d08751652177ea0fcbf5e) @@ -0,0 +1 @@ \ No newline at end of file Index: leahi-dialin/td/treatment_delivery.py =================================================================== diff -u --- leahi-dialin/td/treatment_delivery.py (revision 0) +++ leahi-dialin/td/treatment_delivery.py (revision 12b82879196778f6c83d08751652177ea0fcbf5e) @@ -0,0 +1,307 @@ +########################################################################### +# +# Copyright (c) 2020-2024 Diality Inc. - All Rights Reserved. +# +# THIS CODE MAY NOT BE COPIED OR REPRODUCED IN ANY FORM, IN PART OR IN +# WHOLE, WITHOUT THE EXPLICIT PERMISSION OF THE COPYRIGHT OWNER. +# +# @file hemodialysis_device.py +# +# @author (last) Dara Navaei +# @date (last) 26-Feb-2024 +# @author (original) Peter Lucia +# @date (original) 02-Apr-2020 +# +############################################################################ +import struct + +from .air_pump import TDAirPump +from .air_trap import TDAirTrap +from .alarms import TDAlarms +from .bubble_detector import TDBubbleDectector +from .buttons import TDButtons +from .pressure_sensors import TDPressureSensors +from .switches import TDSwitches + +from ..common.msg_defs import MsgIds, MsgFieldPositions +from ..protocols.CAN import DenaliMessage, DenaliCanMessenger, DenaliChannels +from ..utils.base import AbstractSubSystem, publish, LogManager +from ..utils.checks import check_broadcast_interval_override_ms +from ..utils.conversions import integer_to_bytearray, unsigned_short_to_bytearray, bytearray_to_integer, \ + bytearray_to_byte + + +class TD(AbstractSubSystem): + """ + Treatment Delivery (TD) Dialin object API. + It provides the basic interface to communicate with the TD firmware. + """ + # TD debug event max count + _TD_DEBUG_EVENT_LIST_COUNT = 10 + _TD_DEBUG_EVENT_MSG_LEN_INDEX = 5 + + # TD login password + TD_LOGIN_PASSWORD = '123' + + # UI version message field positions + START_POS_MAJOR = DenaliMessage.PAYLOAD_START_INDEX + END_POS_MAJOR = START_POS_MAJOR + 1 + START_POS_MINOR = END_POS_MAJOR + END_POS_MINOR = START_POS_MINOR + 1 + START_POS_MICRO = END_POS_MINOR + END_POS_MICRO = START_POS_MICRO + 1 + START_POS_BUILD = END_POS_MICRO + END_POS_BUILD = START_POS_BUILD + 2 + START_POS_COMPATIBILITY_REV = END_POS_BUILD + END_POS_COMPATIBILITY_REV = START_POS_COMPATIBILITY_REV + 4 + + def __init__(self, can_interface="can0", log_level=None): + """ + TD object provides test/service commands for the TD sub-system. + + >> TD_object = TD('can0') + >> TD_object = TD(can_interface='can0', log_level="DEBUG") + + Possible log levels: + ["DEBUG", "INFO", "WARNING", "ERROR", "CRITICAL", "CAN_ONLY", "PRINT_ONLY"] + + @param can_interface: (str) CANBus interface name, e.g. "can0" + @param log_level: (str) Logging level, defaults to None + """ + + super().__init__() + self._log_manager = LogManager(log_level=log_level, log_filepath=self.__class__.__name__ + ".log") + self.logger = self._log_manager.logger + + # Create listener + self.can_interface = DenaliCanMessenger(can_interface=can_interface, + logger=self.logger) + self.can_interface.start() + self.callback_id = None + # register handler for TD operation mode broadcast messages + if self.can_interface is not None: + channel_id = DenaliChannels.TD_sync_broadcast_ch_id + msg_id = MsgIds.MSG_ID_TD_OP_MODE_DATA.value + self.can_interface.register_receiving_publication_function(channel_id, msg_id, + self._handler_td_op_mode_sync) + + self.can_interface.register_receiving_publication_function(channel_id, + MsgIds.MSG_ID_TD_DEBUG_EVENT.value, + self._handler_td_debug_event_sync) + + self.can_interface.register_receiving_publication_function(DenaliChannels.ui_to_TD_ch_id, + MsgIds.MSG_ID_UI_VERSION_INFO_RESPONSE.value, + self._handler_ui_version_response_sync) + + # create properties + self.td_op_mode_timestamp = 0.0 + self.td_debug_events_timestamp = 0.0 + self.ui_version_info_response_timestamp = 0.0 + self.td_operation_mode = tdOpModes.MODE_INIT.value + self.td_operation_sub_mode = 0 + self.td_logged_in = False + self.td_set_logged_in_status(False) + self.ui_version = None + self.td_debug_events = [''] * self._TD_DEBUG_EVENT_LIST_COUNT + self.td_debug_event_index = 0 + self.td_last_debug_event = '' + + # Create command groups + self.air_pump = TDAirPump(self.can_interface, self.logger) + self.bubbles = TDBubbleDectector(self.can_interface, self.logger) + self.buttons = TDButtons(self.can_interface, self.logger) + self.pressure_sensors = TDPressureSensors(self.can_interface, self.logger) + + @publish(["td_debug_events_timestamp","td_debug_events"]) + def _handler_td_debug_event_sync(self, message, timestamp = 0.0): + + payload = message['message'] + message_length = payload[self._TD_DEBUG_EVENT_MSG_LEN_INDEX] + temp_message = '' + + index = MsgFieldPositions.START_POS_FIELD_1 + + for i in range(0, message_length): + # Loop through the length and get the + char, char_index = bytearray_to_byte(payload, index + i, False) + temp_message += chr(char) + + self.td_debug_events_timestamp = timestamp + self.td_debug_events.insert(self.td_debug_event_index, temp_message) + self.td_last_debug_event = temp_message + + self.td_debug_event_index += 1 + if self.td_debug_event_index == self._TD_DEBUG_EVENT_LIST_COUNT: + self.td_debug_event_index = 0 + + @publish(["td_logged_in"]) + def td_set_logged_in_status(self, logged_in: bool = False): + """ + Callback for td logged in status change. + @param logged_in boolean logged in status for TD + @return: none + """ + self.td_logged_in = logged_in + + @publish(["td_op_mode_timestamp","td_operation_mode", "td_operation_sub_mode"]) + def _handler_td_op_mode_sync(self, message, timestamp = 0.0): + """ + Handles published TD operation mode messages. Current TD operation mode + is captured for reference. + + @param message: published TD operation mode broadcast message + @return: None + """ + mode = struct.unpack('i', bytearray( + message['message'][MsgFieldPositions.START_POS_FIELD_1:MsgFieldPositions.END_POS_FIELD_1])) + smode = struct.unpack('i', bytearray( + message['message'][MsgFieldPositions.START_POS_FIELD_2:MsgFieldPositions.END_POS_FIELD_2])) + + self.td_operation_mode = mode[0] + self.td_operation_sub_mode = smode[0] + self.td_op_mode_timestamp = timestamp + + + def _handler_ui_version_response_sync(self,message, timestamp = 0.0): + """ + Handler for response from TD regarding its version. + + @param message: response message from TD regarding valid treatment parameter ranges.\n + U08 Major \n + U08 Minor \n + U08 Micro \n + U16 Build \n + U32 Compatibility revision + + @return: None if not successful, the version string if unpacked successfully + """ + major = struct.unpack(' 0 for each in [major, minor, micro, build, compatibility]]): + self.ui_version = f"v{major[0]}.{minor[0]}.{micro[0]}-{build[0]}.{compatibility[0]}" + self.logger.debug(f"UI VERSION: {self.ui_version}") + + else: + self.ui_version = None + self.logger.debug("Failed to retrieve UI Version.") + + def cmd_log_in_to_td(self, resend: bool = False) -> int: + """ + Constructs and sends a login command via CAN bus. Login required before \n + other commands can be sent to the TD. + + @param resend: (bool) if False (default), try to login once. Otherwise, tries to login indefinitely + @return: 1 if logged in, 0 if log in failed + """ + + message = DenaliMessage.build_message(channel_id=DenaliChannels.dialin_to_td_ch_id, + message_id=MsgIds.MSG_ID_TESTER_LOGIN_REQUEST.value, + payload=list(map(int, map(ord, self.TD_LOGIN_PASSWORD)))) + + self.logger.debug("Logging in...") + + # Send message + received_message = self.can_interface.send(message, resend=resend) + + if received_message is not None: + if received_message['message'][DenaliMessage.PAYLOAD_START_INDEX] == 1: + self.logger.debug("Success: Logged In") + self.td_set_logged_in_status(True) + self._send_td_checkin_message() # Timer starts interval first + self.can_interface.transmit_interval_dictionary[self.callback_id].start() + else: + self.logger.debug("Failure: Log In Failed.") + return received_message['message'][DenaliMessage.PAYLOAD_START_INDEX] + else: + self.logger.debug("Login Timeout!!!!") + return False + + def cmd_td_set_operation_mode(self, new_mode: int = 0) -> int: + """ + Constructs and sends a set operation mode request command via CAN bus. + Constraints: + Must be logged into TD. + Transition from current to requested op mode must be legal. + NOTE: for POST the TD device shall be in Standby Mode + + @param new_mode: ID of operation mode to transition to + TD_OP_MODE_FAULT = 0 + TD_OP_MODE_SERVICE = 1 + TD_OP_MODE_INIT_POST = 2 + TD_OP_MODE_STANDBY = 3 + TD_OP_MODE_TREATMENT_PARAMS = 4 + TD_OP_MODE_PRE_TREATMENT = 5 + TD_OP_MODE_TREATMENT = 6 + TD_OP_MODE_POST_TREATMENT = 7 + + @return: 1 if successful, zero otherwise + + """ + + payload = integer_to_bytearray(new_mode) + + message = DenaliMessage.build_message(channel_id=DenaliChannels.dialin_to_td_ch_id, + message_id=MsgIds.MSG_ID_TD_SET_OP_MODE_REQUEST.value, + payload=payload) + + self.logger.debug("Requesting TD mode change to " + str(new_mode)) + + # Send message + received_message = self.can_interface.send(message) + + if received_message is not None: + if received_message['message'][DenaliMessage.PAYLOAD_START_INDEX] == 1: + self.logger.debug("Success: Mode change accepted") + else: + self.logger.debug("Failure: Mode change rejected.") + return received_message['message'][DenaliMessage.PAYLOAD_START_INDEX] + else: + self.logger.debug("TD mode change request Timeout!!!!") + return False + + + def cmd_td_software_reset_request(self) -> None: + """ + Constructs and sends an TD software reset request via CAN bus. + Constraints: + Must be logged into TD. + + @return: None + """ + + message = DenaliMessage.build_message(channel_id=DenaliChannels.dialin_to_td_ch_id, + message_id=MsgIds.MSG_ID_TD_SOFTWARE_RESET_REQUEST.value) + + self.logger.debug("requesting TD software reset") + + # Send message + self.can_interface.send(message, 0) + self.logger.debug("Sent request to TD to reset...") + self.td_set_logged_in_status(False) + + def cmd_request_ui_version(self) -> None: + """ + Constructs and sends a ui version request to the TD. + + @return: none + """ + + message = DenaliMessage.build_message(channel_id=DenaliChannels.TD_to_ui_ch_id, + message_id=MsgIds.MSG_ID_TD_UI_VERSION_INFO_REQUEST.value) + + self.logger.debug("Sending an UI version request to the TD.") + self.can_interface.send(message, 0) + + + Fisheye: Tag 1d187781679790e97292cae1118750036aef7a10 refers to a dead (removed) revision in file `leahi-dialin/ui/__init__.py'. Fisheye: No comparison available. Pass `N' to diff?