Index: leahi_dialin/ui/td_messaging.py =================================================================== diff -u -r0eda9457bf91df9cff16c4f27ea4e833bddeebd7 -rb40b6d73d23cb6c3520ad06b98c1198ef70fd24e --- leahi_dialin/ui/td_messaging.py (.../td_messaging.py) (revision 0eda9457bf91df9cff16c4f27ea4e833bddeebd7) +++ leahi_dialin/ui/td_messaging.py (.../td_messaging.py) (revision b40b6d73d23cb6c3520ad06b98c1198ef70fd24e) @@ -108,14 +108,15 @@ 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, low_level: int, upper_level: int, lower_level_raw: int, upper_level_raw: int, valve_state_h13: int, valve_state_h20: 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 valve_state_h13 : air valve H13 state + @param valve_state_h20 : air valve H20 state @param controlling : air control @return: None """ @@ -128,7 +129,8 @@ 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(valve_state_h13 ) + payload += conversions.unsigned_integer_to_bytearray(valve_state_h20 ) payload += conversions.unsigned_integer_to_bytearray(controlling ) message = CAN.DenaliMessage.build_message( @@ -138,6 +140,48 @@ self.can_interface.send(message, 0) + def td_bubbles(self, status: int, state: int): + """ + Broadcasts the current TD air bubbles data + @param status : Air bubble status + @param state : Air bubble state + @return: None + """ + + if not self.can_enabled: + raise ValueError("CAN Interface is not enabled") + + + payload = conversions.unsigned_integer_to_bytearray(status ) + 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_BUBBLES_DATA.value, + payload=payload) + + self.can_interface.send(message, 0) + + def td_air_pump(self, state: int, power: int): + """ + Broadcasts the current TD air pump data + @param state : Air Pump state + @param power : Air Pump Power level (0-250) + @return: None + """ + + if not self.can_enabled: + raise ValueError("CAN Interface is not enabled") + + + payload = conversions.unsigned_integer_to_bytearray(state ) + payload += conversions.unsigned_integer_to_bytearray(power ) + message = CAN.DenaliMessage.build_message( + channel_id=CAN.DenaliChannels.td_sync_broadcast_ch_id, + message_id=msg_ids.MsgIds.MSG_ID_TD_BUBBLES_DATA.value, + payload=payload) + + self.can_interface.send(message, 0) + def td_ejector(self, state: int, set_speed: float): """ Broadcasts the current TD operation mode @@ -271,6 +315,174 @@ self.can_interface.send(message, 0) + def td_pressure(self, + arterial_pressure : float , + venous_pressure : float , + limit_state : int , + arterial_min : int , + arterial_max : int , + venous_min : int , + venous_max : int , + arterial_long : float , + venous_long : float , + tmp_pressure : float , + tmp_min : float , + tmp_max : float ): + """ + Broadcasts the current TD vpressures data + @param arterial_pressure (float) : Current Arterial pressure value + @param venous_pressure (float) : Current Venous pressure value + @param limit_state (int ) : Pressure limit state + @param arterial_min (int ) : Arterial pressure minimum + @param arterial_max (int ) : Arterial pressure maximum + @param venous_min (int ) : Venous pressure minimum + @param venous_max (int ) : Venous pressure maximum + @param arterial_long (float) : Arterial Long + @param 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 (arterial_pressure ) + payload += conversions.float_to_bytearray (venous_pressure ) + payload += conversions.unsigned_integer_to_bytearray(limit_state ) + payload += conversions.integer_to_bytearray (arterial_min ) + payload += conversions.integer_to_bytearray (arterial_max ) + payload += conversions.integer_to_bytearray (venous_min ) + payload += conversions.integer_to_bytearray (venous_max ) + payload += conversions.float_to_bytearray (arterial_long ) + payload += conversions.float_to_bytearray (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 : float , + tx_elapsed_s : float , + tx_remaining_s : float ): + """ + Broadcasts the current TD vpressures data + @param tx_duration_s (float) : Treatment set duration (s) + @param tx_elapsed_s (float) : Treatment elaspsed time (s) + @param tx_remaining_s (float) : 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.float_to_bytearray (tx_elapsed_s ) + payload += conversions.float_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 : float , + dialysate_flow : float , + dialysate_temp : float ): + """ + Broadcasts the current TD vpressures data + @param blood_flow (float) : Target Blood Flow + @param dialysate_flow (float) : 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.float_to_bytearray (blood_flow ) + payload += conversions.float_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_ULTRAFILTRATION_DATA.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):