esp-radio

https://docs.espressif.com/projects/rust/esp-radio/0.16.0/
Admin
esp-radio is a Rust library for ESP32 microcontroller radio functionality, supporting multiple ESP32...
Tokens:733,166
Snippets:6,854
Trust Score:10
Update:5 months ago
Show doc for...
Tokens:
Raw
### start

Source: https://docs.espressif.com/projects/rust/esp-radio/0.16.0/esp32c3/esp_radio/wifi/struct.WifiController.html?search=Option%3CT%3E%2C+%28T+-%3E+U%29+-%3E+Option%3CU%3E

Starts the Wi-Fi controller. This method is not blocking.

```APIDOC
## start

### Description
Starts the Wi-Fi controller. This method is not blocking.

### Method
`&mut self`

### Returns
`Result<(), WifiError>` - Ok on success, or a `WifiError` on failure.

### Note
To check if the controller has started, use the `Self::is_started` method.
```

--------------------------------

### start_async

Source: https://docs.espressif.com/projects/rust/esp-radio/0.16.0/esp32c3/esp_radio/wifi/struct.WifiController.html?search=std%3A%3Avec

Asynchronous version of `start`. Waits for the Wi-Fi controller to start.

```APIDOC
## start_async

### Description
Async version of `Self::start`.
This function will wait for the Wi-Fi controller to start before returning.

### Returns
* `Result<(), WifiError>` - Ok on success, or a `WifiError` on failure.
```

--------------------------------

### start

Source: https://docs.espressif.com/projects/rust/esp-radio/0.16.0/esp32c3/esp_radio/wifi/struct.WifiController.html?search=std%3A%3Avec

Starts the Wi-Fi controller. This method is not blocking. Use `is_started` to check status.

```APIDOC
## start

### Description
Starts the Wi-Fi controller. This method is not blocking.

### Returns
* `Result<(), WifiError>` - Ok on success, or a `WifiError` on failure.
```

--------------------------------

### Async Start Wi-Fi Controller

Source: https://docs.espressif.com/projects/rust/esp-radio/0.16.0/esp32c3/esp_radio/wifi/struct.WifiController.html?search=

Asynchronously starts the Wi-Fi controller. This function waits for the controller to be fully started before returning.

```rust
self.start_async() -> Result<(), WifiError>
```

--------------------------------

### Asynchronous Start Wi-Fi Controller

Source: https://docs.espressif.com/projects/rust/esp-radio/0.16.0/esp32c3/esp_radio/wifi/struct.WifiController.html?search=Option%3CT%3E%2C+%28T+-%3E+U%29+-%3E+Option%3CU%3E

Asynchronously starts the Wi-Fi controller and waits for it to be ready.

```rust
wifi_controller.start_async().await.unwrap();
```

--------------------------------

### Asynchronous Wi-Fi Start

Source: https://docs.espressif.com/projects/rust/esp-radio/0.16.0/esp32c3/src/esp_radio/wifi/mod.rs.html?search=Option%3CT%3E%2C+%28T+-%3E+U%29+-%3E+Option%3CU%3E

Asynchronously starts the Wi-Fi controller and waits for the start events to complete before returning.

```rust
/// Async version of [`Self::start`].
///
/// This function will wait for the Wi-Fi controller to start before returning.
pub async fn start_async(&mut self) -> Result<(), WifiError> {
        let mut events = enumset::enum_set! {};

        let mode = self.mode()?;
        if mode.is_ap() {
            events |= WifiEvent::ApStart;
        }
        if mode.is_sta() {
            events |= WifiEvent::StaStart;
        }

        Self::clear_events(events);


```

--------------------------------

### Start Wi-Fi Controller

Source: https://docs.espressif.com/projects/rust/esp-radio/0.16.0/esp32c3/src/esp_radio/wifi/mod.rs.html?search=Option%3CT%3E%2C+%28T+-%3E+U%29+-%3E+Option%3CU%3E

Starts the Wi-Fi controller. This method is not blocking. Use `Self::is_started` to check the status.

```rust
pub fn start(&mut self) -> Result<(), WifiError> {
        unsafe {
            esp_wifi_result!(esp_wifi_start())?;

            let mode = WifiMode::current()?;

            // This is not an if-else because in AP-STA mode, both are true
            if mode.is_ap() {
                esp_wifi_result!(include::esp_wifi_set_inactive_time(
                    wifi_interface_t_WIFI_IF_AP,
                    self.ap_beacon_timeout
                ))?;
            }
            if mode.is_sta() {
                esp_wifi_result!(include::esp_wifi_set_inactive_time(
                    wifi_interface_t_WIFI_IF_STA,
                    self.beacon_timeout
                ))?;
            }
        }

        Ok(())
    }
```

--------------------------------

### Asynchronously Start Wi-Fi Controller

Source: https://docs.espressif.com/projects/rust/esp-radio/0.16.0/esp32c3/esp_radio/wifi/struct.WifiController.html

Asynchronously starts the Wi-Fi controller and waits for it to be fully operational before returning.

```rust
self.start_async()
```

--------------------------------

### is_started

Source: https://docs.espressif.com/projects/rust/esp-radio/0.16.0/esp32c3/esp_radio/wifi/struct.WifiController.html?search=std%3A%3Avec

Checks if the Wi-Fi controller has started. Returns true if STA and/or AP are started. Call after `start`.

```APIDOC
## is_started

### Description
Checks if the Wi-Fi controller has started. Returns true if STA and/or AP are started.

### Notes
This function should be called after the `Self::start` method to verify if the Wi-Fi controller has started successfully.

### Returns
* `Result<bool, WifiError>` - True if started, false otherwise, or a `WifiError` on failure.
```

--------------------------------

### Example Searches

Source: https://docs.espressif.com/projects/rust/esp-radio/0.16.0/esp32c3/src/esp_radio/wifi/mod.rs.html?search=

These are example search queries demonstrating common patterns for searching within the codebase or documentation.

```text
std::vec
```

```text
u32 -> bool
```

```text
Option<T>, (T -> U) -> Option<U>
```

--------------------------------

### Start Wi-Fi Controller

Source: https://docs.espressif.com/projects/rust/esp-radio/0.16.0/esp32c3/esp_radio/wifi/struct.WifiController.html?search=

Starts the Wi-Fi controller. This operation is non-blocking. Use `is_started` to verify.

```rust
self.start() -> Result<(), WifiError>
```

--------------------------------

### WifiController::start

Source: https://docs.espressif.com/projects/rust/esp-radio/0.16.0/esp32c3/esp_radio/wifi/struct.WifiController.html?search=

Starts the Wi-Fi controller. This method is not blocking.

```APIDOC
## WifiController::start

### Description
Starts the Wi-Fi controller. This method is not blocking. To check if the controller has started, use the `Self::is_started` method.

### Method
`start`
```

--------------------------------

### is_started

Source: https://docs.espressif.com/projects/rust/esp-radio/0.16.0/esp32c3/esp_radio/wifi/struct.WifiController.html

Checks if the Wi-Fi controller has started. Returns true if STA and/or AP are started. This function should be called after the Self::start method to verify if the Wi-Fi controller has started successfully.

```APIDOC
## is_started

### Description
Checks if the Wi-Fi controller has started. Returns true if STA and/or AP are started.
This function should be called after the `Self::start` method to verify if the Wi-Fi controller has started successfully.

### Method
`pub fn is_started(&self) -> Result<bool, WifiError>`
```

--------------------------------

### is_started

Source: https://docs.espressif.com/projects/rust/esp-radio/0.16.0/esp32c3/esp_radio/wifi/struct.WifiController.html?search=Option%3CT%3E%2C+%28T+-%3E+U%29+-%3E+Option%3CU%3E

Checks if the Wi-Fi controller has started. Returns true if STA and/or AP are started.

```APIDOC
## is_started

### Description
Checks if the Wi-Fi controller has started. Returns true if STA and/or AP are started.

### Method
`&self`

### Returns
`Result<bool, WifiError>` - True if the controller has started, false otherwise, or a `WifiError` on failure.

### Note
This function should be called after the `Self::start` method to verify if the Wi-Fi controller has started successfully.
```

--------------------------------

### Asynchronous Start Wi-Fi Controller

Source: https://docs.espressif.com/projects/rust/esp-radio/0.16.0/esp32c3/src/esp_radio/wifi/mod.rs.html?search=std%3A%3Avec

Asynchronously starts the Wi-Fi controller and waits for the operation to complete before returning.

```APIDOC
## start_async

### Description
Async version of [`Self::start`]. This function will wait for the Wi-Fi controller to start before returning.

### Method
`pub async fn start_async(&mut self) -> Result<(), WifiError>`
```

--------------------------------

### Start Wi-Fi Controller

Source: https://docs.espressif.com/projects/rust/esp-radio/0.16.0/esp32c3/src/esp_radio/wifi/mod.rs.html?search=

Starts the Wi-Fi controller. This operation is non-blocking. Use `is_started` to check the status.

```APIDOC
## start

### Description
Starts the Wi-Fi controller. This method is not blocking. To check if the controller has started, use the [`Self::is_started`] method.

### Method
`pub fn start(&mut self) -> Result<(), WifiError>`

### Parameters
None

### Returns
- `Ok(())` on success.
- `Err(WifiError)` if the operation fails.
```

--------------------------------

### Async Wi-Fi Start

Source: https://docs.espressif.com/projects/rust/esp-radio/0.16.0/esp32c3/src/esp_radio/wifi/mod.rs.html?search=

Asynchronously starts the Wi-Fi controller and waits for the operation to complete. It configures event listeners based on the current Wi-Fi mode.

```rust
/// Async version of [`Self::start`].
///
/// This function will wait for the Wi-Fi controller to start before returning.
pub async fn start_async(&mut self) -> Result<(), WifiError> {
    let mut events = enumset::enum_set! {};

    let mode = self.mode()?;
    if mode.is_ap() {
        events |= WifiEvent::ApStart;
    }
    if mode.is_sta() {
        events |= WifiEvent::StaStart;
    }

    Self::clear_events(events);
    
```

--------------------------------

### Asynchronous Wi-Fi Start

Source: https://docs.espressif.com/projects/rust/esp-radio/0.16.0/esp32c3/src/esp_radio/wifi/mod.rs.html?search=std%3A%3Avec

Asynchronously starts the Wi-Fi controller and waits for the operation to complete. It sets up event listeners based on the current Wi-Fi mode (STA and/or AP).

```rust
pub async fn start_async(&mut self) -> Result<(), WifiError> {
        let mut events = enumset::enum_set! {};

        let mode = self.mode()?;
        if mode.is_ap() {
            events |= WifiEvent::ApStart;
        }
        if mode.is_sta() {
            events |= WifiEvent::StaStart;
        }

        Self::clear_events(events);

    }
```

--------------------------------

### WifiController::is_started

Source: https://docs.espressif.com/projects/rust/esp-radio/0.16.0/esp32c3/esp_radio/wifi/struct.WifiController.html?search=

Checks if the Wi-Fi controller has started. Returns true if STA and/or AP are started.

```APIDOC
## WifiController::is_started

### Description
Checks if the Wi-Fi controller has started. Returns true if STA and/or AP are started.

This function should be called after the `Self::start` method to verify if the Wi-Fi controller has started successfully.

### Method
`is_started`
```

--------------------------------

### Example Searches in Rust Documentation

Source: https://docs.espressif.com/projects/rust/esp-radio/0.16.0/esp32c3/src/esp_radio/wifi/mod.rs.html?search=u32+-%3E+bool

Provides examples of search queries for finding specific functionalities or patterns within Rust documentation, such as type conversions or generic type manipulations.

```text
std::vec
  u32 -> bool
  Option<T>, (T -> U) -> Option<U>
```

--------------------------------

### Check if Wi-Fi Controller Started

Source: https://docs.espressif.com/projects/rust/esp-radio/0.16.0/esp32c3/esp_radio/wifi/struct.WifiController.html?search=

Verifies if the Wi-Fi controller has successfully started. Returns true if either the STA or AP components are running. This should be called after `Self::start`.

```rust
self.is_started() -> Result<bool, WifiError>
```

--------------------------------

### Start Wi-Fi Controller Asynchronously

Source: https://docs.espressif.com/projects/rust/esp-radio/0.16.0/esp32c3/src/esp_radio/wifi/mod.rs.html

Asynchronously starts the Wi-Fi controller, waiting for the operation to complete before returning. It configures the controller based on the current Wi-Fi mode (STA and/or AP).

```APIDOC
## start_async

### Description
Asynchronously starts the Wi-Fi controller. This function waits until the Wi-Fi controller has fully started before returning. It determines which events to monitor based on the current Wi-Fi mode (Station and/or Access Point).

### Method
`pub async fn start_async(&mut self) -> Result<(), WifiError>`

### Returns
- `Ok(())` if the Wi-Fi controller starts successfully.
- `Err(WifiError)` if any error occurs during the startup process.
```

--------------------------------

### Check if Wi-Fi Controller is Started

Source: https://docs.espressif.com/projects/rust/esp-radio/0.16.0/esp32c3/src/esp_radio/wifi/mod.rs.html?search=u32+-%3E+bool

Verifies if the Wi-Fi controller has started, returning true if either STA or AP is active. Call this after `Self::start`.

```rust
/// Checks if the Wi-Fi controller has started. Returns true if STA and/or AP are started.
///
/// This function should be called after the [`Self::start`] method to verify if the
/// Wi-Fi controller has started successfully.
pub fn is_started(&self) -> Result<bool, WifiError> {
    if matches!(
        crate::wifi::sta_state(),
        WifiStaState::Started | WifiStaState::Connected | WifiStaState::Disconnected
    ) {
        return Ok(true);
    }
    if matches!(crate::wifi::ap_state(), WifiApState::Started) {
        return Ok(true);
    }
    Ok(false)
}
```

--------------------------------

### ClientConfig Initialization and Configuration

Source: https://docs.espressif.com/projects/rust/esp-radio/0.16.0/esp32c3/esp_radio/wifi/struct.ClientConfig.html

Demonstrates how to create and configure a ClientConfig object for Wi-Fi connections.

```APIDOC
## ClientConfig

Client configuration for a Wi-Fi connection.

### Methods

#### `with_ssid(self, ssid: String) -> Self`
Assign the given value to the `ssid` field.

#### `ssid(&self) -> &String`
The SSID of the Wi-Fi network.

#### `with_bssid(self, bssid: [u8; 6]) -> Self`
Assign the given value to the `bssid` field.

#### `with_bssid_none(self) -> Self`
Set the value of `bssid` to `None`.

#### `bssid(&self) -> Option<[u8; 6]>`
The BSSID (MAC address) of the client.

#### `with_auth_method(self, auth_method: AuthMethod) -> Self`
Assign the given value to the `auth_method` field.

#### `auth_method(&self) -> AuthMethod`
The authentication method for the Wi-Fi connection.

#### `with_password(self, password: String) -> Self`
Assign the given value to the `password` field.

#### `password(&self) -> &String`
The password for the Wi-Fi connection.

#### `with_channel(self, channel: u8) -> Self`
Assign the given value to the `channel` field.

#### `with_channel_none(self) -> Self`
Set the value of `channel` to `None`.

#### `channel(&self) -> Option<u8>`
The Wi-Fi channel to connect to.

#### `with_protocols(self, protocols: EnumSet<Protocol>) -> Self`
Assign the given value to the `protocols` field.

#### `protocols(&self) -> EnumSet<Protocol>`
The set of protocols supported by the access point.

#### `with_listen_interval(self, listen_interval: u16) -> Self`
Available on **crate feature`unstable`** only.
Assign the given value to the `listen_interval` field.

#### `listen_interval(&self) -> u16`
Available on **crate feature`unstable`** only.
Interval for station to listen to beacon from AP.
The unit of listen interval is one beacon interval. For example, if beacon interval is 100 ms and listen interval is 3, the interval for station to listen to beacon is 300 ms

#### `with_beacon_timeout(self, beacon_timeout: u16) -> Self`
Available on **crate feature`unstable`** only.
Assign the given value to the `beacon_timeout` field.

#### `beacon_timeout(&self) -> u16`
Available on **crate feature`unstable`** only.
Time to disconnect from AP if no data is received.
Must be between 6 and 31.

#### `with_failure_retry_cnt(self, failure_retry_cnt: u8) -> Self`
Available on **crate feature`unstable`** only.
Assign the given value to the `failure_retry_cnt` field.

#### `failure_retry_cnt(&self) -> u8`
Available on **crate feature`unstable`** only.
Number of connection retries station will do before moving to next AP.
`scan_method` should be set as `ScanMethod::AllChannels` to use this config.
Note: Enabling this may cause connection time to increase in case the best AP doesn’t behave properly.

#### `with_scan_method(self, scan_method: ScanMethod) -> Self`
Available on **crate feature`unstable`** only.
Assign the given value to the `scan_method` field.

#### `scan_method(&self) -> ScanMethod`
Available on **crate feature`unstable`** only.
Scan method.
```

--------------------------------

### Other Utility Functions

Source: https://docs.espressif.com/projects/rust/esp-radio/0.16.0/esp32c3/src/esp_radio/ble/npl.rs.html

Utility functions for getting the 'forever' time value and checking if the OS has started.

```APIDOC
## p_ble_npl_get_time_forever

### Description
Returns a value representing 'forever' for time-related operations.

### Function Signature
`Option<unsafe extern "C" fn() -> u32>`

## p_ble_npl_os_started

### Description
Checks if the operating system has started.

### Function Signature
`Option<unsafe extern "C" fn() -> bool>`

## p_ble_npl_get_current_task_id

### Description
Retrieves the ID of the current task.

### Function Signature
`Option<unsafe extern "C" fn() -> u32>`
```

--------------------------------

### BLE NPL Utility Functions

Source: https://docs.espressif.com/projects/rust/esp-radio/0.16.0/esp32c3/src/esp_radio/ble/npl.rs.html?search=u32+-%3E+bool

Utility functions for BLE NPL, such as getting the 'forever' time value and checking if the OS has started.

```APIDOC
## `ble_npl_os_started`

### Description
Checks if the operating system has started.

### Signature
`Option<unsafe extern "C" fn() -> bool>`

## `ble_npl_get_current_task_id`

### Description
Gets the ID of the current task.

### Signature
`Option<unsafe extern "C" fn() -> u32>`

## `ble_npl_get_time_forever`

### Description
Returns a value representing 'forever' time, often used for infinite timeouts.

### Signature
`Option<unsafe extern "C" fn() -> u32>`
```

--------------------------------

### BLE NPL Other Functions

Source: https://docs.espressif.com/projects/rust/esp-radio/0.16.0/esp32c3/src/esp_radio/ble/npl.rs.html?search=

Miscellaneous BLE NPL functions, including checking if the OS has started and getting the forever time value.

```APIDOC
## BLE NPL Other Functions

### `p_ble_npl_os_started`

#### Description
Checks if the operating system has started.

#### Signature
`Option<unsafe extern "C" fn() -> bool>`

### `p_ble_npl_get_current_task_id`

#### Description
Gets the ID of the current task.

#### Signature
`Option<unsafe extern "C" fn() -> u32>`

### `p_ble_npl_get_time_forever`

#### Description
Returns a value representing forever time.

#### Signature
`Option<unsafe extern "C" fn() -> u32>`
```

--------------------------------

### Get WPS PIN Code

Source: https://docs.espressif.com/projects/rust/esp-radio/0.16.0/esp32c3/esp_radio/wifi/event/struct.StaWpsErPin.html?search=Option%3CT%3E%2C+%28T+-%3E+U%29+-%3E+Option%3CU%3E

Retrieves the PIN code received during a WPS (Wi-Fi Protected Setup) process. This method is part of the StaWpsErPin struct implementation.

```rust
pub fn pin(&self) -> &[u8]

```

--------------------------------

### start_async

Source: https://docs.espressif.com/projects/rust/esp-radio/0.16.0/esp32c3/esp_radio/wifi/struct.WifiController.html

Asynchronous version of Self::start. This function will wait for the Wi-Fi controller to start before returning.

```APIDOC
## start_async

### Description
Async version of `Self::start`.
This function will wait for the Wi-Fi controller to start before returning.

### Method
`pub async fn start_async(&mut self) -> Result<(), WifiError>`
```

--------------------------------

### WifiController::start_async

Source: https://docs.espressif.com/projects/rust/esp-radio/0.16.0/esp32c3/esp_radio/wifi/struct.WifiController.html?search=

Asynchronous version of `Self::start`. Waits for the Wi-Fi controller to start.

```APIDOC
## WifiController::start_async

### Description
Asynchronous version of `Self::start`. This function will wait for the Wi-Fi controller to start before returning.

### Method
`start_async`
```

--------------------------------

### Get ESP-NOW Version

Source: https://docs.espressif.com/projects/rust/esp-radio/0.16.0/esp32c3/src/esp_radio/esp_now/mod.rs.html

Gets the version of ESP-NOW.

```APIDOC
## version

### Description
Get the version of ESP-NOW.

### Method
`version(&self) -> Result<u32, EspNowError>`

### Parameters
None

### Returns
`Result<u32, EspNowError>` containing the ESP-NOW version or an error.
```

--------------------------------

### CountryInfo Initialization and Usage

Source: https://docs.espressif.com/projects/rust/esp-radio/0.16.0/esp32c3/esp_radio/wifi/struct.CountryInfo.html?search=std%3A%3Avec

Demonstrates how to create a CountryInfo instance using the `from` method and set the operating class.

```APIDOC
## CountryInfo

### Description
Country information. Defaults to China (CN) with Operating Class “0”.
To create a `CountryInfo` instance, use the `from` method first, then set additional properties using the builder methods.

### Example
```rust
use esp_radio::wifi::{CountryInfo, OperatingClass};

let country_info = CountryInfo::from(*b"CN").operating_class(OperatingClass::Indoors);
```

### Methods
#### `from<[u8; 2]>`
Converts to this type from the input type `[u8; 2]`.

#### `operating_class`
Returns the operating class.

#### `with_operating_class`
Assigns the given value to the `operating_class` field.
```

--------------------------------

### Get Peer Count

Source: https://docs.espressif.com/projects/rust/esp-radio/0.16.0/esp32c3/src/esp_radio/esp_now/mod.rs.html

Gets the number of currently known peers.

```APIDOC
## peer_count

### Description
Get the number of peers.

### Method
`peer_count(&self) -> Result<PeerCount, EspNowError>`

### Parameters
None

### Returns
`Result<PeerCount, EspNowError>` containing the count of peers or an error.
```

--------------------------------

### esp32c3_phy_enable

Source: https://docs.espressif.com/projects/rust/esp-radio/0.16.0/esp32c3/src/esp_radio/wifi/os_adapter/mod.rs.html

Initializes the PHY hardware.

```APIDOC
## esp32c3_phy_enable

### Description
Initializes PHY hardware.

### Function Signature
`pub unsafe extern "C" fn phy_enable()`
```

--------------------------------

### Initialize esp-radio with RTOS Scheduler

Source: https://docs.espressif.com/projects/rust/esp-radio/0.16.0/esp32c3/src/esp_radio/lib.rs.html?search=Option%3CT%3E%2C+%28T+-%3E+U%29+-%3E+Option%3CU%3E

This example shows how to initialize the RTOS scheduler using `esp-rtos` before calling `esp_radio::init()`. Ensure your RTOS is properly configured.

```rust
use esp_hal::timer::timg::TimerGroup;

let timg0 = TimerGroup::new(peripherals.TIMG0);
#[cfg_attr(riscv, doc = " let software_interrupt = SoftwareInterruptControl::new(peripherals.SW_INTERRUPT);")];
#[cfg_attr(riscv, doc = " esp_rtos::start(timg0.timer0, software_interrupt);")];
#[cfg_attr(xtensa, doc = " esp_rtos::start(timg0.timer0);")];
// You can now start esp-radio:
let esp_radio_controller = esp_radio::init().unwrap();
```

--------------------------------

### Initialize BLE Controller Configuration

Source: https://docs.espressif.com/projects/rust/esp-radio/0.16.0/esp32c3/src/esp_radio/ble/os_adapter_esp32c2.rs.html?search=std%3A%3Avec

Sets up the BLE controller configuration with various parameters. This is typically called during system initialization.

```rust
pub(crate) fn ble_controller_config() -> esp_idf_sys::ble_ll_config_t {
    let mut config = esp_idf_sys::ble_ll_config_t::default();
    let rtc_freq = esp_idf_sys::get_rtc_clk_freq() as u32;
    let main_xtal_freq = esp_idf_sys::get_main_xtal_freq() as u32;

    config.ble_ll_sync_cnt = config.ll_sync_cnt;
    config.ble_ll_rsp_dup_list_count = config.ll_rsp_dup_list_count;
    config.ble_ll_adv_dup_list_count = config.ll_adv_dup_list_count;
    config.ble_ll_tx_pwr_dbm = config.default_tx_power.dbm() as u8;
    config.rtc_freq = rtc_freq;
    config.ble_ll_sca = CONFIG_BT_LE_LL_SCA as _;
    config.ble_ll_scan_phy_number = if CONFIG_BT_LE_LL_CFG_FEAT_LE_CODED_PHY != 0 {
        2
    } else {
        1
    };
    config.ble_ll_conn_def_auth_pyld_tmo = 3000;
    config.ble_ll_jitter_usecs = 16;
    config.ble_ll_sched_max_adv_pdu_usecs = 376;
    config.ble_ll_sched_direct_adv_max_usecs = 502;
    config.ble_ll_sched_adv_max_usecs = 852;
    config.ble_scan_rsp_data_max_len = 31;
    config.ble_ll_cfg_num_hci_cmd_pkts = 1;
    config.ble_ll_ctrl_proc_timeout_ms = 40000;
    config.nimble_max_connections = config.max_connections;
    config.ble_whitelist_size = config.whitelist_size;
    config.ble_acl_buf_size = config.acl_buf_size;
    config.ble_acl_buf_count = config.acl_buf_count;
    config.ble_hci_evt_buf_size = config.hci_evt_buf_size;
    config.ble_multi_adv_instances = config.multi_adv_instances;
    config.ble_ext_adv_max_size = config.ext_adv_max_size;
    config.controller_task_stack_size = config.task_stack_size;
    config.controller_task_prio = config.task_priority;
    config.controller_run_cpu = 0;
    config.enable_qa_test = config.qa_test_mode as u8;
    config.enable_bqb_test = config.bqb_test as u8;
    config.enable_uart_hci = 0;
    config.ble_hci_uart_port = 0;
    config.ble_hci_uart_baud = 0;
    config.ble_hci_uart_data_bits = 0;
    config.ble_hci_uart_stop_bits = 0;
    config.ble_hci_uart_flow_ctrl = 0;
    config.ble_hci_uart_uart_parity = 0;
    config.enable_tx_cca = config.cca as u8;
    config.cca_rssi_thresh = (256 - config.cca_threshold as u32) as u8;
    config.sleep_en = 0; // CONFIG_BT_LE_SLEEP_ENABLE unset
    config.coex_phy_coded_tx_rx_time_limit = CONFIG_BT_LE_COEX_PHY_CODED_TX_RX_TLIM_EFF as _;
    config.dis_scan_backoff = config.dis_scan_backoff as u8;
    config.ble_scan_classify_filter_enable = 0;
    config.cca_drop_mode = 0;  //???
    config.cca_low_tx_pwr = 0; //???
    config.main_xtal_freq = main_xtal_freq;
    config.version_num = Efuse::minor_chip_version();
    config.ignore_wl_for_direct_adv = 0;
    config.csa2_select = CONFIG_BT_LE_50_FEATURE_SUPPORT as _;
    config.ble_aa_check = config.verify_access_address as u8;
    config.ble_llcp_disc_flag = config.disconnect_llcp_conn_update as u8
        | ((config.disconnect_llcp_chan_map_update as u8) << 1)
        | ((config.disconnect_llcp_phy_update as u8) << 2);
    config.scan_backoff_upperlimitmax = config.scan_backoff_max;
    config.vhci_enabled = CONFIG_BT_LE_HCI_INTERFACE_USE_RAM as _;
    config.config_magic = CONFIG_MAGIC;
    config
}

```

--------------------------------

### phy_enable

Source: https://docs.espressif.com/projects/rust/esp-radio/0.16.0/esp32c3/src/esp_radio/wifi/os_adapter/mod.rs.html?search=Option%3CT%3E%2C+%28T+-%3E+U%29+-%3E+Option%3CU%3E

Initializes the PHY hardware for WiFi operation.

```APIDOC
## phy_enable

### Description
Initializes the PHY hardware.

### Parameters
None

### Returned Value
None
```

--------------------------------

### ScanConfig Initialization and Configuration

Source: https://docs.espressif.com/projects/rust/esp-radio/0.16.0/esp32c3/esp_radio/wifi/struct.ScanConfig.html?search=

Demonstrates how to create and configure a ScanConfig object using builder-style methods.

```APIDOC
## ScanConfig

### Description
Represents the configuration for a Wi-Fi scan operation.

### Methods

#### `with_ssid(self, ssid: &'a str) -> Self`
Assigns the given SSID to filter scan results.

#### `with_ssid_none(self) -> Self`
Clears the SSID filter, returning all SSIDs.

#### `ssid(&self) -> Option<&'a str>`
Returns the currently set SSID filter.

#### `with_bssid(self, bssid: [u8; 6]) -> Self`
Assigns the given BSSID to filter scan results.

#### `with_bssid_none(self) -> Self`
Clears the BSSID filter, returning all BSSIDs.

#### `bssid(&self) -> Option<[u8; 6]>`
Returns the currently set BSSID filter.

#### `with_channel(self, channel: u8) -> Self`
Assigns the given channel to filter scan results.

#### `with_channel_none(self) -> Self`
Clears the channel filter, returning all channels.

#### `channel(&self) -> Option<u8>`
Returns the currently set channel filter.

#### `with_show_hidden(self, show_hidden: bool) -> Self`
Configures whether to show hidden Wi-Fi networks.

#### `show_hidden(&self) -> bool`
Returns the current setting for showing hidden networks.

#### `with_scan_type(self, scan_type: ScanTypeConfig) -> Self`
Sets the type of scan (active or passive).

#### `scan_type(&self) -> ScanTypeConfig`
Returns the current scan type configuration.

#### `with_max(self, max: usize) -> Self`
Sets the maximum number of networks to return.

#### `with_max_none(self) -> Self`
Clears the maximum network limit, returning all networks.

#### `max(&self) -> Option<usize>`
Returns the maximum number of networks to return.

### Default Value

`ScanConfig::default()` can be used to create a `ScanConfig` with default settings.
```

--------------------------------

### from_raw

Source: https://docs.espressif.com/projects/rust/esp-radio/0.16.0/esp32c3/esp_radio/wifi/struct.RxControlInfo.html?search=

Creates an instance of RxControlInfo from a raw pointer to `wifi_pkt_rx_ctrl_t`.

```APIDOC
### impl RxControlInfo

#### pub unsafe fn from_raw(rx_cntl: *const wifi_pkt_rx_ctrl_t) -> Self

##### Safety

When calling this, you must ensure, that `rx_cntl` points to a valid instance of `wifi_pkt_rx_ctrl_t`.
```

--------------------------------

### Stall Other CPU (Start)

Source: https://docs.espressif.com/projects/rust/esp-radio/0.16.0/esp32c3/src/esp_radio/wifi/os_adapter/mod.rs.html

Placeholder function for starting the process of stalling other CPUs. Currently, this functionality is not supported.

```rust
pub unsafe extern "C" fn dport_access_stall_other_cpu_start_wrap() {
    trace!("dport_access_stall_other_cpu_start_wrap")
}
```

--------------------------------

### Copy Implementation for ConnectionlessModuleWakeIntervalStart

Source: https://docs.espressif.com/projects/rust/esp-radio/0.16.0/esp32c3/esp_radio/wifi/event/struct.ConnectionlessModuleWakeIntervalStart.html?search=std%3A%3Avec

Indicates that ConnectionlessModuleWakeIntervalStart can be copied.

```APIDOC
### impl Copy for ConnectionlessModuleWakeIntervalStart
```

--------------------------------

### Connect Wi-Fi Implementation

Source: https://docs.espressif.com/projects/rust/esp-radio/0.16.0/esp32c3/src/esp_radio/wifi/mod.rs.html?search=u32+-%3E+bool

Initiates a Wi-Fi connection. Currently marked with a TODO for ROAMING implementation.

```rust
fn connect_impl(&mut self) -> Result<(), WifiError> {
    // TODO: implement ROAMING
    esp_wifi_result!(unsafe { esp_wifi_connect_internal() })
}
```

--------------------------------

### Initialize Wi-Fi

Source: https://docs.espressif.com/projects/rust/esp-radio/0.16.0/esp32c3/src/esp_radio/wifi/mod.rs.html?search=std%3A%3Avec

Initializes the Wi-Fi module, including setting up callbacks and internal configurations.

```APIDOC
pub(crate) fn wifi_init(_wifi: crate::hal::peripherals::WIFI<'_>) -> Result<(), WifiError>
```

--------------------------------

### Get AMSDU TX Enable Status

Source: https://docs.espressif.com/projects/rust/esp-radio/0.16.0/esp32c3/esp_radio/wifi/struct.Config.html?search=

Get the status of the AMSDU TX feature. Available on crate feature `unstable` only.

```rust
pub fn amsdu_tx_enable(&self) -> bool
```

--------------------------------

### Get AMPDU TX Enable Status

Source: https://docs.espressif.com/projects/rust/esp-radio/0.16.0/esp32c3/esp_radio/wifi/struct.Config.html?search=

Get the status of the AMPDU TX feature. Available on crate feature `unstable` only.

```rust
pub fn ampdu_tx_enable(&self) -> bool
```

--------------------------------

### Create CountryInfo Instance

Source: https://docs.espressif.com/projects/rust/esp-radio/0.16.0/esp32c3/esp_radio/wifi/struct.CountryInfo.html

Use the `from` method to create a CountryInfo instance, then chain `operating_class` to set the operating class.

```rust
use esp_radio::wifi::{CountryInfo, OperatingClass};

let country_info = CountryInfo::from(*b"CN").operating_class(OperatingClass::Indoors);
```

--------------------------------

### Check if Wi-Fi Controller is Started

Source: https://docs.espressif.com/projects/rust/esp-radio/0.16.0/esp32c3/src/esp_radio/wifi/mod.rs.html?search=std%3A%3Avec

Verifies if the Wi-Fi controller has been successfully started, indicating that either the Station or Access Point (or both) are operational.

```APIDOC
## is_started

### Description
Checks if the Wi-Fi controller has started. Returns true if STA and/or AP are started.

This function should be called after the [`Self::start`] method to verify if the Wi-Fi controller has started successfully.

### Method
`pub fn is_started(&self) -> Result<bool, WifiError>`

### Returns
- `Ok(true)` if STA or AP is started.
- `Ok(false)` if neither STA nor AP is started.
```

--------------------------------

### Register Coexistence Start Callback

Source: https://docs.espressif.com/projects/rust/esp-radio/0.16.0/esp32c3/src/esp_radio/wifi/os_adapter/mod.rs.html?search=Option%3CT%3E%2C+%28T+-%3E+U%29+-%3E+Option%3CU%3E

Registers a callback function to be executed when the coexistence scheduler starts. Returns 0 if the 'coex' feature is not enabled.

```rust
pub unsafe extern "C" fn coex_register_start_cb(
    _cb: Option<unsafe extern "C" fn() -> esp_wifi_sys::c_types::c_int>,
) -> esp_wifi_sys::c_types::c_int {
    #[cfg(coex)]
    return unsafe { esp_wifi_sys::include::coex_register_start_cb(_cb) };

    #[cfg(not(coex))]
    0
}
```

--------------------------------

### Initialize PHY Hardware

Source: https://docs.espressif.com/projects/rust/esp-radio/0.16.0/esp32c3/src/esp_radio/wifi/os_adapter/mod.rs.html?search=u32+-%3E+bool

Initializes the PHY hardware. This function is marked as unsafe and requires careful management of the WIFI resource.

```rust
pub unsafe extern "C" fn phy_enable() {
    // quite some code needed here
    trace!("phy_enable");
    core::mem::forget(unsafe { WIFI::steal() }.enable_phy());
}
```

--------------------------------

### Check if Wi-Fi Controller is Started

Source: https://docs.espressif.com/projects/rust/esp-radio/0.16.0/esp32c3/esp_radio/wifi/struct.WifiController.html?search=Option%3CT%3E%2C+%28T+-%3E+U%29+-%3E+Option%3CU%3E

Checks if the Wi-Fi controller has started, indicating if STA and/or AP are running. This should be called after Self::start.

```rust
let started = wifi_controller.is_started().unwrap();
```

--------------------------------

### Initialize Wi-Fi

Source: https://docs.espressif.com/projects/rust/esp-radio/0.16.0/esp32c3/src/esp_radio/wifi/mod.rs.html

Initializes the Wi-Fi stack and its associated components.

```APIDOC
## wifi_init

### Description
Initializes the Wi-Fi stack, including internal configurations, mode settings, and event callbacks.

### Parameters
- `_wifi` (`crate::hal::peripherals::WIFI<'_>`): A handle to the Wi-Fi peripheral.

### Returns
- `Result<(), WifiError>`: Ok(()) on success, or a `WifiError` on failure.
```

--------------------------------

### Connect Wi-Fi Controller Implementation

Source: https://docs.espressif.com/projects/rust/esp-radio/0.16.0/esp32c3/src/esp_radio/wifi/mod.rs.html?search=Option%3CT%3E%2C+%28T+-%3E+U%29+-%3E+Option%3CU%3E

Internal implementation to connect the Wi-Fi controller. Currently has a TODO for ROAMING.

```rust
fn connect_impl(&mut self) -> Result<(), WifiError> {
        // TODO: implement ROAMING
        esp_wifi_result!(unsafe { esp_wifi_connect_internal() })
    }
```

--------------------------------

### Get RX Block Ack Window Size

Source: https://docs.espressif.com/projects/rust/esp-radio/0.16.0/esp32c3/esp_radio/wifi/struct.Config.html?search=

Get the size of the WiFi Block Ack RX window. Available on crate feature `unstable` only.

```rust
pub fn rx_ba_win(&self) -> u8
```

--------------------------------

### EventExt Implementation for BtwtSetup

Source: https://docs.espressif.com/projects/rust/esp-radio/0.16.0/esp32c3/esp_radio/wifi/event/struct.BtwtSetup.html

Shows how `BtwtSetup` can be used with the `EventExt` trait for handling events, though these methods are unstable.

```APIDOC
### impl<T> EventExt for T

```rust
fn take_handler() -> Box<Handler<Self>>
```

Available on **crate feature `unstable`** only.
Get the handler for this event, replacing it with the default handler.

```rust
fn replace_handler<F: FnMut(&Self) + Sync + Send + 'static>( f: F, ) -> Box<Handler<Self>>
```

Available on **crate feature `unstable`** only.
Set the handler for this event, returning the old handler.

```rust
fn update_handler<F: FnMut(&Self) + Sync + Send + 'static>(f: F)
```

Available on **crate feature `unstable`** only.
Atomic combination of `Self::take_handler` and `Self::replace_handler`. Use this to add a new handler which runs after the previously registered handlers.
```

--------------------------------

### Get New Home Channel

Source: https://docs.espressif.com/projects/rust/esp-radio/0.16.0/esp32c3/esp_radio/wifi/event/struct.HomeChannelChange.html

Retrieves the current or new home channel of the device. Call this method to get the updated primary channel information.

```rust
pub fn new_chan(&self) -> u8

```

--------------------------------

### EventExt Implementation for BtwtSetup

Source: https://docs.espressif.com/projects/rust/esp-radio/0.16.0/esp32c3/esp_radio/wifi/event/struct.BtwtSetup.html?search=

Shows how BtwtSetup can be used with event handling mechanisms through the `EventExt` trait, including methods for taking, replacing, and updating event handlers. Note that these methods are available only on the `unstable` crate feature.

```APIDOC
### impl<T> EventExt for T

where T: Event + 'static,

#### fn take_handler() -> Box<Handler<Self>>

Available on **crate feature`unstable`** only.
Get the handler for this event, replacing it with the default handler.

#### fn replace_handler<F: FnMut(&Self) + Sync + Send + 'static>( f: F, ) -> Box<Handler<Self>>

Available on **crate feature`unstable`** only.
Set the handler for this event, returning the old handler.

#### fn update_handler<F: FnMut(&Self) + Sync + Send + 'static>(f: F)

Available on **crate feature`unstable`** only.
Atomic combination of `Self::take_handler` and `Self::replace_handler`. Use this to add a new handler which runs after the previously registered handlers.
```

--------------------------------

### Initialize BLE Controller

Source: https://docs.espressif.com/projects/rust/esp-radio/0.16.0/esp32c3/src/esp_radio/ble/npl.rs.html

Initializes the BLE controller, including registering callback functions, setting up memory, configuring the controller, and enabling it. Includes platform-specific logic for ESP32-C2.

```rust
unsafe extern "C" {
    fn esp_ble_register_bb_funcs() -> i32;
}
let res = esp_ble_register_bb_funcs();
assert!(res == 0, "esp_ble_register_bb_funcs returned {}", res);
```

```rust
#[cfg(esp32c2)]
let res = ble_controller_init(&cfg as *const esp_bt_controller_config_t);
#[cfg(not(esp32c2))]
let res = r_ble_controller_init(&cfg as *const esp_bt_controller_config_t);

assert!(res == 0, "ble_controller_init returned {}", res);
```

```rust
#[cfg(not(esp32c2))]
{
    unsafe extern "C" {
        fn r_esp_ble_msys_init(
            msys_size1: u16,
            msys_size2: u16,
            msys_cnt1: u16,
            msys_cnt2: u16,
            from_heap: u8,
        ) -> i32;

        fn base_stack_initEnv() -> i32;
        fn conn_stack_initEnv() -> i32;
        fn adv_stack_initEnv() -> i32;
        fn extAdv_stack_initEnv() -> i32;
        fn sync_stack_initEnv() -> i32;
    }

    let res = base_stack_initEnv();
    assert!(res == 0, "base_stack_initEnv returned {}", res);

    let res = conn_stack_initEnv();
    assert!(res == 0, "conn_stack_initEnv returned {}", res);

    let res = adv_stack_initEnv();
    assert!(res == 0, "adv_stack_initEnv returned {}", res);

    let res = extAdv_stack_initEnv();
    if res != 0 {
        panic!("extAdv_stack_initEnv returned {}", res);
    }

    let res = sync_stack_initEnv();
    assert!(res == 0, "sync_stack_initEnv returned {}", res);

    let res = r_esp_ble_msys_init(256, 320, 12, 24, 1);
    assert!(res == 0, "esp_ble_msys_init returned {}", res);
}
```

```rust
#[cfg(coex)]
crate::binary::include::coex_enable();
```

```rust
let mut mac = [0u8; 6];
crate::common_adapter::read_mac(mac.as_mut_ptr(), 2);
mac.reverse();

#[cfg(esp32c2)]
esp_ble_ll_set_public_addr(&mac as *const u8);
#[cfg(not(esp32c2))]
r_esp_ble_ll_set_public_addr(&mac as *const u8);
```

```rust
unsafe extern "C" {
    fn r_ble_hci_trans_init(m: u8);
}
r_ble_hci_trans_init(0);
```

```rust
r_ble_hci_trans_cfg_hs(
    Some(ble_hs_hci_rx_evt),
    core::ptr::null(),
    Some(ble_hs_rx_data),
    core::ptr::null(),
);
```

```rust
#[cfg(esp32c2)]
let res = ble_controller_enable(1); // 1 = BLE
#[cfg(not(esp32c2))]
let res = r_ble_controller_enable(1); // 1 = BLE
assert!(res == 0, "ble_controller_enable returned {}", res);
```

```rust
// this is to avoid (ASSERT r_ble_hci_ram_hs_cmd_tx:34 0 0)
// we wait a bit to make sure the ble task initialized everything
crate::preempt::usleep(10_000);
```

```rust
unsafe { esp_hal::rng::TrngSource::increase_entropy_source_counter() };
```

--------------------------------

### Check if Wi-Fi Controller is Started

Source: https://docs.espressif.com/projects/rust/esp-radio/0.16.0/esp32c3/src/esp_radio/wifi/mod.rs.html?search=std%3A%3Avec

Verifies if the Wi-Fi controller has started, returning true if either the Station (STA) or Access Point (AP) interface is active.

```rust
pub fn is_started(&self) -> Result<bool, WifiError> {
        if matches!(
            crate::wifi::sta_state(),
            WifiStaState::Started | WifiStaState::Connected | WifiStaState::Disconnected
        ) {
            return Ok(true);
        }
        if matches!(crate::wifi::ap_state(), WifiApState::Started) {
            return Ok(true);
        }
        Ok(false)
    }
```

--------------------------------

### Initialize BLE Controller (ESP32-C2)

Source: https://docs.espressif.com/projects/rust/esp-radio/0.16.0/esp32c3/src/esp_radio/ble/npl.rs.html

Initializes the BLE controller on ESP32-C2. Requires a configuration structure.

```rust
pub(crate) fn ble_controller_init(cfg: *const esp_bt_controller_config_t) -> i32;
```

--------------------------------

### WifiController::new

Source: https://docs.espressif.com/projects/rust/esp-radio/0.16.0/esp32c3/esp_radio/wifi/index.html?search=

Creates a new Wi-Fi controller and its associated interfaces. This function is the entry point for initializing Wi-Fi functionality.

```APIDOC
## new

Create a Wi-Fi controller and it’s associated interfaces.

### Function Signature

```rust
fn new() -> WifiController
```

### Description

This function initializes and returns a `WifiController` instance, which manages the Wi-Fi device and its interfaces. It's the primary way to start using Wi-Fi functionalities.
```

--------------------------------

### Start Wi-Fi Scan Configuration

Source: https://docs.espressif.com/projects/rust/esp-radio/0.16.0/esp32c3/src/esp_radio/wifi/mod.rs.html?search=Option%3CT%3E%2C+%28T+-%3E+U%29+-%3E+Option%3CU%3E

Configures and starts a Wi-Fi scan based on the provided ScanConfig. Handles active and passive scan types, and prepares data structures for the underlying ESP-IDF function.

```rust
pub(crate) fn wifi_start_scan(
    block: bool,
    ScanConfig {
        ssid,
        mut bssid,
        channel,
        show_hidden,
        scan_type,
        ..
    }: ScanConfig<'_>,
) -> i32 {
    scan_type.validate();
    let (scan_time, scan_type) = match scan_type {
        ScanTypeConfig::Active { min, max } => (
            wifi_scan_time_t {
                active: wifi_active_scan_time_t {
                    min: min.as_millis() as u32,
                    max: max.as_millis() as u32,
                },
                passive: 0,
            },
            wifi_scan_type_t_WIFI_SCAN_TYPE_ACTIVE,
        ),
        ScanTypeConfig::Passive(dur) => (
            wifi_scan_time_t {
                active: wifi_active_scan_time_t { min: 0, max: 0 },
                passive: dur.as_millis() as u32,
            },
            wifi_scan_type_t_WIFI_SCAN_TYPE_PASSIVE,
        ),
    };

    let mut ssid_buf = ssid.map(|m| {
        let mut buf = alloc::vec::Vec::from_iter(m.bytes());
        buf.push(b'\0');
        buf
    });

    let ssid = ssid_buf
        .as_mut()
        .map(|e| e.as_mut_ptr())
        .unwrap_or_else(core::ptr::null_mut);
    let bssid = bssid
        .as_mut()
        .map(|e| e.as_mut_ptr())
        .unwrap_or_else(core::ptr::null_mut);

    let scan_config = wifi_scan_config_t {
        ssid,
        bssid,
        channel: channel.unwrap_or(0),
        show_hidden,
        scan_type,
        scan_time,
        home_chan_dwell_time: 0,
        channel_bitmap: wifi_scan_channel_bitmap_t {
            ghz_2_channels: 0,
            ghz_5_channels: 0,
        },
        coex_background_scan: false,
    };

    unsafe { esp_wifi_scan_start(&scan_config, block) }
}
```

--------------------------------

### capabilities

Source: https://docs.espressif.com/projects/rust/esp-radio/0.16.0/esp32c3/src/esp_radio/wifi/mod.rs.html?search=Option%3CT%3E%2C+%28T+-%3E+U%29+-%3E+Option%3CU%3E

Get the supported capabilities of the controller.

```APIDOC
## capabilities

### Description
Retrieves the supported Wi-Fi capabilities of the controller.

### Method
`pub fn capabilities(&self) -> Result<EnumSet<crate::wifi::Capability>, WifiError>`

### Parameters
None

### Returns
- `Ok(EnumSet<Capability>)`: An `EnumSet` containing the supported capabilities, such as `Client`, `AccessPoint`, and `ApSta`.
- `Err(WifiError)`: If there is an error retrieving the capabilities.
```

--------------------------------

### Wi-Fi Initialization

Source: https://docs.espressif.com/projects/rust/esp-radio/0.16.0/esp32c3/src/esp_radio/wifi/mod.rs.html?search=Option%3CT%3E%2C+%28T+-%3E+U%29+-%3E+Option%3CU%3E

Initializes the Wi-Fi stack, including setting up internal configurations, modes, and callback handlers.

```APIDOC
## wifi_init

### Description
Initializes the Wi-Fi driver and related components. This function sets up the necessary configurations, registers callback functions for packet reception and transmission, and initializes the supplicant.

### Function Signature
`pub(crate) fn wifi_init(_wifi: crate::hal::peripherals::WIFI<'_>) -> Result<(), WifiError>`

### Parameters
* `_wifi`: A reference to the WIFI peripheral.

### Returns
* `Ok(())` on successful initialization.
* `Err(WifiError)` if any of the internal Wi-Fi functions return an error.

### Notes
- This function includes conditional compilation for `esp32` and `coex` features.
- It calls internal functions like `esp_wifi_init_internal`, `esp_wifi_set_mode`, `esp_supplicant_init`, and registers receive callbacks (`recv_cb_sta`, `recv_cb_ap`).
```

--------------------------------

### ESP-Radio ESP Timer Get Time

Source: https://docs.espressif.com/projects/rust/esp-radio/0.16.0/esp32c3/src/esp_radio/common_adapter.rs.html?search=Option%3CT%3E%2C+%28T+-%3E+U%29+-%3E+Option%3CU%3E

Gets the system time in microseconds since boot. It conditionally uses `crate::preempt::now()` if 'wifi' or 'ble' features are enabled, otherwise it uses `esp_hal::time::Instant::now()`.

```rust
/// **************************************************************************
/// Name: esp_timer_get_time
///
/// Description:
///   Get time in microseconds since boot.
///
/// Returned Value:
///   System time in micros
///
/// **************************************************************************
#[unsafe(no_mangle)]
pub unsafe extern "C" fn __esp_radio_esp_timer_get_time() -> i64 {
    trace!("esp_timer_get_time");
    // Just using IEEE802.15.4 doesn't need the current time. If we don't use `preempt::now`,
    // users will not need to have a scheduler in their firmware.
    cfg_if::cfg_if! {
        if #[cfg(any(feature = "wifi", feature = "ble"))] {
            crate::preempt::now() as i64
        } else {
            // In this case we don't have a scheduler, we can return esp-hal's timestamp.
            esp_hal::time::Instant::now().duration_since_epoch().as_micros() as i64
        }
    }
}
```

--------------------------------

### CountryInfo Creation and Configuration

Source: https://docs.espressif.com/projects/rust/esp-radio/0.16.0/esp32c3/esp_radio/wifi/struct.CountryInfo.html

Demonstrates how to create a CountryInfo instance and set its operating class.

```APIDOC
## Struct CountryInfo

Available on **crate feature`wifi`** only.

Country information. Defaults to China (CN) with Operating Class “0”.

To create a `CountryInfo` instance, use the `from` method first, then set additional properties using the builder methods.

### §Example
```rust
use esp_radio::wifi::{CountryInfo, OperatingClass};

let country_info = CountryInfo::from(*b"CN").operating_class(OperatingClass::Indoors);
```

## impl CountryInfo

### pub fn with_operating_class(self, operating_class: OperatingClass) -> Self

Available on **crate feature`unstable`** only.

Assign the given value to the `operating_class` field.

### pub fn operating_class(&self) -> OperatingClass

Available on **crate feature`unstable`** only.

Operating class.

### impl From<[u8; 2]> for CountryInfo

#### fn from(country: [u8; 2]) -> Self

Converts to this type from the input type.
```

--------------------------------

### report_len

Source: https://docs.espressif.com/projects/rust/esp-radio/0.16.0/esp32c3/esp_radio/wifi/event/struct.StaNeighborRep.html?search=Option%3CT%3E%2C+%28T+-%3E+U%29+-%3E+Option%3CU%3E

Gets the length of the Neighbor Report in bytes.

```APIDOC
## fn report_len(&self) -> u16

### Description
Get the length of report.

### Returns
- `u16`: The length of the Neighbor Report in bytes.
```

--------------------------------

### Get Passphrase

Source: https://docs.espressif.com/projects/rust/esp-radio/0.16.0/esp32c3/esp_radio/wifi/event/struct.ApCredential.html?search=std%3A%3Avec

Retrieves the passphrase for an Access Point.

```APIDOC
## pub fn passphrase(&self) -> &[u8]

Get passphrase for the AP.
```

--------------------------------

### Initialize ESP-NOW and Register Callbacks

Source: https://docs.espressif.com/projects/rust/esp-radio/0.16.0/esp32c3/src/esp_radio/esp_now/mod.rs.html?search=

Initializes the ESP-NOW protocol and registers the receive and send callback functions. This is a crucial setup step before using ESP-NOW for communication.

```rust
check_error_expect!({ esp_now_init() }, "esp-now-init failed");
check_error_expect!(
    { esp_now_register_recv_cb(Some(rcv_cb)) },
    "receiving callback failed"
);
check_error_expect!(
    { esp_now_register_send_cb(Some(send_cb)) },
    "sending callback failed"
);
```

--------------------------------

### Get Capabilities

Source: https://docs.espressif.com/projects/rust/esp-radio/0.16.0/esp32c3/src/esp_radio/wifi/mod.rs.html?search=

Retrieves the supported Wi-Fi capabilities of the controller.

```APIDOC
## capabilities

### Description
Get the supported capabilities of the controller.

### Method
`pub fn capabilities(&self) -> Result<EnumSet<crate::wifi::Capability>, WifiError>`

### Parameters
None

### Returns
- `Ok(EnumSet<Capability>)`: An EnumSet containing the supported capabilities (e.g., Client, AccessPoint, ApSta).
- `Err(WifiError)`: If there is an error retrieving capabilities.
```
Tokens:
Raw