Index: leahi_dialin/ui/td_messaging.py =================================================================== diff -u -r71ac3afa8dddb9ce74c9de0a508e76467f1dcc3a -r5a50ff3c3ba355fffc616bfc85eb7b312b58b702 --- leahi_dialin/ui/td_messaging.py (.../td_messaging.py) (revision 71ac3afa8dddb9ce74c9de0a508e76467f1dcc3a) +++ leahi_dialin/ui/td_messaging.py (.../td_messaging.py) (revision 5a50ff3c3ba355fffc616bfc85eb7b312b58b702) @@ -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_pump(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 + @param H4_meas_flow : meaured speed + @param H4_rot_speed : measured rotor speed + @param H4_mot_speed : measured blood pump speed + @param H4_curr_motor : current motor + @param H4_set_rpm : set rpm + @param H4_rot_count : pres_flow + @param H4_pres_flow : rotation count + @param H6_rot_hall_state : rotor hall state @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,30 +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_h13: int, valve_state_h20: 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_h13 : air valve H13 state - @param valve_state_h20 : air valve H20 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_h13 ) - payload += conversions.unsigned_integer_to_bytearray(valve_state_h20 ) - 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, @@ -140,61 +156,66 @@ self.can_interface.send(message, 0) - def td_bubbles(self, status: int, state: int): + def td_bubbles(self, + H18_status : int, + H18_state : int): """ Broadcasts the current TD air bubbles data - @param status : Air bubble status - @param state : Air bubble state + @param H18_status : Air bubble status + @param H18_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 ) + payload = conversions.unsigned_integer_to_bytearray(H18_status ) + payload += conversions.unsigned_integer_to_bytearray(H18_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): + def td_air_pump(self, + H12_state: int, + H12_power: int): """ Broadcasts the current TD air pump data - @param state : Air Pump state - @param power : Air Pump Power level (0-250) + @param H12_state : Air Pump state + @param H12_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 ) + payload = conversions.unsigned_integer_to_bytearray(H12_state ) + payload += conversions.unsigned_integer_to_bytearray(H12_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): + 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 : ejector state + @param H5_set_speed : 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.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, @@ -203,17 +224,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 : door status @return: None """ if not self.can_enabled: raise ValueError("CAN Interface is not enabled") - payload = conversions.integer_to_bytearray(door ) + payload = conversions.integer_to_bytearray(H9_door ) message = CAN.DenaliMessage.build_message( channel_id=CAN.DenaliChannels.td_sync_broadcast_ch_id, @@ -316,51 +337,51 @@ 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 ): + 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 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 + @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 (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 ) + 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,