esp-hal

https://docs.espressif.com/projects/rust/esp-hal/1.1.1/esp32c3/
Admin
esp-hal is a bare-metal Hardware Abstraction Layer for Espressif ESP32 microcontrollers, providing...
Tokens:2,838,213
Snippets:28,256
Trust Score:10
Update:1 month ago
Show doc for...
Tokens:
Raw
### ShaBackend Example Usage

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

Example demonstrating how to initialize, start, and use the ShaBackend with Sha1Context for hashing data.

```APIDOC
## Example Usage

### Description
This example shows how to initialize a `ShaBackend`, start it to enable SHA operations, and then use it with a `Sha1Context` to compute a SHA-1 hash of input data.

### Code
```rust
use esp_hal::sha::{Sha1Context, ShaBackend};

// Assuming `peripherals.SHA` is available and represents the SHA peripheral
// let mut sha = ShaBackend::new(peripherals.SHA);

// Start the backend, which allows processing SHA operations.
// let _backend = sha.start();

// Create a new context to hash data with SHA-1.
// let mut sha1_ctx = Sha1Context::new();

// SHA-1 outputs a 20-byte digest.
// let mut digest: [u8; 20] = [0; 20];

// Process data. The `update` function returns a handle which can be used to wait
// for the operation to finish.
// sha1_ctx.update(b"input data").wait_blocking();
// sha1_ctx.update(b"input data").wait_blocking();
// sha1_ctx.update(b"input data").wait_blocking();

// Extract the final hash. This resets the context.
// sha1_ctx.finalize(&mut digest).wait_blocking();

// `digest` now contains the SHA-1 hash of the input.
```
```

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

### RSA Backend Example

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

Demonstrates creating and starting an RSA backend for processing operations. The backend manages work items placed in a queue.

```rust
# use esp_hal::rsa::{RsaBackend, RsaContext, operand_sizes::Op512};
# 
let mut rsa_backend = RsaBackend::new(peripherals.RSA);
let _driver = rsa_backend.start();

async fn perform_512bit_big_number_multiplication(
    operand_a: &[u32; 16],
    operand_b: &[u32; 16],
    result: &mut [u32; 32],
) {
    let mut rsa = RsaContext::new();

    let mut handle = rsa.multiply::<Op512>(operand_a, operand_b, result);
    handle.wait().await;
}
```

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

### Initialize and Start AesBackend

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

Creates a new AES backend instance. The backend must be started using `start()` before it can process operations.

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

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

### Async UART Read and Write Example

Source: https://docs.espressif.com/projects/rust/esp-hal/1.1.1/esp32c3/src/esp_hal/uart/mod.rs.html

Demonstrates asynchronous reading and writing to a UART peripheral. Ensure the UART is configured with appropriate pins and settings before use. This example assumes prior setup of the UART instance.

```rust
    ///     .with_tx(peripherals.GPIO2)
    ///     .into_async();
    ///
    /// const MESSAGE: &[u8] = b"Hello, world!";
    /// uart.write_async(&MESSAGE).await?;
    /// uart.flush_async().await?;
    ///
    /// let mut buf = [0u8; MESSAGE.len()];
    /// uart.read_async(&mut buf[..]).await.unwrap();
    /// # {
    /// # after_snippet
    /// # }
    /// ```
```

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

### Default System Initialization

Source: https://docs.espressif.com/projects/rust/esp-hal/1.1.1/esp32c3/src/esp_hal/lib.rs.html?search=std%3A%3Avec

Initializes the ESP-HAL system with default configuration. This is the simplest way to get started.

```rust
# {before_snippet}
let peripherals = esp_hal::init(esp_hal::Config::default());
# {after_snippet}
```

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

### Initialize and Start AesDmaBackend

Source: https://docs.espressif.com/projects/rust/esp-hal/1.1.1/esp32c3/esp_hal/aes/dma/struct.AesDmaBackend.html?search=Option%3CT%3E%2C+%28T+-%3E+U%29+-%3E+Option%3CU%3E

Demonstrates how to create and start the AesDmaBackend for DMA-accelerated AES operations. The backend must be started before processing any AES tasks.

```rust
use esp_hal::aes::dma::AesDmaBackend;

let mut aes = AesDmaBackend::new(peripherals.AES, peripherals.DMA_CH0);
let _handle = aes.start();
```

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

### Minimal Blinky example

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

A basic example showing how to blink an LED using GPIO0 on an ESP32 device.

```rust
#![no_std]
#![no_main]

use esp_hal::{
    clock::CpuClock,
    gpio::{Io, Level, Output, OutputConfig},
    main,
    time::{Duration, Instant},
};

// You need a panic handler. Usually, you would use esp_backtrace, panic-probe, or
// something similar, but you can also bring your own like this:
#[panic_handler]
fn panic(_: &core::panic::PanicInfo) -> ! {
    esp_hal::system::software_reset()
}

#[main]
fn main() -> ! {
    let config = esp_hal::Config::default().with_cpu_clock(CpuClock::max());
    let peripherals = esp_hal::init(config);

    // Set GPIO0 as an output, and set its state high initially.
    let mut led = Output::new(peripherals.GPIO0, Level::High, OutputConfig::default());

    loop {
        led.toggle();
        // Wait for half a second
        let delay_start = Instant::now();
        while delay_start.elapsed() < Duration::from_millis(500) {}
    }
}
```

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

### first example

Source: https://docs.espressif.com/projects/rust/esp-hal/1.1.1/esp32c3/esp_hal/dma/struct.DmaLoopBuf.html?search=

Example usage of the first method on a slice.

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

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

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

### RSA Interrupt Example

Source: https://docs.espressif.com/projects/rust/esp-hal/1.1.1/esp32c3/esp_hal/peripherals/struct.RSA.html?search=std%3A%3Avec

Example demonstrating how to set up and manage RSA peripheral interrupts, including enabling and disabling them.

```rust
use esp_hal::interrupt::Priority;

#[unsafe(no_mangle)]
unsafe extern "C" fn RSA() {
    // do something
}

peripherals.RSA.enable_peri_interrupt(Priority::Priority1);
peripherals.RSA.disable_peri_interrupt_on_all_cores();
```

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

### trim_ascii_start example

Source: https://docs.espressif.com/projects/rust/esp-hal/1.1.1/esp32c3/esp_hal/dma/struct.DmaLoopBuf.html?search=

Example usage of the trim_ascii_start method on a byte slice.

```rust
assert_eq!(b" \t hello world\n".trim_ascii_start(), b"hello world\n");
assert_eq!(b"  ".trim_ascii_start(), b"");
assert_eq!(b"".trim_ascii_start(), b"");
```

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

### RSA Interrupt Example

Source: https://docs.espressif.com/projects/rust/esp-hal/1.1.1/esp32c3/esp_hal/peripherals/struct.RSA.html

Example demonstrating how to set up an interrupt handler and enable/disable the RSA peripheral interrupt. Requires the `unstable` feature.

```rust
use esp_hal::interrupt::Priority;

#[unsafe(no_mangle)]
unsafe extern "C" fn RSA() {
    // do something
}

peripherals.RSA.enable_peri_interrupt(Priority::Priority1);
peripherals.RSA.disable_peri_interrupt_on_all_cores();
```

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

### Initialize the system with default configuration

Source: https://docs.espressif.com/projects/rust/esp-hal/1.1.1/esp32c3/esp_hal/fn.init.html?search=

This example demonstrates how to initialize the system using the default configuration and retrieve the peripherals.

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

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

### Get Current Time in Microseconds

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

Fetches the current time in microseconds. This example demonstrates how to use the `jiff` crate to get the weekday in a specific timezone.

```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();
```

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

### init

Source: https://docs.espressif.com/projects/rust/esp-hal/1.1.1/esp32c3/src/esp_hal/lib.rs.html?search=u32+-%3E+bool

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

```APIDOC
## fn init(config: Config) -> Peripherals

### Description
Initializes the system by setting up the CPU clock, watchdog timers, and peripheral access. This function must be called to prepare the hardware for use.

### Parameters
- **config** (Config) - Required - The configuration object used to initialize the system, including clock settings.
```

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

### EfuseBlock Address Access

Source: https://docs.espressif.com/projects/rust/esp-hal/1.1.1/esp32c3/src/esp_hal/efuse/esp32c2/mod.rs.html

Provides a method to get the memory address of the start of an efuse block.

```APIDOC
## EfuseBlock::address

### Description
Returns the memory address of the start of the specified efuse block.

### Signature
```rust
pub(crate) fn address(self) -> *const u32
```

### Parameters
* `self`: An instance of `EfuseBlock` representing the efuse block to access.

### Returns
A raw pointer (`*const u32`) to the beginning of the efuse block's data in memory.

### Usage Example
```rust
let block0_address = EfuseBlock::Block0.address();
let block1_address = EfuseBlock::Block1.address();
```
```

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

### init()

Source: https://docs.espressif.com/projects/rust/esp-hal/1.1.1/esp32c3/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() -> ...`
```

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

### esp_hal::init

Source: https://docs.espressif.com/projects/rust/esp-hal/1.1.1/esp32c3/src/esp_hal/lib.rs.html?search=u32+-%3E+bool

Initializes the system with the provided configuration.

```APIDOC
## esp_hal::init(config: Config)

### Description
Initializes the system peripherals using the provided configuration object.

### Parameters
- **config** (Config) - The configuration object created via Config::default().

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

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

### Get time in ms from RTC Timer (Duplicate)

Source: https://docs.espressif.com/projects/rust/esp-hal/1.1.1/esp32c3/esp_hal/rtc_cntl/index.html?search=

Demonstrates how to get the current RTC time in milliseconds and set the time to a past value. Requires `Rtc` and `Delay` initialization. This is a duplicate of a previous example.

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

loop {
    // Get 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);
}
```

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

### init(config: Config) -> Peripherals

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

Initializes the system, including CPU clock and watchdog timers, and returns the system peripherals.

```APIDOC
## fn init

### Description
Initializes the system. This function sets up the CPU clock and watchdog, then returns the peripherals and clocks.

### Signature
`pub fn init(config: Config) -> Peripherals`

### Parameters
- **config** (Config) - The system configuration to apply during initialization.

### Returns
- **Peripherals** - The initialized system peripherals.
```

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

### Minimal LED Blink Example in Rust

Source: https://docs.espressif.com/projects/rust/esp-hal/1.1.1/esp32c3/src/esp_hal/lib.rs.html

This is a basic example demonstrating how to blink an LED using the ESP-HAL library. It includes necessary setup for a no_std environment and a panic handler. Ensure you have a suitable panic handler for your project.

```rust
#![no_std]
#![no_main]

use esp_hal::
    clock::CpuClock,
    gpio::{Io, Level, Output, OutputConfig},
    main,
    time::{Duration, Instant},
};

// You need a panic handler. Usually, you would use esp_backtrace, panic-probe, or
// something similar, but you can also bring your own like this:
#[panic_handler]
fn panic(_: &core::panic::PanicInfo) -> !
{
    esp_hal::system::software_reset()
}

#[main]
fn main() -> !
{
    let config = esp_hal::Config::default().with_cpu_clock(CpuClock::max());
    let peripherals = esp_hal::init(config);

    // Set GPIO0 as an output, and set its state high initially.
    let mut led = Output::new(peripherals.GPIO0, Level::High, OutputConfig::default());

    loop {
        led.toggle();
        // Wait for half a second
        let delay_start = Instant::now();
        while delay_start.elapsed() < Duration::from_millis(500) {}
    }
}
```

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

### Using DedicatedGpioFlexBundle for batch operations

Source: https://docs.espressif.com/projects/rust/esp-hal/1.1.1/esp32c3/esp_hal/gpio/dedicated/struct.DedicatedGpioFlexBundle.html?search=Option%3CT%3E%2C+%28T+-%3E+U%29+-%3E+Option%3CU%3E

Example showing how to create dedicated channels, initialize flex drivers, bundle them, and perform batch write and read operations.

```rust
use esp_hal::gpio::{
    Flex,
    Level,
    dedicated::{DedicatedGpio, DedicatedGpioFlex, DedicatedGpioFlexBundle},
};

// Create channels:
let channels = DedicatedGpio::new(peripherals.GPIO_DEDICATED);

// Create flex drivers for two channels:
let p0 = Flex::new(peripherals.GPIO0);
let p1 = Flex::new(peripherals.GPIO1);
let f0 = DedicatedGpioFlex::new(channels.channel0, p0);
let f1 = DedicatedGpioFlex::new(channels.channel1, p1);

// Build a bundle that controls channels 0 and 1:
let mut bundle = DedicatedGpioFlexBundle::new();
bundle.enable_flex(&f0).enable_flex(&f1);

// Set channel 0 high:
bundle.set_high(0b0000_0001);

// Drive both channels at once:
bundle.write_bits(0b0000_0010); // ch0 low, ch1 high

// Read both channels at once:
let in_bits = bundle.levels();
```

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

### Getting pre_idle_count from AtCmdConfig

Source: https://docs.espressif.com/projects/rust/esp-hal/1.1.1/esp32c3/esp_hal/uart/struct.AtCmdConfig.html

Retrieves the configured `pre_idle_count`, which is an optional idle time in clock cycles before AT command detection starts.

```rust
pub fn pre_idle_count(&self) -> Option<u16>
```

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

### Simple entry point example

Source: https://docs.espressif.com/projects/rust/esp-hal/1.1.1/esp32c3/esp_hal/attr.main.html?search=

A basic implementation of a main function using the #[main] attribute.

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

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

### ChipRevision Usage Example

Source: https://docs.espressif.com/projects/rust/esp-hal/1.1.1/esp32c3/esp_hal/efuse/struct.ChipRevision.html?search=std%3A%3Avec

Demonstrates how to get the current chip revision, compare it with other revisions, and convert it to different numeric representations.

```rust
use esp_hal::efuse::ChipRevision;

let rev = esp_hal::efuse::chip_revision();
println!("Chip revision: {}.{}", rev.major, rev.minor);

// You can compare against other ChipRevision objects
if rev < ChipRevision::from_combined(300) {
    // You can print a debug representation
    println!("Chip revision is too old: {:?}", rev);
}
if rev >= ChipRevision::from_packed(0x400) {
    println!("Chip revision is too new: {:?}", rev);
}

// You can convert into two different numeric representations.
assert!(rev.packed() >= 0x300);
assert!(rev.combined() >= 300);
```

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

### fn init

Source: https://docs.espressif.com/projects/rust/esp-hal/1.1.1/esp32c3/esp_hal/fn.init.html?search=std%3A%3Avec

Initializes the system by setting up the CPU clock and watchdog, returning the peripherals and clocks. This function is available only when the 'rt' crate feature is enabled.

```APIDOC
## Function: init

### Description
Initializes the system. This function sets up the CPU clock and watchdog, then returns the peripherals and clocks.

### Signature
`pub fn init(config: Config) -> Peripherals`

### Requirements
- **Crate Feature**: `rt`

### Parameters
- **config** (Config) - The configuration object used to initialize the system.

### Returns
- **Peripherals** - The initialized peripherals and clocks.

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

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

### Get eFuse Block Address

Source: https://docs.espressif.com/projects/rust/esp-hal/1.1.1/esp32c3/src/esp_hal/efuse/esp32c2/mod.rs.html

Returns the memory address of the start of a specific eFuse block. Used for direct register access.

```rust
impl EfuseBlock {
    pub(crate) fn address(self) -> *const u32 {
        let efuse = EFUSE::regs();
        match self {
            Self::Block0 => efuse.rd_wr_dis().as_ptr(),
            Self::Block1 => efuse.rd_blk1_data0().as_ptr(),
            Self::Block2 => efuse.rd_blk2_data0().as_ptr(),
            Self::Block3 => efuse.rd_blk3_data0().as_ptr(),
        }
    }
}
```

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

### pub fn init(config: Config) -> Peripherals

Source: https://docs.espressif.com/projects/rust/esp-hal/1.1.1/esp32c3/esp_hal/fn.init.html?search=

Initializes the system, setting up the CPU clock and watchdog. This function is available only when the 'rt' crate feature is enabled.

```APIDOC
## Function: init

### Description
Initializes the system, including the CPU clock and watchdog. Returns the peripherals and clocks for the application.

### Signature
`pub fn init(config: Config) -> Peripherals`

### Requirements
- Requires crate feature: `rt`

### Parameters
- **config** (Config) - The configuration object used to initialize the system.

### Returns
- **Peripherals** - The initialized peripherals and clocks.

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

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

### init

Source: https://docs.espressif.com/projects/rust/esp-hal/1.1.1/esp32c3/esp_hal/index.html?search=u32+-%3E+bool

Initializes the system.

```APIDOC
## fn init

### Description
Initializes the system. This function is typically called at the start of the program to set up the hardware environment.

### Signature
`pub fn init() -> Peripherals`
```

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

### Perform 512-bit RSA multiplication

Source: https://docs.espressif.com/projects/rust/esp-hal/1.1.1/esp32c3/esp_hal/rsa/struct.RsaBackend.html?search=std%3A%3Avec

This example demonstrates how to initialize the RsaBackend, start the driver, and use RsaContext to perform an asynchronous 512-bit multiplication.

```rust
use esp_hal::rsa::{RsaBackend, RsaContext, operand_sizes::Op512};
let mut rsa_backend = RsaBackend::new(peripherals.RSA);
let _driver = rsa_backend.start();

async fn perform_512bit_big_number_multiplication(
    operand_a: &[u32; 16],
    operand_b: &[u32; 16],
    result: &mut [u32; 32],
) {
    let mut rsa = RsaContext::new();

    let mut handle = rsa.multiply::<Op512>(operand_a, operand_b, result);
    handle.wait().await;
}
```

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

### Config Initialization and Usage

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

Demonstrates how to initialize the Config struct using default values and how to customize it with specific settings like CPU clock frequency.

```APIDOC
## Struct Config

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
```
let peripherals = esp_hal::init(esp_hal::Config::default());
```

#### §Custom initialization
```
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: impl Into<ClockConfig>) -> Self

Apply a clock configuration.

With the `unstable` feature enabled, this function accepts both `ClockConfig` and `CpuClock`.

#### pub fn cpu_clock(&self) -> CpuClock

Deprecated: Use `clock_config` instead.

The CPU clock configuration preset.

##### §Panics

This function will panic if the CPU clock configuration is not **exactly** one of the `CpuClock` presets.

#### pub fn clock_config(&self) -> ClockConfig

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

The CPU clock configuration.

##### §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.

### impl Default for Config

#### fn default() -> Config

Returns the “default value” for a type.
```

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

### Get Wakeup Cause

Source: https://docs.espressif.com/projects/rust/esp-hal/1.1.1/esp32c3/esp_hal/rtc_cntl/fn.wakeup_cause.html

Call this function to retrieve the `SleepSource` enum variant that indicates the reason for waking up from deep sleep. No setup is required.

```rust
pub fn wakeup_cause() -> SleepSource
```

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

### Configure and Use General-purpose Timer

Source: https://docs.espressif.com/projects/rust/esp-hal/1.1.1/esp32c3/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 wait for an 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();

```

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

### Initialize System with Default Configuration

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

Use this snippet to initialize the ESP system with default configuration. It sets up the CPU clock and watchdog, returning the peripherals and clocks.

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

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

### Rust Slice `windows` Iterator Example

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

Demonstrates how to use the `windows` iterator to get overlapping sub-slices of a given size. Panics if the slice is shorter than the window size.

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

```rust
let slice = ['f', 'o', 'o'];
let mut iter = slice.windows(4);
assert!(iter.next().is_none());
```

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

### Aes::new

Source: https://docs.espressif.com/projects/rust/esp-hal/1.1.1/esp32c3/esp_hal/aes/index.html?search=std%3A%3Avec

Initializes the AES peripheral.

```APIDOC
## Aes::new(peripherals.AES)

### Description
Creates a new instance of the AES peripheral container.

### Signature
`pub fn new(aes: AES) -> Self`
```

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

### RsaContext::modular_exponentiate

Source: https://docs.espressif.com/projects/rust/esp-hal/1.1.1/esp32c3/src/esp_hal/rsa/mod.rs.html?search=

Starts a modular exponentiation operation, performing `Z = X ^ Y mod M`. Requires pre-calculated values for `r` and `m_prime` and provides an example using the `crypto-bigint` crate.

```APIDOC
## RsaContext::modular_exponentiate

### Description
Starts a modular exponentiation operation, computing `Z = X ^ Y mod M`. This function leverages hardware acceleration if available. Software must pre-calculate `r` (which is `2 ^ (bitlength * 2) mod M`) and `m_prime` (which is `-(modular multiplicative inverse of M) mod 2^32`). The `crypto-bigint` crate can be used to compute these values.

### Method
`modular_exponentiate(&mut self, x: &Op512, y: &Op512, m: &Op512, r: &Op512, m_prime: u32, z: &mut [u8]) -> RsaHandle<'_>`

### Parameters
- **x** (`&Op512`): The base of the exponentiation.
- **y** (`&Op512`): The exponent.
- **m** (`&Op512`): The modulus.
- **r** (`&Op512`): Pre-calculated value `2 ^ (bitlength * 2) mod M`.
- **m_prime** (`u32`): Pre-calculated value `-(modular multiplicative inverse of M) mod 2^32`.
- **z** (`&mut [u8]`): A mutable buffer to store the result `Z`.

### Returns
An `RsaHandle` that can be used to poll the operation's completion.

### Example
```rust,no_run
# use crypto_bigint::{U512, Uint};
# const fn compute_r(modulus: &U512) -> U512 {
#     let mut d = [0_u32; U512::LIMBS * 2 + 1];
#     d[d.len() - 1] = 1;
#     let d = Uint::from_words(d);
#     d.const_rem(&modulus.resize()).0.resize()
# }
# const fn compute_mprime(modulus: &U512) -> u32 {
#     let m_inv = modulus.inv_mod2k(32).to_words()[0];
#     (-1 * m_inv as i64 & (u32::MAX as i64)) as u32
# }
# // Inputs
# const X: U512 = Uint::from_be_hex(
#     "c7f61058f96db3bd87dbab08ab03b4f7f2f864eac249144adea6a65f97803b719d8ca980b7b3c0389c1c7c6\
#    7dc353c5e0ec11f5fc8ce7f6073796cc8f73fa878",
# );
# const Y: U512 = Uint::from_be_hex(
#     "1763db3344e97be15d04de4868badb12a38046bb793f7630d87cf100aa1c759afac15a01f3c4c83ec2d2f66\
#    6bd22f71c3c1f075ec0e2cb0cb29994d091b73f51",
# );
# const M: U512 = Uint::from_be_hex(
#     "6b6bb3d2b6cbeb45a769eaa0384e611e1b89b0c9b45a045aca1c5fd6e8785b38df7118cf5dd45b9b63d293b\
#    67aeafa9ba25feb8712f188cb139b7d9b9af1c361",
# );
# let r = compute_r(&M);
# let mprime = compute_mprime(&M);
use esp_hal::rsa::{RsaContext, operand_sizes::Op512};

let mut rsa = RsaContext::new();
let mut outbuf = [0; 16]; // Example buffer size, adjust as needed

rsa.modular_exponentiate(&X, &Y, &M, &r, mprime, &mut outbuf);
// The result will be in outbuf after the operation completes.
```
```

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

### Example Usage of RSA Multiply Operation

Source: https://docs.espressif.com/projects/rust/esp-hal/1.1.1/esp32c3/src/esp_hal/rsa/mod.rs.html?search=u32+-%3E+bool

Demonstrates how to perform a standard multiplication using RsaContext. It shows the setup of input and output buffers, initiating the operation, and waiting for completion.

```rust
/// let mut handle = rsa.multiply::<Op512>(&x, &y, &mut outbuf);
/// handle.wait_blocking();
```

```rust
# // Inputs
# let x: [u32; 16] = [0; 16];
# let y: [u32; 16] = [0; 16];
# // let x: [u32; 16] = [...];
# // let y: [u32; 16] = [...];
let mut outbuf = [0; 32];

use esp_hal::rsa::{RsaContext, operand_sizes::Op512};

// Now perform the actual computation:
let mut rsa = RsaContext::new();
let mut handle = rsa.multiply::<Op512>(&x, &y, &mut outbuf);
handle.wait_blocking();
```

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

### Input Initialization

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

Demonstrates how to create a new Input pin instance with default configuration.

```APIDOC
## Input::new

### Description
Initializes a new GPIO pin as an input with the specified configuration.

### Parameters
- `pin`: The GPIO pin to configure.
- `config`: The `InputConfig` for the pin.

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

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

### Create and Use DedicatedGpioInputBundle

Source: https://docs.espressif.com/projects/rust/esp-hal/1.1.1/esp32c3/esp_hal/gpio/dedicated/struct.DedicatedGpioInputBundle.html

Demonstrates creating dedicated input channels, bundling them, and reading their states simultaneously. Ensure the necessary GPIO peripherals and input configurations are set up.

```rust
use esp_hal::gpio::{
    Input,
    InputConfig,
    dedicated::{DedicatedGpio, DedicatedGpioInput, DedicatedGpioInputBundle},
};

// Create channels:
let channels = DedicatedGpio::new(peripherals.GPIO_DEDICATED);

// Create input drivers for two channels:
let p0 = Input::new(peripherals.GPIO0, InputConfig::default());
let p1 = Input::new(peripherals.GPIO1, InputConfig::default());
let in0 = DedicatedGpioInput::new(channels.channel0, p0);
let in1 = DedicatedGpioInput::new(channels.channel1, p1);

// Build a bundle that reads channels 0 and 1:
let mut bundle = DedicatedGpioInputBundle::new();
bundle.enable_input(&in0).enable_input(&in1);

// Read both channels at once:
let bits = bundle.levels();
// bit 0 -> channel 0, bit 1 -> channel 1, ...

```

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

### Get Element Offset

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

Determine the index of an element within a slice using pointer arithmetic. Returns `None` if the element reference does not point to the start of an element. Panics if `T` is zero-sized.

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

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

```rust
let arr: &[[u32; 2]] = &[[0, 1], [2, 3]];
let flat_arr: &[u32] = arr.as_flattened();

let ok_elm: &[u32; 2] = flat_arr[0..2].try_into().unwrap();
let weird_elm: &[u32; 2] = flat_arr[1..3].try_into().unwrap();

assert_eq!(ok_elm, &[0, 1]);
assert_eq!(weird_elm, &[1, 2]);

assert_eq!(arr.element_offset(ok_elm), Some(0)); // Points to element 0
assert_eq!(arr.element_offset(weird_elm), None); // Points between element 0 and 1
```

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

### System Initialization

Source: https://docs.espressif.com/projects/rust/esp-hal/1.1.1/esp32c3/src/esp_hal/lib.rs.html?search=

Initializes the ESP32-C3 system, setting up CPU clock, watchdog, and returning peripherals and clocks.

```APIDOC
## init

### Description
Initializes the system by setting up the CPU clock and watchdog timers. It then returns the available peripherals and clock configurations.

### Parameters
- `config` (`Config`): The configuration object for system initialization.

### Returns
- `Peripherals`: An object containing all available peripherals.

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

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

### Get Weekday in New York using Rtc::current_time_us

Source: https://docs.espressif.com/projects/rust/esp-hal/1.1.1/esp32c3/esp_hal/rtc_cntl/struct.Rtc.html?search=Option%3CT%3E%2C+%28T+-%3E+U%29+-%3E+Option%3CU%3E

Example demonstrating how to retrieve the current time from the RTC and convert it to a timezone-aware weekday using the jiff crate in a no-std environment.

```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();
```

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

### Iterating Chunks from End of Slice

Source: https://docs.espressif.com/projects/rust/esp-hal/1.1.1/esp32c3/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', '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', 'l']);
assert!(iter.next().is_none());
```

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

### Io::new

Source: https://docs.espressif.com/projects/rust/esp-hal/1.1.1/esp32c3/esp_hal/gpio/struct.Io.html?search=Option%3CT%3E%2C+%28T+-%3E+U%29+-%3E+Option%3CU%3E

Initializes the I/O driver. This API is unstable and requires the 'unstable' crate feature.

```APIDOC
## Io::new

### Description
Initializes the I/O driver.

### 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.

### Signature
```rust
pub fn new(_io_mux: IO_MUX<'d>) -> Self
```
```

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

### Iterating Exact Chunks from End of Slice

Source: https://docs.espressif.com/projects/rust/esp-hal/1.1.1/esp32c3/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 are available 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']);
```

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

### System Initialization

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

Initializes the system by setting up the CPU clock and watchdog. This function is available only when the `rt` crate feature is enabled.

```APIDOC
## init

### Description
Initializes the system. This function sets up the CPU clock and watchdog, then returns the peripherals and clocks.

### Signature
```rust
pub fn init(config: Config) -> Peripherals
```

### Availability
Available on `crate feature` `rt` only.

### Parameters
* `config` (Config) - Configuration for the initialization process.

### Returns
* `Peripherals` - The initialized peripherals and clocks.

### Example
```rust
use esp_hal::{Config, init};

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

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

### Mutably Iterating Exact Chunks from End of Slice

Source: https://docs.espressif.com/projects/rust/esp-hal/1.1.1/esp32c3/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 are available 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]);
```

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

### Io::new

Source: https://docs.espressif.com/projects/rust/esp-hal/1.1.1/esp32c3/esp_hal/gpio/struct.Io.html?search=u32+-%3E+bool

Initializes the I/O driver. This method is unstable and requires the `unstable` crate feature.

```APIDOC
### pub fn new(_io_mux: IO_MUX<'d>) -> Self

Initialize the I/O driver.

**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.
```

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

### Using the Sha Driver for SHA-256

Source: https://docs.espressif.com/projects/rust/esp-hal/1.1.1/esp32c3/esp_hal/sha/index.html?search=Option%3CT%3E%2C+%28T+-%3E+U%29+-%3E+Option%3CU%3E

Demonstrates how to use the Sha driver to compute a SHA-256 hash. It initializes the driver, starts a SHA-256 context, updates it with source data in blocks, and finishes the calculation to get the output digest.

```rust
let mut source_data = "HELLO, ESPRESSIF!".as_bytes();
let mut sha = Sha::new(peripherals.SHA);
let mut hasher = sha.start::<Sha256>();
// Short hashes can be created by decreasing the output buffer to the
// desired length
let mut output = [0u8; 32];

while !source_data.is_empty() {
    // All the HW Sha functions are infallible so unwrap is fine to use if
    // you use block!
    source_data = block!(hasher.update(source_data))?;
}

// Finish can be called as many times as desired to get multiple copies of
// the output.
block!(hasher.finish(output.as_mut_slice()))?;
```

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

### Default Config Initialization

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

Initialize the system with default configuration settings. This is the recommended way to create a Config instance.

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

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

### Mutably Iterating Chunks from End of Slice

Source: https://docs.espressif.com/projects/rust/esp-hal/1.1.1/esp32c3/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 slice elements within chunks. 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]);
```

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

### SPI DMA Write Example

Source: https://docs.espressif.com/projects/rust/esp-hal/1.1.1/esp32c3/src/esp_hal/spi/master/dma.rs.html

Writes data to the SPI bus using DMA. This method prepares the SPI driver for full-duplex communication and then initiates DMA transfers from the provided buffer. It ensures that the SPI bus is idle before starting the transfer.

```rust
self.spi_dma.driver().setup_full_duplex()?;
        let empty_rx_buffer = unsafe { self.spi_dma.dma_driver().empty_rx_buffer() };

        for chunk in words.chunks(self.tx_buf.capacity()) {
            self.tx_buf.as_mut_slice()[..chunk.len()].copy_from_slice(chunk);

            unsafe {
                self.spi_dma.start_dma_transfer(
                    0,
                    chunk.len(),
                    empty_rx_buffer,
                    &mut self.tx_buf,
                )?;
            }
```

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

### Perform Modular Multiplication with RsaContext

Source: https://docs.espressif.com/projects/rust/esp-hal/1.1.1/esp32c3/esp_hal/rsa/struct.RsaContext.html

Starts an asynchronous modular multiplication operation (Z = X * Y mod M). Requires pre-calculated values for `r` and `m_prime`. The result is stored in `result` upon completion. Refer to `modular_exponentiate` for an example of calculating these values.

```rust
use esp_hal::rsa::{RsaContext, operand_sizes::Op512};

// Assuming X, Y, M, r, mprime, and outbuf are defined as in the modular_exponentiate example
// let mut rsa = RsaContext::new();
// let mut outbuf = [0; 16];
// let mut handle = rsa.modular_multiply::<Op512>(
//     X.as_words(),
//     Y.as_words(),
//     M.as_words(),
//     r.as_words(),
//     mprime,
//     &mut outbuf,
// );
// handle.wait_blocking();
```

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

### RSA Backend Example Usage

Source: https://docs.espressif.com/projects/rust/esp-hal/1.1.1/esp32c3/src/esp_hal/rsa/mod.rs.html?search=u32+-%3E+bool

Demonstrates setting up and using the RSA backend for performing a 512-bit big number multiplication asynchronously.

```rust
# {before_snippet}
use esp_hal::rsa::{RsaBackend, RsaContext, operand_sizes::Op512};
# 
let mut rsa_backend = RsaBackend::new(peripherals.RSA);
let _driver = rsa_backend.start();

async fn perform_512bit_big_number_multiplication(
    operand_a: &[u32; 16],
    operand_b: &[u32; 16],
    result: &mut [u32; 32],
) {
    let mut rsa = RsaContext::new();

    let mut handle = rsa.multiply::<Op512>(operand_a, operand_b, result);
    handle.wait().await;
}
# {after_snippet}
```

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

### Basic ESP-HAL Application with GPIO Blinking

Source: https://docs.espressif.com/projects/rust/esp-hal/1.1.1/esp32c3/src/esp_hal/lib.rs.html?search=std%3A%3Avec

This example demonstrates a minimal ESP-HAL application. It initializes the system, configures a GPIO pin as an output, and blinks an LED connected to it. Ensure you have a panic handler set up.

```rust
#![no_std]
#![no_main]

use esp_hal::
    clock::CpuClock,
    gpio::{Io, Level, Output, OutputConfig},
    main,
    time::{Duration, Instant},
};

// You need a panic handler. Usually, you would use esp_backtrace, panic-probe, or
// something similar, but you can also bring your own like this:
#[panic_handler]
fn panic(_: &core::panic::PanicInfo) -> ! {
    esp_hal::system::software_reset()
}

#[main]
fn main() -> ! {
    let config = esp_hal::Config::default().with_cpu_clock(CpuClock::max());
    let peripherals = esp_hal::init(config);

    // Set GPIO0 as an output, and set its state high initially.
    let mut led = Output::new(peripherals.GPIO0, Level::High, OutputConfig::default());

    loop {
        led.toggle();
        // Wait for half a second
        let delay_start = Instant::now();
        while delay_start.elapsed() < Duration::from_millis(500) {}
    }
}
```

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

### SPI DMA Read Example

Source: https://docs.espressif.com/projects/rust/esp-hal/1.1.1/esp32c3/src/esp_hal/spi/master/dma.rs.html

Reads data from the SPI bus using DMA. This method sets up the SPI driver for full-duplex communication and then initiates DMA transfers to fill the provided buffer. It waits for the SPI bus to become idle before starting the transfer.

```rust
self.spi_dma.driver().setup_full_duplex()?;

            let empty_tx_buffer = unsafe { self.spi_dma.dma_driver().empty_tx_buffer() };

            unsafe {
                self.spi_dma.start_dma_transfer(
                    chunk.len(),
                    0,
                    &mut self.rx_buf,
                    empty_tx_buffer,
                )?;
            }
```

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

### UART Initialization and Basic Usage

Source: https://docs.espressif.com/projects/rust/esp-hal/1.1.1/esp32c3/esp_hal/uart/struct.Uart.html?search=u32+-%3E+bool

Demonstrates how to initialize a UART instance with custom configuration and perform basic write operations.

```APIDOC
## Uart

esp_hal::uart

### Struct Uart Copy item path

Source
```rust
pub struct Uart<'d, Dm: DriverMode> { /* private fields */ }
```

Expand description
UART (Full-duplex)

### §Example

```rust
use esp_hal::uart::{Config, Uart};
let mut uart = Uart::new(peripherals.UART0, Config::default())?
    .with_rx(peripherals.GPIO1)
    .with_tx(peripherals.GPIO2);

uart.write(b"Hello world!")?;
```
```

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

### Sharing Dedicated GPIO Input Drivers Across Bundles

Source: https://docs.espressif.com/projects/rust/esp-hal/1.1.1/esp32c3/esp_hal/gpio/dedicated/index.html

Demonstrates how to share individual `DedicatedGpioInput` drivers across multiple `DedicatedGpioInputBundle` instances. This is useful when different parts of the system need to monitor the same input channels without duplicating driver setup. The example shows creating two bundles that share common input drivers.

```rust
use esp_hal::gpio::{
    Input,
    InputConfig,
    dedicated::{DedicatedGpio, DedicatedGpioInput, DedicatedGpioInputBundle},
};

// Create channels.
let channels = DedicatedGpio::new(peripherals.GPIO_DEDICATED);

// Configure GPIO inputs
let p0 = Input::new(peripherals.GPIO0, InputConfig::default());
let p1 = Input::new(peripherals.GPIO1, InputConfig::default());
let p2 = Input::new(peripherals.GPIO2, InputConfig::default());
let p4 = Input::new(peripherals.GPIO4, InputConfig::default());

let in0 = DedicatedGpioInput::new(channels.channel0.input, p0);
let in1 = DedicatedGpioInput::new(channels.channel1.input, p1);
let in2 = DedicatedGpioInput::new(channels.channel2.input, p2);
let in4 = DedicatedGpioInput::new(channels.channel4.input, p4);

// Bundle A reads channels 0, 1, 2.
let mut bundle_a = DedicatedGpioInputBundle::new();
bundle_a
    .enable_input(&in0)
    .enable_input(&in1)
    .enable_input(&in2);

// Bundle B reads channels 0, 2, 4.
// Note: `in0` and `in2` are *shared* with bundle A.
let mut bundle_b = DedicatedGpioInputBundle::new();
bundle_b
    .enable_input(&in0)
    .enable_input(&in2)
    .enable_input(&in4);

// Check whether all channels in each bundle are currently high.
let a_all_high = bundle_a.all_high(); // true if ch0, ch1, ch2 are all high
let b_all_high = bundle_b.all_high(); // true if ch0, ch2, ch4 are all high

```

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

### Start a PeriodicTimer countdown

Source: https://docs.espressif.com/projects/rust/esp-hal/1.1.1/esp32c3/esp_hal/timer/struct.PeriodicTimer.html

Starts a new countdown for the `PeriodicTimer` with a specified period. Returns an error if the timer is already running or cannot be started.

```rust
pub fn start(&mut self, period: Duration) -> Result<(), Error>
```

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

### Create AnyI2c from peripheral

Source: https://docs.espressif.com/projects/rust/esp-hal/1.1.1/esp32c3/esp_hal/i2c/master/struct.AnyI2c.html?search=Option%3CT%3E%2C+%28T+-%3E+U%29+-%3E+Option%3CU%3E

Example of creating an AnyI2c instance from a peripheral singleton.

```rust
let any_peripheral = AnyI2c::from(peripheral);
```

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

### Using the ShaBackend driver

Source: https://docs.espressif.com/projects/rust/esp-hal/1.1.1/esp32c3/esp_hal/sha/index.html?search=

Example demonstrating how to use the `ShaBackend` driver for CPU-driven SHA-1 hashing.

```APIDOC
## Using the `ShaBackend` driver

This example demonstrates using the `ShaBackend` for SHA-1 hashing, processing data in chunks and finalizing the digest.

```rust
use esp_hal::sha::{Sha1Context, ShaBackend};
let mut sha = ShaBackend::new(peripherals.SHA);
// Start the backend, which allows processing SHA operations.
let _backend = sha.start();

// Create a new context to hash data with SHA-1.
let mut sha1_ctx = Sha1Context::new();

// SHA-1 outputs a 20-byte digest.
let mut digest: [u8; 20] = [0; 20];

// Process data. The `update` function returns a handle which can be used to wait
// for the operation to finish.
sha1_ctx.update(b"input data").wait_blocking();
sha1_ctx.update(b"input data").wait_blocking();
sha1_ctx.update(b"input data").wait_blocking();

// Extract the final hash. This resets the context.
sha1_ctx.finalize(&mut digest).wait_blocking();

// digest now contains the SHA-1 hash of the input.
```
```

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

### Create and Use DedicatedGpioInput

Source: https://docs.espressif.com/projects/rust/esp-hal/1.1.1/esp32c3/esp_hal/gpio/dedicated/struct.DedicatedGpioInput.html?search=std%3A%3Avec

Demonstrates how to create a new dedicated GPIO input driver and read its current state. Ensure the necessary peripherals and input configurations are available.

```rust
use esp_hal::gpio::{
    Input,
    InputConfig,
    Level,
    dedicated::{DedicatedGpio, DedicatedGpioInput},
};

// Create an input pin driver:
let input = Input::new(peripherals.GPIO0, InputConfig::default());

// Create a dedicated GPIO driver:
let channels = DedicatedGpio::new(peripherals.GPIO_DEDICATED);
let mut dedicated_input = DedicatedGpioInput::new(channels.channel0, input);

// Now you can use the pin:
let level = dedicated_input.level();
```

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

### DMA Setup

Source: https://docs.espressif.com/projects/rust/esp-hal/1.1.1/esp32c3/src/esp_hal/dma/gdma/ahb_v1.rs.html

Placeholder function for DMA setup.

```APIDOC
## DMA Setup

This is a placeholder function for initializing the DMA system. The actual implementation details are not provided in this snippet.

### Function Signature
`pub(crate) fn setup()`

### Usage
This function is intended to be called once during system initialization to configure the DMA controller.
```

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

### Example Searches

Source: https://docs.espressif.com/projects/rust/esp-hal/1.1.1/esp32c3/esp_hal/peripherals/struct.GPIO0.html?search=

Illustrative examples of search queries that can be performed.

```APIDOC
Example searches:
  * std::vec
  * u32 -> bool
  * Option<T>, (T -> U) -> Option<U>
```
Tokens:
Raw