esp-hal = 1.0.0-beta.0 (#14)

Author: psytraxx

Cargo.lock

@@ -10,8 +10,8 @@ esp-backtrace = { version = "0.15.0", features = [
     "panic-handler",
     "defmt",
 ] }
-esp-hal = { version = "0.23.1", features = ["esp32s3", "defmt"] }
-esp-alloc = { version = "0.6.0" }
+esp-hal = { version = "1.0.0-beta.0", features = ["esp32s3", "defmt", "unstable"] }
+esp-alloc = { version = "0.7.0" }
 embassy-net = { version = "0.6.0", features = [
     "tcp",
     "udp",
@@ -22,7 +22,7 @@ embassy-net = { version = "0.6.0", features = [
 ] }
 
 mipidsi = { version = "0.9.0" }
-esp-wifi = { version = "0.12.0", features = [
+esp-wifi = { version = "0.13.0", features = [
     "esp32s3",
     "serde",
     "wifi",
@@ -36,7 +36,7 @@ embassy-executor = { version = "0.7.0", features = [
     "defmt",
 ] }
 embassy-time = { version = "0.4.0", features = ["defmt"] }
-esp-hal-embassy = { version = "0.6.0", features = ["esp32s3", "defmt"] }
+esp-hal-embassy = { version = "0.7.0", features = ["esp32s3", "defmt"] }
 rust-mqtt = { version = "0.3.0", default-features = false, features = [
     "defmt",
 ] }

Cargo.toml

@@ -9,7 +9,7 @@ use embedded_text::alignment::HorizontalAlignment;
 use embedded_text::style::{HeightMode, TextBoxStyleBuilder};
 use embedded_text::TextBox;
 use esp_hal::delay::Delay;
-use esp_hal::gpio::{GpioPin, Level, Output};
+use esp_hal::gpio::{GpioPin, Level, Output, OutputConfig};
 use mipidsi::interface::{Generic8BitBus, ParallelError, ParallelInterface};
 use mipidsi::models::ST7789;
 use mipidsi::options::{ColorInversion, Orientation, Rotation};
@@ -68,25 +68,25 @@ pub struct DisplayPeripherals {
 
 impl Display<'_> {
     pub fn new(p: DisplayPeripherals) -> Result<Self, Error> {
-        let backlight = Output::new(p.backlight, Level::Low);
+        let backlight = Output::new(p.backlight, Level::Low, OutputConfig::default());
 
-        let dc = Output::new(p.dc, Level::Low);
-        let mut cs = Output::new(p.cs, Level::Low);
-        let rst = Output::new(p.rst, Level::Low);
-        let wr = Output::new(p.wr, Level::Low);
-        let mut rd = Output::new(p.rd, Level::Low);
+        let dc = Output::new(p.dc, Level::Low, OutputConfig::default());
+        let mut cs = Output::new(p.cs, Level::Low, OutputConfig::default());
+        let rst = Output::new(p.rst, Level::Low, OutputConfig::default());
+        let wr = Output::new(p.wr, Level::Low, OutputConfig::default());
+        let mut rd = Output::new(p.rd, Level::Low, OutputConfig::default());
 
         cs.set_low();
         rd.set_high();
 
-        let d0 = Output::new(p.d0, Level::Low);
-        let d1 = Output::new(p.d1, Level::Low);
-        let d2 = Output::new(p.d2, Level::Low);
-        let d3 = Output::new(p.d3, Level::Low);
-        let d4 = Output::new(p.d4, Level::Low);
-        let d5 = Output::new(p.d5, Level::Low);
-        let d6 = Output::new(p.d6, Level::Low);
-        let d7 = Output::new(p.d7, Level::Low);
+        let d0 = Output::new(p.d0, Level::Low, OutputConfig::default());
+        let d1 = Output::new(p.d1, Level::Low, OutputConfig::default());
+        let d2 = Output::new(p.d2, Level::Low, OutputConfig::default());
+        let d3 = Output::new(p.d3, Level::Low, OutputConfig::default());
+        let d4 = Output::new(p.d4, Level::Low, OutputConfig::default());
+        let d5 = Output::new(p.d5, Level::Low, OutputConfig::default());
+        let d6 = Output::new(p.d6, Level::Low, OutputConfig::default());
+        let d7 = Output::new(p.d7, Level::Low, OutputConfig::default());
 
         let bus = Generic8BitBus::new((d0, d1, d2, d3, d4, d5, d6, d7));
 

src/display.rs

@@ -16,7 +16,7 @@ use embassy_time::{Duration, Timer};
 use esp_alloc::heap_allocator;
 use esp_hal::{
     clock::CpuClock,
-    gpio::{Level, Output},
+    gpio::{Level, Output, OutputConfig},
     ram,
     timer::timg::TimerGroup,
 };
@@ -73,10 +73,10 @@ async fn main_fallible(spawner: Spawner, boot_count: u32) -> Result<(), Error> {
     let peripherals = esp_hal::init(esp_hal::Config::default().with_cpu_clock(CpuClock::_160MHz));
 
     // This IO15 must be set to HIGH, otherwise nothing will be displayed when USB is not connected.
-    let mut power_pin = Output::new(peripherals.GPIO15, Level::Low);
+    let mut power_pin = Output::new(peripherals.GPIO15, Level::Low, OutputConfig::default());
     power_pin.set_high();
 
-    heap_allocator!(72 * 1024);
+    heap_allocator!(size: 72 * 1024);
 
     let timg0 = TimerGroup::new(peripherals.TIMG0);
     let timg1 = TimerGroup::new(peripherals.TIMG1);
@@ -159,7 +159,8 @@ async fn main_fallible(spawner: Spawner, boot_count: u32) -> Result<(), Error> {
 
     let deep_sleep_duration = Duration::from_secs(DEEP_SLEEP_DURATION_SECONDS);
     info!("Enter deep sleep for {}s", DEEP_SLEEP_DURATION_SECONDS);
-    enter_deep(peripherals.GPIO14, peripherals.LPWR, deep_sleep_duration);
+    let mut wake_up_btn_pin = peripherals.GPIO14;
+    enter_deep(&mut wake_up_btn_pin, peripherals.LPWR, deep_sleep_duration);
 }
 
 #[derive(Debug, defmt::Format)]

src/main.rs

@@ -1,6 +1,6 @@
 use defmt::info;
 use embassy_time::{Duration, Timer};
-use esp_hal::gpio::{GpioPin, Level, Output};
+use esp_hal::gpio::{GpioPin, Level, Output, OutputConfig};
 
 use crate::ENABLE_PUMP;
 
@@ -10,7 +10,7 @@ const PUMP_INTERVAL: Duration = Duration::from_secs(10);
 pub async fn relay_task(pin: GpioPin<2>) {
     info!("Created a relay task");
     // Configure GPIO pin for relay (using GPIO2)
-    let mut dht_pin = Output::new(pin, Level::Low);
+    let mut dht_pin = Output::new(pin, Level::Low, OutputConfig::default());
 
     loop {
         let start_pump = ENABLE_PUMP.wait().await;

src/relay_task.rs

@@ -8,8 +8,9 @@ use esp_hal::{
         RegisterAccess,
     },
     delay::Delay,
-    gpio::{GpioPin, Input, Level, Output, OutputOpenDrain, Pull},
+    gpio::{DriveMode, GpioPin, Input, InputConfig, Level, Output, OutputConfig, Pull},
     peripherals::{ADC1, ADC2},
+    Blocking,
 };
 
 use crate::{
@@ -55,10 +56,15 @@ pub async fn sensor_task(
         .enable_pin_with_cal::<GpioPin<4>, AdcCalLine<ADC1>>(p.battery_pin, Attenuation::_11dB);
     let mut adc1 = Adc::new(p.adc1, adc1_config);
 
-    let moisture_input_pin = Input::new(p.moisture_digital_pin, esp_hal::gpio::Pull::None);
+    let moisture_input_pin = Input::new(
+        p.moisture_digital_pin,
+        InputConfig::default().with_pull(Pull::None),
+    );
 
-    let mut moisture_power_pin = Output::new(p.moisture_power_pin, Level::Low);
-    let mut water_level_power_pin = Output::new(p.water_level_power_pin, Level::Low);
+    let mut moisture_power_pin =
+        Output::new(p.moisture_power_pin, Level::Low, OutputConfig::default());
+    let mut water_level_power_pin =
+        Output::new(p.water_level_power_pin, Level::Low, OutputConfig::default());
 
     loop {
         // Collect samples for each sensor type
@@ -79,10 +85,17 @@ pub async fn sensor_task(
             info!("Reading sensor data {}/{}", (i + 1), SENSOR_SAMPLE_COUNT);
 
             {
-                let dht11_pin =
-                    OutputOpenDrain::new(&mut p.dht11_digital_pin, Level::High, Pull::None);
-                let mut dht11_sensor: Dht11<OutputOpenDrain<'_>, Delay> =
-                    Dht11::new(dht11_pin, delay);
+                let mut dht11_pin = Output::new(
+                    &mut p.dht11_digital_pin,
+                    Level::High,
+                    OutputConfig::default()
+                        .with_drive_mode(DriveMode::OpenDrain)
+                        .with_pull(Pull::None),
+                )
+                .into_flex();
+                dht11_pin.enable_input(true);
+
+                let mut dht11_sensor = Dht11::new(dht11_pin, delay);
 
                 // DHT11 needs a longer initial delay
                 Timer::after(Duration::from_millis(DHT11_WARMUP_DELAY_MILLISECONDS)).await;
@@ -179,15 +192,19 @@ pub async fn sensor_task(
         moisture_power_pin.set_low();
         water_level_power_pin.set_low();
         // Force the pin into an explicit low-power state after the sensor is dropped
-        Output::new(&mut p.dht11_digital_pin, Level::Low);
+        Output::new(
+            &mut p.dht11_digital_pin,
+            Level::Low,
+            OutputConfig::default(),
+        );
 
         Timer::after(sampling_period).await;
     }
 }
 
 /// Sample an ADC pin and return the value
 async fn sample_adc<PIN, ADCI, ADCC>(
-    adc: &mut Adc<'_, ADCI>,
+    adc: &mut Adc<'_, ADCI, Blocking>,
     pin: &mut AdcPin<PIN, ADCI, ADCC>,
 ) -> Option<u16>
 where

src/sensors_task.rs

@@ -1,19 +1,13 @@
 use defmt::info;
 use embassy_time::Duration;
 use esp_hal::gpio::RtcPin;
-use esp_hal::peripheral::Peripheral;
 use esp_hal::peripherals::LPWR;
 use esp_hal::rtc_cntl::sleep::{RtcSleepConfig, RtcioWakeupSource, TimerWakeupSource, WakeupLevel};
 use esp_hal::rtc_cntl::Rtc;
 
 /// Enter deep sleep mode for the specified duration.
-pub fn enter_deep(
-    wakeup_pin: impl Peripheral<P = impl RtcPin>,
-    rtc_cntl: LPWR,
-    interval: Duration,
-) -> ! {
-    let wakeup_pins: &mut [(&mut dyn RtcPin, WakeupLevel)] =
-        &mut [(&mut *wakeup_pin.into_ref(), WakeupLevel::Low)];
+pub fn enter_deep(wakeup_pin: &mut dyn RtcPin, rtc_cntl: LPWR, interval: Duration) -> ! {
+    let wakeup_pins: &mut [(&mut dyn RtcPin, WakeupLevel)] = &mut [(wakeup_pin, WakeupLevel::Low)];
     let ext0 = RtcioWakeupSource::new(wakeup_pins);
 
     let wakeup_source_timer = TimerWakeupSource::new(interval.into());

src/sleep.rs

@@ -1,16 +1,15 @@
 use core::str::FromStr;
 use defmt::{error, info};
 use embassy_executor::Spawner;
-use embassy_net::{Stack, StackResources};
+use embassy_net::{Runner, Stack, StackResources};
 use embassy_sync::{blocking_mutex::raw::CriticalSectionRawMutex, signal::Signal};
 use embassy_time::{Duration, Timer};
 use esp_hal::{
     peripherals::{self, RNG},
     rng::Rng,
 };
 use esp_wifi::wifi::{
-    ClientConfiguration, Configuration, WifiController, WifiDevice, WifiError, WifiEvent,
-    WifiStaDevice, WifiState,
+    ClientConfiguration, Configuration, WifiController, WifiDevice, WifiError, WifiEvent, WifiState,
 };
 use heapless::String;
 use static_cell::StaticCell;
@@ -35,8 +34,9 @@ pub async fn connect_to_wifi(
     static INIT: StaticCell<esp_wifi::EspWifiController<'static>> = StaticCell::new();
     let init = INIT.init(esp_wifi::init(timer, rng, radio_clocks).unwrap());
 
-    let (wifi_interface, controller) =
-        esp_wifi::wifi::new_with_mode(init, wifi, WifiStaDevice).unwrap();
+    let (controller, interfaces) = esp_wifi::wifi::new(init, wifi).unwrap();
+
+    let wifi_interface = interfaces.sta;
 
     // initialize network stack
     let mut dhcp_config = embassy_net::DhcpConfig::default();
@@ -73,7 +73,7 @@ pub async fn connect_to_wifi(
 }
 
 #[embassy_executor::task]
-async fn net_task(mut runner: embassy_net::Runner<'static, WifiDevice<'static, WifiStaDevice>>) {
+async fn net_task(mut runner: Runner<'static, WifiDevice<'static>>) {
     runner.run().await
 }