Make *_state() private

bjoernQ · bjoernQ · commit d56cc1f07418 · 2025-12-17T11:19:14.000+01:00
diff --git a/esp-radio/src/wifi/mod.rs b/esp-radio/src/wifi/mod.rs
@@ -22,12 +22,12 @@ pub(crate) use self::os_adapter::*;
 use self::sniffer::Sniffer;
 #[cfg(feature = "wifi-eap")]
 use self::sta::eap::EapStationConfig;
-pub use self::state::*;
 use self::{
     ap::{AccessPointConfig, AccessPointInfo, convert_ap_info},
     private::PacketBuffer,
     scan::{FreeApListOnDrop, ScanConfig, ScanResults, ScanTypeConfig},
     sta::StationConfig,
+    state::*,
 };
 #[cfg(all(feature = "csi", feature = "unstable"))]
 #[instability::unstable]
@@ -2119,6 +2119,9 @@ impl WifiController<'_> {
     /// This method is not blocking. To check if the controller has started, use the
     /// [`Self::is_started`] method.
     pub fn start(&mut self) -> Result<(), WifiError> {
+        set_access_point_state(WifiAccessPointState::Starting);
+        set_station_state(WifiStationState::Starting);
+
         unsafe {
             esp_wifi_result!(esp_wifi_start())?;
 
@@ -2292,15 +2295,22 @@ impl WifiController<'_> {
     }
 
     fn stop_impl(&mut self) -> Result<(), WifiError> {
+        set_access_point_state(WifiAccessPointState::Stopping);
+        set_station_state(WifiStationState::Stopping);
+
         esp_wifi_result!(unsafe { esp_wifi_stop() })
     }
 
     fn connect_impl(&mut self) -> Result<(), WifiError> {
+        set_station_state(WifiStationState::Connecting);
+
         // TODO: implement ROAMING
         esp_wifi_result!(unsafe { esp_wifi_connect_internal() })
     }
 
     fn disconnect_impl(&mut self) -> Result<(), WifiError> {
+        set_station_state(WifiStationState::Disconnecting);
+
         // TODO: implement ROAMING
         esp_wifi_result!(unsafe { esp_wifi_disconnect_internal() })
     }
@@ -2413,9 +2423,6 @@ impl WifiController<'_> {
 
         self.wait_for_all_events(events, false).await;
 
-        reset_access_point_state();
-        reset_station_state();
-
         Ok(())
     }
 
diff --git a/esp-radio/src/wifi/state.rs b/esp-radio/src/wifi/state.rs
@@ -1,7 +1,7 @@
 use core::sync::atomic::Ordering;
 
 use private::{AtomicWifiAccessPointState, AtomicWifiStationState};
-pub use private::{WifiAccessPointState, WifiStationState};
+pub(crate) use private::{WifiAccessPointState, WifiStationState};
 
 use super::WifiEvent;
 
@@ -14,12 +14,20 @@ mod private {
     #[cfg_attr(feature = "defmt", derive(defmt::Format))]
     #[non_exhaustive]
     pub enum WifiStationState {
+        /// Start initiated.
+        Starting,
         /// Station started.
         Started,
+        /// Connect initiated.
+        Connecting,
         /// Station connected.
         Connected,
+        /// Disconnect initiated.
+        Disconnecting,
         /// Station disconnected.
         Disconnected,
+        /// Stop initiated.
+        Stopping,
         /// Station stopped
         Stopped,
         /// Invalid state.
@@ -32,8 +40,12 @@ mod private {
     #[cfg_attr(feature = "defmt", derive(defmt::Format))]
     #[non_exhaustive]
     pub enum WifiAccessPointState {
+        /// Start initiated.
+        Starting,
         /// Access point started.
         Started,
+        /// Stop initiated.
+        Stopping,
         /// Access point stopped.
         Stopped,
         /// Invalid state.
@@ -69,12 +81,12 @@ pub(crate) static ACCESS_POINT_STATE: AtomicWifiAccessPointState =
     AtomicWifiAccessPointState::new(WifiAccessPointState::Invalid);
 
 /// Get the current state of the access point.
-pub fn access_point_state() -> WifiAccessPointState {
+pub(crate) fn access_point_state() -> WifiAccessPointState {
     ACCESS_POINT_STATE.load(Ordering::Relaxed)
 }
 
 /// Get the current state of the Station.
-pub fn station_state() -> WifiStationState {
+pub(crate) fn station_state() -> WifiStationState {
     STATION_STATE.load(Ordering::Relaxed)
 }
 
@@ -99,10 +111,10 @@ pub(crate) fn update_state(event: WifiEvent, handled: bool) {
     }
 }
 
-pub(crate) fn reset_access_point_state() {
-    ACCESS_POINT_STATE.store(WifiAccessPointState::Invalid, Ordering::Relaxed)
+pub(crate) fn set_access_point_state(state: WifiAccessPointState) {
+    ACCESS_POINT_STATE.store(state, Ordering::Relaxed)
 }
 
-pub(crate) fn reset_station_state() {
-    STATION_STATE.store(WifiStationState::Invalid, Ordering::Relaxed)
+pub(crate) fn set_station_state(state: WifiStationState) {
+    STATION_STATE.store(state, Ordering::Relaxed)
 }
diff --git a/examples/wifi/embassy_access_point/src/main.rs b/examples/wifi/embassy_access_point/src/main.rs
@@ -34,14 +34,7 @@ use esp_hal::{
     timer::timg::TimerGroup,
 };
 use esp_println::{print, println};
-use esp_radio::wifi::{
-    ModeConfig,
-    WifiAccessPointState,
-    WifiController,
-    WifiDevice,
-    WifiEvent,
-    ap::AccessPointConfig,
-};
+use esp_radio::wifi::{ModeConfig, WifiController, WifiDevice, WifiEvent, ap::AccessPointConfig};
 
 esp_bootloader_esp_idf::esp_app_desc!();
 
@@ -238,21 +231,17 @@ async fn connection(mut controller: WifiController<'static>) {
     println!("start connection task");
     println!("Device capabilities: {:?}", controller.capabilities());
     loop {
-        match esp_radio::wifi::access_point_state() {
-            WifiAccessPointState::Started => {
-                // wait until we're no longer connected
-                controller.wait_for_event(WifiEvent::AccessPointStop).await;
-                Timer::after(Duration::from_millis(5000)).await
-            }
-            _ => {}
-        }
         if !matches!(controller.is_started(), Ok(true)) {
             let station_config =
                 ModeConfig::AccessPoint(AccessPointConfig::default().with_ssid("esp-radio".into()));
             controller.set_config(&station_config).unwrap();
             println!("Starting wifi");
             controller.start_async().await.unwrap();
             println!("Wifi started!");
+        } else {
+            // wait until we're no longer connected
+            controller.wait_for_event(WifiEvent::AccessPointStop).await;
+            Timer::after(Duration::from_millis(5000)).await
         }
     }
 }
diff --git a/examples/wifi/embassy_access_point_with_sta/src/main.rs b/examples/wifi/embassy_access_point_with_sta/src/main.rs
@@ -44,7 +44,6 @@ use esp_hal::{
 use esp_println::{print, println};
 use esp_radio::wifi::{
     ModeConfig,
-    WifiAccessPointState,
     WifiController,
     WifiDevice,
     WifiEvent,
@@ -315,25 +314,24 @@ async fn connection(mut controller: WifiController<'static>) {
     println!("Wifi started!");
 
     loop {
-        match esp_radio::wifi::access_point_state() {
-            WifiAccessPointState::Started => {
-                println!("About to connect...");
-
-                match controller.connect_async().await {
-                    Ok(_) => {
-                        // wait until we're no longer connected
-                        controller
-                            .wait_for_event(WifiEvent::StationDisconnected)
-                            .await;
-                        println!("Station disconnected");
-                    }
-                    Err(e) => {
-                        println!("Failed to connect to wifi: {e:?}");
-                        Timer::after(Duration::from_millis(5000)).await
-                    }
+        if matches!(controller.is_started(), Ok(true)) {
+            println!("About to connect...");
+
+            match controller.connect_async().await {
+                Ok(_) => {
+                    // wait until we're no longer connected
+                    controller
+                        .wait_for_event(WifiEvent::StationDisconnected)
+                        .await;
+                    println!("Station disconnected");
+                }
+                Err(e) => {
+                    println!("Failed to connect to wifi: {e:?}");
+                    Timer::after(Duration::from_millis(5000)).await
                 }
             }
-            _ => return,
+        } else {
+            return;
         }
     }
 }
diff --git a/examples/wifi/embassy_dhcp/src/main.rs b/examples/wifi/embassy_dhcp/src/main.rs
@@ -29,7 +29,6 @@ use esp_radio::wifi::{
     WifiController,
     WifiDevice,
     WifiEvent,
-    WifiStationState,
     scan::ScanConfig,
     sta::StationConfig,
 };
@@ -149,16 +148,14 @@ async fn connection(mut controller: WifiController<'static>) {
     println!("start connection task");
     println!("Device capabilities: {:?}", controller.capabilities());
     loop {
-        match esp_radio::wifi::station_state() {
-            WifiStationState::Connected => {
-                // wait until we're no longer connected
-                controller
-                    .wait_for_event(WifiEvent::StationDisconnected)
-                    .await;
-                Timer::after(Duration::from_millis(5000)).await
-            }
-            _ => {}
+        if matches!(controller.is_connected(), Ok(true)) {
+            // wait until we're no longer connected
+            controller
+                .wait_for_event(WifiEvent::StationDisconnected)
+                .await;
+            Timer::after(Duration::from_millis(5000)).await
         }
+
         if !matches!(controller.is_started(), Ok(true)) {
             let station_config = ModeConfig::Station(
                 StationConfig::default()
diff --git a/examples/wifi/embassy_sntp/src/main.rs b/examples/wifi/embassy_sntp/src/main.rs
@@ -35,7 +35,6 @@ use esp_radio::wifi::{
     WifiController,
     WifiDevice,
     WifiEvent,
-    WifiStationState,
     scan::ScanConfig,
     sta::StationConfig,
 };
@@ -209,13 +208,14 @@ async fn connection(mut controller: WifiController<'static>) {
     println!("start connection task");
     println!("Device capabilities: {:?}", controller.capabilities());
     loop {
-        if esp_radio::wifi::station_state() == WifiStationState::Connected {
+        if matches!(controller.is_connected(), Ok(true)) {
             // wait until we're no longer connected
             controller
                 .wait_for_event(WifiEvent::StationDisconnected)
                 .await;
             Timer::after(Duration::from_millis(5000)).await
         }
+
         if !matches!(controller.is_started(), Ok(true)) {
             let station_config = ModeConfig::Station(
                 StationConfig::default()
diff --git a/qa-test/src/bin/embassy_wifi_bench.rs b/qa-test/src/bin/embassy_wifi_bench.rs
@@ -33,14 +33,7 @@ use esp_hal::{
     timer::timg::TimerGroup,
 };
 use esp_println::println;
-use esp_radio::wifi::{
-    ModeConfig,
-    WifiController,
-    WifiDevice,
-    WifiEvent,
-    WifiStationState,
-    sta::StationConfig,
-};
+use esp_radio::wifi::{ModeConfig, WifiController, WifiDevice, WifiEvent, sta::StationConfig};
 
 esp_bootloader_esp_idf::esp_app_desc!();
 
@@ -146,16 +139,14 @@ async fn connection(mut controller: WifiController<'static>) {
     println!("start connection task");
     println!("Device capabilities: {:?}", controller.capabilities());
     loop {
-        match esp_radio::wifi::station_state() {
-            WifiStationState::Connected => {
-                // wait until we're no longer connected
-                controller
-                    .wait_for_event(WifiEvent::StationDisconnected)
-                    .await;
-                Timer::after(Duration::from_millis(5000)).await
-            }
-            _ => {}
+        if matches!(controller.is_connected(), Ok(true)) {
+            // wait until we're no longer connected
+            controller
+                .wait_for_event(WifiEvent::StationDisconnected)
+                .await;
+            Timer::after(Duration::from_millis(5000)).await
         }
+
         if !matches!(controller.is_started(), Ok(true)) {
             let station_config = ModeConfig::Station(
                 StationConfig::default()
diff --git a/qa-test/src/bin/embassy_wifi_i2s.rs b/qa-test/src/bin/embassy_wifi_i2s.rs
@@ -22,15 +22,7 @@ use esp_hal::{
     timer::timg::TimerGroup,
 };
 use esp_println::println;
-use esp_radio::wifi::{
-    ModeConfig,
-    WifiController,
-    WifiDevice,
-    WifiEvent,
-    WifiStationState,
-    sta::StationConfig,
-    station_state,
-};
+use esp_radio::wifi::{ModeConfig, WifiController, WifiDevice, WifiEvent, sta::StationConfig};
 use static_cell::StaticCell;
 
 esp_bootloader_esp_idf::esp_app_desc!();
@@ -86,8 +78,8 @@ async fn connection_manager(
     }
 
     loop {
-        match station_state() {
-            WifiStationState::Connected => {
+        match controller.is_connected() {
+            Ok(true) => {
                 controller
                     .wait_for_event(WifiEvent::StationDisconnected)
                     .await;
