Index: dialin/ui/hd_simulator.py =================================================================== diff -u -rb31694e714c45e0678632ab11efbcdcf6dbf6e96 -rdf207aa2b33d777cf082539d8b6547f4e97b5999 --- dialin/ui/hd_simulator.py (.../hd_simulator.py) (revision b31694e714c45e0678632ab11efbcdcf6dbf6e96) +++ dialin/ui/hd_simulator.py (.../hd_simulator.py) (revision df207aa2b33d777cf082539d8b6547f4e97b5999) @@ -1506,54 +1506,7 @@ self.can_interface.send(message, 0) - def cmd_send_general_response(self, message_id, accepted, reason, fromHD = True): - """ - :param message_id: (int) the message id - :param accepted: (int) boolean accept/reject response - :param reason: (int) rejection reason - :return: none - """ - payload = integer_to_bytearray(accepted) - payload += integer_to_bytearray(reason) - message = DenaliMessage.build_message(channel_id= DenaliChannels.hd_to_ui_ch_id if fromHD else DenaliChannels.dg_to_ui_ch_id, - message_id=message_id, - payload=payload) - - self.can_interface.send(message, 0) - - def cmd_send_general_progress_data(self, message_id, total, countdown, fromHD = True): - """ - send the pretreatment filter flush progress data - :param accepted: (U32) Total time in second - :param reason: (U32) count down time in second - :return: None - """ - payload = integer_to_bytearray(total) - payload += integer_to_bytearray(countdown) - - message = DenaliMessage.build_message(channel_id= DenaliChannels.hd_to_ui_ch_id if fromHD else DenaliChannels.dg_to_ui_ch_id, - message_id=message_id, - payload=payload) - - self.can_interface.send(message, 0) - - def cmd_send_pre_treatment_filter_flush_progress_data(self, total, countdown): - """ - send the pretreatment filter flush progress data - :param accepted: (U32) Total time in second - :param reason: (U32) count down time in second - :return: None - """ - payload = integer_to_bytearray(total) - payload += integer_to_bytearray(countdown) - - message = DenaliMessage.build_message(channel_id=DenaliChannels.dg_to_ui_ch_id, - message_id=MsgIds.MSG_ID_DG_FILTER_FLUSH_PROGRESS.value, - payload=payload) - - self.can_interface.send(message, 0) - def cmd_send_pre_treatment_water_sample_response(self, accepted, reason ): """ send the pretreatment water sample response @@ -1685,11 +1638,11 @@ def cmd_send_post_treatment_disposable_removal_confirm_response(self, accepted, reason ): """ - send post treatment disposable removal confirm response - :param accepted: (U32) accept or reject - :param reason: (U32) rejection reason - :return: None - """ + send post treatment disposable removal confirm response + :param accepted: (U32) accept or reject + :param reason: (U32) rejection reason + :return: None + """ payload = integer_to_bytearray(accepted) payload += integer_to_bytearray(reason) @@ -1699,40 +1652,269 @@ self.can_interface.send(message, 0) - def cmd_send_post_treatment_log_response(self, accepted, reason, parameters): + def cmd_send_post_treatment_log_response(self, accepted: bool, reason: int, + bood_flow_rate: int, + dialysate_flow_rate: int, + treatment_duration: int, + actual_treatment_duration: int, + acid_concentrate_type: int, + bicarbonate_concentrate_type: int, + potassium_concentration: int, + calcium_concentration: int, + bicarbonate_concentration: int, + sodium_concentration: int, + dialysate_temperature: float, + dialyzer_type: int, + treatment_date_time: int, + average_blood_flow: float, + average_dialysate_flow: float, + dialysate_volume_used: float, + average_dialysate_temp: float, + target_uf_volume: float, + actual_uf_volume: float, + target_uf_rate: float, + actual_uf_rate: float, + saline_bolus_volume: int, + heparin_type: int, + heparin_concentration: int, + heparin_bolus_volume: float, + heparin_dispense_rate: float, + heparin_pre_stop: int, + heparin_delivered_volume: float, + average_arterial_pressure: float, + average_venous_pressure: float, + end_treatment_early_alarm: int, + device_id: int, + water_sample_test_result: int + ) -> None: """ send post treatment log response - :param accepted: (U32) accept or reject - :param reason: (U32) rejection reason - :param parameters: (array of values) - :return: None + :param accepted: true if accpeted + :param reason: the rejection reason + :param bood_flow_rate: bood flow rate + :param dialysate_flow_rate: dialysate flow rate + :param treatment_duration: treatment duration + :param actual_treatment_duration: actual treatment duration + :param acid_concentrate_type: acid concentrate type + :param bicarbonate_concentrate_type: bicarbonate concentrate type + :param potassium_concentration: potassium concentration + :param calcium_concentration: calcium concentration + :param bicarbonate_concentration: bicarbonate concentration + :param sodium_concentration: sodium concentration + :param dialysate_temperature: dialysate temperature + :param dialyzer_type: dialyzer type + :param treatment_date_time: treatment date time + :param average_blood_flow: average blood flow + :param average_dialysate_flow: average dialysate flow + :param dialysate_volume_used: dialysate volume used + :param average_dialysate_temp: average dialysate temp + :param target_uf_volume: target uf volume + :param actual_uf_volume: actual uf volume + :param target_uf_rate: target uf rate + :param actual_uf_rate: actual uf rate + :param saline_bolus_volume: saline bolus volume + :param heparin_type: heparin type + :param heparin_concentration: heparin concentration + :param heparin_bolus_volume: heparin bolus volume + :param heparin_dispense_rate: heparin dispense rate + :param heparin_pre_stop: heparin pre stop + :param heparin_delivered_volume: heparin delivered volume + :param average_arterial_pressure: average arterial pressure + :param average_venous_pressure: average venous pressure + :param end_treatment_early_alarm: end treatment early alarm + :param device_id: device id + :param water_sample_test_result: water sample test result + :return: """ + payload = integer_to_bytearray(accepted) payload += integer_to_bytearray(reason) - for parameter in parameters: - payload += parameter + payload += unsigned_to_bytearray(int(bood_flow_rate)) + payload += unsigned_to_bytearray(int(dialysate_flow_rate)) + payload += unsigned_to_bytearray(int(treatment_duration)) + payload += unsigned_to_bytearray(int(actual_treatment_duration)) + payload += unsigned_to_bytearray(int(acid_concentrate_type)) + payload += unsigned_to_bytearray(int(bicarbonate_concentrate_type)) + payload += unsigned_to_bytearray(int(potassium_concentration)) + payload += unsigned_to_bytearray(int(calcium_concentration)) + payload += unsigned_to_bytearray(int(bicarbonate_concentration)) + payload += unsigned_to_bytearray(int(sodium_concentration)) + payload += float_to_bytearray(float(dialysate_temperature)) + payload += unsigned_to_bytearray(int(dialyzer_type)) + payload += unsigned_to_bytearray(int(treatment_date_time)) + payload += float_to_bytearray(float(average_blood_flow)) + payload += float_to_bytearray(float(average_dialysate_flow)) + payload += float_to_bytearray(float(dialysate_volume_used)) + payload += float_to_bytearray(float(average_dialysate_temp)) + payload += float_to_bytearray(float(target_uf_volume)) + payload += float_to_bytearray(float(actual_uf_volume)) + payload += float_to_bytearray(float(target_uf_rate)) + payload += float_to_bytearray(float(actual_uf_rate)) + payload += unsigned_to_bytearray(int(saline_bolus_volume)) + payload += unsigned_to_bytearray(int(heparin_type)) + payload += unsigned_to_bytearray(int(heparin_concentration)) + payload += float_to_bytearray(float(heparin_bolus_volume)) + payload += float_to_bytearray(float(heparin_dispense_rate)) + payload += unsigned_to_bytearray(int(heparin_pre_stop)) + payload += float_to_bytearray(float(heparin_delivered_volume)) + payload += float_to_bytearray(float(average_arterial_pressure)) + payload += float_to_bytearray(float(average_venous_pressure)) + payload += unsigned_to_bytearray(int(end_treatment_early_alarm)) + payload += unsigned_to_bytearray(int(device_id)) + payload += unsigned_to_bytearray(int(water_sample_test_result)) message = DenaliMessage.build_message(channel_id=DenaliChannels.hd_to_ui_ch_id, message_id=MsgIds.MSG_ID_HD_TREATMENT_LOG_DATA_RESPONSE.value, payload=payload) self.can_interface.send(message, 0) - def cmd_send_dg_disinfection_state(self, subMode, flushMode, heatMode, chemicalMode): + def cmd_send_treatment_log_data(self, bloodFlowRate: int, dialysateFlowRate: int, ufRate: float, arterialPressure: float, venousPressure: float) -> None: """ - Broadcasts the current DG disinfection mode - :param subMode (int): disinfect states - :param flushMode (int): flush states - :param heatMode (int): heat states - :param ChemicalMode (int): chemical states - :return: + send the treatment log data + :param bloodFlowRate: (U32) blood flow rate + :param dialysateFlowRate: (U32) Dialysate Flow Rate + :param ufRate: (F32) UF Rate + :param arterialPressure: (F32) Arterial Pressure + :param venousPressure: (F32) Venous Pressure + :return: None """ - payload = integer_to_bytearray(subMode) - payload += integer_to_bytearray(flushMode) - payload += integer_to_bytearray(heatMode) - payload += integer_to_bytearray(chemicalMode) + payload = integer_to_bytearray(bloodFlowRate) + payload += integer_to_bytearray(dialysateFlowRate) + payload += float_to_bytearray(ufRate) + payload += float_to_bytearray(arterialPressure) + payload += float_to_bytearray(venousPressure) - message = DenaliMessage.build_message(channel_id=DenaliChannels.dg_sync_broadcast_ch_id, - message_id=MsgIdsDialin.MSG_DIALIN_ID_HD_DISINFECT_STATE.value, + message = DenaliMessage.build_message(channel_id=DenaliChannels.hd_to_ui_ch_id, + message_id=MsgIds.MSG_ID_HD_TREATMENT_LOG_PERIODIC_DATA.value, payload=payload) - self.can_interface.send(message, 0) \ No newline at end of file + + self.can_interface.send(message, 0) + + def cmd_send_treatment_log_alarm(self, alarmID: int, parameter1: float, parameter2: float) -> None: + """ + send the treatment log data + :param alarmID: (U32) alarm ID + :param parameter1: (F32) paramter 1 (it's not clear yet how many paramters with what type is required and this is only plceholder) + :param parameter2: (F32) paramter 2 (it's not clear yet how many paramters with what type is required and this is only plceholder) + :return: None + """ + payload = integer_to_bytearray(alarmID) + payload += float_to_bytearray(parameter1) + payload += float_to_bytearray(parameter2) + + message = DenaliMessage.build_message(channel_id=DenaliChannels.hd_to_ui_ch_id, + message_id=MsgIds.MSG_ID_HD_TREATMENT_LOG_ALARM_EVENT.value, + payload=payload) + + self.can_interface.send(message, 0) + + def cmd_send_treatment_log_event(self, eventID: int, oldValue: float, newValue: float) -> None: + """ + send the treatment log data + :param alarmID: (U32) alarm ID + :param oldValue: (F32) the old value + :param newValue: (F32) the new value + :return: none + """ + payload = integer_to_bytearray(eventID) + payload += float_to_bytearray(oldValue) + payload += float_to_bytearray(newValue) + + message = DenaliMessage.build_message(channel_id=DenaliChannels.hd_to_ui_ch_id, + message_id=MsgIds.MSG_ID_HD_TREATMENT_LOG_EVENT.value, + payload=payload) + + self.can_interface.send(message, 0) + + def cmd_send_hd_disinfect_response(self, accepted: bool, reason: int) -> None: + """ + the HD response to the request from UI to initiate a disinfection/flush + :param accepted: boolean accepted or rejected + :param reason: the rejection reason + :return: None + """ + payload = integer_to_bytearray(accepted) + payload += integer_to_bytearray(reason) + + message = DenaliMessage.build_message(channel_id= DenaliChannels.hd_to_ui_ch_id, + message_id=MsgIds.MSG_ID_HD_DISINFECT_RESPONSE.value, + payload=payload) + + self.can_interface.send(message, 0) + + def cmd_send_hd_disinfect_chemical_confirm(self, accepted: bool, reason: int) -> None: + """ + the HD response to the UI sending the user chimical disinfection steps confirm. + :param accepted: boolean accepted or rejected + :param reason: the rejection reason + :return: None + """ + payload = integer_to_bytearray(accepted) + payload += integer_to_bytearray(reason) + + message = DenaliMessage.build_message(channel_id= DenaliChannels.hd_to_ui_ch_id, + message_id=MsgIds.MSG_ID_HD_CHEM_DISINFECT_CONFIRM_RESPONSE.value, + payload=payload) + + self.can_interface.send(message, 0) + + # ------------------------------------------------ GENERAL MESSAGES ------------------------------------------------ + + def cmd_send_general_hd_response(self, message_id: int, accepted: int, reason: int, + is_pure_data: bool = False, + has_parameters: bool = False, + parameters_payload: any = 0x00) -> None: + """ + a general method to send any standard response message, by it's id and list of paramters. + :param message_id: the id of the message + :param accepted: the standard accepted parameter of any response message + :param reason: the standard rejection reason parameter of any response message + :param has_parameters: if the message has parameter this needs to be true. + :param parameters_payload: the list of parameters pre-converted and ready to be concatenated to the payload. + :return: None + """ + if not is_pure_data: + payload = integer_to_bytearray(accepted) + payload += integer_to_bytearray(reason) + + if has_parameters: + payload += parameters_payload + else: + if has_parameters: + payload = parameters_payload + + message = DenaliMessage.build_message(channel_id= DenaliChannels.hd_to_ui_ch_id, + message_id=message_id, + payload=payload) + + self.can_interface.send(message, 0) + + def cmd_send_general_hd_progress_data(self, message_id: int, total: int, countdown: int) -> None: + """ + a general method t send any standard progress data message, by it's id + :param message_id: the id of the message + :param total: the total value of the progress data + :param countdown: the remaining or countdown value + :return: None + """ + payload = integer_to_bytearray(total) + payload += integer_to_bytearray(countdown) + + message = DenaliMessage.build_message(channel_id= DenaliChannels.hd_to_ui_ch_id, + message_id=message_id, + payload=payload) + + self.can_interface.send(message, 0) + + def cmd_ack_send_hd(self, seq: int) -> None: + """ + sending hd ack message by the sequence seq + :param seq: the message sequence number + :return: None + """ + message = DenaliMessage.build_message(channel_id=DenaliChannels.hd_to_ui_ch_id, + message_id=GuiActionType.Acknow, + seq=seq) + + self.can_interface.send(message, 0)