Index: dialin/common/alarm_defs.py =================================================================== diff -u -r8a4783c11ec826a2b84480ffb6b033edcac12954 -r46342bac3e23428e90666525bb5a89c4532da945 --- dialin/common/alarm_defs.py (.../alarm_defs.py) (revision 8a4783c11ec826a2b84480ffb6b033edcac12954) +++ dialin/common/alarm_defs.py (.../alarm_defs.py) (revision 46342bac3e23428e90666525bb5a89c4532da945) @@ -1,34 +1,23 @@ ########################################################################### # -# Copyright (c) 2019-2020 Diality Inc. - All Rights Reserved. +# Copyright (c) 2019-2021 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 alarm_defs.py # -# @author (last) Sean Nash -# @date (last) 03-Nov-2020 +# @author (last) Peter Lucia +# @date (last) 04-Jun-2021 # @author (original) Peter Lucia -# @date (original) 07-Aug-2020 +# @date (original) 04-Jun-2021 # ############################################################################ -import os from enum import unique -from ..utils.base import AlarmEnum, DialinEnum +from ..utils.base import AlarmEnum -enum_list = {} -with open(os.path.join(os.path.dirname(__file__), 'AlarmIds.txt'), 'r') as file_obj: - for line in file_obj: - split_str = line.split('=') - enum_list[split_str[0].strip()] = split_str[1].strip() -AlarmList = AlarmEnum('AlarmList', enum_list) - +# Branch: staging @unique -class AlarmPriorities(DialinEnum): - ALARM_PRIORITY_NONE = 0 # Indicates not an alarm or no alarms active at this time - ALARM_PRIORITY_LOW = 1 # Low priority alarm - 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 AlarmList(AlarmEnum): + ALARM_ID_NO_ALARM = 0 Index: dialin/common/msg_ids.py =================================================================== diff -u -r0514a69831286e4727429f57e046f71e73e78110 -r46342bac3e23428e90666525bb5a89c4532da945 --- dialin/common/msg_ids.py (.../msg_ids.py) (revision 0514a69831286e4727429f57e046f71e73e78110) +++ dialin/common/msg_ids.py (.../msg_ids.py) (revision 46342bac3e23428e90666525bb5a89c4532da945) @@ -8,9 +8,9 @@ # @file msg_ids.py # # @author (last) Peter Lucia -# @date (last) 24-May-2021 +# @date (last) 04-Jun-2021 # @author (original) Peter Lucia -# @date (original) 24-May-2021 +# @date (original) 04-Jun-2021 # ############################################################################ from enum import unique @@ -174,6 +174,8 @@ MSG_ID_UI_ACTIVE_ALARMS_LIST_REQUEST = 0X97 MSG_ID_HD_ACTIVE_ALARMS_LIST_REQUEST_RESPONSE = 0X98 MSG_ID_HD_SERIAL_NUMBER = 0X99 + MSG_ID_DG_CHEM_DISINFECT_TO_UI_DATA_PUBLISH = 0X9A + MSG_ID_DG_HEAT_DISINFECT_TO_UI_DATA_PUBLISH = 0X9B MSG_ID_CAN_ERROR_COUNT = 0X999 MSG_ID_TESTER_LOGIN_REQUEST = 0X8000 MSG_ID_DIAL_OUT_FLOW_SET_PT_OVERRIDE = 0X8001 @@ -332,6 +334,7 @@ MSG_ID_DG_FLUID_LEAK_SEND_INTERVAL_OVERRIDE = 0XA03F MSG_ID_DG_FLUID_LEAK_STATE_DETECTOR_OVERRIDE = 0XA040 MSG_ID_DG_FLUSH_PUBLISH_INTERVAL_OVERRIDE = 0XA041 + MSG_ID_FILTER_FLUSH_TIME_PERIOD_OVERRIDE = 0XA042 MSG_ID_HD_DEBUG_EVENT = 0XFFF1 MSG_ID_DG_DEBUG_EVENT = 0XFFF2 MSG_ID_ACK_MESSAGE_THAT_REQUIRES_ACK = 0XFFFF Index: dialin/common/ui_defs.py =================================================================== diff -u -rbe687b87ec7dbbb312fc9dc67fd422119e43e64c -r46342bac3e23428e90666525bb5a89c4532da945 --- dialin/common/ui_defs.py (.../ui_defs.py) (revision be687b87ec7dbbb312fc9dc67fd422119e43e64c) +++ dialin/common/ui_defs.py (.../ui_defs.py) (revision 46342bac3e23428e90666525bb5a89c4532da945) @@ -71,6 +71,10 @@ AcknowGeneric = 0 # Generic Acknowledgment is not a unique message ID and inherits its Id from the actual message. Zero is a placeholder +class GuiActionTypeLength: + TREATMENT_LOG_LENGTH = 33 + + class TXStates: # Sub Mode TREATMENT_START_STATE = 0 # Start treatment - initialize treatment and go to blood prime state Index: dialin/ui/dg_simulator.py =================================================================== diff -u -r6b8fcf58c046f2177d120544922c3f49449bb88f -r46342bac3e23428e90666525bb5a89c4532da945 --- dialin/ui/dg_simulator.py (.../dg_simulator.py) (revision 6b8fcf58c046f2177d120544922c3f49449bb88f) +++ dialin/ui/dg_simulator.py (.../dg_simulator.py) (revision 46342bac3e23428e90666525bb5a89c4532da945) @@ -510,3 +510,143 @@ msg = messageBuilder.buildMessage(GuiActionType.DGDebugText, 1 * (message_length + 1), False, txt) return messageBuilder.toFrames(msg) + 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_dg_disinfection_state(self, subMode, flushMode, heatMode, chemicalMode): + """ + 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: + """ + payload = integer_to_bytearray(subMode) + payload += integer_to_bytearray(flushMode) + payload += integer_to_bytearray(heatMode) + payload += integer_to_bytearray(chemicalMode) + + message = DenaliMessage.build_message(channel_id=DenaliChannels.dg_sync_broadcast_ch_id, + message_id=MsgIdsDialin.MSG_DIALIN_ID_HD_DISINFECT_STATE.value, + payload=payload) + self.can_interface.send(message, 0) + + def cmd_send_dg_disinfect_progress_time_flush(self, total: int, countdown: int) -> None: + """ + the broadcast progress water flush time + :param total: the total time + :param countdown: the gradual countdown time + :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_FLUSH_TIME_DATA.value, + payload=payload) + + self.can_interface.send(message, 0) + + def cmd_send_dg_disinfect_progress_time_heat(self, total: int, countdown: int) -> None: + """ + the broadcast progress heat disinfect time + :param total: the total time + :param countdown: the gradual countdown time + :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_HEAT_DISINFECT_TIME_DATA.value, + payload=payload) + + self.can_interface.send(message, 0) + + def cmd_send_dg_disinfect_progress_time_checmical(self, total: int, countdown: int) -> None: + """ + the broadcast progress chemical disinfect time + :param total: the total time + :param countdown: the gradual countdown time + :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_CHEM_DISINFECT_TIME_DATA.value, + payload=payload) + + self.can_interface.send(message, 0) + + def cmd_send_general_dg_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.dg_to_ui_ch_id, + message_id=message_id, + payload=payload) + + self.can_interface.send(message, 0) + + def cmd_send_general_dg_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.dg_to_ui_ch_id, + message_id=message_id, + payload=payload) + + self.can_interface.send(message, 0) + + def cmd_ack_send_dg(self, seq: int) -> None: + """ + sending dg ack message by the sequence seq + :param seq: the message sequence number + :return: None + """ + message = DenaliMessage.build_message(channel_id=DenaliChannels.dg_to_ui_ch_id, + message_id=GuiActionType.Acknow, + seq=seq) + + self.can_interface.send(message, 0) Index: dialin/ui/hd_simulator.py =================================================================== diff -u -r0514a69831286e4727429f57e046f71e73e78110 -r46342bac3e23428e90666525bb5a89c4532da945 --- dialin/ui/hd_simulator.py (.../hd_simulator.py) (revision 0514a69831286e4727429f57e046f71e73e78110) +++ dialin/ui/hd_simulator.py (.../hd_simulator.py) (revision 46342bac3e23428e90666525bb5a89c4532da945) @@ -1504,54 +1504,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 @@ -1683,11 +1636,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) @@ -1697,40 +1650,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) Index: dialin/ui/hd_simulator_alarms.py =================================================================== diff -u -rb20262631dc86edf5c3550762bc888089fa2626d -r46342bac3e23428e90666525bb5a89c4532da945 --- dialin/ui/hd_simulator_alarms.py (.../hd_simulator_alarms.py) (revision b20262631dc86edf5c3550762bc888089fa2626d) +++ dialin/ui/hd_simulator_alarms.py (.../hd_simulator_alarms.py) (revision 46342bac3e23428e90666525bb5a89c4532da945) @@ -25,6 +25,7 @@ from ..utils.conversions import integer_to_bytearray, integer_to_bit_array, float_to_bytearray from ..common.msg_defs import MsgIds, MsgFieldPositions from ..common.alarm_defs import AlarmList +from dialin.common.prs_defs import Alarm_Data_Types HIGH = 3 MED = 2 @@ -359,7 +360,8 @@ self.can_interface.send(message, 0) - def cmd_set_alarm_triggered(self, alarm_id): + def cmd_set_alarm_triggered(self, alarm_id,field_descriptor_1: int, data_field_1: str, + field_descriptor_2: int, data_field_2: str) -> None: """ Triggers an alarm. @@ -370,7 +372,30 @@ @param alarm_id: int, the alarm id to trigger @return: None """ + zero = integer_to_bytearray(0) payload = integer_to_bytearray(alarm_id) + if (field_descriptor_1 == Alarm_Data_Types.ALARM_DATA_TYPE_NONE): + payload += zero + payload += zero + payload += zero + payload += zero + else: + if (field_descriptor_1 == Alarm_Data_Types.ALARM_DATA_TYPE_F32): + payload += integer_to_bytearray(field_descriptor_1) + payload += float_to_bytearray(float(data_field_1)) + else: # BOOL, S32, U32 + payload += integer_to_bytearray(field_descriptor_1) + payload += integer_to_bytearray(int(data_field_1)) + if (field_descriptor_2 == Alarm_Data_Types.ALARM_DATA_TYPE_NONE): + payload += zero + payload += zero + else: + if (field_descriptor_2 == Alarm_Data_Types.ALARM_DATA_TYPE_F32): + payload += integer_to_bytearray(field_descriptor_2) + payload += float_to_bytearray(float(data_field_2)) + else: # BOOL, S32, U32 + payload += integer_to_bytearray(field_descriptor_2) + payload += integer_to_bytearray(int(data_field_2)) message = DenaliMessage.build_message(channel_id=DenaliChannels.hd_alarm_broadcast_ch_id, message_id=MsgIds.MSG_ID_ALARM_TRIGGERED.value, @@ -466,3 +491,40 @@ if self.clear_after_user_action: self.cmd_send_clear_alarms() + def cmd_send_active_list_response(self, accept: bool, reason: int=0, + a0: int=0, a1: int=0, a2: int=0, a3: int=0, a4: int=0, + a5: int=0, a6: int=0, a7: int=0, a8: int=0, a9: int=0) -> None: + """ + send the list of active alarms + :param accept: boolean value true if the request accepted + :param reason: the rejection reason + :param a0: alarm id 0 in the list - First + :param a1: alarm id 1 in the list + :param a2: alarm id 2 in the list + :param a3: alarm id 3 in the list + :param a4: alarm id 4 in the list + :param a5: alarm id 5 in the list + :param a6: alarm id 6 in the list + :param a7: alarm id 7 in the list + :param a8: alarm id 8 in the list + :param a9: alarm id 9 in the list - Last + :return: + """ + payload = integer_to_bytearray(accept) + payload += integer_to_bytearray(reason) + payload += integer_to_bytearray(a0) + payload += integer_to_bytearray(a1) + payload += integer_to_bytearray(a2) + payload += integer_to_bytearray(a3) + payload += integer_to_bytearray(a4) + payload += integer_to_bytearray(a5) + payload += integer_to_bytearray(a6) + payload += integer_to_bytearray(a7) + payload += integer_to_bytearray(a8) + payload += integer_to_bytearray(a9) + + message = DenaliMessage.build_message(channel_id=DenaliChannels.hd_to_ui_ch_id, + message_id=MsgIds.MSG_ID_HD_ACTIVE_ALARMS_LIST_REQUEST_RESPONSE.value, + payload=payload) + + self.can_interface.send(message, 0)