Upgrade nrf51-hal to 0.12.1

This is a large change down to the nrf51-hal API changing significantly
between 0.7 and 0.10. Below I cover the big changes from the perspective
of what has changed in the nrf51-hal API first as that is where I
started.

The library
===========

`nrf51_hal::timer`
------------------
This is the biggest change. The new timer interface is significantly
stripped back so all of the interrupt and compare config in
`microbit::display::timer` now have to be done directly on the PAC.
A gotcha I hit here was that on the nrf51 all but the first timer seem
to only be 16 bit. While the implementation has changed significantly
here the public interface has not changed.

`nrf51_hal::gpio`
-----------------
How the pins are accessed and how they are named has changed however at
the end of the day, they're still GPIO pins so it's not too difficult.

`nrf51_hal::twi`
----------------
The name has changed, arguments are slightly different and you have to
pass the frequency explicitly now. Other than that it seems the same.

`nrf51_hal::uart`
-----------------
The name has changed, arguments are slightly different and you have to
pass whether the parity bit is included explicitly now. There doesn't
seem to be a way to split it into separate read and write parts but for
the examples that didn't seem to be a problem.

The examples
============

I have updated all examples to compile and tried to run them however not
all of them work.

Fully working
-------------
- `gpio_direct_blinky.rs`
- `gpio_hal_blinky.rs`
- `gpio_hal_ledbutton.rs`
- `gpio_hal_printbuttons.rs`
- `led_blocking.rs`
- `led_nonblocking.rs` (it's a bit flickery but it was before, I'll look
  at that separately
- `led_rtfm.rs`
- `rng_direct_printrngserial.rs`
- `serial_direct_echo.rs`
- `serial_direct_helloworld.rs`
- `serial_hal_blocking_echo.rs`

Not working
-----------

None of these work for me on this branch or on master. I would
appreciate someone who has them working on master testing them for me.

- `rng_hal_printrandserial.rs`: crashes on line 84 at `rng.next_u32()`.
- `gpio_hal_receivedcf77.rs`: just get a zero timestamp.

I believe all these are failing because I have v1.5 see #9
- `i2c_direct_printmagserial.rs`
- `i2c_hal_printmagserial.rs`
- `i2c_haldriver_printmagserial.rs`

Author: robyoung

Cargo.toml

@@ -23,23 +23,42 @@ version = "0.8.0"
 cortex-m = "0.6.1"
 cortex-m-rt = "0.6.10"
 nb = "0.1.2"
-nrf51-hal = "0.7.0"
+nrf51-hal = "0.12.1"
 tiny-led-matrix = "1.0.1"
+embedded-hal = "0.2.4"
+
+defmt = "0.1.3"
 
 [dev-dependencies]
-cortex-m-semihosting = "0.3.5"
 numtoa = "0.2.3"
 dcf77 = "0.1.0"
 mag3110 = "0.1.4"
 panic-halt = "0.2.0"
-cortex-m-rtfm = "0.5"
+cortex-m-rtic = "0.5"
+defmt-rtt = "0.1.0"
+panic-probe = { version = "0.1.0", features = ["print-defmt"] }
+
+[features]
+# set logging levels here
+default = [
+  "defmt-default",
+  # "dependency-a/defmt-trace",
+]
+
+# do NOT modify these features
+defmt-default = []
+defmt-trace = []
+defmt-debug = []
+defmt-info = []
+defmt-warn = []
+defmt-error = []
 
 [dev-dependencies.rand]
 default-features = false
-version = "0.7.2"
+version = "0.8.3"
 
 [dev-dependencies.rand_chacha]
-version = "0.2.1"
+version = "0.3.0"
 default-features = false
 
 [profile.dev]

examples/gpio_direct_blinky.rs

@@ -23,7 +23,7 @@ fn main() -> ! {
                 p.GPIO.out.write(|w| unsafe { w.bits(0) });
             }
 
-            for _ in 0..1_000_000 {
+            for _ in 0..50_000 {
                 cortex_m::asm::nop();
             }
         }

examples/gpio_hal_blinky.rs

@@ -3,24 +3,28 @@
 
 use panic_halt as _;
 
-use microbit::hal::delay::Delay;
-use microbit::hal::prelude::*;
-
 use cortex_m_rt::entry;
+use embedded_hal::{blocking::delay::DelayMs, digital::v2::OutputPin};
+use microbit::hal::{
+    gpio::{p0, Level},
+    timer::Timer,
+};
 
 #[entry]
 fn main() -> ! {
     if let Some(p) = microbit::Peripherals::take() {
-        let gpio = p.GPIO.split();
-        let mut delay = Delay::new(p.TIMER0);
-        let mut led = gpio.pin13.into_push_pull_output();
-        let _ = gpio.pin4.into_push_pull_output();
+        /* Split GPIO pins */
+        let gpio = p0::Parts::new(p.GPIO);
+
+        let mut timer = Timer::new(p.TIMER0);
+        let mut led = gpio.p0_13.into_push_pull_output(Level::Low);
+        let _ = gpio.p0_04.into_push_pull_output(Level::Low);
 
         loop {
             let _ = led.set_low();
-            delay.delay_ms(1_000_u16);
+            timer.delay_ms(1_000_u16);
             let _ = led.set_high();
-            delay.delay_ms(1_000_u16);
+            timer.delay_ms(1_000_u16);
         }
     }
 

examples/gpio_hal_ledbutton.rs

@@ -4,24 +4,24 @@
 use panic_halt as _;
 
 use cortex_m_rt::entry;
-use microbit::hal::prelude::*;
+use microbit::hal::{self, gpio::Level, prelude::*};
 
 #[entry]
 fn main() -> ! {
     if let Some(p) = microbit::Peripherals::take() {
         // Split GPIO pins
-        let gpio = p.GPIO.split();
+        let gpio = hal::gpio::p0::Parts::new(p.GPIO);
 
         // Set row of LED matrix to permanent high
-        let _ = gpio.pin13.into_push_pull_output().set_high();
+        let _ = gpio.p0_13.into_push_pull_output(Level::Low).set_high();
 
         // Set 2 columns to output to control LED states
-        let mut led1 = gpio.pin4.into_push_pull_output();
-        let mut led2 = gpio.pin6.into_push_pull_output();
+        let mut led1 = gpio.p0_04.into_push_pull_output(Level::Low);
+        let mut led2 = gpio.p0_06.into_push_pull_output(Level::Low);
 
         // Configure button GPIOs as inputs
-        let button_a = gpio.pin17.into_floating_input();
-        let button_b = gpio.pin26.into_floating_input();
+        let button_a = gpio.p0_17.into_floating_input();
+        let button_b = gpio.p0_26.into_floating_input();
 
         loop {
             if let Ok(true) = button_a.is_high() {

examples/gpio_hal_printbuttons.rs

@@ -3,39 +3,39 @@
 
 use panic_halt as _;
 
-use microbit::hal::nrf51::{interrupt, GPIOTE, UART0};
-use microbit::hal::prelude::*;
-use microbit::hal::serial;
-use microbit::hal::serial::BAUD115200;
-use microbit::NVIC;
+use core::{cell::RefCell, fmt::Write, ops::DerefMut};
 
 use cortex_m::interrupt::Mutex;
 use cortex_m_rt::entry;
+use microbit::{
+    hal::{
+        self,
+        uart::{Baudrate, Uart},
+    },
+    pac::{self, interrupt},
+};
 
-use core::cell::RefCell;
-use core::fmt::Write;
-use core::ops::DerefMut;
-
-static GPIO: Mutex<RefCell<Option<GPIOTE>>> = Mutex::new(RefCell::new(None));
-static TX: Mutex<RefCell<Option<serial::Tx<UART0>>>> = Mutex::new(RefCell::new(None));
+static GPIO: Mutex<RefCell<Option<pac::GPIOTE>>> = Mutex::new(RefCell::new(None));
+static TX: Mutex<RefCell<Option<Uart<pac::UART0>>>> = Mutex::new(RefCell::new(None));
 
 #[entry]
 fn main() -> ! {
     if let Some(p) = microbit::Peripherals::take() {
         cortex_m::interrupt::free(move |cs| {
             /* Enable external GPIO interrupts */
             unsafe {
-                NVIC::unmask(microbit::Interrupt::GPIOTE);
+                pac::NVIC::unmask(pac::Interrupt::GPIOTE);
             }
-            microbit::NVIC::unpend(microbit::Interrupt::GPIOTE);
+            pac::NVIC::unpend(pac::Interrupt::GPIOTE);
 
             /* Split GPIO pins */
-            let gpio = p.GPIO.split();
+            let gpio = hal::gpio::p0::Parts::new(p.GPIO);
 
             /* Configure button GPIOs as inputs */
-            let _ = gpio.pin26.into_floating_input();
-            let _ = gpio.pin17.into_floating_input();
+            let _ = gpio.p0_26.into_floating_input();
+            let _ = gpio.p0_17.into_floating_input();
 
+            // TODO: check for safe wrappers
             /* Set up GPIO 17 (button A) to generate an interrupt when pulled down */
             p.GPIOTE.config[0]
                 .write(|w| unsafe { w.mode().event().psel().bits(17).polarity().hi_to_lo() });
@@ -50,18 +50,14 @@ fn main() -> ! {
 
             *GPIO.borrow(cs).borrow_mut() = Some(p.GPIOTE);
 
-            /* Configure RX and TX pins accordingly */
-            let tx = gpio.pin24.into_push_pull_output().into();
-            let rx = gpio.pin25.into_floating_input().into();
-
-            /* Set up serial port using the prepared pins */
-            let (mut tx, _) = serial::Serial::uart0(p.UART0, tx, rx, BAUD115200).split();
+            /* Initialise serial port on the micro:bit */
+            let mut serial = microbit::serial_port!(gpio, p.UART0, Baudrate::BAUD115200);
 
             let _ = write!(
-                tx,
+                serial,
                 "\n\rWelcome to the buttons demo. Press buttons A and/or B for some action.\n\r",
             );
-            *TX.borrow(cs).borrow_mut() = Some(tx);
+            *TX.borrow(cs).borrow_mut() = Some(serial);
         });
     }
 

examples/gpio_hal_receivedcf77.rs

@@ -3,33 +3,31 @@
 
 use panic_halt as _;
 
-use dcf77::{DCF77Time, SimpleDCF77Decoder};
-
-use microbit::hal::gpio::gpio::PIN16;
-use microbit::hal::gpio::{Floating, Input};
-use microbit::hal::nrf51::{interrupt, RTC0, UART0};
-use microbit::hal::prelude::*;
-use microbit::hal::serial;
-use microbit::hal::serial::BAUD115200;
-use microbit::NVIC;
+use core::{cell::RefCell, fmt::Write, ops::DerefMut};
 
 use cortex_m::interrupt::Mutex;
-
 use cortex_m_rt::entry;
-
-use core::cell::RefCell;
-use core::fmt::Write;
-use core::ops::DerefMut;
+use dcf77::{DCF77Time, SimpleDCF77Decoder};
+use microbit::{
+    hal::{
+        self,
+        gpio::{p0::P0_16, Floating, Input},
+        prelude::*,
+        uart::{Baudrate, Uart},
+    },
+    pac::{self, interrupt},
+};
 
 static DCF: Mutex<RefCell<Option<SimpleDCF77Decoder>>> = Mutex::new(RefCell::new(None));
-static DCFPIN: Mutex<RefCell<Option<PIN16<Input<Floating>>>>> = Mutex::new(RefCell::new(None));
-static RTC: Mutex<RefCell<Option<RTC0>>> = Mutex::new(RefCell::new(None));
-static TX: Mutex<RefCell<Option<serial::Tx<UART0>>>> = Mutex::new(RefCell::new(None));
+static DCFPIN: Mutex<RefCell<Option<P0_16<Input<Floating>>>>> = Mutex::new(RefCell::new(None));
+static RTC: Mutex<RefCell<Option<pac::RTC0>>> = Mutex::new(RefCell::new(None));
+static TX: Mutex<RefCell<Option<Uart<pac::UART0>>>> = Mutex::new(RefCell::new(None));
 
 #[entry]
 fn main() -> ! {
     if let Some(p) = microbit::Peripherals::take() {
         cortex_m::interrupt::free(move |cs| {
+            // TODO: check if there are safe wrappers now
             p.CLOCK.tasks_lfclkstart.write(|w| unsafe { w.bits(1) });
 
             while p.CLOCK.events_lfclkstarted.read().bits() == 0 {}
@@ -38,36 +36,34 @@ fn main() -> ! {
             p.CLOCK.events_lfclkstarted.write(|w| unsafe { w.bits(0) });
 
             /* Split GPIO pins */
-            let gpio = p.GPIO.split();
+            let gpio = hal::gpio::p0::Parts::new(p.GPIO);
 
             /* Configure DCF77 receiver GPIO as input */
-            let pin = gpio.pin16.into_floating_input();
-
-            /* Configure RX and TX pins accordingly */
-            let tx = gpio.pin24.into_push_pull_output().into();
-            let rx = gpio.pin25.into_floating_input().into();
+            let pin = gpio.p0_16.into_floating_input();
 
-            /* Set up serial port using the prepared pins */
-            let (mut tx, _) = serial::Serial::uart0(p.UART0, tx, rx, BAUD115200).split();
+            /* Initialise serial port on the micro:bit */
+            let mut serial = microbit::serial_port!(gpio, p.UART0, Baudrate::BAUD115200);
 
-            let _ = tx.write_str("\n\rWelcome to the DCF77 decoder demo.\n\r");
-            let _ = tx.write_str("If you are within reach of a DCF77 radio clock signal and have a DCF77 receiver connected\n\r");
-            let _ = tx.write_str("you should see a stream of 59 bits appear in a line, followed by thd decoded date and time.\n\r");
-            let _ = tx.write_str("If not, please check your hardware, location and reception.\n\r");
+            let _ = serial.write_str("\n\rWelcome to the DCF77 decoder demo.\n\r");
+            let _ = serial.write_str("If you are within reach of a DCF77 radio clock signal and have a DCF77 receiver connected\n\r");
+            let _ = serial.write_str("you should see a stream of 59 bits appear in a line, followed by thd decoded date and time.\n\r");
+            let _ =
+                serial.write_str("If not, please check your hardware, location and reception.\n\r");
+            // TODO: check for safe wrappers
             p.RTC0.prescaler.write(|w| unsafe { w.bits(327) });
             p.RTC0.evtenset.write(|w| w.tick().set_bit());
             p.RTC0.intenset.write(|w| w.tick().set_bit());
             p.RTC0.tasks_start.write(|w| unsafe { w.bits(1) });
 
             *RTC.borrow(cs).borrow_mut() = Some(p.RTC0);
-            *TX.borrow(cs).borrow_mut() = Some(tx);
+            *TX.borrow(cs).borrow_mut() = Some(serial);
             *DCFPIN.borrow(cs).borrow_mut() = Some(pin);
             *DCF.borrow(cs).borrow_mut() = Some(SimpleDCF77Decoder::new());
 
             unsafe {
-                NVIC::unmask(microbit::Interrupt::RTC0);
+                pac::NVIC::unmask(pac::Interrupt::RTC0);
             }
-            microbit::NVIC::unpend(microbit::Interrupt::RTC0);
+            pac::NVIC::unpend(pac::Interrupt::RTC0);
         });
     }
 

examples/i2c_direct_printmagserial.rs

@@ -3,19 +3,15 @@
 
 use panic_halt as _;
 
-use microbit::hal::nrf51::*;
-use microbit::hal::nrf51::{interrupt, UART0};
-use microbit::NVIC;
+use core::{cell::RefCell, fmt::Write};
 
 use cortex_m::interrupt::Mutex;
-
-use core::cell::RefCell;
-use core::fmt::Write;
 use cortex_m_rt::entry;
+use microbit::pac::{self, interrupt};
 
-static RTC: Mutex<RefCell<Option<RTC0>>> = Mutex::new(RefCell::new(None));
-static UART: Mutex<RefCell<Option<UART0>>> = Mutex::new(RefCell::new(None));
-static TWI: Mutex<RefCell<Option<TWI1>>> = Mutex::new(RefCell::new(None));
+static RTC: Mutex<RefCell<Option<pac::RTC0>>> = Mutex::new(RefCell::new(None));
+static UART: Mutex<RefCell<Option<pac::UART0>>> = Mutex::new(RefCell::new(None));
+static TWI: Mutex<RefCell<Option<pac::TWI1>>> = Mutex::new(RefCell::new(None));
 
 #[entry]
 fn main() -> ! {
@@ -93,9 +89,9 @@ fn main() -> ! {
         });
 
         unsafe {
-            NVIC::unmask(microbit::Interrupt::RTC0);
+            pac::NVIC::unmask(pac::Interrupt::RTC0);
         }
-        microbit::NVIC::unpend(microbit::Interrupt::RTC0);
+        pac::NVIC::unpend(pac::Interrupt::RTC0);
     }
 
     loop {
@@ -166,7 +162,7 @@ fn RTC0() {
     }
 }
 
-pub struct UART0Buffer<'a>(pub &'a UART0);
+pub struct UART0Buffer<'a>(pub &'a pac::UART0);
 
 impl<'a> core::fmt::Write for UART0Buffer<'a> {
     fn write_str(&mut self, s: &str) -> core::fmt::Result {