Fix bug preventing RobotInfo widget from updating and reset RobotInfo UI upon robot disconnection (UBC-Thunderbots#3476)

Author: williamckha

src/software/thunderscope/common/common_widgets.py

@@ -64,15 +64,15 @@ class ColorQLabel(QLabel):
     def __init__(
         self,
         label_text: str,
-        initial_value: str,
+        initial_value: float,
         min_val: float = 0,
         max_val: float = 100,
     ):
         """Initializes the ColorQLabel with the given label, min and max bounds
         Or 0 and 100 as default
 
-        :param label_text: the text displayed within this label as a string.
-        :param initial_value: the initial string value of the label
+        :param label_text: the text displayed within this label as a string
+        :param initial_value: the initial value of the label
         :param min_val: the minimum value of the label color (no color)
         :param max_val: the maxmimum value of the label color (100% red)
         """
@@ -81,17 +81,15 @@ def __init__(
         self.min = min_val
         self.max = max_val
         self.label_text = label_text
-        self.initial_value = initial_value
 
-        self.setText(label_text + initial_value)
-        self.__update_background_color(0)
+        self.set_float_val(initial_value)
 
     def set_float_val(self, val: float) -> None:
         """Sets the current value of the label to the given float value
 
         :param val: the new float value
         """
-        self.setText(f"{self.label_text}{val:02d}")
+        self.setText(f"{self.label_text} {val:d}")
         self.__update_background_color(val)
 
     def __update_background_color(self, val: float) -> None:

src/software/thunderscope/robot_communication.py

@@ -1,11 +1,10 @@
-from typing import Self, Type
+from typing import Self
 
 import threading
 import time
 import os
 import software.python_bindings as tbots_cpp
 
-from google.protobuf.message import Message
 from proto.import_all_protos import *
 from software.logger.logger import create_logger
 from software.thunderscope.thread_safe_buffer import ThreadSafeBuffer
@@ -268,15 +267,6 @@ def __run_primitive_set(self) -> None:
             if IndividualRobotMode.AI not in self.robot_control_mode_map.values():
                 time.sleep(ROBOT_COMMUNICATIONS_TIMEOUT_S)
 
-    def __forward_to_proto_unix_io(self, type: Type[Message], data: Message) -> None:
-        """Forwards to proto unix IO iff running is true
-
-        :param data: the data to be passed through
-        :param type: the proto type
-        """
-        if self.running:
-            self.current_proto_unix_io.send_proto(type, data)
-
     def __enter__(self) -> Self:
         """Enter RobotCommunication context manager. Setup multicast listeners
         for RobotStatus, RobotLogs, and RobotCrash msgs, and multicast sender for PrimitiveSet
@@ -288,22 +278,6 @@ def __enter__(self) -> Self:
 
         return self
 
-    def __receive_robot_status(self, robot_status: Message) -> None:
-        """Forwards the given robot status to the full system along with the round-trip time
-
-        :param robot_status: RobotStatus to forward to fullsystem
-        """
-        round_trip_time_seconds = time.time() - (
-            robot_status.adjusted_time_sent.epoch_timestamp_seconds
-        )
-        robot_statistic = RobotStatistic(
-            robot_id=robot_status.robot_id,
-            round_trip_time_seconds=round_trip_time_seconds,
-        )
-
-        self.__forward_to_proto_unix_io(RobotStatus, robot_status)
-        self.__forward_to_proto_unix_io(RobotStatistic, robot_statistic)
-
     def __exit__(self, type, value, traceback) -> None:
         """Exit RobotCommunication context manager
 

src/software/thunderscope/robot_diagnostics/motor_fault_view.py

@@ -27,13 +27,14 @@ def __init__(self) -> None:
         super().__init__()
         self.layout = QHBoxLayout()
 
-        self.enabled = None
+        self.enabled = False
         self.fault_count = 0
         self.motor_faults = {
             "Front Left": None,
             "Front Right": None,
             "Back Left": None,
             "Back Right": None,
+            "Dribbler": None,
         }
         self.motor_fault_tooltip = ""
 
@@ -133,7 +134,7 @@ def update_ui(self) -> None:
             - if all motors are still enabled, color is yellow and text is "Warning"
             - if any motor is disabled, color is red and text is "Error"
         """
-        if self.enabled is None:
+        if not self.enabled:
             self.motor_fault_display.setStyleSheet("background: grey; color: white;")
             self.motor_fault_display.setText("No Signal")
         else:
@@ -153,6 +154,14 @@ def update_ui(self) -> None:
 
                 self.fault_count_label.hide()
 
+    def reset_ui(self) -> None:
+        """Resets the UI to the default uninitialized state
+        (widget will indicate that it has not received a signal yet)
+        """
+        self.motor_fault_tooltip = ""
+        self.enabled = False
+        self.update_ui()
+
     def refresh(self, motor_status: MotorStatus, enum_descriptor: Any) -> None:
         """Converts the given message into a map of motor name to its fault info
         And calls functions to update the main UI and the tooltip

src/software/thunderscope/robot_diagnostics/robot_info.py

@@ -100,30 +100,30 @@ def __init__(
         self.battery_progress_bar = common_widgets.ColorProgressBar(
             MIN_BATTERY_VOLTAGE - self.BATTERY_MIN_OFFSET, MAX_BATTERY_VOLTAGE
         )
+
         # Battery Voltage Label
         self.battery_label = QLabel()
-        self.battery_label.setText("NAN")
+
         # Label changes when voltage bar level changes
         self.battery_progress_bar.floatValueChanged.connect(
             lambda float_val: self.battery_label.setText("%.2fV" % float_val)
         )
 
         # Stop primitive received indicator
         self.stop_primitive_label = QLabel()
-        self.stop_primitive_label.setText("NA")
         self.stats_layout.addWidget(self.stop_primitive_label)
 
         # Primitive loss rate label
         self.primitive_loss_rate_label = common_widgets.ColorQLabel(
             label_text="P%",
-            initial_value="NA",
+            initial_value=0,
             max_val=MAX_ACCEPTABLE_PACKET_LOSS_PERCENT,
         )
 
         # Primitive round-trip time label and queue
         self.primitive_rtt_label = common_widgets.ColorQLabel(
             label_text="RTT:",
-            initial_value="NA",
+            initial_value=0,
             max_val=MAX_ACCEPTABLE_MILLISECOND_ROUND_TRIP_TIME,
             min_val=MIN_ACCEPTABLE_MILLISECOND_ROUND_TRIP_TIME,
         )
@@ -141,17 +141,21 @@ def __init__(
 
         # Control mode dropdown
         self.control_mode_layout = QHBoxLayout()
-        self.control_mode_menu = self.create_control_mode_menu(available_control_modes)
+        self.control_mode_menu = self.__create_control_mode_menu(
+            available_control_modes
+        )
 
-        # Robot Status expand button
-        self.robot_status_expand = self.create_robot_status_expand_button()
+        # Button to expand/collapse the robot status view
+        self.expand_robot_status_button = QPushButton()
+        self.expand_robot_status_button.setCheckable(True)
+        self.expand_robot_status_button.setText("INFO")
 
         # motor fault visualisation for the 4 wheel motors
         self.motor_fault_view = MotorFaultView()
 
         self.control_mode_layout.addWidget(self.motor_fault_view)
         self.control_mode_layout.addWidget(self.control_mode_menu)
-        self.control_mode_layout.addWidget(self.robot_status_expand)
+        self.control_mode_layout.addWidget(self.expand_robot_status_button)
 
         self.status_layout.addLayout(self.control_mode_layout)
 
@@ -160,10 +164,10 @@ def __init__(
         self.robot_model_layout.setContentsMargins(0, 5, 5, 0)
 
         # Vision Pattern
-        self.color_vision_pattern = self.create_vision_pattern(
+        self.color_vision_pattern = self.__create_vision_pattern(
             Colors.ROBOT_MIDDLE_BLUE, ROBOT_RADIUS, True
         )
-        self.bw_vision_pattern = self.create_vision_pattern(
+        self.bw_vision_pattern = self.__create_vision_pattern(
             Colors.BW_ROBOT_MIDDLE_BLUE, ROBOT_RADIUS, False
         )
 
@@ -189,17 +193,33 @@ def __init__(
         self.last_robot_status = None
         self.last_robot_statistic = None
 
-    def create_robot_status_expand_button(self) -> QPushButton:
-        """Creates the button to expand / collapse the robot status view
+    def update_robot_status(self, robot_status: RobotStatus):
+        """Receives a RobotStatus message and updates the UI to reflect the new data
+
+        :param robot_status: The latest RobotStatus message for this robot
+        """
+        self.time_of_last_robot_status = time.time()
+        self.last_robot_status = robot_status
+
+        self.robot_model.setPixmap(self.color_vision_pattern)
+        self.__update_ui()
+
+        # We should check in after DISCONNECT_DURATION_MS and see whether we've
+        # received any new RobotStatus messages within the time that passed.
+        # If not, then the robot probably disconnected.
+        QtCore.QTimer.singleShot(
+            int(DISCONNECT_DURATION_MS), self.__check_for_disconnection
+        )
 
-        :return: QPushButton object
+    def update_robot_statistic(self, robot_statistic: RobotStatistic):
+        """Receives a RobotStatistic message and updates the UI to reflect the new data
+
+        :param robot_statistic: The latest RobotStatistic message for this robot
         """
-        button = QPushButton()
-        button.setCheckable(True)
-        button.setText("INFO")
-        return button
+        self.last_robot_statistic = robot_statistic
+        self.__update_ui()
 
-    def create_control_mode_menu(
+    def __create_control_mode_menu(
         self, available_control_modes: list[IndividualRobotMode]
     ) -> QComboBox:
         """Creates the drop down menu to select the input for each robot
@@ -232,7 +252,7 @@ def create_control_mode_menu(
 
         return control_mode_menu
 
-    def create_vision_pattern(
+    def __create_vision_pattern(
         self, team_colour: QtGui.QColor, radius: int, connected: bool
     ) -> QtGui.QPixmap:
         """Given a robot id, team color and radius, draw the vision
@@ -295,56 +315,43 @@ def create_vision_pattern(
 
         return pixmap
 
-    def update_robot_status(self, robot_status: RobotStatus):
-        """Receives a RobotStatus message
-
-        Saves the current time as the last robot status time
-        Sets the robot UI as connected and updates the UI
-        Then sets a timer callback to disconnect the robot if needed
-
-        :param robot_status: The robot status message for this robot
+    def __check_for_disconnection(self) -> None:
+        """Calculates the time between the last robot status received and now.
+        If more than our threshold, assume the robot disconnected and reset the UI.
         """
-        self.time_of_last_robot_status = time.time()
-
-        self.robot_model.setPixmap(self.color_vision_pattern)
-
-        self.last_robot_status = robot_status
-
-        self.__update_ui()
-
-        QtCore.QTimer.singleShot(int(DISCONNECT_DURATION_MS), self.disconnect_robot)
-
-    def update_rtt(self, robot_statistic: RobotStatistic):
-        self.last_robot_statistic = robot_statistic
-
-        self.__update_ui()
-
-    def disconnect_robot(self) -> None:
-        """Calculates the time between the last robot status and now
-        If more than our threshold, resets UI
-        """
-        time_since_last_robot_status = time.time() - self.time_of_last_robot_status
         if (
-            time_since_last_robot_status
-            > DISCONNECT_DURATION_MS * SECONDS_PER_MILLISECOND
+            time.time() - self.time_of_last_robot_status
+            >= DISCONNECT_DURATION_MS * SECONDS_PER_MILLISECOND
         ):
             self.__reset_ui()
 
     def __reset_ui(self) -> None:
         """Resets the UI to the default, uninitialized values"""
+        self.__update_stop_primitive(None)
+
         self.robot_model.setPixmap(self.bw_vision_pattern)
 
+        self.primitive_loss_rate_label.set_float_val(0)
+        self.primitive_rtt_label.set_float_val(0)
         self.breakbeam_label.update_breakbeam_status(None)
+        self.battery_progress_bar.setValue(self.battery_progress_bar.minimum())
+        self.motor_fault_view.reset_ui()
 
-    def __update_stop_primitive(self, is_running: bool) -> None:
+    def __update_stop_primitive(self, is_running: bool | None) -> None:
         """Updates the stop primitive label based on the current running state
 
-        :param is_running: if the robot is running currently
+        :param is_running: true if the robot is running currently, false if the
+                           robot is stopped, or None if the robot is disconnected
+                           and there is no primitive executor status
         """
-        self.stop_primitive_label.setText("RUN" if is_running else "STOP")
-        self.stop_primitive_label.setStyleSheet(
-            f"background-color: {'green' if is_running else 'red'}; border: 1px solid black;"
-        )
+        if is_running is None:
+            self.stop_primitive_label.setVisible(False)
+        else:
+            self.stop_primitive_label.setVisible(True)
+            self.stop_primitive_label.setText("RUN" if is_running else "STOP")
+            self.stop_primitive_label.setStyleSheet(
+                f"background-color: {'green' if is_running else 'red'}; border: 1px solid black;"
+            )
 
     def __update_ui(self) -> None:
         """Receives important sections of RobotStatus proto for this robot and updates widget with alerts
@@ -357,11 +364,12 @@ def __update_ui(self) -> None:
         """
         if not self.last_robot_status or not self.last_robot_statistic:
             return
-        motor_status = robot_status.motor_status
-        power_status = robot_status.power_status
-        network_status = robot_status.network_status
-        primitive_executor_status = robot_status.primitive_executor_status
-        rtt_time_seconds = robot_statistic.round_trip_time_seconds
+
+        motor_status = self.last_robot_status.motor_status
+        power_status = self.last_robot_status.power_status
+        network_status = self.last_robot_status.network_status
+        primitive_executor_status = self.last_robot_status.primitive_executor_status
+        rtt_time_seconds = self.last_robot_statistic.round_trip_time_seconds
 
         self.__update_stop_primitive(primitive_executor_status.running_primitive)
 
@@ -374,6 +382,7 @@ def __update_ui(self) -> None:
                 rtt_time_seconds * MILLISECONDS_PER_SECOND
             )
         )
+
         self.breakbeam_label.update_breakbeam_status(power_status.breakbeam_tripped)
 
         self.motor_fault_view.refresh(