Remove async parameter queries that cause threading issues

Author: kPatch

coffee_ws/src/coffee_voice_agent_ui/coffee_voice_agent_ui/voice_agent_monitor_app.py

@@ -159,6 +159,9 @@ def __init__(self):
         except:
             pass  # Icon not critical
 
+        # Initialize configuration with reasonable defaults first
+        self._initialize_simple_config()
+        
         # Create central widget and layout
         central_widget = QWidget()
         self.setCentralWidget(central_widget)
@@ -204,6 +207,13 @@ def _setup_ui(self, central_widget):
         main_layout.setColumnStretch(0, 1)  # Status/Emotion column
         main_layout.setColumnStretch(1, 2)  # Conversation/Tools column (wider)
         main_layout.setColumnStretch(2, 1)  # Analytics/Controls column
+        
+        # Initialize conversation widget with default configuration
+        if hasattr(self, 'last_config_update'):
+            self.conversation_widget.update_configuration(
+                self.last_config_update['config_data'], 
+                "disconnected"  # Start as disconnected
+            )
 
     def _init_ros(self):
         """Initialize ROS2 node and connections"""
@@ -232,14 +242,6 @@ def _init_ros(self):
         self.ros_executor.add_node(self.ros_node)
         self.ros_thread = threading.Thread(target=self.ros_executor.spin, daemon=True)
         self.ros_thread.start()
-        
-        # Query and distribute initial configuration (with delay for bridge startup)
-        QTimer.singleShot(2000, self._query_and_distribute_config)  # Wait 2 seconds for bridge to initialize
-        
-        # Set up periodic config refresh in case bridge connects later
-        self.config_refresh_timer = QTimer()
-        self.config_refresh_timer.timeout.connect(self._retry_config_if_fallback)
-        self.config_refresh_timer.start(10000)  # Check every 10 seconds
 
     def _setup_timers(self):
         """Set up update timers for the UI"""
@@ -253,86 +255,16 @@ def _setup_timers(self):
         self.analytics_timer.timeout.connect(self._update_analytics)
         self.analytics_timer.start(1000)  # 1 FPS for analytics
 
-    def _query_and_distribute_config(self):
-        """Query configuration parameters from bridge and distribute to widgets"""
-        try:
-            # Query parameters from the voice agent bridge
-            config_data = {}
-            config_source = "fallback"
-            
-            # Try to get parameters from bridge using parameter client
-            try:
-                from rclpy.parameter_client import AsyncParameterClient
-                
-                # Create parameter client to query bridge node
-                param_client = AsyncParameterClient(self.ros_node, 'voice_agent_bridge')
-                
-                # Wait for bridge node to be available (timeout after 5 seconds)
-                if param_client.wait_for_services(timeout_sec=5.0):
-                    # Query timeout parameters from bridge
-                    parameter_names = ['user_response_timeout', 'max_conversation_time', 'config_received']
-                    
-                    # Use async parameter client - get future and wait for result
-                    future = param_client.get_parameters(parameter_names)
-                    
-                    # Spin until the future is complete (with timeout)
-                    import time
-                    start_time = time.time()
-                    timeout = 5.0
-                    
-                    while not future.done() and (time.time() - start_time) < timeout:
-                        rclpy.spin_once(self.ros_node, timeout_sec=0.1)
-                    
-                    if future.done():
-                        parameters = future.result().values
-                        
-                        config_data = {
-                            'user_response_timeout': parameters[0].double_value if parameters[0].type == 3 else 15.0,  # PARAMETER_DOUBLE = 3
-                            'max_conversation_time': parameters[1].double_value if parameters[1].type == 3 else 180.0
-                        }
-                        
-                        # Check if we got real configuration from agent using config_received flag
-                        config_received = parameters[2].bool_value if parameters[2].type == 1 else False  # PARAMETER_BOOL = 1
-                        if config_received:
-                            config_source = "agent"  # Bridge has received agent configuration
-                        else:
-                            config_source = "fallback"  # Bridge still using defaults
-                        
-                        self.ros_node.get_logger().info(f"Retrieved configuration from bridge: {config_data} (source: {config_source})")
-                    else:
-                        raise Exception("Parameter query timed out")
-                else:
-                    raise Exception("Bridge node not available")
-                
-            except Exception as e:
-                # Parameters not available, use fallback values
-                self.ros_node.get_logger().warn(f"Could not query bridge parameters: {e}, using fallback configuration")
-                config_data = {
-                    'user_response_timeout': 15.0,
-                    'max_conversation_time': 180.0
-                }
-                config_source = "fallback"
-            
-            # Distribute configuration to widgets
-            if hasattr(self, 'conversation_widget'):
-                self.conversation_widget.update_configuration(config_data, config_source)
-                self.ros_node.get_logger().info("Updated conversation widget configuration")
-            
-            # Add configuration info to analytics data
-            self.last_config_update = {
-                'config_data': config_data,
-                'config_source': config_source,
-                'timestamp': datetime.now()
-            }
-            
-        except Exception as e:
-            self.ros_node.get_logger().error(f"Error in configuration query and distribution: {e}")
-    
-    def _retry_config_if_fallback(self):
-        """Retry configuration query if still using fallback values"""
-        if (hasattr(self, 'last_config_update') and 
-            self.last_config_update.get('config_source') == 'fallback'):
-            self._query_and_distribute_config()
+    def _initialize_simple_config(self):
+        """Initialize configuration with reasonable defaults"""
+        self.last_config_update = {
+            'config_data': {
+                'user_response_timeout': 15.0,
+                'max_conversation_time': 180.0
+            },
+            'config_source': "fallback",
+            'timestamp': datetime.now()
+        }
 
     @pyqtSlot(AgentStatus)
     def _update_agent_status(self, status):
@@ -356,6 +288,12 @@ def _update_user_speech(self, speech):
     def _update_connection_status(self, connected):
         """Update UI with connection status"""
         self.agent_status_widget.update_connection(connected)
+        
+        # Update conversation widget configuration status based on connection
+        if hasattr(self, 'conversation_widget') and hasattr(self, 'last_config_update'):
+            config_data = self.last_config_update['config_data']
+            source = "connected" if connected else "disconnected"
+            self.conversation_widget.update_configuration(config_data, source)
 
     @pyqtSlot(str)
     def _send_virtual_request(self, request_json):
@@ -402,8 +340,6 @@ def closeEvent(self, event):
             self.update_timer.stop()
         if hasattr(self, 'analytics_timer'):
             self.analytics_timer.stop()
-        if hasattr(self, 'config_refresh_timer'):
-            self.config_refresh_timer.stop()
 
         # Clean up ROS
         if hasattr(self, 'ros_executor'):

coffee_ws/src/coffee_voice_agent_ui/coffee_voice_agent_ui/widgets/conversation_widget.py

@@ -164,13 +164,13 @@ def _setup_ui(self):
 
         layout.addLayout(metrics_layout)
 
-    def update_configuration(self, config_data, source="agent"):
+    def update_configuration(self, config_data, source="disconnected"):
         """
         Update widget configuration from monitor
         
         Args:
             config_data: Dictionary containing configuration values
-            source: Source of configuration ("agent", "fallback", "parameter_override")
+            source: Connection status ("connected", "disconnected")
         """
         # Update timeout values
         if 'user_response_timeout' in config_data:
@@ -183,19 +183,15 @@ def update_configuration(self, config_data, source="agent"):
         self.config_source = source
         self.config_timestamp = datetime.now()
 
-        # Update configuration status display
-        if source == "agent":
-            status_text = f"Agent ({self.user_response_timeout:.0f}s, {self.max_conversation_time/60:.0f}m)"
+        # Update configuration status display based on connection
+        if source == "connected":
+            status_text = f"Bridge Connected ({self.user_response_timeout:.0f}s, {self.max_conversation_time/60:.0f}m)"
             self.config_status_label.setText(status_text)
-            self.config_status_label.setStyleSheet("color: #28a745; font-size: 10px;")  # Green for agent
-        elif source == "parameter_override":
-            status_text = f"Override ({self.user_response_timeout:.0f}s, {self.max_conversation_time/60:.0f}m)"
-            self.config_status_label.setText(status_text)
-            self.config_status_label.setStyleSheet("color: #007bff; font-size: 10px;")  # Blue for override
+            self.config_status_label.setStyleSheet("color: #28a745; font-size: 10px;")  # Green for connected
         else:
-            status_text = f"Fallback ({self.user_response_timeout:.0f}s, {self.max_conversation_time/60:.0f}m)"
+            status_text = f"Bridge Disconnected ({self.user_response_timeout:.0f}s, {self.max_conversation_time/60:.0f}m)"
             self.config_status_label.setText(status_text)
-            self.config_status_label.setStyleSheet("color: #ffc107; font-size: 10px;")  # Yellow for fallback
+            self.config_status_label.setStyleSheet("color: #dc3545; font-size: 10px;")  # Red for disconnected
 
     def update_agent_state(self, status: AgentStatus):
         """Update conversation state from agent status"""