ESP-HAL

https://docs.espressif.com/projects/rust/esp-hal/1.0.0/esp32/esp_hal/
Admin
ESP-HAL is a bare-metal Hardware Abstraction Layer for Espressif ESP32 microcontrollers that...
Tokens:625,539
Snippets:5,122
Trust Score:10
Update:3 months ago
Show doc for...
Tokens:
Raw
### Initialize esp-hal with Default Configuration

Source: https://docs.espressif.com/projects/rust/esp-hal/1.0.0/esp32/esp_hal/struct.Config.html

Use this snippet to initialize the esp-hal system with the default configuration settings. This is the simplest way to get started.

```rust
let peripherals = esp_hal::init(esp_hal::Config::default());
```

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

### Initialize and Start AES Backend

Source: https://docs.espressif.com/projects/rust/esp-hal/1.0.0/esp32/esp_hal/aes/struct.AesBackend.html

Demonstrates how to create a new AES backend instance and start it, enabling it to process AES operations. The backend needs to be started before it can execute AES operations.

```rust
use esp_hal::aes::AesBackend;
let mut aes = AesBackend::new(peripherals.AES);
```

```rust
use esp_hal::aes::AesBackend;
let mut aes = AesBackend::new(peripherals.AES);
// Start the backend, which allows processing AES operations.
let _backend = aes.start();
```

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

### CPU Core Usage Example

Source: https://docs.espressif.com/projects/rust/esp-hal/1.0.0/esp32/esp_hal/system/enum.Cpu.html

Demonstrates how to get the current CPU core.

```APIDOC
## Example: Get Current CPU Core

### Code
```rust
use esp_hal::system::Cpu;

let current_cpu = Cpu::current();
println!("Current CPU: {:?}", current_cpu);
```
```

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

### Install and Run esp-generate

Source: https://docs.espressif.com/projects/rust/esp-hal/1.0.0/esp32/esp_hal/index.html

Installs the project generation tool and initializes a new project for a specific chip.

```bash
cargo install esp-generate
esp-generate --chip=esp32c6 your-project
```

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

### Configure and Use General-purpose Timer

Source: https://docs.espressif.com/projects/rust/esp-hal/1.0.0/esp32/esp_hal/timer/timg/index.html

Demonstrates how to initialize a general-purpose timer, get the current timestamp, set a timeout, start the timer, and clear the interrupt.

```rust
use esp_hal::timer::{Timer, timg::TimerGroup};

let timg0 = TimerGroup::new(peripherals.TIMG0);
let timer0 = timg0.timer0;

// Get the current timestamp, in microseconds:
let now = timer0.now();

// Wait for timeout:
timer0.load_value(Duration::from_secs(1));
timer0.start();

while !timer0.is_interrupt_set() {
    // Wait
}

timer0.clear_interrupt();
```

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

### Start Application Core

Source: https://docs.espressif.com/projects/rust/esp-hal/1.0.0/esp32/esp_hal/system/struct.CpuControl.html

Demonstrates how to start the second application core with a given stack and entry function. The returned guard parks the core when dropped. Requires the `unstable` crate feature.

```rust
static mut APP_CORE_STACK: Stack<8192> = Stack::new();

let counter = Mutex::new(RefCell::new(0));

let mut cpu_control = CpuControl::new(peripherals.CPU_CTRL);
let cpu1_fnctn = || {
    cpu1_task(&delay, &counter);
};
let _guard =
    cpu_control.start_app_core(unsafe { &mut *addr_of_mut!(APP_CORE_STACK) }, cpu1_fnctn)?;

loop {
    delay.delay(Duration::from_secs(1));
    let count = critical_section::with(|cs| *counter.borrow_ref(cs));
}

// Where `cpu1_task()` may be defined as:

fn cpu1_task(delay: &Delay, counter: &critical_section::Mutex<RefCell<i32>>) -> ! {
    loop {
        delay.delay(Duration::from_millis(500));

        critical_section::with(|cs| {
            let mut val = counter.borrow_ref_mut(cs);
            *val = val.wrapping_add(1);
        });
    }
}
```

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

### I2S Read Example with DMA

Source: https://docs.espressif.com/projects/rust/esp-hal/1.0.0/esp32/esp_hal/i2s/master/index.html

Demonstrates how to configure and use the I2S peripheral for reading audio data using DMA in TDM Philips mode. Ensure the `unstable` crate feature is enabled. Requires setup of DMA channel, I2S peripheral, and pin configurations.

```rust
let dma_channel = peripherals.DMA_I2S0;
let (mut rx_buffer, rx_descriptors, _, _) = dma_buffers!(4 * 4092, 0);

let i2s = I2s::new(
    peripherals.I2S0,
    dma_channel,
    Config::new_tdm_philips()
        .with_sample_rate(Rate::from_hz(44100))
        .with_data_format(DataFormat::Data16Channel16)
        .with_channels(Channels::STEREO),
)?;

let mut i2s_rx = i2s
    .i2s_rx
    .with_bclk(peripherals.GPIO1)
    .with_ws(peripherals.GPIO2)
    .with_din(peripherals.GPIO5)
    .build(rx_descriptors);

let mut transfer = i2s_rx.read_dma_circular(&mut rx_buffer)?;

loop {
    let avail = transfer.available()?;

    if avail > 0 {
        let mut rcv = [0u8; 5000];
        transfer.pop(&mut rcv[..avail])?;
    }
}
```

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

### Create a New SHA Backend Instance

Source: https://docs.espressif.com/projects/rust/esp-hal/1.0.0/esp32/esp_hal/sha/struct.ShaBackend.html

Instantiates a new SHA backend. The backend must be started using the `start()` method before it can be used for SHA operations.

```rust
pub fn new(sha: SHA<'d>) -> Self
```

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

### Create and Start RsaBackend

Source: https://docs.espressif.com/projects/rust/esp-hal/1.0.0/esp32/esp_hal/rsa/struct.RsaBackend.html

Demonstrates how to create a new RsaBackend instance and start it to enable RSA operations. The returned driver object manages the backend's lifecycle.

```rust
use esp_hal::rsa::RsaBackend;
let mut rsa = RsaBackend::new(peripherals.RSA);
```

```rust
use esp_hal::rsa::RsaBackend;
let mut rsa = RsaBackend::new(peripherals.RSA);
// Start the backend, which allows processing RSA operations.
let _backend = rsa.start();
```

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

### Initialize I2C Master Driver

Source: https://docs.espressif.com/projects/rust/esp-hal/1.0.0/esp32/esp_hal/i2c/master/struct.I2c.html

Initializes the I2C master driver with default configuration and assigns SDA and SCL pins. This example demonstrates basic setup for I2C communication.

```rust
use esp_hal::i2c::master::{Config, I2c};
let mut i2c = I2c::new(peripherals.I2C0, Config::default())?
    .with_sda(peripherals.GPIO1)
    .with_scl(peripherals.GPIO2);

let mut data = [0u8; 22];
i2c.write_read(DEVICE_ADDR, &[0xaa], &mut data)?;
```

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

### Configure TWAI for Self-Testing

Source: https://docs.espressif.com/projects/rust/esp-hal/1.0.0/esp32/esp_hal/twai/index.html

Initializes the TWAI peripheral in Self-Test mode using specified pins and baud rate. It configures acceptance filters and starts the peripheral. The example then creates a frame for self-reception and waits to receive it.

```rust
// Use GPIO pins 2 and 3 to connect to the respective pins on the TWAI
// transceiver.
let can_rx_pin = peripherals.GPIO3;
let can_tx_pin = peripherals.GPIO2;

// The speed of the TWAI bus.
const TWAI_BAUDRATE: twai::BaudRate = BaudRate::B1000K;

// Begin configuring the TWAI peripheral.
let mut can_config = twai::TwaiConfiguration::new(
    peripherals.TWAI0,
    can_rx_pin,
    can_tx_pin,
    TWAI_BAUDRATE,
    TwaiMode::SelfTest
);

// Partially filter the incoming messages to reduce overhead of receiving
// undesired messages
can_config.set_filter(const { SingleStandardFilter::new(b"xxxxxxxxxx0",
b"x", [b"xxxxxxxx", b"xxxxxxxx"]) });

// Start the peripheral. This locks the configuration settings of the
// peripheral and puts it into operation mode, allowing packets to be sent
// and received.
let mut can = can_config.start();

let frame = EspTwaiFrame::new_self_reception(StandardId::ZERO,
    &[1, 2, 3]).unwrap(); // Wait for a frame to be received.
let frame = block!(can.receive())?;

```

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

### Start Touch Measurement (OneShot, Blocking)

Source: https://docs.espressif.com/projects/rust/esp-hal/1.0.0/esp32/esp_hal/touch/struct.TouchPad.html

Starts a touch measurement on the pin. Use in `OneShot` mode. The result can be retrieved by calling `read` after measurement is finished.

```rust
pub fn start_measurement(&mut self)
```

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

### esp_hal::init

Source: https://docs.espressif.com/projects/rust/esp-hal/1.0.0/esp32/esp_hal/fn.init.html

Initializes the system, setting up the CPU clock and watchdog. It returns the peripherals and clocks.

```APIDOC
## POST /init

### Description
Initializes the system, setting up the CPU clock and watchdog. It returns the peripherals and clocks.

### Method
POST

### Endpoint
/init

### Parameters
#### Request Body
- **config** (Config) - Required - Configuration for the system initialization.

### Request Example
```json
{
  "config": {
    "default": true
  }
}
```

### Response
#### Success Response (200)
- **peripherals** (Peripherals) - The initialized system peripherals.
- **clocks** (Clocks) - The initialized system clocks.

#### Response Example
```json
{
  "peripherals": {},
  "clocks": {}
}
```

### Notes
Available on `crate feature 'rt'` only.
```

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

### Get Current Time in Microseconds

Source: https://docs.espressif.com/projects/rust/esp-hal/1.0.0/esp32/esp_hal/rtc_cntl/struct.Rtc.html

Gets the current time in microseconds. This example shows how to get the weekday of the current time in New York using the `jiff` crate and works in core-only environments without dynamic memory allocation.

```rust
use jiff::{
    Timestamp,
    tz::{self, TimeZone},
};

static TZ: TimeZone = tz::get!("America/New_York");

let rtc = Rtc::new(peripherals.LPWR);
let now = Timestamp::from_microsecond(rtc.current_time_us() as i64)?;
let weekday_in_new_york = now.to_zoned(TZ.clone()).weekday();
```

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

### UART Initialization and Basic Usage

Source: https://docs.espressif.com/projects/rust/esp-hal/1.0.0/esp32/esp_hal/uart/struct.Uart.html

Demonstrates how to initialize a UART instance with default configuration and set up RX/TX pins, followed by writing data.

```APIDOC
## POST /api/uart

### Description
Initializes and configures a UART peripheral for communication.

### Method
POST

### Endpoint
/api/uart

### Parameters
#### Request Body
- **uart_instance** (string) - Required - The UART peripheral instance to use (e.g., "UART0").
- **rx_pin** (string) - Required - The GPIO pin to use for receiving data.
- **tx_pin** (string) - Required - The GPIO pin to use for transmitting data.
- **config** (object) - Optional - UART configuration settings. Defaults to `Config::default()`.
  - **baudrate** (number) - Optional - The baud rate for the UART communication.
  - **data_bits** (string) - Optional - The number of data bits (e.g., "DataBits8").
  - **parity** (string) - Optional - The parity setting (e.g., "ParityNone").
  - **stop_bits** (string) - Optional - The number of stop bits (e.g., "StopBits1").

### Request Example
```json
{
  "uart_instance": "UART0",
  "rx_pin": "GPIO1",
  "tx_pin": "GPIO2",
  "config": {
    "baudrate": 115200,
    "data_bits": "DataBits8",
    "parity": "ParityNone",
    "stop_bits": "StopBits1"
  }
}
```

### Response
#### Success Response (200)
- **uart_handle** (string) - A unique identifier for the initialized UART instance.

#### Response Example
```json
{
  "uart_handle": "uart0_instance_12345"
}
```
```

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

### Get Subslice Range

Source: https://docs.espressif.com/projects/rust/esp-hal/1.0.0/esp32/esp_hal/dma/struct.DmaLoopBuf.html

Example of using `subslice_range` to find the byte range of a subslice within a larger slice. This API is nightly-only and does not compare elements, relying on pointer alignment.

```rust
#![feature(substr_range)]

let nums = &[0, 5, 10, 0, 0, 5];

let mut iter = nums
    .split(|t| *t == 0)
    .map(|n| nums.subslice_range(n).unwrap());

assert_eq!(iter.next(), Some(0..0));
assert_eq!(iter.next(), Some(1..3));
assert_eq!(iter.next(), Some(4..4));
assert_eq!(iter.next(), Some(5..6));
```

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

### init

Source: https://docs.espressif.com/projects/rust/esp-hal/1.0.0/esp32/esp_hal/index.html

Initializes the system hardware and runtime environment.

```APIDOC
## init

### Description
Initializes the system. This function should be called at the start of the program to set up the necessary hardware and runtime environment.

### Signature
`fn init() -> ...`
```

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

### TouchPad Initialization and Basic Usage

Source: https://docs.espressif.com/projects/rust/esp-hal/1.0.0/esp32/esp_hal/touch/struct.TouchPad.html

Demonstrates how to initialize a TouchPad and read its capacitance value.

```APIDOC
## POST /api/users

### Description
Creates a new user in the system.

### Method
POST

### Endpoint
/api/users

### Parameters
#### Request Body
- **username** (string) - Required - The desired username for the new user.
- **email** (string) - Required - The email address of the new user.
- **password** (string) - Required - The password for the new user.

### Request Example
```json
{
  "username": "johndoe",
  "email": "john.doe@example.com",
  "password": "securepassword123"
}
```

### Response
#### Success Response (201)
- **id** (string) - The unique identifier for the newly created user.
- **username** (string) - The username of the created user.
- **email** (string) - The email address of the created user.

#### Response Example
```json
{
  "id": "user-12345",
  "username": "johndoe",
  "email": "john.doe@example.com"
}
```
```

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

### Iterate over slice chunks from the end

Source: https://docs.espressif.com/projects/rust/esp-hal/1.0.0/esp32/esp_hal/dma/struct.DmaLoopBuf.html

Use `rchunks` to get an iterator over mutable slices of a specified size, starting from the end. The last chunk may be smaller if the slice length is not divisible by `chunk_size`.

```rust
let slice = ['l', 'o', 'r', 'e', 'm'];
let mut iter = slice.rchunks(2);
assert_eq!(iter.next().unwrap(), &['e', 'm']);
assert_eq!(iter.next().unwrap(), &['o', 'r']);
assert_eq!(iter.next().unwrap(), &['l']);
assert!(iter.next().is_none());
```

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

### Initialize Input Pin

Source: https://docs.espressif.com/projects/rust/esp-hal/1.0.0/esp32/esp_hal/gpio/struct.Input.html

Demonstrates how to initialize a GPIO pin as an input with default configuration.

```rust
use esp_hal::gpio::{Input, InputConfig};
let pin = Input::new(peripherals.GPIO5, InputConfig::default());
let is_low = pin.is_low();

```

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

### Get Element Offset in Slice

Source: https://docs.espressif.com/projects/rust/esp-hal/1.0.0/esp32/esp_hal/dma/struct.DmaLoopBuf.html

Example of using `element_offset` to find the index of an element within a slice. This API relies on pointer arithmetic and does not compare elements. It's a nightly-only experimental feature.

```rust
#![feature(substr_range)]

let nums: &[u32] = &[1, 7, 1, 1];
let num = &nums[2];

assert_eq!(num, &1);
assert_eq!(nums.element_offset(num), Some(2));
```

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

### Enable Rwdt

Source: https://docs.espressif.com/projects/rust/esp-hal/1.0.0/esp32/esp_hal/rtc_cntl/struct.Rwdt.html

Enables the watchdog timer instance. Watchdog starts with default settings.

```rust
pub fn enable(&mut self)
```

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

### Iterate over exact slice chunks from the end

Source: https://docs.espressif.com/projects/rust/esp-hal/1.0.0/esp32/esp_hal/dma/struct.DmaLoopBuf.html

Use `rchunks_exact` to get an iterator over slices of exactly `chunk_size`, starting from the end. Any remaining elements that do not form a full chunk can be accessed via the `remainder()` method.

```rust
let slice = ['l', 'o', 'r', 'e', 'm'];
let mut iter = slice.rchunks_exact(2);
assert_eq!(iter.next().unwrap(), &['e', 'm']);
assert_eq!(iter.next().unwrap(), &['o', 'r']);
assert!(iter.next().is_none());
assert_eq!(iter.remainder(), &['l']);
```

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

### Mutably iterate over exact slice chunks from the end

Source: https://docs.espressif.com/projects/rust/esp-hal/1.0.0/esp32/esp_hal/dma/struct.DmaLoopBuf.html

Use `rchunks_exact_mut` to get an iterator over mutable slices of exactly `chunk_size`, starting from the end. This allows in-place modification. Remaining elements can be accessed via `into_remainder()`.

```rust
let v = &mut [0, 0, 0, 0, 0];
let mut count = 1;

for chunk in v.rchunks_exact_mut(2) {
    for elem in chunk.iter_mut() {
        *elem += count;
    }
    count += 1;
}
assert_eq!(v, &[0, 2, 2, 1, 1]);
```

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

### Initialize and Configure GPIO Pins

Source: https://docs.espressif.com/projects/rust/esp-hal/1.0.0/esp32/esp_hal/gpio/index.html

Demonstrates initializing the HAL and accessing individual pins for use as general purpose digital I/O. Pins can be configured as input or output with various options.

```rust
let peripherals = Peripherals::take();
let io = Io::new(peripherals.GPIO, peripherals.IO_MUX);

let mut pin_2 = io.pins2.into_output();
pin_2.set_high().unwrap();
```

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

### Set up and handle software interrupt 0

Source: https://docs.espressif.com/projects/rust/esp-hal/1.0.0/esp32/esp_hal/interrupt/software/index.html

Demonstrates how to initialize, set up a handler for, and manage software interrupt 0. Requires the `unstable` crate feature. Ensure the interrupt handler is set up within a critical section.

```rust
let sw_ints = SoftwareInterruptControl::new(peripherals.SW_INTERRUPT);

// Take the interrupt you want to use.
let mut int0 = sw_ints.software_interrupt0;

// Set up the interrupt handler. Do this in a critical section so the global
// contains the interrupt object before the interrupt is triggered.
critical_section::with(|cs| {
    int0.set_interrupt_handler(swint0_handler);
    SWINT0.borrow_ref_mut(cs).replace(int0);
});

// ... somewhere outside of your main function

// Define a shared handle to the software interrupt.
static SWINT0: Mutex<RefCell<Option<SoftwareInterrupt<0>>>> = Mutex::new(RefCell::new(None));

#[handler]
fn swint0_handler() {
    println!("SW interrupt0 handled");

    // Clear the interrupt request.
    critical_section::with(|cs| {
        if let Some(swint) = SWINT0.borrow_ref(cs).as_ref() {
            swint.reset();
        }
    });
}
```

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

### Mutably iterate over slice chunks from the end

Source: https://docs.espressif.com/projects/rust/esp-hal/1.0.0/esp32/esp_hal/dma/struct.DmaLoopBuf.html

Use `rchunks_mut` to get an iterator over mutable slices of a specified size, starting from the end. This allows in-place modification of elements within each chunk. The last chunk may be smaller.

```rust
let v = &mut [0, 0, 0, 0, 0];
let mut count = 1;

for chunk in v.rchunks_mut(2) {
    for elem in chunk.iter_mut() {
        *elem += count;
    }
    count += 1;
}
assert_eq!(v, &[3, 2, 2, 1, 1]);
```

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

### Async Driver Initialization

Source: https://docs.espressif.com/projects/rust/esp-hal/1.0.0/esp32/esp_hal/struct.Async.html

Demonstrates how to initialize a driver in asynchronous mode using the `into_async` method.

```APIDOC
## Async Driver Initialization Example

### Description
This example shows how to convert a blocking UART driver into an asynchronous driver.

### Method
`into_async()`

### Endpoint
N/A (This is a code example, not an API endpoint)

### Request Body
N/A

### Request Example
```rust
let uart = Uart::new(peripherals.UART0, Config::default())?
    .with_rx(peripherals.GPIO1)
    .with_tx(peripherals.GPIO2)
    .into_async();
```

### Response
N/A

### Response Example
N/A
```

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

### Get Period of MCPWM Timer

Source: https://docs.espressif.com/projects/rust/esp-hal/1.0.0/esp32/esp_hal/mcpwm/operator/struct.PwmPin.html

Get the period of the timer associated with a PwmPin.

```rust
pub fn period(&self) -> u16
```

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

### Create and Use GPIO Output Driver

Source: https://docs.espressif.com/projects/rust/esp-hal/1.0.0/esp32/esp_hal/gpio/struct.Output.html

Configures a GPIO pin as an output and demonstrates basic usage with a delay. Assumes LED is on when pin is low.

```rust
use esp_hal::{
    delay::Delay,
    gpio::{Level, Output, OutputConfig},
};

fn blink_once(led: &mut Output<'_>, delay: &mut Delay) {
    led.set_low();
    delay.delay_millis(500);
    led.set_high();
}

let config = OutputConfig::default();
let mut led = Output::new(peripherals.GPIO5, Level::High, config);
let mut delay = Delay::new();

blink_once(&mut led, &mut delay);
```

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

### H-Bridge Example with LinkedPins

Source: https://docs.espressif.com/projects/rust/esp-hal/1.0.0/esp32/esp_hal/mcpwm/operator/struct.LinkedPins.html

Demonstrates setting up an H-bridge configuration using `LinkedPins` for complementary signals with deadtime. Requires the `unstable` crate feature.

```rust
let bridge_active = DeadTimeCfg::new_ahc();
let bridge_off = DeadTimeCfg::new_bypass().set_output_swap(PWMStream::PWMA, true);
let clock_cfg = PeripheralClockConfig::with_frequency(Rate::from_mhz(40))?;
let mut mcpwm = McPwm::new(peripherals.MCPWM0, clock_cfg);

let mut pins = mcpwm.operator0.with_linked_pins(
    peripherals.GPIO0,
    PwmPinConfig::UP_DOWN_ACTIVE_HIGH, // use PWMA as our main input
    peripherals.GPIO1,
    PwmPinConfig::EMPTY, // keep PWMB "low"
    bridge_off,
);

pins.set_falling_edge_deadtime(5);
pins.set_rising_edge_deadtime(5);
// pin_a: ________________________________________
// pin_b: ________________________________________
pins.set_timestamp_a(40); // 40% duty cycle if period configured to 100
pins.set_deadtime_cfg(bridge_active);
// pin_a: _______-------_____________-------______
// pin_b: ------_________-----------_________-----
```

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

### Get Type ID

Source: https://docs.espressif.com/projects/rust/esp-hal/1.0.0/esp32/esp_hal/sha/struct.Sha1.html

Gets the `TypeId` of the `Sha1` struct. This is part of the `Any` trait implementation.

```rust
fn type_id(&self) -> TypeId;
```

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

### Get Type ID

Source: https://docs.espressif.com/projects/rust/esp-hal/1.0.0/esp32/esp_hal/ledc/struct.HighSpeed.html

Gets the `TypeId` of the current type. This is a blanket implementation for any type `T` that is `'static + ?Sized`.

```rust
fn type_id(&self) -> TypeId;

```

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

### UART Initialization and Basic Usage

Source: https://docs.espressif.com/projects/rust/esp-hal/1.0.0/esp32/esp_hal/uart/struct.Uart.html

Demonstrates how to initialize the UART peripheral and set up basic transmit and receive pins.

```APIDOC
## UART Initialization and Basic Usage

### Description
Initializes the UART peripheral with a default configuration and assigns specific GPIO pins for transmit (TX) and receive (RTS) functionality.

### Method
POST (Implicitly, as initialization creates a new instance)

### Endpoint
N/A (This is a library function, not a network endpoint)

### Request Body
N/A

### Request Example
```rust
use esp_hal::uart::{Config, Uart};
let uart = Uart::new(peripherals.UART0, Config::default())?
    .with_tx(peripherals.GPIO2)
    .with_rts(peripherals.GPIO3);
```

### Response
N/A (Initialization returns a `Result` which is handled by the caller)

```

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

### Initialize esp-hal System

Source: https://docs.espressif.com/projects/rust/esp-hal/1.0.0/esp32/esp_hal/fn.init.html

Call this function to set up the CPU clock and watchdog. Requires the `rt` crate feature. Returns peripherals and clocks.

```rust
use esp_hal::{Config, init};
let peripherals = init(Config::default());
```

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

### Start RSA Multiplication Operation

Source: https://docs.espressif.com/projects/rust/esp-hal/1.0.0/esp32/esp_hal/rsa/struct.RsaMultiplication.html

Starts the RSA multiplication operation with the second operand. This method prepares the peripheral for the multiplication.

```rust
pub fn start_multiplication(&mut self, operand_b: &T::InputType)
```

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

### SPI Master Initialization and Configuration

Source: https://docs.espressif.com/projects/rust/esp-hal/1.0.0/esp32/esp_hal/spi/master/struct.Spi.html

Demonstrates how to initialize and configure the SPI master driver with basic settings like frequency and mode.

```APIDOC
## POST /api/spi/master/new

### Description
Constructs an SPI instance in 8bit dataframe mode.

### Method
POST

### Endpoint
/api/spi/master/new

### Parameters
#### Request Body
- **spi** (impl Instance + 'd) - Required - The SPI peripheral instance.
- **config** (Config) - Required - The SPI configuration.

### Request Example
```json
{
  "spi": "peripherals.SPI2",
  "config": {
    "frequency": {
      "value": 100,
      "unit": "khz"
    },
    "mode": "_0"
  }
}
```

### Response
#### Success Response (200)
- **Spi<'d, Blocking>** (object) - The initialized SPI instance.

#### Response Example
```json
{
  "spi_instance": "<initialized_spi_instance>"
}
```
```

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

### Start RSA Modular Multiplication

Source: https://docs.espressif.com/projects/rust/esp-hal/1.0.0/esp32/esp_hal/rsa/struct.RsaModularMultiplication.html

Starts the modular multiplication operation with the second operand. Refer to the Technical Reference Manual for more details.

```rust
pub fn start_modular_multiplication(&mut self, operand_b: &T::InputType)
```

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

### Get Last Element of a Slice

Source: https://docs.espressif.com/projects/rust/esp-hal/1.0.0/esp32/esp_hal/dma/struct.DmaLoopBuf.html

Use `last` to get an immutable reference to the last element. Returns `None` if the slice is empty.

```rust
let v = [10, 40, 30];
assert_eq!(Some(&30), v.last());

let w: &[i32] = &[];
assert_eq!(None, w.last());
```

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

### TryFrom<AnyPin<'lt>> for GPIO5<'lt>

Source: https://docs.espressif.com/projects/rust/esp-hal/1.0.0/esp32/esp_hal/gpio/struct.AnyPin.html

Demonstrates the conversion of an AnyPin to a GPIO5 pin. This conversion can fail if the AnyPin is not compatible with GPIO5.

```APIDOC
## impl<'lt> TryFrom<AnyPin<'lt>> for GPIO5<'lt>

### Description
Performs the conversion from an `AnyPin` to a `GPIO5` pin. This operation is fallible and returns a `Result`.

### Method
`try_from`

### Parameters
#### Path Parameters
None

#### Query Parameters
None

#### Request Body
None

### Request Example
```rust
let any_pin: AnyPin = ...;
let gpio5_pin: Result<GPIO5, AnyPin> = GPIO5::try_from(any_pin);
```

### Response
#### Success Response (Ok)
- **GPIO5<'lt>** - The successfully converted GPIO5 pin.

#### Error Response (Err)
- **AnyPin<'lt>** - The original `AnyPin` if the conversion fails.

#### Response Example
```json
{
  "Ok": "GPIO5 Pin Object"
}
```

```json
{
  "Err": "AnyPin Object"
}
```
```

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

### Get Old Timestamp from MCPWM Pin

Source: https://docs.espressif.com/projects/rust/esp-hal/1.0.0/esp32/esp_hal/mcpwm/operator/struct.PwmPin.html

Get the old timestamp from a PwmPin. The value of the timestamp will take effect according to the set `PwmUpdateMethod`.

```rust
pub fn timestamp(&self) -> u16
```

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

### Output::new

Source: https://docs.espressif.com/projects/rust/esp-hal/1.0.0/esp32/esp_hal/gpio/struct.Output.html

Creates a new GPIO output driver, configuring the pin with initial level and output settings.

```APIDOC
## `Output::new`

### Description
Creates a new GPIO output driver.

The `initial_level` parameter sets the initial output level of the pin. The `config` parameter sets the drive mode, drive strength, and pull direction of the pin.

### Method
`pub fn new( pin: impl OutputPin + 'd, initial_level: Level, config: OutputConfig, ) -> Self`

### Parameters
- **pin** (impl OutputPin + 'd) - The GPIO pin to configure as output.
- **initial_level** (Level) - The initial state of the output pin (High or Low).
- **config** (OutputConfig) - Configuration for the output pin (drive mode, strength, pull direction).

### Example
```rust
use esp_hal::{
    delay::Delay,
    gpio::{Level, Output, OutputConfig},
};

fn blink_once(led: &mut Output<'_>, delay: &mut Delay) {
    led.set_low();
    delay.delay_millis(500);
    led.set_high();
}

let config = OutputConfig::default();
let mut led = Output::new(peripherals.GPIO5, Level::High, config);
let mut delay = Delay::new();

blink_once(&mut led, &mut delay);
```
```

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

### Use chip macro to get chip name

Source: https://docs.espressif.com/projects/rust/esp-hal/1.0.0/esp32/esp_hal/macro.chip.html

Use the `chip!` macro to get the current chip name. Ensure the `esp_hal` crate is imported.

```rust
use esp_hal::chip;
let chip_name = chip!();
assert_eq!(chip_name, esp32)
```

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

### Get Mutable Reference to Last Element of a Slice

Source: https://docs.espressif.com/projects/rust/esp-hal/1.0.0/esp32/esp_hal/dma/struct.DmaLoopBuf.html

Use `last_mut` to get a mutable reference to the last element. Returns `None` if the slice is empty.

```rust
let x = &mut [0, 1, 2];

if let Some(last) = x.last_mut() {
    *last = 10;
}
assert_eq!(x, &[0, 1, 10]);

let y: &mut [i32] = &mut [];
assert_eq!(None, y.last_mut());
```

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

### GPIO Input Configuration and Usage

Source: https://docs.espressif.com/projects/rust/esp-hal/1.0.0/esp32/esp_hal/gpio/struct.Input.html

This section covers the creation and basic usage of the GPIO Input driver, including setting up input pins and reading their current state.

```APIDOC
## POST /api/users

### Description
Creates a new user in the system.

### Method
POST

### Endpoint
/api/users

### Parameters
#### Request Body
- **username** (string) - Required - The desired username for the new user.
- **email** (string) - Required - The email address for the new user.
- **password** (string) - Required - The password for the new user.

### Request Example
```json
{
  "username": "johndoe",
  "email": "john.doe@example.com",
  "password": "securepassword123"
}
```

### Response
#### Success Response (201)
- **id** (string) - The unique identifier for the newly created user.
- **username** (string) - The username of the created user.
- **email** (string) - The email address of the created user.

#### Response Example
```json
{
  "id": "user-12345",
  "username": "johndoe",
  "email": "john.doe@example.com"
}
```
```

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

### From and TryFrom Implementations for AnySpi

Source: https://docs.espressif.com/projects/rust/esp-hal/1.0.0/esp32/esp_hal/spi/master/struct.AnySpi.html

Details on how to convert SPI peripherals into `AnySpi` using `From` and how to convert `AnySpi` back to specific SPI types using `TryFrom`.

```APIDOC
### `impl<'d> From<SPI2<'d>> for AnySpi<'d>`

#### `fn from(inner: SPI2<'d>) -> Self`
Converts to this type from the input type.

### `impl<'d> From<SPI3<'d>> for AnySpi<'d>`

#### `fn from(inner: SPI3<'d>) -> Self`
Converts to this type from the input type.

### `impl<'d> TryFrom<AnySpi<'d>> for SPI2<'d>`

#### `type Error = AnySpi<'d>`
The type returned in the event of a conversion error.

#### `fn try_from(any: AnySpi<'d>) -> Result<Self, AnySpi<'d>>`
Performs the conversion.

### `impl<'d> TryFrom<AnySpi<'d>> for SPI3<'d>`

#### `type Error = AnySpi<'d>`
The type returned in the event of a conversion error.

#### `fn try_from(any: AnySpi<'d>) -> Result<Self, AnySpi<'d>>`
Performs the conversion.
```

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

### ShaBackend Methods

Source: https://docs.espressif.com/projects/rust/esp-hal/1.0.0/esp32/esp_hal/sha/struct.ShaBackend.html

Details the available methods for the ShaBackend struct, including creation and starting the SHA driver.

```APIDOC
## impl<'d> ShaBackend<'d>

### pub fn new(sha: SHA<'d>) -> Self

Creates a new SHA backend.

The backend needs to be `start`ed before it can execute SHA operations.

### pub fn start(&mut self) -> ShaWorkQueueDriver<'_, 'd>

Registers the CPU-driven SHA driver to process SHA operations.

The driver stops operating when the returned object is dropped.
```

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

### Start SHA Digest Calculation

Source: https://docs.espressif.com/projects/rust/esp-hal/1.0.0/esp32/esp_hal/sha/struct.Sha.html

Starts a new SHA digest calculation. This method takes a mutable reference to the SHA driver and requires a specified ShaAlgorithm.

```rust
pub fn start<'a, A: ShaAlgorithm>( &'a mut self, ) -> ShaDigest<'d, A, &'a mut Self>
```

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

### AesBackend::new

Source: https://docs.espressif.com/projects/rust/esp-hal/1.0.0/esp32/esp_hal/aes/struct.AesBackend.html

Creates a new AES backend instance. The backend must be started before it can execute operations.

```APIDOC
## fn new<'d>(aes: AES<'d>) -> AesBackend<'d>

### Description
Creates a new AES backend.

The backend needs to be `start`ed before it can execute AES operations.

### Parameters
#### Path Parameters
- **aes** (AES<'d>) - Required - The AES peripheral instance.

### Request Example
```rust
use esp_hal::aes::AesBackend;
let mut aes = AesBackend::new(peripherals.AES);
```
```

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

### Get Last Element of Immutable Slice

Source: https://docs.espressif.com/projects/rust/esp-hal/1.0.0/esp32/esp_hal/dma/struct.DmaLoopBuf.html

Use `split_off_last` to remove and get a reference to the last element of an immutable slice. Returns `None` if the slice is empty.

```rust
let mut slice: &[_] = &['a', 'b', 'c'];
let last = slice.split_off_last().unwrap();

assert_eq!(slice, &['a', 'b']);
assert_eq!(last, &'c');
```

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

### TryFrom<AnyPin<'lt>> for GPIO4<'lt>

Source: https://docs.espressif.com/projects/rust/esp-hal/1.0.0/esp32/esp_hal/gpio/struct.AnyPin.html

Demonstrates the conversion of an AnyPin to a GPIO4 pin. This conversion can fail if the AnyPin is not compatible with GPIO4.

```APIDOC
## impl<'lt> TryFrom<AnyPin<'lt>> for GPIO4<'lt>

### Description
Performs the conversion from an `AnyPin` to a `GPIO4` pin. This operation is fallible and returns a `Result`.

### Method
`try_from`

### Parameters
#### Path Parameters
None

#### Query Parameters
None

#### Request Body
None

### Request Example
```rust
let any_pin: AnyPin = ...;
let gpio4_pin: Result<GPIO4, AnyPin> = GPIO4::try_from(any_pin);
```

### Response
#### Success Response (Ok)
- **GPIO4<'lt>** - The successfully converted GPIO4 pin.

#### Error Response (Err)
- **AnyPin<'lt>** - The original `AnyPin` if the conversion fails.

#### Response Example
```json
{
  "Ok": "GPIO4 Pin Object"
}
```

```json
{
  "Err": "AnyPin Object"
}
```
```

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

### Get First Element of Immutable Slice

Source: https://docs.espressif.com/projects/rust/esp-hal/1.0.0/esp32/esp_hal/dma/struct.DmaLoopBuf.html

Use `split_off_first` to remove and get a reference to the first element of an immutable slice. Returns `None` if the slice is empty.

```rust
let mut slice: &[_] = &['a', 'b', 'c'];
let first = slice.split_off_first().unwrap();

assert_eq!(slice, &['b', 'c']);
assert_eq!(first, &'a');
```

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

### Initialize SPI Master with Configuration

Source: https://docs.espressif.com/projects/rust/esp-hal/1.0.0/esp32/esp_hal/spi/master/struct.Spi.html

Initializes an SPI master instance with a specified configuration, including frequency and mode. Ensure the necessary peripherals and pins are available.

```rust
use esp_hal::spi::{
    Mode,
    master::{Config, Spi},
};
let mut spi = Spi::new(
    peripherals.SPI2,
    Config::default()
        .with_frequency(Rate::from_khz(100))
        .with_mode(Mode::_0),
)?
.with_sck(peripherals.GPIO0)
.with_mosi(peripherals.GPIO1)
.with_miso(peripherals.GPIO2);
```

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

### UartTx Initialization and Configuration

Source: https://docs.espressif.com/projects/rust/esp-hal/1.0.0/esp32/esp_hal/uart/struct.UartTx.html

This section covers the creation and configuration of the UartTx struct, including setting up pins and applying configurations. Note that these APIs are unstable.

```APIDOC
## POST /api/users

### Description
Creates a new UART TX instance in `Blocking` mode.

### Method
POST

### Endpoint
/api/users

### Parameters
#### Path Parameters
- **param1** (type) - Required/Optional - Description

#### Query Parameters
- **param1** (type) - Required/Optional - Description

#### Request Body
- **uart** (impl Instance + 'd) - Required - The UART instance to use.
- **config** (Config) - Required - The configuration for the UART.

### Request Example
```json
{
  "uart": "peripherals.UART0",
  "config": "Config::default()"
}
```

### Response
#### Success Response (200)
- **Self** (UartTx<'d, Blocking>) - The newly created UartTx instance.
- **ConfigError** (Error) - An error if the configuration is not supported by the hardware.

#### Response Example
```json
{
  "result": "UartTx instance created successfully"
}
```

## §Stability
**This API is marked as unstable** and is only available when the `unstable` crate feature is enabled. This comes with no stability guarantees, and could be changed or removed at any time.
```

```APIDOC
## POST /api/users

### Description
Assigns the TX pin for the UART instance.

### Method
POST

### Endpoint
/api/users

### Parameters
#### Path Parameters
- **param1** (type) - Required/Optional - Description

#### Query Parameters
- **param1** (type) - Required/Optional - Description

#### Request Body
- **tx** (impl PeripheralOutput<'d>) - Required - The pin to be used as the TX pin.

### Request Example
```json
{
  "tx": "peripherals.GPIO1"
}
```

### Response
#### Success Response (200)
- **Self** (UartTx<'d, Dm>) - The UartTx instance with the TX pin assigned.

#### Response Example
```json
{
  "result": "TX pin assigned successfully"
}
```

## §Stability
**This API is marked as unstable** and is only available when the `unstable` crate feature is enabled. This comes with no stability guarantees, and could be changed or removed at any time.
```

```APIDOC
## POST /api/users

### Description
Applies a new configuration to the UART peripheral.

### Method
POST

### Endpoint
/api/users

### Parameters
#### Path Parameters
- **param1** (type) - Required/Optional - Description

#### Query Parameters
- **param1** (type) - Required/Optional - Description

#### Request Body
- **config** (&Config) - Required - The new configuration to apply.

### Request Example
```json
{
  "config": {
    "baudrate": 115200,
    "data_bits": "DataBits::Data8",
    "parity": "Parity::ParityNone",
    "stop_bits": "StopBits::Stop1"
  }
}
```

### Response
#### Success Response (200)
- **Result** (Result<(), ConfigError>) - Ok if the configuration was applied successfully, or Err if a `ConfigError` occurred.

#### Response Example
```json
{
  "result": "Configuration applied successfully"
}
```

## §Stability
**This API is marked as unstable** and is only available when the `unstable` crate feature is enabled. This comes with no stability guarantees, and could be changed or removed at any time.
```

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

### Get PSRAM Raw Parts Address and Size

Source: https://docs.espressif.com/projects/rust/esp-hal/1.0.0/esp32/esp_hal/psram/fn.psram_raw_parts.html

Use this function to get the memory address and size of available PSRAM. Requires the 'unstable' crate feature.

```rust
pub fn psram_raw_parts(_psram: &PSRAM<'_>) -> (*mut u8, usize)
```

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

### Config Struct and Initialization

Source: https://docs.espressif.com/projects/rust/esp-hal/1.0.0/esp32/esp_hal/struct.Config.html

Details on the Config struct, its purpose, and how to initialize it using default or custom settings.

```APIDOC
## Config Struct

### Description
System configuration. This `struct` is marked with `#[non_exhaustive]` and can’t be instantiated directly. This is done to prevent breaking changes when new fields are added to the `struct`. Instead, use the `Config::default()` method to create a new instance.

### Examples
#### Default initialization
```rust
let peripherals = esp_hal::init(esp_hal::Config::default());
```

#### Custom initialization
```rust
use esp_hal::{clock::CpuClock, time::Duration};
let config = esp_hal::Config::default().with_cpu_clock(CpuClock::max());
let peripherals = esp_hal::init(config);
```

## Implementations
### impl Config
#### pub fn with_cpu_clock(self, cpu_clock: CpuClock) -> Self
Assign the given value to the `cpu_clock` field.

#### pub fn cpu_clock(&self) -> CpuClock
The CPU clock configuration.

#### pub fn with_psram(self, psram: PsramConfig) -> Self
Available on **crate feature`unstable`** only.
Assign the given value to the `psram` field.

#### pub fn psram(&self) -> PsramConfig
Available on **crate feature`unstable`** only.
PSRAM configuration.

### impl Default for Config
#### fn default() -> Config
Returns the “default value” for a type.
```

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

### Ext0WakeupSource Configuration and Deep Sleep

Source: https://docs.espressif.com/projects/rust/esp-hal/1.0.0/esp32/esp_hal/rtc_cntl/sleep/struct.Ext0WakeupSource.html

Demonstrates how to configure an external wake-up source (Ext0) and initiate deep sleep using the ESP32 HAL.

```APIDOC
## POST /esp_hal/rtc_cntl/sleep/ext0

### Description
Configures and initiates deep sleep with an external wake-up source (Ext0).

### Method
POST

### Endpoint
/esp_hal/rtc_cntl/sleep/ext0

### Parameters
#### Query Parameters
- **pin** (RtcIoWakeupPinType) - Required - The GPIO pin to use for the external wake-up.
- **level** (WakeupLevel) - Required - The wake-up level (High or Low).

### Request Body
```json
{
  "timer_duration_secs": 30
}
```

### Response
#### Success Response (200)
- **status** (string) - Indicates successful initiation of deep sleep.

#### Response Example
```json
{
  "status": "Deep sleep initiated"
}
```
```

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

### Get Current Instant

Source: https://docs.espressif.com/projects/rust/esp-hal/1.0.0/esp32/esp_hal/time/struct.Instant.html

Use `Instant::now()` to get the current time. The counter does not measure time during sleep mode and has a 1-microsecond resolution, wrapping after approximately 36,558 years.

```rust
use esp_hal::time::Instant;
let now = Instant::now();
```

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

### Get Last Chunk of a Slice

Source: https://docs.espressif.com/projects/rust/esp-hal/1.0.0/esp32/esp_hal/dma/struct.DmaLoopBuf.html

Use `last_chunk` with a const generic `N` to get an array reference to the last `N` items. Returns `None` if the slice is shorter than `N`.

```rust
let x = &[0, 1, 2];

if let Some(last) = x.last_chunk::<2>() {
    assert_eq!(last, &[1, 2]);
}

assert_eq!(None, x.last_chunk::<4>());
```

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

### ADC Configuration and Reading

Source: https://docs.espressif.com/projects/rust/esp-hal/1.0.0/esp32/esp_hal/analog/adc/struct.Adc.html

This section covers the initialization of the ADC peripheral and how to perform one-shot readings from a specified pin.

```APIDOC
## POST /api/adc/new

### Description
Configures a given ADC instance using the provided configuration and initializes the ADC for use.

### Method
POST

### Endpoint
/api/adc/new

### Parameters
#### Request Body
- **adc_instance** (object) - Required - The ADC instance to configure.
- **config** (object) - Required - The ADC configuration.

### Request Example
```json
{
  "adc_instance": "ADC1",
  "config": {
    "channel": "GPIO34",
    "attenuation": "11dB",
    "width": 12
  }
}
```

### Response
#### Success Response (200)
- **Adc** (object) - The initialized ADC instance.

#### Response Example
```json
{
  "adc": "initialized_adc_instance"
}
```

## POST /api/adc/read_oneshot

### Description
Requests the ADC to begin a conversion on the specified pin and returns the resulting value.

### Method
POST

### Endpoint
/api/adc/read_oneshot

### Parameters
#### Request Body
- **adc_instance** (object) - Required - The ADC instance to use for reading.
- **pin** (object) - Required - The AdcPin reference to sample from.

### Request Example
```json
{
  "adc_instance": "initialized_adc_instance",
  "pin": {
    "channel": "GPIO34"
  }
}
```

### Response
#### Success Response (200)
- **value** (u16) - The result of the ADC conversion.

#### Response Example
```json
{
  "value": 2048
}
```

### Errors
- **()** - An error occurred during the ADC conversion.
```

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

### Get First Chunk of a Slice

Source: https://docs.espressif.com/projects/rust/esp-hal/1.0.0/esp32/esp_hal/dma/struct.DmaLoopBuf.html

Use `first_chunk` with a const generic `N` to get an array reference to the first `N` items. Returns `None` if the slice is shorter than `N`.

```rust
let u = [10, 40, 30];
assert_eq!(Some(&[10, 40]), u.first_chunk::<2>());

let v: &[i32] = &[10];
assert_eq!(None, v.first_chunk::<2>());

let w: &[i32] = &[];
assert_eq!(Some(&[]), w.first_chunk::<0>());
```

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

### Declare Program Entry Point with #[main]

Source: https://docs.espressif.com/projects/rust/esp-hal/1.0.0/esp32/esp_hal/attr.main.html

Use the #[main] attribute to mark the entry point function. This function must have the signature `[unsafe] fn() -> !` and will be called after RAM initialization. The FPU is enabled if present.

```rust
#[main]
fn main() -> !
{
    loop { /* .. */ }
}
```

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

### Get Time in Milliseconds from RTC Timer

Source: https://docs.espressif.com/projects/rust/esp-hal/1.0.0/esp32/esp_hal/rtc_cntl/index.html

Demonstrates how to get the current RTC time in milliseconds and manipulate it. Requires initialization of Rtc and Delay. Note the multiplication factor for time conversion.

```rust
let rtc = Rtc::new(peripherals.LPWR);
let delay = Delay::new();

loop {
    // Print the current RTC time in milliseconds
    let time_ms = rtc.current_time_us() / 1000;
    delay.delay_millis(1000);

    // Set the time to half a second in the past
    let new_time = rtc.current_time_us() - 500_000;
    rtc.set_current_time_us(new_time);
}
```

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

### Config Constructors and Channel/Width/Polarity Settings

Source: https://docs.espressif.com/projects/rust/esp-hal/1.0.0/esp32/esp_hal/i2s/master/struct.Config.html

Methods for creating new configurations and setting channel, word select width, and word select polarity.

```APIDOC
### Constructors

#### `new_tdm_philips() -> Self`
TDM Philips standard configuration with two 16-bit active channels

#### `new_tdm_msb() -> Self`
TDM MSB standard configuration with two 16-bit active channels

#### `new_tdm_pcm_short() -> Self`
TDM PCM short frame standard configuration with two 16-bit active channels

### Channel and Width Settings

#### `with_channels(self, channels: Channels) -> Self`
Assign the given value to the `channels` field in both units.

#### `with_ws_width(self, ws_width: WsWidth) -> Self`
Assign the given value to the `ws_width` field in both units.

#### `with_ws_polarity(self, ws_polarity: Polarity) -> Self`
Assign the given value to the `ws_polarity` field in both units.

#### `with_msb_shift(self, msb_shift: bool) -> Self`
Assign the given value to the `msb_shift` field in both units.
```
Tokens:
Raw