Index: leahi_dialin/ui/td_messaging.py =================================================================== diff -u -r5ba18a64ff52ea9cc0f46616a44c9f09ea48368e -rd710522ba28b7ea7534904a42940c2c41f3558e4 --- leahi_dialin/ui/td_messaging.py (.../td_messaging.py) (revision 5ba18a64ff52ea9cc0f46616a44c9f09ea48368e) +++ leahi_dialin/ui/td_messaging.py (.../td_messaging.py) (revision d710522ba28b7ea7534904a42940c2c41f3558e4) @@ -326,6 +326,51 @@ self.can_interface.send(message, 0) + + def td_syringePump(self, PumpState : int , + DeliveryState : int , + SetRate : float, + MeasRate : float, + Position : int , + VolumeDelivered : float, + Home : float, + Force : float, + SafetyVolume : float, + Status : int ): + """ + Broadcasts the current TD voltage data (Msg ID: 0x1D, 29) + Args: + @param line_1_2v (float): Processor 1.2V + @param line_3_3v (float): Logic voltage (3.3V) + @param line_logic_5v (float): Logic voltage (5V) + @param line_24v_1 (float): Actuators voltage (24V) + @param line_24v_2 (float): Actuators voltage (24V) + @param fpga_vcc (float): FPGA input voltage (3V) + @param fpga_vaux (float): FPGA aux. voltage (3V) + @param fpga_vpvn (float): FPGA pvn voltage (1V) + @return: None + """ + if not self.can_enabled: + raise ValueError("CAN Interface is not enabled") + + payload = conversions.unsigned_integer_to_bytearray(PumpState ) + payload += conversions.unsigned_integer_to_bytearray(DeliveryState ) + payload += conversions.float_to_bytearray (SetRate ) + payload += conversions.float_to_bytearray (MeasRate ) + payload += conversions.unsigned_integer_to_bytearray(Position ) + payload += conversions.float_to_bytearray (VolumeDelivered ) + payload += conversions.float_to_bytearray (Home ) + payload += conversions.float_to_bytearray (Force ) + payload += conversions.float_to_bytearray (SafetyVolume ) + payload += conversions.unsigned_integer_to_bytearray(Status ) + message = CAN.CanMessage.build_message( + channel_id=CAN.CanChannels.td_sync_broadcast_ch_id, + message_id=msg_ids.MsgIds.MSG_ID_TD_SYRINGE_PUMP_DATA.value, + payload=payload) + + self.can_interface.send(message, 0) + + def td_voltage(self, line_1_2v : float, line_3_3v : float, line_logic_5v : float, @@ -367,6 +412,7 @@ self.can_interface.send(message, 0) + def td_pressure(self, H2_arterial_pressure : float , H14_venous_pressure : float , @@ -428,8 +474,8 @@ self.can_interface.send(message, 0) def td_heparin( self, - target : float , cumulative : float , + target : float , time_remaining : int ): """ Broadcasts the current TD Heparin data (Msg ID: 0xXX, XX) @@ -443,9 +489,9 @@ raise ValueError("CAN Interface is not enabled") - payload = conversions.float_to_bytearray (target ) - payload += conversions.float_to_bytearray (cumulative ) - payload += conversions.unsigned_integer_to_bytearray(time_remaining ) + payload = conversions.float_to_bytearray (cumulative ) + payload += conversions.float_to_bytearray (target ) + payload += conversions.unsigned_integer_to_bytearray(time_remaining ) message = CAN.CanMessage.build_message( channel_id=CAN.CanChannels.td_sync_broadcast_ch_id, @@ -749,25 +795,66 @@ self.can_interface.send(message, 0) - def td_recirculate_progress(self, vTimeout: int, - vCountdown: int): + def td_dry_bicart_disconnect_data(self, vShowDialog : int, + vTotal : int, + vProgress : int, + vDrainInProgress : int, + vDepressurizeInProgress : int): """ rinseback progress message (Msg ID: 0x8F, 143) Args: @param vTimeout : (int) Total Timeout of Recirculate delivery @param vCountdown : (int) Current Timeout count down of Recirculate delivery @return: None """ - payload = conversions.unsigned_integer_to_bytearray (vTimeout ) - payload += conversions.unsigned_integer_to_bytearray (vCountdown ) + payload = conversions.integer_to_bytearray ( vShowDialog ) + payload += conversions.integer_to_bytearray ( vTotal ) + payload += conversions.integer_to_bytearray ( vProgress ) + payload += conversions.integer_to_bytearray ( vDrainInProgress ) + payload += conversions.integer_to_bytearray ( vDepressurizeInProgress ) message = CAN.CanMessage.build_message( channel_id=CAN.CanChannels.td_to_ui_ch_id, + message_id=msg_ids.MsgIds.MSG_ID_TD_DRY_BICARD_DISCONNECT_DATA.value, + payload=payload) + self.can_interface.send(message, 0) + + + def td_recirculate_progress(self, vCountdown: int): + """ + rinseback progress message (Msg ID: 0x8F, 143) + Args: + @param vCountdown : (int) Current Timeout count down of Recirculate delivery + @return: None + """ + payload = conversions.unsigned_integer_to_bytearray (vCountdown ) + + message = CAN.CanMessage.build_message( + channel_id=CAN.CanChannels.td_to_ui_ch_id, message_id=msg_ids.MsgIds.MSG_ID_TD_RECIRCULATE_DATA.value, payload=payload) self.can_interface.send(message, 0) + def td_dry_bicart_cmd_response(self, vAccepted: int, vRejectionReason: int): + """ + rinseback command response message (Msg ID: 0xC6, 145) + Args: + @param vRejectionReason : (int) rejection reason + @return: None + """ + payload = conversions.integer_to_bytearray(vAccepted) + payload += conversions.integer_to_bytearray(vRejectionReason) + + message = CAN.CanMessage.build_message( + channel_id=CAN.CanChannels.td_to_ui_ch_id, + message_id=msg_ids.MsgIds.MSG_ID_TD_DRY_BICARD_DISCONNECT_RESPONSE.value, + payload=payload) + + self.can_interface.send(message, 0) + + + def td_recirculate_cmd_response(self, vAccepted: int, vRejectionReason: int): """ rinseback command response message (Msg ID: 0x99, 145) @@ -1464,7 +1551,7 @@ def td_rinseback_progress(self, vTargetVolume: float, vDeliveredVolume: float, vFlowRate: int, vTimeout: int, - vCountdown: int, vIsCompleted: int): + vCountdown: int, vIsCompleted: int, vIsAllowed: int): """ rinseback progress message (Msg ID: 0x8F, 143) Args: @@ -1482,6 +1569,7 @@ payload += conversions.unsigned_integer_to_bytearray (vTimeout ) payload += conversions.unsigned_integer_to_bytearray (vCountdown ) payload += conversions.integer_to_bytearray (vIsCompleted ) + payload += conversions.integer_to_bytearray (vIsAllowed ) message = CAN.CanMessage.build_message( channel_id=CAN.CanChannels.td_to_ui_ch_id, @@ -1634,6 +1722,24 @@ payload=payload) self.can_interface.send(message, 0) + + def td_patient_connect_confirm_response(self,vRejectionReason: int): + """ + the blood set auto eject response message method(Msg ID: 0xXX, XXX) + Args: + None + @return: None + """ + payload = conversions.integer_to_bytearray(1 if vRejectionReason == 0 else 0) + payload += conversions.integer_to_bytearray(vRejectionReason) + + message = CAN.CanMessage.build_message( + channel_id=CAN.CanChannels.td_to_ui_ch_id, + message_id=msg_ids.MsgIds.MSG_ID_TD_SETUP_CONNECTION_CONFIRM_RESPONSE.value, + payload=payload) + self.can_interface.send(message, 0) + + def td_blood_set_auto_eject_response(self, vAccepted: int, vRejectionReason: int): """ the blood set aito eject response message method(Msg ID: 0xXX, XXX) @@ -2008,6 +2114,7 @@ payload=payload) self.can_interface.send(message, 0) + def td_tx_state(self, sub_mode : int, blood_prime_state : int, @@ -2054,6 +2161,46 @@ self.can_interface.send(message, 0) + def td_pre_tx_state(self, + sub_mode : int, + install_state : int, + self_test_dry_state : int, + prime_state : int, + recirculate_state : int, + confirm_rx_state : int, + heparin_setup_state : int, + patient_connection_state: int) -> None: + """A general method to send any standard response message, by it's id and list of parameters. (Msg ID: 0xB7, 60) + Args: + sub_mode (int): Treatment Submode + install_state (int): Pre-Treatment install_state + self_test_dry_state (int): Pre-Treatment self_test_dry_state + prime_state (int): Pre-Treatment prime_state + recirculate_state (int): Pre-Treatment recirculate_state + confirm_rx_state (int): Pre-Treatment confirm_rx_state + heparin_setup_state (int): Pre-Treatment heparin_setup_state + patient_connection_state (int): Pre-Treatment patient_connection_state + """ + if not self.can_enabled: + raise ValueError("CAN Interface is not enabled") + + payload = conversions.unsigned_integer_to_bytearray(sub_mode ) + payload += conversions.unsigned_integer_to_bytearray(install_state ) + payload += conversions.unsigned_integer_to_bytearray(self_test_dry_state ) + payload += conversions.unsigned_integer_to_bytearray(prime_state ) + payload += conversions.unsigned_integer_to_bytearray(recirculate_state ) + payload += conversions.unsigned_integer_to_bytearray(confirm_rx_state ) + payload += conversions.unsigned_integer_to_bytearray(heparin_setup_state ) + payload += conversions.unsigned_integer_to_bytearray(patient_connection_state ) + + message = CAN.CanMessage.build_message( + channel_id=CAN.CanChannels.td_sync_broadcast_ch_id, + message_id=msg_ids.MsgIds.MSG_ID_TD_PRE_TREATMENT_STATE_DATA.value, + payload=payload) + + self.can_interface.send(message, 0) + + def td_treatment_log_alarm(self, alarm_id: int, parameter1: float, parameter2: float) -> None: """ send the treatment log data @@ -2121,14 +2268,109 @@ payload += conversions.float_to_bytearray(tmpPressure ) payload += conversions.float_to_bytearray(dialysate_temp ) - message = CAN.DenaliMessage.build_message( - channel_id=CAN.DenaliChannels.td_to_ui_ch_id, + message = CAN.CanMessage.build_message( + channel_id=CAN.CanChannels.td_to_ui_ch_id, message_id=msg_ids.MsgIds.MSG_ID_TD_TREATMENT_LOG_AVERAGE_DATA.value, payload=payload) self.can_interface.send(message, 0) + def td_hdf_data(self, HDFState : int, + AutoSubState : int, + reqRate : float, + targetTMP : float, + currentRate : float, + currentTMP : float, + reqVol : float, + totalVol : float, + IsHdfReqState : int) -> None: + """ + send the treatment log data + @param HDFState : (U32) blood flow rate + @param AutoSubState : (U32) dialysate flow rate + @param reqRate : (F32) uf flow rate + @param targetTMP : (F32) arterial Pressure + @param currentRate : (F32) venous Pressure + @param currentTMP : (F32) tmp Pressure + @param reqVol : (F32) dialysate temp + @param totalVol : (F32) dialysate temp + @param IsHdfReqState : (U32) dialysate temp + @return: none + """ + payload = conversions.integer_to_bytearray(HDFState ) + payload += conversions.integer_to_bytearray(AutoSubState ) + payload += conversions.float_to_bytearray (reqRate ) + payload += conversions.float_to_bytearray (targetTMP ) + payload += conversions.float_to_bytearray (currentRate ) + payload += conversions.float_to_bytearray (currentTMP ) + payload += conversions.float_to_bytearray (reqVol ) + payload += conversions.float_to_bytearray (totalVol ) + payload += conversions.integer_to_bytearray(IsHdfReqState ) + + message = CAN.CanMessage.build_message( + channel_id=CAN.CanChannels.td_to_ui_ch_id, + message_id=msg_ids.MsgIds.MSG_ID_TD_HEMODIAFILTRATION_DATA.value, + payload=payload) + + self.can_interface.send(message, 0) + + + def td_hdf_state_cmd_response(self, vAccepted: int, vRejectionReason: int): + """ + rinseback command response message (Msg ID: 0x99, 145) + Args: + @param vRejectionReason : (int) rejection reason + @return: None + """ + payload = conversions.integer_to_bytearray(vAccepted) + payload += conversions.integer_to_bytearray(vRejectionReason) + + message = CAN.CanMessage.build_message( + channel_id=CAN.CanChannels.td_to_ui_ch_id, + message_id=msg_ids.MsgIds.MSG_ID_TD_PAUSE_SUB_FLOW_RESPONSE.value, + payload=payload) + + self.can_interface.send(message, 0) + + + def td_auto_sub_state_response(self, vAccepted: int, vRejectionReason: int): + """ + rinseback command response message (Msg ID: 0x99, 145) + Args: + @param vRejectionReason : (int) rejection reason + @return: None + """ + payload = conversions.integer_to_bytearray(vAccepted) + payload += conversions.integer_to_bytearray(vRejectionReason) + + message = CAN.CanMessage.build_message( + channel_id=CAN.CanChannels.td_to_ui_ch_id, + message_id=msg_ids.MsgIds.MSG_ID_TD_AUTO_SUBSTITUTION_REPONSE.value, + payload=payload) + + self.can_interface.send(message, 0) + + + def td_hdf_adjust_response(self, vAccepted: int, vTxModeRejectionReason: int, vFluidVOlumeRejectionReason: int): + """ + rinseback command response message (Msg ID: 0x99, 145) + Args: + @param vRejectionReason : (int) rejection reason + @return: None + """ + payload = conversions.integer_to_bytearray(vAccepted ) + payload += conversions.integer_to_bytearray(vTxModeRejectionReason ) + payload += conversions.integer_to_bytearray(vFluidVOlumeRejectionReason ) + + message = CAN.CanMessage.build_message( + channel_id=CAN.CanChannels.td_to_ui_ch_id, + message_id=msg_ids.MsgIds.MSG_ID_TD_HDF_ADJUSTMENT_RESPONSE.value, + payload=payload) + + self.can_interface.send(message, 0) + + def cmd_send_general_response(self, message_id: int, accepted: int, reason: int, is_pure_data: bool = False, has_parameters: bool = False,