fix: fix battery status

Author: HaoboGu

docs/docs/main/docs/features/event.md

@@ -40,7 +40,7 @@ RMK provides built-in event types organized by category:
 **Battery Events** (`rmk::event::battery`):
 - `BatteryAdcEvent` - Raw battery ADC reading
 - `ChargingStateEvent` - Charging state changed
-- `BatteryStatusEvent` - Battery state changed (includes level and charging status)
+- `BatteryStatusEvent` - Battery status changed (includes level and charging status)
 
 **Connection Events** (`rmk::event::connection`):
 - `ConnectionChangeEvent` - Connection type changed (USB/BLE)
@@ -49,7 +49,7 @@ RMK provides built-in event types organized by category:
 **Split Keyboard Events** (`rmk::event::split`, when split is enabled):
 - `PeripheralConnectedEvent` - Peripheral connection state changed
 - `CentralConnectedEvent` - Connected to central state changed
-- `PeripheralBatteryEvent` - Peripheral battery state changed
+- `PeripheralBatteryEvent` - Peripheral battery status changed
 - `ClearPeerEvent` - BLE peer clearing event
 
 ## Defining Custom Events

examples/use_rust/nrf52840_ble_split_dongle/Cargo.lock

@@ -68,7 +68,7 @@ impl crate::KeyboardTomlConfig {
             wpm_update,
             led_indicator,
             sleep_state,
-            battery_state,
+            battery_status,
             battery_adc,
             charging_state,
             pointing,

rmk-config/src/resolved/build_constants.rs

@@ -69,10 +69,10 @@ impl<P: PacketPool> BleBatteryServer<'_, '_, '_, P> {
 
         // Report the battery level.
         loop {
-            let battery_state = self.wait_until_battery_state_available().await;
+            let battery_status = self.wait_until_battery_status_available().await;
 
             // Try to receive the latest message
-            let state = self.sub.try_next_message_pure().unwrap_or(battery_state);
+            let state = self.sub.try_next_message_pure().unwrap_or(battery_status);
             if let BatteryStatus::Available { level: Some(level), .. } = state.0 {
                 if let Err(e) = self.battery_level.notify(self.conn, &level).await {
                     error!("Failed to notify battery level: {:?}", e);
@@ -81,13 +81,13 @@ impl<P: PacketPool> BleBatteryServer<'_, '_, '_, P> {
         }
     }
 
-    /// Wait until the battery state is available.
+    /// Wait until the battery status is available.
     /// To avoid unexpected wakeup, before reporting battery level, all conditions should be satistied:
     ///
-    /// 1. There's a battery state update
+    /// 1. There's a battery status update
     /// 2. There's a key press in last 1 minute, or timeout(30 minutes)
     /// 3. The keyboard is not in the sleep mode
-    async fn wait_until_battery_state_available(&mut self) -> BatteryStatusEvent {
+    async fn wait_until_battery_status_available(&mut self) -> BatteryStatusEvent {
         loop {
             // Calculate timeout when reporting battery level
             let timeout = async {
@@ -100,8 +100,8 @@ impl<P: PacketPool> BleBatteryServer<'_, '_, '_, P> {
                 }
             };
 
-            // Wait until there are both battery state update and key pressing or timeout
-            let (battery_state, last_press) =
+            // Wait until there are both battery status update and key pressing or timeout
+            let (battery_status, last_press) =
                 join(self.sub.next_message_pure(), select(timeout, LAST_KEY_TIMESTAMP.wait())).await;
 
             // Then check the value last press time
@@ -110,10 +110,10 @@ impl<P: PacketPool> BleBatteryServer<'_, '_, '_, P> {
                 Either::Second(last_press) => last_press,
             };
 
-            // Only report battery state if the last key action is less than 60 seconds ago
+            // Only report battery status if the last key action is less than 60 seconds ago
             let current_time = Instant::now().as_secs() as u32;
             if current_time.saturating_sub(last_press) < 60 {
-                return battery_state;
+                return battery_status;
             }
         }
     }

rmk/src/ble/battery_service.rs

@@ -3,7 +3,7 @@
 //! This module contains all battery-related events:
 //! - Battery ADC reading events
 //! - Charging state events
-//! - Battery state events (computed from ADC and charging state)
+//! - Battery status events (computed from ADC and charging state)
 
 use postcard::experimental::max_size::MaxSize;
 use rmk_macro::event;
@@ -32,7 +32,7 @@ pub struct ChargingStateEvent {
     pub charging: bool,
 }
 
-/// Battery state changed event, wraps [`BatteryStatus`].
+/// Battery status changed event, wraps [`BatteryStatus`].
 #[event(channel_size = crate::BATTERY_STATUS_EVENT_CHANNEL_SIZE, pubs = crate::BATTERY_STATUS_EVENT_PUB_SIZE, subs = crate::BATTERY_STATUS_EVENT_SUB_SIZE)]
 #[derive(Serialize, Deserialize, Clone, Copy, Debug, PartialEq, Eq, MaxSize)]
 #[cfg_attr(feature = "defmt", derive(defmt::Format))]

rmk/src/event/battery.rs

@@ -11,7 +11,7 @@
 //!
 //! - `input`: Input events (keyboard, modifier, pointing device)
 //! - `state`: Keyboard state events (layer, WPM, LED indicator, sleep)
-//! - `battery`: Battery events (ADC, charging, battery state)
+//! - `battery`: Battery events (ADC, charging, battery status)
 //! - `connection`: Connection events (USB/BLE, BLE status)
 //! - `split`: Split keyboard events (peripheral/central connection)
 

rmk/src/event/mod.rs

@@ -21,7 +21,7 @@ pub struct CentralConnectedEvent {
     pub connected: bool,
 }
 
-/// Peripheral battery state changed event
+/// Peripheral battery status changed event
 #[event(channel_size = crate::PERIPHERAL_BATTERY_EVENT_CHANNEL_SIZE, pubs = crate::PERIPHERAL_BATTERY_EVENT_PUB_SIZE, subs = crate::PERIPHERAL_BATTERY_EVENT_SUB_SIZE)]
 #[derive(Clone, Copy, Debug, PartialEq, Eq)]
 #[cfg_attr(feature = "defmt", derive(defmt::Format))]

rmk/src/event/split.rs

@@ -75,21 +75,21 @@ impl<I: InputPin> ChargingStateReader<I> {
 }
 
 /// BatteryProcessor processes battery adc value and charging state,
-/// emits `BatteryStatusEvent` when battery state changes.
+/// emits `BatteryStatusEvent` when battery status changes.
 #[processor(subscribe = [BatteryAdcEvent, ChargingStateEvent])]
 pub struct BatteryProcessor {
     adc_divider_measured: u32,
     adc_divider_total: u32,
-    /// Current battery state
-    battery_state: BatteryStatus,
+    /// Current battery status
+    battery_status: BatteryStatus,
 }
 
 impl BatteryProcessor {
     pub fn new(adc_divider_measured: u32, adc_divider_total: u32) -> Self {
         BatteryProcessor {
             adc_divider_measured,
             adc_divider_total,
-            battery_state: BatteryStatus::Unavailable,
+            battery_status: BatteryStatus::Unavailable,
         }
     }
 
@@ -138,19 +138,19 @@ impl BatteryProcessor {
         #[cfg(feature = "_ble")]
         {
             // Only update level when not charging
-            let (charge_state, current_level) = match self.battery_state {
+            let (charge_state, current_level) = match self.battery_status {
                 BatteryStatus::Available { charge_state, level } => (Some(charge_state), level),
                 BatteryStatus::Unavailable => (None, None),
             };
             if !matches!(charge_state, Some(ChargeState::Charging)) {
                 let battery_percent = self.get_battery_percent(val);
                 if current_level != Some(battery_percent) || charge_state.is_none() {
-                    self.battery_state = BatteryStatus::Available {
+                    self.battery_status = BatteryStatus::Available {
                         charge_state: charge_state.unwrap_or(ChargeState::Unknown),
                         level: Some(battery_percent),
                     };
 
-                    publish_event(BatteryStatusEvent::from(self.battery_state));
+                    publish_event(BatteryStatusEvent::from(self.battery_status));
                 }
             }
         }
@@ -164,20 +164,20 @@ impl BatteryProcessor {
         {
             if charging {
                 // Keep current level when charging
-                let level = match self.battery_state {
+                let level = match self.battery_status {
                     BatteryStatus::Available { level, .. } => level,
                     BatteryStatus::Unavailable => None,
                 };
-                self.battery_state = BatteryStatus::Available {
+                self.battery_status = BatteryStatus::Available {
                     charge_state: ChargeState::Charging,
                     level,
                 };
             } else {
                 // When unplugged, mark unavailable until next ADC reading
-                self.battery_state = BatteryStatus::Unavailable;
+                self.battery_status = BatteryStatus::Unavailable;
             }
 
-            publish_event(BatteryStatusEvent::from(self.battery_state));
+            publish_event(BatteryStatusEvent::from(self.battery_status));
         }
     }
 }

rmk/src/input_device/battery.rs

@@ -81,7 +81,7 @@ pub trait Processor: Runnable {
 ///
 ///     // Called every 1000ms (poll_interval)
 ///     async fn poll(&mut self) {
-///         // Toggle LED based on battery state
+///         // Toggle LED based on battery status
 ///         self.led_on = !self.led_on;
 ///     }
 /// }

rmk/src/processor.rs

@@ -41,7 +41,7 @@ pub(crate) enum SplitMessage {
     KeyboardIndicator(u8),
     /// Layer number from central to peripheral
     Layer(u8),
-    /// Battery state, from peripheral to central
+    /// Battery status, from peripheral to central
     #[cfg(feature = "_ble")]
     BatteryStatus(BatteryStatusEvent),
 }