Index: leahi_dialin/ui/td_messaging.py =================================================================== diff -u -r0eda9457bf91df9cff16c4f27ea4e833bddeebd7 -rb98dcb8a6118a4b06328b4f96bb9aa54ff7b077a --- leahi_dialin/ui/td_messaging.py (.../td_messaging.py) (revision 0eda9457bf91df9cff16c4f27ea4e833bddeebd7) +++ leahi_dialin/ui/td_messaging.py (.../td_messaging.py) (revision b98dcb8a6118a4b06328b4f96bb9aa54ff7b077a) @@ -72,34 +72,43 @@ self.can_interface.send(message, 0) - def td_blood_pump(self, set_flow: int, meas_flow: float, rot_speed: float, mot_speed: float, curr_motor: float, set_rpm: float, rot_count: int, pres_flow: int, rot_hall_state: int): + def td_blood_flow(self, + H4_set_flow : int, + H4_meas_flow : float, + H4_rot_speed : float, + H4_mot_speed : float, + H4_curr_motor : float, + H4_set_rpm : float, + H4_rot_count : int, + H4_pres_flow : int, + H6_rot_hall_state : int): """ Broadcasts the current TD Blood Pump Data - @param set_flow : set flow rate - @param meas_flow : meaured speed - @param rot_speed : measured rotor speed - @param mot_speed : measured blood pump speed - @param curr_motor : current motor - @param set_rpm : set rpm - @param pres_flow : pres_flow - @param rot_count : rotation count - @param rot_hall_state : rotor hall state + @param H4_set_flow : Set flow rate in mL/min. + @param H4_meas_flow : Measured flow rate in mL/min. + @param H4_rot_speed : Measured rotor speed in RPM. + @param H4_mot_speed : Measured pump speed in RPM. + @param H4_curr_motor : Measure motor current in Amps. + @param H4_set_rpm : Set motor speed in RPM. + @param H4_rot_count : Rotor count. + @param H4_pres_flow : Prescribed blood flow in mL/min. + @param H6_rot_hall_state : Rotor hall state (1=home, 0=not home) @return: None """ if not self.can_enabled: raise ValueError("CAN Interface is not enabled") - payload = conversions.integer_to_bytearray (set_flow ) - payload += conversions.float_to_bytearray (meas_flow ) - payload += conversions.float_to_bytearray (rot_speed ) - payload += conversions.float_to_bytearray (mot_speed ) - payload += conversions.float_to_bytearray (curr_motor ) - payload += conversions.float_to_bytearray (set_rpm ) - payload += conversions.unsigned_integer_to_bytearray(rot_count ) - payload += conversions.unsigned_integer_to_bytearray(pres_flow ) - payload += conversions.unsigned_integer_to_bytearray(rot_hall_state ) + payload = conversions.integer_to_bytearray (H4_set_flow ) + payload += conversions.float_to_bytearray (H4_meas_flow ) + payload += conversions.float_to_bytearray (H4_rot_speed ) + payload += conversions.float_to_bytearray (H4_mot_speed ) + payload += conversions.float_to_bytearray (H4_curr_motor ) + payload += conversions.float_to_bytearray (H4_set_rpm ) + payload += conversions.unsigned_integer_to_bytearray(H4_rot_count ) + payload += conversions.unsigned_integer_to_bytearray(H4_pres_flow ) + payload += conversions.unsigned_integer_to_bytearray(H6_rot_hall_state ) message = CAN.DenaliMessage.build_message( channel_id=CAN.DenaliChannels.td_sync_broadcast_ch_id, @@ -108,28 +117,37 @@ self.can_interface.send(message, 0) - def td_air_trap(self, low_level: int, upper_level: int, lower_level_raw: int, upper_level_raw: int, valve_state: int, controlling: int): + def td_air_trap(self, + H17_state : int, + H16_state : int, + H17_raw_state : int, + H16_raw_state : int, + H13_state : int, + H20_State : int, + controlling : int): """ Broadcasts the current TD air trap data - @param low_level : lower level value - @param upper_level : upper level value - @param low_level_raw : lower level raw value - @param upper_level_raw : upper level raw value - @param valve_state : air valve state - @param controlling : air control + @param H17_state : lower level value + @param H16_state : upper level value + @param H17_raw_state : lower level raw value + @param H16_raw_state : upper level raw value + @param H13_state : Air trap intake Valve state (open/closed) + @param H20_State : Air trap outlet valve state (open/closed) + @param controlling : air control @return: None """ if not self.can_enabled: raise ValueError("CAN Interface is not enabled") - payload = conversions.unsigned_integer_to_bytearray(low_level ) - payload += conversions.unsigned_integer_to_bytearray(upper_level ) - payload += conversions.unsigned_integer_to_bytearray(lower_level_raw ) - payload += conversions.unsigned_integer_to_bytearray(upper_level_raw ) - payload += conversions.unsigned_integer_to_bytearray(valve_state ) - payload += conversions.unsigned_integer_to_bytearray(controlling ) + payload = conversions.unsigned_integer_to_bytearray(H17_state ) + payload += conversions.unsigned_integer_to_bytearray(H16_state ) + payload += conversions.unsigned_integer_to_bytearray(H17_raw_state ) + payload += conversions.unsigned_integer_to_bytearray(H16_raw_state ) + payload += conversions.unsigned_integer_to_bytearray(H13_state ) + payload += conversions.unsigned_integer_to_bytearray(H20_State ) + payload += conversions.unsigned_integer_to_bytearray(controlling ) message = CAN.DenaliMessage.build_message( channel_id=CAN.DenaliChannels.td_sync_broadcast_ch_id, @@ -138,19 +156,19 @@ self.can_interface.send(message, 0) - def td_ejector(self, state: int, set_speed: float): + def td_ejector(self, H5_state: int, H5_set_speed: float): """ Broadcasts the current TD operation mode - @param state : ejector state - @param set_speed : ejector set speed + @param H5_state (int ) : ejector state + @param H5_set_speed (float): ejector set speed @return: None """ if not self.can_enabled: raise ValueError("CAN Interface is not enabled") - payload = conversions.integer_to_bytearray(state ) - payload += conversions.float_to_bytearray (set_speed) + payload = conversions.unsigned_integer_to_bytearray(H5_state ) + payload += conversions.float_to_bytearray (H5_set_speed) message = CAN.DenaliMessage.build_message( channel_id=CAN.DenaliChannels.td_sync_broadcast_ch_id, @@ -159,17 +177,17 @@ self.can_interface.send(message, 0) - def td_switches(self, door: int): + def td_switches(self, H9_door: int): """ Broadcasts the current TD switch Data - @param door : door status + @param H9_door (int): door status @return: None """ if not self.can_enabled: raise ValueError("CAN Interface is not enabled") - payload = conversions.integer_to_bytearray(door ) + payload = conversions.unsigned_integer_to_bytearray(H9_door ) message = CAN.DenaliMessage.build_message( channel_id=CAN.DenaliChannels.td_sync_broadcast_ch_id, @@ -181,17 +199,17 @@ def td_battery(self, capacity: int, ac_power: int): """ Broadcasts the current TD Battery Data - @param capacity : battery capacity - @param ac_power : a/c power status + @param capacity (int): battery capacity + @param ac_power (int): a/c power status @return: None """ # TODO: replace with proper payload and message ID once message is defined if not self.can_enabled: raise ValueError("CAN Interface is not enabled") - payload = conversions.integer_to_bytearray(capacity) - payload += conversions.integer_to_bytearray(ac_power) + payload = conversions.unsigned_integer_to_bytearray(capacity) + payload += conversions.unsigned_integer_to_bytearray(ac_power) message = CAN.DenaliMessage.build_message( channel_id=CAN.DenaliChannels.td_sync_broadcast_ch_id, @@ -203,11 +221,11 @@ def td_valves(self, valve_id: int, state: int, pos_name: int, pos_count: int, next_pos: int): """ Broadcasts the current TD Battery Data - @param valve_id : Valve ID - @param state : Valve State - @param pos_name : Position Name - @param pos_count : Position Count - @param next_pos : Next Position + @param valve_id (int): Valve ID + @param state (int): Valve State + @param pos_name (int): Position Name + @param pos_count (int): Position Count + @param next_pos (int): Next Position @return: None """ @@ -228,30 +246,29 @@ self.can_interface.send(message, 0) - def td_voltages(self, line_1_2v: float, line_3_3v: float, line_logic_5v: float, + def td_voltage(self, line_1_2v: float, line_3_3v: float, line_logic_5v: float, line_sensors_5v: float, line_24v: float, line_regen_24v: float, fpga_adc_ref: float, res_ref: float, fpga_vcc: float, fpga_vaux: float, fpga_vpvn: float): """ Broadcasts the current TD voltage data - @param line_1_2v : 1.2V line - @param line_3_3v : 3.3V line - @param line_logic_5v : Logic voltage (5V) - @param line_sensors_5v : Sensors voltage (5V) - @param line_24v : Actuators voltage (24V) - @param line_regen_24v : Actuators regen voltage (24V) - @param fpga_adc_ref : FPGA ADC reference voltage (1V) - @param res_ref : PBA ADC reference voltage (3V) - @param fpga_vcc : FPGA Vcc (3V) - @param fpga_vaux : FPGA Vaux (3V) - @param fpga_vpvn : FPGA Vpvn (1V) + @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_sensors_5v (float): Sensors voltage (5V) + @param line_24v (float): Actuators voltage (24V) + @param line_regen_24v (float): Actuators regen voltage (24V) + @param fpga_adc_ref (float): FPGA ADC reference voltage (1V) + @param res_ref (float): PBA ADC reference voltage (3V) + @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.float_to_bytearray(line_1_2v ) payload += conversions.float_to_bytearray(line_3_3v ) payload += conversions.float_to_bytearray(line_logic_5v ) @@ -271,6 +288,174 @@ self.can_interface.send(message, 0) + def td_pressure(self, + H2_arterial_pressure : float , + H14_venous_pressure : float , + limit_state : int , + H2_arterial_min : int , + H2_arterial_max : int , + H14_venous_min : int , + H14_venous_max : int , + H2_arterial_long : float , + H14_venous_long : float , + tmp_pressure : float , + tmp_min : float , + tmp_max : float ): + """ + Broadcasts the current TD vpressures data + @param H2_arterial_pressure (float) : Current Arterial pressure value + @param H14_venous_pressure (float) : Current Venous pressure value + @param limit_state (int ) : Pressure limit state + @param H2_arterial_min (int ) : Arterial pressure minimum + @param H2_arterial_max (int ) : Arterial pressure maximum + @param H14_venous_min (int ) : Venous pressure minimum + @param H14_venous_max (int ) : Venous pressure maximum + @param H2_arterial_long (float) : Arterial Long + @param H14_venous_long (float) : Venous Long + @param tmp_pressure (float) : TMP pressure + @param tmp_min (float) : TMP minimum + @param tmp_max (float) : TMP maximum + @return: None + """ + + if not self.can_enabled: + raise ValueError("CAN Interface is not enabled") + + + payload = conversions.float_to_bytearray (H2_arterial_pressure ) + payload += conversions.float_to_bytearray (H14_venous_pressure ) + payload += conversions.unsigned_integer_to_bytearray(limit_state ) + payload += conversions.integer_to_bytearray (H2_arterial_min ) + payload += conversions.integer_to_bytearray (H2_arterial_max ) + payload += conversions.integer_to_bytearray (H14_venous_min ) + payload += conversions.integer_to_bytearray (H14_venous_max ) + payload += conversions.float_to_bytearray (H2_arterial_long ) + payload += conversions.float_to_bytearray (H14_venous_long ) + payload += conversions.float_to_bytearray (tmp_pressure ) + payload += conversions.float_to_bytearray (tmp_min ) + payload += conversions.float_to_bytearray (tmp_max ) + + message = CAN.DenaliMessage.build_message( + channel_id=CAN.DenaliChannels.td_sync_broadcast_ch_id, + message_id=msg_ids.MsgIds.MSG_ID_TD_PRESSURE_DATA.value, + payload=payload) + + self.can_interface.send(message, 0) + + def td_saline( self, + target_volume : int , + cumulative_volume : float , + bolus_volume : float , + state : int ): + """ + Broadcasts the current TD vpressures data + @param target_volume (int ) : Saline target volume + @param cumulative_volume (float) : Saline cumulative volume + @param bolus_volume (float) : Saline bolus set volume + @param state (int ) : Saline bolus state + @return: None + """ + + if not self.can_enabled: + raise ValueError("CAN Interface is not enabled") + + + payload = conversions.unsigned_integer_to_bytearray(target_volume ) + payload += conversions.float_to_bytearray (cumulative_volume ) + payload += conversions.float_to_bytearray (bolus_volume ) + payload += conversions.unsigned_integer_to_bytearray(state ) + + message = CAN.DenaliMessage.build_message( + channel_id=CAN.DenaliChannels.td_sync_broadcast_ch_id, + message_id=msg_ids.MsgIds.MSG_ID_TD_SALINE_BOLUS_DATA.value, + payload=payload) + + self.can_interface.send(message, 0) + + def td_ultrafiltration( self, + set_volume : float , + target_rate : float , + volume_delivered : float , + state : int ): + """ + Broadcasts the current TD vpressures data + @param set_volume (float) : UF set volume (L) + @param target_rate (float) : UF target Rate (L) + @param volume_delivered (float) : UF Volume delivered (L) + @param state (int ) : UF state + @return: None + """ + + if not self.can_enabled: + raise ValueError("CAN Interface is not enabled") + + + payload = conversions.float_to_bytearray (set_volume ) + payload += conversions.float_to_bytearray (target_rate ) + payload += conversions.float_to_bytearray (volume_delivered ) + payload += conversions.unsigned_integer_to_bytearray(state ) + + message = CAN.DenaliMessage.build_message( + channel_id=CAN.DenaliChannels.td_sync_broadcast_ch_id, + message_id=msg_ids.MsgIds.MSG_ID_TD_ULTRAFILTRATION_DATA.value, + payload=payload) + + self.can_interface.send(message, 0) + + def td_treatment_time( self, + tx_duration_s : int , + tx_elapsed_s : int , + tx_remaining_s : int ): + """ + Broadcasts the current TD vpressures data + @param tx_duration_s (int) : Treatment set duration (s) + @param tx_elapsed_s (int) : Treatment elaspsed time (s) + @param tx_remaining_s (int) : Treatment time remaining (s) + @return: None + """ + + if not self.can_enabled: + raise ValueError("CAN Interface is not enabled") + + + payload = conversions.unsigned_integer_to_bytearray(tx_duration_s ) + payload += conversions.unsigned_integer_to_bytearray(tx_elapsed_s ) + payload += conversions.unsigned_integer_to_bytearray(tx_remaining_s ) + + message = CAN.DenaliMessage.build_message( + channel_id=CAN.DenaliChannels.td_sync_broadcast_ch_id, + message_id=msg_ids.MsgIds.MSG_ID_TD_TREATMENT_TIME_DATA.value, + payload=payload) + + self.can_interface.send(message, 0) + + def td_treatment_set_points(self, + blood_flow : int , + dialysate_flow : int , + dialysate_temp : float ): + """ + Broadcasts the current TD vpressures data + @param blood_flow (int ) : Target Blood Flow + @param dialysate_flow (int ) : Target Dialysate Flow + @param dialysate_temp (float) : Target Dialysate Temperature + @return: None + """ + + if not self.can_enabled: + raise ValueError("CAN Interface is not enabled") + + + payload = conversions.unsigned_integer_to_bytearray(blood_flow ) + payload += conversions.unsigned_integer_to_bytearray(dialysate_flow ) + payload += conversions.float_to_bytearray (dialysate_temp ) + + message = CAN.DenaliMessage.build_message( + channel_id=CAN.DenaliChannels.td_sync_broadcast_ch_id, + message_id=msg_ids.MsgIds.MSG_ID_TD_TREATMENT_SET_POINTS.value, + payload=payload) + + self.can_interface.send(message, 0) + def td_versions(self, major: int, minor: int, micro: int, build: int, fpga_id: int, fpga_major: int, fpga_minor: int, fpga_lab: int, compatibility_rev: int): @@ -314,7 +499,6 @@ @param serial: serial number @return: None """ - # TODO: replace with proper payload and message ID once message is defined payload = bytes(serial, 'ascii') + b'\x00' message = CAN.DenaliMessage.build_message( @@ -426,7 +610,51 @@ payload=payload) self.can_interface.send(message, 0) + def td_tx_state(self, + sub_mode : int, + blood_prime_state : int, + dialysis_state : int, + isolated_uf_state : int, + tx_stop_state : int, + tx_rinseback_state : int, + tx_recirculate_state : int, + tx_end_state : int, + tx_saline_state : int, + tx_heparin_state : int) -> None: + """A general method to send any standard response message, by it's id and list of parameters. + Args: + sub_mode (int): Treatment Submode + blood_prime_state (int): Treatment Blood Prime State + dialysis_state (int): Treatment dialysis state + isolated_uf_state (int): Treatment Isolated UF state + tx_stop_state (int): Treatment Stop state + tx_rinseback_state (int): Treatment Rinseback State + tx_recirculate_state (int): Treatment Recirculate State + tx_end_state (int): Treatment End state + tx_saline_state (int): Saline Bolus state + tx_heparin_state (int): Heparin 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(blood_prime_state ) + payload += conversions.unsigned_integer_to_bytearray(dialysis_state ) + payload += conversions.unsigned_integer_to_bytearray(isolated_uf_state ) + payload += conversions.unsigned_integer_to_bytearray(tx_stop_state ) + payload += conversions.unsigned_integer_to_bytearray(tx_rinseback_state ) + payload += conversions.unsigned_integer_to_bytearray(tx_recirculate_state ) + payload += conversions.unsigned_integer_to_bytearray(tx_end_state ) + payload += conversions.unsigned_integer_to_bytearray(tx_saline_state ) + payload += conversions.unsigned_integer_to_bytearray(tx_heparin_state ) + + message = CAN.DenaliMessage.build_message( + channel_id=CAN.DenaliChannels.td_sync_broadcast_ch_id, + message_id=msg_ids.MsgIds.MSG_ID_TD_TREATMENT_STATE_DATA.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,