Some adjustments for utick and sleep

Author: nickray

Makefile

@@ -6,6 +6,10 @@ view-rtfm-expansion:
 	rustfmt target/rtfm-expansion.rs
 	vi target/rtfm-expansion.rs
 
+# turn off the LEDs and whatnot
+darkness:
+	gdb-multiarch -q -x darkness.gdb > /dev/null 2> /dev/null
+
 #
 # External documentation
 #

darkness.gdb

@@ -0,0 +1,8 @@
+# source .gdb-dashboard
+
+set history save on
+set confirm off
+
+target extended-remote :2331
+monitor reset
+quit

examples/aes.rs

@@ -19,8 +19,6 @@ use cortex_m_semihosting::dbg;
 
 #[entry]
 fn main() -> ! {
-    // let _dp = hal::raw::Peripherals::take().unwrap();
-
     // AES-xxx variants have key sizes of xxx bits
     let key = GenericArray::from_slice(&[0u8; 32]);
     // AES always has block size of 128 bits
@@ -36,10 +34,10 @@ fn main() -> ! {
     cipher.encrypt_block(&mut block);
     let after = hal::get_cycle_count();
     dbg!("encrypting took {} cycles", after - before);
-    // dbg!(block);
+    dbg!(block);
     // And decrypt it back
     cipher.decrypt_block(&mut block);
-    // dbg!(block);
+    dbg!(block);
     assert_eq!(block, block_copy);
 
     // // We can encrypt 8 blocks simultaneously using

examples/baby_usb.rs

@@ -0,0 +1,35 @@
+#![no_main]
+#![no_std]
+
+///
+/// Compare also with: https://github.com/Ko-/aes-armcortexm
+///
+extern crate panic_halt;
+use cortex_m::asm;
+use cortex_m_rt::entry;
+use cortex_m_semihosting::dbg;
+
+use hal::prelude::*;
+#[allow(unused_imports)]
+use lpc55s6x_hal as hal;
+
+
+#[entry]
+fn main() -> ! {
+    let mut dp = hal::raw::Peripherals::take().unwrap();
+    let mut syscon = hal::syscon::wrap(dp.SYSCON);
+
+    syscon.enable_clock(&mut dp.USB0);
+
+    // returns 0x0, 0x0 if clock is not enabled...
+    // UM says: (5, 1)  <-- probly swapped
+    // We get: (1, 6)
+    dbg!(dp.USB0.info.read().majrev().bits());
+    dbg!(dp.USB0.info.read().minrev().bits());
+    dbg!(dp.USB0.info.read().frame_nr().bits());
+    dbg!(dp.USB0.info.read().err_code().bits());
+
+    loop {
+        asm::wfi();
+    }
+}

examples/led.rs

@@ -43,7 +43,7 @@ fn main() -> ! {
         clock: &clock,
     }; // 500 ms = 0.5 s
 
-    let mut sleep = hal::sleep::Busy::prepare(&mut utick);
+    let mut sleep = hal::sleep::Busy::wrap(&mut utick);
 
     loop {
         sleep.sleep(delay);

examples/led_utick.rs

@@ -4,8 +4,9 @@
 // extern crate panic_semihosting;  // 4004 bytes
 extern crate panic_halt; // 672 bytes
 
-use cortex_m::asm;
+// use cortex_m::asm;
 use cortex_m_rt::entry;
+// use nb::block;
 
 use hal::{gpio::Level, prelude::*};
 use lpc55s6x_hal as hal;
@@ -45,23 +46,18 @@ fn main() -> ! {
     loop {
         red.set_low().unwrap();
         utick.start(1_000_000u32);
-        while let Err(nb::Error::WouldBlock) = utick.wait() {
-            asm::nop();
-        }
+        // block!(utick.wait()).unwrap();
+        utick.blocking_wait();
         red.set_high().unwrap();
 
         green.set_low().unwrap();
         utick.start(1_000_000u32);
-        while let Err(nb::Error::WouldBlock) = utick.wait() {
-            asm::nop();
-        }
+        utick.blocking_wait();
         green.set_high().unwrap();
 
         blue.set_low().unwrap();
         utick.start(1_000_000u32);
-        while let Err(nb::Error::WouldBlock) = utick.wait() {
-            asm::nop();
-        }
+        utick.blocking_wait();
         blue.set_high().unwrap();
     }
 }

src/sleep.rs

@@ -43,34 +43,7 @@ where
 /// Provides a [`Sleep`] implementation based on busy waiting and uses the [UTICK]
 /// to measure the time. An interrupt handler is not required.
 ///
-/// Only clocks that the UTICK supports can be used. See [`utick::Clock`] for more
-/// details.
-///
-/// Since this sleep mode waits busily, which is very energy-inefficient, it is
-/// only suitable for simple examples, or very short wait times.
-///
-/// # Examples
-///
-/// ``` no_run
-/// use lpc82x_hal::prelude::*;
-/// use lpc82x_hal::{
-///     sleep,
-///     Peripherals,
-/// };
-/// use lpc82x_hal::clock::Ticks;
-///
-/// let mut p = Peripherals::take().unwrap();
-///
-/// let mut syscon = p.SYSCON.split();
-/// let mut utick    = p.UTICK.enable(&mut syscon.handle);
-///
-/// let clock = syscon.irc_derived_clock;
-///
-/// let mut sleep = sleep::Busy::prepare(&mut utick);
-///
-/// let delay = Ticks { value: 750_000, clock: &clock }; // 1000 ms
-/// sleep.sleep(delay);
-/// ```
+/// Examples: led_utick.rs
 pub struct Busy<'utick, 'fro1mhz> {
     utick: &'utick mut EnabledUtick<'fro1mhz>,
 }
@@ -84,7 +57,7 @@ impl<'utick, 'fro1mhz> Busy<'utick, 'fro1mhz> {
     /// Requires a mutable reference to [`UTICK`]. The reference will be borrowed
     /// for as long as the `sleep::Busy` instance exists, as it will be needed
     /// to count down the time in every call to [`Sleep::sleep`].
-    pub fn prepare(utick: &'utick mut EnabledUtick<'fro1mhz>) -> Self {
+    pub fn wrap(utick: &'utick mut EnabledUtick<'fro1mhz>) -> Self {
         Busy { utick }
     }
 }

src/utick.rs

@@ -5,30 +5,7 @@
 //! The UTICK peripheral is described in the user manual, chapter 26.
 //! It is driven by the FRO 1Mhz clock and has a microsecond resolution.
 //!
-//! # Examples
-//!
-//! ``` no_run
-//! extern crate lpc55S6x_hal;
-//! extern crate nb;
-//!
-//! use lpc55S6x_hal::prelude::*;
-//! use lpc55S6x_hal::Peripherals;
-//!
-//! let mut p = Peripherals::take().unwrap();
-//!
-//! let mut syscon = p.SYSCON.split();
-//! let mut timer  = p.UTICK.enable(&mut syscon.handle);
-//!
-//! // Start the timer at 1_000_000. Sine the UTICK tuner 1 MHz,
-//! // this translates to a one second wait.
-//! timer.start(1_000_000u32);
-//!
-//! while let Err(nb::Error::WouldBlock) = timer.wait() {
-//!     // do stuff
-//! }
-//! ```
-//!
-//! Please refer to the [examples in the repository] for more example code.
+//! # Examples: led.rs, led_utick.rs
 
 use embedded_hal::timer;
 use nb;
@@ -162,11 +139,17 @@ impl timer::CountDown for EnabledUtick<'_> {
     }
 }
 
+impl EnabledUtick<'_> {
+    pub fn blocking_wait(&mut self) {
+        while self.raw.stat.read().active().bit_is_set() {}
+    }
+}
+
 /// A clock that is usable by the micro-tick timer (UTICK)
 ///
 /// This trait is implemented for all clocks that are supported by the UTICK,
 /// which is just FRO1MHZ.
 /// The user shouldn't need to implement this trait themselves.
 pub trait Clock {}
 
-impl<State> Clock for Fro1MhzUtickClock<State> {}
+impl Clock for Fro1MhzUtickClock<init_state::Enabled> {}