Split remove old examples

examples/stm32f3_blinky/.cargo/config.toml

@@ -0,0 +1,45 @@
+[target.thumbv7m-none-eabi]
+# uncomment this to make `cargo run` execute programs on QEMU
+# runner = "qemu-system-arm -cpu cortex-m3 -machine lm3s6965evb -nographic -semihosting-config enable=on,target=native -kernel"
+
+[target.'cfg(all(target_arch = "arm", target_os = "none"))']
+# uncomment ONE of these three option to make `cargo run` start a GDB session
+# which option to pick depends on your system
+# runner = "arm-none-eabi-gdb -q -x openocd.gdb"
+# runner = "gdb-multiarch -q -x openocd.gdb"
+# runner = "gdb -q -x openocd.gdb"
+
+rustflags = [
+  # This is needed if your flash or ram addresses are not aligned to 0x10000 in memory.x
+  # See https://github.com/rust-embedded/cortex-m-quickstart/pull/95
+  "-C", "link-arg=--nmagic",
+
+  # LLD (shipped with the Rust toolchain) is used as the default linker
+  "-C", "link-arg=-Tlink.x",
+
+  # if you run into problems with LLD switch to the GNU linker by commenting out
+  # this line
+  # "-C", "linker=arm-none-eabi-ld",
+
+  # if you need to link to pre-compiled C libraries provided by a C toolchain
+  # use GCC as the linker by commenting out both lines above and then
+  # uncommenting the three lines below
+  # "-C", "linker=arm-none-eabi-gcc",
+  # "-C", "link-arg=-Wl,-Tlink.x",
+  # "-C", "link-arg=-nostartfiles",
+]
+
+[build]
+# Pick ONE of these compilation targets
+# target = "thumbv6m-none-eabi"        # Cortex-M0 and Cortex-M0+
+target = "thumbv7m-none-eabi"        # Cortex-M3
+# target = "thumbv7em-none-eabi"       # Cortex-M4 and Cortex-M7 (no FPU)
+# target = "thumbv7em-none-eabihf"     # Cortex-M4F and Cortex-M7F (with FPU)
+# target = "thumbv8m.base-none-eabi"   # Cortex-M23
+# target = "thumbv8m.main-none-eabi"   # Cortex-M33 (no FPU)
+# target = "thumbv8m.main-none-eabihf" # Cortex-M33 (with FPU)
+
+# thumbv7m-none-eabi is not coming with core and alloc, compile myself
+[unstable]
+mtime-on-use = true
+build-std = ["core", "alloc"]

examples/stm32f3_blinky/Cargo.toml

@@ -0,0 +1,35 @@
+[package]
+authors = ["Simsys <winfried.simon@gmail.com>"]
+edition = "2021"
+readme = "README.md"
+name = "stm32f3-blinky"
+version = "0.1.0"
+
+[dependencies]
+embedded-hal = "0.2.7"
+rtic = { git = "https://github.com/rtic-rs/rtic", features = ["thumbv7-backend"] }
+rtic-monotonics = { git = "https://github.com/rtic-rs/rtic", features = ["cortex-m-systick"] }
+panic-rtt-target = { version = "0.1.2", features = ["cortex-m"] }
+rtt-target = { version = "0.3.1", features = ["cortex-m"] }
+
+[dependencies.stm32f3xx-hal]
+features = ["stm32f303xc", "rt"]
+version = "0.9.2"
+
+# this lets you use `cargo fix`!
+[[bin]]
+name = "stm32f3-blinky"
+test = false
+bench = false
+
+[profile.dev]
+opt-level = 1
+codegen-units = 16
+debug = true
+lto = false
+
+[profile.release]
+opt-level = "s"   # optimize for size
+codegen-units = 1 # better optimizations
+debug = true      # symbols are nice and they don't increase the size on Flash
+lto = true        # better optimizations

examples/stm32f3_blinky/Embed.toml

@@ -0,0 +1,9 @@
+[default.general]
+chip = "stm32f303re"
+
+
+[default.rtt]
+enabled = true
+
+[default.gdb]
+enabled = false

examples/stm32f3_blinky/README.md

@@ -0,0 +1,19 @@
+# STM32F3 RTIC Blink example
+
+Working example of simple LED blinking application for STM32 F303 Nucleo-64 board based on the STM32F303RE chip. Example uses schedule API and peripherials access. This example is based on blue-pill blinky example.
+
+## How-to
+
+### Build
+
+Run `cargo +nightly build` to compile the code. If you run it for the first time, it will take some time to download and compile dependencies.
+
+After that, you can use for example the cargo-embed tool to flash and run it
+
+```bash
+$ cargo +nightly embed
+```
+
+### Setup environment, flash and run program
+
+In the [Discovery Book](https://rust-embedded.github.io/discovery) you find all needed informations to setup the environment, flash the controler and run the program.

examples/stm32f3_blinky/memory.x

@@ -0,0 +1,5 @@
+MEMORY
+{
+    FLASH : ORIGIN = 0x08000000, LENGTH = 256K
+    RAM : ORIGIN = 0x20000000, LENGTH = 40K
+}

examples/stm32f3_blinky/src/main.rs

@@ -0,0 +1,74 @@
+#![deny(unsafe_code)]
+#![deny(warnings)]
+#![no_main]
+#![no_std]
+#![feature(type_alias_impl_trait)]
+
+use panic_rtt_target as _;
+use rtic::app;
+use rtic_monotonics::systick::*;
+use rtt_target::{rprintln, rtt_init_print};
+use stm32f3xx_hal::gpio::{Output, PushPull, PA5};
+use stm32f3xx_hal::prelude::*;
+
+#[app(device = stm32f3xx_hal::pac, peripherals = true, dispatchers = [SPI1])]
+mod app {
+    use super::*;
+
+    rtic_monotonics::make_systick_handler!();
+
+    #[shared]
+    struct Shared {}
+
+    #[local]
+    struct Local {
+        led: PA5<Output<PushPull>>,
+        state: bool,
+    }
+
+    #[init]
+    fn init(cx: init::Context) -> (Shared, Local) {
+        // Setup clocks
+        let mut flash = cx.device.FLASH.constrain();
+        let mut rcc = cx.device.RCC.constrain();
+
+        Systick::start(cx.core.SYST, 36_000_000); // default STM32F303 clock-rate is 36MHz
+
+        rtt_init_print!();
+        rprintln!("init");
+
+        let _clocks = rcc
+            .cfgr
+            .use_hse(8.MHz())
+            .sysclk(36.MHz())
+            .pclk1(36.MHz())
+            .freeze(&mut flash.acr);
+
+        // Setup LED
+        let mut gpioa = cx.device.GPIOA.split(&mut rcc.ahb);
+        let mut led = gpioa
+            .pa5
+            .into_push_pull_output(&mut gpioa.moder, &mut gpioa.otyper);
+        led.set_high().unwrap();
+
+        // Schedule the blinking task
+        blink::spawn().ok();
+
+        (Shared {}, Local { led, state: false })
+    }
+
+    #[task(local = [led, state])]
+    async fn blink(cx: blink::Context) {
+        loop {
+            rprintln!("blink");
+            if *cx.local.state {
+                cx.local.led.set_high().unwrap();
+                *cx.local.state = false;
+            } else {
+                cx.local.led.set_low().unwrap();
+                *cx.local.state = true;
+            }
+            Systick::delay(1000.millis()).await;
+        }
+    }
+}