Remove timer module, fugit & void deps

Removal lets us drop two direct dependencies. Nowadays, I think this
module adds more complexity than it's worth, particularly when folks can
write their own blocking delays against the drivers.

I had no plans to add embedded-hal 1.0 support for these, so I figure
removing them altogether would be more consistent than not supporting
the newer traits.

Author: mciantyre

CHANGELOG.md

@@ -58,6 +58,9 @@ are still exposed when building with a chip feature.
 - `snvs`
 - `timer`
 
+**BREAKING** Remove the `timer` module, including most embedded-hal 0.2 blocking
+delay implementations.
+
 Introduce an `imxrt1180` feature to support the RT1180 series.
 
 Add a `defmt` feature targeting version 0.3. When enabled, select imxrt-hal

Cargo.toml

@@ -24,14 +24,6 @@ version = "1.0"
 [dependencies.bitflags]
 version = "1.3"
 
-[dependencies.fugit]
-version = "0.3"
-
-# For EH02 CountDown.
-[dependencies.void]
-version = "1"
-default-features = false
-
 [dependencies.nb]
 version = "1"
 

examples/hal_i2c_lcd1602.rs

@@ -10,14 +10,60 @@
 use board::lcd1602::*;
 use imxrt_hal as hal;
 
+use hal::gpt::{Gpt, Mode, OutputCompareRegister};
+
 const LCD_ADDRESS: u8 = 0x7c >> 1;
 const RGB_ADDRESS: u8 = 0xc4 >> 1;
 
+/// A blocking delay adapter over a GPT timer.
+struct GptDelay {
+    gpt: Gpt,
+    ticks_per_ms: u32,
+}
+
+impl GptDelay {
+    fn new(mut gpt: Gpt, frequency_hz: u32) -> Self {
+        gpt.disable();
+        gpt.clear_rollover();
+        gpt.set_rollover_interrupt_enable(false);
+        gpt.set_mode(Mode::Restart);
+        gpt.set_reset_on_enable(true);
+        for ocr in [
+            OutputCompareRegister::OCR1,
+            OutputCompareRegister::OCR2,
+            OutputCompareRegister::OCR3,
+        ] {
+            gpt.clear_elapsed(ocr);
+            gpt.set_output_interrupt_on_compare(ocr, false);
+        }
+        Self {
+            gpt,
+            ticks_per_ms: frequency_hz / 1_000,
+        }
+    }
+
+    fn block_ms(&mut self, ms: u32) {
+        let ticks = self.ticks_per_ms.saturating_mul(ms);
+        let ocr = OutputCompareRegister::OCR1;
+        self.gpt.set_output_compare_count(ocr, ticks);
+        self.gpt.enable();
+        while !self.gpt.is_elapsed(ocr) {}
+        self.gpt.clear_elapsed(ocr);
+        self.gpt.disable();
+    }
+}
+
+impl eh02::blocking::delay::DelayMs<u16> for GptDelay {
+    fn delay_ms(&mut self, ms: u16) {
+        self.block_ms(ms as u32);
+    }
+}
+
 #[imxrt_rt::entry]
 fn main() -> ! {
     let (board::Common { gpt1, .. }, board::Specifics { i2c, .. }) = board::new();
 
-    let mut delay = hal::timer::Blocking::<_, { board::GPT1_FREQUENCY }>::from_gpt(gpt1);
+    let mut delay = GptDelay::new(gpt1, board::GPT1_FREQUENCY);
     let mut lcd = Lcd::new(i2c, LCD_ADDRESS, RGB_ADDRESS, &mut delay).unwrap();
 
     lcd.set_cursor(Cursor::On).unwrap();

examples/rtic_gpio_input.rs

@@ -2,14 +2,15 @@
 //!
 //! It uses your board's button to react to falling edges.
 //! The LED's state changes every time you press the button.
-//! A timer provides a little wait for debounce.
+//! A PIT channel provides a little wait for debounce.
 
 #![no_std]
 #![no_main]
 
 #[rtic::app(device = board, peripherals = false)]
 mod app {
-    use hal::{gpio::Trigger, pit::Channel, timer::BlockingPit};
+    use hal::gpio::Trigger;
+    use hal::pit::{Channel, Pit};
     use imxrt_hal as hal;
 
     #[shared]
@@ -19,7 +20,7 @@ mod app {
     struct Local {
         led: board::Led,
         button: board::Button,
-        delay: BlockingPit<{ board::PIT_FREQUENCY }>,
+        pit: Pit,
     }
 
     #[init]
@@ -34,22 +35,29 @@ mod app {
             },
         ) = board::new();
         led.set();
-        let delay = BlockingPit::from_pit(pit, Channel::Chan2);
         let button_port = ports.button_mut();
         button_port
             .set_interrupt(&button, Some(Trigger::FallingEdge))
             .unwrap();
-        (Shared {}, Local { led, button, delay })
+        (Shared {}, Local { led, button, pit })
     }
 
-    #[task(binds = BOARD_BUTTON, local = [led, delay, button])]
+    #[task(binds = BOARD_BUTTON, local = [led, pit, button])]
     fn button_press(cx: button_press::Context) {
-        let delay = cx.local.delay;
+        let pit = cx.local.pit;
         let led = cx.local.led;
         let button = cx.local.button;
 
         led.toggle();
         button.clear_triggered();
-        delay.block_us(1000);
+
+        // Simple blocking delay for debounce using PIT channel 2.
+        let channel = Channel::Chan2;
+        let ticks = board::PIT_FREQUENCY / 1_000; // 1 ms
+        pit.set_load_timer_value(channel, ticks);
+        pit.enable(channel);
+        while !pit.is_elapsed(channel) {}
+        pit.clear_elapsed(channel);
+        pit.disable(channel);
     }
 }