Index: leahi_dialin/td/modules/treatment.py =================================================================== diff -u -r0ca34ba27790b8aeb6c368190cc770ca3f345184 -r1f2bf6d939eb4033dbedb7d7005494cc12fccbc6 --- leahi_dialin/td/modules/treatment.py (.../treatment.py) (revision 0ca34ba27790b8aeb6c368190cc770ca3f345184) +++ leahi_dialin/td/modules/treatment.py (.../treatment.py) (revision 1f2bf6d939eb4033dbedb7d7005494cc12fccbc6) @@ -7,147 +7,131 @@ # # @file treatment.py # -# @author (last) Michael Garthwaite -# @date (last) 22-Apr-2025 +# @author (last) Zoltan Miskolci +# @date (last) 05-May-2026 # @author (original) Michael Garthwaite # @date (original) 22-Apr-2025 # ############################################################################ -import struct + +# Module imports from logging import Logger -from enum import unique -from .constants import RESET, NO_RESET -from leahi_dialin.common.msg_defs import MsgIds, MsgFieldPositions -from leahi_dialin.protocols.CAN import DenaliMessage, DenaliChannels -from leahi_dialin.utils.base import AbstractSubSystem, publish, DialinEnum -from leahi_dialin.utils.checks import check_broadcast_interval_override_ms +# Project imports +from leahi_dialin.common.constants import NO_RESET +from leahi_dialin.common.generic_defs import DataTypes +from leahi_dialin.common.msg_defs import MsgIds +from leahi_dialin.common.override_templates import cmd_generic_override +from leahi_dialin.common import td_enum_repository +from leahi_dialin.protocols.CAN import CanMessenger, CanChannels +from leahi_dialin.utils.abstract_classes import AbstractSubSystem +from leahi_dialin.utils.base import publish from leahi_dialin.utils.conversions import integer_to_bytearray, float_to_bytearray -@unique -class TDTreatmentParameters(DialinEnum): - TREATMENT_PARAM_BLOOD_FLOW = 0 # Blood flow rate (in mL/min) - TREATMENT_PARAM_DIALYSATE_FLOW = 1 # Dialysate flow rate (in mL/min) - TREATMENT_PARAM_TREATMENT_DURATION = 2 # Treatment duration (in minutes) - TREATMENT_PARAM_SALINE_BOLUS_VOLUME = 3 # Saline bolus volume (in mL) - TREATMENT_PARAM_HEPARIN_STOP_TIME = 4 # Heparin stop time (in minutes) - TREATMENT_PARAM_HEPARIN_TYPE = 5 # Heparin type (enum) - TREATMENT_PARAM_ACID_CONCENTRATE = 6 # Acid concentrate type (enum) - TREATMENT_PARAM_BICARB_CONCENTRATE = 7 # Bicarbonate concentrate type (enum) - TREATMENT_PARAM_DIALYZER_TYPE = 8 # Dialysate type (enum) - TREATMENT_PARAM_BP_MEAS_INTERVAL = 9 # Blood pressure measurement interval (in minutes) - TREATMENT_PARAM_RINSEBACK_FLOW_RATE = 10 # Rinseback flow rate (in mL/min) - TREATMENT_PARAM_RINSEBACK_VOLUME = 11 # Rinseback volume (in mL) - TREATMENT_PARAM_ART_PRES_LIMIT_WINDOW = 12 # Arterial pressure alarm limit window (in mmHg) - TREATMENT_PARAM_VEN_PRES_LIMIT_WINDOW = 13 # Venous pressure alarm limit window (in mmHg) - TREATMENT_PARAM_VEN_PRES_LIMIT_ASYMMETRIC = 14 # Venous pressure alarm limit asymmetric (in mmHg) - TREATMENT_PARAM_TMP_PRES_LIMIT_WINDOW = 15 # TMP alarm limit window (in mmHg) - TREATMENT_PARAM_DIALYSATE_TEMPERATURE = 16 # Dialysate temperature (in degC) - TREATMENT_PARAM_HEPARIN_DISPENSE_RATE = 17 # Heparin dispense rate (in mL/hr) - TREATMENT_PARAM_HEPARIN_BOLUS_VOLUME = 18 # Heparin bolus volume (in mL) - TREATMENT_PARAM_UF_VOLUME = 19 # Ultrafiltration volume (in liters) - provided separately by UI - NUM_OF_TREATMENT_PARAMS = 20 # Total number of treatment parameters - class TDTreatment(AbstractSubSystem): """ Treatment Delivery (TD) Dialin API sub-class for treatment related commands. """ - def __init__(self, can_interface, logger: Logger): + def __init__(self, can_interface: CanMessenger, logger: Logger): """ TDTreatment constructor - """ super().__init__() self.can_interface = can_interface self.logger = logger if self.can_interface is not None: - channel_id = DenaliChannels.td_sync_broadcast_ch_id - msg_id = MsgIds.MSG_ID_TD_TREATMENT_PARAM_RANGES.value - self.can_interface.register_receiving_publication_function(channel_id, msg_id, - self._handler_treatment_param_ranges_sync) - msg_id = MsgIds.MSG_ID_TD_SALINE_BOLUS_DATA.value - self.can_interface.register_receiving_publication_function(channel_id, msg_id, - self._handler_saline_bolus_sync) - msg_id = MsgIds.MSG_ID_TD_ULTRAFILTRATION_DATA.value - self.can_interface.register_receiving_publication_function(channel_id, msg_id, - self._handler_uf_sync) - msg_id = MsgIds.MSG_ID_TD_TREATMENT_TIME_DATA.value - self.can_interface.register_receiving_publication_function(channel_id, msg_id, - self._handler_treatment_time_sync) - msg_id = MsgIds.MSG_ID_TD_TREATMENT_STATE_DATA.value - self.can_interface.register_receiving_publication_function(channel_id, msg_id, - self._handler_treatment_state_sync) - msg_id = MsgIds.MSG_ID_TD_RSP_CURRENT_TREATMENT_PARAMETERS.value - self.can_interface.register_receiving_publication_function(channel_id, msg_id, - self._handler_resp_treatment_parameters_sync) + self.can_interface.register_receiving_publication_function(channel_id = CanChannels.td_sync_broadcast_ch_id, + message_id = MsgIds.MSG_ID_TD_TREATMENT_PARAM_RANGES.value, + function = self._handler_treatment_param_ranges_sync) + self.can_interface.register_receiving_publication_function(channel_id = CanChannels.td_sync_broadcast_ch_id, + message_id = MsgIds.MSG_ID_TD_SALINE_BOLUS_DATA.value, + function = self._handler_saline_bolus_sync) + + self.can_interface.register_receiving_publication_function(channel_id = CanChannels.td_sync_broadcast_ch_id, + message_id = MsgIds.MSG_ID_TD_ULTRAFILTRATION_DATA.value, + function = self._handler_uf_sync) + + self.can_interface.register_receiving_publication_function(channel_id = CanChannels.td_sync_broadcast_ch_id, + message_id = MsgIds.MSG_ID_TD_TREATMENT_TIME_DATA.value, + function = self._handler_treatment_time_sync) + + self.can_interface.register_receiving_publication_function(channel_id = CanChannels.td_sync_broadcast_ch_id, + message_id = MsgIds.MSG_ID_TD_TREATMENT_STATE_DATA.value, + function = self._handler_treatment_state_sync) + + self.can_interface.register_receiving_publication_function(channel_id = CanChannels.td_sync_broadcast_ch_id, + message_id = MsgIds.MSG_ID_TD_RSP_CURRENT_TREATMENT_PARAMETERS.value, + function = self._handler_resp_treatment_parameters_sync) + # Treatment param ranges data - self.min_tx_time = 0 - self.max_tx_time = 0 - self.min_uf_volume = 0.0 - self.max_uf_volume = 0.0 - self.min_dial_rate = 0 - self.max_dial_rate = 0 - self.tx_params_timestamp = 0 + self.min_tx_time = 0 #: Minimum Treatment time + self.max_tx_time = 0 #: Maximum Treatment time + self.min_uf_volume = 0.0 #: Minimum Ultrafiltration volume + self.max_uf_volume = 0.0 #: Maximum Ultrafiltration volume + self.min_dial_rate = 0 #: Minimum Dialysate rate + self.max_dial_rate = 0 #: Maximum Dialysate rate + self.tx_params_timestamp = 0 #: The timestamp of the latest Treatment Parameters message # Saline Bolus data - self.tgt_saline_volume = 0 # in mL - self.cum_saline_volume = 0.0 # in mL - self.bol_saline_volume = 0.0 # in mL - self.saline_bolus_state = 0 - self.saline_bolus_timestamp = 0 + self.tgt_saline_volume = 0 #: Target Saline Bolus volume in mL + self.cum_saline_volume = 0.0 #: Cum Saline Bolus volume in mL + self.bol_saline_volume = 0.0 #: Bol Saline Bolus volume in mL + self.saline_bolus_state = 0 #: The State of the Saline Bolus + self.saline_bolus_timestamp = 0 #: The timestamp of the latest Saline Bolus message # UF data - self.set_uf_volume = 0.0 # in L - self.tgt_uf_rate = 0.0 # in L/hr - self.uf_volume_delivered = 0.0 # in L - self.uf_state = 0 - self.uf_timestamp = 0 + self.set_uf_volume = 0.0 #: The Ultrafiltration volume in L + self.tgt_uf_rate = 0.0 #: The Ultrafiltration rate in L/hr + self.uf_volume_delivered = 0.0 #: How much was delivered during Ultrafiltration in L + self.uf_state = 0 #: The State of the Ultrafiltration + self.uf_timestamp = 0 #: The timestamp of the latest Ultrafiltration message # Treatment Time Data - self.tx_time_prescribed = 0 - self.tx_time_elapsed = 0 - self.tx_time_remaining = 0 - self.tx_time_timestamp = 0 + self.tx_time_prescribed = 0 #: Total Treatment duration + self.tx_time_elapsed = 0 #: How much time is elapsed in the Treatment + self.tx_time_remaining = 0 #: How much time is remaining from the Treatment + self.tx_time_timestamp = 0 #: The timestamp of the latest Treatment message # Treatment State Data - self.tx_sub_mode = 0 - self.blood_prime_state = 0 - self.dialysis_state = 0 - self.isolated_uf_state = 0 - self.tx_stop_state = 0 - self.rinseback_state = 0 - self.tx_recirc_state = 0 - self.tx_end_state = 0 - self.tx_state_timestamp = 0 + self.tx_sub_mode = 0 #: The Treatment Operation Sub-Mode + self.blood_prime_state = 0 #: The Blood Prime Operation Sub-Mode + self.dialysis_state = 0 #: The Dialysis Operation Sub-Mode + self.isolated_uf_state = 0 #: The Isolated Ultrafiltration Operation Sub-Mode + self.tx_stop_state = 0 #: The Treatment Stop Operation Sub-Mode + self.rinseback_state = 0 #: The Rinsback Operation Sub-Mode + self.tx_recirc_state = 0 #: The Recirculation Operation Sub-Mode + self.tx_end_state = 0 #: The Treatment End Operation Sub-Mode + self.tx_state_timestamp = 0 #: The timestamp of the latest Treatment State message # Treatment Parameters Data. Most recent response. - self.blood_flow_rate = 0 - self.dialysate_flow_rate = 0 - self.tx_duration = 0 - self.saline_bolus_volume = 0 - self.hep_stop_time = 0 - self.hep_time = 0 - self.acid_con = 0 - self.bicarb_con = 0 - self.dialyzer_type = 0 - self.bp_interval = 0 - self.rb_flow_rate = 0 - self.rb_volume = 0 - self.art_pressure_window = 0 - self.venous_pressure_window = 0 - self.venous_asymm_window = 0 - self.tmp_limit_window = 0 - self.dialysate_temp = 0.0 - self.hep_dispense_rate = 0.0 - self.hep_bolus_vol = 0.0 - self.uf_vol = 0.0 - self.tx_param_req_timestamp = 0 + self.blood_flow_rate = 0 #: The Blood flow rate + self.dialysate_flow_rate = 0 #: The Dialysate flow rate + self.tx_duration = 0 #: The Treatment duration + self.saline_bolus_volume = 0 #: The Saline Bolus volume + self.hep_stop_time = 0 #: The Heparin stop time + self.hep_time = 0 #: The Heparin start time + self.acid_con = 0 #: The selected Acid concentrate's option index + self.bicarb_con = 0 #: The selected Bicarb concentrate's option index + self.dialyzer_type = 0 #: The selected Dialyser option index + self.bp_interval = 0 #: The Body Pulse interval + self.rb_flow_rate = 0 #: The RB flow rate + self.rb_volume = 0 #: The RB volume + self.art_pressure_window = 0 #: The Artery pressure window duration + self.venous_pressure_window = 0 #: The Venous pressure window duration + self.venous_asymm_window = 0 #: The Venous asymmetric window duration + self.tmp_limit_window = 0 #: The Transmembrane limit window duration + self.dialysate_temp = 0.0 #: The Dialysate temperature + self.hep_dispense_rate = 0.0 #: The Heparin dispense rate + self.hep_bolus_vol = 0.0 #: The Heparin bolus volume + self.uf_vol = 0.0 #: The Ultrafiltration volume + self.tx_param_req_timestamp = 0 #: The timestamp of the latest Treatment Parameters Request message - @publish(["min_tx_time","max_tx_time","min_uf_volume","max_uf_volume", + + @publish(["msg_id_td_treatment_param_ranges", "min_tx_time","max_tx_time","min_uf_volume","max_uf_volume", "min_dial_rate","max_dial_rate","tx_params_timestamp"]) def _handler_treatment_param_ranges_sync(self, message, timestamp=0.0): """ @@ -156,23 +140,20 @@ @param message: published treatment parameter range data message @return: none """ + msg_list = [] + msg_list.append(['self.min_tx_time', DataTypes.U32]) + msg_list.append(['self.max_tx_time', DataTypes.U32]) + msg_list.append(['self.min_uf_volume', DataTypes.F32]) + msg_list.append(['self.max_uf_volume', DataTypes.F32]) + msg_list.append(['self.min_dial_rate', DataTypes.U32]) + msg_list.append(['self.max_dial_rate', DataTypes.U32]) - self.min_tx_time = struct.unpack('i', bytearray( - message['message'][MsgFieldPositions.START_POS_FIELD_1:MsgFieldPositions.END_POS_FIELD_1]))[0] - self.max_tx_time = struct.unpack('i', bytearray( - message['message'][MsgFieldPositions.START_POS_FIELD_2:MsgFieldPositions.END_POS_FIELD_2]))[0] - self.min_uf_volume = struct.unpack('f', bytearray( - message['message'][MsgFieldPositions.START_POS_FIELD_3:MsgFieldPositions.END_POS_FIELD_3]))[0] - self.max_uf_volume = struct.unpack('f', bytearray( - message['message'][MsgFieldPositions.START_POS_FIELD_4:MsgFieldPositions.END_POS_FIELD_4]))[0] - self.min_dial_rate = struct.unpack('i', bytearray( - message['message'][MsgFieldPositions.START_POS_FIELD_5:MsgFieldPositions.END_POS_FIELD_5]))[0] - self.max_dial_rate = struct.unpack('i', bytearray( - message['message'][MsgFieldPositions.START_POS_FIELD_6:MsgFieldPositions.END_POS_FIELD_6]))[0] - + self.process_into_vars(decoder_list = msg_list, + message = message) self.tx_params_timestamp = timestamp - @publish(["tgt_saline_volume","cum_saline_volume","bol_saline_volume", + + @publish(["msg_id_td_saline_bolus_data", "tgt_saline_volume","cum_saline_volume","bol_saline_volume", "saline_bolus_state","saline_bolus_timestamp"]) def _handler_saline_bolus_sync(self, message, timestamp=0.0): """ @@ -181,19 +162,18 @@ @param message: published saline bolus data message @return: none """ + msg_list = [] + msg_list.append(['self.tgt_saline_volume', DataTypes.U32]) + msg_list.append(['self.cum_saline_volume', DataTypes.F32]) + msg_list.append(['self.bol_saline_volume', DataTypes.F32]) + msg_list.append(['self.saline_bolus_state', DataTypes.U32]) - self.tgt_saline_volume = struct.unpack('i', bytearray( - message['message'][MsgFieldPositions.START_POS_FIELD_1:MsgFieldPositions.END_POS_FIELD_1]))[0] - self.cum_saline_volume = struct.unpack('f', bytearray( - message['message'][MsgFieldPositions.START_POS_FIELD_2:MsgFieldPositions.END_POS_FIELD_2]))[0] - self.bol_saline_volume = struct.unpack('f', bytearray( - message['message'][MsgFieldPositions.START_POS_FIELD_3:MsgFieldPositions.END_POS_FIELD_3]))[0] - self.saline_bolus_state = struct.unpack('i', bytearray( - message['message'][MsgFieldPositions.START_POS_FIELD_4:MsgFieldPositions.END_POS_FIELD_4]))[0] - + self.process_into_vars(decoder_list = msg_list, + message = message) self.saline_bolus_timestamp = timestamp - @publish(["set_uf_volume","tgt_uf_rate","uf_volume_delivered", + + @publish(["msg_id_td_uf_data", "set_uf_volume","tgt_uf_rate","uf_volume_delivered", "uf_state","uf_timestamp"]) def _handler_uf_sync(self, message, timestamp=0.0): """ @@ -202,19 +182,18 @@ @param message: published ultrafiltration data message @return: none """ + msg_list = [] + msg_list.append(['self.set_uf_volume', DataTypes.F32]) + msg_list.append(['self.tgt_uf_rate', DataTypes.F32]) + msg_list.append(['self.uf_volume_delivered', DataTypes.F32]) + msg_list.append(['self.uf_state', DataTypes.U32]) - self.set_uf_volume = struct.unpack('f', bytearray( - message['message'][MsgFieldPositions.START_POS_FIELD_1:MsgFieldPositions.END_POS_FIELD_1]))[0] - self.tgt_uf_rate = struct.unpack('f', bytearray( - message['message'][MsgFieldPositions.START_POS_FIELD_2:MsgFieldPositions.END_POS_FIELD_2]))[0] - self.uf_volume_delivered = struct.unpack('f', bytearray( - message['message'][MsgFieldPositions.START_POS_FIELD_3:MsgFieldPositions.END_POS_FIELD_3]))[0] - self.uf_state = struct.unpack('i', bytearray( - message['message'][MsgFieldPositions.START_POS_FIELD_4:MsgFieldPositions.END_POS_FIELD_4]))[0] - + self.process_into_vars(decoder_list = msg_list, + message = message) self.uf_timestamp = timestamp - @publish(["tx_time_prescribed","tx_time_elapsed","tx_time_remaining", + + @publish(["msg_id_td_treatment_time_data", "tx_time_prescribed","tx_time_elapsed","tx_time_remaining", "tx_time_timestamp"]) def _handler_treatment_time_sync(self, message, timestamp=0.0): """ @@ -223,17 +202,17 @@ @param message: published treatment time data message @return: none """ + msg_list = [] + msg_list.append(['self.tx_time_prescribed', DataTypes.U32]) + msg_list.append(['self.tx_time_elapsed', DataTypes.U32]) + msg_list.append(['self.tx_time_remaining', DataTypes.U32]) - self.tx_time_prescribed = struct.unpack('i', bytearray( - message['message'][MsgFieldPositions.START_POS_FIELD_1:MsgFieldPositions.END_POS_FIELD_1]))[0] - self.tx_time_elapsed = struct.unpack('i', bytearray( - message['message'][MsgFieldPositions.START_POS_FIELD_2:MsgFieldPositions.END_POS_FIELD_2]))[0] - self.tx_time_remaining = struct.unpack('i', bytearray( - message['message'][MsgFieldPositions.START_POS_FIELD_3:MsgFieldPositions.END_POS_FIELD_3]))[0] - + self.process_into_vars(decoder_list = msg_list, + message = message) self.tx_time_timestamp = timestamp - @publish(["tx_sub_mode","blood_prime_state","dialysis_state","isolated_uf_state", + + @publish(["msg_id_td_treatment_state_data", "tx_sub_mode","blood_prime_state","dialysis_state","isolated_uf_state", "tx_stop_state","rinseback_state","tx_recirc_state","tx_end_state","tx_state_timestamp"]) def _handler_treatment_state_sync(self, message, timestamp=0.0): """ @@ -242,82 +221,60 @@ @param message: published treatment state data message @return: none """ + msg_list = [] + msg_list.append(['self.tx_sub_mode', DataTypes.U32]) + msg_list.append(['self.blood_prime_state', DataTypes.U32]) + msg_list.append(['self.dialysis_state', DataTypes.U32]) + msg_list.append(['self.isolated_uf_state', DataTypes.U32]) + msg_list.append(['self.tx_stop_state', DataTypes.U32]) + msg_list.append(['self.rinseback_state', DataTypes.U32]) + msg_list.append(['self.tx_recirc_state', DataTypes.U32]) + msg_list.append(['self.tx_end_state', DataTypes.U32]) - self.tx_sub_mode = struct.unpack('i', bytearray( - message['message'][MsgFieldPositions.START_POS_FIELD_1:MsgFieldPositions.END_POS_FIELD_1]))[0] - self.blood_prime_state = struct.unpack('i', bytearray( - message['message'][MsgFieldPositions.START_POS_FIELD_2:MsgFieldPositions.END_POS_FIELD_2]))[0] - self.dialysis_state = struct.unpack('i', bytearray( - message['message'][MsgFieldPositions.START_POS_FIELD_3:MsgFieldPositions.END_POS_FIELD_3]))[0] - self.isolated_uf_state = struct.unpack('i', bytearray( - message['message'][MsgFieldPositions.START_POS_FIELD_4:MsgFieldPositions.END_POS_FIELD_4]))[0] - self.tx_stop_state = struct.unpack('i', bytearray( - message['message'][MsgFieldPositions.START_POS_FIELD_5:MsgFieldPositions.END_POS_FIELD_5]))[0] - self.rinseback_state = struct.unpack('i', bytearray( - message['message'][MsgFieldPositions.START_POS_FIELD_6:MsgFieldPositions.END_POS_FIELD_6]))[0] - self.tx_recirc_state = struct.unpack('i', bytearray( - message['message'][MsgFieldPositions.START_POS_FIELD_7:MsgFieldPositions.END_POS_FIELD_7]))[0] - self.tx_end_state = struct.unpack('i', bytearray( - message['message'][MsgFieldPositions.START_POS_FIELD_8:MsgFieldPositions.END_POS_FIELD_8]))[0] - + self.process_into_vars(decoder_list = msg_list, + message = message) self.tx_state_timestamp = timestamp - @publish(["blood_flow_rate", "dialysate_flow_rate", "tx_duration", "saline_bolus_volume", - "hep_stop_time", "hep_time", "acid_con", "bicarb_con", + + @publish(["msg_id_td_rsp_current_treatment_parameters", "blood_flow_rate", "dialysate_flow_rate", "tx_duration", + "saline_bolus_volume", "hep_stop_time", "hep_time", "acid_con", "bicarb_con", "dialyzer_type", "bp_interval", "rb_flow_rate", "rb_volume", "art_pressure_window","venous_pressure_window","venous_asymm_window","tmp_limit_window", - "dialysate_temp", "hep_dispense_rate", "hep_bolus_vol", "uf_vol"]) + "dialysate_temp", "hep_dispense_rate", "hep_bolus_vol", "uf_vol","tx_param_req_timestamp"]) def _handler_resp_treatment_parameters_sync(self, message, timestamp=0.0): """ Handles published treatment parameter response data messages. @param message: published treatment parameter response data message @return: none """ + msg_list = [] + msg_list.append(['self.blood_flow_rate', DataTypes.U32]) + msg_list.append(['self.dialysate_flow_rate', DataTypes.U32]) + msg_list.append(['self.tx_duration', DataTypes.U32]) + msg_list.append(['self.saline_bolus_volume', DataTypes.U32]) + msg_list.append(['self.hep_stop_time', DataTypes.U32]) + msg_list.append(['self.hep_time', DataTypes.U32]) + msg_list.append(['self.acid_con', DataTypes.U32]) + msg_list.append(['self.bicarb_con', DataTypes.U32]) + msg_list.append(['self.dialyzer_type', DataTypes.U32]) + msg_list.append(['self.bp_interval', DataTypes.U32]) + msg_list.append(['self.rb_flow_rate', DataTypes.U32]) + msg_list.append(['self.rb_volume', DataTypes.U32]) + msg_list.append(['self.art_pressure_window', DataTypes.U32]) + msg_list.append(['self.venous_pressure_window', DataTypes.U32]) + msg_list.append(['self.venous_asymm_window', DataTypes.U32]) + msg_list.append(['self.tmp_limit_window', DataTypes.U32]) + msg_list.append(['self.dialysate_temp', DataTypes.F32]) + msg_list.append(['self.hep_dispense_rate', DataTypes.F32]) + msg_list.append(['self.hep_bolus_vol', DataTypes.F32]) + msg_list.append(['self.uf_vol', DataTypes.F32]) - self.blood_flow_rate = struct.unpack('i', bytearray( - message['message'][MsgFieldPositions.START_POS_FIELD_1:MsgFieldPositions.END_POS_FIELD_1]))[0] - self.dialysate_flow_rate = struct.unpack('i', bytearray( - message['message'][MsgFieldPositions.START_POS_FIELD_2:MsgFieldPositions.END_POS_FIELD_2]))[0] - self.tx_duration = struct.unpack('i', bytearray( - message['message'][MsgFieldPositions.START_POS_FIELD_3:MsgFieldPositions.END_POS_FIELD_3]))[0] - self.saline_bolus_volume = struct.unpack('i', bytearray( - message['message'][MsgFieldPositions.START_POS_FIELD_4:MsgFieldPositions.END_POS_FIELD_4]))[0] - self.hep_stop_time = struct.unpack('i', bytearray( - message['message'][MsgFieldPositions.START_POS_FIELD_5:MsgFieldPositions.END_POS_FIELD_5]))[0] - self.hep_time = struct.unpack('i', bytearray( - message['message'][MsgFieldPositions.START_POS_FIELD_6:MsgFieldPositions.END_POS_FIELD_6]))[0] - self.acid_con = struct.unpack('i', bytearray( - message['message'][MsgFieldPositions.START_POS_FIELD_7:MsgFieldPositions.END_POS_FIELD_7]))[0] - self.bicarb_con = struct.unpack('i', bytearray( - message['message'][MsgFieldPositions.START_POS_FIELD_8:MsgFieldPositions.END_POS_FIELD_8]))[0] - self.dialyzer_type = struct.unpack('i', bytearray( - message['message'][MsgFieldPositions.START_POS_FIELD_9:MsgFieldPositions.END_POS_FIELD_9]))[0] - self.bp_interval = struct.unpack('i', bytearray( - message['message'][MsgFieldPositions.START_POS_FIELD_10:MsgFieldPositions.END_POS_FIELD_10]))[0] - self.rb_flow_rate = struct.unpack('i', bytearray( - message['message'][MsgFieldPositions.START_POS_FIELD_11:MsgFieldPositions.END_POS_FIELD_11]))[0] - self.rb_volume = struct.unpack('i', bytearray( - message['message'][MsgFieldPositions.START_POS_FIELD_12:MsgFieldPositions.END_POS_FIELD_12]))[0] - self.art_pressure_window = struct.unpack('i', bytearray( - message['message'][MsgFieldPositions.START_POS_FIELD_13:MsgFieldPositions.END_POS_FIELD_13]))[0] - self.venous_pressure_window = struct.unpack('i', bytearray( - message['message'][MsgFieldPositions.START_POS_FIELD_14:MsgFieldPositions.END_POS_FIELD_14]))[0] - self.venous_asymm_window = struct.unpack('i', bytearray( - message['message'][MsgFieldPositions.START_POS_FIELD_15:MsgFieldPositions.END_POS_FIELD_15]))[0] - self.tmp_limit_window = struct.unpack('i', bytearray( - message['message'][MsgFieldPositions.START_POS_FIELD_16:MsgFieldPositions.END_POS_FIELD_16]))[0] - self.dialysate_temp = struct.unpack('f', bytearray( - message['message'][MsgFieldPositions.START_POS_FIELD_17:MsgFieldPositions.END_POS_FIELD_17]))[0] - self.hep_dispense_rate = struct.unpack('f', bytearray( - message['message'][MsgFieldPositions.START_POS_FIELD_18:MsgFieldPositions.END_POS_FIELD_18]))[0] - self.hep_bolus_vol = struct.unpack('f', bytearray( - message['message'][MsgFieldPositions.START_POS_FIELD_19:MsgFieldPositions.END_POS_FIELD_19]))[0] - self.uf_vol = struct.unpack('f', bytearray( - message['message'][MsgFieldPositions.START_POS_FIELD_20:MsgFieldPositions.END_POS_FIELD_20]))[0] - + self.process_into_vars(decoder_list = msg_list, + message = message) self.tx_param_req_timestamp = timestamp + def cmd_set_treatment_parameter(self, tx_param_id: int = 0, tx_param_value = 0 ): """ Constructs and sends set treatment parameter command to the TD. @@ -329,30 +286,25 @@ @return: 1 if successful, zero otherwise """ - idx = integer_to_bytearray(tx_param_id) - - if tx_param_id <= TDTreatmentParameters.TREATMENT_PARAM_RINSEBACK_VOLUME.value: + if tx_param_id <= td_enum_repository.TDTreatmentParameters.TREATMENT_PARAM_RINSEBACK_VOLUME.value: tpv = integer_to_bytearray(tx_param_value) - elif tx_param_id >= TDTreatmentParameters.TREATMENT_PARAM_DIALYSATE_TEMPERATURE.value: + elif tx_param_id >= td_enum_repository.TDTreatmentParameters.TREATMENT_PARAM_DIALYSATE_TEMPERATURE.value: tpv = float_to_bytearray(tx_param_value) else: tpv = integer_to_bytearray(tx_param_value) + idx = integer_to_bytearray(tx_param_id) payload = idx + tpv - message = DenaliMessage.build_message(channel_id=DenaliChannels.dialin_to_td_ch_id, - message_id=MsgIds.MSG_ID_TD_SET_TREATMENT_PARAMETER.value, - payload=payload) - - # Send message - received_message = self.can_interface.send(message) - - # If there is content... - if received_message is not None: - # response payload is OK or not OK - return received_message['message'][DenaliMessage.PAYLOAD_START_INDEX] - else: - self.logger.debug("Timeout!!!!") - return False \ No newline at end of file + param_name = td_enum_repository.TDTreatmentParameters(tx_param_id).name + return cmd_generic_override( + payload = payload, + reset = NO_RESET, + channel_id = CanChannels.dialin_to_td_ch_id, + msg_id = MsgIds.MSG_ID_TD_SET_TREATMENT_PARAMETER, + entity_name = f'TD {param_name}', + override_text = str(tx_param_value), + logger = self.logger, + can_interface = self.can_interface)