"]
-edition = "2018"
+edition = "2021"
resolver = "2"
categories = ["embedded", "hardware-support"]
keywords = ["hal", "idf", "esp-idf", "esp32"]
@@ -10,34 +10,63 @@ description = "A Hardware abstraction layer for Espressif's ESP family of microc
repository = "https://github.com/esp-rs/esp-idf-hal"
license = "MIT OR Apache-2.0"
readme = "README.md"
-documentation = "https://esp-rs.github.io/esp-idf-hal/"
-rust-version = "1.61"
+links = "esp_idf_hal"
+build = "build.rs"
+documentation = "https://docs.esp-rs.org/esp-idf-hal/"
+rust-version = "1.75"
+
+[lib]
+harness = false
[features]
-default = ["std", "alloc", "esp-idf-sys"]
-std = ["alloc", "esp-idf-sys/std", "edge-executor?/std"]
+default = ["std", "binstart"]
+std = ["alloc", "esp-idf-sys/std"]
alloc = []
-riscv-ulp-hal = []
+nightly = []
+experimental = []
+wake-from-isr = [] # Only enable if you plan to use the `edge-executor` crate
+embassy-sync = [] # For now, the dependecy on the `embassy-sync` crate is non-optional, but this might change in future
+# Temporary, until (https://github.com/espressif/esp-idf/issues/13938) is addressed
+# - When enabled, the code for the legacy ADC oneshot driver will be compiled;
+# - When not enabled (default) the code for the new ADC oneshot driver will be compiled;
+# - Since we don't wrap the legacy _continuous_ ADC driver, the new _continuous_ ADC driver is always compiled.
+adc-oneshot-legacy = []
+# Similar to adc-oneshot-legacy
+# - When enabled (default), the code for the legacy RMT TX/RX driver will be compiled.
+# - When disabled the code for the new onewire RMT driver will be compiled.
+rmt-legacy = []
+# Propagated esp-idf-sys features
+native = ["esp-idf-sys/native"]
+pio = ["esp-idf-sys/pio"]
+alloc_handler = ["esp-idf-sys/alloc_handler"]
+panic_handler = ["esp-idf-sys/panic_handler"]
+binstart = ["esp-idf-sys/binstart"]
+libstart = ["esp-idf-sys/libstart"]
[dependencies]
-nb = "1.0.0"
+nb = "1"
embedded-can = "0.4.1"
-embedded-hal = "=1.0.0-alpha.9"
+embedded-hal = "1"
embedded-hal-0-2 = { package = "embedded-hal", version = "0.2.7", features = ["unproven"] }
-embedded-hal-nb = "=1.0.0-alpha.1"
-esp-idf-sys = { version = "0.32", optional = true, default-features = false, features = ["native"] }
-critical-section = { version = "1.1", optional = true }
-heapless = "0.7"
-embassy-sync = { version = "0.1", optional = true }
-edge-executor = { version = "0.3", optional = true, default-features = false }
+embedded-hal-nb = "1"
+embedded-hal-async = "1"
+embedded-io = "0.6"
+embedded-io-async = "0.6"
+esp-idf-sys = { version = "0.36", default-features = false }
+critical-section = { version = "1.1.1", optional = true, features = ["restore-state-none"] }
+heapless = "0.8"
+num_enum = { version = "0.7", default-features = false }
+enumset = { version = "1.1.4", default-features = false }
+log = { version = "0.4", default-features = false }
+atomic-waker = { version = "1.1.1", default-features = false }
+embassy-sync = { version = "0.6" }
[build-dependencies]
-embuild = "0.31"
-anyhow = "1"
+embuild = "0.33"
[dev-dependencies]
anyhow = "1"
-esp-idf-sys = { version = "0.32", features = ["native", "binstart"] }
+esp-idf-sys = { version = "0.36", features = ["binstart"] }
mipidsi = "0.5.0"
display-interface-spi = "0.4.1"
embedded-graphics = "0.7.1"
diff --git a/README.md b/README.md
index 3df92b023a2..bf7ba186a23 100644
--- a/README.md
+++ b/README.md
@@ -1,20 +1,63 @@
-# An [embedded-hal](https://github.com/rust-embedded/embedded-hal) implementation for ESP32[-XX] + ESP-IDF
+# Safe Rust wrappers for the drivers in the [ESP IDF SDK](https://docs.espressif.com/projects/esp-idf/en/latest/esp32/)
[](https://github.com/esp-rs/esp-idf-hal/actions/workflows/ci.yml)
-
+[](https://crates.io/crates/esp-idf-hal)
[](https://esp-rs.github.io/esp-idf-hal/esp_idf_hal/index.html)
+[](https://matrix.to/#/#esp-rs:matrix.org)
+[](https://wokwi.com/projects/332188235906155092)
-* This crate is intended for usage in ESP32[-XX] embedded projects that utilize and link with the **ESP-IDF SDK**.
-* For embedded projects that don't need Rust STD support, WiFi or BLE (and thus don't link with the ESP-IDF SDK), please check [esp-hal](https://github.com/esp-rs/esp-hal).
+## Highlights
+
+* Implements the traits of [embedded-hal](https://github.com/rust-embedded/embedded-hal) `V0.2` as well as those of `V1.0` - both blocking and async
+* Supports almost all ESP IDF drivers: GPIO, SPI, I2C, TIMER, PWM, I2S, UART, etc.
+* Blocking and `async` mode for each driver (`async` support in progress)
+* Re-exports `esp-idf-sys` as `esp_idf_hal::sys`
+
+**You might want to also check out the ESP IDF [Services](https://github.com/esp-rs/esp-idf-svc) wrappers, and the raw bindings to ESP IDF in the [`esp-idf-sys`](https://github.com/esp-rs/esp-idf-sys) crate!**
+
+(For baremetal Rust ESP projects please check [`esp-hal`](https://github.com/esp-rs/esp-hal).)
+
+## Build Prerequisites
+
+Follow the [Prerequisites](https://github.com/esp-rs/esp-idf-template#prerequisites) section in the `esp-idf-template` crate.
+
+## Examples
+
+The examples could be built and flashed conveniently with [`cargo-espflash`](https://github.com/esp-rs/espflash/). To run e.g. the `ledc_simple` on an e.g. ESP32-C3:
+(Swap the Rust target and example name with the target corresponding for your ESP32 MCU and with the example you would like to build)
+
+with `cargo-espflash`:
+```sh
+$ MCU=esp32c3 cargo espflash flash --target riscv32imc-esp-espidf --example ledc_simple --monitor
+```
+
+| MCU | "--target" |
+| --- | ------ |
+| esp32c2 | riscv32imc-esp-espidf |
+| esp32c3| riscv32imc-esp-espidf |
+| esp32c6| riscv32imac-esp-espidf |
+| esp32h2 | riscv32imac-esp-espidf |
+| esp32p4 | riscv32imafc-esp-espidf |
+| esp32 | xtensa-esp32-espidf |
+| esp32s2 | xtensa-esp32s2-espidf |
+| esp32s3 | xtensa-esp32s3-espidf |
+
+In order to run the examples on other chips you will most likely need to adapt at least the used pins.
+
+## Setting up a "Hello, world!" binary crate with ESP IDF
+
+Use the [`esp-idf-template`](https://github.com/esp-rs/esp-idf-template) project. Everything would be arranged and built for you automatically - no need to manually clone the ESP IDF repository.
+
+## More information
For more information, check out:
* The [Rust on ESP Book](https://esp-rs.github.io/book/)
-* The [embedded-hal](https://github.com/rust-embedded/embedded-hal) project
-* The [esp-hal](https://github.com/esp-rs/esp-hal) project
-* The [esp-idf-template](https://github.com/esp-rs/esp-idf-template) project
-* The [esp-idf-sys](https://github.com/esp-rs/esp-idf-sys) project
-* The [embedded-svc](https://github.com/esp-rs/embedded-svc) project
-* The [esp-idf-svc](https://github.com/esp-rs/esp-idf-svc) project
+* The [ESP Embedded Training](https://github.com/esp-rs/std-training)
+* The [`esp-idf-template`](https://github.com/esp-rs/esp-idf-template) project
+* The [`embedded-hal`](https://github.com/rust-embedded/embedded-hal) project
+* The [`esp-idf-svc`](https://github.com/esp-rs/esp-idf-svc) project
+* The [`embedded-svc`](https://github.com/esp-rs/embedded-svc) project
+* The [`esp-idf-sys`](https://github.com/esp-rs/esp-idf-sys) project
* The [Rust for Xtensa toolchain](https://github.com/esp-rs/rust-build)
* The [Rust-with-STD demo](https://github.com/ivmarkov/rust-esp32-std-demo) project
@@ -27,17 +70,11 @@ Please refer to the table below to determine the pins which are not recommended
| Chip | GPIOs |
| ------------ | :----------------: |
| **ESP32** | 6 - 11, 16 - 17 |
+| **ESP32-C2** | 12 - 17 |
| **ESP32-C3** | 12 - 17 |
+| **ESP32-C6** | 24 - 30 |
+| **ESP32-H2** | 15 - 21 |
| **ESP32-S2** | 26 - 32 |
| **ESP32-S3** | 26 - 32, 33 - 37\* |
_\* When using Octal Flash and/or Octal PSRAM_
-
-## Examples
-
-The examples could be built and flashed conveniently with [`cargo-espflash`](https://github.com/esp-rs/espflash/). To run `ledc-simple` on an ESP32-C3:
-```
-$ cargo espflash --release --target riscv32imc-esp-espidf --example ledc-simple --monitor /dev/ttyUSB0
-```
-
-In order to run the examples on other chips you will most likely need to adapt at least the used pins.
diff --git a/build.rs b/build.rs
index f13628e59e2..f0f0a39dd52 100644
--- a/build.rs
+++ b/build.rs
@@ -1,33 +1,4 @@
-#[cfg(not(feature = "riscv-ulp-hal"))]
-fn main() -> anyhow::Result<()> {
- embuild::build::CfgArgs::output_propagated("ESP_IDF")?;
-
- // Will not be available when built with a CMake-first or a PIO-first build
- // We need to output these only when building the examples' binaries anyway
- if let Ok(args) = embuild::build::LinkArgs::try_from_env("ESP_IDF") {
- args.output();
- }
-
- Ok(())
-}
-
-#[cfg(feature = "riscv-ulp-hal")]
fn main() {
- println!("cargo:rustc-cfg=esp32s2");
-
- let riscv_ulp_dir = std::env::current_dir().unwrap().join("riscv-ulp");
- println!("cargo:rustc-link-search={}", riscv_ulp_dir.display());
-
- println!(
- "cargo:rerun-if-changed={}",
- riscv_ulp_dir.join("libriscv_ulp_start.a").display()
- );
- println!(
- "cargo:rerun-if-changed={}",
- riscv_ulp_dir.join("riscv_ulp_link_base.x").display()
- );
- println!(
- "cargo:rerun-if-changed={}",
- riscv_ulp_dir.join("riscv_ulp_link_default.x").display()
- );
+ embuild::espidf::sysenv::relay();
+ embuild::espidf::sysenv::output(); // Only necessary for building the examples
}
diff --git a/clippy.toml b/clippy.toml
new file mode 100644
index 00000000000..493dbc02a83
--- /dev/null
+++ b/clippy.toml
@@ -0,0 +1 @@
+future-size-threshold = 900
diff --git a/espflash.toml b/espflash.toml
new file mode 100644
index 00000000000..d22b92e7795
--- /dev/null
+++ b/espflash.toml
@@ -0,0 +1 @@
+partition_table = "partitions.csv"
diff --git a/examples/adc.rs b/examples/adc.rs
index 3e1c0e5b3c8..bdd2ec21e9b 100644
--- a/examples/adc.rs
+++ b/examples/adc.rs
@@ -1,24 +1,22 @@
//! ADC example, reading a value form a pin and printing it on the terminal
//!
-use esp_idf_sys::{self as _}; // If using the `binstart` feature of `esp-idf-sys`, always keep this module imported
+#![allow(unknown_lints)]
+#![allow(unexpected_cfgs)]
+
+use esp_idf_sys as _; // If using the `binstart` feature of `esp-idf-sys`, always keep this module imported
use std::thread;
use std::time::Duration;
-use esp_idf_hal::adc::config::Config;
-use esp_idf_hal::adc::Atten11dB;
-use esp_idf_hal::adc::*;
-use esp_idf_hal::peripherals::Peripherals;
-
-#[cfg(not(esp32))]
-use esp_idf_hal::gpio::Gpio4;
-
-#[cfg(esp32)]
-use esp_idf_hal::gpio::Gpio12;
-
+#[cfg(any(feature = "adc-oneshot-legacy", esp_idf_version_major = "4"))]
fn main() -> anyhow::Result<()> {
- let peripherals = Peripherals::take().unwrap();
+ use esp_idf_hal::adc::config::Config;
+ use esp_idf_hal::adc::*;
+ use esp_idf_hal::peripherals::Peripherals;
+ use esp_idf_hal::sys::adc_atten_t; // If using the `binstart` feature of `esp-idf-sys`, always keep this module imported
+
+ let peripherals = Peripherals::take()?;
#[cfg(not(esp32))]
let mut adc = AdcDriver::new(peripherals.adc1, &Config::new().calibration(true))?;
@@ -26,19 +24,30 @@ fn main() -> anyhow::Result<()> {
#[cfg(esp32)]
let mut adc = AdcDriver::new(peripherals.adc2, &Config::new().calibration(true))?;
+ const ATTENUATION: adc_atten_t = attenuation::DB_12;
+
// configuring pin to analog read, you can regulate the adc input voltage range depending on your need
// for this example we use the attenuation of 11db which sets the input voltage range to around 0-3.6V
#[cfg(not(esp32))]
- let mut adc_pin: esp_idf_hal::adc::AdcChannelDriver<'_, Gpio4, Atten11dB<_>> =
+ let mut adc_pin: esp_idf_hal::adc::AdcChannelDriver<{ ATTENUATION }, _> =
AdcChannelDriver::new(peripherals.pins.gpio4)?;
#[cfg(esp32)]
- let mut adc_pin: esp_idf_hal::adc::AdcChannelDriver<'_, Gpio12, Atten11dB<_>> =
+ let mut adc_pin: esp_idf_hal::adc::AdcChannelDriver<{ ATTENUATION }, _> =
AdcChannelDriver::new(peripherals.pins.gpio12)?;
loop {
// you can change the sleep duration depending on how often you want to sample
thread::sleep(Duration::from_millis(10));
- println!("ADC value: {}", adc.read(&mut adc_pin).unwrap());
+ println!("ADC value: {}", adc.read(&mut adc_pin)?);
+ }
+}
+
+#[cfg(not(any(feature = "adc-oneshot-legacy", esp_idf_version_major = "4")))]
+fn main() -> anyhow::Result<()> {
+ println!("This example requires feature `adc-oneshot-legacy` enabled or using ESP-IDF v4.4.X");
+
+ loop {
+ thread::sleep(Duration::from_millis(1000));
}
}
diff --git a/examples/adc_oneshot.rs b/examples/adc_oneshot.rs
new file mode 100644
index 00000000000..7181ee00510
--- /dev/null
+++ b/examples/adc_oneshot.rs
@@ -0,0 +1,54 @@
+//! ADC oneshot example, reading a value form a pin and printing it on the terminal
+//! requires ESP-IDF v5.0 or newer
+
+#![allow(unknown_lints)]
+#![allow(unexpected_cfgs)]
+
+use std::thread;
+use std::time::Duration;
+
+#[cfg(not(any(feature = "adc-oneshot-legacy", esp_idf_version_major = "4")))]
+fn main() -> anyhow::Result<()> {
+ use esp_idf_hal::adc::attenuation::DB_12;
+ use esp_idf_hal::adc::oneshot::config::AdcChannelConfig;
+ use esp_idf_hal::adc::oneshot::*;
+ use esp_idf_hal::peripherals::Peripherals;
+
+ let peripherals = Peripherals::take()?;
+
+ #[cfg(not(esp32))]
+ let adc = AdcDriver::new(peripherals.adc1)?;
+
+ #[cfg(esp32)]
+ let adc = AdcDriver::new(peripherals.adc2)?;
+
+ // configuring pin to analog read, you can regulate the adc input voltage range depending on your need
+ // for this example we use the attenuation of 11db which sets the input voltage range to around 0-3.6V
+ let config = AdcChannelConfig {
+ attenuation: DB_12,
+ ..Default::default()
+ };
+
+ #[cfg(not(esp32))]
+ let mut adc_pin = AdcChannelDriver::new(&adc, peripherals.pins.gpio2, &config)?;
+
+ #[cfg(esp32)]
+ let mut adc_pin = AdcChannelDriver::new(&adc, peripherals.pins.gpio12, &config)?;
+
+ loop {
+ // you can change the sleep duration depending on how often you want to sample
+ thread::sleep(Duration::from_millis(100));
+ println!("ADC value: {}", adc.read(&mut adc_pin)?);
+ }
+}
+
+#[cfg(any(feature = "adc-oneshot-legacy", esp_idf_version_major = "4"))]
+fn main() -> anyhow::Result<()> {
+ println!(
+ "This example requires ESP-IDF v5.X or newer and feature `adc-oneshot-legacy` disabled"
+ );
+
+ loop {
+ thread::sleep(Duration::from_millis(1000));
+ }
+}
diff --git a/examples/blinky.rs b/examples/blinky.rs
index 31422f16df7..5d5f329fbb4 100644
--- a/examples/blinky.rs
+++ b/examples/blinky.rs
@@ -10,9 +10,9 @@ use esp_idf_hal::gpio::*;
use esp_idf_hal::peripherals::Peripherals;
fn main() -> anyhow::Result<()> {
- esp_idf_sys::link_patches();
+ esp_idf_hal::sys::link_patches();
- let peripherals = Peripherals::take().unwrap();
+ let peripherals = Peripherals::take()?;
let mut led = PinDriver::output(peripherals.pins.gpio4)?;
loop {
diff --git a/examples/blinky_async.rs b/examples/blinky_async.rs
new file mode 100644
index 00000000000..343ad951e68
--- /dev/null
+++ b/examples/blinky_async.rs
@@ -0,0 +1,32 @@
+//! Blinks an LED
+//!
+//! This assumes that a LED is connected to GPIO4.
+//! Depending on your target and the board you are using you should change the pin.
+//! If your board doesn't have on-board LEDs don't forget to add an appropriate resistor.
+//!
+
+use esp_idf_hal::gpio::*;
+use esp_idf_hal::peripherals::Peripherals;
+use esp_idf_hal::task::*;
+use esp_idf_hal::timer::*;
+
+fn main() -> anyhow::Result<()> {
+ esp_idf_hal::sys::link_patches();
+
+ let peripherals = Peripherals::take()?;
+
+ let mut led = PinDriver::output(peripherals.pins.gpio4)?;
+ let mut timer = TimerDriver::new(peripherals.timer00, &TimerConfig::new())?;
+
+ block_on(async {
+ loop {
+ led.set_high()?;
+
+ timer.delay(timer.tick_hz()).await?;
+
+ led.set_low()?;
+
+ timer.delay(timer.tick_hz()).await?;
+ }
+ })
+}
diff --git a/examples/button.rs b/examples/button.rs
index c1326592fe2..cc74d800bfb 100644
--- a/examples/button.rs
+++ b/examples/button.rs
@@ -12,9 +12,9 @@ use esp_idf_hal::gpio::*;
use esp_idf_hal::peripherals::Peripherals;
fn main() -> anyhow::Result<()> {
- esp_idf_sys::link_patches();
+ esp_idf_hal::sys::link_patches();
- let peripherals = Peripherals::take().unwrap();
+ let peripherals = Peripherals::take()?;
let mut led = PinDriver::output(peripherals.pins.gpio4)?;
let mut button = PinDriver::input(peripherals.pins.gpio9)?;
diff --git a/examples/button_async.rs b/examples/button_async.rs
new file mode 100644
index 00000000000..b3f0caab06b
--- /dev/null
+++ b/examples/button_async.rs
@@ -0,0 +1,35 @@
+//! Turn an LED on/off depending on the state of a button
+//!
+//! This assumes that a LED is connected to GPIO4.
+//! Additionally this assumes a button connected to GPIO9.
+//! On an ESP32C3 development board this is the BOOT button.
+//!
+//! Depending on your target and the board you are using you should change the pins.
+//! If your board doesn't have on-board LEDs don't forget to add an appropriate resistor.
+
+use esp_idf_hal::gpio::*;
+use esp_idf_hal::peripherals::Peripherals;
+use esp_idf_hal::task::*;
+
+fn main() -> anyhow::Result<()> {
+ esp_idf_hal::sys::link_patches();
+
+ let peripherals = Peripherals::take()?;
+
+ let mut led = PinDriver::output(peripherals.pins.gpio4)?;
+ let mut button = PinDriver::input(peripherals.pins.gpio9)?;
+
+ button.set_pull(Pull::Down)?;
+
+ block_on(async {
+ loop {
+ button.wait_for_high().await?;
+
+ led.set_high()?;
+
+ button.wait_for_low().await?;
+
+ led.set_low()?;
+ }
+ })
+}
diff --git a/examples/button_interrupt.rs b/examples/button_interrupt.rs
new file mode 100644
index 00000000000..97c7bf0ed67
--- /dev/null
+++ b/examples/button_interrupt.rs
@@ -0,0 +1,60 @@
+//! Toggle an LED on/off with a button
+//!
+//! This assumes that a LED is connected to GPIO4.
+//! Additionally this assumes a button connected to GPIO9.
+//! On an ESP32C3 development board this is the BOOT button.
+//!
+//! Depending on your target and the board you are using you should change the pins.
+//! If your board doesn't have on-board LEDs don't forget to add an appropriate resistor.
+
+use core::num::NonZero;
+use esp_idf_hal::delay::FreeRtos;
+use esp_idf_hal::gpio::{InterruptType, PinDriver, Pull};
+use esp_idf_hal::peripherals::Peripherals;
+use esp_idf_hal::task::notification::Notification;
+
+fn main() -> anyhow::Result<()> {
+ esp_idf_hal::sys::link_patches();
+
+ let peripherals = Peripherals::take()?;
+ let mut led = PinDriver::output(peripherals.pins.gpio4)?;
+ let mut button = PinDriver::input(peripherals.pins.gpio9)?;
+
+ button.set_pull(Pull::Down)?;
+ button.set_interrupt_type(InterruptType::PosEdge)?;
+
+ let mut led_state = false;
+ led.set_low()?;
+
+ loop {
+ // prepare communication channel
+ let notification = Notification::new();
+ let waker = notification.notifier();
+
+ // register interrupt callback, here it's a closure on stack
+ unsafe {
+ button
+ .subscribe_nonstatic(move || {
+ waker.notify(NonZero::new(1).unwrap());
+ })
+ .unwrap();
+ }
+
+ // enable interrupt, will be automatically disabled after being triggered
+ button.enable_interrupt()?;
+ // block until notified
+ notification.wait_any();
+
+ // toggle the LED
+ if led_state {
+ led.set_low()?;
+ led_state = false;
+ } else {
+ led.set_high()?;
+ led_state = true;
+ }
+
+ // debounce
+ FreeRtos::delay_ms(200);
+ }
+}
diff --git a/examples/i2c_master_slave.rs b/examples/i2c_master_slave.rs
new file mode 100644
index 00000000000..2759b3e606d
--- /dev/null
+++ b/examples/i2c_master_slave.rs
@@ -0,0 +1,179 @@
+//! Test communication between a master and a slave I2C on the same device
+//!
+//! Wiring required, but can be changed in main():
+//! - GPIO21 to GPIO18
+//! - GPIO22 to GPIO19
+//!
+//! ESP32-C2/C3 does not have two I2C peripherals, so this example will not work.
+//!
+//! Description:
+//! Consists of three parts:
+//! 1. Simple master write, master writes 8 bytes and print out what slave receives
+//! 2. Simple master read, master read 8 bytes and print out.
+//! 3. Read/write register, write a value to a register addr and read it back.
+//!
+#![allow(unused)]
+#![allow(unknown_lints)]
+#![allow(unexpected_cfgs)]
+
+use esp_idf_hal::delay::BLOCK;
+use esp_idf_hal::gpio::{AnyIOPin, InputPin, OutputPin};
+use esp_idf_hal::i2c::{I2c, I2cConfig, I2cDriver, I2cSlaveConfig, I2cSlaveDriver};
+use esp_idf_hal::peripheral::Peripheral;
+use esp_idf_hal::peripherals::Peripherals;
+use esp_idf_hal::prelude::*;
+use esp_idf_hal::units::Hertz;
+
+const SLAVE_ADDR: u8 = 0x22;
+const SLAVE_BUFFER_SIZE: usize = 128;
+
+fn i2c_master_init<'d>(
+ i2c: impl Peripheral + 'd,
+ sda: AnyIOPin,
+ scl: AnyIOPin,
+ baudrate: Hertz,
+) -> anyhow::Result> {
+ let config = I2cConfig::new().baudrate(baudrate);
+ let driver = I2cDriver::new(i2c, sda, scl, &config)?;
+ Ok(driver)
+}
+
+fn i2c_slave_init<'d>(
+ i2c: impl Peripheral + 'd,
+ sda: AnyIOPin,
+ scl: AnyIOPin,
+ buflen: usize,
+ slave_addr: u8,
+) -> anyhow::Result> {
+ let config = I2cSlaveConfig::new()
+ .rx_buffer_length(buflen)
+ .tx_buffer_length(buflen);
+ let driver = I2cSlaveDriver::new(i2c, sda, scl, slave_addr, &config)?;
+ Ok(driver)
+}
+
+#[cfg(not(esp32))]
+fn main() -> anyhow::Result<()> {
+ println!("Test only configured for ESP32");
+ Ok(())
+}
+
+#[cfg(esp32)]
+fn main() -> anyhow::Result<()> {
+ esp_idf_hal::sys::link_patches();
+
+ println!("Starting I2C self test");
+
+ let peripherals = Peripherals::take()?;
+
+ let mut i2c_master = i2c_master_init(
+ peripherals.i2c0,
+ peripherals.pins.gpio21.into(),
+ peripherals.pins.gpio22.into(),
+ 100.kHz().into(),
+ )?;
+
+ let mut i2c_slave = i2c_slave_init(
+ peripherals.i2c1,
+ peripherals.pins.gpio18.into(),
+ peripherals.pins.gpio19.into(),
+ SLAVE_BUFFER_SIZE,
+ SLAVE_ADDR,
+ )?;
+
+ let tx_buf: [u8; 8] = [0x01, 0x23, 0x45, 0x67, 0x89, 0xab, 0xcd, 0xef];
+
+ println!("-------- TESTING SIMPLE MASTER WRITE --------");
+ i2c_master.write(SLAVE_ADDR, &tx_buf, BLOCK)?;
+
+ let mut rx_buf: [u8; 8] = [0; 8];
+ match i2c_slave.read(&mut rx_buf, BLOCK) {
+ Ok(_) => println!("Master send {:?} Slave receives {:?}", tx_buf, rx_buf),
+ Err(e) => println!("Error: {:?}", e),
+ }
+
+ println!("-------- TESTING SIMPLE MASTER READ --------");
+ i2c_slave.write(&tx_buf, BLOCK)?; // fill slave buffer before master tries to read
+
+ let mut rx_buf: [u8; 8] = [0; 8];
+ match i2c_master.read(SLAVE_ADDR, &mut rx_buf, BLOCK) {
+ Ok(_) => println!("Slave send {:?} Master receives {:?}", tx_buf, rx_buf),
+ Err(e) => println!("Error: {:?}", e),
+ }
+
+ println!("-------- TESTING READ/WRITE REGISTER --------");
+
+ let thread0 = std::thread::Builder::new()
+ .stack_size(7000)
+ .spawn(move || {
+ let mut data: [u8; 256] = [0; 256];
+ loop {
+ let mut reg_addr: [u8; 1] = [0];
+ let res = i2c_slave.read(&mut reg_addr, BLOCK);
+ if res.is_err() {
+ println!(
+ "SLAVE: failed to read register address from master: Error: {:?}",
+ res
+ );
+ continue;
+ }
+ let mut rx_data: [u8; 1] = [0];
+ match i2c_slave.read(&mut rx_data, 0) {
+ Ok(_) => {
+ println!(
+ "SLAVE: write operation {:#04x} to reg addr {:#04x}",
+ rx_data[0], reg_addr[0]
+ );
+ data[reg_addr[0] as usize] = rx_data[0];
+ }
+ Err(_) => {
+ let d = data[reg_addr[0] as usize];
+ println!(
+ "SLAVE: read operation {:#04x} from reg addr {:#04x}",
+ d, reg_addr[0]
+ );
+ i2c_slave.write(&[d], BLOCK).unwrap();
+ }
+ }
+ }
+ })?;
+
+ // allow thread to run
+ std::thread::yield_now();
+
+ let reg_addr: u8 = 0x05;
+ let new_value: u8 = 0x42;
+
+ println!("MASTER: read reg addr {:#04x}", reg_addr);
+ let mut rx_buf: [u8; 1] = [0; 1];
+ // TODO: make write_read work
+ i2c_master.write(SLAVE_ADDR, &[reg_addr], BLOCK)?;
+ i2c_master.read(SLAVE_ADDR, &mut rx_buf, BLOCK)?;
+ println!(
+ "MASTER: value of reg addr {:#04x} is {:#04x}",
+ reg_addr, rx_buf[0]
+ );
+
+ println!("---------------------");
+
+ println!(
+ "MASTER: write {:#04x} to reg addr {:#04x}",
+ new_value, reg_addr
+ );
+ i2c_master.write(SLAVE_ADDR, &[reg_addr, new_value], BLOCK)?;
+
+ println!("---------------------");
+
+ println!("MASTER: read reg addr {:#04x}", reg_addr);
+ let mut rx_buf: [u8; 1] = [0; 1];
+ // TODO: make write_read work
+ i2c_master.write(SLAVE_ADDR, &[reg_addr], BLOCK)?;
+ i2c_master.read(SLAVE_ADDR, &mut rx_buf, BLOCK)?;
+ println!(
+ "MASTER: value of reg addr {:#04x} is {:#04x}",
+ reg_addr, rx_buf[0]
+ );
+
+ thread0.join().unwrap();
+ Ok(())
+}
diff --git a/examples/i2c_ssd1306.rs b/examples/i2c_ssd1306.rs
index 0de4e0e079d..87df5b498ab 100644
--- a/examples/i2c_ssd1306.rs
+++ b/examples/i2c_ssd1306.rs
@@ -17,9 +17,9 @@ use esp_idf_hal::prelude::*;
const SSD1306_ADDRESS: u8 = 0x3c;
fn main() -> anyhow::Result<()> {
- esp_idf_sys::link_patches();
+ esp_idf_hal::sys::link_patches();
- let peripherals = Peripherals::take().unwrap();
+ let peripherals = Peripherals::take()?;
let i2c = peripherals.i2c0;
let sda = peripherals.pins.gpio5;
let scl = peripherals.pins.gpio6;
diff --git a/examples/ledc_fade.rs b/examples/ledc_fade.rs
new file mode 100644
index 00000000000..5a68ed24679
--- /dev/null
+++ b/examples/ledc_fade.rs
@@ -0,0 +1,39 @@
+use esp_idf_hal::delay::FreeRtos;
+use esp_idf_hal::ledc::{config::TimerConfig, LedcDriver, LedcTimerDriver};
+use esp_idf_hal::peripherals::Peripherals;
+use esp_idf_hal::prelude::*;
+use std::time::Duration;
+
+fn main() -> anyhow::Result<()> {
+ esp_idf_hal::sys::link_patches();
+
+ let peripherals = Peripherals::take()?;
+
+ let timer_driver = LedcTimerDriver::new(
+ peripherals.ledc.timer0,
+ &TimerConfig::default().frequency(25.kHz().into()),
+ )?;
+
+ let mut ledc_driver = LedcDriver::new(
+ peripherals.ledc.channel0,
+ timer_driver,
+ peripherals.pins.gpio7,
+ )?;
+
+ for _ in 0..2 {
+ // Fade up over 2 seconds
+ ledc_driver.fade_with_time(
+ ledc_driver.get_max_duty(),
+ Duration::from_secs(2).as_millis() as i32,
+ true,
+ )?;
+
+ // Fade down over 2 seconds
+ ledc_driver.fade_with_time(0, Duration::from_secs(2).as_millis() as i32, true)?;
+ }
+
+ ledc_driver.set_duty(ledc_driver.get_max_duty() / 10)?;
+ FreeRtos::delay_ms(10000);
+
+ Ok(())
+}
diff --git a/examples/ledc-simple.rs b/examples/ledc_simple.rs
similarity index 73%
rename from examples/ledc-simple.rs
rename to examples/ledc_simple.rs
index fd4c5917070..fb7da2b4262 100644
--- a/examples/ledc-simple.rs
+++ b/examples/ledc_simple.rs
@@ -4,17 +4,18 @@ use esp_idf_hal::peripherals::Peripherals;
use esp_idf_hal::prelude::*;
fn main() -> anyhow::Result<()> {
- esp_idf_sys::link_patches();
+ esp_idf_hal::sys::link_patches();
println!("Configuring output channel");
- let peripherals = Peripherals::take().unwrap();
- let config = config::TimerConfig::new().frequency(25.kHz().into());
+ let peripherals = Peripherals::take()?;
let mut channel = LedcDriver::new(
peripherals.ledc.channel0,
- LedcTimerDriver::new(peripherals.ledc.timer0, &config)?,
+ LedcTimerDriver::new(
+ peripherals.ledc.timer0,
+ &config::TimerConfig::new().frequency(25.kHz().into()),
+ )?,
peripherals.pins.gpio4,
- &config,
)?;
println!("Starting duty-cycle loop");
diff --git a/examples/ledc-threads.rs b/examples/ledc_threads.rs
similarity index 81%
rename from examples/ledc-threads.rs
rename to examples/ledc_threads.rs
index 91edbc9429e..d0946a030fa 100644
--- a/examples/ledc-threads.rs
+++ b/examples/ledc_threads.rs
@@ -1,4 +1,5 @@
-use std::{sync::Arc, time::Duration};
+use std::rc::Rc;
+use std::time::Duration;
use embedded_hal_0_2::PwmPin;
@@ -9,25 +10,19 @@ use esp_idf_hal::prelude::*;
const CYCLES: usize = 3;
fn main() -> anyhow::Result<()> {
- esp_idf_sys::link_patches();
+ esp_idf_hal::sys::link_patches();
println!("Setting up PWM output channels");
- let peripherals = Peripherals::take().unwrap();
+ let peripherals = Peripherals::take()?;
let config = config::TimerConfig::new().frequency(25.kHz().into());
- let timer = Arc::new(LedcTimerDriver::new(peripherals.ledc.timer0, &config)?);
+ let timer = Rc::new(LedcTimerDriver::new(peripherals.ledc.timer0, &config)?);
let channel0 = LedcDriver::new(
peripherals.ledc.channel0,
timer.clone(),
peripherals.pins.gpio4,
- &config,
- )?;
- let channel1 = LedcDriver::new(
- peripherals.ledc.channel1,
- timer,
- peripherals.pins.gpio5,
- &config,
)?;
+ let channel1 = LedcDriver::new(peripherals.ledc.channel1, timer, peripherals.pins.gpio5)?;
println!("Spawning PWM threads");
diff --git a/examples/mcpwm-simple.rs b/examples/mcpwm-simple.rs
index 5921d82d59d..ccdd3014a1f 100644
--- a/examples/mcpwm-simple.rs
+++ b/examples/mcpwm-simple.rs
@@ -58,8 +58,6 @@
#[cfg(all(any(esp32, esp32s3), esp_idf_version_major = "5"))]
fn main() -> anyhow::Result<()> {
- use embedded_hal::delay::DelayUs;
-
use esp_idf_hal::delay::FreeRtos;
use esp_idf_hal::mcpwm::{OperatorConfig, TimerConfig, TimerDriver};
use esp_idf_hal::prelude::Peripherals;
@@ -98,7 +96,7 @@ fn main() -> anyhow::Result<()> {
operator.set_compare_value_x(duty)?; // In this configuration this controls the duty on pin4
operator.set_compare_value_y(period_ticks - duty)?; // and this controls pin5
- FreeRtos.delay_ms(10)?;
+ FreeRtos::delay_ms(10);
}
unreachable!()
diff --git a/examples/pcnt_rotary_encoder.rs b/examples/pcnt_rotary_encoder.rs
new file mode 100644
index 00000000000..f7398553ad8
--- /dev/null
+++ b/examples/pcnt_rotary_encoder.rs
@@ -0,0 +1,146 @@
+//! PCNT decoding a rotary encoder
+//!
+//! To try this out, connect a rotary encoder to pins 5 and 6, the common should be grounded
+//!
+//! Note that PCNT only track a singed 16bit value. We use interrupts to detect a LOW and HIGH
+//! threshold and track how much that accounts for and provide an i32 value result
+//!
+
+#![allow(unknown_lints)]
+#![allow(unexpected_cfgs)]
+
+#[cfg(any(esp32, esp32s2, esp32s3))]
+fn main() -> anyhow::Result<()> {
+ use anyhow::Context;
+ use encoder::Encoder;
+ use esp_idf_hal::delay::FreeRtos;
+ use esp_idf_hal::prelude::*;
+
+ // Temporary. Will disappear once ESP-IDF 4.4 is released, but for now it is necessary to call this function once,
+ // or else some patches to the runtime implemented by esp-idf-sys might not link properly.
+ esp_idf_hal::sys::link_patches();
+
+ println!("setup pins");
+ let peripherals = Peripherals::take().context("failed to take Peripherals")?;
+ let mut pin_a = peripherals.pins.gpio5;
+ let mut pin_b = peripherals.pins.gpio6;
+ println!("setup encoder");
+ let encoder = Encoder::new(peripherals.pcnt0, &mut pin_a, &mut pin_b)?;
+
+ let mut last_value = 0i32;
+ loop {
+ let value = encoder.get_value()?;
+ if value != last_value {
+ println!("value: {value}");
+ last_value = value;
+ }
+ FreeRtos::delay_ms(100u32);
+ }
+}
+
+#[cfg(not(any(esp32, esp32s2, esp32s3)))]
+fn main() {
+ use esp_idf_hal::delay::FreeRtos;
+ println!("pcnt peripheral not supported on this device!");
+ loop {
+ FreeRtos::delay_ms(100u32);
+ }
+}
+
+#[cfg(any(esp32, esp32s2, esp32s3))]
+// esp-idf encoder implementation using v4 pcnt api
+mod encoder {
+ use std::cmp::min;
+ use std::sync::atomic::AtomicI32;
+ use std::sync::atomic::Ordering;
+ use std::sync::Arc;
+
+ use esp_idf_hal::gpio::AnyInputPin;
+ use esp_idf_hal::gpio::InputPin;
+ use esp_idf_hal::pcnt::*;
+ use esp_idf_hal::peripheral::Peripheral;
+ use esp_idf_sys::EspError;
+
+ const LOW_LIMIT: i16 = -100;
+ const HIGH_LIMIT: i16 = 100;
+
+ pub struct Encoder<'d> {
+ unit: PcntDriver<'d>,
+ approx_value: Arc,
+ }
+
+ impl<'d> Encoder<'d> {
+ pub fn new(
+ pcnt: impl Peripheral + 'd,
+ pin_a: impl Peripheral
+ 'd,
+ pin_b: impl Peripheral
+ 'd,
+ ) -> Result {
+ let mut unit = PcntDriver::new(
+ pcnt,
+ Some(pin_a),
+ Some(pin_b),
+ Option::::None,
+ Option::::None,
+ )?;
+ unit.channel_config(
+ PcntChannel::Channel0,
+ PinIndex::Pin0,
+ PinIndex::Pin1,
+ &PcntChannelConfig {
+ lctrl_mode: PcntControlMode::Reverse,
+ hctrl_mode: PcntControlMode::Keep,
+ pos_mode: PcntCountMode::Decrement,
+ neg_mode: PcntCountMode::Increment,
+ counter_h_lim: HIGH_LIMIT,
+ counter_l_lim: LOW_LIMIT,
+ },
+ )?;
+ unit.channel_config(
+ PcntChannel::Channel1,
+ PinIndex::Pin1,
+ PinIndex::Pin0,
+ &PcntChannelConfig {
+ lctrl_mode: PcntControlMode::Reverse,
+ hctrl_mode: PcntControlMode::Keep,
+ pos_mode: PcntCountMode::Increment,
+ neg_mode: PcntCountMode::Decrement,
+ counter_h_lim: HIGH_LIMIT,
+ counter_l_lim: LOW_LIMIT,
+ },
+ )?;
+
+ unit.set_filter_value(min(10 * 80, 1023))?;
+ unit.filter_enable()?;
+
+ let approx_value = Arc::new(AtomicI32::new(0));
+ // unsafe interrupt code to catch the upper and lower limits from the encoder
+ // and track the overflow in `value: Arc` - I plan to use this for
+ // a wheeled robot's odomerty
+ unsafe {
+ let approx_value = approx_value.clone();
+ unit.subscribe(move |status| {
+ let status = PcntEventType::from_repr_truncated(status);
+ if status.contains(PcntEvent::HighLimit) {
+ approx_value.fetch_add(HIGH_LIMIT as i32, Ordering::SeqCst);
+ }
+ if status.contains(PcntEvent::LowLimit) {
+ approx_value.fetch_add(LOW_LIMIT as i32, Ordering::SeqCst);
+ }
+ })?;
+ }
+ unit.event_enable(PcntEvent::HighLimit)?;
+ unit.event_enable(PcntEvent::LowLimit)?;
+ unit.counter_pause()?;
+ unit.counter_clear()?;
+ unit.counter_resume()?;
+
+ Ok(Self { unit, approx_value })
+ }
+
+ pub fn get_value(&self) -> Result {
+ let value =
+ self.approx_value.load(Ordering::Relaxed) + self.unit.get_counter_value()? as i32;
+ Ok(value)
+ }
+ }
+}
diff --git a/examples/reset_reason.rs b/examples/reset_reason.rs
new file mode 100644
index 00000000000..20c2c0bb58c
--- /dev/null
+++ b/examples/reset_reason.rs
@@ -0,0 +1,25 @@
+//! This example demonstrates a how to ask for the reset reason and the wakeup reason.
+use std::{thread, time};
+
+use esp_idf_sys::{self as _}; // If using the `binstart` feature of `esp-idf-sys`, always keep this module imported
+
+fn main() -> anyhow::Result<()> {
+ esp_idf_sys::link_patches();
+
+ let wakeup_reason = esp_idf_hal::reset::WakeupReason::get();
+ println!("Wakeup reason: {:?}", wakeup_reason);
+
+ let reset_reason = esp_idf_hal::reset::ResetReason::get();
+ println!("Reset reason: {:?}", reset_reason);
+
+ thread::sleep(time::Duration::from_millis(1000));
+
+ let sleep_micros = 2_000_000;
+ unsafe {
+ esp_idf_sys::esp_sleep_enable_timer_wakeup(sleep_micros);
+
+ println!("Going to deep sleep {} seconds", sleep_micros / 1_000_000);
+ esp_idf_sys::esp_deep_sleep_start();
+ // Software reset!
+ }
+}
diff --git a/examples/rmt_morse_code.rs b/examples/rmt_morse_code.rs
index 95ea01ddda2..3837fa6f75b 100644
--- a/examples/rmt_morse_code.rs
+++ b/examples/rmt_morse_code.rs
@@ -14,150 +14,177 @@
//! * Background sending.
//! * Taking a [`Pin`] and [`Channel`] by ref mut, so that they can be used again later.
//!
-use esp_idf_hal::delay::Ets;
-use esp_idf_hal::gpio::*;
-use esp_idf_hal::peripheral::*;
-use esp_idf_hal::peripherals::Peripherals;
-use esp_idf_hal::rmt::config::{CarrierConfig, DutyPercent, Loop, TransmitConfig};
-use esp_idf_hal::rmt::*;
-use esp_idf_hal::units::FromValueType;
-fn main() -> anyhow::Result<()> {
- esp_idf_sys::link_patches();
-
- let peripherals = Peripherals::take().unwrap();
- let mut channel = peripherals.rmt.channel0;
- let mut led = peripherals.pins.gpio17;
- let stop = peripherals.pins.gpio16;
-
- let carrier = CarrierConfig::new()
- .duty_percent(DutyPercent::new(50)?)
- .frequency(611.Hz());
- let mut config = TransmitConfig::new()
- .carrier(Some(carrier))
- .looping(Loop::Endless)
- .clock_divider(255);
-
- let tx = send_morse_code(&mut channel, &mut led, &config, "HELLO ")?;
+#![allow(unknown_lints)]
+#![allow(unexpected_cfgs)]
- let stop = PinDriver::input(stop)?;
+#[cfg(any(feature = "rmt-legacy", esp_idf_version_major = "4"))]
+fn main() -> anyhow::Result<()> {
+ example::main()
+}
- println!("Keep sending until pin {} is set low.", stop.pin());
+#[cfg(not(any(feature = "rmt-legacy", esp_idf_version_major = "4")))]
+fn main() -> anyhow::Result<()> {
+ println!("This example requires feature `rmt-legacy` enabled or using ESP-IDF v4.4.X");
- while stop.is_high() {
- Ets::delay_ms(100);
+ loop {
+ std::thread::sleep(std::time::Duration::from_millis(1000));
}
+}
- println!("Pin {} set to low. Stopped.", stop.pin());
+#[cfg(any(feature = "rmt-legacy", esp_idf_version_major = "4"))]
+mod example {
+ use esp_idf_hal::units::FromValueType;
+ use esp_idf_hal::{
+ delay::Ets,
+ gpio::{OutputPin, PinDriver},
+ peripheral::Peripheral,
+ prelude::Peripherals,
+ rmt::{
+ config::{CarrierConfig, DutyPercent, Loop, TransmitConfig},
+ PinState, Pulse, PulseTicks, RmtChannel, TxRmtDriver, VariableLengthSignal,
+ },
+ };
+
+ pub fn main() -> anyhow::Result<()> {
+ esp_idf_hal::sys::link_patches();
+
+ let peripherals = Peripherals::take()?;
+ let mut channel = peripherals.rmt.channel0;
+ let mut led = peripherals.pins.gpio17;
+ let stop = peripherals.pins.gpio16;
+
+ let carrier = CarrierConfig::new()
+ .duty_percent(DutyPercent::new(50)?)
+ .frequency(611.Hz());
+ let mut config = TransmitConfig::new()
+ .carrier(Some(carrier))
+ .looping(Loop::Endless)
+ .clock_divider(255);
+
+ let tx = send_morse_code(&mut channel, &mut led, &config, "HELLO ")?;
+
+ let stop = PinDriver::input(stop)?;
+
+ println!("Keep sending until pin {} is set low.", stop.pin());
+
+ while stop.is_high() {
+ Ets::delay_ms(100);
+ }
- // Release pin and channel so we can use them again.
- drop(tx);
+ println!("Pin {} set to low. Stopped.", stop.pin());
- // Wait so the messages don't get garbled.
- Ets::delay_ms(3000);
+ // Release pin and channel so we can use them again.
+ drop(tx);
- // Now send a single message and stop.
- println!("Saying GOODBYE!");
- config.looping = Loop::None;
- send_morse_code(channel, led, &config, "GOODBYE")?;
+ // Wait so the messages don't get garbled.
+ Ets::delay_ms(3000);
- Ok(())
-}
+ // Now send a single message and stop.
+ println!("Saying GOODBYE!");
+ config.looping = Loop::None;
+ send_morse_code(channel, led, &config, "GOODBYE")?;
-fn send_morse_code<'d>(
- channel: impl Peripheral + 'd,
- led: impl Peripheral
+ 'd,
- config: &TransmitConfig,
- message: &str,
-) -> anyhow::Result> {
- println!("Sending morse message '{message}'.");
-
- let mut signal = VariableLengthSignal::new();
- let pulses = str_pulses(message);
- // We've been collecting `Pulse` but `VariableLengthSignal` needs `&Pulse`:
- let pulses: Vec<&Pulse> = pulses.iter().collect();
- signal.push(pulses)?;
-
- let mut tx = TxRmtDriver::new(channel, led, config)?;
- tx.start(signal)?;
-
- // Return `tx` so we can release the pin and channel later.
- Ok(tx)
-}
-
-fn high() -> Pulse {
- Pulse::new(PinState::High, PulseTicks::max())
-}
+ Ok(())
+ }
-fn low() -> Pulse {
- Pulse::new(PinState::Low, PulseTicks::max())
-}
+ fn send_morse_code<'d>(
+ channel: impl Peripheral + 'd,
+ led: impl Peripheral
+ 'd,
+ config: &TransmitConfig,
+ message: &str,
+ ) -> anyhow::Result> {
+ println!("Sending morse message '{message}'.");
+
+ let mut signal = VariableLengthSignal::new();
+ let pulses = str_pulses(message);
+ // We've been collecting `Pulse` but `VariableLengthSignal` needs `&Pulse`:
+ let pulses: Vec<&Pulse> = pulses.iter().collect();
+ signal.push(pulses)?;
+
+ let mut tx = TxRmtDriver::new(channel, led, config)?;
+ tx.start(signal)?;
+
+ // Return `tx` so we can release the pin and channel later.
+ Ok(tx)
+ }
-enum Code {
- Dot,
- Dash,
- WordGap,
-}
+ enum Code {
+ Dot,
+ Dash,
+ WordGap,
+ }
-impl Code {
- pub fn push_pulse(&self, pulses: &mut Vec) {
- match &self {
- Code::Dot => pulses.extend_from_slice(&[high(), low()]),
- Code::Dash => pulses.extend_from_slice(&[high(), high(), high(), low()]),
- Code::WordGap => pulses.extend_from_slice(&[low(), low(), low(), low(), low(), low()]),
+ impl Code {
+ pub fn push_pulse(&self, pulses: &mut Vec) {
+ match &self {
+ Code::Dot => pulses.extend_from_slice(&[high(), low()]),
+ Code::Dash => pulses.extend_from_slice(&[high(), high(), high(), low()]),
+ Code::WordGap => {
+ pulses.extend_from_slice(&[low(), low(), low(), low(), low(), low()])
+ }
+ }
}
}
-}
-fn find_codes(c: &char) -> &'static [Code] {
- for (found, codes) in CODES.iter() {
- if found == c {
- return codes;
- }
+ fn high() -> Pulse {
+ Pulse::new(PinState::High, PulseTicks::max())
}
- &[]
-}
-fn str_pulses(s: &str) -> Vec {
- let mut pulses = vec![];
- for c in s.chars() {
- for code in find_codes(&c) {
- code.push_pulse(&mut pulses);
+ fn low() -> Pulse {
+ Pulse::new(PinState::Low, PulseTicks::max())
+ }
+
+ fn find_codes(c: &char) -> &'static [Code] {
+ for (found, codes) in CODES.iter() {
+ if found == c {
+ return codes;
+ }
}
+ &[]
+ }
+
+ fn str_pulses(s: &str) -> Vec {
+ let mut pulses = vec![];
+ for c in s.chars() {
+ for code in find_codes(&c) {
+ code.push_pulse(&mut pulses);
+ }
- // Create a gap after each symbol.
- pulses.push(low());
- pulses.push(low());
+ // Create a gap after each symbol.
+ pulses.push(low());
+ pulses.push(low());
+ }
+ pulses
}
- pulses
-}
-const CODES: &[(char, &[Code])] = &[
- (' ', &[Code::WordGap]),
- ('A', &[Code::Dot, Code::Dash]),
- ('B', &[Code::Dash, Code::Dot, Code::Dot, Code::Dot]),
- ('C', &[Code::Dash, Code::Dot, Code::Dash, Code::Dot]),
- ('D', &[Code::Dash, Code::Dot, Code::Dot]),
- ('E', &[Code::Dot]),
- ('F', &[Code::Dot, Code::Dot, Code::Dash, Code::Dot]),
- ('G', &[Code::Dash, Code::Dash, Code::Dot]),
- ('H', &[Code::Dot, Code::Dot, Code::Dot, Code::Dot]),
- ('I', &[Code::Dot, Code::Dot]),
- ('J', &[Code::Dot, Code::Dash, Code::Dash, Code::Dash]),
- ('K', &[Code::Dash, Code::Dot, Code::Dash]),
- ('L', &[Code::Dot, Code::Dash, Code::Dot, Code::Dot]),
- ('M', &[Code::Dash, Code::Dash]),
- ('N', &[Code::Dash, Code::Dot]),
- ('O', &[Code::Dash, Code::Dash, Code::Dash]),
- ('P', &[Code::Dot, Code::Dash, Code::Dash, Code::Dot]),
- ('Q', &[Code::Dash, Code::Dash, Code::Dot, Code::Dash]),
- ('R', &[Code::Dot, Code::Dash, Code::Dot]),
- ('S', &[Code::Dot, Code::Dot, Code::Dot]),
- ('T', &[Code::Dash]),
- ('U', &[Code::Dot, Code::Dot, Code::Dash]),
- ('V', &[Code::Dot, Code::Dot, Code::Dot, Code::Dash]),
- ('W', &[Code::Dot, Code::Dash, Code::Dash]),
- ('X', &[Code::Dash, Code::Dot, Code::Dot, Code::Dash]),
- ('Y', &[Code::Dash, Code::Dot, Code::Dash, Code::Dash]),
- ('Z', &[Code::Dash, Code::Dash, Code::Dot, Code::Dot]),
-];
+ const CODES: &[(char, &[Code])] = &[
+ (' ', &[Code::WordGap]),
+ ('A', &[Code::Dot, Code::Dash]),
+ ('B', &[Code::Dash, Code::Dot, Code::Dot, Code::Dot]),
+ ('C', &[Code::Dash, Code::Dot, Code::Dash, Code::Dot]),
+ ('D', &[Code::Dash, Code::Dot, Code::Dot]),
+ ('E', &[Code::Dot]),
+ ('F', &[Code::Dot, Code::Dot, Code::Dash, Code::Dot]),
+ ('G', &[Code::Dash, Code::Dash, Code::Dot]),
+ ('H', &[Code::Dot, Code::Dot, Code::Dot, Code::Dot]),
+ ('I', &[Code::Dot, Code::Dot]),
+ ('J', &[Code::Dot, Code::Dash, Code::Dash, Code::Dash]),
+ ('K', &[Code::Dash, Code::Dot, Code::Dash]),
+ ('L', &[Code::Dot, Code::Dash, Code::Dot, Code::Dot]),
+ ('M', &[Code::Dash, Code::Dash]),
+ ('N', &[Code::Dash, Code::Dot]),
+ ('O', &[Code::Dash, Code::Dash, Code::Dash]),
+ ('P', &[Code::Dot, Code::Dash, Code::Dash, Code::Dot]),
+ ('Q', &[Code::Dash, Code::Dash, Code::Dot, Code::Dash]),
+ ('R', &[Code::Dot, Code::Dash, Code::Dot]),
+ ('S', &[Code::Dot, Code::Dot, Code::Dot]),
+ ('T', &[Code::Dash]),
+ ('U', &[Code::Dot, Code::Dot, Code::Dash]),
+ ('V', &[Code::Dot, Code::Dot, Code::Dot, Code::Dash]),
+ ('W', &[Code::Dot, Code::Dash, Code::Dash]),
+ ('X', &[Code::Dash, Code::Dot, Code::Dot, Code::Dash]),
+ ('Y', &[Code::Dash, Code::Dot, Code::Dash, Code::Dash]),
+ ('Z', &[Code::Dash, Code::Dash, Code::Dot, Code::Dot]),
+ ];
+}
diff --git a/examples/rmt_musical_buzzer.rs b/examples/rmt_musical_buzzer.rs
index dee24a392e8..75ae4f43d80 100644
--- a/examples/rmt_musical_buzzer.rs
+++ b/examples/rmt_musical_buzzer.rs
@@ -4,166 +4,230 @@
//!
//! Based off the ESP-IDF rmt musical buzzer example:
//! https://github.com/espressif/esp-idf/blob/b092fa073047c957545a0ae9504f04972a8c6d74/examples/peripherals/rmt/musical_buzzer/main/musical_buzzer_example_main.c
-use core::time::Duration;
-use esp_idf_hal::delay::Ets;
-use esp_idf_hal::peripherals::Peripherals;
-use esp_idf_hal::rmt::config::{Loop, TransmitConfig};
-use esp_idf_hal::rmt::*;
-
-use notes::*;
+#![allow(unknown_lints)]
+#![allow(unexpected_cfgs)]
+#[cfg(any(feature = "rmt-legacy", esp_idf_version_major = "4"))]
fn main() -> anyhow::Result<()> {
- esp_idf_sys::link_patches();
+ example::main()
+}
- let peripherals = Peripherals::take().unwrap();
- let led = peripherals.pins.gpio17;
- let channel = peripherals.rmt.channel0;
- let config = TransmitConfig::new().looping(Loop::Endless);
- let mut tx: TxRmtDriver<'static> = TxRmtDriver::new(channel, led, &config)?;
+#[cfg(not(any(feature = "rmt-legacy", esp_idf_version_major = "4")))]
+fn main() -> anyhow::Result<()> {
+ println!("This example requires feature `rmt-legacy` enabled or using ESP-IDF v4.4.X");
loop {
- play_song(&mut tx, ODE_TO_JOY)?;
- Ets::delay_ms(3000);
+ std::thread::sleep(std::time::Duration::from_millis(1000));
}
}
-pub fn play_song(tx: &mut TxRmtDriver<'static>, song: &[NoteValue]) -> anyhow::Result<()> {
- for note_value in song {
- play_note(tx, note_value.note.0, note_value.duration)?;
+#[cfg(any(feature = "rmt-legacy", esp_idf_version_major = "4"))]
+mod example {
+ use std::time::Duration;
+
+ use esp_idf_hal::delay::Ets;
+ use esp_idf_hal::{
+ prelude::Peripherals,
+ rmt::{self, config::TransmitConfig, TxRmtDriver},
+ units::Hertz,
+ };
+ use notes::*;
+
+ pub fn main() -> anyhow::Result<()> {
+ esp_idf_hal::sys::link_patches();
+
+ let peripherals = Peripherals::take()?;
+ let led = peripherals.pins.gpio17;
+ let channel = peripherals.rmt.channel0;
+ let config = TransmitConfig::new();
+ let mut tx: TxRmtDriver<'static> = TxRmtDriver::new(channel, led, &config)?;
+
+ loop {
+ play_song(&mut tx, ODE_TO_JOY)?;
+ Ets::delay_ms(3000);
+ }
}
- Ok(())
-}
-pub fn play_note(
- tx: &mut TxRmtDriver<'static>,
- pitch: u16,
- duration: Duration,
-) -> anyhow::Result<()> {
- // Calculate the frequency for a piezo buzzer.
- let ticks_hz = tx.counter_clock()?;
- let tick_count = (ticks_hz.0 as u128 / pitch as u128 / 2_u128) as u16;
- let ticks = PulseTicks::new(tick_count)?;
-
- // Add high and low pulses for the tick duration.
- let on = Pulse::new(PinState::High, ticks);
- let off = Pulse::new(PinState::Low, ticks);
- let mut signal = FixedLengthSignal::<1>::new();
- signal.set(0, &(on, off))?;
-
- // Play the note for the 80% of the duration.
- tx.start(signal)?;
- Ets::delay_ms((80 * duration.as_millis() / 100) as u32);
-
- // Small pause between notes, 20% of the specified duration.
- tx.stop()?;
- Ets::delay_ms((20 * duration.as_millis() / 100) as u32);
-
- Ok(())
-}
+ pub fn play_song(tx: &mut TxRmtDriver<'static>, song: &[NoteValue]) -> anyhow::Result<()> {
+ for note_value in song {
+ note_value.play(tx)?;
+ }
+ Ok(())
+ }
-#[derive(Debug)]
-pub struct Note(u16);
+ pub struct NoteValueIter {
+ ticks: rmt::PulseTicks,
+ tone_cycles: u32,
+ pause_cycles: u32,
+ }
-pub mod notes {
- use crate::Note;
+ impl NoteValueIter {
+ fn new(ticks_per_sec: Hertz, note: &NoteValue) -> Self {
+ // Calculate the frequency for a piezo buzzer.
+ let dur_ms = note.duration.as_millis();
+ let cycles_per_sec = note.note.0; // pitch
+ let ticks_per_cycle = ticks_per_sec.0 as u128 / cycles_per_sec as u128;
+ let ticks_per_half = (ticks_per_cycle / 2_u128) as u16;
+ let ticks = rmt::PulseTicks::new(ticks_per_half).unwrap();
+
+ let total_cycles = (cycles_per_sec as u128 * dur_ms / 1000_u128) as u32;
+ // Pause for the last 40ms of every note
+ let pause_cycles = (cycles_per_sec as u128 * 40_u128 / 1000_u128) as u32;
+ let tone_cycles = total_cycles - pause_cycles;
+
+ Self {
+ ticks,
+ tone_cycles,
+ pause_cycles,
+ }
+ }
+ }
+
+ impl std::iter::Iterator for NoteValueIter {
+ type Item = rmt::Symbol;
+
+ // runs in ISR
+ fn next(&mut self) -> Option {
+ if self.tone_cycles + self.pause_cycles > 0 {
+ let high_state = if self.tone_cycles > 0 {
+ self.tone_cycles -= 1;
+ rmt::PinState::High
+ } else {
+ self.pause_cycles -= 1;
+ rmt::PinState::Low
+ };
+ let level0 = rmt::Pulse::new(high_state, self.ticks);
+ let level1 = rmt::Pulse::new(rmt::PinState::Low, self.ticks);
+ Some(rmt::Symbol::new(level0, level1))
+ } else {
+ None
+ }
+ }
+ }
+
+ #[derive(Debug)]
+ pub struct Note(u16);
#[allow(dead_code)]
- pub const A4: Note = Note(440);
- pub const AS4: Note = Note(466);
- pub const B4: Note = Note(494);
- pub const C5: Note = Note(523);
- pub const CS5: Note = Note(554);
- pub const D5: Note = Note(587);
- pub const DS5: Note = Note(622);
- pub const E5: Note = Note(659);
- pub const F5: Note = Note(698);
- pub const FS5: Note = Note(740);
- pub const G5: Note = Note(784);
- pub const GS5: Note = Note(831);
- pub const A5: Note = Note(880);
-}
+ pub mod notes {
+ use super::Note;
+
+ pub const A4: Note = Note(440);
+ pub const AS4: Note = Note(466);
+ pub const B4: Note = Note(494);
+ pub const C5: Note = Note(523);
+ pub const CS5: Note = Note(554);
+ pub const D5: Note = Note(587);
+ pub const DS5: Note = Note(622);
+ pub const E5: Note = Note(659);
+ pub const F5: Note = Note(698);
+ pub const FS5: Note = Note(740);
+ pub const G5: Note = Note(784);
+ pub const GS5: Note = Note(831);
+ pub const A5: Note = Note(880);
+ }
-#[derive(Debug)]
-pub struct NoteValue {
- note: Note,
- duration: Duration,
-}
+ #[derive(Debug)]
+ pub struct NoteValue {
+ note: Note,
+ duration: Duration,
+ }
-macro_rules! n {
- ($n: expr, $duration: expr) => {
- NoteValue {
- note: $n,
- duration: Duration::from_millis($duration),
+ impl NoteValue {
+ pub fn play(&self, tx: &mut TxRmtDriver<'static>) -> anyhow::Result<()> {
+ let ticks_hz = tx.counter_clock()?;
+ tx.start_iter_blocking(self.iter(ticks_hz))?;
+ Ok(())
}
- };
+
+ pub fn iter(&self, ticks_hz: Hertz) -> NoteValueIter {
+ NoteValueIter::new(ticks_hz, self)
+ }
+ }
+
+ macro_rules! n {
+ ($n: expr, $duration: expr) => {
+ NoteValue {
+ note: $n,
+ duration: Duration::from_millis($duration),
+ }
+ };
+ }
+
+ const ODE_TO_JOY: &[NoteValue] = &[
+ n!(FS5, 400),
+ n!(FS5, 600),
+ n!(G5, 400),
+ n!(A5, 400),
+ n!(A5, 400),
+ n!(G5, 400),
+ n!(FS5, 400),
+ n!(E5, 400),
+ n!(D5, 400),
+ n!(D5, 400),
+ n!(E5, 400),
+ n!(FS5, 400),
+ n!(FS5, 400),
+ n!(FS5, 200),
+ n!(E5, 200),
+ n!(E5, 800),
+ n!(FS5, 400),
+ n!(FS5, 600),
+ n!(G5, 400),
+ n!(A5, 400),
+ n!(A5, 400),
+ n!(G5, 400),
+ n!(FS5, 400),
+ n!(E5, 400),
+ n!(D5, 400),
+ n!(D5, 400),
+ n!(E5, 400),
+ n!(FS5, 400),
+ n!(E5, 400),
+ n!(E5, 200),
+ n!(D5, 200),
+ n!(D5, 800),
+ n!(E5, 400),
+ n!(E5, 400),
+ n!(FS5, 400),
+ n!(D5, 400),
+ n!(E5, 400),
+ n!(FS5, 200),
+ n!(G5, 200),
+ n!(FS5, 400),
+ n!(D5, 400),
+ n!(E5, 400),
+ n!(FS5, 200),
+ n!(G5, 200),
+ n!(FS5, 400),
+ n!(E5, 400),
+ n!(D5, 400),
+ n!(E5, 400),
+ n!(A4, 400),
+ n!(A4, 400),
+ n!(FS5, 400),
+ n!(FS5, 600),
+ n!(G5, 400),
+ n!(A5, 400),
+ n!(A5, 400),
+ n!(G5, 400),
+ n!(FS5, 400),
+ n!(E5, 400),
+ n!(D5, 400),
+ n!(D5, 400),
+ n!(E5, 400),
+ n!(FS5, 400),
+ n!(E5, 400),
+ n!(E5, 200),
+ n!(D5, 200),
+ n!(D5, 800),
+ ];
}
-const ODE_TO_JOY: &[NoteValue] = &[
- n!(FS5, 400),
- n!(FS5, 600),
- n!(G5, 400),
- n!(A5, 400),
- n!(A5, 400),
- n!(G5, 400),
- n!(FS5, 400),
- n!(E5, 400),
- n!(D5, 400),
- n!(D5, 400),
- n!(E5, 400),
- n!(FS5, 400),
- n!(FS5, 400),
- n!(FS5, 200),
- n!(E5, 200),
- n!(E5, 800),
- n!(FS5, 400),
- n!(FS5, 600),
- n!(G5, 400),
- n!(A5, 400),
- n!(A5, 400),
- n!(G5, 400),
- n!(FS5, 400),
- n!(E5, 400),
- n!(D5, 400),
- n!(D5, 400),
- n!(E5, 400),
- n!(FS5, 400),
- n!(E5, 400),
- n!(E5, 200),
- n!(D5, 200),
- n!(D5, 800),
- n!(E5, 400),
- n!(E5, 400),
- n!(FS5, 400),
- n!(D5, 400),
- n!(E5, 400),
- n!(FS5, 200),
- n!(G5, 200),
- n!(FS5, 400),
- n!(D5, 400),
- n!(E5, 400),
- n!(FS5, 200),
- n!(G5, 200),
- n!(FS5, 400),
- n!(E5, 400),
- n!(D5, 400),
- n!(E5, 400),
- n!(A4, 400),
- n!(A4, 400),
- n!(FS5, 400),
- n!(FS5, 600),
- n!(G5, 400),
- n!(A5, 400),
- n!(A5, 400),
- n!(G5, 400),
- n!(FS5, 400),
- n!(E5, 400),
- n!(D5, 400),
- n!(D5, 400),
- n!(E5, 400),
- n!(FS5, 400),
- n!(E5, 400),
- n!(E5, 200),
- n!(D5, 200),
- n!(D5, 800),
-];
+// #[cfg(any(feature = "rmt-legacy", esp_idf_version_major = "4"))]
+// #[cfg(any(feature = "rmt-legacy", esp_idf_version_major = "4"))]
+// #[cfg(any(feature = "rmt-legacy", esp_idf_version_major = "4"))]
+// #[cfg(any(feature = "rmt-legacy", esp_idf_version_major = "4"))]
+// #[allow(dead_code)]
+// #[cfg(any(feature = "rmt-legacy", esp_idf_version_major = "4"))]
diff --git a/examples/rmt_neopixel.rs b/examples/rmt_neopixel.rs
index 1de75a8a23c..70e8171716e 100644
--- a/examples/rmt_neopixel.rs
+++ b/examples/rmt_neopixel.rs
@@ -1,7 +1,5 @@
//! A simple example to change colours of a WS2812/NeoPixel compatible LED.
//!
-//! It is set to pin 18 which some dev boards have connected to a compatible LED.
-//!
//! This example demonstrates the use of [`FixedLengthSignal`][crate::rmt::FixedLengthSignal] which
//! lives on the stack and requires a known length before creating it.
//!
@@ -11,43 +9,122 @@
//! Datasheet (PDF) for a WS2812, which explains how the pulses are to be sent:
//! https://cdn-shop.adafruit.com/datasheets/WS2812.pdf
-use core::time::Duration;
-
-use esp_idf_hal::delay::Ets;
-use esp_idf_hal::peripherals::Peripherals;
-use esp_idf_hal::rmt::config::TransmitConfig;
-use esp_idf_hal::rmt::*;
+#![allow(unknown_lints)]
+#![allow(unexpected_cfgs)]
+#[cfg(any(feature = "rmt-legacy", esp_idf_version_major = "4"))]
fn main() -> anyhow::Result<()> {
- esp_idf_sys::link_patches();
+ example::main()
+}
- let peripherals = Peripherals::take().unwrap();
- let led = peripherals.pins.gpio18;
- let channel = peripherals.rmt.channel0;
- let config = TransmitConfig::new().clock_divider(1);
- let mut tx = TxRmtDriver::new(channel, led, &config)?;
+#[cfg(not(any(feature = "rmt-legacy", esp_idf_version_major = "4")))]
+fn main() -> anyhow::Result<()> {
+ println!("This example requires feature `rmt-legacy` enabled or using ESP-IDF v4.4.X");
- let rgbs = [0xff0000, 0xffff00, 0x00ffff, 0x00ff00, 0xa000ff];
loop {
- for rgb in rgbs {
- let ticks_hz = tx.counter_clock()?;
- let t0h = Pulse::new_with_duration(ticks_hz, PinState::High, &ns(350))?;
- let t0l = Pulse::new_with_duration(ticks_hz, PinState::Low, &ns(800))?;
- let t1h = Pulse::new_with_duration(ticks_hz, PinState::High, &ns(700))?;
- let t1l = Pulse::new_with_duration(ticks_hz, PinState::Low, &ns(600))?;
-
- let mut signal = FixedLengthSignal::<24>::new();
- for i in 0..24 {
- let bit = 2_u32.pow(i) & rgb != 0;
- let (high_pulse, low_pulse) = if bit { (t1h, t1l) } else { (t0h, t0l) };
- signal.set(i as usize, &(high_pulse, low_pulse))?;
+ std::thread::sleep(std::time::Duration::from_millis(1000));
+ }
+}
+
+#[cfg(any(feature = "rmt-legacy", esp_idf_version_major = "4"))]
+mod example {
+ use std::time::Duration;
+
+ use anyhow::{bail, Result};
+ use esp_idf_hal::{
+ delay::FreeRtos,
+ prelude::Peripherals,
+ rmt::{config::TransmitConfig, FixedLengthSignal, PinState, Pulse, TxRmtDriver},
+ };
+
+ pub fn main() -> Result<()> {
+ esp_idf_hal::sys::link_patches();
+
+ let peripherals = Peripherals::take()?;
+ // Onboard RGB LED pin
+ // ESP32-C3-DevKitC-02 gpio8, ESP32-C3-DevKit-RUST-1 gpio2
+ let led = peripherals.pins.gpio2;
+ let channel = peripherals.rmt.channel0;
+ let config = TransmitConfig::new().clock_divider(1);
+ let mut tx = TxRmtDriver::new(channel, led, &config)?;
+
+ // 3 seconds white at 10% brightness
+ neopixel(Rgb::new(25, 25, 25), &mut tx)?;
+ FreeRtos::delay_ms(3000);
+
+ // infinite rainbow loop at 20% brightness
+ (0..360).cycle().try_for_each(|hue| {
+ FreeRtos::delay_ms(10);
+ let rgb = Rgb::from_hsv(hue, 100, 20)?;
+ neopixel(rgb, &mut tx)
+ })
+ }
+
+ fn neopixel(rgb: Rgb, tx: &mut TxRmtDriver) -> Result<()> {
+ let color: u32 = rgb.into();
+ let ticks_hz = tx.counter_clock()?;
+ let (t0h, t0l, t1h, t1l) = (
+ Pulse::new_with_duration(ticks_hz, PinState::High, &Duration::from_nanos(350))?,
+ Pulse::new_with_duration(ticks_hz, PinState::Low, &Duration::from_nanos(800))?,
+ Pulse::new_with_duration(ticks_hz, PinState::High, &Duration::from_nanos(700))?,
+ Pulse::new_with_duration(ticks_hz, PinState::Low, &Duration::from_nanos(600))?,
+ );
+ let mut signal = FixedLengthSignal::<24>::new();
+ for i in (0..24).rev() {
+ let p = 2_u32.pow(i);
+ let bit: bool = p & color != 0;
+ let (high_pulse, low_pulse) = if bit { (t1h, t1l) } else { (t0h, t0l) };
+ signal.set(23 - i as usize, &(high_pulse, low_pulse))?;
+ }
+ tx.start_blocking(&signal)?;
+ Ok(())
+ }
+
+ struct Rgb {
+ r: u8,
+ g: u8,
+ b: u8,
+ }
+
+ impl Rgb {
+ pub fn new(r: u8, g: u8, b: u8) -> Self {
+ Self { r, g, b }
+ }
+ /// Converts hue, saturation, value to RGB
+ pub fn from_hsv(h: u32, s: u32, v: u32) -> Result {
+ if h > 360 || s > 100 || v > 100 {
+ bail!("The given HSV values are not in valid range");
}
- tx.start_blocking(&signal)?;
- Ets::delay_ms(1000);
+ let s = s as f64 / 100.0;
+ let v = v as f64 / 100.0;
+ let c = s * v;
+ let x = c * (1.0 - (((h as f64 / 60.0) % 2.0) - 1.0).abs());
+ let m = v - c;
+ let (r, g, b) = match h {
+ 0..=59 => (c, x, 0.0),
+ 60..=119 => (x, c, 0.0),
+ 120..=179 => (0.0, c, x),
+ 180..=239 => (0.0, x, c),
+ 240..=299 => (x, 0.0, c),
+ _ => (c, 0.0, x),
+ };
+ Ok(Self {
+ r: ((r + m) * 255.0) as u8,
+ g: ((g + m) * 255.0) as u8,
+ b: ((b + m) * 255.0) as u8,
+ })
}
}
-}
-fn ns(nanos: u64) -> Duration {
- Duration::from_nanos(nanos)
+ impl From for u32 {
+ /// Convert RGB to u32 color value
+ ///
+ /// e.g. rgb: (1,2,4)
+ /// G R B
+ /// 7 0 7 0 7 0
+ /// 00000010 00000001 00000100
+ fn from(rgb: Rgb) -> Self {
+ ((rgb.g as u32) << 16) | ((rgb.r as u32) << 8) | rgb.b as u32
+ }
+ }
}
diff --git a/examples/rmt_onewire_temperature.rs b/examples/rmt_onewire_temperature.rs
new file mode 100644
index 00000000000..594d0d5ce57
--- /dev/null
+++ b/examples/rmt_onewire_temperature.rs
@@ -0,0 +1,175 @@
+//! RMT Onewire Example
+//!
+//! Example demonstrating the use of the onewire component to measure temperature from the ds18b20 temperature probe.
+//!
+//! In order to use this example, an overidden `Cargo.toml` must be defined with the following definitions:
+//! ```
+//! [[package.metadata.esp-idf-sys.extra_components]]
+//! remote_component = { name = "onewire_bus", version = "^1.0.2" }
+//!
+//!
+//! [patch.crates-io]
+//! esp-idf-sys = { git = "https://github.com/esp-rs/esp-idf-sys", rev = "2728b85" }
+//!
+//! ```
+//!
+//! The example can then be run with
+//! `MCU= cargo run --example rmt_onewire --manifest-path /path/to/other/Cargo.toml`
+//!
+//! Below is a connection sketch, the signal pin must be externally pulled-up
+//! with a 4.7kOhm resistor.
+//! This example uses gpio 16, but any pin capable of
+//! input AND output is suitable.
+//!
+//! If the example is successful, it should print the address of each
+//! onewire device attached to the bus.
+//!
+//! ┌──────────────────────────┐
+//! │ 3.3V├───────┬─────────────┬──────────────────────┐
+//! │ │ ┌┴┐ │VDD │VDD
+//! │ ESP Board │ 4.7k│ │ ┌──────┴──────┐ ┌──────┴──────┐
+//! │ │ └┬┘ DQ│ │ DQ│ │
+//! │ ONEWIRE_GPIO_PIN├───────┴──┬───┤ DS18B20 │ ┌───┤ DS18B20 │ ......
+//! │ │ └───│-------------│────┴───│-------------│──
+//! │ │ └──────┬──────┘ └──────┬──────┘
+//! │ │ │GND │GND
+//! │ GND├─────────────────────┴──────────────────────┘
+//! └──────────────────────────┘
+//!
+//!
+//! This example demonstrates:
+//! * A RMT device in both TX and RX mode.
+//! * Usage of the onewire bus driver interface.
+//! * How to iterate through a device search to discover devices on the bus.
+
+#![allow(unknown_lints)]
+#![allow(unexpected_cfgs)]
+
+#[cfg(all(
+ esp_idf_soc_rmt_supported,
+ not(feature = "rmt-legacy"),
+ esp_idf_comp_espressif__onewire_bus_enabled,
+))]
+use esp_idf_hal::onewire::{OWAddress, OWCommand, OWDriver};
+
+#[cfg(all(
+ esp_idf_soc_rmt_supported,
+ not(esp_idf_version_major = "4"),
+ esp_idf_comp_espressif__onewire_bus_enabled,
+))]
+fn main() -> anyhow::Result<()> {
+ use esp_idf_hal::delay::FreeRtos;
+ use esp_idf_hal::peripherals::Peripherals;
+ use esp_idf_hal::sys::EspError;
+ use std::time::Duration;
+
+ println!("Starting APP!");
+
+ let peripherals = Peripherals::take()?;
+
+ let channel = peripherals.rmt.channel0;
+ let onewire_gpio_pin = peripherals.pins.gpio16;
+
+ let mut onewire_bus: OWDriver = OWDriver::new(onewire_gpio_pin, channel)?;
+ let device = {
+ let mut search = onewire_bus.search()?;
+ search.next()
+ };
+
+ if device.is_none() {
+ println!("No device found");
+ return Ok(());
+ }
+
+ let device = device.unwrap();
+ if let Err(err) = device {
+ println!("An error occured searching for the device, err = {}", err);
+ return Err(err.into());
+ }
+ let device = device.unwrap();
+ println!(
+ "Found Device: {:?}, family code = {}",
+ device,
+ device.family_code()
+ );
+
+ loop {
+ ds18b20_trigger_temp_conversion(&device, &onewire_bus)?;
+ let temp = ds18b20_get_temperature(&device, &onewire_bus)?;
+ println!("Temperature: {}", temp);
+ FreeRtos::delay_ms(3000);
+ }
+}
+
+#[cfg(any(
+ feature = "rmt-legacy",
+ esp_idf_version_major = "4",
+ not(esp_idf_comp_espressif__onewire_bus_enabled),
+ not(esp_idf_soc_rmt_supported),
+))]
+fn main() -> anyhow::Result<()> {
+ println!("This example requires feature `rmt-legacy` disabled, using ESP-IDF > v4.4.X, the component included in `Cargo.toml`, or is not supported on this MCU");
+
+ loop {
+ std::thread::sleep(std::time::Duration::from_millis(1000));
+ }
+}
+
+#[cfg(all(
+ esp_idf_soc_rmt_supported,
+ not(esp_idf_version_major = "4"),
+ esp_idf_comp_espressif__onewire_bus_enabled,
+))]
+fn ds18b20_send_command<'a>(addr: &OWAddress, bus: &OWDriver, cmd: u8) -> Result<(), EspError> {
+ let mut buf = [0; 10];
+ buf[0] = OWCommand::MatchRom as _;
+ let addr = addr.address().to_le_bytes();
+ buf[1..9].copy_from_slice(&addr);
+ buf[9] = cmd;
+
+ bus.write(&buf)
+}
+
+#[allow(dead_code)]
+#[repr(u8)]
+enum Ds18b20Command {
+ ConvertTemp = 0x44,
+ WriteScratch = 0x4E,
+ ReadScratch = 0xBE,
+}
+#[cfg(all(
+ esp_idf_soc_rmt_supported,
+ not(esp_idf_version_major = "4"),
+ esp_idf_comp_espressif__onewire_bus_enabled,
+))]
+fn ds18b20_trigger_temp_conversion<'a>(addr: &OWAddress, bus: &OWDriver) -> Result<(), EspError> {
+ // reset bus and check if the ds18b20 is present
+ bus.reset()?;
+
+ ds18b20_send_command(addr, bus, Ds18b20Command::ConvertTemp as u8)?;
+
+ // delay proper time for temp conversion,
+ // assume max resolution (12-bits)
+ std::thread::sleep(Duration::from_millis(800));
+
+ Ok(())
+}
+#[cfg(all(
+ esp_idf_soc_rmt_supported,
+ not(esp_idf_version_major = "4"),
+ esp_idf_comp_espressif__onewire_bus_enabled,
+))]
+fn ds18b20_get_temperature<'a>(addr: &OWAddress, bus: &OWDriver) -> Result {
+ bus.reset()?;
+
+ ds18b20_send_command(addr, bus, Ds18b20Command::ReadScratch as u8)?;
+
+ let mut buf = [0u8; 9];
+ bus.read(&mut buf)?;
+ let lsb = buf[0];
+ let msb = buf[1];
+
+ let temp_raw: u16 = (u16::from(msb) << 8) | u16::from(lsb);
+
+ Ok(f32::from(temp_raw) / 16.0)
+}
diff --git a/examples/rmt_transceiver.rs b/examples/rmt_transceiver.rs
index 396a4bdd27b..b9b6fa87a8d 100644
--- a/examples/rmt_transceiver.rs
+++ b/examples/rmt_transceiver.rs
@@ -18,92 +18,112 @@
//! level0 = High dur0 = PulseTicks(210) level1 = Low dur1 = PulseTicks(0)
//! Tx Loop
-use esp_idf_sys::{self as _}; // If using the `binstart` feature of `esp-idf-sys`, always keep this module imported
-
-use esp_idf_hal::delay::FreeRtos;
-use esp_idf_hal::peripherals::Peripherals;
-use esp_idf_hal::rmt::{
- FixedLengthSignal, PinState, Pulse, PulseTicks, Receive, RmtReceiveConfig, RmtTransmitConfig,
- RxRmtDriver, TxRmtDriver,
-};
+#![allow(unknown_lints)]
+#![allow(unexpected_cfgs)]
+#[cfg(any(feature = "rmt-legacy", esp_idf_version_major = "4"))]
fn main() -> anyhow::Result<()> {
- println!("Starting APP!");
-
- let peripherals = Peripherals::take().unwrap();
-
- /*
- *********************** SET UP RMT RECEIVER ******************************
- */
- let mut rx = RxRmtDriver::new(
- peripherals.rmt.channel2,
- peripherals.pins.gpio2,
- &RmtReceiveConfig::new().idle_threshold(700u16),
- 250,
- )?;
-
- rx.start().unwrap();
-
- let _ = std::thread::Builder::new()
- .stack_size(10000)
- .spawn(move || loop {
- println!("Rx Loop");
-
- let mut pulses = [(Pulse::zero(), Pulse::zero()); 250];
+ example::main()
+}
- // See sdkconfig.defaults to determine the tick time value ( default is one tick = 10 milliseconds)
- // Set ticks_to_wait to 0 for non-blocking
- let receive = rx.receive(&mut pulses, 0).unwrap();
+#[cfg(not(any(feature = "rmt-legacy", esp_idf_version_major = "4")))]
+fn main() -> anyhow::Result<()> {
+ println!("This example requires feature `rmt-legacy` enabled or using ESP-IDF v4.4.X");
- if let Receive::Read(length) = receive {
- let pulses = &pulses[..length];
+ loop {
+ std::thread::sleep(std::time::Duration::from_millis(1000));
+ }
+}
- for (pulse0, pulse1) in pulses {
- println!("0={pulse0:?}, 1={pulse1:?}");
+#[cfg(any(feature = "rmt-legacy", esp_idf_version_major = "4"))]
+mod example {
+ use esp_idf_hal::{
+ delay::FreeRtos,
+ prelude::Peripherals,
+ rmt::{
+ FixedLengthSignal, PinState, Pulse, PulseTicks, Receive, RmtReceiveConfig,
+ RmtTransmitConfig, RxRmtDriver, TxRmtDriver,
+ },
+ };
+
+ pub fn main() -> anyhow::Result<()> {
+ println!("Starting APP!");
+
+ let peripherals = Peripherals::take()?;
+
+ /*
+ *********************** SET UP RMT RECEIVER ******************************
+ */
+ let mut rx = RxRmtDriver::new(
+ peripherals.rmt.channel2,
+ peripherals.pins.gpio2,
+ &RmtReceiveConfig::new().idle_threshold(700u16),
+ 250,
+ )?;
+
+ rx.start()?;
+
+ let _ = std::thread::Builder::new()
+ .stack_size(10000)
+ .spawn(move || loop {
+ println!("Rx Loop");
+
+ let mut pulses = [(Pulse::zero(), Pulse::zero()); 250];
+
+ // See sdkconfig.defaults to determine the tick time value ( default is one tick = 10 milliseconds)
+ // Set ticks_to_wait to 0 for non-blocking
+ let receive = rx.receive(&mut pulses, 0).unwrap();
+
+ if let Receive::Read(length) = receive {
+ let pulses = &pulses[..length];
+
+ for (pulse0, pulse1) in pulses {
+ println!("0={pulse0:?}, 1={pulse1:?}");
+ }
}
- }
- FreeRtos::delay_ms(500);
+ FreeRtos::delay_ms(500);
+ });
+
+ /*
+ *********************** SET UP RMT TRANSMITTER ******************************
+ */
+
+ // Prepare the tx_config
+ // The default uses one memory block or 64 signals and clock divider set to 80 (1us tick)
+ let mut tx = TxRmtDriver::new(
+ peripherals.rmt.channel0,
+ peripherals.pins.gpio4,
+ &RmtTransmitConfig::new(),
+ )?;
+
+ // Prepare signal pulse signal to be sent.
+ let one_low = Pulse::new(PinState::Low, PulseTicks::new(410)?);
+ let one_high = Pulse::new(PinState::High, PulseTicks::new(210)?);
+ let zero_low = Pulse::new(PinState::Low, PulseTicks::new(210)?);
+ let zero_high = Pulse::new(PinState::High, PulseTicks::new(410)?);
+ let sync_low = Pulse::new(PinState::Low, PulseTicks::new(620)?);
+ let sync_high = Pulse::new(PinState::High, PulseTicks::new(620)?);
+
+ let _ = std::thread::spawn(move || loop {
+ println!("Tx Loop");
+
+ // Create a sequence
+ let mut signal = FixedLengthSignal::<5>::new();
+ signal.set(0, &(sync_high, sync_low)).unwrap();
+ signal.set(1, &(sync_high, sync_low)).unwrap();
+ signal.set(2, &(one_high, one_low)).unwrap();
+ signal.set(3, &(zero_high, zero_low)).unwrap();
+ signal.set(4, &(one_high, one_low)).unwrap();
+
+ // Transmit the signal (send sequence)
+ tx.start(signal).unwrap();
+
+ FreeRtos::delay_ms(1000);
});
- /*
- *********************** SET UP RMT TRANSMITTER ******************************
- */
-
- // Prepare the tx_config
- // The default uses one memory block or 64 signals and clock divider set to 80 (1us tick)
- let mut tx = TxRmtDriver::new(
- peripherals.rmt.channel0,
- peripherals.pins.gpio4,
- &RmtTransmitConfig::new(),
- )?;
-
- // Prepare signal pulse signal to be sent.
- let one_low = Pulse::new(PinState::Low, PulseTicks::new(410)?);
- let one_high = Pulse::new(PinState::High, PulseTicks::new(210)?);
- let zero_low = Pulse::new(PinState::Low, PulseTicks::new(210)?);
- let zero_high = Pulse::new(PinState::High, PulseTicks::new(410)?);
- let sync_low = Pulse::new(PinState::Low, PulseTicks::new(620)?);
- let sync_high = Pulse::new(PinState::High, PulseTicks::new(620)?);
-
- let _ = std::thread::spawn(move || loop {
- println!("Tx Loop");
-
- // Create a sequence
- let mut signal = FixedLengthSignal::<5>::new();
- signal.set(0, &(sync_high, sync_low)).unwrap();
- signal.set(1, &(sync_high, sync_low)).unwrap();
- signal.set(2, &(one_high, one_low)).unwrap();
- signal.set(3, &(zero_high, zero_low)).unwrap();
- signal.set(4, &(one_high, one_low)).unwrap();
-
- // Transmit the signal (send sequence)
- tx.start(signal).unwrap();
-
- FreeRtos::delay_ms(1000);
- });
-
- loop {
- FreeRtos::delay_ms(3000);
+ loop {
+ FreeRtos::delay_ms(3000);
+ }
}
}
diff --git a/examples/spi_loopback.rs b/examples/spi_loopback.rs
index 75c98efdf87..c58c85716ff 100644
--- a/examples/spi_loopback.rs
+++ b/examples/spi_loopback.rs
@@ -18,20 +18,26 @@ use esp_idf_hal::prelude::*;
use esp_idf_hal::spi::*;
fn main() -> anyhow::Result<()> {
- esp_idf_sys::link_patches();
+ esp_idf_hal::sys::link_patches();
- let peripherals = Peripherals::take().unwrap();
+ let peripherals = Peripherals::take()?;
let spi = peripherals.spi2;
- let sclk = peripherals.pins.gpio6;
- let serial_in = peripherals.pins.gpio2; // SDI
- let serial_out = peripherals.pins.gpio7; // SDO
- let cs_1 = peripherals.pins.gpio10;
- let cs_2 = peripherals.pins.gpio3;
+ let sclk = peripherals.pins.gpio15;
+ let serial_in = peripherals.pins.gpio16; // SDI
+ let serial_out = peripherals.pins.gpio17; // SDO
+ let cs_1 = peripherals.pins.gpio18;
+ let cs_2 = peripherals.pins.gpio19;
println!("Starting SPI loopback test");
- let driver = SpiDriver::new::(spi, sclk, serial_out, Some(serial_in), Dma::Disabled)?;
+ let driver = SpiDriver::new::(
+ spi,
+ sclk,
+ serial_out,
+ Some(serial_in),
+ &SpiDriverConfig::new(),
+ )?;
let config_1 = config::Config::new().baudrate(26.MHz().into());
let mut device_1 = SpiDeviceDriver::new(&driver, Some(cs_1), &config_1)?;
@@ -42,16 +48,23 @@ fn main() -> anyhow::Result<()> {
let mut read = [0u8; 4];
let write = [0xde, 0xad, 0xbe, 0xef];
- let mut in_place_buf = [0xde, 0xad, 0xbe, 0xef];
-
loop {
// we are using thread::sleep here to make sure the watchdog isn't triggered
FreeRtos::delay_ms(500);
device_1.transfer(&mut read, &write)?;
println!("Device 1: Wrote {write:x?}, read {read:x?}");
- println!("Device 2: To write {in_place_buf:x?} ... ");
- device_2.transaction(|bus| bus.transfer_in_place(&mut in_place_buf))?;
- println!("... read {in_place_buf:x?}");
+ let write_buf = [0xde, 0xad, 0xbe, 0xef];
+ let mut write_in_place_buf = [0xde, 0xad, 0xbe, 0xef];
+ let mut read_buf = [0; 8];
+
+ println!("Device 2: To write {write_in_place_buf:x?} ... ");
+ // cascade multiple operations with different buffer length into one transaction
+ device_2.transaction(&mut [
+ Operation::Write(&write_buf),
+ Operation::TransferInPlace(&mut write_in_place_buf),
+ Operation::Read(&mut read_buf),
+ ])?;
+ println!("... read {write_in_place_buf:x?}");
}
}
diff --git a/examples/spi_loopback_async.rs b/examples/spi_loopback_async.rs
new file mode 100644
index 00000000000..f19d94846e5
--- /dev/null
+++ b/examples/spi_loopback_async.rs
@@ -0,0 +1,72 @@
+//! SPI loopback test
+//!
+//! Folowing pins are used:
+//! SCLK GPIO6
+//! SDI GPIO2
+//! SDO GPIO7
+//! CS_1 GPIO10
+//! CS_2 GPIO3
+//!
+//! Depending on your target and the board you are using you have to change the pins.
+//!
+//! This example transfers data via SPI.
+//! Connect SDI and SDO pins to see the outgoing data is read as incoming data.
+
+use esp_idf_hal::peripherals::Peripherals;
+use esp_idf_hal::prelude::*;
+use esp_idf_hal::spi::*;
+use esp_idf_hal::task::*;
+
+fn main() -> anyhow::Result<()> {
+ esp_idf_hal::sys::link_patches();
+
+ let peripherals = Peripherals::take()?;
+ let spi = peripherals.spi2;
+
+ let sclk = peripherals.pins.gpio15;
+ let serial_in = peripherals.pins.gpio16; // SDI
+ let serial_out = peripherals.pins.gpio17; // SDO
+ let cs_1 = peripherals.pins.gpio18;
+ let cs_2 = peripherals.pins.gpio19;
+
+ println!("Starting SPI loopback test");
+
+ let driver = SpiDriver::new::(
+ spi,
+ sclk,
+ serial_out,
+ Some(serial_in),
+ &SpiDriverConfig::new(),
+ )?;
+
+ let config_1 = config::Config::new().baudrate(26.MHz().into());
+ let mut device_1 = SpiDeviceDriver::new(&driver, Some(cs_1), &config_1)?;
+
+ let config_2 = config::Config::new().baudrate(13.MHz().into());
+ let mut device_2 = SpiDeviceDriver::new(&driver, Some(cs_2), &config_2)?;
+
+ let write = [0xde, 0xad, 0xbe, 0xef];
+ let write_buf = [0xde, 0xad, 0xbe, 0xef];
+
+ let mut read = [0u8; 4];
+ let mut write_in_place_buf = [0xde, 0xad, 0xbe, 0xef];
+ let mut read_buf = [0; 8];
+
+ block_on(async {
+ loop {
+ device_1.transfer_async(&mut read, &write).await?;
+ println!("Device 1: Wrote {write:x?}, read {read:x?}");
+
+ println!("Device 2: To write {write_in_place_buf:x?} ... ");
+ // cascade multiple operations with different buffer length into one transaction
+ device_2
+ .transaction_async(&mut [
+ Operation::Write(&write_buf),
+ Operation::TransferInPlace(&mut write_in_place_buf),
+ Operation::Read(&mut read_buf),
+ ])
+ .await?;
+ println!("... read {write_in_place_buf:x?}");
+ }
+ })
+}
diff --git a/examples/spi_st7789.rs b/examples/spi_st7789.rs
index 861d7edbfee..9d3db52d08c 100644
--- a/examples/spi_st7789.rs
+++ b/examples/spi_st7789.rs
@@ -12,8 +12,6 @@
//! For this example you need to hook up an ST7789 SPI display.
//! The display will display an image on ferris the crab on a black background.
-use esp_idf_sys as _; // If using the `binstart` feature of `esp-idf-sys`, always keep this module imported
-
use std::thread;
use std::time::Duration;
@@ -34,7 +32,7 @@ use embedded_graphics::prelude::*;
use mipidsi::{Builder, Orientation};
fn main() -> anyhow::Result<()> {
- let peripherals = Peripherals::take().unwrap();
+ let peripherals = Peripherals::take()?;
let spi = peripherals.spi2;
let rst = PinDriver::output(peripherals.pins.gpio3)?;
@@ -52,8 +50,15 @@ fn main() -> anyhow::Result<()> {
.baudrate(26.MHz().into())
.data_mode(MODE_3);
- let device =
- SpiDeviceDriver::new_single(spi, sclk, sda, Some(sdi), Dma::Disabled, Some(cs), &config)?;
+ let device = SpiDeviceDriver::new_single(
+ spi,
+ sclk,
+ sda,
+ Some(sdi),
+ Some(cs),
+ &SpiDriverConfig::new(),
+ &config,
+ )?;
// display interface abstraction from SPI and DC
let di = SPIInterfaceNoCS::new(device, dc);
diff --git a/examples/temperature_sensor.rs b/examples/temperature_sensor.rs
new file mode 100644
index 00000000000..7572a586ebd
--- /dev/null
+++ b/examples/temperature_sensor.rs
@@ -0,0 +1,31 @@
+#![allow(unknown_lints)]
+#![allow(unexpected_cfgs)]
+
+#[cfg(all(esp_idf_soc_temp_sensor_supported, esp_idf_version_major = "5"))]
+fn main() -> anyhow::Result<()> {
+ use esp_idf_hal::delay::FreeRtos;
+ use esp_idf_hal::peripherals::Peripherals;
+ use esp_idf_hal::temp_sensor::*;
+
+ esp_idf_hal::sys::link_patches();
+
+ let peripherals = Peripherals::take()?;
+ let cfg = TempSensorConfig::default();
+ let mut temp = TempSensorDriver::new(&cfg, peripherals.temp_sensor)?;
+ temp.enable()?;
+
+ loop {
+ let t = temp.get_celsius()?;
+ println!("Temperature {t}C");
+ FreeRtos::delay_ms(1000);
+ }
+}
+
+#[cfg(not(all(esp_idf_soc_temp_sensor_supported, esp_idf_version_major = "5")))]
+fn main() -> anyhow::Result<()> {
+ println!("This example requires feature `esp_idf_soc_temp_sensor_supported` enabled");
+
+ loop {
+ std::thread::sleep(std::time::Duration::from_millis(1000));
+ }
+}
diff --git a/examples/timer_async.rs b/examples/timer_async.rs
new file mode 100644
index 00000000000..cc8b16d36d7
--- /dev/null
+++ b/examples/timer_async.rs
@@ -0,0 +1,22 @@
+use esp_idf_hal::peripherals::*;
+use esp_idf_hal::sys::EspError;
+use esp_idf_hal::task::*;
+use esp_idf_hal::timer::*;
+
+fn main() -> Result<(), EspError> {
+ // It is necessary to call this function once. Otherwise some patches to the runtime
+ // implemented by esp-idf-sys might not link properly. See https://github.com/esp-rs/esp-idf-template/issues/71
+ esp_idf_hal::sys::link_patches();
+
+ let per = Peripherals::take()?;
+
+ let mut timer = TimerDriver::new(per.timer00, &TimerConfig::new())?;
+
+ block_on(async {
+ loop {
+ timer.delay(timer.tick_hz()).await?; // Every second
+
+ println!("Tick");
+ }
+ })
+}
diff --git a/examples/timer_notify.rs b/examples/timer_notify.rs
new file mode 100644
index 00000000000..595b154a5d1
--- /dev/null
+++ b/examples/timer_notify.rs
@@ -0,0 +1,52 @@
+use std::num::NonZeroU32;
+
+use esp_idf_hal::peripherals::*;
+use esp_idf_hal::sys::EspError;
+use esp_idf_hal::task::notification::Notification;
+use esp_idf_hal::timer::*;
+
+fn main() -> Result<(), EspError> {
+ // It is necessary to call this function once. Otherwise some patches to the runtime
+ // implemented by esp-idf-sys might not link properly. See https://github.com/esp-rs/esp-idf-template/issues/71
+ esp_idf_hal::sys::link_patches();
+
+ let per = Peripherals::take()?;
+
+ // A safer abstraction over FreeRTOS/ESP-IDF task notifications.
+ let notification = Notification::new();
+
+ // BaseClock for the Timer is the APB_CLK that is running on 80MHz at default
+ // The default clock-divider is -> 80
+ // default APB clk is available with the APB_CLK_FREQ constant
+ let timer_conf = config::Config::new().auto_reload(true);
+ let mut timer = TimerDriver::new(per.timer00, &timer_conf)?;
+
+ // Every half a second
+ timer.set_alarm(timer.tick_hz() / 2)?;
+
+ let notifier = notification.notifier();
+
+ // Saftey: make sure the `Notification` object is not dropped while the subscription is active
+ unsafe {
+ timer.subscribe(move || {
+ let bitset = 0b10001010101;
+ notifier.notify_and_yield(NonZeroU32::new(bitset).unwrap());
+ })?;
+ }
+
+ timer.enable_interrupt()?;
+ timer.enable_alarm(true)?;
+ timer.enable(true)?;
+
+ loop {
+ // Notify approach
+ // The benefit with this approach over checking a global static variable is
+ // that the scheduler can block the task, and quickly resume it when notified
+ // so no spinlock is needed / the CPU does not waste cycles.
+ let bitset = notification.wait(esp_idf_hal::delay::BLOCK);
+
+ if let Some(bitset) = bitset {
+ println!("got event with bits {bitset:#b} from ISR");
+ }
+ }
+}
diff --git a/examples/uart_loopback.rs b/examples/uart_loopback.rs
index c2d18bc8caf..d90f1b694d8 100644
--- a/examples/uart_loopback.rs
+++ b/examples/uart_loopback.rs
@@ -1,8 +1,8 @@
//! UART loopback test
//!
//! Folowing pins are used:
-//! TX GPIO5
-//! RX GPIO6
+//! TX GPIO12
+//! RX GPIO13
//!
//! Depending on your target and the board you are using you have to change the pins.
//!
@@ -16,11 +16,11 @@ use esp_idf_hal::prelude::*;
use esp_idf_hal::uart::*;
fn main() -> anyhow::Result<()> {
- esp_idf_sys::link_patches();
+ esp_idf_hal::sys::link_patches();
- let peripherals = Peripherals::take().unwrap();
- let tx = peripherals.pins.gpio5;
- let rx = peripherals.pins.gpio6;
+ let peripherals = Peripherals::take()?;
+ let tx = peripherals.pins.gpio12;
+ let rx = peripherals.pins.gpio13;
println!("Starting UART loopback test");
let config = config::Config::new().baudrate(Hertz(115_200));
@@ -31,8 +31,7 @@ fn main() -> anyhow::Result<()> {
Option::::None,
Option::::None,
&config,
- )
- .unwrap();
+ )?;
loop {
uart.write(&[0xaa])?;
diff --git a/examples/uart_loopback_async.rs b/examples/uart_loopback_async.rs
new file mode 100644
index 00000000000..a012370da03
--- /dev/null
+++ b/examples/uart_loopback_async.rs
@@ -0,0 +1,46 @@
+//! UART loopback test
+//!
+//! Folowing pins are used:
+//! TX GPIO12
+//! RX GPIO13
+//!
+//! Depending on your target and the board you are using you have to change the pins.
+//!
+//! This example transfers data via UART.
+//! Connect TX and RX pins to see the outgoing data is read as incoming data.
+
+use esp_idf_hal::gpio;
+use esp_idf_hal::peripherals::Peripherals;
+use esp_idf_hal::prelude::*;
+use esp_idf_hal::task::*;
+use esp_idf_hal::uart::*;
+
+fn main() -> anyhow::Result<()> {
+ esp_idf_hal::sys::link_patches();
+
+ let peripherals = Peripherals::take()?;
+ let tx = peripherals.pins.gpio12;
+ let rx = peripherals.pins.gpio13;
+
+ println!("Starting UART loopback test");
+ let config = config::Config::new().baudrate(Hertz(115_200));
+ let uart = AsyncUartDriver::new(
+ peripherals.uart1,
+ tx,
+ rx,
+ Option::::None,
+ Option::::None,
+ &config,
+ )?;
+
+ block_on(async {
+ loop {
+ uart.write(&[0xaa]).await?;
+
+ let mut buf = [0_u8; 1];
+ uart.read(&mut buf).await?;
+
+ println!("Written 0xaa, read 0x{:02x}", buf[0]);
+ }
+ })
+}
diff --git a/partitions.csv b/partitions.csv
new file mode 100644
index 00000000000..924878bc2d5
--- /dev/null
+++ b/partitions.csv
@@ -0,0 +1,5 @@
+# Name, Type, SubType, Offset, Size, Flags
+# Note: if you have increased the bootloader size, make sure to update the offsets to avoid overlap
+nvs, data, nvs, , 0x6000,
+phy_init, data, phy, , 0x1000,
+factory, app, factory, , 3M,
\ No newline at end of file
diff --git a/riscv-ulp/libriscv_ulp_start.a b/riscv-ulp/libriscv_ulp_start.a
deleted file mode 100644
index d3f858baf1d..00000000000
Binary files a/riscv-ulp/libriscv_ulp_start.a and /dev/null differ
diff --git a/riscv-ulp/riscv_ulp_link_base.x b/riscv-ulp/riscv_ulp_link_base.x
deleted file mode 100644
index 769ba832519..00000000000
--- a/riscv-ulp/riscv_ulp_link_base.x
+++ /dev/null
@@ -1,86 +0,0 @@
-PROVIDE(UserSoft = DefaultHandler);
-PROVIDE(SupervisorSoft = DefaultHandler);
-PROVIDE(MachineSoft = DefaultHandler);
-PROVIDE(UserTimer = DefaultHandler);
-PROVIDE(SupervisorTimer = DefaultHandler);
-PROVIDE(MachineTimer = DefaultHandler);
-PROVIDE(UserExternal = DefaultHandler);
-PROVIDE(SupervisorExternal = DefaultHandler);
-PROVIDE(MachineExternal = DefaultHandler);
-
-PROVIDE(DefaultHandler = DefaultInterruptHandler);
-PROVIDE(ExceptionHandler = DefaultExceptionHandler);
-
-ENTRY(reset_vector)
-
-MEMORY
-{
- ram(RW) : ORIGIN = 0, LENGTH = _ram_size
-}
-
-PROVIDE(_stext = ORIGIN(ram));
-
-SECTIONS
-{
- .text.dummy (NOLOAD) :
- {
- /* This section is intended to make _stext address work */
- . = ABSOLUTE(_stext);
- } > ram
-
- .text _stext :
- {
- KEEP(*(.init)); // Default reset vector must link to offset 0x0
- KEEP(*(.start.rust));
- KEEP(*(.trap.rust));
-
- *(.text .text.*);
- } > ram
-
- .rodata ALIGN(4):
- {
- *(.srodata .srodata.*);
- *(.rodata .rodata.*);
-
- /* 4-byte align the end (VMA) of this section.
- This is required by LLD to ensure the LMA of the following .data
- section will have the correct alignment. */
- . = ALIGN(4);
- } > ram
-
- .data ALIGN(4):
- {
- /* Must be called __global_pointer$ for linker relaxations to work. */
- PROVIDE(__global_pointer$ = . + 0x800);
- *(.sdata .sdata.* .sdata2 .sdata2.*);
- *(.data .data.*);
- . = ALIGN(4);
- } > ram
-
- .bss ALIGN(4) :
- {
- *(.sbss .sbss.* .bss .bss.*);
- . = ALIGN(4);
- } > ram
-
- /* fake output .got section */
- /* Dynamic relocations are unsupported. This section is only used to detect
- relocatable code in the input files and raise an error if relocatable code
- is found */
- .got (INFO) :
- {
- KEEP(*(.got .got.*));
- }
-
- .eh_frame (INFO) :
- {
- KEEP(*(.eh_frame))
- }
-
- .eh_frame_hdr (INFO) :
- {
- *(.eh_frame_hdr)
- }
-
- _stack_top = ORIGIN(ram) + LENGTH(ram);
-}
\ No newline at end of file
diff --git a/riscv-ulp/riscv_ulp_link_default.x b/riscv-ulp/riscv_ulp_link_default.x
deleted file mode 100644
index fbf70875072..00000000000
--- a/riscv-ulp/riscv_ulp_link_default.x
+++ /dev/null
@@ -1,2 +0,0 @@
-PROVIDE(_ram_size = 4K);
-INCLUDE riscv_ulp_link_base.x;
diff --git a/riscv-ulp/riscv_ulp_start.S b/riscv-ulp/riscv_ulp_start.S
deleted file mode 100644
index cc33001eae0..00000000000
--- a/riscv-ulp/riscv_ulp_start.S
+++ /dev/null
@@ -1,117 +0,0 @@
-// NOTE: Adapted from riscv-rt/asm.S
-#define REGBYTES (1 << 2)
-
-.section .init, "ax"
- .global reset_vector
- .global irq_vector
-
-// The reset vector, jumps to startup code
-reset_vector:
- j _start
-
-// Interrupt handler
-.option push
-.option norelax // To prevent an unsupported R_RISCV_ALIGN relocation from being generated
-.balign 16
-irq_vector:
- addi sp, sp, -16*REGBYTES
-
- sw ra, 0*REGBYTES(sp)
- sw t0, 1*REGBYTES(sp)
- sw t1, 2*REGBYTES(sp)
- sw t2, 3*REGBYTES(sp)
- sw t3, 4*REGBYTES(sp)
- sw t4, 5*REGBYTES(sp)
- sw t5, 6*REGBYTES(sp)
- sw t6, 7*REGBYTES(sp)
- sw a0, 8*REGBYTES(sp)
- sw a1, 9*REGBYTES(sp)
- sw a2, 10*REGBYTES(sp)
- sw a3, 11*REGBYTES(sp)
- sw a4, 12*REGBYTES(sp)
- sw a5, 13*REGBYTES(sp)
- sw a6, 14*REGBYTES(sp)
- sw a7, 15*REGBYTES(sp)
-
- add a0, sp, zero
- jal ra, _start_trap_rust
-
- lw ra, 0*REGBYTES(sp)
- lw t0, 1*REGBYTES(sp)
- lw t1, 2*REGBYTES(sp)
- lw t2, 3*REGBYTES(sp)
- lw t3, 4*REGBYTES(sp)
- lw t4, 5*REGBYTES(sp)
- lw t5, 6*REGBYTES(sp)
- lw t6, 7*REGBYTES(sp)
- lw a0, 8*REGBYTES(sp)
- lw a1, 9*REGBYTES(sp)
- lw a2, 10*REGBYTES(sp)
- lw a3, 11*REGBYTES(sp)
- lw a4, 12*REGBYTES(sp)
- lw a5, 13*REGBYTES(sp)
- lw a6, 14*REGBYTES(sp)
- lw a7, 15*REGBYTES(sp)
-
- addi sp, sp, 16*REGBYTES
- ret
-.option pop
-
-_start:
- .cfi_startproc
- .cfi_undefined ra
-
- li x1, 0
- li x2, 0
- li x3, 0
- li x4, 0
- li x5, 0
- li x6, 0
- li x7, 0
- li x8, 0
- li x9, 0
- li x10,0
- li x11,0
- li x12,0
- li x13,0
- li x14,0
- li x15,0
- li x16,0
- li x17,0
- li x18,0
- li x19,0
- li x20,0
- li x21,0
- li x22,0
- li x23,0
- li x24,0
- li x25,0
- li x26,0
- li x27,0
- li x28,0
- li x29,0
- li x30,0
- li x31,0
-
- .option push
- .option norelax // To prevent an unsupported R_RISCV_ALIGN relocation from being generated
- la gp, __global_pointer$
- .option pop
-
- // Allocate stack
- la sp, _stack_top
-
- // Set frame pointer
- add s0, sp, zero
-
- jal zero, _start_rust
-
- .cfi_endproc
-
-loop:
- j loop
-
-// Make sure there is an abort when linking
-.globl abort
-abort:
- j abort
diff --git a/riscv-ulp/riscv_ulp_start_assemble.ps1 b/riscv-ulp/riscv_ulp_start_assemble.ps1
deleted file mode 100644
index 226bd384a6c..00000000000
--- a/riscv-ulp/riscv_ulp_start_assemble.ps1
+++ /dev/null
@@ -1,7 +0,0 @@
-# remove existing blob because otherwise this will append object file to the old blob
-Remove-Item -Force riscv_ulp_start.a
-
-riscv32-esp-elf-gcc -Desp_ulp -ggdb3 -fdebug-prefix-map=$(pwd)=/riscv_ulp_start -c -mabi=ilp32 -march=rv32imc riscv_ulp_start.S -o riscv_ulp_start.o
-riscv32-esp-elf-ar crs libriscv_ulp_start.a riscv_ulp_start.o
-
-Remove-Item riscv_ulp_start.o
diff --git a/riscv-ulp/riscv_ulp_start_assemble.sh b/riscv-ulp/riscv_ulp_start_assemble.sh
deleted file mode 100755
index f366acb8620..00000000000
--- a/riscv-ulp/riscv_ulp_start_assemble.sh
+++ /dev/null
@@ -1,11 +0,0 @@
-#!/bin/bash
-
-set -euxo pipefail
-
-# remove existing blob because otherwise this will append object file to the old blob
-rm -f riscv_ulp_start.a
-
-riscv32-esp-elf-gcc -Desp_ulp -ggdb3 -fdebug-prefix-map=$(pwd)=/riscv_ulp_start -c -mabi=ilp32 -march=rv32imc riscv_ulp_start.S -o riscv_ulp_start.o
-riscv32-esp-elf-ar crs libriscv_ulp_start.a riscv_ulp_start.o
-
-rm riscv_ulp_start.o
diff --git a/src/adc.rs b/src/adc.rs
index a05ebe3d97f..1ebffe0b9ed 100644
--- a/src/adc.rs
+++ b/src/adc.rs
@@ -1,306 +1,452 @@
-use core::marker::PhantomData;
+//! Analog to Digital Converter peripheral control.
-#[cfg(not(feature = "riscv-ulp-hal"))]
use esp_idf_sys::*;
-#[cfg(feature = "riscv-ulp-hal")]
-use crate::riscv_ulp_hal::sys::*;
-
-#[cfg(not(feature = "riscv-ulp-hal"))]
-use crate::gpio::ADCPin;
-
-#[cfg(not(feature = "riscv-ulp-hal"))]
-use crate::peripheral::{Peripheral, PeripheralRef};
-
-#[cfg(not(feature = "riscv-ulp-hal"))]
-pub type AdcConfig = config::Config;
+#[cfg(all(
+ not(esp_idf_version_major = "4"),
+ not(esp32c2),
+ esp_idf_comp_esp_adc_enabled
+))]
+#[allow(deprecated)]
+pub use continuous::{
+ config as cont_config, config::Config as AdcContConfig, AdcChannels, AdcChannelsArray,
+ AdcDriver as AdcContDriver, AdcMeasurement, Atten11dB, Atten12dB, Atten2p5dB, Atten6dB,
+ AttenNone, Attenuated, ChainedAdcChannels, EmptyAdcChannels,
+};
+
+#[cfg(any(feature = "adc-oneshot-legacy", esp_idf_version_major = "4"))]
+pub use oneshot_legacy::*;
pub trait Adc: Send {
fn unit() -> adc_unit_t;
}
-pub trait Attenuation: Send {
- fn attenuation() -> adc_atten_t;
+// NOTE: Will be changed to an enum once C-style enums are usable as const generics
+pub mod attenuation {
+ pub use esp_idf_sys::{
+ adc_atten_t, adc_atten_t_ADC_ATTEN_DB_0, adc_atten_t_ADC_ATTEN_DB_11,
+ adc_atten_t_ADC_ATTEN_DB_11 as adc_atten_t_ADC_ATTEN_DB_12, adc_atten_t_ADC_ATTEN_DB_2_5,
+ adc_atten_t_ADC_ATTEN_DB_6,
+ };
+
+ pub const NONE: adc_atten_t = adc_atten_t_ADC_ATTEN_DB_0;
+ pub const DB_2_5: adc_atten_t = adc_atten_t_ADC_ATTEN_DB_2_5;
+ pub const DB_6: adc_atten_t = adc_atten_t_ADC_ATTEN_DB_6;
+ #[deprecated(since = "0.45.3", note = "Use `DB_12` instead")]
+ pub const DB_11: adc_atten_t = adc_atten_t_ADC_ATTEN_DB_11;
+ pub const DB_12: adc_atten_t = adc_atten_t_ADC_ATTEN_DB_12;
}
-pub struct Atten0dB(PhantomData);
-pub struct Atten2p5dB(PhantomData);
-pub struct Atten6dB(PhantomData);
-pub struct Atten11dB(PhantomData);
+/// The sampling/readout resolution of the ADC
+#[derive(Debug, PartialEq, Eq, Clone, Copy)]
+pub enum Resolution {
+ #[cfg(esp32)]
+ Resolution9Bit,
+ #[cfg(esp32)]
+ Resolution10Bit,
+ #[cfg(esp32)]
+ Resolution11Bit,
+ #[cfg(any(esp32, esp32c3, esp32s3, esp32c2, esp32h2, esp32c5, esp32c6, esp32p4))]
+ Resolution12Bit,
+ #[cfg(esp32s2)]
+ Resolution13Bit,
+}
-impl Attenuation for Atten0dB {
- fn attenuation() -> adc_atten_t {
- adc_atten_t_ADC_ATTEN_DB_0
+impl Resolution {
+ #[cfg(not(esp32s2))]
+ pub const fn new() -> Self {
+ Self::Resolution12Bit
}
-}
-impl Attenuation for Atten2p5dB {
- fn attenuation() -> adc_atten_t {
- adc_atten_t_ADC_ATTEN_DB_2_5
+ #[cfg(esp32s2)]
+ pub const fn new() -> Self {
+ Self::Resolution13Bit
}
}
-impl Attenuation for Atten6dB {
- fn attenuation() -> adc_atten_t {
- adc_atten_t_ADC_ATTEN_DB_6
+impl Default for Resolution {
+ fn default() -> Self {
+ Self::new()
}
}
-impl Attenuation for Atten11dB {
- fn attenuation() -> adc_atten_t {
- adc_atten_t_ADC_ATTEN_DB_11
+impl From for adc_bits_width_t {
+ fn from(resolution: Resolution) -> Self {
+ match resolution {
+ #[cfg(esp32)]
+ Resolution::Resolution9Bit => adc_bits_width_t_ADC_WIDTH_BIT_9,
+ #[cfg(esp32)]
+ Resolution::Resolution10Bit => adc_bits_width_t_ADC_WIDTH_BIT_10,
+ #[cfg(esp32)]
+ Resolution::Resolution11Bit => adc_bits_width_t_ADC_WIDTH_BIT_11,
+ #[cfg(any(esp32, esp32s3, esp32c3, esp32c2, esp32h2, esp32c5, esp32c6, esp32p4))]
+ Resolution::Resolution12Bit => adc_bits_width_t_ADC_WIDTH_BIT_12,
+ #[cfg(esp32s2)]
+ Resolution::Resolution13Bit => adc_bits_width_t_ADC_WIDTH_BIT_13,
+ }
}
}
-/// ADC configuration
-#[cfg(not(feature = "riscv-ulp-hal"))]
-pub mod config {
+#[cfg(any(feature = "adc-oneshot-legacy", esp_idf_version_major = "4"))]
+mod oneshot_legacy {
use esp_idf_sys::*;
- /// The sampling/readout resolution of the ADC
- #[derive(Debug, PartialEq, Eq, Clone, Copy)]
- pub enum Resolution {
- #[cfg(esp32)]
- Resolution9Bit,
- #[cfg(esp32)]
- Resolution10Bit,
- #[cfg(esp32)]
- Resolution11Bit,
- #[cfg(any(esp32, esp32c3, esp32s3))]
- Resolution12Bit,
- #[cfg(esp32s2)]
- Resolution13Bit,
- }
+ use crate::gpio::ADCPin;
- impl Default for Resolution {
- #[cfg(any(esp32, esp32c3, esp32s3))]
- fn default() -> Self {
- Self::Resolution12Bit
+ use crate::peripheral::{Peripheral, PeripheralRef};
+
+ use super::{to_nb_err, Adc, DirectConverter};
+
+ pub type AdcConfig = config::Config;
+
+ /// ADC configuration
+ pub mod config {
+ pub use crate::adc::Resolution;
+
+ #[derive(Debug, Copy, Clone, Default)]
+ pub struct Config {
+ pub resolution: Resolution,
+ #[cfg(any(esp_idf_comp_esp_adc_cal_enabled, esp_idf_comp_esp_adc_enabled))]
+ pub calibration: bool,
}
- #[cfg(esp32s2)]
- fn default() -> Self {
- Self::Resolution13Bit
- }
- }
-
- impl From for adc_bits_width_t {
- fn from(resolution: Resolution) -> Self {
- match resolution {
- #[cfg(esp32)]
- Resolution::Resolution9Bit => adc_bits_width_t_ADC_WIDTH_BIT_9,
- #[cfg(esp32)]
- Resolution::Resolution10Bit => adc_bits_width_t_ADC_WIDTH_BIT_10,
- #[cfg(esp32)]
- Resolution::Resolution11Bit => adc_bits_width_t_ADC_WIDTH_BIT_11,
- #[cfg(any(esp32, esp32s3, esp32c3))]
- Resolution::Resolution12Bit => adc_bits_width_t_ADC_WIDTH_BIT_12,
- #[cfg(esp32s2)]
- Resolution::Resolution13Bit => adc_bits_width_t_ADC_WIDTH_BIT_13,
+ impl Config {
+ pub fn new() -> Self {
+ Default::default()
+ }
+
+ #[must_use]
+ pub fn resolution(mut self, resolution: Resolution) -> Self {
+ self.resolution = resolution;
+ self
+ }
+
+ #[cfg(any(esp_idf_comp_esp_adc_cal_enabled, esp_idf_comp_esp_adc_enabled))]
+ #[must_use]
+ pub fn calibration(mut self, calibration: bool) -> Self {
+ self.calibration = calibration;
+ self
}
}
}
- #[derive(Debug, Copy, Clone, Default)]
- pub struct Config {
- pub resolution: Resolution,
- #[cfg(any(esp_idf_comp_esp_adc_cal_enabled, esp_idf_comp_esp_adc_enabled))]
- pub calibration: bool,
+ pub struct AdcChannelDriver<'d, const A: adc_atten_t, T: ADCPin> {
+ pin: PeripheralRef<'d, T>,
}
- impl Config {
- pub fn new() -> Self {
- Default::default()
- }
-
- #[must_use]
- pub fn resolution(mut self, resolution: Resolution) -> Self {
- self.resolution = resolution;
- self
- }
+ impl<'d, const A: adc_atten_t, T: ADCPin> AdcChannelDriver<'d, A, T> {
+ pub fn new(pin: impl Peripheral + 'd) -> Result {
+ crate::into_ref!(pin);
- #[cfg(any(esp_idf_comp_esp_adc_cal_enabled, esp_idf_comp_esp_adc_enabled))]
- #[must_use]
- pub fn calibration(mut self, calibration: bool) -> Self {
- self.calibration = calibration;
- self
- }
- }
-}
+ unsafe {
+ crate::gpio::rtc_reset_pin(pin.pin())?;
+ }
-#[cfg(not(feature = "riscv-ulp-hal"))]
-pub struct AdcChannelDriver<'d, T: ADCPin, ATTEN> {
- pin: PeripheralRef<'d, T>,
- _atten: PhantomData,
-}
+ if T::Adc::unit() == adc_unit_t_ADC_UNIT_1 {
+ esp!(unsafe { adc1_config_channel_atten(pin.adc_channel(), A) })?;
+ } else {
+ #[cfg(not(any(esp32c2, esp32h2, esp32c5, esp32c6, esp32p4)))]
+ esp!(unsafe { adc2_config_channel_atten(pin.adc_channel(), A) })?;
-#[cfg(not(feature = "riscv-ulp-hal"))]
-impl<'d, T: ADCPin, ATTEN> AdcChannelDriver<'d, T, ATTEN>
-where
- ATTEN: Attenuation,
-{
- #[inline]
- pub fn new(
- pin: impl Peripheral + 'd,
- ) -> Result, EspError> {
- crate::into_ref!(pin);
+ #[cfg(any(esp32c2, esp32h2, esp32c5, esp32c6, esp32p4))]
+ unreachable!();
+ }
- unsafe {
- crate::gpio::rtc_reset_pin(pin.pin())?;
+ Ok(Self { pin })
}
- if T::Adc::unit() == adc_unit_t_ADC_UNIT_1 {
- esp!(unsafe { adc1_config_channel_atten(pin.adc_channel(), ATTEN::attenuation()) })?;
- } else {
- esp!(unsafe { adc2_config_channel_atten(pin.adc_channel(), ATTEN::attenuation()) })?;
+ fn pin(&mut self) -> &mut PeripheralRef<'d, T> {
+ &mut self.pin
}
+ }
+
+ impl embedded_hal_0_2::adc::Channel
+ for AdcChannelDriver<'_, A, T>
+ {
+ type ID = (adc_channel_t, adc_atten_t);
- Ok(Self {
- pin,
- _atten: PhantomData,
- })
+ fn channel() -> Self::ID {
+ (T::CHANNEL, A)
+ }
}
- fn pin(&mut self) -> &mut PeripheralRef<'d, T> {
- &mut self.pin
+ pub struct AdcDriver<'d, ADC: Adc> {
+ _adc: PeripheralRef<'d, ADC>,
+ #[allow(dead_code)]
+ resolution: config::Resolution,
+ #[cfg(all(
+ any(esp32, esp32s2, esp32s3, esp32c3),
+ any(esp_idf_comp_esp_adc_cal_enabled, esp_idf_comp_esp_adc_enabled)
+ ))]
+ cal_characteristics: Option<
+ [Option; adc_atten_t_ADC_ATTEN_DB_11 as usize + 1],
+ >,
}
-}
-#[cfg(not(feature = "riscv-ulp-hal"))]
-impl<'d, T: ADCPin, ATTEN> embedded_hal_0_2::adc::Channel
- for AdcChannelDriver<'d, T, ATTEN>
-{
- type ID = u8;
+ unsafe impl Send for AdcDriver<'_, ADC> {}
+
+ impl<'d, ADC: Adc> AdcDriver<'d, ADC> {
+ #[cfg(all(
+ esp32,
+ any(esp_idf_comp_esp_adc_cal_enabled, esp_idf_comp_esp_adc_enabled)
+ ))]
+ const CALIBRATION_SCHEME: esp_adc_cal_value_t =
+ esp_adc_cal_value_t_ESP_ADC_CAL_VAL_EFUSE_VREF;
+
+ #[cfg(all(
+ any(esp32c3, esp32s2),
+ any(esp_idf_comp_esp_adc_cal_enabled, esp_idf_comp_esp_adc_enabled)
+ ))]
+ const CALIBRATION_SCHEME: esp_adc_cal_value_t =
+ esp_adc_cal_value_t_ESP_ADC_CAL_VAL_EFUSE_TP;
+
+ #[cfg(all(
+ esp32s3,
+ any(esp_idf_comp_esp_adc_cal_enabled, esp_idf_comp_esp_adc_enabled)
+ ))]
+ const CALIBRATION_SCHEME: esp_adc_cal_value_t =
+ esp_adc_cal_value_t_ESP_ADC_CAL_VAL_EFUSE_TP_FIT;
+
+ pub fn new(
+ adc: impl Peripheral + 'd,
+ config: &config::Config,
+ ) -> Result {
+ crate::into_ref!(adc);
+
+ #[cfg(all(
+ any(esp32, esp32s2, esp32s3, esp32c3),
+ any(esp_idf_comp_esp_adc_cal_enabled, esp_idf_comp_esp_adc_enabled)
+ ))]
+ if config.calibration {
+ esp!(unsafe { esp_adc_cal_check_efuse(Self::CALIBRATION_SCHEME) })?;
+ }
- fn channel() -> Self::ID {
- T::CHANNEL as _
- }
-}
+ if ADC::unit() == adc_unit_t_ADC_UNIT_1 {
+ esp!(unsafe { adc1_config_width(config.resolution.into()) })?;
+ }
-#[cfg(not(feature = "riscv-ulp-hal"))]
-pub struct AdcDriver<'d, ADC: Adc> {
- _adc: PeripheralRef<'d, ADC>,
- resolution: config::Resolution,
- #[cfg(any(esp_idf_comp_esp_adc_cal_enabled, esp_idf_comp_esp_adc_enabled))]
- cal_characteristics:
- Option<[Option; adc_atten_t_ADC_ATTEN_DB_11 as usize + 1]>,
-}
+ Ok(Self {
+ _adc: adc,
+ resolution: config.resolution,
+ #[cfg(all(
+ any(esp32, esp32s2, esp32s3, esp32c3),
+ any(esp_idf_comp_esp_adc_cal_enabled, esp_idf_comp_esp_adc_enabled)
+ ))]
+ cal_characteristics: if config.calibration {
+ Some(Default::default())
+ } else {
+ None
+ },
+ })
+ }
-#[cfg(not(feature = "riscv-ulp-hal"))]
-unsafe impl<'d, ADC: Adc> Send for AdcDriver<'d, ADC> {}
-
-#[cfg(not(feature = "riscv-ulp-hal"))]
-impl<'d, ADC: Adc> AdcDriver<'d, ADC> {
- #[cfg(all(
- esp32,
- any(esp_idf_comp_esp_adc_cal_enabled, esp_idf_comp_esp_adc_enabled)
- ))]
- const CALIBRATION_SCHEME: esp_adc_cal_value_t = esp_adc_cal_value_t_ESP_ADC_CAL_VAL_EFUSE_VREF;
-
- #[cfg(all(
- any(esp32c3, esp32s2),
- any(esp_idf_comp_esp_adc_cal_enabled, esp_idf_comp_esp_adc_enabled)
- ))]
- const CALIBRATION_SCHEME: esp_adc_cal_value_t = esp_adc_cal_value_t_ESP_ADC_CAL_VAL_EFUSE_TP;
-
- #[cfg(all(
- esp32s3,
- any(esp_idf_comp_esp_adc_cal_enabled, esp_idf_comp_esp_adc_enabled)
- ))]
- const CALIBRATION_SCHEME: esp_adc_cal_value_t =
- esp_adc_cal_value_t_ESP_ADC_CAL_VAL_EFUSE_TP_FIT;
+ #[inline(always)]
+ pub fn read(
+ &mut self,
+ pin: &mut AdcChannelDriver<'_, A, T>,
+ ) -> Result
+ where
+ T: ADCPin,
+ {
+ self.read_internal(ADC::unit(), pin.pin().adc_channel(), A)
+ }
- #[cfg(not(esp32s2))]
- const MAX_READING: u32 = 4095;
+ #[inline(always)]
+ pub fn read_raw(
+ &mut self,
+ pin: &mut AdcChannelDriver<'_, A, T>,
+ ) -> Result
+ where
+ T: ADCPin,
+ {
+ self.read_internal_raw(ADC::unit(), pin.pin().adc_channel())
+ }
- #[cfg(esp32s2)]
- const MAX_READING: u32 = 8191;
+ #[inline(always)]
+ #[cfg(all(esp32, esp_idf_version_major = "4"))]
+ pub fn read_hall(
+ &mut self,
+ hall_sensor: &mut crate::hall::HallSensor,
+ ) -> Result {
+ let measurement = self.read_hall_raw(hall_sensor);
- pub fn new(
- adc: impl Peripheral + 'd,
- config: &config::Config,
- ) -> Result {
- crate::into_ref!(adc);
+ self.raw_to_voltage(measurement, adc_atten_t_ADC_ATTEN_DB_0)
+ }
- #[cfg(any(esp_idf_comp_esp_adc_cal_enabled, esp_idf_comp_esp_adc_enabled))]
- if config.calibration {
- esp!(unsafe { esp_adc_cal_check_efuse(Self::CALIBRATION_SCHEME) })?;
+ #[inline(always)]
+ #[cfg(all(esp32, esp_idf_version_major = "4"))]
+ pub fn read_hall_raw(&mut self, _hall_sensor: &mut crate::hall::HallSensor) -> u16 {
+ unsafe { hall_sensor_read() as u16 }
}
- if ADC::unit() == adc_unit_t_ADC_UNIT_1 {
- esp!(unsafe { adc1_config_width(config.resolution.into()) })?;
+ #[inline(always)]
+ fn read_internal(
+ &mut self,
+ unit: adc_unit_t,
+ channel: adc_channel_t,
+ atten: adc_atten_t,
+ ) -> Result {
+ let measurement = self.read_internal_raw(unit, channel)?;
+ self.raw_to_voltage(measurement, atten)
}
- Ok(Self {
- _adc: adc,
- resolution: config.resolution,
- #[cfg(any(esp_idf_comp_esp_adc_cal_enabled, esp_idf_comp_esp_adc_enabled))]
- cal_characteristics: if config.calibration {
- Some(Default::default())
+ #[inline(always)]
+ fn read_internal_raw(
+ &mut self,
+ unit: adc_unit_t,
+ channel: adc_channel_t,
+ ) -> Result {
+ if unit == adc_unit_t_ADC_UNIT_1 {
+ Ok(unsafe { adc1_get_raw(channel) } as _)
} else {
- None
- },
- })
+ #[cfg(not(any(esp32c2, esp32h2, esp32c5, esp32c6, esp32p4)))]
+ {
+ let mut measurement = 0;
+ esp!(unsafe {
+ adc2_get_raw(channel, self.resolution.into(), &mut measurement)
+ })?;
+
+ Ok(measurement as _)
+ }
+
+ #[cfg(any(esp32c2, esp32h2, esp32c5, esp32c6, esp32p4))]
+ unreachable!();
+ }
+ }
+
+ #[inline(always)]
+ fn raw_to_voltage(
+ &mut self,
+ measurement: u16,
+ attenuation: adc_atten_t,
+ ) -> Result {
+ #[cfg(all(
+ any(esp32, esp32s2, esp32s3, esp32c3),
+ any(esp_idf_comp_esp_adc_cal_enabled, esp_idf_comp_esp_adc_enabled)
+ ))]
+ let mv = if let Some(cal) = self.get_cal_characteristics(attenuation)? {
+ unsafe { esp_adc_cal_raw_to_voltage(measurement as u32, &cal) as u16 }
+ } else {
+ DirectConverter(attenuation).raw_to_mv(measurement)
+ };
+
+ #[cfg(not(all(
+ any(esp32, esp32s2, esp32s3, esp32c3),
+ any(esp_idf_comp_esp_adc_cal_enabled, esp_idf_comp_esp_adc_enabled)
+ )))]
+ let mv = DirectConverter(attenuation).raw_to_mv(measurement);
+
+ Ok(mv)
+ }
+
+ #[cfg(all(
+ any(esp32, esp32s2, esp32s3, esp32c3),
+ any(esp_idf_comp_esp_adc_cal_enabled, esp_idf_comp_esp_adc_enabled)
+ ))]
+ fn get_cal_characteristics(
+ &mut self,
+ attenuation: adc_atten_t,
+ ) -> Result, EspError> {
+ if let Some(characteristics) = &mut self.cal_characteristics {
+ if let Some(cal) = characteristics[attenuation as usize] {
+ Ok(Some(cal))
+ } else {
+ esp!(unsafe { esp_adc_cal_check_efuse(Self::CALIBRATION_SCHEME) })?;
+
+ let mut cal: esp_adc_cal_characteristics_t = Default::default();
+ unsafe {
+ esp_adc_cal_characterize(
+ ADC::unit(),
+ attenuation,
+ self.resolution.into(),
+ 0,
+ &mut cal,
+ )
+ };
+
+ characteristics[attenuation as usize] = Some(cal);
+
+ Ok(Some(cal))
+ }
+ } else {
+ Ok(None)
+ }
+ }
}
- pub fn read(
- &mut self,
- pin: &mut AdcChannelDriver<'_, T, ATTEN>,
- ) -> Result
+ impl<'c, const A: adc_atten_t, T>
+ embedded_hal_0_2::adc::OneShot>
+ for AdcDriver<'_, T::Adc>
where
T: ADCPin,
- ATTEN: Attenuation,
{
- self.read_internal(ADC::unit(), pin.pin().adc_channel(), ATTEN::attenuation())
+ type Error = EspError;
+
+ fn read(&mut self, pin: &mut AdcChannelDriver<'c, A, T>) -> nb::Result {
+ self.read_internal(T::Adc::unit(), pin.pin.adc_channel(), A)
+ .map_err(to_nb_err)
+ }
}
#[cfg(all(esp32, esp_idf_version_major = "4"))]
- pub fn read_hall(
- &mut self,
- _hall_sensor: &mut crate::hall::HallSensor,
- ) -> Result {
- let measurement = unsafe { hall_sensor_read() };
-
- self.raw_to_voltage(measurement, adc_atten_t_ADC_ATTEN_DB_0)
- }
-
- fn read_internal(
- &mut self,
- unit: adc_unit_t,
- channel: adc_channel_t,
- atten: adc_atten_t,
- ) -> Result {
- let mut measurement = 0_i32;
-
- if unit == adc_unit_t_ADC_UNIT_1 {
- measurement = unsafe { adc1_get_raw(channel) };
- } else {
- esp!(unsafe { adc2_get_raw(channel, self.resolution.into(), &mut measurement) })?;
- };
+ impl embedded_hal_0_2::adc::OneShot
+ for AdcDriver<'_, super::ADC1>
+ {
+ type Error = EspError;
- self.raw_to_voltage(measurement, atten)
+ fn read(
+ &mut self,
+ hall_sensor: &mut crate::hall::HallSensor,
+ ) -> nb::Result {
+ AdcDriver::read_hall(self, hall_sensor).map_err(to_nb_err)
+ }
}
+}
- fn raw_to_voltage(
- &mut self,
- measurement: core::ffi::c_int,
- attenuation: adc_atten_t,
- ) -> Result {
- #[cfg(any(esp_idf_comp_esp_adc_cal_enabled, esp_idf_comp_esp_adc_enabled))]
- let mv = if let Some(cal) = self.get_cal_characteristics(attenuation)? {
- unsafe { esp_adc_cal_raw_to_voltage(measurement as u32, &cal) as u16 }
- } else {
- (measurement as u32 * Self::get_max_mv(attenuation) / Self::MAX_READING) as u16
- };
+fn to_nb_err(err: EspError) -> nb::Error {
+ if err.code() == ESP_ERR_INVALID_STATE {
+ nb::Error::WouldBlock
+ } else {
+ nb::Error::Other(err)
+ }
+}
- #[cfg(not(any(esp_idf_comp_esp_adc_cal_enabled, esp_idf_comp_esp_adc_enabled)))]
- let mv = (measurement as u32 * Self::get_max_mv(attenuation) / Self::MAX_READING) as u16;
+macro_rules! impl_adc {
+ ($adc:ident: $unit:expr) => {
+ crate::impl_peripheral!($adc);
- Ok(mv)
+ impl Adc for $adc {
+ #[inline(always)]
+ fn unit() -> adc_unit_t {
+ $unit
+ }
+ }
+ };
+}
+
+impl_adc!(ADC1: adc_unit_t_ADC_UNIT_1);
+#[cfg(not(any(esp32c2, esp32h2, esp32c5, esp32c6, esp32p4)))] // TODO: Check for esp32c5 and esp32p4
+impl_adc!(ADC2: adc_unit_t_ADC_UNIT_2);
+
+/// Converts a raw reading to mV without using calibration
+struct DirectConverter(adc_atten_t);
+
+impl DirectConverter {
+ #[cfg(not(esp32s2))]
+ const MAX_READING: u32 = 4095;
+
+ #[cfg(esp32s2)]
+ const MAX_READING: u32 = 8191;
+
+ fn raw_to_mv(&self, raw: u16) -> u16 {
+ (raw as u32 * self.get_max_mv() as u32 / Self::MAX_READING) as u16
}
+ #[inline(always)]
#[allow(non_upper_case_globals)]
- fn get_max_mv(attenuation: adc_atten_t) -> u32 {
+ fn get_max_mv(&self) -> u16 {
+ let attenuation = self.0;
+
#[cfg(esp32)]
let mv = match attenuation {
adc_atten_t_ADC_ATTEN_DB_0 => 950,
@@ -310,7 +456,7 @@ impl<'d, ADC: Adc> AdcDriver<'d, ADC> {
other => panic!("Unknown attenuation: {}", other),
};
- #[cfg(any(esp32c3, esp32s2))]
+ #[cfg(any(esp32c3, esp32s2, esp32c2, esp32h2, esp32c5, esp32c6, esp32p4))]
let mv = match attenuation {
adc_atten_t_ADC_ATTEN_DB_0 => 750,
adc_atten_t_ADC_ATTEN_DB_2_5 => 1050,
@@ -330,90 +476,1109 @@ impl<'d, ADC: Adc> AdcDriver<'d, ADC> {
mv
}
+}
- #[cfg(any(esp_idf_comp_esp_adc_cal_enabled, esp_idf_comp_esp_adc_enabled))]
- fn get_cal_characteristics(
- &mut self,
- attenuation: adc_atten_t,
- ) -> Result, EspError> {
- if let Some(characteristics) = &mut self.cal_characteristics {
- if let Some(cal) = characteristics[attenuation as usize] {
- Ok(Some(cal))
- } else {
- esp!(unsafe { esp_adc_cal_check_efuse(Self::CALIBRATION_SCHEME) })?;
+/// One-shot ADC module
+/// Example: reading a value form a pin and printing it on the terminal
+/// ```
+/// use std::thread;
+/// use std::time::Duration;
+///
+/// fn main() -> anyhow::Result<()> {
+/// use esp_idf_hal::adc::attenuation::DB_12;
+/// use esp_idf_hal::adc::oneshot::config::AdcChannelConfig;
+/// use esp_idf_hal::adc::oneshot::*;
+/// use esp_idf_hal::peripherals::Peripherals;
+///
+/// let peripherals = Peripherals::take()?;
+/// let adc = AdcDriver::new(peripherals.adc1)?;
+///
+/// /// configuring pin to analog read, you can regulate the adc input voltage range depending on your need
+/// /// for this example we use the attenuation of 11db which sets the input voltage range to around 0-3.6V
+/// let config = AdcChannelConfig {
+/// attenuation: DB_12,
+/// ..Default::default()
+/// };
+/// let mut adc_pin = AdcChannelDriver::new(&adc, peripherals.pins.gpio2, &config)?;
+///
+/// loop {
+/// /// you can change the sleep duration depending on how often you want to sample
+/// thread::sleep(Duration::from_millis(100));
+/// println!("ADC value: {}", adc.read(&mut adc_pin)?);
+/// }
+/// }
+/// ```
+#[cfg(all(
+ not(feature = "adc-oneshot-legacy"),
+ not(esp_idf_version_major = "4"),
+ esp_idf_comp_esp_adc_enabled
+))]
+pub mod oneshot {
+ use core::borrow::Borrow;
+
+ use esp_idf_sys::*;
+
+ use crate::gpio::ADCPin;
+ use crate::peripheral::Peripheral;
+ use crate::peripheral::PeripheralRef;
+
+ use super::attenuation::adc_atten_t;
+ use super::to_nb_err;
+ use super::Adc;
+ use super::DirectConverter;
+
+ pub mod config {
+ use super::adc_atten_t;
+
+ pub use crate::adc::Resolution;
+
+ #[derive(Debug, Copy, Clone, Default, Eq, PartialEq, Hash)]
+ pub enum Calibration {
+ #[default]
+ None,
+ #[cfg(all(
+ any(esp_idf_comp_esp_adc_cal_enabled, esp_idf_comp_esp_adc_enabled),
+ any(
+ esp32c3,
+ all(
+ esp32c6,
+ not(all(esp_idf_version_major = "5", esp_idf_version_minor = "0")),
+ not(esp_idf_version_full = "5.1.0")
+ ),
+ esp32s3,
+ )
+ ))]
+ Curve,
+ #[cfg(all(
+ any(esp_idf_comp_esp_adc_cal_enabled, esp_idf_comp_esp_adc_enabled),
+ any(esp32, esp32c2, esp32s2)
+ ))]
+ Line,
+ }
+
+ #[derive(Debug, Copy, Clone, Default)]
+ pub struct AdcChannelConfig {
+ pub attenuation: adc_atten_t,
+ pub resolution: Resolution,
+ pub calibration: Calibration,
+ }
- let mut cal: esp_adc_cal_characteristics_t = Default::default();
- unsafe {
- esp_adc_cal_characterize(
- ADC::unit(),
- attenuation,
- self.resolution.into(),
- 0,
- &mut cal,
+ impl AdcChannelConfig {
+ pub const fn new() -> Self {
+ Self {
+ attenuation: crate::adc::attenuation::NONE,
+ resolution: Resolution::new(),
+ calibration: Calibration::None,
+ }
+ }
+ }
+ }
+
+ /// Converts a raw reading to mV with or without calibration
+ enum Converter {
+ NoCalibration(adc_atten_t),
+ #[cfg(all(
+ any(esp_idf_comp_esp_adc_cal_enabled, esp_idf_comp_esp_adc_enabled),
+ any(
+ esp32c3,
+ all(
+ esp32c6,
+ not(all(esp_idf_version_major = "5", esp_idf_version_minor = "0")),
+ not(esp_idf_version_full = "5.1.0")
+ ),
+ esp32s3,
+ )
+ ))]
+ CurveFittingCalibration(adc_cali_handle_t),
+ #[cfg(all(
+ any(esp_idf_comp_esp_adc_cal_enabled, esp_idf_comp_esp_adc_enabled),
+ any(esp32, esp32c2, esp32s2)
+ ))]
+ LineFittingCalibration(adc_cali_handle_t),
+ }
+
+ impl Converter {
+ #[allow(unused_variables)]
+ fn create(
+ unit_id: u8,
+ chan: adc_channel_t,
+ atten: adc_atten_t,
+ bitwidth: adc_bits_width_t,
+ calibration: config::Calibration,
+ ) -> Result {
+ match calibration {
+ config::Calibration::None => Ok(Self::NoCalibration(atten)),
+ #[cfg(all(
+ any(esp_idf_comp_esp_adc_cal_enabled, esp_idf_comp_esp_adc_enabled),
+ any(
+ esp32c3,
+ all(
+ esp32c6,
+ not(all(esp_idf_version_major = "5", esp_idf_version_minor = "0")),
+ not(esp_idf_version_full = "5.1.0")
+ ),
+ esp32s3,
)
- };
+ ))]
+ config::Calibration::Curve => {
+ // it would be nice if esp-idf-sys could export some cfg values to replicate these two defines
+ // from esp-idf:
+ // ADC_CALI_SCHEME_CURVE_FITTING_SUPPORTED
+ // ADC_CALI_SCHEME_LINE_FITTING_SUPPORTED
+ // then we wouuld not need the ugliness for the esp32c6
+ let cal_config = adc_cali_curve_fitting_config_t {
+ unit_id: unit_id as u32,
+ #[cfg(all(
+ esp_idf_version_major = "5",
+ not(esp_idf_version_minor = "0"),
+ not(all(esp_idf_version_minor = "1", esp_idf_version_patch = "0"))
+ ))]
+ chan,
+ atten,
+ bitwidth,
+ };
+ let mut cal_handle: adc_cali_handle_t = core::ptr::null_mut();
+ esp!(unsafe {
+ esp_idf_sys::adc_cali_create_scheme_curve_fitting(
+ &cal_config,
+ &mut cal_handle,
+ )
+ })?;
+
+ Ok(Self::CurveFittingCalibration(cal_handle))
+ }
+ #[cfg(all(
+ any(esp_idf_comp_esp_adc_cal_enabled, esp_idf_comp_esp_adc_enabled),
+ any(esp32, esp32c2, esp32s2)
+ ))]
+ config::Calibration::Line => {
+ // esp32 has an additional field that the exanple defaults
+ // to using fuse values for vref. Maybe we should expose
+ // this as a config option?
+ #[allow(clippy::needless_update)]
+ let cal_config = adc_cali_line_fitting_config_t {
+ unit_id: unit_id as u32,
+ atten,
+ bitwidth,
+ ..Default::default()
+ };
+ let mut cal_handle: adc_cali_handle_t = core::ptr::null_mut();
+ esp!(unsafe {
+ esp_idf_sys::adc_cali_create_scheme_line_fitting(
+ &cal_config,
+ &mut cal_handle,
+ )
+ })?;
+
+ Ok(Self::LineFittingCalibration(cal_handle))
+ }
+ }
+ }
- characteristics[attenuation as usize] = Some(cal);
+ fn raw_to_mv(&self, raw: u16) -> Result {
+ match self {
+ Self::NoCalibration(atten) => Ok(DirectConverter(*atten).raw_to_mv(raw)),
+ #[cfg(all(
+ any(esp_idf_comp_esp_adc_cal_enabled, esp_idf_comp_esp_adc_enabled),
+ any(
+ esp32c3,
+ all(
+ esp32c6,
+ not(all(esp_idf_version_major = "5", esp_idf_version_minor = "0")),
+ not(esp_idf_version_full = "5.1.0")
+ ),
+ esp32s3,
+ )
+ ))]
+ Self::CurveFittingCalibration(handle) => {
+ let mut mv = 0i32;
+ esp!(unsafe { adc_cali_raw_to_voltage(*handle, raw as i32, &mut mv) })?;
+
+ Ok(mv as u16)
+ }
+ #[cfg(all(
+ any(esp_idf_comp_esp_adc_cal_enabled, esp_idf_comp_esp_adc_enabled),
+ any(esp32, esp32c2, esp32s2)
+ ))]
+ Self::LineFittingCalibration(handle) => {
+ let mut mv = 0i32;
+ esp!(unsafe { adc_cali_raw_to_voltage(*handle, raw as i32, &mut mv) })?;
+
+ Ok(mv as u16)
+ }
+ }
+ }
+ }
- Ok(Some(cal))
+ impl Drop for Converter {
+ fn drop(&mut self) {
+ match self {
+ Self::NoCalibration(_) => (),
+ #[cfg(all(
+ any(esp_idf_comp_esp_adc_cal_enabled, esp_idf_comp_esp_adc_enabled),
+ any(
+ esp32c3,
+ all(
+ esp32c6,
+ not(all(esp_idf_version_major = "5", esp_idf_version_minor = "0")),
+ not(esp_idf_version_full = "5.1.0")
+ ),
+ esp32s3,
+ )
+ ))]
+ Self::CurveFittingCalibration(handle) => {
+ esp!(unsafe { esp_idf_sys::adc_cali_delete_scheme_curve_fitting(*handle) })
+ .unwrap()
+ }
+ #[cfg(all(
+ any(esp_idf_comp_esp_adc_cal_enabled, esp_idf_comp_esp_adc_enabled),
+ any(esp32, esp32c2, esp32s2)
+ ))]
+ Self::LineFittingCalibration(handle) => {
+ esp!(unsafe { esp_idf_sys::adc_cali_delete_scheme_line_fitting(*handle) })
+ .unwrap()
+ }
}
- } else {
- Ok(None)
}
}
-}
-#[cfg(not(feature = "riscv-ulp-hal"))]
-impl<'d, ADC, ATTEN, PIN> embedded_hal_0_2::adc::OneShot for AdcDriver<'d, ADC>
-where
- ADC: Adc,
- ATTEN: Attenuation,
- PIN: embedded_hal_0_2::adc::Channel,
-{
- type Error = EspError;
-
- fn read(&mut self, _pin: &mut PIN) -> nb::Result {
- self.read_internal(
- ADC::unit(),
- PIN::channel() as adc_channel_t,
- ATTEN::attenuation(),
- )
- .map_err(to_nb_err)
+ pub struct AdcChannelDriver<'d, T, M>
+ where
+ T: ADCPin,
+ M: Borrow>,
+ {
+ adc: M,
+ _pin: PeripheralRef<'d, T>,
+ converter: Converter,
}
-}
-#[cfg(all(esp32, esp_idf_version_major = "4", not(feature = "riscv-ulp-hal")))]
-impl<'d> embedded_hal_0_2::adc::OneShot
- for AdcDriver<'d, ADC1>
-{
- type Error = EspError;
+ impl<'d, T, M> AdcChannelDriver<'d, T, M>
+ where
+ T: ADCPin,
+ M: Borrow>,
+ {
+ pub fn new(
+ adc: M,
+ pin: impl Peripheral + 'd,
+ config: &config::AdcChannelConfig,
+ ) -> Result {
+ crate::into_ref!(pin);
+
+ unsafe {
+ crate::gpio::rtc_reset_pin(pin.pin())?;
+ }
+
+ let chan_config = adc_oneshot_chan_cfg_t {
+ atten: config.attenuation,
+ bitwidth: config.resolution.into(),
+ };
+
+ let converter = Converter::create(
+ T::Adc::unit() as u8,
+ pin.adc_channel(),
+ config.attenuation,
+ config.resolution.into(),
+ config.calibration,
+ )?;
+
+ unsafe {
+ esp!(adc_oneshot_config_channel(
+ adc.borrow().handle,
+ pin.adc_channel(),
+ &chan_config
+ ))?
+ };
+
+ Ok(Self {
+ adc,
+ _pin: pin,
+ converter,
+ })
+ }
+
+ #[inline(always)]
+ pub fn read(&mut self) -> Result {
+ let raw = self.read_raw()?;
+ self.raw_to_mv(raw)
+ }
- fn read(&mut self, hall_sensor: &mut crate::hall::HallSensor) -> nb::Result {
- AdcDriver::read_hall(self, hall_sensor).map_err(to_nb_err)
+ #[inline(always)]
+ pub fn read_raw(&mut self) -> Result {
+ let channel = T::CHANNEL;
+ self.adc.borrow().read_raw_internal(channel)
+ }
+
+ #[inline(always)]
+ pub fn raw_to_mv(&self, raw: u16) -> Result {
+ self.converter.raw_to_mv(raw)
+ }
}
-}
-#[cfg(not(feature = "riscv-ulp-hal"))]
-fn to_nb_err(err: EspError) -> nb::Error {
- if err.code() == ESP_ERR_INVALID_STATE {
- nb::Error::WouldBlock
- } else {
- nb::Error::Other(err)
+ impl<'d, T, M> embedded_hal_0_2::adc::Channel for AdcChannelDriver<'d, T, M>
+ where
+ T: ADCPin,
+ M: Borrow>,
+ {
+ type ID = adc_channel_t;
+
+ fn channel() -> Self::ID {
+ T::CHANNEL
+ }
+ }
+
+ unsafe impl<'d, T, M> Send for AdcChannelDriver<'d, T, M>
+ where
+ T: ADCPin,
+ M: Borrow>,
+ {
+ }
+
+ pub struct AdcDriver<'d, ADC: Adc> {
+ handle: adc_oneshot_unit_handle_t,
+ _adc: PeripheralRef<'d, ADC>,
+ }
+
+ impl<'d, ADC: Adc> AdcDriver<'d, ADC> {
+ pub fn new(adc: impl Peripheral + 'd) -> Result {
+ crate::into_ref!(adc);
+ let config = adc_oneshot_unit_init_cfg_t {
+ unit_id: ADC::unit(),
+ ..Default::default()
+ };
+ let mut handle: adc_oneshot_unit_handle_t = core::ptr::null_mut();
+ unsafe { esp!(adc_oneshot_new_unit(&config, &mut handle))? };
+ Ok(Self { handle, _adc: adc })
+ }
+
+ #[inline(always)]
+ pub fn read(&self, channel: &mut AdcChannelDriver<'d, T, M>) -> Result
+ where
+ T: ADCPin,
+ M: Borrow>,
+ {
+ let raw = self.read_raw(channel)?;
+ self.raw_to_mv(channel, raw)
+ }
+
+ #[inline(always)]
+ pub fn read_raw(
+ &self,
+ _channel: &mut AdcChannelDriver<'d, T, M>,
+ ) -> Result
+ where
+ T: ADCPin,
+ M: Borrow>,
+ {
+ self.read_raw_internal(T::CHANNEL)
+ }
+
+ #[inline(always)]
+ fn read_raw_internal(&self, channel: adc_channel_t) -> Result {
+ let mut measurement = 0;
+ unsafe { esp!(adc_oneshot_read(self.handle, channel, &mut measurement)) }?;
+ Ok(measurement as u16)
+ }
+
+ #[inline(always)]
+ pub fn raw_to_mv(
+ &self,
+ channel: &AdcChannelDriver<'d, T, M>,
+ raw: u16,
+ ) -> Result
+ where
+ T: ADCPin,
+ M: Borrow>,
+ {
+ channel.converter.raw_to_mv(raw)
+ }
}
+
+ impl Drop for AdcDriver<'_, ADC> {
+ fn drop(&mut self) {
+ unsafe { esp!(adc_oneshot_del_unit(self.handle)) }.unwrap();
+ }
+ }
+
+ impl<'d, T, M> embedded_hal_0_2::adc::OneShot>
+ for AdcDriver<'d, T::Adc>
+ where
+ T: ADCPin,
+ M: Borrow>,
+ {
+ type Error = EspError;
+
+ fn read(&mut self, pin: &mut AdcChannelDriver<'d, T, M>) -> nb::Result {
+ AdcDriver::read(self, pin).map_err(to_nb_err)
+ }
+ }
+
+ unsafe impl Send for AdcDriver<'_, ADC> {}
+ unsafe impl Sync for AdcDriver<'_, ADC> {}
}
-macro_rules! impl_adc {
- ($adc:ident: $unit:expr) => {
- crate::impl_peripheral!($adc);
+/// Continuous ADC module
+/// Example: continuously reading value from a pin
+/// ```
+/// use ::log::{info, debug};
+///
+/// fn main() -> anyhow::Result<()> {
+/// use esp_idf_svc::hal::adc::{AdcContConfig, AdcContDriver, AdcMeasurement, Attenuated};
+/// use esp_idf_svc::hal::modem::Modem;
+/// use esp_idf_svc::hal::peripherals::Peripherals;
+/// use esp_idf_svc::sys::EspError;
+///
+/// esp_idf_svc::sys::link_patches();
+/// esp_idf_svc::log::EspLogger::initialize_default();
+///
+/// let peripherals = Peripherals::take()?;
+/// let config = AdcContConfig::default();
+///
+/// let adc_1_channel_0 = Attenuated::db12(peripherals.pins.gpio0);
+/// let mut adc = AdcContDriver::new(peripherals.adc1, &config, adc_1_channel_0)?;
+///
+/// adc.start()?;
+///
+/// /// Default to just read 100 measurements per each read
+/// let mut samples = [AdcMeasurement::default(); 100];
+///
+/// loop {
+/// if let Ok(num_read) = adc.read(&mut samples, 10) {
+/// debug!("Read {} measurement.", num_read);
+/// for index in 0..num_read {
+/// debug!("{}", samples[index].data());
+/// }
+/// }
+/// }
+/// }
+/// ```
+#[cfg(all(
+ not(esp_idf_version_major = "4"),
+ not(esp32c2),
+ esp_idf_comp_esp_adc_enabled
+))]
+pub mod continuous {
+ use core::ffi::c_void;
+ use core::fmt::{self, Debug, Display};
+ use core::marker::PhantomData;
- impl Adc for $adc {
- #[inline(always)]
- fn unit() -> adc_unit_t {
- $unit
+ use esp_idf_sys::*;
+
+ use crate::delay::{self, TickType};
+ use crate::gpio::{sealed::ADCPin as _, ADCPin};
+ use crate::interrupt::asynch::HalIsrNotification;
+ use crate::io::EspIOError;
+ use crate::peripheral::Peripheral;
+
+ use super::{attenuation, Adc};
+
+ /// Set ADC attenuation level
+ /// Example: let pin = Attenuated::db12(peripherals.pins.gpio0);
+ pub struct Attenuated(T);
+
+ impl Attenuated<{ attenuation::NONE }, T> {
+ pub const fn none(t: T) -> Self {
+ Self(t)
+ }
+ }
+
+ impl Attenuated<{ attenuation::DB_2_5 }, T> {
+ pub const fn db2_5(t: T) -> Self {
+ Self(t)
+ }
+ }
+
+ impl Attenuated<{ attenuation::DB_6 }, T> {
+ pub const fn db6(t: T) -> Self {
+ Self(t)
+ }
+ }
+
+ #[allow(deprecated)]
+ impl Attenuated<{ attenuation::DB_11 }, T> {
+ #[cfg_attr(
+ not(esp_idf_version_major = "4"),
+ deprecated(since = "0.45.3", note = "Use `Attenuated::db12` instead")
+ )]
+ pub const fn db11(t: T) -> Self {
+ Self(t)
+ }
+ }
+
+ #[cfg(not(esp_idf_version_major = "4"))]
+ impl Attenuated<{ attenuation::DB_12 }, T> {
+ pub const fn db12(t: T) -> Self {
+ Self(t)
+ }
+ }
+
+ impl Attenuated {
+ pub fn atten(channel: (adc_channel_t, adc_atten_t)) -> (adc_channel_t, adc_atten_t) {
+ (channel.0, A)
+ }
+ }
+
+ pub type AttenNone = Attenuated<{ attenuation::NONE }, T>;
+ pub type Atten2p5dB = Attenuated<{ attenuation::DB_2_5 }, T>;
+ pub type Atten6dB = Attenuated<{ attenuation::DB_6 }, T>;
+ #[deprecated(since = "0.45.3", note = "Use `Atten12dB` instead")]
+ #[allow(deprecated)]
+ pub type Atten11dB = Attenuated<{ attenuation::DB_11 }, T>;
+ pub type Atten12dB = Attenuated<{ attenuation::DB_12 }, T>;
+
+ pub trait AdcChannels {
+ type Adc: Adc;
+ type Iterator<'a>: Iterator-
+ where
+ Self: 'a;
+
+ fn iter(&self) -> Self::Iterator<'_>;
+ }
+
+ impl
AdcChannels for P
+ where
+ P: Peripheral,
+ P::P: ADCPin,
+ {
+ type Adc = <
::P as ADCPin>::Adc;
+
+ type Iterator<'a>
+ = core::iter::Once<(adc_channel_t, adc_atten_t)>
+ where
+ Self: 'a;
+
+ fn iter(&self) -> Self::Iterator<'_> {
+ core::iter::once((P::P::CHANNEL, attenuation::NONE))
+ }
+ }
+
+ impl AdcChannels for Attenuated
+ where
+ C: AdcChannels,
+ {
+ type Adc = C::Adc;
+
+ type Iterator<'a>
+ = core::iter::Map<
+ C::Iterator<'a>,
+ fn((adc_channel_t, adc_atten_t)) -> (adc_channel_t, adc_atten_t),
+ >
+ where
+ Self: 'a;
+
+ fn iter(&self) -> Self::Iterator<'_> {
+ self.0.iter().map(Attenuated::::atten)
+ }
+ }
+
+ pub struct AdcChannelsArray(pub [C; N]);
+
+ impl AdcChannels for AdcChannelsArray
+ where
+ C: AdcChannels,
+ {
+ type Adc = C::Adc;
+
+ type Iterator<'a>
+ = core::iter::FlatMap<
+ core::slice::Iter<'a, C>,
+ ::Iterator<'a>,
+ fn(&'a C) -> C::Iterator<'a>,
+ >
+ where
+ Self: 'a;
+
+ fn iter(&self) -> Self::Iterator<'_> {
+ self.0.iter().flat_map(AdcChannels::iter)
+ }
+ }
+
+ pub struct EmptyAdcChannels(PhantomData);
+
+ impl EmptyAdcChannels {
+ pub fn chain(other: O) -> ChainedAdcChannels
+ where
+ A: Adc,
+ O: AdcChannels,
+ {
+ ChainedAdcChannels {
+ first: Self(PhantomData),
+ second: other,
}
}
- };
-}
+ }
-impl_adc!(ADC1: adc_unit_t_ADC_UNIT_1);
-impl_adc!(ADC2: adc_unit_t_ADC_UNIT_2);
+ impl AdcChannels for EmptyAdcChannels
+ where
+ A: Adc,
+ {
+ type Adc = A;
+
+ type Iterator<'a>
+ = core::iter::Empty<(adc_channel_t, adc_atten_t)>
+ where
+ Self: 'a;
+
+ fn iter(&self) -> Self::Iterator<'_> {
+ core::iter::empty()
+ }
+ }
+
+ pub struct ChainedAdcChannels {
+ first: F,
+ second: S,
+ }
+
+ impl ChainedAdcChannels {
+ pub fn chain(self, other: O) -> ChainedAdcChannels
+ where
+ F: AdcChannels,
+ S: AdcChannels,
+ O: AdcChannels,
+ {
+ ChainedAdcChannels {
+ first: self,
+ second: other,
+ }
+ }
+ }
+
+ impl AdcChannels for ChainedAdcChannels
+ where
+ F: AdcChannels,
+ S: AdcChannels,
+ {
+ type Adc = F::Adc;
+
+ type Iterator<'a>
+ = core::iter::Chain, S::Iterator<'a>>
+ where
+ Self: 'a;
+
+ fn iter(&self) -> Self::Iterator<'_> {
+ self.first.iter().chain(self.second.iter())
+ }
+ }
+
+ #[derive(Copy, Clone)]
+ #[repr(transparent)]
+ pub struct AdcMeasurement(adc_digi_output_data_t);
+
+ impl Default for AdcMeasurement {
+ fn default() -> Self {
+ Self::new()
+ }
+ }
+
+ impl AdcMeasurement {
+ pub const INIT: Self = AdcMeasurement(unsafe {
+ core::mem::transmute::<
+ [u8; core::mem::size_of::()],
+ adc_digi_output_data_t,
+ >([0u8; core::mem::size_of::()])
+ });
+
+ pub const fn new() -> Self {
+ Self::INIT
+ }
+
+ #[cfg(any(esp32, esp32s2))]
+ pub fn data(&self) -> u16 {
+ unsafe { self.0.__bindgen_anon_1.type1.data() as _ }
+ }
+
+ #[cfg(any(esp32, esp32s2))]
+ pub fn channel(&self) -> adc_channel_t {
+ unsafe { self.0.__bindgen_anon_1.type1.channel() as _ }
+ }
+
+ #[cfg(not(any(esp32, esp32s2)))]
+ pub fn data(&self) -> u16 {
+ unsafe { self.0.__bindgen_anon_1.type2.data() as _ }
+ }
+
+ #[cfg(not(any(esp32, esp32s2)))]
+ pub fn channel(&self) -> adc_channel_t {
+ unsafe { self.0.__bindgen_anon_1.type2.channel() as _ }
+ }
+
+ #[cfg(not(any(esp32, esp32s2, esp32h2, esp32c6)))]
+ pub fn unit(&self) -> adc_unit_t {
+ unsafe { self.0.__bindgen_anon_1.type2.unit() as _ }
+ }
+
+ #[cfg(any(esp32, esp32s2))]
+ pub fn nullify(&mut self) {
+ self.0.__bindgen_anon_1.val = self.data();
+ }
+
+ #[cfg(not(any(esp32, esp32s2)))]
+ pub fn nullify(&mut self) {
+ self.0.__bindgen_anon_1.val = self.data() as _;
+ }
+
+ #[cfg(any(esp32, esp32s2))]
+ pub fn as_pcm16(data: &mut [AdcMeasurement]) -> &mut [u16] {
+ for measurement in data.iter_mut() {
+ measurement.nullify();
+ }
+
+ unsafe { core::slice::from_raw_parts_mut(data.as_mut_ptr() as *mut _, data.len()) }
+ }
+
+ #[cfg(not(any(esp32, esp32s2)))]
+ pub fn as_pcm32(data: &mut [AdcMeasurement]) -> &mut [u32] {
+ for measurement in data.iter_mut() {
+ measurement.nullify();
+ }
+
+ unsafe { core::slice::from_raw_parts_mut(data.as_mut_ptr() as *mut _, data.len()) }
+ }
+ }
+
+ impl Display for AdcMeasurement {
+ fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
+ write!(
+ f,
+ "ADC Reading {{channel={}, data={}}}",
+ self.channel(),
+ self.data()
+ )
+ }
+ }
+
+ impl Debug for AdcMeasurement {
+ fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
+ write!(
+ f,
+ "AdcMeasurement {{channel: {}, data: {}}}",
+ self.channel(),
+ self.data()
+ )
+ }
+ }
+
+ pub mod config {
+ use crate::units::*;
+
+ /// ADC continuous mode driver configurations.
+ /// The default configuration is:
+ /// * [`sample_freq`][Config::sample_freq]: 2000 Hz
+ /// * [`frame_measurements`][Config::frame_measurements]: 100
+ /// * [`frames_count`][Config::frames_count]: 10
+ #[derive(Debug, Copy, Clone)]
+ pub struct Config {
+ pub sample_freq: Hertz,
+ pub frame_measurements: usize,
+ pub frames_count: usize,
+ }
+
+ impl Config {
+ pub const fn new() -> Self {
+ Self {
+ sample_freq: Hertz(20000),
+ frame_measurements: 100,
+ frames_count: 10,
+ }
+ }
+
+ #[must_use]
+ pub fn sample_freq(mut self, sample_freq: Hertz) -> Self {
+ self.sample_freq = sample_freq;
+ self
+ }
+
+ #[must_use]
+ pub fn frame_measurements(mut self, frame_measurements: usize) -> Self {
+ self.frame_measurements = frame_measurements;
+ self
+ }
+
+ #[must_use]
+ pub fn frames_count(mut self, frames_count: usize) -> Self {
+ self.frames_count = frames_count;
+ self
+ }
+ }
+
+ impl Default for Config {
+ fn default() -> Self {
+ Self::new()
+ }
+ }
+ }
+
+ pub struct AdcDriver<'d> {
+ handle: adc_continuous_handle_t,
+ adc: u8,
+ _ref: PhantomData<&'d ()>,
+ }
+
+ impl<'d> AdcDriver<'d> {
+ /// Initialize ADC continuous driver with configuration and channels.
+ #[cfg(esp32)]
+ pub fn new(
+ adc: impl Peripheral + 'd,
+ _i2s: impl Peripheral
+ 'd,
+ config: &config::Config,
+ channels: impl AdcChannels + 'd,
+ ) -> Result {
+ Self::internal_new(adc, config, channels)
+ }
+
+ /// Initialize ADC continuous driver with configuration and channels
+ #[cfg(esp32s2)]
+ pub fn new(
+ adc: impl Peripheral + 'd,
+ _spi: impl Peripheral
+ 'd,
+ config: &config::Config,
+ channels: impl AdcChannels + 'd,
+ ) -> Result {
+ Self::internal_new(adc, config, channels)
+ }
+
+ /// Initialize ADC continuous driver with configuration and channels.
+ #[cfg(not(any(esp32, esp32s2)))]
+ pub fn new(
+ adc: impl Peripheral + 'd,
+ config: &config::Config,
+ channels: impl AdcChannels + 'd,
+ ) -> Result {
+ Self::internal_new(adc, config, channels)
+ }
+
+ fn internal_new(
+ _adc: impl Peripheral + 'd,
+ config: &config::Config,
+ channels: impl AdcChannels + 'd,
+ ) -> Result {
+ let mut patterns = [adc_digi_pattern_config_t::default(); 32];
+
+ for (index, (channel, atten)) in channels.iter().enumerate() {
+ if index >= patterns.len() {
+ return Err(EspError::from_infallible::());
+ }
+
+ patterns[index].atten = atten as _;
+ patterns[index].channel = channel as _;
+ patterns[index].unit = A::unit() as _;
+ patterns[index].bit_width = 12; // For now only 12 bits is supported
+ }
+
+ let mut handle: adc_continuous_handle_t = core::ptr::null_mut();
+
+ #[allow(clippy::needless_update)]
+ esp!(unsafe {
+ adc_continuous_new_handle(
+ &adc_continuous_handle_cfg_t {
+ max_store_buf_size: SOC_ADC_DIGI_DATA_BYTES_PER_CONV
+ * (config.frame_measurements as u32)
+ * (config.frames_count as u32),
+ conv_frame_size: SOC_ADC_DIGI_DATA_BYTES_PER_CONV
+ * (config.frame_measurements as u32),
+ ..Default::default()
+ },
+ &mut handle,
+ )
+ })?;
+
+ let conv_mode = if A::unit() == 0 {
+ adc_digi_convert_mode_t_ADC_CONV_SINGLE_UNIT_1
+ } else {
+ adc_digi_convert_mode_t_ADC_CONV_SINGLE_UNIT_2
+ };
+
+ #[cfg(any(esp32, esp32s2))]
+ let format = adc_digi_output_format_t_ADC_DIGI_OUTPUT_FORMAT_TYPE1;
+
+ #[cfg(not(any(esp32, esp32s2)))]
+ let format = adc_digi_output_format_t_ADC_DIGI_OUTPUT_FORMAT_TYPE2;
+
+ esp!(unsafe {
+ adc_continuous_config(
+ handle,
+ &adc_continuous_config_t {
+ pattern_num: channels.iter().count() as _,
+ adc_pattern: &patterns as *const _ as *mut _,
+ sample_freq_hz: config.sample_freq.into(),
+ conv_mode,
+ format,
+ },
+ )
+ })?;
+
+ #[cfg(not(esp_idf_adc_continuous_isr_iram_safe))]
+ {
+ esp!(unsafe {
+ adc_continuous_register_event_callbacks(
+ handle,
+ &adc_continuous_evt_cbs_t {
+ on_conv_done: Some(Self::handle_isr),
+ on_pool_ovf: Some(Self::handle_isr),
+ },
+ &NOTIFIER[A::unit() as usize] as *const _ as *mut _,
+ )
+ })?;
+ }
+
+ Ok(Self {
+ handle,
+ adc: A::unit() as _,
+ _ref: PhantomData,
+ })
+ }
+
+ /// Get the ADC driver handle.
+ pub fn handle(&self) -> adc_continuous_handle_t {
+ self.handle
+ }
+
+ // Get the ADC unit. ADC1 or ADC2.
+ pub fn unit(&self) -> adc_unit_t {
+ self.adc as _
+ }
+
+ /// Start the ADC under continuous mode and generate results.
+ pub fn start(&mut self) -> Result<(), EspError> {
+ esp!(unsafe { adc_continuous_start(self.handle) })
+ }
+
+ /// Stop the ADC.
+ pub fn stop(&mut self) -> Result<(), EspError> {
+ esp!(unsafe { adc_continuous_stop(self.handle) })
+ }
+
+ /// Read `AdcMeasurements` in continuous mode.
+ pub fn read(
+ &mut self,
+ buf: &mut [AdcMeasurement],
+ timeout: TickType_t,
+ ) -> Result {
+ let mut read: u32 = 0;
+
+ esp!(unsafe {
+ adc_continuous_read(
+ self.handle,
+ buf.as_mut_ptr() as *mut _,
+ core::mem::size_of_val(buf) as _,
+ &mut read,
+ TickType(timeout).as_millis_u32(),
+ )
+ })?;
+
+ Ok(read as usize / core::mem::size_of::())
+ }
+
+ /// Read bytes in continuous mode.
+ pub fn read_bytes(
+ &mut self,
+ buf: &mut [u8],
+ timeout: TickType_t,
+ ) -> Result {
+ let mut read: u32 = 0;
+
+ esp!(unsafe {
+ adc_continuous_read(
+ self.handle,
+ buf.as_mut_ptr() as *mut _,
+ core::mem::size_of_val(buf) as _,
+ &mut read,
+ TickType(timeout).as_millis_u32(),
+ )
+ })?;
+
+ Ok(read as usize)
+ }
+
+ #[cfg(not(esp_idf_adc_continuous_isr_iram_safe))]
+ pub async fn read_async(&mut self, buf: &mut [AdcMeasurement]) -> Result {
+ loop {
+ match self.read(buf, delay::NON_BLOCK) {
+ Ok(len) if len > 0 => return Ok(len),
+ Err(e) if e.code() != ESP_ERR_TIMEOUT => return Err(e),
+ _ => {
+ NOTIFIER[self.adc as usize].wait().await;
+ }
+ }
+ }
+ }
+
+ #[cfg(not(esp_idf_adc_continuous_isr_iram_safe))]
+ pub async fn read_bytes_async(&mut self, buf: &mut [u8]) -> Result {
+ loop {
+ match self.read_bytes(buf, delay::NON_BLOCK) {
+ Ok(len) if len > 0 => return Ok(len),
+ Err(e) if e.code() != ESP_ERR_TIMEOUT => return Err(e),
+ _ => {
+ NOTIFIER[self.adc as usize].wait().await;
+ }
+ }
+ }
+ }
+
+ #[cfg(not(esp_idf_adc_continuous_isr_iram_safe))]
+ extern "C" fn handle_isr(
+ _handle: adc_continuous_handle_t,
+ _data: *const adc_continuous_evt_data_t,
+ user_data: *mut c_void,
+ ) -> bool {
+ let notifier: &HalIsrNotification =
+ unsafe { (user_data as *const HalIsrNotification).as_ref() }.unwrap();
+
+ notifier.notify_lsb()
+ }
+ }
+
+ impl Drop for AdcDriver<'_> {
+ fn drop(&mut self) {
+ let _ = self.stop();
+
+ #[cfg(not(esp_idf_adc_continuous_isr_iram_safe))]
+ {
+ esp!(unsafe {
+ adc_continuous_register_event_callbacks(
+ self.handle,
+ &adc_continuous_evt_cbs_t {
+ on_conv_done: None,
+ on_pool_ovf: None,
+ },
+ core::ptr::null_mut(),
+ )
+ })
+ .unwrap();
+ }
+
+ esp!(unsafe { adc_continuous_deinit(self.handle) }).unwrap();
+
+ #[cfg(not(esp_idf_adc_continuous_isr_iram_safe))]
+ NOTIFIER[self.adc as usize].reset();
+ }
+ }
+
+ unsafe impl Send for AdcDriver<'_> {}
+
+ impl embedded_io::ErrorType for AdcDriver<'_> {
+ type Error = EspIOError;
+ }
+
+ impl embedded_io::Read for AdcDriver<'_> {
+ fn read(&mut self, buf: &mut [u8]) -> Result {
+ self.read_bytes(buf, delay::BLOCK).map_err(EspIOError)
+ }
+ }
+
+ #[cfg(not(esp_idf_adc_continuous_isr_iram_safe))]
+ impl embedded_io_async::Read for AdcDriver<'_> {
+ async fn read(&mut self, buf: &mut [u8]) -> Result {
+ self.read_bytes_async(buf).await.map_err(EspIOError)
+ }
+ }
+
+ #[cfg(not(esp_idf_adc_continuous_isr_iram_safe))]
+ #[cfg(any(esp32c2, esp32h2, esp32c5, esp32c6, esp32p4))] // TODO: Check for esp32c5 and esp32p4
+ static NOTIFIER: [HalIsrNotification; 1] = [HalIsrNotification::new()];
+
+ #[cfg(not(esp_idf_adc_continuous_isr_iram_safe))]
+ #[cfg(not(any(esp32c2, esp32h2, esp32c5, esp32c6, esp32p4)))] // TODO: Check for esp32c5 and esp32p4
+ static NOTIFIER: [HalIsrNotification; 2] =
+ [HalIsrNotification::new(), HalIsrNotification::new()];
+}
diff --git a/src/can.rs b/src/can.rs
index 7c0ff37e14b..c03d54e0dba 100644
--- a/src/can.rs
+++ b/src/can.rs
@@ -32,11 +32,23 @@
//! }
//! ```
+use core::borrow::BorrowMut;
+use core::ffi::CStr;
+use core::marker::PhantomData;
+use core::num::NonZeroU32;
+
+use enumset::{EnumSet, EnumSetType};
+
use esp_idf_sys::*;
-use crate::delay::{BLOCK, NON_BLOCK};
-use crate::gpio::*;
+use num_enum::TryFromPrimitive;
+
+use crate::cpu::Core;
+use crate::delay::{self, BLOCK, NON_BLOCK};
+use crate::interrupt::InterruptType;
use crate::peripheral::{Peripheral, PeripheralRef};
+use crate::task::asynch::Notification;
+use crate::{gpio::*, task};
crate::embedded_hal_error!(CanError, embedded_can::Error, embedded_can::ErrorKind);
@@ -49,8 +61,13 @@ crate::embedded_hal_error!(
pub type CanConfig = config::Config;
pub mod config {
+ use enumset::EnumSet;
use esp_idf_sys::*;
+ use crate::interrupt::InterruptType;
+
+ use super::Alert;
+
/// CAN timing
#[derive(Debug, Copy, Clone, Eq, PartialEq)]
pub enum Timing {
@@ -80,7 +97,6 @@ pub mod config {
tseg_1: 16,
tseg_2: 8,
sjw: 3,
- triple_sampling: false,
..Default::default()
},
Timing::B50K => twai_timing_config_t {
@@ -88,7 +104,6 @@ pub mod config {
tseg_1: 15,
tseg_2: 4,
sjw: 3,
- triple_sampling: false,
..Default::default()
},
Timing::B100K => twai_timing_config_t {
@@ -96,7 +111,6 @@ pub mod config {
tseg_1: 15,
tseg_2: 4,
sjw: 3,
- triple_sampling: false,
..Default::default()
},
Timing::B125K => twai_timing_config_t {
@@ -104,7 +118,6 @@ pub mod config {
tseg_1: 15,
tseg_2: 4,
sjw: 3,
- triple_sampling: false,
..Default::default()
},
Timing::B250K => twai_timing_config_t {
@@ -112,7 +125,6 @@ pub mod config {
tseg_1: 15,
tseg_2: 4,
sjw: 3,
- triple_sampling: false,
..Default::default()
},
Timing::B500K => twai_timing_config_t {
@@ -120,7 +132,6 @@ pub mod config {
tseg_1: 15,
tseg_2: 4,
sjw: 3,
- triple_sampling: false,
..Default::default()
},
Timing::B800K => twai_timing_config_t {
@@ -128,7 +139,6 @@ pub mod config {
tseg_1: 16,
tseg_2: 8,
sjw: 3,
- triple_sampling: false,
..Default::default()
},
Timing::B1M => twai_timing_config_t {
@@ -136,7 +146,6 @@ pub mod config {
tseg_1: 15,
tseg_2: 4,
sjw: 3,
- triple_sampling: false,
..Default::default()
},
Timing::Custom {
@@ -150,7 +159,24 @@ pub mod config {
tseg_1: timing_segment_1,
tseg_2: timing_segment_2,
sjw: synchronization_jump_width,
+ #[cfg(any(
+ esp_idf_version_major = "4",
+ esp_idf_version = "5.0",
+ esp_idf_version = "5.1",
+ esp_idf_version = "5.2",
+ esp_idf_version = "5.3",
+ esp_idf_version = "5.4"
+ ))]
triple_sampling,
+ #[cfg(not(any(
+ esp_idf_version_major = "4",
+ esp_idf_version = "5.0",
+ esp_idf_version = "5.1",
+ esp_idf_version = "5.2",
+ esp_idf_version = "5.3",
+ esp_idf_version = "5.4"
+ )))]
+ __bindgen_anon_1: twai_timing_config_t__bindgen_ty_1 { triple_sampling },
..Default::default()
},
}
@@ -211,9 +237,16 @@ pub mod config {
/// ```
#[derive(Debug, Copy, Clone, Eq, PartialEq)]
pub enum Filter {
- // Filter for 11 bit standard CAN IDs
+ /// Filter for 11 bit standard CAN IDs
Standard { filter: u16, mask: u16 },
- // Filter for 29 bit extended CAN IDs
+ /// Filter for two 11 bit standard CAN IDs
+ Dual {
+ filter1: u16,
+ mask1: u16,
+ filter2: u16,
+ mask2: u16,
+ },
+ /// Filter for 29 bit extended CAN IDs
Extended { filter: u32, mask: u32 },
}
@@ -236,14 +269,45 @@ pub mod config {
}
#[derive(Debug, Copy, Clone, Default)]
+ pub enum Mode {
+ #[default]
+ Normal,
+ NoAck,
+ ListenOnly,
+ }
+
+ impl From for twai_mode_t {
+ fn from(val: Mode) -> Self {
+ match val {
+ Mode::Normal => twai_mode_t_TWAI_MODE_NORMAL,
+ Mode::NoAck => twai_mode_t_TWAI_MODE_NO_ACK,
+ Mode::ListenOnly => twai_mode_t_TWAI_MODE_LISTEN_ONLY,
+ }
+ }
+ }
+
+ #[derive(Debug, Clone)]
pub struct Config {
pub timing: Timing,
pub filter: Filter,
+ pub tx_queue_len: u32,
+ pub rx_queue_len: u32,
+ pub mode: Mode,
+ pub alerts: EnumSet,
+ pub intr_flags: EnumSet,
}
impl Config {
pub fn new() -> Self {
- Default::default()
+ Self {
+ timing: Default::default(),
+ filter: Default::default(),
+ tx_queue_len: 5,
+ rx_queue_len: 5,
+ mode: Default::default(),
+ alerts: Default::default(),
+ intr_flags: EnumSet::::empty(),
+ }
}
#[must_use]
@@ -257,113 +321,198 @@ pub mod config {
self.filter = filter;
self
}
+
+ #[must_use]
+ pub fn tx_queue_len(mut self, tx_queue_len: u32) -> Self {
+ self.tx_queue_len = tx_queue_len;
+ self
+ }
+
+ #[must_use]
+ pub fn rx_queue_len(mut self, rx_queue_len: u32) -> Self {
+ self.rx_queue_len = rx_queue_len;
+ self
+ }
+
+ #[must_use]
+ pub fn mode(mut self, mode: Mode) -> Self {
+ self.mode = mode;
+ self
+ }
+
+ #[must_use]
+ pub fn alerts(mut self, alerts: EnumSet) -> Self {
+ self.alerts = alerts;
+ self
+ }
+
+ #[must_use]
+ pub fn intr_flags(mut self, flags: EnumSet) -> Self {
+ self.intr_flags = flags;
+ self
+ }
+ }
+
+ impl Default for Config {
+ fn default() -> Self {
+ Self::new()
+ }
}
}
-/// CAN abstraction
-pub struct CanDriver<'d>(PeripheralRef<'d, CAN>);
+#[derive(Debug, EnumSetType, TryFromPrimitive)]
+#[enumset(repr = "u32")]
+#[repr(u32)]
+pub enum Alert {
+ TransmitIdle = 1,
+ Success = 2,
+ Received = 3,
+ BelowErrorWarning = 4,
+ ActiveError = 5,
+ RecoveryInProgress = 6,
+ BusRecovered = 7,
+ ArbLost = 8,
+ AboveErrorWarning = 9,
+ BusError = 10,
+ TransmitFailed = 11,
+ ReceiveQueueFull = 12,
+ ErrorPass = 13,
+ BusOffline = 14,
+ ReceiveFifoOverflow = 15,
+ TransmitRetried = 16,
+ PeripheralReset = 17,
+ AlertAndLog = 18,
+}
-unsafe impl<'d> Send for CanDriver<'d> {}
+/// CAN abstraction
+pub struct CanDriver<'d>(PeripheralRef<'d, CAN>, EnumSet, bool);
impl<'d> CanDriver<'d> {
pub fn new(
can: impl Peripheral + 'd,
tx: impl Peripheral
+ 'd,
- rx: impl Peripheral
+ 'd,
+ rx: impl Peripheral
+ 'd,
config: &config::Config,
) -> Result {
crate::into_ref!(can, tx, rx);
+ #[allow(clippy::needless_update)]
let general_config = twai_general_config_t {
- mode: twai_mode_t_TWAI_MODE_NORMAL,
+ mode: config.mode.into(),
tx_io: tx.pin(),
rx_io: rx.pin(),
clkout_io: -1,
bus_off_io: -1,
- tx_queue_len: 5,
- rx_queue_len: 5,
- alerts_enabled: TWAI_ALERT_NONE,
+ tx_queue_len: config.tx_queue_len,
+ rx_queue_len: config.rx_queue_len,
+ alerts_enabled: config.alerts.as_repr(),
clkout_divider: 0,
- intr_flags: ESP_INTR_FLAG_LEVEL1 as i32,
+ intr_flags: InterruptType::to_native(config.intr_flags) as _,
+ ..Default::default()
};
let timing_config = config.timing.into();
// modify filter and mask to be compatible with TWAI acceptance filter
- let (filter, mask) = match config.filter {
+ let (filter, mask, single_filter) = match config.filter {
config::Filter::Standard { filter, mask } => {
- ((filter as u32) << 21, !((mask as u32) << 21))
+ ((filter as u32) << 21, !((mask as u32) << 21), true)
}
- config::Filter::Extended { filter, mask } => (filter << 3, !(mask << 3)),
+ config::Filter::Extended { filter, mask } => (filter << 3, !(mask << 3), true),
+ config::Filter::Dual {
+ filter1,
+ mask1,
+ filter2,
+ mask2,
+ } => (
+ ((filter1 as u32) << 21) | ((filter2 as u32) << 5),
+ !(((mask1 as u32) << 21) | ((mask2 as u32) << 5)),
+ false,
+ ),
};
let filter_config = twai_filter_config_t {
acceptance_code: filter,
acceptance_mask: mask,
- single_filter: true,
+ single_filter,
};
esp!(unsafe { twai_driver_install(&general_config, &timing_config, &filter_config) })?;
- esp!(unsafe { twai_start() })?;
- Ok(Self(can))
+ Ok(Self(can, config.alerts, config.tx_queue_len > 0))
+ }
+
+ pub fn start(&mut self) -> Result<(), EspError> {
+ esp!(unsafe { twai_start() })
}
- pub fn transmit(&mut self, frame: &Frame, timeout: TickType_t) -> Result<(), EspError> {
+ pub fn stop(&mut self) -> Result<(), EspError> {
+ esp!(unsafe { twai_stop() })
+ }
+
+ pub fn transmit(&self, frame: &Frame, timeout: TickType_t) -> Result<(), EspError> {
esp!(unsafe { twai_transmit(&frame.0, timeout) })
}
- pub fn receive(&mut self, timeout: TickType_t) -> Result {
- let mut rx_msg = twai_message_t {
- ..Default::default()
- };
+ pub fn receive(&self, timeout: TickType_t) -> Result {
+ let mut rx_msg = Default::default();
match esp_result!(unsafe { twai_receive(&mut rx_msg, timeout) }, ()) {
Ok(_) => Ok(Frame(rx_msg)),
Err(err) => Err(err),
}
}
+
+ pub fn read_alerts(&self, timeout: TickType_t) -> Result, EspError> {
+ let mut alerts = 0;
+
+ esp!(unsafe { twai_read_alerts(&mut alerts, timeout) })?;
+
+ Ok(EnumSet::from_repr_truncated(alerts))
+ }
}
-impl<'d> Drop for CanDriver<'d> {
+impl Drop for CanDriver<'_> {
fn drop(&mut self) {
- esp!(unsafe { twai_stop() }).unwrap();
+ let _ = self.stop();
esp!(unsafe { twai_driver_uninstall() }).unwrap();
}
}
-impl<'d> embedded_hal_0_2::blocking::can::Can for CanDriver<'d> {
+unsafe impl Send for CanDriver<'_> {}
+
+impl embedded_hal_0_2::blocking::can::Can for CanDriver<'_> {
type Frame = Frame;
type Error = Can02Error;
fn transmit(&mut self, frame: &Self::Frame) -> Result<(), Self::Error> {
- self.transmit(frame, BLOCK).map_err(Can02Error::other)
+ CanDriver::transmit(self, frame, BLOCK).map_err(Can02Error::other)
}
fn receive(&mut self) -> Result {
- self.receive(BLOCK).map_err(Can02Error::other)
+ CanDriver::receive(self, BLOCK).map_err(Can02Error::other)
}
}
-impl<'d> embedded_can::blocking::Can for CanDriver<'d> {
+impl embedded_can::blocking::Can for CanDriver<'_> {
type Frame = Frame;
type Error = CanError;
fn transmit(&mut self, frame: &Self::Frame) -> Result<(), Self::Error> {
- self.transmit(frame, BLOCK).map_err(CanError::other)
+ CanDriver::transmit(self, frame, BLOCK).map_err(CanError::other)
}
fn receive(&mut self) -> Result {
- self.receive(BLOCK).map_err(CanError::other)
+ CanDriver::receive(self, BLOCK).map_err(CanError::other)
}
}
-impl<'d> embedded_hal_0_2::can::nb::Can for CanDriver<'d> {
+impl embedded_hal_0_2::can::nb::Can for CanDriver<'_> {
type Frame = Frame;
type Error = Can02Error;
fn transmit(&mut self, frame: &Self::Frame) -> nb::Result, Self::Error> {
- match self.transmit(frame, NON_BLOCK) {
+ match CanDriver::transmit(self, frame, NON_BLOCK) {
Ok(_) => Ok(None),
Err(e) if e.code() == ESP_FAIL => Err(nb::Error::WouldBlock),
Err(e) if e.code() == ESP_ERR_TIMEOUT => Err(nb::Error::WouldBlock),
@@ -372,7 +521,7 @@ impl<'d> embedded_hal_0_2::can::nb::Can for CanDriver<'d> {
}
fn receive(&mut self) -> nb::Result {
- match self.receive(NON_BLOCK) {
+ match CanDriver::receive(self, NON_BLOCK) {
Ok(frame) => Ok(frame),
Err(e) if e.code() == ESP_ERR_TIMEOUT => Err(nb::Error::WouldBlock),
Err(e) => Err(nb::Error::Other(Can02Error::other(e))),
@@ -380,12 +529,12 @@ impl<'d> embedded_hal_0_2::can::nb::Can for CanDriver<'d> {
}
}
-impl<'d> embedded_can::nb::Can for CanDriver<'d> {
+impl embedded_can::nb::Can for CanDriver<'_> {
type Frame = Frame;
type Error = CanError;
fn transmit(&mut self, frame: &Self::Frame) -> nb::Result, Self::Error> {
- match self.transmit(frame, NON_BLOCK) {
+ match CanDriver::transmit(self, frame, NON_BLOCK) {
Ok(_) => Ok(None),
Err(e) if e.code() == ESP_FAIL => Err(nb::Error::WouldBlock),
Err(e) if e.code() == ESP_ERR_TIMEOUT => Err(nb::Error::WouldBlock),
@@ -394,7 +543,7 @@ impl<'d> embedded_can::nb::Can for CanDriver<'d> {
}
fn receive(&mut self) -> nb::Result {
- match self.receive(NON_BLOCK) {
+ match CanDriver::receive(self, NON_BLOCK) {
Ok(frame) => Ok(frame),
Err(e) if e.code() == ESP_ERR_TIMEOUT => Err(nb::Error::WouldBlock),
Err(e) => Err(nb::Error::Other(CanError::other(e))),
@@ -402,28 +551,241 @@ impl<'d> embedded_can::nb::Can for CanDriver<'d> {
}
}
+fn read_alerts() -> EnumSet {
+ Alert::Success | Alert::Received | Alert::ReceiveQueueFull
+}
+
+fn write_alerts() -> EnumSet {
+ Alert::Success | Alert::TransmitIdle | Alert::TransmitFailed | Alert::TransmitRetried
+}
+
+pub type OwnedAsyncCanDriver<'d> = AsyncCanDriver<'d, CanDriver<'d>>;
+
+pub struct AsyncCanDriver<'d, T>
+where
+ T: BorrowMut>,
+{
+ driver: T,
+ task: TaskHandle_t,
+ _data: PhantomData<&'d ()>,
+}
+
+impl<'d> AsyncCanDriver<'d, CanDriver<'d>> {
+ pub fn new(
+ can: impl Peripheral + 'd,
+ tx: impl Peripheral
+ 'd,
+ rx: impl Peripheral
+ 'd,
+ config: &config::Config,
+ ) -> Result {
+ Self::wrap(CanDriver::new(can, tx, rx, config)?)
+ }
+}
+
+impl<'d, T> AsyncCanDriver<'d, T>
+where
+ T: BorrowMut>,
+{
+ pub fn wrap(driver: T) -> Result {
+ Self::wrap_custom(driver, None, None)
+ }
+
+ pub fn wrap_custom(
+ mut driver: T,
+ priority: Option,
+ pin_to_core: Option,
+ ) -> Result {
+ let _ = driver.borrow_mut().stop();
+
+ let mut alerts = 0;
+ esp!(unsafe {
+ twai_reconfigure_alerts(
+ driver
+ .borrow()
+ .1
+ .union(read_alerts())
+ .union(write_alerts())
+ .as_repr(),
+ &mut alerts,
+ )
+ })?;
+
+ let task = unsafe {
+ task::create(
+ Self::process_alerts,
+ CStr::from_bytes_until_nul(b"CAN - Alerts task\0").unwrap(),
+ 2048,
+ core::ptr::null_mut(),
+ priority.unwrap_or(6),
+ pin_to_core,
+ )?
+ };
+
+ Ok(Self {
+ driver,
+ task,
+ _data: PhantomData,
+ })
+ }
+
+ pub fn driver(&self) -> &CanDriver<'d> {
+ self.driver.borrow()
+ }
+
+ pub fn driver_mut(&mut self) -> &mut CanDriver<'d> {
+ self.driver.borrow_mut()
+ }
+
+ pub fn start(&mut self) -> Result<(), EspError> {
+ self.driver.borrow_mut().start()
+ }
+
+ pub fn stop(&mut self) -> Result<(), EspError> {
+ self.driver.borrow_mut().stop()
+ }
+
+ pub async fn transmit(&self, frame: &Frame) -> Result<(), EspError> {
+ loop {
+ let res = self.driver.borrow().transmit(frame, delay::NON_BLOCK);
+
+ match res {
+ Ok(()) => return Ok(()),
+ Err(e)
+ if e.code() != ESP_ERR_TIMEOUT
+ && (e.code() != ESP_FAIL || self.driver.borrow().2) =>
+ {
+ return Err(e)
+ }
+ _ => (),
+ }
+
+ WRITE_NOTIFICATION.wait().await;
+ }
+ }
+
+ pub async fn receive(&self) -> Result {
+ loop {
+ let res = self.driver.borrow().receive(delay::NON_BLOCK);
+
+ match res {
+ Ok(frame) => return Ok(frame),
+ Err(e) if e.code() != ESP_ERR_TIMEOUT => return Err(e),
+ _ => (),
+ }
+
+ READ_NOTIFICATION.wait().await;
+ }
+ }
+
+ pub async fn read_alerts(&self) -> Result, EspError> {
+ let alerts = loop {
+ let alerts = EnumSet::from_repr(ALERT_NOTIFICATION.wait().await.into())
+ .intersection(self.driver.borrow().1);
+
+ if !alerts.is_empty() {
+ break alerts;
+ }
+ };
+
+ Ok(alerts)
+ }
+
+ extern "C" fn process_alerts(_arg: *mut core::ffi::c_void) {
+ let mut alerts = 0;
+
+ loop {
+ if unsafe { twai_read_alerts(&mut alerts, delay::BLOCK) } == 0 {
+ let ealerts: EnumSet = EnumSet::from_repr_truncated(alerts);
+
+ if !ealerts.is_disjoint(read_alerts()) {
+ READ_NOTIFICATION.notify_lsb();
+ }
+
+ if !ealerts.is_disjoint(write_alerts()) {
+ WRITE_NOTIFICATION.notify_lsb();
+ }
+
+ if let Some(alerts) = NonZeroU32::new(alerts) {
+ ALERT_NOTIFICATION.notify(alerts);
+ }
+ }
+ }
+ }
+}
+
+impl<'d, T> Drop for AsyncCanDriver<'d, T>
+where
+ T: BorrowMut>,
+{
+ fn drop(&mut self) {
+ let _ = self.stop();
+
+ unsafe { task::destroy(self.task) };
+
+ let mut alerts = 0;
+ esp!(unsafe { twai_reconfigure_alerts(self.driver.borrow().1.as_repr(), &mut alerts) })
+ .unwrap();
+
+ READ_NOTIFICATION.reset();
+ WRITE_NOTIFICATION.reset();
+ ALERT_NOTIFICATION.reset();
+ }
+}
+
+unsafe impl<'d, T> Send for AsyncCanDriver<'d, T> where T: BorrowMut> + Send {}
+
+static READ_NOTIFICATION: Notification = Notification::new();
+static WRITE_NOTIFICATION: Notification = Notification::new();
+static ALERT_NOTIFICATION: Notification = Notification::new();
+
+/// Twai message flags
+#[derive(Debug, EnumSetType)]
+pub enum Flags {
+ /// Message is in Extended Frame Format (29bit ID)
+ Extended,
+ /// Message is a Remote Frame (Remote Transmission Request)
+ Remote,
+ /// Transmit message using Single Shot Transmission
+ /// (Message will not be retransmitted upon error or loss of arbitration).
+ /// Unused for received message.
+ SingleShot,
+ /// Transmit message using Self Reception Request
+ /// (Transmitted message will also received by the same node).
+ /// Unused for received message.
+ SelfReception,
+ /// Message's Data length code is larger than 8.
+ /// This will break compliance with TWAI
+ DlcNonComp,
+ None,
+}
+
pub struct Frame(twai_message_t);
impl Frame {
- pub fn new(id: u32, extended: bool, data: &[u8]) -> Option {
+ pub fn new(id: u32, flags: EnumSet, data: &[u8]) -> Option {
let dlc = data.len();
if dlc <= 8 {
// unions are not very well supported in rust
// therefore setting those union flags is quite hairy
- let mut flags = twai_message_t__bindgen_ty_1::default();
-
- // set bits in an union
- unsafe { flags.__bindgen_anon_1.set_ss(1) };
- if extended {
- unsafe { flags.__bindgen_anon_1.set_extd(1) };
+ let mut twai_flags = twai_message_t__bindgen_ty_1::default();
+
+ // Iterate over the flags set and set the corresponding bits in the union
+ for flag in flags.iter() {
+ match flag {
+ Flags::Extended => unsafe { twai_flags.__bindgen_anon_1.set_extd(1) },
+ Flags::Remote => unsafe { twai_flags.__bindgen_anon_1.set_rtr(1) },
+ Flags::SingleShot => unsafe { twai_flags.__bindgen_anon_1.set_ss(1) },
+ Flags::SelfReception => unsafe { twai_flags.__bindgen_anon_1.set_self(1) },
+ Flags::DlcNonComp => unsafe { twai_flags.__bindgen_anon_1.set_dlc_non_comp(1) },
+ Flags::None => {}
+ }
}
let mut payload = [0; 8];
payload[..dlc].copy_from_slice(data);
let twai_message = twai_message_t {
- __bindgen_anon_1: flags,
+ __bindgen_anon_1: twai_flags,
identifier: id,
data_length_code: dlc as u8,
data: payload,
@@ -443,7 +805,6 @@ impl Frame {
// set bits in an union
unsafe { flags.__bindgen_anon_1.set_rtr(1) };
- unsafe { flags.__bindgen_anon_1.set_ss(1) };
if extended {
unsafe { flags.__bindgen_anon_1.set_extd(1) };
}
@@ -484,24 +845,34 @@ impl Frame {
impl core::fmt::Display for Frame {
fn fmt(&self, f: &mut core::fmt::Formatter<'_>) -> core::fmt::Result {
- write!(
- f,
- "Frame {{ id: {}, remote: {}, data: {:?} }}",
- self.identifier(),
- self.is_remote_frame(),
- self.data()
- )
+ if self.is_extended() {
+ write!(
+ f,
+ "Frame {{ id: {:08x}, remote: {}, data: {:?} }}",
+ self.identifier(),
+ self.is_remote_frame(),
+ self.data()
+ )
+ } else {
+ write!(
+ f,
+ "Frame {{ id: {:03x}, remote: {}, data: {:?} }}",
+ self.identifier(),
+ self.is_remote_frame(),
+ self.data()
+ )
+ }
}
}
impl embedded_hal_0_2::can::Frame for Frame {
fn new(id: impl Into, data: &[u8]) -> Option {
- let (id, extended) = match id.into() {
- embedded_hal_0_2::can::Id::Standard(id) => (id.as_raw() as u32, false),
- embedded_hal_0_2::can::Id::Extended(id) => (id.as_raw(), true),
+ let (id, flags) = match id.into() {
+ embedded_hal_0_2::can::Id::Standard(id) => (id.as_raw() as u32, Flags::None),
+ embedded_hal_0_2::can::Id::Extended(id) => (id.as_raw(), Flags::Extended),
};
- Self::new(id, extended, data)
+ Self::new(id, flags.into(), data)
}
fn new_remote(id: impl Into, dlc: usize) -> Option {
@@ -552,12 +923,12 @@ impl embedded_hal_0_2::can::Frame for Frame {
impl embedded_can::Frame for Frame {
fn new(id: impl Into, data: &[u8]) -> Option {
- let (id, extended) = match id.into() {
- embedded_can::Id::Standard(id) => (id.as_raw() as u32, false),
- embedded_can::Id::Extended(id) => (id.as_raw(), true),
+ let (id, flags) = match id.into() {
+ embedded_can::Id::Standard(id) => (id.as_raw() as u32, Flags::None),
+ embedded_can::Id::Extended(id) => (id.as_raw(), Flags::Extended),
};
- Self::new(id, extended, data)
+ Self::new(id, flags.into(), data)
}
fn new_remote(id: impl Into, dlc: usize) -> Option {
diff --git a/src/cpu.rs b/src/cpu.rs
index 609825ee674..6a910f2d766 100644
--- a/src/cpu.rs
+++ b/src/cpu.rs
@@ -3,11 +3,13 @@ use core::arch::asm;
use esp_idf_sys::*;
+use enumset::EnumSetType;
+
/// Returns the number of cores supported by the esp32* chip
pub const CORES: u32 = SOC_CPU_CORES_NUM;
+#[derive(Debug, EnumSetType)]
#[repr(C)]
-#[derive(Copy, Clone, Eq, PartialEq, Debug)]
pub enum Core {
Core0 = 0, // PRO on dual-core systems, the one and only CPU on single-core systems
#[cfg(any(esp32, esp32s3))]
@@ -48,21 +50,21 @@ impl From for Core {
#[inline(always)]
#[link_section = ".iram1.cpu_core"]
pub fn core() -> Core {
- #[cfg(any(esp32c3, esp32s2))]
+ #[cfg(any(esp32c3, esp32s2, esp32c2, esp32h2, esp32c5, esp32c6))]
let core = 0;
#[allow(unused_assignments)]
- #[cfg(any(esp32, esp32s3))]
+ #[cfg(any(esp32, esp32s3, esp32p4))]
let mut core = 0;
- #[cfg(any(esp32, esp32s3))]
+ #[cfg(any(esp32, esp32s3))] // TODO: Need a way to get the running core on esp32p4 in future
unsafe {
asm!("rsr.prid {0}", "extui {0},{0},13,1", out(reg) core);
}
match core {
0 => Core::Core0,
- #[cfg(any(esp32, esp32s3))]
+ #[cfg(any(esp32, esp32s3, esp32p4))]
1 => Core::Core1,
other => panic!("Unknown core: {}", other),
}
diff --git a/src/delay.rs b/src/delay.rs
index 9929ae1e3df..d38f8f0fc0a 100644
--- a/src/delay.rs
+++ b/src/delay.rs
@@ -1,25 +1,145 @@
-use core::convert::Infallible;
+//! Delay providers.
+//!
+//! If you don't know how large your delays will be, you'll probably want to
+//! use [`Delay`]. Otherwise use [`Ets`] for delays <10ms and
+//! [`FreeRtos`] for delays >=10ms.
+//!
+//! Example of an Ets vs. FreeRtos auto-selecting delay:
+//! ```
+//! use esp_idf_hal::delay::Delay;
+//!
+//! let delay: Delay = Default::default();
+//! // ...
+//! delay.delay_us(42);
+//! // ...
+//! delay.delay_ms(142);
+//! // ...
+//! ```
+//!
+//! Example of a small microsecond delay:
+//! ```
+//! use esp_idf_hal::delay::Ets;
+//!
+//! Ets::delay_us(42);
+//! ```
+//!
+//! Example of a millisecond delay:
+//! ```
+//! use esp_idf_hal::delay::FreeRtos;
+//!
+//! FreeRtos::delay_ms(42);
+//! ```
+//!
+//! Example of an [embedded_hal::delay::DelayNs] consumer with an
+//! Ets vs. FreeRtos auto-selecting delay:
+//! ```ignore
+//! use esp_idf_hal::delay::Delay;
+//!
+//! let mut delay: Delay = Default::default();
+//! some_trait_user(&mut delay);
+//! ```
+
use core::time::Duration;
use esp_idf_sys::*;
-#[allow(non_upper_case_globals)]
+/// The raw OS tick type. Also see [TickType].
+pub use esp_idf_sys::TickType_t;
+
+/// Sentinel value used as "maximum delay" or "maximum blocking" marker.
+///
+/// This value is also used for representing `Option` being `None`
+/// when converting to/from [TickType].
pub const BLOCK: TickType_t = TickType_t::MAX;
-#[allow(non_upper_case_globals)]
-pub const NON_BLOCK: TickType_t = TickType_t::MIN;
+/// Sentinel value used as "no delay" or "no blocking" marker.
+pub const NON_BLOCK: TickType_t = 0;
+
+/// The configured OS tick rate in Hz.
+/// There are [TICK_RATE_HZ] number of [TickType] ticks per second.
+pub const TICK_RATE_HZ: u32 = configTICK_RATE_HZ;
-#[allow(non_upper_case_globals)]
-const portTICK_PERIOD_MS: u32 = 1000 / configTICK_RATE_HZ;
+const MS_PER_S: u64 = 1_000;
+const NS_PER_MS: u64 = 1_000_000;
+const US_PER_MS: u32 = 1_000;
+const NS_PER_US: u32 = 1_000;
+
+#[inline]
+const fn const_min_u64(a: u64, b: u64) -> u64 {
+ if a < b {
+ a
+ } else {
+ b
+ }
+}
+/// Transparent wrapper around [TickType_t] with conversion methods.
+#[repr(transparent)]
pub struct TickType(pub TickType_t);
+impl TickType {
+ /// Construct a [TickType] from a number of ticks.
+ #[inline]
+ pub const fn new(ticks: TickType_t) -> Self {
+ Self(ticks)
+ }
+
+ /// Construct a [TickType] from a number of milliseconds.
+ /// This function will round the number of ticks up, if required.
+ pub const fn new_millis(ms: u64) -> Self {
+ let ticks = ms
+ .saturating_mul(TICK_RATE_HZ as u64)
+ .saturating_add(MS_PER_S - 1)
+ / MS_PER_S;
+ Self(const_min_u64(ticks, TickType_t::MAX as _) as _)
+ }
+
+ /// Get the number of ticks.
+ #[inline]
+ pub const fn ticks(&self) -> TickType_t {
+ self.0
+ }
+
+ /// Convert the number of ticks to a number of milliseconds.
+ /// This function will round the number of milliseconds up, if required.
+ pub const fn as_millis(&self) -> u64 {
+ (self.0 as u64)
+ .saturating_mul(MS_PER_S)
+ .saturating_add(TICK_RATE_HZ as u64 - 1)
+ / TICK_RATE_HZ as u64
+ }
+
+ /// Convert the number of ticks to a number of milliseconds
+ /// and saturate to u32.
+ /// This function will round the number of milliseconds up, if required.
+ #[inline]
+ pub const fn as_millis_u32(&self) -> u32 {
+ const_min_u64(self.as_millis(), u32::MAX as _) as _
+ }
+}
+
+impl From for TickType {
+ #[inline]
+ fn from(value: TickType_t) -> Self {
+ Self::new(value)
+ }
+}
+
+impl From for TickType_t {
+ #[inline]
+ fn from(value: TickType) -> Self {
+ value.ticks()
+ }
+}
+
impl From for TickType {
fn from(duration: Duration) -> Self {
- TickType(
- ((duration.as_millis() + portTICK_PERIOD_MS as u128 - 1) / portTICK_PERIOD_MS as u128)
- as TickType_t,
- )
+ let sec_ms = duration.as_secs().saturating_mul(MS_PER_S);
+ let subsec_ns: u64 = duration.subsec_nanos().into();
+ // Convert to ms and round up. Not saturating. Cannot overflow.
+ let subsec_ms = subsec_ns.div_ceil(NS_PER_MS);
+
+ TickType::new_millis(sec_ms.saturating_add(subsec_ms))
}
}
@@ -35,7 +155,7 @@ impl From> for TickType {
impl From for Duration {
fn from(ticks: TickType) -> Self {
- Duration::from_millis(ticks.0 as u64 * portTICK_PERIOD_MS as u64)
+ Duration::from_millis(ticks.as_millis())
}
}
@@ -49,154 +169,286 @@ impl From for Option {
}
}
-/// Espressif built-in delay provider
-/// Use only for very small delays (us or a few ms at most), or else the FreeRTOS IDLE tasks' might starve and
-/// the IDLE tasks' watchdog will trigger
+/// Espressif's built-in delay provider for small delays
+///
+/// Use only for very small delays or else the FreeRTOS IDLE tasks might starve and
+/// the IDLE task's watchdog will trigger.
+///
+/// Small delays are up to `1000 /` [TICK_RATE_HZ] milliseconds, which is typically
+/// 10 milliseconds.
pub struct Ets;
-// No longer available in the generated bindings for ESP-IDF 5
+// This binding is no longer available in the generated bindings for ESP-IDF 5 or later.
+// The function itself is still available. Therefore, we define the binding here.
#[cfg(not(esp_idf_version_major = "4"))]
extern "C" {
- pub fn ets_delay_us(us: u32);
+ fn ets_delay_us(us: u32);
}
impl Ets {
+ /// Pauses execution for at minimum `us` microseconds.
+ /// The delay can be longer due to rounding and/or runtime effects.
+ #[inline]
pub fn delay_us(us: u32) {
unsafe {
ets_delay_us(us);
}
}
+ /// Pauses execution for at minimum `ms` milliseconds.
+ /// The delay can be longer due to rounding and/or runtime effects.
+ /// This delay should only be used up to `1000 /` [TICK_RATE_HZ] milliseconds.
pub fn delay_ms(ms: u32) {
- unsafe {
- ets_delay_us(ms * 1000);
- }
+ Self::delay_us(ms.saturating_mul(US_PER_MS));
}
}
impl embedded_hal_0_2::blocking::delay::DelayUs for Ets {
+ #[inline]
fn delay_us(&mut self, us: u32) {
Ets::delay_us(us);
}
}
impl embedded_hal_0_2::blocking::delay::DelayUs for Ets {
+ #[inline]
fn delay_us(&mut self, us: u16) {
- Ets::delay_us(us as _);
+ Ets::delay_us(us.into());
}
}
impl embedded_hal_0_2::blocking::delay::DelayUs for Ets {
+ #[inline]
fn delay_us(&mut self, us: u8) {
- Ets::delay_us(us as _);
+ Ets::delay_us(us.into());
}
}
impl embedded_hal_0_2::blocking::delay::DelayMs for Ets {
+ #[inline]
fn delay_ms(&mut self, ms: u32) {
Ets::delay_ms(ms);
}
}
impl embedded_hal_0_2::blocking::delay::DelayMs for Ets {
+ #[inline]
fn delay_ms(&mut self, ms: u16) {
- Ets::delay_ms(ms as _);
+ Ets::delay_ms(ms.into());
}
}
impl embedded_hal_0_2::blocking::delay::DelayMs for Ets {
+ #[inline]
fn delay_ms(&mut self, ms: u8) {
- Ets::delay_ms(ms as _);
+ Ets::delay_ms(ms.into());
}
}
-impl embedded_hal::delay::DelayUs for Ets {
- type Error = Infallible;
+impl embedded_hal::delay::DelayNs for Ets {
+ #[inline]
+ fn delay_ns(&mut self, ns: u32) {
+ Ets::delay_us(ns.saturating_add(NS_PER_US - 1) / NS_PER_US);
+ }
- fn delay_us(&mut self, us: u32) -> Result<(), Self::Error> {
+ #[inline]
+ fn delay_us(&mut self, us: u32) {
Ets::delay_us(us);
-
- Ok(())
}
- fn delay_ms(&mut self, ms: u32) -> Result<(), Self::Error> {
+ #[inline]
+ fn delay_ms(&mut self, ms: u32) {
Ets::delay_ms(ms);
-
- Ok(())
}
}
-/// FreeRTOS-based delay provider
-/// Use for delays larger than 10ms (delays smaller than 10ms used in a loop would
-/// starve the FreeRTOS IDLE tasks' as they are low prio tasks and hence the
-/// the IDLE tasks' watchdog will trigger)
+/// FreeRTOS-based delay provider for delays larger than 10 ms.
+///
+/// Delays bigger than `1000 /` [TICK_RATE_HZ] milliseconds (typically 10 ms) used in a
+/// loop would starve the FreeRTOS IDLE tasks as they are low prio tasks and hence the
+/// IDLE task's watchdog could trigger.
+/// This delayer avoids that by yielding to the OS during the delay.
pub struct FreeRtos;
impl FreeRtos {
- pub fn delay_us(us: u32) {
- let ms = us / 1000;
-
- Self::delay_ms(ms);
- }
-
+ /// Pauses execution for at minimum `ms` milliseconds.
+ /// The delay can be longer due to rounding and/or runtime effects.
pub fn delay_ms(ms: u32) {
- // divide by tick length, rounding up
- let ticks = ms.saturating_add(portTICK_PERIOD_MS - 1) / portTICK_PERIOD_MS;
-
+ let ticks = TickType::new_millis(ms.into()).ticks();
unsafe {
vTaskDelay(ticks);
}
}
+
+ // Internal helper: Round up to ms.
+ // This is not supposed to be `pub`, because the user code shall not use this
+ // timer for microsecond delay. Only used for trait impl below.
+ fn delay_us(us: u32) {
+ Self::delay_ms(us.saturating_add(US_PER_MS - 1) / US_PER_MS);
+ }
}
impl embedded_hal_0_2::blocking::delay::DelayUs