STUSB4500: prohibit reset when battery is low

Prohibit reset for 1 minute when battery is very low.
This should avoid a power loss during start of charging.

Author: surban

openemc-firmware/src/main.rs

@@ -544,7 +544,7 @@ mod app {
         blink_charging!(board, delay, watchman, 8);
 
         // Initialize power supplies.
-        let stusb4500 = match ThisBoard::STUSB4500_I2C_ADDR {
+        let mut stusb4500 = match ThisBoard::STUSB4500_I2C_ADDR {
             Some(addr) => {
                 // Verify and possibily reprogram NVM of STUSB4500.
                 let mut reprogrammed = false;
@@ -622,6 +622,14 @@ mod app {
             }
         }
 
+        // Avoid losing charger momentarily while battery is very low.
+        match &mut stusb4500 {
+            Some(stusb4500) if prohibit_power_on => {
+                stusb4500.prohibit_reset_until(monotonics::now() + 60u32.secs());
+            }
+            _ => (),
+        }
+
         // Prevent system power on if required.
         if prohibit_power_on && board.power_mode().is_full() {
             defmt::warn!("System power on is prohibited");

openemc-firmware/src/supply/stusb4500/mod.rs

@@ -138,6 +138,8 @@ pub struct StUsb4500<I2C> {
     best_pdo_requested: bool,
     report: PowerSupply,
     started: Instant,
+    reset_prohibited_until: Option<Instant>,
+    reset_queued: bool,
     _i2c: PhantomData<I2C>,
 }
 
@@ -200,6 +202,8 @@ where
             best_pdo_requested: false,
             report: Default::default(),
             started: monotonics::now(),
+            reset_prohibited_until: None,
+            reset_queued: false,
             _i2c: PhantomData,
         }
     }
@@ -217,6 +221,8 @@ where
 
         defmt::info!("STUSB4500 pin reset");
         self.reset = ResetState::PinResetHigh(monotonics::now());
+        self.reset_prohibited_until = None;
+        self.reset_queued = false;
     }
 
     /// Initiates a register reset.
@@ -227,9 +233,13 @@ where
 
         if power_on {
             defmt::info!("Skipping STUSB4500 register reset due to power on or pin reset");
+        } else if self.reset_prohibited_until.map(|until| until >= monotonics::now()).unwrap_or_default() {
+            defmt::info!("Queueing STUSB4500 register reset because it is currently prohibited");
+            self.reset_queued = true;
         } else {
             defmt::info!("STUSB4500 register reset");
             self.write(i2c, REG_RESET, &[1])?;
+            self.reset_queued = false;
         }
 
         self.read(i2c, REG_ALERT_STATUS_1, 12)?;
@@ -628,6 +638,15 @@ where
 
         defmt::trace!("STUSB4500 periodic");
 
+        // Perform queued reset, if necessary.
+        if !self.reset_prohibited_until.map(|until| until >= monotonics::now()).unwrap_or_default()
+            && self.reset_queued
+        {
+            defmt::info!("Executing queued STUSB4500 register reset");
+            self.reset_prohibited_until = None;
+            self.start_register_reset(i2c, false)?;
+        }
+
         // Read monitoring status.
         self.update_monitoring_status(i2c)?;
         self.update_hw_fault_status(i2c)?;
@@ -805,6 +824,12 @@ where
         self.reset = ResetState::None;
         self.start_pin_reset();
     }
+
+    /// Prohibits register reset until the specified time.
+    pub fn prohibit_reset_until(&mut self, until: Instant) {
+        defmt::info!("STUSB4500 reset prohibited");
+        self.reset_prohibited_until = Some(until);
+    }
 }
 
 // Register definitions.