fix status indicators

Author: nathantsoi

src/gui/gui_main.cc

@@ -50,6 +50,7 @@
 
 #include "amrl_msgs/msg/ackermann_curvature_drive_msg.hpp"
 #include "ut_automata/msg/car_status_msg.hpp"
+#include "std_msgs/msg/int32.hpp"
 #include "gui_mainwindow.h"
 #include "shared/util/timer.h"
 
@@ -59,6 +60,7 @@ using sensor_msgs::msg::LaserScan;
 using sensor_msgs::msg::Image;
 using sensor_msgs::msg::Joy;
 using sensor_msgs::msg::Imu;
+using std_msgs::msg::Int32;
 
 namespace {
 ut_automata_gui::MainWindow* main_window_ = nullptr;
@@ -71,6 +73,7 @@ std::atomic<float> battery_voltage_{0.0f};
 std::atomic_int drive_mode_{0};
 std::atomic<float> throttle_{0.0f};
 std::atomic<float> steering_{0.0f};
+std::atomic_bool is_recording_{false};
 // Track last joystick message time for timeout detection
 std::atomic<std::chrono::steady_clock::time_point> last_joystick_time_{std::chrono::steady_clock::time_point{}};
 // Track last IMU message time for timeout detection
@@ -83,6 +86,7 @@ rclcpp::Subscription<AckermannCurvatureDriveMsg>::SharedPtr drive_sub_ = nullptr
 rclcpp::Subscription<Image>::SharedPtr camera_sub_ = nullptr;
 rclcpp::Subscription<Joy>::SharedPtr joystick_sub_ = nullptr;
 rclcpp::Subscription<Imu>::SharedPtr imu_sub_ = nullptr;
+rclcpp::Subscription<Int32>::SharedPtr recording_sub_ = nullptr;
 std::mutex cleanup_mutex_;
 int lock_fd_ = -1;  // File descriptor for the lock file
 }  // namespace
@@ -190,6 +194,15 @@ void ImuCallback(const Imu::SharedPtr msg) {
   imu_okay_.store(true);
 }
 
+// Recording status callback
+void RecordingCallback(const Int32::SharedPtr msg) {
+  std::lock_guard<std::mutex> lock(cleanup_mutex_);
+  if (!run_.load() || main_window_ == nullptr || !rclcpp::ok()) return;
+  
+  bool recording = (msg->data == 1);
+  is_recording_.store(recording);
+}
+
 void* RosThread(void* arg) {
   // Don't detach - we need to properly join the thread
   // pthread_detach(pthread_self());
@@ -209,6 +222,8 @@ void* RosThread(void* arg) {
       "joystick", 10u, &JoystickCallback);
   imu_sub_ = ros_node_->create_subscription<Imu>(
       "/imu", 10u, &ImuCallback);
+  recording_sub_ = ros_node_->create_subscription<Int32>(
+      "/recording", 10u, &RecordingCallback);
 
   RateLoop loop(5.0);
   while (rclcpp::ok() && run_.load()) {
@@ -263,6 +278,7 @@ void* RosThread(void* arg) {
                                  imu_okay_.load(),
                                  throttle_.load(),
                                  steering_.load());
+      main_window_->UpdateRecordingStatus(is_recording_.load());
     }
     loop.Sleep();
   }
@@ -302,6 +318,10 @@ void* RosThread(void* arg) {
           imu_sub_.reset();
           printf("IMU subscription cleaned up\n");
         }
+        if (recording_sub_) {
+          recording_sub_.reset();
+          printf("Recording subscription cleaned up\n");
+        }
       } catch (const std::exception& e) {
         printf("Exception during subscription cleanup: %s\n", e.what());
       }
@@ -327,6 +347,7 @@ void* RosThread(void* arg) {
       camera_sub_.reset();
       joystick_sub_.reset();
       imu_sub_.reset();
+      recording_sub_.reset();
       ros_node_.reset();
     }
   }

src/gui/gui_mainwindow.cc

@@ -154,12 +154,12 @@ void CameraDisplay::resizeEvent(QResizeEvent* event) {
   }
 }
 
-StatusLed::StatusLed(QString name) : led_(nullptr) {
+StatusLed::StatusLed(QString name, bool is_recording_led) : led_(nullptr) {
   QFont font("Arial");
   font.setPointSize(15);
   QLabel* label = new QLabel(name);
   label->setFont(font);
-  led_ = new Led();
+  led_ = new Led(is_recording_led);
   led_->setFixedSize(30, 30);
   QHBoxLayout* layout = new QHBoxLayout();
   layout->addWidget(label);
@@ -316,7 +316,8 @@ MainWindow::MainWindow(QWidget* parent) :
     display_(nullptr),
     status_label_(nullptr),
     disk_space_bar_(nullptr),
-    stop_config_button_(nullptr) {
+    stop_config_button_(nullptr),
+    recording_led_(nullptr) {
   this->setWindowTitle("UT AUTOmataGUI");
 
   // Ensure window takes full screen space
@@ -336,8 +337,15 @@ MainWindow::MainWindow(QWidget* parent) :
   status_label_ = new QLabel("Mode: Autonomous\nBattery: 0V");
   status_label_->setFont(font);
   status_label_->setAlignment(Qt::AlignHCenter);
+  
+  // Add recording indicator
+  recording_led_ = new StatusLed("REC", true);  // true = use grey when off
+  recording_led_->setFixedHeight(60);
+  
   top_bar->addWidget(ipaddr_label_);
   top_bar->addStretch();
+  top_bar->addWidget(recording_led_);
+  top_bar->addStretch();
   top_bar->addWidget(status_label_);
   top_bar->addStretch();
   top_bar->addWidget(close_button);
@@ -437,6 +445,67 @@ MainWindow::MainWindow(QWidget* parent) :
 
     tab_widget_->addTab(main_widget, "Main");
     tab_widget_->addTab(ros_group, tr("Configurations"));
+    
+    // Create Recorder Tab
+    QWidget* recorder_widget = new QWidget();
+    QVBoxLayout* recorder_layout = new QVBoxLayout();
+    
+    QLabel* recorder_title = new QLabel("Recording Topics");
+    recorder_title->setFont(font);
+    recorder_layout->addWidget(recorder_title);
+    
+    // Create scroll area for topics
+    QWidget* topics_container = new QWidget();
+    QVBoxLayout* topics_layout = new QVBoxLayout();
+    topics_container->setLayout(topics_layout);
+    
+    // Initialize default topics
+    selected_topics_ = {
+      "/scan",
+      "/camera_0/image_raw",
+      "/ackermann_curvature_drive",
+      "/car_status",
+      "/joystick",
+      "/imu",
+      "/odom"
+    };
+    
+    available_topics_ = {
+      "/scan",
+      "/camera_0/image_raw",
+      "/ackermann_curvature_drive",
+      "/car_status",
+      "/joystick",
+      "/imu",
+      "/odom",
+      "/tf",
+      "/tf_static"
+    };
+    
+    topic_buttons_.clear();
+    
+    for (const auto& topic : available_topics_) {
+      QPushButton* topic_btn = new QPushButton(QString::fromStdString(topic));
+      topic_btn->setFont(font);
+      topic_btn->setCheckable(true);
+      
+      // Check if topic is in selected list
+      bool is_selected = std::find(selected_topics_.begin(), 
+                                   selected_topics_.end(), 
+                                   topic) != selected_topics_.end();
+      topic_btn->setChecked(is_selected);
+      
+      connect(topic_btn, SIGNAL(clicked()), this, SLOT(ToggleTopicRecording()));
+      topic_buttons_.push_back(topic_btn);
+      topics_layout->addWidget(topic_btn);
+    }
+    
+    topics_layout->addStretch();
+    
+    recorder_layout->addWidget(topics_container);
+    recorder_widget->setLayout(recorder_layout);
+    
+    tab_widget_->addTab(recorder_widget, tr("Recorder"));
   }
 
   main_layout_ = new QVBoxLayout(this);
@@ -464,6 +533,10 @@ MainWindow::MainWindow(QWidget* parent) :
   connect(this,
           SIGNAL(UpdateCameraSignal(const QPixmap&)),
           SLOT(UpdateCameraSlot(const QPixmap&)));
+  
+  connect(this,
+          SIGNAL(UpdateRecordingStatusSignal(bool)),
+          SLOT(UpdateRecordingStatusSlot(bool)));
 }
 
 MainWindow::~MainWindow() {
@@ -737,4 +810,54 @@ void MainWindow::StopTmuxConfiguration() {
   }
 }
 
+void MainWindow::UpdateRecordingStatus(bool recording) {
+  UpdateRecordingStatusSignal(recording);
+}
+
+void MainWindow::UpdateRecordingStatusSlot(bool recording) {
+  if (recording_led_) {
+    recording_led_->SetStatus(recording);
+  }
+}
+
+void MainWindow::ToggleTopicRecording() {
+  QPushButton* button = qobject_cast<QPushButton*>(sender());
+  if (!button) return;
+  
+  // Find which topic was toggled
+  for (size_t i = 0; i < topic_buttons_.size(); ++i) {
+    if (topic_buttons_[i] == button) {
+      std::string topic = available_topics_[i];
+      
+      // Update selected topics list
+      auto it = std::find(selected_topics_.begin(), selected_topics_.end(), topic);
+      if (button->isChecked()) {
+        if (it == selected_topics_.end()) {
+          selected_topics_.push_back(topic);
+        }
+      } else {
+        if (it != selected_topics_.end()) {
+          selected_topics_.erase(it);
+        }
+      }
+      
+      // TODO: Publish updated topic list to recorder node
+      UpdateTopicsToRecord();
+      break;
+    }
+  }
+}
+
+void MainWindow::UpdateTopicsToRecord() {
+  // This will be called when topics are toggled
+  // For now, we'll log the change
+  std::string topics_str = "Selected topics: ";
+  for (const auto& topic : selected_topics_) {
+    topics_str += topic + ", ";
+  }
+  printf("%s\n", topics_str.c_str());
+  
+  // TODO: Publish to /recorder/set_topics topic
+}
+
 }  // namespace ut_automata_gui

src/gui/gui_mainwindow.h

@@ -68,7 +68,7 @@ class Led : public QWidget {
   Q_OBJECT
 
  public:
-  Led() : status_on_(false) {}
+  Led(bool is_recording_led = false) : status_on_(false), is_recording_led_(is_recording_led) {}
   void SetStatus(bool value) {
     if (status_on_ == value) return;
     status_on_ = value;
@@ -79,25 +79,38 @@ class Led : public QWidget {
   void paintEvent(QPaintEvent *event) override {
     static const QBrush kGreenBrush = QBrush(QColor(0, 225, 0));
     static const QBrush kRedBrush = QBrush(QColor(255, 0, 0));
+    static const QBrush kGreyBrush = QBrush(QColor(128, 128, 128));
     QPainter painter;
     painter.begin(this);
-    if (status_on_) {
-      painter.fillRect(QRectF(0, 0, width(), height()), kGreenBrush);
+    
+    if (is_recording_led_) {
+      // Recording LED: Red when recording (on), Grey when not recording (off)
+      if (status_on_) {
+        painter.fillRect(QRectF(0, 0, width(), height()), kRedBrush);
+      } else {
+        painter.fillRect(QRectF(0, 0, width(), height()), kGreyBrush);
+      }
     } else {
-      painter.fillRect(QRectF(0, 0, width(), height()), kRedBrush);
+      // Normal status LED: Green when okay (on), Red when not okay (off)
+      if (status_on_) {
+        painter.fillRect(QRectF(0, 0, width(), height()), kGreenBrush);
+      } else {
+        painter.fillRect(QRectF(0, 0, width(), height()), kRedBrush);
+      }
     }
     painter.end();
   }
 
  private:
   bool status_on_;
+  bool is_recording_led_;
 };
 
 class StatusLed : public QFrame {
   Q_OBJECT
 
  public:
-  explicit StatusLed(QString name);
+  explicit StatusLed(QString name, bool is_recording_led = false);
   void SetStatus(bool value);
 
  private:
@@ -156,6 +169,7 @@ class MainWindow : public QWidget {
                     float throttle,
                     float steering);
   void UpdateCamera(const QPixmap& image);
+  void UpdateRecordingStatus(bool recording);
 
 public slots:
   void closeWindow();
@@ -175,6 +189,9 @@ public slots:
   void UpdateTmuxConfigurations();
   void StartTmuxConfiguration();
   void StopTmuxConfiguration();
+  void UpdateRecordingStatusSlot(bool recording);
+  void UpdateTopicsToRecord();
+  void ToggleTopicRecording();
 
 signals:
   void UpdateQuestion(std::string question,
@@ -189,6 +206,7 @@ public slots:
                           float throttle,
                           float steering);
   void UpdateCameraSignal(const QPixmap& image);
+  void UpdateRecordingStatusSignal(bool recording);
 
 private:
 
@@ -221,6 +239,14 @@ public slots:
   QPushButton* stop_config_button_;
   std::vector<std::string> tmux_config_names_;
 
+  // Recording status
+  StatusLed* recording_led_;
+  
+  // Recording topic selection
+  std::vector<std::string> available_topics_;
+  std::vector<std::string> selected_topics_;
+  std::vector<QPushButton*> topic_buttons_;
+  
   // Helper functions for GUI-aware tmux configuration
   bool IsGuiNodeRunning();
   std::string CreateTmuxConfigWithoutGui(const std::string& config_name);