Use probe-rs as probe-run is deprecated

.cargo/config.toml

@@ -1,5 +1,5 @@
 [target.'cfg(all(target_arch = "arm", target_os = "none"))']
-runner = "probe-run --chip STM32F446RETx" # Use with probe-run (see https://github.com/knurling-rs/probe-run)
+runner = "probe-rs run --chip STM32F446RETx" # Use with probe-rs (see https://github.com/probe-rs/probe-rs)
 # runner = "arm-none-eabi-gdb -q -x openocd.gdb" # Use with GDB / OpenOCD. Note: you may need to use gdb-multiarch instead depending on your platform
 
 rustflags = [

Cargo.toml

@@ -13,11 +13,12 @@ categories = ["embedded", "hardware-support", "no-std"]
 # See more keys and their definitions at https://doc.rust-lang.org/cargo/reference/manifest.html
 
 [dependencies]
-cortex-m = "0.7.5"
+cortex-m = { version = "0.7.5", features = ["critical-section-single-core"] }
 embedded-hal = "0.2.7"
 switch-hal = "0.4.0"
 stm32f4xx-hal = { version = "0.13.2", features = ["stm32f446"]}
 unwrap-infallible = "0.1.5"
+rtt-target = "0.5.0"
 
 [dev-dependencies]
 cortex-m-rt = "0.7.1"

Embed.toml

@@ -0,0 +1,7 @@
+[default.general]
+chip = "STM32F446RETx"
+
+# By default use denable rtt if we use `cargo embed`
+[default.rtt]
+enabled = true
+

README.md

@@ -25,7 +25,7 @@ There are two main ways to make use of this BSP:
 Many examples are provided to illustrate both ways of using the BSP, which can be found in the `examples` directory. Use a USB cable to connect the Nucleo board's debugger to the host computer, and then run an example with cargo:
 > `cargo run --example blinky`
 
-Here, `cargo run` implicitly makes use of [probe-run](https://github.com/knurling-rs/probe-run) to flash, execute, and handle panic and backtrace info. If you prefer GDB and OpenOCD, you can change the behavior of `cargo run` by editing `.cargo/config.toml` (basic scripts for GDB and OpenOCD are provided).
+Here, `cargo run` implicitly makes use of [probe-rs](https://github.com/probe-rs/probe-rs) to flash, execute, and handle panic and backtrace info. If you prefer GDB and OpenOCD, you can change the behavior of `cargo run` by editing `.cargo/config.toml` (basic scripts for GDB and OpenOCD are provided).
 
 # Reference material
 

examples/README.md

@@ -0,0 +1,14 @@
+# Examples
+
+If you've installed `probe-rs` with `cargo install probe-rs --features cli`
+just use `cargo run --example <filename>` to build and run any of the
+examples.
+
+For `channels-3d-1u` you can use also use
+`cargo embed --example channels-3d-1u` which provides a nicer interface,
+a terminal with 3 tabs and you can switch between the tabe using
+F1, F2 and F3.
+
+In all cases Ctrl-C terminates the program.
+
+**TODO:** Document serial_*, inparticular how to setup the hardware!

examples/channels-3u-1d.rs

@@ -0,0 +1,91 @@
+#![deny(unsafe_code)]
+#![no_std]
+#![no_main]
+
+use cortex_m_rt::entry;
+use embedded_hal::blocking::delay::DelayMs;
+use nucleo_f446re::{led::LedDigital, Nucleo};
+use panic_probe as _;
+
+
+use core::fmt::Write;
+use rtt_target::{rtt_init, ChannelMode::BlockIfFull};
+
+#[entry]
+fn main() -> ! {
+    let mut nucleo = Nucleo::<LedDigital>::init().unwrap();
+
+    let channels = rtt_init! {
+        up: {
+            0: {
+                size: 512,
+                mode: BlockIfFull,
+                name: "Up zero"
+            }
+            1: {
+                size: 128,
+                name: "Up one"
+            }
+            2: {
+                size: 128,
+                name: "Up two"
+            }
+        }
+        down: {
+            0: {
+                size: 512,
+                mode: BlockIfFull,
+                name: "Down zero"
+            }
+        }
+    };
+
+    let mut output2 = channels.up.1;
+    writeln!(
+        output2,
+        "Hi! I will turn anything you type on channel 0 into upper case."
+    )
+    .ok();
+
+    let mut output = channels.up.0;
+    let mut log = channels.up.2;
+    let mut input = channels.down.0;
+    let mut buf = [0u8; 512];
+    let mut count: u8 = 0;
+
+    loop {
+        writeln!(log, "Top of loop, invoking input.read").ok();
+        let bytes = loop {
+            let bytes_read = input.read(&mut buf[..]);
+
+            if bytes_read > 0 {
+                break bytes_read;
+            }
+
+            writeln!(log, "No bytes read, sleeping").ok();
+            nucleo.delay.delay_ms(1000_u32);
+        };
+
+        writeln!(log, "read {} bytes", bytes).ok();
+        if bytes > 0 {
+            for c in buf.iter_mut() {
+                c.make_ascii_uppercase();
+            }
+
+            let mut p = 0;
+            while p < bytes {
+                p += output.write(&buf[p..bytes]);
+            }
+        }
+
+        writeln!(log, "Messsge no. {}/{}", count, bytes).ok();
+        nucleo.user_led.toggle();
+
+        count += 1;
+
+        nucleo.delay.delay_ms(10_u32);
+        //for _ in 0..1_000_000 {
+        //    cortex_m::asm::nop();
+        //}
+    }
+}

examples/rprintln.rs

@@ -0,0 +1,23 @@
+#![deny(unsafe_code)]
+#![no_std]
+#![no_main]
+
+use cortex_m_rt::entry;
+use embedded_hal::blocking::delay::DelayMs;
+use nucleo_f446re::{led::LedDigital, Nucleo};
+use panic_probe as _;
+use rtt_target;
+
+#[entry]
+fn main() -> ! {
+    let mut nucleo = Nucleo::<LedDigital>::init().unwrap();
+    // Can also use the LED default generic argument with <Nucleo>::init().unwrap();
+
+    rtt_target::rtt_init_print!();
+    loop {
+        rtt_target::rprintln!("rprintln!(Hello, world!)");
+        rtt_target::debug_rprintln!("debug_rprintln!(Hello, world!)");
+        nucleo.user_led.toggle();
+        nucleo.delay.delay_ms(500_u32);
+    }
+}