Struct esp_idf_svc::wifi::AsyncWifi

pub struct AsyncWifi<T> { /* private fields */ }

Wraps a WifiDriver or EspWifi, and offers strictly async (non-blocking) function calls for their functionality.

Implementations

impl<T> AsyncWifi<T>

where T: Wifi<Error = EspError> + NonBlocking,

pub fn wrap( wifi: T, event_loop: EspSystemEventLoop, timer_service: EspTaskTimerService, ) -> Result<Self, EspError>

pub fn wifi(&self) -> &T

Returns the underlying WifiDriver or EspWifi

pub fn wifi_mut(&mut self) -> &mut T

Returns the underlying WifiDriver or EspWifi, as mutable

pub fn get_capabilities(&self) -> Result<EnumSet<Capability>, EspError>

As per WifiDriver::get_capabilities()

pub fn get_configuration(&self) -> Result<Configuration, EspError>

As per WifiDriver::get_configuration()

pub fn set_configuration( &mut self, conf: &Configuration, ) -> Result<(), EspError>

As per WifiDriver::set_configuration()

pub fn is_started(&self) -> Result<bool, EspError>

As per WifiDriver::is_started()

pub fn is_connected(&self) -> Result<bool, EspError>

As per WifiDriver::is_connected()

pub async fn start(&mut self) -> Result<(), EspError>

As per WifiDriver::start(), but as an async call that awaits until the wifi driver has started.

pub async fn stop(&mut self) -> Result<(), EspError>

As per WifiDriver::stop(), but as an async call that awaits until the wifi driver has stopped.

pub async fn connect(&mut self) -> Result<(), EspError>

As per WifiDriver::connect(), but as an async call that awaits until the wifi driver has connected.

pub async fn disconnect(&mut self) -> Result<(), EspError>

As per WifiDriver::disconnect(), but as an async call that awaits until the wifi driver has disconnected.

pub async fn scan_n<const N: usize>( &mut self, ) -> Result<(Vec<AccessPointInfo, N>, usize), EspError>

As per WifiDriver::start_scan() plus WifiDriver::get_scan_result_n(), as an async call that awaits until the scan is complete.

pub async fn scan(&mut self) -> Result<Vec<AccessPointInfo>, EspError>

As per WifiDriver::start_scan() plus WifiDriver::get_scan_result(), as an async call that awaits until the scan is complete.

pub async fn wifi_wait<F: FnMut(&mut Self) -> Result<bool, EspError>>( &mut self, matcher: F, timeout: Option<Duration>, ) -> Result<(), EspError>

Awaits for a certain condition provided by the user in the form of a matcher callback to become false. Most often than not that condition would be related to the state of the Wifi driver. In other words, whether the driver is started, stopped, (dis)connected and so on.

Note that the waiting is not done internally using busy-looping and/or timeouts. Rather, the condition (matcher) is evaluated initially, and if it returns true, it is re-evaluated each time the ESP IDF C Wifi driver posts a Wifi event on the system event loop. The reasoning behind this is that changes to the state of the Wifi driver are always accompanied by posting Wifi events.

pub async fn start_wps( &mut self, config: &WpsConfig<'_>, ) -> Result<WpsStatus, EspError>

Start WPS and perform a wait asynchronously until it connects, fails or times out. A WpsStatus is returned that contains the success status of the WPS connection. When the credentials of only one access point are received, the WiFi driver configuration will automatically be set to that access point. If multiple credentials were received, a WpsStatus::Success will be returned with a vector containing those credentials. The caller must then handle those credentials and set the configuration manually.

impl<T> AsyncWifi<T>

where T: NetifStatus,

pub fn is_up(&self) -> Result<bool, EspError>

As per EspWifi::is_up().

pub async fn wait_netif_up(&mut self) -> Result<(), EspError>

Waits until the underlaying network interface is up.

pub async fn ip_wait_while<F: FnMut(&mut Self) -> Result<bool, EspError>>( &mut self, matcher: F, timeout: Option<Duration>, ) -> Result<(), EspError>

As AsyncWifi::wifi_wait(), but for EspWifi events related to the IP layer, instead of WifiDriver events on the data link layer.

Trait Implementations

impl<T> NetifStatus for AsyncWifi<T>

where T: NetifStatus,

async fn is_up(&self) -> Result<bool, EspError>

impl<T> Wifi for AsyncWifi<T>

where T: Wifi<Error = EspError> + NonBlocking,

type Error = <T as Wifi>::Error

async fn get_capabilities(&self) -> Result<EnumSet<Capability>, Self::Error>

async fn get_configuration(&self) -> Result<Configuration, Self::Error>

async fn set_configuration( &mut self, conf: &Configuration, ) -> Result<(), Self::Error>

async fn start(&mut self) -> Result<(), Self::Error>

async fn stop(&mut self) -> Result<(), Self::Error>

async fn connect(&mut self) -> Result<(), Self::Error>

async fn disconnect(&mut self) -> Result<(), Self::Error>

async fn is_started(&self) -> Result<bool, Self::Error>

async fn is_connected(&self) -> Result<bool, Self::Error>

async fn scan_n<const N: usize>( &mut self, ) -> Result<(Vec<AccessPointInfo, N>, usize), Self::Error>

async fn scan(&mut self) -> Result<Vec<AccessPointInfo>, Self::Error>