Integrate real device detection into Dashboard UI

- Replace simulated dongle detection with actual kp.core.scan_devices()
- Display real device series (KL520, KL720, etc.) and port IDs in UI
- Add device information management methods (get_detected_devices, refresh_dongle_detection, etc.)
- Enhanced performance estimation based on actual detected devices
- Add device-specific optimization suggestions and warnings
- Fallback to simulation mode if device scanning fails
- Store detected device info for use throughout the application

The Dashboard now shows real Kneron device information when "Detect Dongles" is clicked,
displaying format: "KL520 Dongle - Port 28" with total device count.

🤖 Generated with [Claude Code](https://claude.ai/code)

Co-Authored-By: Claude <noreply@anthropic.com>

cluster4npu_ui/ui/windows/dashboard.py

@@ -162,6 +162,7 @@ class IntegratedPipelineDashboard(QMainWindow):
         self.memory_label = None
         self.suggestions_text = None
         self.dongles_list = None
+        self.detected_devices = []  # Store detected device information
         self.stage_count_widget = None
         self.analysis_timer = None
         self.previous_stage_count = 0
@@ -1445,27 +1446,116 @@ class IntegratedPipelineDashboard(QMainWindow):
     
     
     def detect_dongles(self):
-        """Detect available dongles."""
+        """Detect available dongles using actual device scanning."""
         if not self.dongles_list:
             return
         
         self.dongles_list.clear()
-        # Simulate dongle detection
+        
-        self.dongles_list.addItem("Simulated KL520 Dongle - Port 28")
+        try:
-        self.dongles_list.addItem("Simulated KL720 Dongle - Port 32") 
+            # Import MultiDongle for device scanning
-        self.dongles_list.addItem("No additional dongles detected")
+            from cluster4npu_ui.core.functions.Multidongle import MultiDongle
+            
+            # Scan for available devices
+            devices = MultiDongle.scan_devices()
+            
+            if devices:
+                # Add detected devices to the list
+                for device in devices:
+                    port_id = device['port_id']
+                    series = device['series']
+                    self.dongles_list.addItem(f"{series} Dongle - Port {port_id}")
+                
+                # Add summary item
+                self.dongles_list.addItem(f"Total: {len(devices)} device(s) detected")
+                
+                # Store device info for later use
+                self.detected_devices = devices
+                
+            else:
+                self.dongles_list.addItem("No Kneron devices detected")
+                self.detected_devices = []
+                
+        except Exception as e:
+            # Fallback to simulation if scanning fails
+            self.dongles_list.addItem("Device scanning failed - using simulation")
+            self.dongles_list.addItem("Simulated KL520 Dongle - Port 28")
+            self.dongles_list.addItem("Simulated KL720 Dongle - Port 32")
+            self.detected_devices = []
+            
+            # Print error for debugging
+            print(f"Dongle detection error: {str(e)}")
+    
+    def get_detected_devices(self):
+        """
+        Get the list of detected devices with their port IDs and series.
+        
+        Returns:
+            List[Dict]: List of device information with port_id and series
+        """
+        return getattr(self, 'detected_devices', [])
+    
+    def refresh_dongle_detection(self):
+        """
+        Refresh the dongle detection and update the UI.
+        This can be called when dongles are plugged/unplugged.
+        """
+        self.detect_dongles()
+        
+        # Update any other UI components that depend on dongle detection
+        self.update_performance_estimation()
+    
+    def get_available_ports(self):
+        """
+        Get list of available port IDs from detected devices.
+        
+        Returns:
+            List[int]: List of available port IDs
+        """
+        return [device['port_id'] for device in self.get_detected_devices()]
+    
+    def get_device_by_port(self, port_id):
+        """
+        Get device information by port ID.
+        
+        Args:
+            port_id (int): Port ID to search for
+            
+        Returns:
+            Dict or None: Device information if found, None otherwise
+        """
+        for device in self.get_detected_devices():
+            if device['port_id'] == port_id:
+                return device
+        return None
     
     def update_performance_estimation(self):
-        """Update performance metrics."""
+        """Update performance metrics based on pipeline and detected devices."""
         if not all([self.fps_label, self.latency_label, self.memory_label]):
             return
         
-        # Simple performance estimation
+        # Enhanced performance estimation with device information
         if self.graph:
             num_nodes = len(self.graph.all_nodes())
-            estimated_fps = max(1, 60 - (num_nodes * 5))
+            num_devices = len(self.get_detected_devices())
-            estimated_latency = num_nodes * 10
+            
-            estimated_memory = num_nodes * 50
+            # Base performance calculation
+            base_fps = max(1, 60 - (num_nodes * 5))
+            base_latency = num_nodes * 10
+            base_memory = num_nodes * 50
+            
+            # Adjust for device availability
+            if num_devices > 0:
+                # More devices can potentially improve performance
+                device_multiplier = min(1.5, 1 + (num_devices - 1) * 0.1)
+                estimated_fps = int(base_fps * device_multiplier)
+                estimated_latency = max(5, int(base_latency / device_multiplier))
+                estimated_memory = base_memory  # Memory usage doesn't change much
+            else:
+                # No devices detected - show warning performance
+                estimated_fps = 1
+                estimated_latency = 999
+                estimated_memory = base_memory
             
             self.fps_label.setText(f"{estimated_fps} FPS")
             self.latency_label.setText(f"{estimated_latency} ms")
@@ -1473,10 +1563,26 @@ class IntegratedPipelineDashboard(QMainWindow):
             
             if self.suggestions_text:
                 suggestions = []
+                
+                # Device-specific suggestions
+                if num_devices == 0:
+                    suggestions.append("No Kneron devices detected. Connect dongles to enable inference.")
+                elif num_devices < num_nodes:
+                    suggestions.append(f"Consider connecting more devices ({num_devices} available, {num_nodes} pipeline stages).")
+                
+                # Performance suggestions
                 if num_nodes > 5:
                     suggestions.append("Consider reducing the number of pipeline stages for better performance.")
-                if estimated_fps < 30:
+                if estimated_fps < 30 and num_devices > 0:
                     suggestions.append("Current configuration may not achieve real-time performance.")
+                
+                # Hardware-specific suggestions
+                detected_devices = self.get_detected_devices()
+                if detected_devices:
+                    device_series = set(device['series'] for device in detected_devices)
+                    if len(device_series) > 1:
+                        suggestions.append(f"Mixed device types detected: {', '.join(device_series)}. Performance may vary.")
+                
                 if not suggestions:
                     suggestions.append("Pipeline configuration looks good for optimal performance.")