Index: HemodialysisDevice.py =================================================================== diff -u -r678ba7efb2e019c266a119500e572ae5c27b369c -raef4802f8270da7b77751fd8e5b774f3ece46799 --- HemodialysisDevice.py (.../HemodialysisDevice.py) (revision 678ba7efb2e019c266a119500e572ae5c27b369c) +++ HemodialysisDevice.py (.../HemodialysisDevice.py) (revision aef4802f8270da7b77751fd8e5b774f3ece46799) @@ -50,11 +50,12 @@ # Create command groups self._Basics = HD.HD__Basics(self) self.Alarms = HD.HD_Alarms(self, self.can_interface) - self.Buttons = HD.HD_Buttons(self) self.BloodFlow = HD.HD_BloodFlow(self, self.can_interface) - self.RTC = HD.HD_RTC(self, self.can_interface) + self.Buttons = HD.HD_Buttons(self) self.DialysateInletFlow = HD.HD_DialysateInletFlow(self, self.can_interface) self.DialysateOutletFlow = HD.HD_DialysateOutletFlow(self, self.can_interface) + self.Pressure_Occlusion = HD.HD_Pressure_Occlusion(self, self.can_interface) + self.RTC = HD.HD_RTC(self, self.can_interface) self.Treatment = HD.HD_Treatment(self, self.can_interface) self.Watchdog = HD.HD_Watchdog(self) ## DialOut is an HD_DialOutFlow object @@ -1787,6 +1788,302 @@ self.TreatmentTimeElapsed = ela[0] self.TreatmentTimeRemaining = rem[0] + class HD_Pressure_Occlusion: + """ + \class HD_Pressure_Occlusion + + \brief Hemodialysis Device (HD) Dialin API sub-class for pressure related commands. + + """ + + # Pressure/Occlusion message IDs + MSG_ID_HD_PRESSURE_OCCLUSION_DATA = 0x0009 + MSG_ID_HD_PRESSURE_ARTERIAL_OVERRIDE = 0x8017 + MSG_ID_HD_PRESSURE_VENOUS_OVERRIDE = 0x8018 + MSG_ID_HD_OCCLUSION_BLOOD_PUMP_OVERRIDE = 0x8019 + MSG_ID_HD_OCCLUSION_DIAL_IN_PUMP_OVERRIDE = 0x801A + MSG_ID_HD_OCCLUSION_DIAL_OUT_PUMP_OVERRIDE = 0x801B + MSG_ID_HD_PRES_OCCL_SEND_INTERVAL_OVERRIDE = 0x801C + + # Pressure/Occlusion broadcast message field positions + START_POS_ART_PRES = DenaliMessage.PAYLOAD_START_INDEX + END_POS_ART_PRES = START_POS_ART_PRES + 4 + START_POS_VEN_PRES = END_POS_ART_PRES + END_POS_VEN_PRES = START_POS_VEN_PRES + 4 + START_POS_BP_OCCL = END_POS_VEN_PRES + END_POS_BP_OCCL = START_POS_BP_OCCL + 4 + START_POS_DIP_OCCL = END_POS_BP_OCCL + END_POS_DIP_OCCL = START_POS_DIP_OCCL + 4 + START_POS_DOP_OCCL = END_POS_DIP_OCCL + END_POS_DOP_OCCL = START_POS_DOP_OCCL + 4 + + def __init__(self, outer_instance, can_interface=None): + """ + HD_Pressure_Occlusion constructor + + \param outer_instance: reference to the HD (outer) class. + + \returns HD_Pressure_Occlusion object. + """ + self.outer_instance = outer_instance + + if can_interface is not None: + channel_id = DenaliChannels.hd_sync_broadcast_ch_id + msg_id = self.MSG_ID_HD_PRESSURE_OCCLUSION_DATA + can_interface.registerReceivingPublicationFunction(channel_id, msg_id, + self.handlerPresOcclSyncFunction) + + self.arterialPressure = 0 + self.venousPressure = 0.0 + self.bloodPumpOcclusion = 0.0 + self.dialysateInletPumpOcclusion = 0.0 + self.dialysateOutletPumpOcclusion = 0.0 + + def handlerPresOcclSyncFunction(self, message): + """ + Handles published pressure & occlusion data messages. Pressure data are captured + for reference. + + \param message: published pressure & occlusion data message + \returns none + """ + + art = struct.unpack('f', bytearray( + message['message'][self.START_POS_ART_PRES:self.END_POS_ART_PRES])) + ven = struct.unpack('f', bytearray( + message['message'][self.START_POS_VEN_PRES:self.END_POS_VEN_PRES])) + bp = struct.unpack('f', bytearray( + message['message'][self.START_POS_BP_OCCL:self.END_POS_BP_OCCL])) + dpi = struct.unpack('f', bytearray( + message['message'][self.START_POS_DIP_OCCL:self.END_POS_DIP_OCCL])) + dpo = struct.unpack('f', bytearray( + message['message'][self.START_POS_DOP_OCCL:self.END_POS_DOP_OCCL])) + + self.arterialPressure = art[0] + self.venousPressure = ven[0] + self.bloodPumpOcclusion = bp[0] + self.dialysateInletPumpOcclusion = dpi[0] + self.dialysateOutletPumpOcclusion = dpo[0] + + def CmdArterialPressureMeasuredOverride(self, reset, pres): + """ + Constructs and sends the measured arterial pressure override command + + \param reset: integer - 1 to reset a previous override, 0 to override + \param pres: float - measured arterial pressure (in mmHg) to override with + \returns 1 if successful, zero otherwise + """ + + rst = self.outer_instance.integer2ByteArray(reset) + prs = self.outer_instance.float2ByteArray(pres) + payload = rst + prs + + message = DenaliMessage.buildMessage(channel_id=DenaliChannels.dialin_to_hd_ch_id, + message_id=self.MSG_ID_HD_PRESSURE_ARTERIAL_OVERRIDE, + payload=payload) + + print("override measured arterial pressure") + + # Send message + received_message = self.outer_instance.can_interface.send(message) + + # If there is content... + if received_message is not None: + if reset == HD.RESET: + str_res = "reset back to normal. " + else: + str_res = str(pres) + " mmHg. " + print("Arterial 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: + print("Timeout!!!!") + return False + + def CmdVenousPressureMeasuredOverride(self, reset, pres): + """ + Constructs and sends the measured venous pressure \n + override command. + + \param reset: integer - 1 to reset a previous override, 0 to override + \param pres: float - venous pressure (in mmHg) to override with + \returns 1 if successful, zero otherwise + """ + + rst = self.outer_instance.integer2ByteArray(reset) + prs = self.outer_instance.float2ByteArray(pres) + payload = rst + prs + + message = DenaliMessage.buildMessage(channel_id=DenaliChannels.dialin_to_hd_ch_id, + message_id=self.MSG_ID_HD_PRESSURE_VENOUS_OVERRIDE, + payload=payload) + + print("override measured venous pressure") + + # Send message + received_message = self.outer_instance.can_interface.send(message) + + # If there is content... + if received_message is not None: + if reset == HD.RESET: + str_res = "reset back to normal. " + else: + str_res = str(pres) + " mmHg. " + print("Venous 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: + print("Timeout!!!!") + return False + + def CmdBloodPumpMeasuredOcclusionOverride(self, reset, occl): + """ + Constructs and sends the measured blood pump occlusion pressure override command + + \param reset: integer - 1 to reset a previous override, 0 to override + \param occl: float - pressure (in mmHg) to override with + \returns 1 if successful, zero otherwise + """ + + rst = self.outer_instance.integer2ByteArray(reset) + occ = self.outer_instance.float2ByteArray(occl) + payload = rst + occ + + message = DenaliMessage.buildMessage(channel_id=DenaliChannels.dialin_to_hd_ch_id, + message_id=self.MSG_ID_HD_OCCLUSION_BLOOD_PUMP_OVERRIDE, + payload=payload) + + print("override measured blood pump occlusion pressure") + + # Send message + received_message = self.outer_instance.can_interface.send(message) + + # If there is content... + if received_message is not None: + if reset == HD.RESET: + str_res = "reset back to normal. " + else: + str_res = str(occl) + " mmHg. " + print("Blood pump occlusion 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: + print("Timeout!!!!") + return False + + def CmdDialysateInletPumpMeasuredOcclusionOverride(self, reset, occl): + """ + Constructs and sends the measured dialysate inlet pump occlusion pressure override \n + command. + + \param reset: integer - 1 to reset a previous override, 0 to override + \param occl: float - pressure (in mmHg) to override with + \returns 1 if successful, zero otherwise + """ + + rst = self.outer_instance.integer2ByteArray(reset) + occ = self.outer_instance.float2ByteArray(occl) + payload = rst + occ + + message = DenaliMessage.buildMessage(channel_id=DenaliChannels.dialin_to_hd_ch_id, + message_id=self.MSG_ID_HD_OCCLUSION_DIAL_IN_PUMP_OVERRIDE, + payload=payload) + + print("override measured dialysate inlet pump occlusion pressure") + + # Send message + received_message = self.outer_instance.can_interface.send(message) + + # If there is content... + if received_message is not None: + if reset == HD.RESET: + str_res = "reset back to normal. " + else: + str_res = str(occl) + " mmHg. " + print("Dialysate inlet pump occlusion 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: + print("Timeout!!!!") + return False + + def CmdDialysateOutletPumpMeasuredOcclusionOverride(self, reset, occl): + """ + Constructs and sends the measured dialysate outlet pump occlusion pressure override \n + command. + + \param reset: integer - 1 to reset a previous override, 0 to override + \param occl: float - pressure (in mmHg) to override with + \returns 1 if successful, zero otherwise + """ + + rst = self.outer_instance.integer2ByteArray(reset) + occ = self.outer_instance.float2ByteArray(occl) + payload = rst + occ + + message = DenaliMessage.buildMessage(channel_id=DenaliChannels.dialin_to_hd_ch_id, + message_id=self.MSG_ID_HD_OCCLUSION_DIAL_OUT_PUMP_OVERRIDE, + payload=payload) + + print("override measured dialysate outlet pump occlusion pressure") + + # Send message + received_message = self.outer_instance.can_interface.send(message) + + # If there is content... + if received_message is not None: + if reset == HD.RESET: + str_res = "reset back to normal. " + else: + str_res = str(occl) + " mmHg. " + print("Dialysate outlet pump occlusion 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: + print("Timeout!!!!") + return False + + def CmdPressureOcclusionBroadcastIntervalOverride(self, reset, ms): + """ + Constructs and sends the pressure/occlusion broadcast interval override command + + \param reset: integer - 1 to reset a previous override, 0 to override + \param ms: integer - interval (in ms) to override with + \returns 1 if successful, zero otherwise + """ + + rst = self.outer_instance.integer2ByteArray(reset) + mis = self.outer_instance.integer2ByteArray(ms) + payload = rst + mis + + message = DenaliMessage.buildMessage(channel_id=DenaliChannels.dialin_to_hd_ch_id, + message_id=self.MSG_ID_HD_PRES_OCCL_SEND_INTERVAL_OVERRIDE, + payload=payload) + + print("override pressure/occlusion broadcast interval") + + # Send message + received_message = self.outer_instance.can_interface.send(message) + + # If there is content... + if received_message is not None: + if reset == HD.RESET: + str_res = "reset back to normal: " + else: + str_res = str(ms) + " ms: " + print("Pressure/occlusion 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: + print("Timeout!!!!") + return False + def integer2ByteArray(self, val): """ Converts an integer value into a byte array (little endian)