Make it remember previous settings and log everything to a csv file

Author: erdemsimsek

Cargo.lock

@@ -25,6 +25,8 @@ CanOpenDataViewer/
 * **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.
+* **Configuration Persistence:** Automatically saves and restores your last used settings (CAN interface, Node ID, EDS file path, logging preferences). No need to re-enter configuration on every startup.
+* **Automatic File Logging:** Optionally log all SDO data, connection events, and errors to CSV files with timestamps. Logs are saved to `~/.local/share/canopen-viewer/logs/` by default. Enable/disable logging via the checkbox in the top panel, and open the log folder with one click.
 * **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.
@@ -128,11 +130,11 @@ 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: `examples/mock_node.eds` (for testing with mock node)
-    - Click "Start"
+    - **First time:** Select CAN interface (`vcan0`), enter Node ID (`4`), and select EDS file (`examples/mock_node.eds`)
+    - **Subsequent times:** Your last configuration will be automatically loaded - just click through the steps
+    - Click "Start" - your settings will be saved automatically
     - **You should see:** Green "● Connected" status in the top panel
+    - **Optional:** Enable logging with the "Enable Logging" checkbox (top-right) to record all events to CSV
     - 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
 
@@ -193,6 +195,26 @@ This ensures the user is always presented with information in its most useful fo
 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
 
+### Logging Issues
+
+**Problem:** Logging checkbox doesn't work or logs aren't being created.
+
+**Solution:**
+1. Check that the log directory is writable: `~/.local/share/canopen-viewer/logs/`
+2. If the directory doesn't exist, the application will try to create it automatically
+3. Click "Open Log Folder" button to view the log directory in your file manager
+4. Log files are named: `canopen_log_YYYYMMDD_HHMMSS.csv`
+
+**Log File Format:**
+- CSV format with headers: `Timestamp, Event Type, Address, Value, Message`
+- Event types: `SDO_DATA`, `SDO_ERROR`, `CONNECTION_FAILED`, `CONNECTION_STATUS`
+- Open with any spreadsheet application (Excel, LibreOffice Calc, etc.)
+
+**Configuration File Location:**
+- Configuration is saved to: `~/.config/canopen-viewer/config.toml`
+- You can manually edit this file if needed
+- Fields: `can_interface`, `node_id`, `eds_file_path`, `enable_logging`, `log_directory`
+
 ## Roadmap
 
 * []

README.md

@@ -17,5 +17,12 @@ egui_plot = "0.31.0"
 image = "0.25.1"
 chrono = "0.4.41"
 
+# Configuration and logging
+serde = { version = "1.0", features = ["derive"] }
+toml = "0.8"
+csv = "1.3"
+directories = "5.0"
+open = "5.0"
+
 # This will use the shared CANopen protocol code
 canopen-common = { path = "../canopen-common" }

canopen-viewer/Cargo.toml

@@ -0,0 +1,97 @@
+use std::path::PathBuf;
+use serde::{Deserialize, Serialize};
+use std::fs;
+
+#[derive(Debug, Clone, Serialize, Deserialize)]
+pub struct AppConfig {
+    pub can_interface: String,
+    pub node_id: u8,
+    pub eds_file_path: Option<String>,
+    pub enable_logging: bool,
+    pub log_directory: Option<String>,
+}
+
+impl Default for AppConfig {
+    fn default() -> Self {
+        Self {
+            can_interface: String::new(),
+            node_id: 1,
+            eds_file_path: None,
+            enable_logging: true,
+            log_directory: None,
+        }
+    }
+}
+
+impl AppConfig {
+    /// Get the path to the config file
+    pub fn config_file_path() -> Option<PathBuf> {
+        directories::ProjectDirs::from("com", "canopen", "canopen-viewer")
+            .map(|proj_dirs| {
+                let config_dir = proj_dirs.config_dir();
+                config_dir.join("config.toml")
+            })
+    }
+
+    /// Load configuration from file, returns default if file doesn't exist or on error
+    pub fn load() -> Self {
+        if let Some(config_path) = Self::config_file_path() {
+            if config_path.exists() {
+                match fs::read_to_string(&config_path) {
+                    Ok(contents) => {
+                        match toml::from_str(&contents) {
+                            Ok(config) => {
+                                println!("✓ Loaded configuration from {:?}", config_path);
+                                return config;
+                            }
+                            Err(e) => {
+                                eprintln!("Failed to parse config file: {}", e);
+                            }
+                        }
+                    }
+                    Err(e) => {
+                        eprintln!("Failed to read config file: {}", e);
+                    }
+                }
+            }
+        }
+
+        println!("Using default configuration");
+        Self::default()
+    }
+
+    /// Save configuration to file
+    pub fn save(&self) -> Result<(), Box<dyn std::error::Error>> {
+        if let Some(config_path) = Self::config_file_path() {
+            // Create config directory if it doesn't exist
+            if let Some(parent) = config_path.parent() {
+                fs::create_dir_all(parent)?;
+            }
+
+            let toml_string = toml::to_string_pretty(self)?;
+            fs::write(&config_path, toml_string)?;
+            println!("✓ Saved configuration to {:?}", config_path);
+            Ok(())
+        } else {
+            Err("Could not determine config file path".into())
+        }
+    }
+
+    /// Get the default log directory path
+    pub fn default_log_directory() -> Option<PathBuf> {
+        directories::ProjectDirs::from("com", "canopen", "canopen-viewer")
+            .map(|proj_dirs| {
+                let data_dir = proj_dirs.data_local_dir();
+                data_dir.join("logs")
+            })
+    }
+
+    /// Get the log directory as PathBuf, using default if not set
+    pub fn get_log_directory(&self) -> Option<PathBuf> {
+        if let Some(ref dir) = self.log_directory {
+            Some(PathBuf::from(dir))
+        } else {
+            Self::default_log_directory()
+        }
+    }
+}