Fix tests and examples

Author: bugadani

examples/src/bin/embassy_rmt_rx.rs

@@ -13,7 +13,7 @@ use embassy_executor::Spawner;
 use embassy_time::{Duration, Timer};
 use esp_backtrace as _;
 use esp_hal::{
- gpio::{GpioPin, Io, Level, Output},
+ gpio::{Io, Level, Output},
  prelude::*,
  rmt::{asynch::RxChannelAsync, PulseCode, Rmt, RxChannelConfig, RxChannelCreatorAsync},
  timer::timg::TimerGroup,
@@ -26,7 +26,7 @@ const WIDTH: usize = 80;
 compile_error!("Run this example in release mode");
 
 #[embassy_executor::task]
-async fn signal_task(mut pin: Output<'static, GpioPin<5>>) {
+async fn signal_task(mut pin: Output<'static>) {
  loop {
  for _ in 0..10 {
  pin.toggle();

examples/src/bin/gpio_interrupt.rs

@@ -17,20 +17,12 @@ use critical_section::Mutex;
 use esp_backtrace as _;
 use esp_hal::{
  delay::Delay,
- gpio::{Event, GpioPin, Input, Io, Level, Output, Pull},
+ gpio::{Event, Input, Io, Level, Output, Pull},
  macros::ram,
  prelude::*,
 };
 
-cfg_if::cfg_if! {
- if #[cfg(any(feature = "esp32", feature = "esp32s2", feature = "esp32s3"))] {
- const BUTTON_PIN: u8 = 0;
- } else {
- const BUTTON_PIN: u8 = 9;
- }
-}
-
-static BUTTON: Mutex<RefCell<Option<Input<GpioPin<BUTTON_PIN>>>>> = Mutex::new(RefCell::new(None));
+static BUTTON: Mutex<RefCell<Option<Input>>> = Mutex::new(RefCell::new(None));
 
 #[entry]
 fn main() -> ! {

examples/src/bin/spi_slave_dma.rs

@@ -34,7 +34,7 @@ use esp_hal::{
  delay::Delay,
  dma::{Dma, DmaPriority},
  dma_buffers,
- gpio::{GpioPin, Input, Io, Level, Output, Pull},
+ gpio::{Input, Io, Level, Output, Pull},
  prelude::*,
  spi::{
  slave::{prelude::*, Spi},
@@ -48,17 +48,16 @@ fn main() -> ! {
  let peripherals = esp_hal::init(esp_hal::Config::default());
 
  let io = Io::new(peripherals.GPIO, peripherals.IO_MUX);
- let slave_sclk = io.pins.gpio0;
+
  let mut master_sclk = Output::new(io.pins.gpio4, Level::Low);
- let slave_miso = io.pins.gpio1;
  let master_miso = Input::new(io.pins.gpio5, Pull::None);
- let slave_mosi = io.pins.gpio2;
  let mut master_mosi = Output::new(io.pins.gpio8, Level::Low);
+ let mut master_cs = Output::new(io.pins.gpio9, Level::High);
+
+ let slave_sclk = io.pins.gpio0;
+ let slave_miso = io.pins.gpio1;
+ let slave_mosi = io.pins.gpio2;
  let slave_cs = io.pins.gpio3;
- let mut master_cs = Output::new(io.pins.gpio9, Level::Low);
- master_cs.set_high();
- master_sclk.set_low();
- master_mosi.set_low();
 
  let dma = Dma::new(peripherals.DMA);
  cfg_if::cfg_if! {
@@ -189,10 +188,10 @@ fn main() -> ! {
 fn bitbang_master(
  master_send: &[u8],
  master_receive: &mut [u8],
- master_cs: &mut Output<GpioPin<9>>,
- master_mosi: &mut Output<GpioPin<8>>,
- master_sclk: &mut Output<GpioPin<4>>,
- master_miso: &Input<GpioPin<5>>,
+ master_cs: &mut Output,
+ master_mosi: &mut Output,
+ master_sclk: &mut Output,
+ master_miso: &Input,
 ) {
  // Bit-bang out the contents of master_send and read into master_receive
  // as quickly as manageable. MSB first. Mode 0, so sampled on the rising

hil-test/src/lib.rs

@@ -49,8 +49,7 @@ macro_rules! common_test_pins {
  cfg_if::cfg_if! {
  if #[cfg(any(esp32s2, esp32s3))] {
  ($io.pins.gpio9, $io.pins.gpio10)
- }
- else {
+ } else {
  ($io.pins.gpio2, $io.pins.gpio3)
  }
  }

hil-test/tests/aes_dma.rs

@@ -14,7 +14,6 @@ use esp_hal::{
  dma::{Dma, DmaPriority},
  dma_buffers,
  peripherals::Peripherals,
- prelude::*,
 };
 use hil_test as _;
 

hil-test/tests/delay.rs

@@ -20,7 +20,7 @@ mod tests {
 
  #[init]
  fn init() -> Context {
- let peripherals = esp_hal::init(esp_hal::Config::default());
+ let _peripherals = esp_hal::init(esp_hal::Config::default());
  let delay = Delay::new();
 
  Context { delay }

hil-test/tests/get_time.rs

@@ -61,7 +61,7 @@ mod tests {
  #[test]
  #[timeout(3)]
  fn test_current_time_construct_timg0(ctx: Context) {
- time_moves_forward_during(ctx, |ctx| {
+ time_moves_forward_during(ctx, |_| {
  // construct the timer in between calls to current_time
  let _ = esp_hal::timer::timg::TimerGroup::new(unsafe {
  esp_hal::peripherals::TIMG0::steal()

hil-test/tests/gpio.rs

@@ -15,19 +15,19 @@ use core::cell::RefCell;
 use critical_section::Mutex;
 use esp_hal::{
  delay::Delay,
- gpio::{AnyPin, GpioPin, Input, Io, Level, Output, Pull},
+ gpio::{AnyPin, ErasedPin, Input, Io, Level, Output, Pin, Pull},
  macros::handler,
  timer::timg::TimerGroup,
  InterruptConfigurable,
 };
 use hil_test as _;
 
 static COUNTER: Mutex<RefCell<u32>> = Mutex::new(RefCell::new(0));
-static INPUT_PIN: Mutex<RefCell<Option<Input<'static>>>> = Mutex::new(RefCell::new(None));
+static INPUT_PIN: Mutex<RefCell<Option<Input>>> = Mutex::new(RefCell::new(None));
 
-struct Context<'d> {
- test_gpio1: Input<'d>,
- test_gpio2: Output<'d>,
+struct Context {
+ test_gpio1: ErasedPin,
+ test_gpio2: ErasedPin,
  delay: Delay,
 }
 
@@ -53,7 +53,7 @@ mod tests {
  use super::*;
 
  #[init]
- fn init() -> Context<'static> {
+ fn init() -> Context {
  let peripherals = esp_hal::init(esp_hal::Config::default());
 
  let mut io = Io::new(peripherals.GPIO, peripherals.IO_MUX);
@@ -67,20 +67,22 @@ mod tests {
  esp_hal_embassy::init(timg0.timer0);
 
  Context {
- test_gpio1: Input::new(gpio1, Pull::Down),
- test_gpio2: Output::new(gpio2, Level::Low),
+ test_gpio1: gpio1.degrade(),
+ test_gpio2: gpio2.degrade(),
  delay,
  }
  }
 
  #[test]
- async fn test_async_edge(ctx: Context<'static>) {
+ async fn test_async_edge(ctx: Context) {
  let counter = AtomicUsize::new(0);
  let Context {
- mut test_gpio1,
- mut test_gpio2,
+ test_gpio1,
+ test_gpio2,
  ..
  } = ctx;
+ let mut test_gpio1 = Input::new(test_gpio1, Pull::Down);
+ let mut test_gpio2 = Output::new(test_gpio2, Level::Low);
  embassy_futures::select::select(
  async {
  loop {
@@ -102,8 +104,8 @@ mod tests {
  }
 
  #[test]
- async fn test_a_pin_can_wait(_ctx: Context<'static>) {
- let mut first = Input::new(unsafe { GpioPin::<0>::steal() }, Pull::Down);
+ async fn test_a_pin_can_wait(ctx: Context) {
+ let mut first = Input::new(ctx.test_gpio1, Pull::Down);
 
  embassy_futures::select::select(
  first.wait_for_rising_edge(),
@@ -115,69 +117,74 @@ mod tests {
  }
 
  #[test]
- fn test_gpio_input(ctx: Context<'static>) {
+ fn test_gpio_input(ctx: Context) {
+ let test_gpio1 = Input::new(ctx.test_gpio1, Pull::Down);
  // `InputPin`:
- assert_eq!(ctx.test_gpio1.is_low(), true);
- assert_eq!(ctx.test_gpio1.is_high(), false);
+ assert_eq!(test_gpio1.is_low(), true);
+ assert_eq!(test_gpio1.is_high(), false);
  }
 
  #[test]
- fn test_gpio_output(mut ctx: Context<'static>) {
+ fn test_gpio_output(ctx: Context) {
+ let mut test_gpio2 = Output::new(ctx.test_gpio2, Level::Low);
+
  // `StatefulOutputPin`:
- assert_eq!(ctx.test_gpio2.is_set_low(), true);
- assert_eq!(ctx.test_gpio2.is_set_high(), false);
- ctx.test_gpio2.set_high();
- assert_eq!(ctx.test_gpio2.is_set_low(), false);
- assert_eq!(ctx.test_gpio2.is_set_high(), true);
+ assert_eq!(test_gpio2.is_set_low(), true);
+ assert_eq!(test_gpio2.is_set_high(), false);
+ test_gpio2.set_high();
+ assert_eq!(test_gpio2.is_set_low(), false);
+ assert_eq!(test_gpio2.is_set_high(), true);
 
  // `ToggleableOutputPin`:
- ctx.test_gpio2.toggle();
- assert_eq!(ctx.test_gpio2.is_set_low(), true);
- assert_eq!(ctx.test_gpio2.is_set_high(), false);
- ctx.test_gpio2.toggle();
- assert_eq!(ctx.test_gpio2.is_set_low(), false);
- assert_eq!(ctx.test_gpio2.is_set_high(), true);
+ test_gpio2.toggle();
+ assert_eq!(test_gpio2.is_set_low(), true);
+ assert_eq!(test_gpio2.is_set_high(), false);
+ test_gpio2.toggle();
+ assert_eq!(test_gpio2.is_set_low(), false);
+ assert_eq!(test_gpio2.is_set_high(), true);
  }
 
  #[test]
- fn test_gpio_interrupt(mut ctx: Context<'static>) {
+ fn test_gpio_interrupt(ctx: Context) {
+ let mut test_gpio1 = Input::new(ctx.test_gpio1, Pull::Down);
+ let mut test_gpio2 = Output::new(ctx.test_gpio2, Level::Low);
+
  critical_section::with(|cs| {
  *COUNTER.borrow_ref_mut(cs) = 0;
- ctx.test_gpio1.listen(Event::AnyEdge);
- INPUT_PIN.borrow_ref_mut(cs).replace(ctx.test_gpio1);
+ test_gpio1.listen(Event::AnyEdge);
+ INPUT_PIN.borrow_ref_mut(cs).replace(test_gpio1);
  });
- ctx.test_gpio2.set_high();
+ test_gpio2.set_high();
  ctx.delay.delay_millis(1);
- ctx.test_gpio2.set_low();
+ test_gpio2.set_low();
  ctx.delay.delay_millis(1);
- ctx.test_gpio2.set_high();
+ test_gpio2.set_high();
  ctx.delay.delay_millis(1);
- ctx.test_gpio2.set_low();
+ test_gpio2.set_low();
  ctx.delay.delay_millis(1);
- ctx.test_gpio2.set_high();
+ test_gpio2.set_high();
  ctx.delay.delay_millis(1);
- ctx.test_gpio2.set_low();
+ test_gpio2.set_low();
  ctx.delay.delay_millis(1);
- ctx.test_gpio2.set_high();
+ test_gpio2.set_high();
  ctx.delay.delay_millis(1);
- ctx.test_gpio2.set_low();
+ test_gpio2.set_low();
  ctx.delay.delay_millis(1);
- ctx.test_gpio2.set_high();
+ test_gpio2.set_high();
  ctx.delay.delay_millis(1);
 
  let count = critical_section::with(|cs| *COUNTER.borrow_ref(cs));
  assert_eq!(count, 9);
 
- ctx.test_gpio1 = critical_section::with(|cs| INPUT_PIN.borrow_ref_mut(cs).take().unwrap());
- ctx.test_gpio1.unlisten();
+ let mut test_gpio1 =
+ critical_section::with(|cs| INPUT_PIN.borrow_ref_mut(cs).take().unwrap());
+ test_gpio1.unlisten();
  }
 
  #[test]
- fn test_gpio_od(ctx: Context<'static>) {
- let mut test_gpio1 =
- OutputOpenDrain::new(unsafe { TestGpio1::steal() }, Level::High, Pull::Up);
- let mut test_gpio2 =
- OutputOpenDrain::new(unsafe { TestGpio2::steal() }, Level::High, Pull::Up);
+ fn test_gpio_od(ctx: Context) {
+ let mut test_gpio1 = OutputOpenDrain::new(ctx.test_gpio1, Level::High, Pull::Up);
+ let mut test_gpio2 = OutputOpenDrain::new(ctx.test_gpio2, Level::High, Pull::Up);
 
  ctx.delay.delay_millis(1);
 
@@ -221,9 +228,9 @@ mod tests {
  }
 
  #[test]
- fn test_gpio_flex(ctx: Context<'static>) {
- let mut test_gpio1 = Flex::new(unsafe { TestGpio1::steal() });
- let mut test_gpio2 = Flex::new(unsafe { TestGpio2::steal() });
+ fn test_gpio_flex(ctx: Context) {
+ let mut test_gpio1 = Flex::new(ctx.test_gpio1);
+ let mut test_gpio2 = Flex::new(ctx.test_gpio2);
 
  test_gpio1.set_high();
  test_gpio1.set_as_output();
@@ -263,9 +270,9 @@ mod tests {
  // Tests touch pin (GPIO2) as AnyPin and Output
  // https://github.com/esp-rs/esp-hal/issues/1943
  #[test]
- fn test_gpio_touch_anypin_output() {
- let any_pin2 = AnyPin::new(unsafe { TestGpio1::steal() });
- let any_pin3 = AnyPin::new(unsafe { TestGpio2::steal() });
+ fn test_gpio_touch_anypin_output(ctx: Context) {
+ let any_pin2 = AnyPin::new(ctx.test_gpio1);
+ let any_pin3 = AnyPin::new(ctx.test_gpio2);
 
  let out_pin = Output::new(any_pin2, Level::High);
  let in_pin = Input::new(any_pin3, Pull::Down);
@@ -277,9 +284,9 @@ mod tests {
  // Tests touch pin (GPIO2) as AnyPin and Input
  // https://github.com/esp-rs/esp-hal/issues/1943
  #[test]
- fn test_gpio_touch_anypin_input() {
- let any_pin2 = AnyPin::new(unsafe { TestGpio1::steal() });
- let any_pin3 = AnyPin::new(unsafe { TestGpio2::steal() });
+ fn test_gpio_touch_anypin_input(ctx: Context) {
+ let any_pin2 = AnyPin::new(ctx.test_gpio1);
+ let any_pin3 = AnyPin::new(ctx.test_gpio2);
 
  let out_pin = Output::new(any_pin3, Level::Low);
  let in_pin = Input::new(any_pin2, Pull::Down);

hil-test/tests/qspi_write_read.rs

@@ -17,7 +17,7 @@
 use esp_hal::{
  dma::{Channel, Dma, DmaPriority, DmaRxBuf, DmaTxBuf},
  dma_buffers,
- gpio::{AnyPin, Io, Level, Output},
+ gpio::{ErasedPin, Io, Level, Output},
  prelude::*,
  spi::{
  master::{Address, Command, Spi, SpiDma},
@@ -106,7 +106,7 @@ mod tests {
  let (mosi, mosi_mirror) = hil_test::common_test_pins!(io);
 
  let mosi = mosi.degrade();
- let mosi_mirror = AnyOutput::new(mosi_mirror, Level::High);
+ let mosi_mirror = Output::new(mosi_mirror, Level::High);
 
  let dma = Dma::new(peripherals.DMA);
 

hil-test/tests/spi_full_duplex_dma_async.rs

@@ -24,7 +24,7 @@ use embedded_hal_async::spi::SpiBus;
 use esp_hal::{
  dma::{Dma, DmaPriority, DmaRxBuf, DmaTxBuf},
  dma_buffers,
- gpio::{ErasedPin, GpioPin, Io, Level, Output, Pull},
+ gpio::{ErasedPin, Io, Level, Output, Pull},
  pcnt::{
  channel::{EdgeMode, PcntInputConfig, PcntSource},
  unit::Unit,