feat: Add external RTC interrupt configuration commands

- Add new 'rtc' command group with status, config, and show subcommands
- Support configuring external PCF2131 RTC interrupt actions:
  - none: Just log interrupt events
  - wake: Always wake i.MX93 on interrupt
  - auto: Auto-power i.MX93 if PMIC is currently off
- Add JSON parsing support for RTC status responses
- Update CLI documentation with v2.4.0 features
- Maintain backward compatibility with existing commands

This enables runtime configuration of the PMU's response to external
RTC interrupts without requiring firmware updates.

Author: Alex J Lennon

README.md

@@ -19,11 +19,19 @@ The E-ink Power CLI is a Rust-based command-line tool designed to communicate wi
 - **Power Management**: Control PMIC, WiFi, and display power rails
 - **Battery Monitoring**: Real-time LTC2959 coulomb counter readings
 - **System Control**: GPIO manipulation, system information, and diagnostics
+- **🆕 RTC Management**: External PCF2131 RTC interrupt configuration (v2.4.0+)
 - **🆕 Firmware Management**: Upload firmware via mcumgr with progress indication (v2.3.0)
 - **Board Control**: E-Ink controller reset and shutdown (WiFi+Display+PMIC)
 - **Automation**: JSON/CSV output formats and batch operations
 
-## What's New in v2.3.0
+## What's New in v2.4.0
+
+- **🕐 RTC Management**: External PCF2131 RTC interrupt configuration and monitoring
+- **⚙️ Auto-Power Mode**: Configure PMU to auto-power i.MX93 when PMIC is off
+- **📊 Interrupt Tracking**: Monitor external RTC interrupt events and statistics
+- **🔧 Runtime Configuration**: Change RTC interrupt actions without firmware updates
+
+## Previous Release - v2.3.0
 
 - **🚀 Firmware Management**: Complete firmware upload with mcumgr integration
 - **📊 Progress Indication**: Real-time upload progress and boot countdown
@@ -73,6 +81,13 @@ eink-power-cli board shutdown  # WiFi+Display+PMIC power off
 eink-power-cli gpio get gpioa 5
 eink-power-cli gpio set gpiob 3 1
 
+# RTC management (NEW in v2.4.0+)
+eink-power-cli rtc status              # Show RTC status and interrupt events
+eink-power-cli rtc config auto         # Auto-power i.MX93 if PMIC is off
+eink-power-cli rtc config wake         # Always wake i.MX93 on interrupt
+eink-power-cli rtc config none         # Just log interrupt events
+eink-power-cli rtc show               # Show current configuration
+
 # Get system information
 eink-power-cli system info
 
@@ -145,6 +160,15 @@ eink-power-cli nfc info                   # Device information
 eink-power-cli nfc field-detect           # Check field detection
 ```
 
+### RTC Management (v2.4.0+)
+```bash
+eink-power-cli rtc status                 # Show RTC status and interrupt events
+eink-power-cli rtc config none            # No action - just log events
+eink-power-cli rtc config wake            # Always wake i.MX93 on interrupt
+eink-power-cli rtc config auto            # Auto-power i.MX93 if PMIC is off
+eink-power-cli rtc show                   # Show current configuration
+```
+
 ## Configuration
 
 Create a configuration file at `~/.config/eink-power-cli/config.toml`:

src/cli/mod.rs

@@ -100,6 +100,10 @@ pub enum Commands {
     #[command(subcommand)]
     Pm(PowerManagementCommands),
 
+    /// RTC (Real-Time Clock) commands
+    #[command(subcommand)]
+    Rtc(RtcCommands),
+
     /// Firmware management commands
     #[command(subcommand)]
     Firmware(FirmwareCommands),
@@ -314,3 +318,29 @@ pub enum MonitorAction {
     Start,
     Stop,
 }
+
+/// RTC (Real-Time Clock) commands
+#[derive(Subcommand, Debug, Clone)]
+pub enum RtcCommands {
+    /// Show RTC status (internal + external PCF2131)
+    Status,
+    /// Configure external RTC interrupt action
+    Config {
+        /// External RTC interrupt action
+        #[arg(value_enum)]
+        action: ExternalRtcAction,
+    },
+    /// Show external RTC interrupt configuration
+    Show,
+}
+
+/// External RTC interrupt actions
+#[derive(ValueEnum, Clone, Debug)]
+pub enum ExternalRtcAction {
+    /// No action - just log the event
+    None,
+    /// Always wake i.MX93 when interrupt occurs
+    Wake,
+    /// Auto-power i.MX93 if PMIC is currently off
+    Auto,
+}

src/json.rs

@@ -94,6 +94,33 @@ pub struct GpioJson {
     pub state: Option<String>,
 }
 
+/// RTC status information in JSON format
+#[derive(Debug, Serialize, Deserialize)]
+pub struct RtcStatusJson {
+    pub internal_rtc: InternalRtcJson,
+    pub external_rtc: ExternalRtcJson,
+    pub last_wake_source: Option<String>,
+}
+
+/// Internal RTC information
+#[derive(Debug, Serialize, Deserialize)]
+pub struct InternalRtcJson {
+    pub wake_events: Option<u32>,
+    pub status: Option<String>,
+    pub function: Option<String>,
+}
+
+/// External RTC (PCF2131) information
+#[derive(Debug, Serialize, Deserialize)]
+pub struct ExternalRtcJson {
+    pub interrupt_events: Option<u32>,
+    pub status: Option<String>,
+    pub connection: Option<String>,
+    pub i2c_address: Option<String>,
+    pub function: Option<String>,
+    pub interrupt_action: Option<String>,
+}
+
 /// NFC status for JSON output
 #[derive(Debug, Serialize, Deserialize)]
 pub struct NfcJson {
@@ -371,4 +398,58 @@ impl ResponseParser {
 
         gpio
     }
+
+    /// Parse RTC status response into JSON
+    pub fn parse_rtc_status(response: &str) -> RtcStatusJson {
+        let mut rtc = RtcStatusJson {
+            internal_rtc: InternalRtcJson {
+                wake_events: None,
+                status: None,
+                function: Some("Periodic maintenance and battery monitoring".to_string()),
+            },
+            external_rtc: ExternalRtcJson {
+                interrupt_events: None,
+                status: None,
+                connection: Some("INTB# → PTC5 (LLWU_P9) - Active LOW".to_string()),
+                i2c_address: Some("0x53".to_string()),
+                function: Some("Alarms, timers, watchdog, timestamps".to_string()),
+                interrupt_action: None,
+            },
+            last_wake_source: None,
+        };
+
+        // Parse internal RTC wake events
+        if let Some(caps) = regex::Regex::new(r"Internal RTC.*?Wake events:\s*(\d+)")
+            .unwrap()
+            .captures(response)
+        {
+            rtc.internal_rtc.wake_events = Some(caps[1].parse().unwrap_or(0));
+        }
+
+        // Parse external RTC interrupt events
+        if let Some(caps) = regex::Regex::new(r"External RTC.*?Interrupt events:\s*(\d+)")
+            .unwrap()
+            .captures(response)
+        {
+            rtc.external_rtc.interrupt_events = Some(caps[1].parse().unwrap_or(0));
+        }
+
+        // Parse interrupt action
+        if let Some(caps) = regex::Regex::new(r"Interrupt Action:\s*(.+)")
+            .unwrap()
+            .captures(response)
+        {
+            rtc.external_rtc.interrupt_action = Some(caps[1].trim().to_string());
+        }
+
+        // Parse last wake source
+        if let Some(caps) = regex::Regex::new(r"Last Wake Source:\s*(.+)")
+            .unwrap()
+            .captures(response)
+        {
+            rtc.last_wake_source = Some(caps[1].trim().to_string());
+        }
+
+        rtc
+    }
 }

src/main.rs

@@ -131,6 +131,10 @@ fn output_response(
                         json::ResponseParser::parse_gpio_response(response, "unknown", 0);
                     serde_json::to_value(gpio_data)?
                 }
+                cmd if cmd.contains("rtc") => {
+                    let rtc_data = json::ResponseParser::parse_rtc_status(response);
+                    serde_json::to_value(rtc_data)?
+                }
                 _ => {
                     // Generic response - just wrap the raw text
                     serde_json::json!({
@@ -474,6 +478,28 @@ async fn execute_command(
                 }
             }
         }
+        Commands::Rtc(rtc_cmd) => {
+            use cli::{RtcCommands, ExternalRtcAction};
+            match rtc_cmd {
+                RtcCommands::Status => {
+                    let response = controller.rtc_status().await?;
+                    output_response(cli, "rtc status", &response, "🕐", "RTC Status")?;
+                }
+                RtcCommands::Config { action } => {
+                    let action_str = match action {
+                        ExternalRtcAction::None => "none",
+                        ExternalRtcAction::Wake => "wake",
+                        ExternalRtcAction::Auto => "auto",
+                    };
+                    let response = controller.rtc_config(action_str).await?;
+                    output_response(cli, "rtc config", &response, "⚙️", "RTC Configuration")?;
+                }
+                RtcCommands::Show => {
+                    let response = controller.rtc_show_config().await?;
+                    output_response(cli, "rtc show", &response, "📋", "RTC Configuration")?;
+                }
+            }
+        }
         Commands::Firmware(firmware_cmd) => {
             use cli::FirmwareCommands;
 

src/power/control.rs

@@ -185,6 +185,24 @@ impl PowerController {
         self.protocol.execute_nfc_command(cmd).await
     }
 
+    /// Get RTC status (internal + external PCF2131)
+    pub async fn rtc_status(&mut self) -> Result<String> {
+        info!("Getting RTC status");
+        self.protocol.execute_power_command("rtc", "").await
+    }
+
+    /// Configure external RTC interrupt action
+    pub async fn rtc_config(&mut self, action: &str) -> Result<String> {
+        info!("Configuring external RTC action: {}", action);
+        self.protocol.execute_power_command("rtc_config", action).await
+    }
+
+    /// Show external RTC interrupt configuration
+    pub async fn rtc_show_config(&mut self) -> Result<String> {
+        info!("Getting external RTC configuration");
+        self.protocol.execute_power_command("rtc_config", "status").await
+    }
+
     /// Parse power statistics response
     fn parse_power_stats(&self, response: &str) -> Result<PowerStats> {
         debug!("Parsing power stats: {}", response);