feat(example): Add LP I2C Example (SHT30 temp. and humid. sensor)

esp-hal/src/soc/esp32c6/lp_core.rs

@@ -17,7 +17,7 @@
 //! detailed study of how to use this LP Core please visit [the repository
 //! with corresponding example].
 //!
-//! [the repository with corresponding example]: https://github.com/esp-rs/esp-hal/blob/main/examples/peripheral/lp_core/src/main.rs
+//! [the repository with corresponding example]: https://github.com/esp-rs/esp-hal/blob/main/examples/peripheral/lp_core/lp_blinky/src/main.rs
 
 use crate::peripherals::{LP_AON, LP_CORE, LP_PERI, LPWR, PMU};
 

esp-lp-hal/Cargo.toml

@@ -88,6 +88,10 @@ required-features = []
 name              = "i2c"
 required-features = ["esp32c6"]
 
+[[example]]
+name              = "i2c_sht30"
+required-features = ["esp32c6"]
+
 [[example]]
 name              = "uart"
 required-features = ["esp32c6"]

esp-lp-hal/examples/i2c_sht30.rs

@@ -0,0 +1,64 @@
+//! Uses `LP_I2C` and reads temperature and humidity from SHT30 sensor.
+//!
+//! This code runs on the LP core and writes the sensor data to LP memory,
+//! which can then be accessed by the HP core.
+//!
+//! The following wiring is assumed:
+//! - SDA => GPIO6
+//! - SCL => GPIO7
+
+//% CHIPS: esp32c6
+
+#![no_std]
+#![no_main]
+
+use embedded_hal::delay::DelayNs;
+use esp_lp_hal::{
+    delay::Delay,
+    i2c::{Error, LpI2c},
+    prelude::*,
+};
+use panic_halt as _;
+
+// LP SRAM addresses used as a simple shared-memory interface between the LP and HP cores.
+// These addresses must match the locations that the HP core expects to read from.
+//  - 0x5000_2000: f32 temperature value
+//  - 0x5000_2004: f32 humidity value (4 bytes after temperature to hold a second f32)
+// Adjust with care: changing these requires updating the corresponding HP-core code and
+// ensuring the chosen addresses stay within a valid, reserved LP memory region.
+const TEMP_ADDRESS: u32 = 0x5000_2000;
+const HUMID_ADDRESS: u32 = 0x5000_2004;
+
+// I2C address of the SHT30 temperature and humidity sensor.
+const DEV_ADDR: u8 = 0x44;
+// SHT30 command for single-shot measurement, clock stretching disabled, high repeatability.
+const CMD_READ_ONESHOT: [u8; 2] = [0x2C, 0x06];
+
+fn read_temp_humid(i2c: &mut LpI2c) -> Result<(f32, f32), Error> {
+    let mut buffer = [0u8; 6];
+    // Send single-shot measurement command.
+    i2c.write(DEV_ADDR, &CMD_READ_ONESHOT)?;
+    // Wait for the measurement to complete (up to 15 ms per datasheet).
+    Delay.delay_ms(15);
+    // Read measurement results.
+    i2c.read(DEV_ADDR, &mut buffer)?;
+    let temp_raw = u16::from_be_bytes([buffer[0], buffer[1]]);
+    let hum_raw = u16::from_be_bytes([buffer[3], buffer[4]]);
+    let temperature = -45.0 + (175.0 * (temp_raw as f32) / 65535.0);
+    let humidity = 100.0 * (hum_raw as f32) / 65535.0;
+    Ok((temperature, humidity))
+}
+
+#[entry]
+fn main(mut i2c: LpI2c) -> ! {
+    let temp_ptr = TEMP_ADDRESS as *mut f32;
+    let hum_ptr = HUMID_ADDRESS as *mut f32;
+    loop {
+        let (temp, humid) = read_temp_humid(&mut i2c).unwrap_or((f32::NAN, f32::NAN));
+        unsafe {
+            temp_ptr.write_volatile(temp);
+            hum_ptr.write_volatile(humid);
+        }
+        Delay.delay_ms(1000);
+    }
+}

examples/peripheral/lp_core/lp_blinky/Cargo.toml

@@ -0,0 +1,27 @@
+[package]
+name    = "lp-core-blinky"
+version = "0.0.0"
+edition = "2024"
+publish = false
+
+[dependencies]
+esp-backtrace = { path = "../../../../esp-backtrace", features = [
+    "panic-handler",
+    "println",
+] }
+esp-bootloader-esp-idf = { path = "../../../../esp-bootloader-esp-idf" }
+esp-hal = { path = "../../../../esp-hal", features = ["log-04", "unstable"] }
+esp-println = { path = "../../../../esp-println", features = ["log-04"] }
+
+[features]
+esp32c6 = [
+    "esp-backtrace/esp32c6",
+    "esp-bootloader-esp-idf/esp32c6",
+    "esp-hal/esp32c6",
+]
+
+[profile.release]
+debug            = true
+debug-assertions = true
+lto              = "fat"
+codegen-units    = 1

examples/peripheral/lp_core/src/main.rs → examples/peripheral/lp_core/lp_blinky/src/main.rs

@@ -37,7 +37,7 @@ fn main() -> ! {
 
     // load code to LP core
     let lp_core_code = load_lp_code!(
-        "../../../esp-lp-hal/target/riscv32imac-unknown-none-elf/release/examples/blinky"
+        "../../../../esp-lp-hal/target/riscv32imac-unknown-none-elf/release/examples/blinky"
     );
 
     // start LP core

examples/peripheral/lp_core/lp_i2c/.cargo/config.toml

@@ -0,0 +1,24 @@
+[target.'cfg(target_arch = "riscv32")']
+runner    = "espflash flash --monitor"
+rustflags = [
+  "-C", "link-arg=-Tlinkall.x",
+  "-C", "force-frame-pointers",
+]
+
+[target.'cfg(target_arch = "xtensa")']
+runner    = "espflash flash --monitor"
+rustflags = [
+  # GNU LD
+  "-C", "link-arg=-Wl,-Tlinkall.x",
+  "-C", "link-arg=-nostartfiles",
+
+  # LLD
+  # "-C", "link-arg=-Tlinkall.x",
+  # "-C", "linker=rust-lld",
+]
+
+[env]
+ESP_LOG = "info"
+
+[unstable]
+build-std = ["core", "alloc"]

examples/peripheral/lp_core/Cargo.toml → examples/peripheral/lp_core/lp_i2c/Cargo.toml

@@ -1,17 +1,17 @@
 [package]
-name    = "lp-core"
+name    = "lp-core-i2c"
 version = "0.0.0"
 edition = "2024"
 publish = false
 
 [dependencies]
-esp-backtrace = { path = "../../../esp-backtrace", features = [
+esp-backtrace = { path = "../../../../esp-backtrace", features = [
     "panic-handler",
     "println",
 ] }
-esp-bootloader-esp-idf = { path = "../../../esp-bootloader-esp-idf" }
-esp-hal = { path = "../../../esp-hal", features = ["log-04", "unstable"] }
-esp-println = { path = "../../../esp-println", features = ["log-04"] }
+esp-bootloader-esp-idf = { path = "../../../../esp-bootloader-esp-idf" }
+esp-hal = { path = "../../../../esp-hal", features = ["log-04", "unstable"] }
+esp-println = { path = "../../../../esp-println", features = ["log-04"] }
 
 [features]
 esp32c6 = [

examples/peripheral/lp_core/lp_i2c/src/main.rs

@@ -0,0 +1,75 @@
+//! SHT30 humidity and temperature sensor example running on the LP core via LP I2C
+//!
+//! Code on LP core reads humidity and temperature from an SHT30 sensor via I2C.
+//! The current value is printed by the HP core.
+//!
+//! ⚠️ Make sure to first compile the `esp-lp-hal/examples/i2c_sht30.rs` example ⚠️
+//!
+//! The following wiring is assumed:
+//! - SDA => GPIO6
+//! - SCL => GPIO7
+
+#![no_std]
+#![no_main]
+
+use esp_backtrace as _;
+use esp_hal::{
+    gpio::lp_io::LowPowerOutputOpenDrain,
+    i2c::lp_i2c::LpI2c,
+    load_lp_code,
+    lp_core::{LpCore, LpCoreWakeupSource},
+    main,
+    time::Rate,
+};
+use esp_println::{print, println};
+
+esp_bootloader_esp_idf::esp_app_desc!();
+
+// Shared-memory locations used for communication with the LP core firmware.
+// The `esp-lp-hal` example `i2c_sht30.rs` running on the LP core writes the
+// latest temperature and humidity readings as `f32` values to these addresses:
+// - TEMP_ADDRESS: 4-byte `f32` at 0x5000_2000
+// - HUMID_ADDRESS: 4-byte `f32` at 0x5000_2004 (immediately after temperature)
+//
+// These addresses must match the memory layout used by the LP core code; if you
+// change them here, you must also update the corresponding addresses in the LP
+// core example so both cores agree on the shared memory region.
+const TEMP_ADDRESS: u32 = 0x5000_2000;
+const HUMID_ADDRESS: u32 = 0x5000_2004;
+
+#[main]
+fn main() -> ! {
+    esp_println::logger::init_logger_from_env();
+    let peripherals = esp_hal::init(esp_hal::Config::default());
+
+    // configure LP I2C
+    let i2c = LpI2c::new(
+        peripherals.LP_I2C0,
+        LowPowerOutputOpenDrain::new(peripherals.GPIO6),
+        LowPowerOutputOpenDrain::new(peripherals.GPIO7),
+        Rate::from_khz(100),
+    );
+
+    let mut lp_core = LpCore::new(peripherals.LP_CORE);
+    lp_core.stop();
+    println!("lp core stopped");
+
+    // load code to LP core
+    let lp_core_code = load_lp_code!(
+        "../../../../esp-lp-hal/target/riscv32imac-unknown-none-elf/release/examples/i2c_sht30"
+    );
+
+    // start LP core
+    lp_core_code.run(&mut lp_core, LpCoreWakeupSource::HpCpu, i2c);
+    println!("lp core run");
+
+    let temp = TEMP_ADDRESS as *mut f32;
+    let humid = HUMID_ADDRESS as *mut f32;
+    loop {
+        print!(
+            "Current {:.2} C {:.2} %           \u{000d}",
+            unsafe { temp.read_volatile() },
+            unsafe { humid.read_volatile() }
+        );
+    }
+}