Improvement on error reporting and user feedback

erdemsimsek · erdemsimsek · commit 685825418d21 · 2025-10-12T18:43:05.000+01:00
diff --git a/README.md b/README.md
@@ -23,6 +23,8 @@ CanOpenDataViewer/
 
 * **Real-time Plotting:** Visualize numeric TPDO and SDO data as it arrives from the CAN bus using a smooth, high-performance plot.
 * **Configurable SDO Polling:** Select any SDO from a device's Object Dictionary, set a custom polling rate for each, and see the values plotted or logged in real-time.
+* **Node Health Monitoring:** Automatic health checks verify that the CANopen node is alive by periodically reading the mandatory Device Type object (0x1000:00). Detects node disconnection within 4-6 seconds and updates the UI accordingly.
+* **Connection Status & Error Reporting:** Clear visual indicators show whether the node is connected (green) or disconnected (red). All connection failures and SDO read errors are displayed in dismissible error banners with detailed messages.
 * **Selective TPDO Monitoring:** The UI automatically lists all available Transmit-PDOs from a device profile. Simply check the ones you want to monitor.
 * **Intelligent Data Handling:**
     * **Numeric** PDO data is automatically sent to the real-time plot.
@@ -66,8 +68,12 @@ This ensures the user is always presented with information in its most useful fo
 3.  **Configure Monitoring:**
     * For **TPDOs**, the user simply checks a box next to each PDO they wish to monitor.
     * For **SDOs**, the user selects an SDO and enters a polling interval in milliseconds (e.g., `250ms`).
-4.  **Start Session:** The user clicks "Connect". The CAN thread starts, begins polling the configured SDOs at their specified rates, and listens for all incoming TPDOs.
-5.  **View Data:** As messages arrive, the application checks if they are on the user's monitoring list and handles them according to the design philosophy: plotting numeric data and logging everything else.
+4.  **Start Session:** The user clicks "Start". The CAN thread establishes the connection and begins health monitoring.
+5.  **Monitor Connection:** The application automatically checks node health every 2 seconds by reading the Device Type object (0x1000:00). The UI displays:
+    * **Green "● Connected"** when the node responds to health checks
+    * **Red "● Disconnected"** when the node stops responding (after 2 consecutive failures)
+    * **Error banners** for connection failures or SDO read errors (click "✖" to dismiss)
+6.  **View Data:** As messages arrive, the application checks if they are on the user's monitoring list and handles them according to the design philosophy: plotting numeric data and logging everything else.
 
 ## Technology Stack
 
@@ -124,8 +130,68 @@ This ensures the user is always presented with information in its most useful fo
     Then in the GUI:
     - Select CAN interface: `vcan0`
     - Enter Node ID: `4`
-    - Select EDS file (or skip for testing)
-    - Click "Start" and subscribe to SDOs
+    - Select EDS file: `examples/mock_node.eds` (for testing with mock node)
+    - Click "Start"
+    - **You should see:** Green "● Connected" status in the top panel
+    - Subscribe to SDOs via the "Subscribe to SDO" button
+    - **Try it:** Stop the mock node (Ctrl+C in Terminal 1) and watch the status change to red "● Disconnected" within 4-6 seconds
+
+## Troubleshooting
+
+### "Network is down (os error 100)" or Connection Failed
+
+**Problem:** Error banner appears immediately after clicking "Start" with message about network being down.
+
+**Solution:**
+1. Check if the CAN interface exists and is UP:
+   ```bash
+   ip link show vcan0
+   ```
+
+2. If the interface doesn't exist or is DOWN, set it up:
+   ```bash
+   sudo modprobe vcan
+   sudo ip link add dev vcan0 type vcan
+   sudo ip link set up vcan0
+   ```
+
+3. Verify the interface is UP:
+   ```bash
+   ip link show vcan0
+   # Should show: "vcan0: <NOARP,UP,LOWER_UP> ..."
+   ```
+
+### Connection Shows "Disconnected" Even Though Mock Node is Running
+
+**Problem:** The status indicator shows red "● Disconnected" even when the mock node is running.
+
+**Possible causes:**
+1. **Wrong Node ID:** Ensure the Node ID in the viewer matches the mock node's `--node-id` parameter (default: 4)
+2. **Wrong Interface:** Ensure both applications are using the same CAN interface (e.g., `vcan0`)
+3. **Mock Node Crashed:** Check Terminal 1 for errors in the mock node output
+4. **Node Missing 0x1000:00:** The health check reads Device Type (0x1000:00), which must exist in the node's object dictionary
+
+### SDO Read Errors
+
+**Problem:** Error banner shows "SDO Read Error: 0xXXXX:YY - request failed: sdo request timeout"
+
+**Possible causes:**
+1. **Object doesn't exist:** The SDO address may not be implemented in the node
+2. **Node stopped responding:** Check if the mock node is still running
+3. **Wrong data type:** The data type selected in the subscription doesn't match the object's actual type in the EDS file
+
+**Solution:**
+- Verify the object exists in the EDS file and is marked as readable (`accesstype=ro` or `accesstype=rw`)
+- Check that the mock node is still running and hasn't crashed
+- Ensure the data type matches what's specified in the EDS file
+
+### Application Freezes or Unresponsive
+
+**Problem:** The UI becomes unresponsive or freezes.
+
+**This shouldn't happen!** The application is designed with a non-blocking UI architecture. If you encounter this:
+1. Check CPU usage - the application should use minimal CPU when idle
+2. Report the issue with steps to reproduce at: https://github.com/erdemsimsek/CanOpenDataViewer/issues
 
 ## Roadmap
 
diff --git a/canopen-viewer/src/communication.rs b/canopen-viewer/src/communication.rs
@@ -49,14 +49,18 @@ pub enum Command {
 #[derive(Debug)]
 pub enum Update {
     SdoList(BTreeMap<u16, SdoObject>),
-    #[allow(dead_code)]  // TODO: Will be used in Priority 1 fixes for connection status
+    #[allow(dead_code)]  // TODO: Will be used for successful connection notifications
     ConnectionSuccess(BTreeMap<u16, SdoObject>),
-    #[allow(dead_code)]  // TODO: Will be used in Priority 1 fixes for error reporting
     ConnectionFailed(String),
+    ConnectionStatus(bool),  // true = node alive, false = node not responding
     SdoData {
         address: SdoAddress,
         value: String,
     },
+    SdoReadError {
+        address: SdoAddress,
+        error: String,
+    },
 }
 
 async fn sdo_polling_task(
@@ -86,11 +90,57 @@ async fn sdo_polling_task(
                     value: value_string,
                 });
             },
-            _ => {}
+            Err(err) => {
+                let _ = update_tx.send(Update::SdoReadError {
+                    address: address.clone(),
+                    error: err.to_string(),
+                });
+            }
         };
     }
 }
 
+/// Health check task that periodically reads Device Type (0x1000:00) to verify node is alive
+async fn health_check_task(
+    update_tx: Sender<Update>,
+    node_handle: CANopenNodeHandle,
+) {
+    let mut interval = tokio::time::interval(Duration::from_secs(2));
+    let mut consecutive_failures = 0;
+    const MAX_FAILURES: u32 = 2; // Mark disconnected after 2 consecutive failures
+
+    loop {
+        interval.tick().await;
+
+        // Read mandatory Device Type object (0x1000:00)
+        let request = SdoRequest {
+            node_id: node_handle.node_id(),
+            index: 0x1000,
+            subindex: 0x00,
+            expected_type: SdoDataType::UInt32,
+        };
+
+        match node_handle.sdo_read(request).await {
+            Ok(_) => {
+                // Node is alive
+                consecutive_failures = 0;
+                let _ = update_tx.send(Update::ConnectionStatus(true));
+            },
+            Err(err) => {
+                // Node not responding
+                consecutive_failures += 1;
+                if consecutive_failures >= MAX_FAILURES {
+                    println!("Health check failed: {}", err);
+                    let _ = update_tx.send(Update::ConnectionStatus(false));
+                    let _ = update_tx.send(Update::ConnectionFailed(
+                        format!("Node not responding: {}", err)
+                    ));
+                }
+            }
+        }
+    }
+}
+
 // Make the main function for the thread public as well.
 pub fn communication_thread_main(
     command_rx: Receiver<Command>,
@@ -102,6 +152,7 @@ pub fn communication_thread_main(
 
     let rt = tokio::runtime::Runtime::new().unwrap();
     let mut subscription_handles: HashMap<SdoAddress, JoinHandle<()>> = HashMap::new();
+    let mut _health_check_handle: Option<JoinHandle<()>> = None;
     // Keep connection alive - it owns the background CAN reader task
     let mut _connection_handle: Option<CANopenConnection> = None;
     let mut node_handle: Option<CANopenNodeHandle> = None;
@@ -117,7 +168,17 @@ pub fn communication_thread_main(
                 }){
                     Ok((conn, handle)) => {
                         _connection_handle = Some(conn);
-                        node_handle = Some(handle);
+                        node_handle = Some(handle.clone());
+
+                        // Spawn health check task to monitor node
+                        let update_tx_clone = update_tx.clone();
+                        let health_handle = rt.spawn(health_check_task(
+                            update_tx_clone,
+                            handle,
+                        ));
+                        _health_check_handle = Some(health_handle);
+
+                        println!("Connection established, health check started");
                     },
                     Err(err) => {
                         let _ = update_tx.send(Update::ConnectionFailed(err.to_string()));
diff --git a/canopen-viewer/src/main.rs b/canopen-viewer/src/main.rs
@@ -46,6 +46,7 @@ struct MyApp {
     update_rx: Option<Receiver<Update>>,
 
     connection_status: bool,
+    connection_requested: bool,
 
     sdo_requested : bool,
     sdo_data : Option<BTreeMap<u16, SdoObject>>,
@@ -57,7 +58,10 @@ struct MyApp {
     modal_open_for: Option<SdoAddress>,
     modal_interval_str: String,
 
-    sdo_search_query: String
+    sdo_search_query: String,
+
+    // Error reporting
+    error_message: Option<String>,
 }
 
 
@@ -75,6 +79,7 @@ impl Default for MyApp {
             update_rx: None,
 
             connection_status: false,
+            connection_requested: false,
 
             sdo_requested: false,
             sdo_data: None,
@@ -84,7 +89,9 @@ impl Default for MyApp {
             modal_open_for: None,
             modal_interval_str: String::new(),
 
-            sdo_search_query: String::new()
+            sdo_search_query: String::new(),
+
+            error_message: None,
         }
     }
 }
@@ -112,6 +119,16 @@ impl eframe::App for MyApp {
                         }
                     }
                 }
+                Update::ConnectionFailed(error) => {
+                    self.error_message = Some(format!("Connection Error: {}", error));
+                    self.connection_status = false;
+                }
+                Update::ConnectionStatus(is_alive) => {
+                    self.connection_status = is_alive;
+                }
+                Update::SdoReadError { address, error } => {
+                    self.error_message = Some(format!("SDO Read Error [{:#06X}:{:02X}]: {}", address.index, address.sub_index, error));
+                }
                 _ => {
 
                 }
@@ -305,21 +322,56 @@ impl MyApp {
 
     /// Draws the main application view.
     fn draw_main_view(&mut self, ui: &mut egui::Ui) {
-        if !self.connection_status {
+        // Request connection only once at startup
+        if !self.connection_requested {
             if let Some(tx) = &self.command_tx {
                 tx.send(Command::Connect).unwrap();
             }
-            self.connection_status = true;
+            self.connection_requested = true;
         }
-        
-        
+
         if !self.sdo_requested {
             if let Some(tx) = &self.command_tx {
                 tx.send(Command::FetchSdos).unwrap();
                 self.sdo_requested = true;
             }
         }
 
+        // Top panel for status and error display
+        egui::TopBottomPanel::top("status_panel").show_inside(ui, |ui| {
+            ui.horizontal(|ui| {
+                // Connection status indicator
+                let status_color = if self.connection_status {
+                    Color32::from_rgb(0, 200, 0) // Green
+                } else {
+                    Color32::from_rgb(200, 0, 0) // Red
+                };
+                let status_text = if self.connection_status { "● Connected" } else { "● Disconnected" };
+                ui.colored_label(status_color, status_text);
+
+                ui.separator();
+
+                // Show interface and node ID info
+                if let Some(interface) = &self.selected_can_interface {
+                    ui.label(format!("Interface: {}", interface));
+                }
+                if let Some(node_id) = self.selected_node_id {
+                    ui.label(format!("Node ID: {}", node_id));
+                }
+            });
+
+            // Error banner
+            if let Some(error_msg) = self.error_message.clone() {
+                ui.separator();
+                ui.horizontal(|ui| {
+                    ui.colored_label(Color32::from_rgb(255, 100, 100), format!("⚠ {}", error_msg));
+                    if ui.button("✖").clicked() {
+                        self.error_message = None; // Clear error on click
+                    }
+                });
+            }
+        });
+
         // Creating panels. Left panel for SDO data, right panel for graphing.
         egui::SidePanel::left("sdo_list_panel").show_inside(ui, |ui| {
             self.draw_sdo_list(ui);
