Update 05-led-roulette/it-blinks.md to the updated crates

Author: nikgul

microbit/src/05-led-roulette/it-blinks.md

@@ -5,12 +5,12 @@ Now we're going to take a brief look into delay abstractions provided by `embedd
 before combining this with the GPIO abstractions from the previous chapter in order to
 finally make an LED blink.
 
-`embedded-hal` provides us with two abstractions to delay the execution of our program:
-[`DelayUs`] and [`DelayMs`]. Both of them essentially work the exact same way except
-that they accept different units for their delay function.
+`embedded-hal` provides us with an abstractions to delay the execution of our program:
+[`DelayNs`]. This abstraction provides three functions `delay_ns`, `delay_us` and `delay_ms`
+that delays execution for nano, micro or mili seconds respectively. They essentially work
+the exact same way except that they accept different units for their delay function.
 
-[`DelayUs`]: https://docs.rs/embedded-hal/0.2.6/embedded_hal/blocking/delay/trait.DelayUs.html
-[`DelayMs`]: https://docs.rs/embedded-hal/0.2.6/embedded_hal/blocking/delay/trait.DelayMs.html
+[`DelayNs`]: https://docs.rs/embedded-hal/1.0.0/embedded_hal/blocking/delay/trait.DelayNs.html
 
 Inside our MCU, several so-called "timers" exist. They can do various things regarding time for us,
 including simply pausing the execution of our program for a fixed amount of time. A very
@@ -22,21 +22,25 @@ simple delay-based program that prints something every second might for example
 #![no_std]
 
 use cortex_m_rt::entry;
-use rtt_target::{rtt_init_print, rprintln};
+use embedded_hal::delay::DelayNS;
+use rtt_target::{
+    rtt_init_print,
+    rprintln,
+};
 use panic_rtt_target as _;
 use microbit::board::Board;
 use microbit::hal::timer::Timer;
-use microbit::hal::prelude::*;
 
 #[entry]
 fn main() -> ! {
     rtt_init_print!();
-    let mut board = Board::take().unwrap();
+
+    let board = Board::take().unwrap();
 
     let mut timer = Timer::new(board.TIMER0);
 
     loop {
-        timer.delay_ms(1000u16);
+        timer.delay_ms(1_000u32);
         rprintln!("1000 ms passed");
     }
 }
@@ -47,20 +51,20 @@ Note that we changed our panic implementation from `panic_halt` to
 RTT lines from `Cargo.toml` and comment the `panic-halt` one out,
 since Rust only allows one panic implementation at a time.
 
-In order to actually see the prints we have to change `Embed.toml` like this:
+In order to actually see the prints we have to change `Embed.toml` like shown on the marked lines (`<--- Here`):
 ```
 [default.general]
 # chip = "nrf52833_xxAA" # uncomment this line for micro:bit V2
 # chip = "nrf51822_xxAA" # uncomment this line for micro:bit V1
 
 [default.reset]
-halt_afterwards = false
+halt_afterwards = false     <--- Here
 
 [default.rtt]
-enabled = true
+enabled = true              <--- Here
 
 [default.gdb]
-enabled = false
+enabled = false             <--- Here
 ```
 
 And now after putting the code into `src/main.rs` and another quick `cargo embed` (again with the same flags you used before)
@@ -78,15 +82,22 @@ a mash-up of the one above and the one that turned an LED on in the last section
 #![no_std]
 
 use cortex_m_rt::entry;
-use rtt_target::{rtt_init_print, rprintln};
+use rtt_target::{
+    rtt_init_print,
+    rprintln,
+};
 use panic_rtt_target as _;
+use embedded_hal::{
+    delay::DelayNS,
+    digital::OutputPin,
+};
 use microbit::board::Board;
 use microbit::hal::timer::Timer;
-use microbit::hal::prelude::*;
 
 #[entry]
 fn main() -> ! {
     rtt_init_print!();
+
     let mut board = Board::take().unwrap();
 
     let mut timer = Timer::new(board.TIMER0);
@@ -98,6 +109,7 @@ fn main() -> ! {
         row1.set_low().unwrap();
         rprintln!("Dark!");
         timer.delay_ms(1_000_u16);
+
         row1.set_high().unwrap();
         rprintln!("Light!");
         timer.delay_ms(1_000_u16);