Index: HemodialysisDevice.py =================================================================== diff -u -r90bbd3f735b72658325f9c4124916cc75d62422a -r519260ce5bc660d7d44c612848412ea4e50ca662 --- HemodialysisDevice.py (.../HemodialysisDevice.py) (revision 90bbd3f735b72658325f9c4124916cc75d62422a) +++ HemodialysisDevice.py (.../HemodialysisDevice.py) (revision 519260ce5bc660d7d44c612848412ea4e50ca662) @@ -20,9 +20,10 @@ from DialityCoreCanProtocol import DenaliChannels from time import sleep from binascii import unhexlify -from HD_DialOutFlow import HD_DialOut -from HD_DialOutFlow import DialOutStates +#from HD_DialOutFlow import HD_DialOut +#from HD_DialOutFlow import DialOutStates import struct +import ctypes class HD: @@ -48,12 +49,14 @@ self.can_interface.start() # Create command groups self._Basics = HD.HD__Basics(self) - self.Alarms = HD.HD_Alarms(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.DialysateInletFlow = HD.HD_DialysateInletFlow(self, self.can_interface) self.Watchdog = HD.HD_Watchdog(self) ## DialOut is an HD_DialOutFlow object - self.DialOut = HD_DialOut(self.can_interface) + # self.DialOut = HD_DialOut(self.can_interface) class HD__Basics: """ @@ -98,8 +101,12 @@ received_message = self.outer_instance.can_interface.send(message) if received_message is not None: - print(received_message) - print("Logged In: " + str(received_message['message'][DenaliMessage.PAYLOAD_START_INDEX])) + #print(received_message) + if received_message['message'][DenaliMessage.PAYLOAD_START_INDEX] == 1: + print("Logged In") + else: + print("Log In Failed.") + #print("Logged In: " + str(received_message['message'][DenaliMessage.PAYLOAD_START_INDEX])) return received_message['message'][DenaliMessage.PAYLOAD_START_INDEX] else: print("Timeout!!!!") @@ -126,7 +133,7 @@ # If there is content... if received_message is not None: - print(received_message) + #print(received_message) print("Inserted message: " + str(received_message['message'][DenaliMessage.PAYLOAD_START_INDEX])) # response payload is OK or not OK return received_message['message'][DenaliMessage.PAYLOAD_START_INDEX] @@ -180,7 +187,7 @@ # If there is content... if received_message is not None: - print(received_message) + #print(received_message) if reset == HD.RESET: str_res = "reset back to normal" else: @@ -218,7 +225,7 @@ # If there is content... if received_message is not None: - print(received_message) + #print(received_message) if reset == HD.RESET: str_res = "reset back to normal" else: @@ -278,7 +285,7 @@ # If there is content... if received_message is not None: - print(received_message) + #print(received_message) if reset == HD.RESET: str_res = "reset back to normal" else: @@ -320,7 +327,10 @@ END_POS_ALARM_TOP = START_POS_ALARM_TOP + 4 START_POS_ALARM_SILENCE_EXPIRES_IN = END_POS_ALARM_TOP END_POS_ALARM_SILENCE_EXPIRES_IN = START_POS_ALARM_SILENCE_EXPIRES_IN + 4 - START_POS_ALARMS_FLAGS = END_POS_ALARM_SILENCE_EXPIRES_IN + START_POS_ALARM_ESCALATES_IN = END_POS_ALARM_SILENCE_EXPIRES_IN + END_POS_ALARM_ESCALATES_IN = START_POS_ALARM_ESCALATES_IN + 4 + START_POS_ALARMS_FLAGS = END_POS_ALARM_ESCALATES_IN + END_POS_ALARMS_FLAGS = START_POS_ALARMS_FLAGS + 2 def __init__(self, outer_instance, can_interface=None): @@ -334,14 +344,15 @@ self.outer_instance = outer_instance if can_interface is not None: - channel_id = DenaliChannels.hd_sync_broadcast_ch_id + channel_id = DenaliChannels.hd_alarm_broadcast_ch_id msg_id = self.MSG_ID_HD_ALARMS_PUBLISHED_STATUS can_interface.registerReceivingPublicationFunction(channel_id, msg_id, self.handlerAlarmsStatusSyncFunction) self.alarmsState = 0 self.alarmTop = 0 self.alarmsSilenceExpiresIn = 0 + self.alarmsEscalatesIn = 0 self.alarmsFlags = 0 def handlerAlarmsStatusSyncFunction(self, message): @@ -362,6 +373,9 @@ self.alarmsSilenceExpiresIn = int.from_bytes(bytearray( message['message'][self.START_POS_ALARM_SILENCE_EXPIRES_IN:self.END_POS_ALARM_SILENCE_EXPIRES_IN]), byteorder=DenaliMessage.BYTE_ORDER) + self.alarmsEscalatesIn = int.from_bytes(bytearray( + message['message'][self.START_POS_ALARM_ESCALATES_IN:self.END_POS_ALARM_ESCALATES_IN]), + byteorder=DenaliMessage.BYTE_ORDER) self.alarmsFlags = int.from_bytes(bytearray( message['message'][self.START_POS_ALARMS_FLAGS:self.END_POS_ALARMS_FLAGS]), byteorder=DenaliMessage.BYTE_ORDER) @@ -392,7 +406,7 @@ # If there is content... if received_message is not None: - print(received_message) + #print(received_message) if reset == HD.RESET: str_res = "reset back to normal" else: @@ -431,7 +445,7 @@ # If there is content... if received_message is not None: - print(received_message) + #print(received_message) if reset == HD.RESET: str_res = "reset back to normal" else: @@ -501,6 +515,81 @@ print("Timeout!!!!") return False + class HD_RTC: + + MSG_ID_SET_RTC_DATE_TIME = 0x801D + MSG_ID_RTC_EPOCH = 0x000A + + START_POS_SET_PT = DenaliMessage.PAYLOAD_START_INDEX + END_POS_SET_PT = START_POS_SET_PT + 4 + + def __init__(self, outer_instance, can_interface=None): + """ + HD_BloodFlow constructor + + \param outer_instance: reference to the HD (outer) class. + + \returns HD_BloodFlow 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_RTC_EPOCH + can_interface.registerReceivingPublicationFunction(channel_id, msg_id, + self.handlerRTCEpoch) + self.RTCEpoch = 0 + + def handlerRTCEpoch(self, message): + """ + Publishes the RTC time in epoch + + \param message: published RTC epoch message + \returns none + """ + epoch = int.from_bytes(bytearray( + message['message'][self.START_POS_SET_PT:self.END_POS_SET_PT]), + byteorder=DenaliMessage.BYTE_ORDER) + self.RTCEpoch = ctypes.c_uint32(epoch) + + def CmdSetRTCTimeAndDate(self, secs, mins, hours, days, months, years): + """ + Constructs and sends the time and date to be written to RTC + + \returns 1 if successful, zero otherwise + """ + sec = bytes([secs]) + min = bytes([mins]) + hour = bytes([hours]) + day = bytes([days]) + month = bytes([months]) + year = self.outer_instance.integer2ByteArray(years) + payload = sec + min + hour + day + month + year + + message = DenaliMessage.buildMessage(channel_id=DenaliChannels.dialin_to_hd_ch_id, + message_id=self.MSG_ID_SET_RTC_DATE_TIME, + payload=payload) + + print("Setting time and date to RTC") + + # Send message + received_message = self.outer_instance.can_interface.send(message) + + # If there is content... + if received_message is not None: + print(received_message) + #str_res = str(flow) + print("Time and Date in RTC set to seconds: " + str(sec) + " minutes: " + str(min) + " hours: " + + str(hour) + " days: " + str(day) + " months: " + str(month) + " years: " + str(year) + + 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 + + + class HD_BloodFlow: """ \class HD_BloodFlow @@ -556,7 +645,7 @@ self.MeasuredBloodPumpRotorSpeed = 0.0 self.MeasuredBloodPumpSpeed = 0.0 self.MeasuredBloodPumpMCSpeed = 0.0 - self.MeasuredBloodPumpMCurrent = 0.0 + self.MeasuredBloodPumpMCCurrent = 0.0 self.PWMDutyCyclePct = 0.0 def handlerBloodFlowSyncFunction(self, message): @@ -568,9 +657,12 @@ \returns none """ - self.TargetBloodFlowRate = int.from_bytes(bytearray( - message['message'][self.START_POS_SET_PT:self.END_POS_SET_PT]), - byteorder=DenaliMessage.BYTE_ORDER) + #self.TargetBloodFlowRate = int.from_bytes(bytearray( + # message['message'][self.START_POS_SET_PT:self.END_POS_SET_PT]), + # byteorder=DenaliMessage.BYTE_ORDER) + tgt = struct.unpack('i',bytearray( + message['message'][self.START_POS_SET_PT:self.END_POS_SET_PT])) + flow = struct.unpack('f', bytearray( message['message'][self.START_POS_MEAS_FLOW:self.END_POS_MEAS_FLOW])) rotor = struct.unpack('f', bytearray( @@ -584,6 +676,7 @@ pwm = struct.unpack('f', bytearray( message['message'][self.START_POS_PWM_DC:self.END_POS_PWM_DC])) + self.TargetBloodFlowRate = tgt[0] self.MeasuredBloodFlowRate = flow[0] self.MeasuredBloodPumpRotorSpeed = rotor[0] self.MeasuredBloodPumpSpeed = speed[0] @@ -615,7 +708,7 @@ # If there is content... if received_message is not None: - print(received_message) + #print(received_message) if reset == HD.RESET: str_res = "reset back to normal" else: @@ -653,7 +746,7 @@ # If there is content... if received_message is not None: - print(received_message) + #print(received_message) if reset == HD.RESET: str_res = "reset back to normal" else: @@ -666,9 +759,6 @@ print("Timeout!!!!") return False - # TODO - add override command for blood pump motor speed (motor hall sensor via FPGA) - # TODO - add override command for blood pump speed (pump hall sensor via NHET?) - def CmdBloodPumpMCMeasuredSpeedOverride(self, reset, speed): """ Constructs and sends the measured blood pump motor controller speed \n @@ -694,7 +784,7 @@ # If there is content... if received_message is not None: - print(received_message) + #print(received_message) if reset == HD.RESET: str_res = "reset back to normal" else: @@ -731,7 +821,7 @@ # If there is content... if received_message is not None: - print(received_message) + #print(received_message) if reset == HD.RESET: str_res = "reset back to normal" else: @@ -769,7 +859,7 @@ # If there is content... if received_message is not None: - print(received_message) + #print(received_message) if reset == HD.RESET: str_res = "reset back to normal" else: @@ -807,7 +897,7 @@ # If there is content... if received_message is not None: - print(received_message) + #print(received_message) if reset == HD.RESET: str_res = "reset back to normal" else: @@ -822,7 +912,7 @@ def CmdBloodFlowBroadcastIntervalOverride(self, reset, ms): """ - Constructs and sends the measured flow broadcast interval override command + Constructs and sends the measured blood flow 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 @@ -844,7 +934,7 @@ # If there is content... if received_message is not None: - print(received_message) + #print(received_message) if reset == HD.RESET: str_res = "reset back to normal: " else: @@ -857,6 +947,359 @@ print("Timeout!!!!") return False + class HD_DialysateInletFlow: + """ + \class HD_DialysateInletFlow + + \brief Hemodialysis Device (HD) Dialin API sub-class for dialysate inlet pump related commands. + + """ + + # DialysateFlow message IDs + MSG_ID_HD_DIAL_IN_FLOW_PUBLISHED_DATA = 0x0006 + MSG_ID_HD_DIAL_IN_FLOW_SET_RATE_OVERRIDE = 0x8010 + MSG_ID_HD_DIAL_IN_FLOW_MEAS_RATE_OVERRIDE = 0x8011 + MSG_ID_HD_DIAL_IN_PUMP_MC_MEAS_SPEED_OVERRIDE = 0x8012 + MSG_ID_HD_DIAL_IN_PUMP_MC_MEAS_CURRENT_OVERRIDE = 0x8013 + MSG_ID_HD_DIAL_IN_FLOW_PUBLISH_INTERVAL_OVERRIDE = 0x8014 + MSG_ID_HD_DIAL_IN_PUMP_MEAS_SPEED_OVERRIDE = 0x8015 + MSG_ID_HD_DIAL_IN_PUMP_ROTOR_MEAS_SPEED_OVERRIDE = 0x8016 + + # BloodFlow broadcast message field positions + START_POS_SET_PT = DenaliMessage.PAYLOAD_START_INDEX + END_POS_SET_PT = START_POS_SET_PT + 4 + START_POS_MEAS_FLOW = END_POS_SET_PT + END_POS_MEAS_FLOW = START_POS_MEAS_FLOW + 4 + START_POS_MEAS_ROT_SPEED = END_POS_MEAS_FLOW + END_POS_MEAS_ROT_SPEED = START_POS_MEAS_ROT_SPEED + 4 + START_POS_MEAS_SPEED = END_POS_MEAS_ROT_SPEED + END_POS_MEAS_SPEED = START_POS_MEAS_SPEED + 4 + START_POS_MEAS_MC_SPEED = END_POS_MEAS_SPEED + END_POS_MEAS_MC_SPEED = START_POS_MEAS_MC_SPEED + 4 + START_POS_MEAS_MC_CURR = END_POS_MEAS_MC_SPEED + END_POS_MEAS_MC_CURR = START_POS_MEAS_MC_CURR + 4 + START_POS_PWM_DC = END_POS_MEAS_MC_CURR + END_POS_PWM_DC = START_POS_PWM_DC + 4 + + def __init__(self, outer_instance, can_interface=None): + """ + HD_DialysateFlow constructor + + \param outer_instance: reference to the HD (outer) class. + + \returns HD_DialysateFlow 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_DIAL_IN_FLOW_PUBLISHED_DATA + can_interface.registerReceivingPublicationFunction(channel_id, msg_id, + self.handlerDialysateInletFlowSyncFunction) + + self.TargetDialysateInletFlowRate = 0 + self.MeasuredDialysateInletFlowRate = 0.0 + self.MeasuredDialysateInletPumpRotorSpeed = 0.0 + self.MeasuredDialysateInletPumpSpeed = 0.0 + self.MeasuredDialysateInletPumpMCSpeed = 0.0 + self.MeasuredDialysateInletPumpMCCurrent = 0.0 + self.PWMDutyCyclePct = 0.0 + + def handlerDialysateInletFlowSyncFunction(self, message): + """ + Handles published dialysate inlet flow data messages. Dialysate flow data are captured + for reference. + + \param message: published dialysate flow data message + \returns none + """ + + self.TargetDialysateInletFlowRate = int.from_bytes(bytearray( + message['message'][self.START_POS_SET_PT:self.END_POS_SET_PT]), + byteorder=DenaliMessage.BYTE_ORDER) + flow = struct.unpack('f', bytearray( + message['message'][self.START_POS_MEAS_FLOW:self.END_POS_MEAS_FLOW])) + rotor = struct.unpack('f', bytearray( + message['message'][self.START_POS_MEAS_ROT_SPEED:self.END_POS_MEAS_ROT_SPEED])) + speed = struct.unpack('f', bytearray( + message['message'][self.START_POS_MEAS_SPEED:self.END_POS_MEAS_SPEED])) + mcspeed = struct.unpack('f', bytearray( + message['message'][self.START_POS_MEAS_MC_SPEED:self.END_POS_MEAS_MC_SPEED])) + mccurr = struct.unpack('f', bytearray( + message['message'][self.START_POS_MEAS_MC_CURR:self.END_POS_MEAS_MC_CURR])) + pwm = struct.unpack('f', bytearray( + message['message'][self.START_POS_PWM_DC:self.END_POS_PWM_DC])) + + self.MeasuredDialysateInletFlowRate = flow[0] + self.MeasuredDialysateInletPumpRotorSpeed = rotor[0] + self.MeasuredDialysateInletPumpSpeed = speed[0] + self.MeasuredDialysateInletPumpMCSpeed = mcspeed[0] + self.MeasuredDialysateInletPumpMCCurrent = mccurr[0] + self.PWMDutyCyclePct = pwm[0] + + def CmdDialysateInletFlowSetPointOverride(self, reset, flow): + """ + Constructs and sends the dialysate flow set point override command + + \param reset: integer - 1 to reset a previous override, 0 to override + \param flow: integer - flow set point (in mL/min) to override with + \returns 1 if successful, zero otherwise + """ + + rst = self.outer_instance.integer2ByteArray(reset) + flo = self.outer_instance.integer2ByteArray(flow) + payload = rst + flo + + message = DenaliMessage.buildMessage(channel_id=DenaliChannels.dialin_to_hd_ch_id, + message_id=self.MSG_ID_HD_DIAL_IN_FLOW_SET_RATE_OVERRIDE, + payload=payload) + + print("override dialysate flow set point") + + # Send message + received_message = self.outer_instance.can_interface.send(message) + + # If there is content... + if received_message is not None: + #print(received_message) + if reset == HD.RESET: + str_res = "reset back to normal" + else: + str_res = str(flow) + print( + "Dialysate flow set point overridden to " + str_res + " mL/min: " + + 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 CmdDialysateInletFlowMeasuredOverride(self, reset, flow): + """ + Constructs and sends the measured dialysate flow override command + + \param reset: integer - 1 to reset a previous override, 0 to override + \param flow: integer - measured flow (in mL/min) to override with + \returns 1 if successful, zero otherwise + """ + + rst = self.outer_instance.integer2ByteArray(reset) + flo = self.outer_instance.integer2ByteArray(flow) + payload = rst + flo + + message = DenaliMessage.buildMessage(channel_id=DenaliChannels.dialin_to_hd_ch_id, + message_id=self.MSG_ID_HD_DIAL_IN_FLOW_MEAS_RATE_OVERRIDE, + payload=payload) + + print("override measured dialysate flow") + + # Send message + received_message = self.outer_instance.can_interface.send(message) + + # If there is content... + if received_message is not None: + #print(received_message) + if reset == HD.RESET: + str_res = "reset back to normal" + else: + str_res = str(flow) + print("Dialysate flow (measured)) overridden to " + str_res + " mL/min: " + + 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 CmdDialysateInletPumpMCMeasuredSpeedOverride(self, reset, speed): + """ + Constructs and sends the measured dialysate inlet pump motor controller speed \n + override command. + + \param reset: integer - 1 to reset a previous override, 0 to override + \param speed: integer - speed (in RPM) to override with + \returns 1 if successful, zero otherwise + """ + + rst = self.outer_instance.integer2ByteArray(reset) + spd = self.outer_instance.integer2ByteArray(speed) + payload = rst + spd + + message = DenaliMessage.buildMessage(channel_id=DenaliChannels.dialin_to_hd_ch_id, + message_id=self.MSG_ID_HD_DIAL_IN_PUMP_MC_MEAS_SPEED_OVERRIDE, + payload=payload) + + print("override measured dialysate inlet pump motor controller speed") + + # Send message + received_message = self.outer_instance.can_interface.send(message) + + # If there is content... + if received_message is not None: + #print(received_message) + if reset == HD.RESET: + str_res = "reset back to normal" + else: + str_res = str(speed) + print("Dialysate pump MC speed (measured) overridden to " + str_res + " RPM: " + + 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 CmdDialysateInletPumpMeasuredCurrentOverride(self, reset, curr): + """ + Constructs and sends the measured dialysate inlet pump motor current override command + + \param reset: integer - 1 to reset a previous override, 0 to override + \param curr: integer - current (in mA) to override with + \returns 1 if successful, zero otherwise + """ + + rst = self.outer_instance.integer2ByteArray(reset) + cur = self.outer_instance.integer2ByteArray(curr) + payload = rst + cur + + message = DenaliMessage.buildMessage(channel_id=DenaliChannels.dialin_to_hd_ch_id, + message_id=self.MSG_ID_HD_DIAL_IN_PUMP_MC_MEAS_CURRENT_OVERRIDE, + payload=payload) + + print("override measured dialysate inlet pump motor controller current") + + # Send message + received_message = self.outer_instance.can_interface.send(message) + + # If there is content... + if received_message is not None: + #print(received_message) + if reset == HD.RESET: + str_res = "reset back to normal" + else: + str_res = str(curr) + print("Dialysate inlet pump MC current (measured) overridden to " + str_res + " mA: " + + 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 CmdDialysateInletPumpMeasuredSpeedOverride(self, reset, speed): + """ + Constructs and sends the measured dialysate inlet pump motor speed override \n + command. + + \param reset: integer - 1 to reset a previous override, 0 to override + \param speed: integer - speed (in RPM) to override with + \returns 1 if successful, zero otherwise + """ + + rst = self.outer_instance.integer2ByteArray(reset) + spd = self.outer_instance.integer2ByteArray(speed) + payload = rst + spd + + message = DenaliMessage.buildMessage(channel_id=DenaliChannels.dialin_to_hd_ch_id, + message_id=self.MSG_ID_HD_DIAL_IN_PUMP_MEAS_SPEED_OVERRIDE, + payload=payload) + + print("override measured dialysate inlet pump speed") + + # Send message + received_message = self.outer_instance.can_interface.send(message) + + # If there is content... + if received_message is not None: + #print(received_message) + if reset == HD.RESET: + str_res = "reset back to normal" + else: + str_res = str(speed) + print("Dialysate inlet pump speed (measured) overridden to " + str_res + " RPM: " + + 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 CmdDialysateInletPumpRotorMeasuredSpeedOverride(self, reset, speed): + """ + Constructs and sends the measured dialysate inlet pump rotor speed override \n + command. + + \param reset: integer - 1 to reset a previous override, 0 to override + \param speed: integer - speed (in RPM) to override with + \returns 1 if successful, zero otherwise + """ + + rst = self.outer_instance.integer2ByteArray(reset) + spd = self.outer_instance.integer2ByteArray(speed) + payload = rst + spd + + message = DenaliMessage.buildMessage(channel_id=DenaliChannels.dialin_to_hd_ch_id, + message_id=self.MSG_ID_HD_DIAL_IN_PUMP_ROTOR_MEAS_SPEED_OVERRIDE, + payload=payload) + + print("override measured dialysate inlet pump rotor speed") + + # Send message + received_message = self.outer_instance.can_interface.send(message) + + # If there is content... + if received_message is not None: + #print(received_message) + if reset == HD.RESET: + str_res = "reset back to normal" + else: + str_res = str(speed) + print("Dialysate inlet pump rotor speed (measured) overridden to " + str_res + " RPM: " + + 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 CmdDialysateInletFlowBroadcastIntervalOverride(self, reset, ms): + """ + Constructs and sends the measured dialysate inlet flow 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_DIAL_IN_FLOW_PUBLISH_INTERVAL_OVERRIDE, + payload=payload) + + print("override dialysate inlet flow broadcast interval") + + # Send message + received_message = self.outer_instance.can_interface.send(message) + + # If there is content... + if received_message is not None: + #print(received_message) + if reset == HD.RESET: + str_res = "reset back to normal: " + else: + str_res = str(ms) + " ms: " + print("Dialysate inlet flow 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) @@ -927,6 +1370,13 @@ sleep(2) hd._Basics.CmdLogInToHD() + #hd.RTC.CmdSetRTCTimeAndDate(0, 2, 1, 5, 1, 2020) + + while True: + print(hd.RTC.RTCEpoch) + sleep(1) +"""" + hd.BloodFlow.CmdBloodPumpMeasuredCurrentOverride(hd.NO_RESET,149) totalVolumeInMl = 2400 rxTimeInMins = 30 flowRateMlmin = 100 @@ -998,3 +1448,4 @@ print(hd.BloodFlow.MeasuredBloodFlowRate) # hd.BloodFlow.CmdBloodFlowBroadcastIntervalOverride(hd.RESET,0) +"""