### Run All RTIC Examples with QEMU

Source: https://github.com/rtic-rs/rtic/blob/master/book/en/src/by-example.md

This command executes all RTIC examples using QEMU, targeting the default 'lm3s6965' device. Ensure 'qemu-system-arm' is installed and the embedded Rust environment is set up.

```bash
cargo xtask qemu
```

--------------------------------

### Run examples/tests on QEMU device

Source: https://github.com/rtic-rs/rtic/blob/master/CONTRIBUTING.md

Executes examples and tests on a local QEMU installation to simulate a device environment.

```shell
> cargo xtask qemu

```

--------------------------------

### Run Specific RTIC Example with QEMU

Source: https://github.com/rtic-rs/rtic/blob/master/book/en/src/by-example.md

This command runs a specific RTIC example (e.g., 'locals') using QEMU. Replace '<example name>' with the desired example's filename. This is useful for testing individual examples.

```bash
cargo xtask qemu --example <example name>
```

--------------------------------

### RTIC Example Run Command

Source: https://github.com/rtic-rs/rtic/blob/master/book/en/src/by-example.md

This is the underlying Cargo run command executed by 'cargo xtask qemu' for a specific example. It builds and then runs the example using QEMU with specified configurations.

```bash
cd examples/lm3s6965 && cargo run --target thumbv7m-none-eabi --features test-critical-section,thumbv7-backend --release --example locals
```

--------------------------------

### Cargo xtask Help

Source: https://github.com/rtic-rs/rtic/blob/master/book/en/src/by-example.md

This command displays the help message for 'cargo xtask qemu', providing information on available options for running and configuring examples, such as changing the target platform.

```bash
cargo xtask qemu --help
```

--------------------------------

### RTIC Idle Task Example

Source: https://github.com/rtic-rs/rtic/blob/master/book/en/src/by-example/app_idle.md

Demonstrates the basic usage of the RTIC idle task, showing its execution after the init task. This snippet assumes the RTIC framework and a target microcontroller setup.

```rust
rtic::app! {
    // ... other components

    idle: idle,

    #[init]
    fn init(cx: init::Context) -> (Self::Resources, ()), {
        // ... initialization code
        (MyResources { /* ... */ }, ())
    }

    #[idle]
    fn idle(_cx: idle::Context) -> ! {
        loop {
            // Idle task runs here, with interrupts enabled
            // This task must never return
        }
    }

    // ... other tasks
}

```

--------------------------------

### RTIC Example Build Command

Source: https://github.com/rtic-rs/rtic/blob/master/book/en/src/by-example.md

This is the underlying Cargo build command executed by 'cargo xtask qemu' for a specific example. It specifies the target architecture, release profile, and features, then builds the example.

```bash
cd examples/lm3s6965 && cargo build --target thumbv7m-none-eabi --features test-critical-section,thumbv7-backend --release --example locals
```

--------------------------------

### QEMU Execution Command

Source: https://github.com/rtic-rs/rtic/blob/master/book/en/src/by-example.md

This command demonstrates how QEMU is invoked to run a compiled RTIC example. It configures the CPU, machine, and essential emulation parameters like nographic and semihosting.

```bash
qemu-system-arm -cpu cortex-m3 -machine lm3s6965evb -nographic -semihosting-config enable=on,target=native -kernel target/thumbv7m-none-eabi/release/examples/locals
```

--------------------------------

### Run 'sw_and_hw' Example

Source: https://github.com/rtic-rs/rtic/blob/master/examples/esp32c6/README.md

Executes the 'sw_and_hw' example, demonstrating software and hardware task interactions on the ESP32-C6. The optional '--release' flag enables optimizations for performance.

```bash
cargo run --example sw_and_hw (--release)
```

--------------------------------

### Run RTIC Example with Verbose Output

Source: https://github.com/rtic-rs/rtic/blob/master/book/en/src/by-example.md

This command runs an RTIC example with verbose logging enabled, showing detailed build and execution information, as well as program output. The '--verbose' or '-v' flag is crucial for observing program output during debugging.

```bash
cargo xtask qemu --verbose --example locals
```

--------------------------------

### Run RTIC Example with ESP32-C3 Backend

Source: https://github.com/rtic-rs/rtic/blob/master/examples/esp32c3/README.md

Builds and runs the `sw_and_hw` example of the RTIC application on the ESP32-C3 microcontroller. This command utilizes the `riscv-esp32c3-backend` feature and optionally compiles in release mode.

```bash
cargo run --example sw_and_hw --features=riscv-esp32c3-backend (--release)
```

--------------------------------

### RTIC v1.0.x Blinky Example

Source: https://github.com/rtic-rs/rtic/blob/master/book/en/src/migration_v1_v2/complete_example.md

This Rust code implements a basic blinking LED example using RTIC v1.0.x. It sets up hardware peripherals, initializes a monotonic timer, and schedules a periodic task to toggle the LED. Dependencies include `panic_rtt_target`, `rtic`, `rtt_target`, `stm32f3xx_hal`, and `systick_monotonic`.

```rust
#![deny(unsafe_code)]
#![deny(warnings)]
#![no_main]
#![no_std]

use panic_rtt_target as _;
use rtic::app;
use rtt_target::{rprintln, rtt_init_print};
use stm32f3xx_hal::gpio::{Output, PushPull, PA5};
use stm32f3xx_hal::prelude::*;
use systick_monotonic::{fugit::Duration, Systick};

#[app(device = stm32f3xx_hal::pac, peripherals = true, dispatchers = [SPI1])] 
mod app {
    use super::*;

    #[shared]
    struct Shared {}

    #[local]
    struct Local {
        led: PA5<Output<PushPull>>,
        state: bool,
    }

    #[monotonic(binds = SysTick, default = true)]
    type MonoTimer = Systick<1000>;

    #[init]
    fn init(cx: init::Context) -> (Shared, Local, init::Monotonics) {
        // Setup clocks
        let mut flash = cx.device.FLASH.constrain();
        let mut rcc = cx.device.RCC.constrain();

        let mono = Systick::new(cx.core.SYST, 36_000_000);

        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_after(Duration::<u64, 1, 1000>::from_ticks(1000)).unwrap();

        (
            Shared {},
            Local { led, state: false },
            init::Monotonics(mono),
        )
    }

    #[task(local = [led, state])]
    fn blink(cx: blink::Context) {
        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;
        }
        blink::spawn_after(Duration::<u64, 1, 1000>::from_ticks(1000)).unwrap();
    }
}

```

--------------------------------

### Run 'monotonic' Example

Source: https://github.com/rtic-rs/rtic/blob/master/examples/esp32c6/README.md

Executes the 'monotonic' example, showcasing the use of monotonic time and task scheduling in RTIC for the ESP32-C6. The optional '--release' flag enables optimizations.

```bash
cargo run --example monotonic (--release)
```

--------------------------------

### Check examples with cargo xtask

Source: https://github.com/rtic-rs/rtic/blob/master/CONTRIBUTING.md

Performs a check on the project's examples to ensure they are valid and functional.

```shell
> cargo xtask example-check

```

--------------------------------

### RTIC v2.0.0 Blinky Example with Async Tasks

Source: https://github.com/rtic-rs/rtic/blob/master/book/en/src/migration_v1_v2/complete_example.md

This Rust code demonstrates a blinking LED example using RTIC v2.0.0, featuring asynchronous tasks and updated monotonic timer handling. It utilizes `rtic-monotonics` for the Systick timer and `async/await` for task delays. Dependencies include `panic_rtt_target`, `rtic`, `stm32f3xx_hal`, and `rtic_monotonics`.

```rust
#![no_main]
 #![no_std]
 
 use panic_rtt_target as _;
 use rtic::app;
 use stm32f3xx_hal::gpio::{Output, PushPull, PA5};
 use stm32f3xx_hal::prelude::*;
 use rtic_monotonics::Systick;
 
 #[app(device = stm32f3xx_hal::pac, peripherals = true, dispatchers = [SPI1])] 
 mod app {
     use super::*;
 
     #[shared]
     struct Shared {}
 
     #[local]
     struct Local {
         led: PA5<Output<PushPull>>,
         state: bool,
     }
 
     #[init]
     fn init(cx: init::Context) -> (Shared, Local, init::Monotonics) {
         // Setup clocks
         let mut flash = cx.device.FLASH.constrain();
         let mut rcc = cx.device.RCC.constrain();
 
         let mono_token = rtic_monotonics::create_systick_token!();
         let mono = Systick::start(cx.core.SYST, 36_000_000, mono_token);
 
         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().unwrap();
 
         (
             Shared {},
             Local { led, state: false },
             init::Monotonics(mono),
         )
     }
 
     #[task(local = [led, state])]
     async fn blink(cx: blink::Context) {
         loop {
             // A task is now allowed to run forever, provided that
             // there is an `await` somewhere in the loop.
             SysTick::delay(1000.millis()).await;
             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;
             }
         }
     }
 }

```

--------------------------------

### Install Espressif Toolchain using Cargo

Source: https://github.com/rtic-rs/rtic/blob/master/examples/esp32c6/README.md

Installs the necessary Espressif toolchain components, cargo-espflash and espflash, which are essential for flashing and managing the ESP32-C6 device. This is a prerequisite for running the RTIC application.

```bash
cargo install cargo-espflash espflash
```

--------------------------------

### RTIC Migration Diff: Monotonic Timer and Task Scheduling

Source: https://github.com/rtic-rs/rtic/blob/master/book/en/src/migration_v1_v2/complete_example.md

This diff highlights the key changes between RTIC v1.0.x and v2.0.0 for the stm32f3_blinky example. It shows the transition from `systick_monotonic` to `rtic_monotonics`, the removal of the explicit `#[monotonic]` attribute, and the adoption of `async/await` for task execution with `SysTick::delay`.

```diff
#![no_main]
 #![no_std]
 
 use panic_rtt_target as _;
 use rtic::app;
 use stm32f3xx_hal::gpio::{Output, PushPull, PA5};
 use stm32f3xx_hal::prelude::*;
-use systick_monotonic::{fugit::Duration, Systick};
+use rtic_monotonics::Systick;
 
 #[app(device = stm32f3xx_hal::pac, peripherals = true, dispatchers = [SPI1])] 
 mod app {
@@ -20,16 +21,14 @@ mod app {
         state: bool,
     }
 
-    #[monotonic(binds = SysTick, default = true)]
-    type MonoTimer = Systick<1000>;
-
     #[init]
     fn init(cx: init::Context) -> (Shared, Local, init::Monotonics) {
         // Setup clocks
         let mut flash = cx.device.FLASH.constrain();
         let mut rcc = cx.device.RCC.constrain();
 
-        let mono = Systick::new(cx.core.SYST, 36_000_000);
+        let mono_token = rtic_monotonics::create_systick_token!();
+        let mono = Systick::start(cx.core.SYST, 36_000_000, mono_token);
 
         let _clocks = rcc
             .cfgr
@@ -46,7 +45,7 @@ mod app {
         led.set_high().unwrap();
 
         // Schedule the blinking task
-        blink::spawn_after(Duration::<u64, 1, 1000>::from_ticks(1000)).unwrap();
+        blink::spawn().unwrap();
 
         (
             Shared {},
@@ -56,14 +55,18 @@ mod app {
     }
 
     #[task(local = [led, state])]
-    fn blink(cx: blink::Context) {
-        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;
-        blink::spawn_after(Duration::<u64, 1, 1000>::from_ticks(1000)).unwrap();
-    }
+    async fn blink(cx: blink::Context) {
+        loop {
+            // A task is now allowed to run forever, provided that
+            // there is an `await` somewhere in the loop.
+            SysTick::delay(1000.millis()).await;
+            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;
+            }
+        }
+    }
 }

```

--------------------------------

### Console Output: Zero Priority Task Example

Source: https://github.com/rtic-rs/rtic/blob/master/book/en/src/by-example/software_tasks.md

This console output shows the expected execution flow and messages when running the `zero-prio-task` example on the lm3s6965 platform. It details the sequence of task activations and log messages, providing insight into the priority zero task's behavior.

```console
Initializing... 
SysTick interrupt
SysTick interrupt
task0 running, tick: 188775
SysTick interrupt
task1 running
SysTick interrupt
task0 running, tick: 377550
SysTick interrupt
task1 running
SysTick interrupt
task0 running, tick: 566325
SysTick interrupt
task1 running
SysTick interrupt
task0 running, tick: 755100
SysTick interrupt
task1 running
SysTick interrupt
task0 running, tick: 943875
SysTick interrupt
task1 running
SysTick interrupt
task0 running, tick: 1132650
SysTick interrupt
task1 running
SysTick interrupt
task0 running, tick: 1321425
SysTick interrupt
task1 running
SysTick interrupt
task0 running, tick: 1510200
SysTick interrupt
task1 running
SysTick interrupt
task0 running, tick: 1698975
SysTick interrupt
task1 running
SysTick interrupt
task0 running, tick: 1887750
SysTick interrupt
task1 running
SysTick interrupt
task0 running, tick: 2076525
SysTick interrupt
task1 running
SysTick interrupt
task0 running, tick: 2265300
SysTick interrupt
task1 running
SysTick interrupt
task0 running, tick: 2454075
SysTick interrupt
task1 running
SysTick interrupt
task0 running, tick: 2642850
SysTick interrupt
task1 running
SysTick interrupt
task0 running, tick: 2831625
SysTick interrupt
task1 running
SysTick interrupt
task0 running, tick: 3020400
SysTick interrupt
task1 running
SysTick interrupt
task0 running, tick: 3209175
SysTick interrupt
task1 running
SysTick interrupt
task0 running, tick: 3397950
SysTick interrupt
task1 running
SysTick interrupt
task0 running, tick: 3586725
SysTick interrupt
task1 running
SysTick interrupt
task0 running, tick: 3775500
SysTick interrupt
task1 running
SysTick interrupt
task0 running, tick: 3964275
SysTick interrupt
task1 running
SysTick interrupt
task0 running, tick: 4153050
SysTick interrupt
task1 running
SysTick interrupt
task0 running, tick: 4341825
SysTick interrupt
task1 running
SysTick interrupt
task0 running, tick: 4530600
SysTick interrupt
task1 running
SysTick interrupt
task0 running, tick: 4719375
SysTick interrupt
task1 running
SysTick interrupt
task0 running, tick: 4908150
SysTick interrupt
task1 running
SysTick interrupt
task0 running, tick: 5096925
SysTick interrupt
task1 running
SysTick interrupt
task0 running, tick: 5285700
SysTick interrupt
task1 running
SysTick interrupt
task0 running, tick: 5474475
SysTick interrupt
task1 running
SysTick interrupt
task0 running, tick: 5663250
SysTick interrupt
task1 running
SysTick interrupt
task0 running, tick: 5852025
SysTick interrupt
task1 running
SysTick interrupt
task0 running, tick: 6040800
SysTick interrupt
task1 running
SysTick interrupt
task0 running, tick: 6229575
SysTick interrupt
task1 running
SysTick interrupt
task0 running, tick: 6418350
SysTick interrupt
task1 running
SysTick interrupt
task0 running, tick: 6607125
SysTick interrupt
task1 running
SysTick interrupt
task0 running, tick: 6795900
SysTick interrupt
task1 running
SysTick interrupt
task0 running, tick: 6984675
SysTick interrupt
task1 running
SysTick interrupt
task0 running, tick: 7173450
SysTick interrupt
task1 running
SysTick interrupt
task0 running, tick: 7362225
SysTick interrupt
task1 running
SysTick interrupt
task0 running, tick: 7551000
SysTick interrupt
task1 running
SysTick interrupt
task0 running, tick: 7739775
SysTick interrupt
task1 running
SysTick interrupt
task0 running, tick: 7928550
SysTick interrupt
task1 running
SysTick interrupt
task0 running, tick: 8117325
SysTick interrupt
task1 running
SysTick interrupt
task0 running, tick: 8306100
SysTick interrupt
task1 running
SysTick interrupt
task0 running, tick: 8494875
SysTick interrupt
task1 running
SysTick interrupt
task0 running, tick: 8683650
SysTick interrupt
task1 running
SysTick interrupt
task0 running, tick: 8872425
SysTick interrupt
task1 running
SysTick interrupt
task0 running, tick: 9061200
SysTick interrupt
task1 running
SysTick interrupt
task0 running, tick: 9249975
SysTick interrupt
task1 running
SysTick interrupt
task0 running, tick: 9438750
SysTick interrupt
task1 running
SysTick interrupt
task0 running, tick: 9627525
SysTick interrupt
task1 running
SysTick interrupt
task0 running, tick: 9816300
SysTick interrupt
task1 running
SysTick interrupt
task0 running, tick: 10005075
SysTick interrupt
task1 running
SysTick interrupt
task0 running, tick: 10193850
SysTick interrupt
task1 running
SysTick interrupt
task0 running, tick: 10382625
SysTick interrupt
task1 running
SysTick interrupt
task0 running, tick: 10571400
SysTick interrupt
task1 running
SysTick interrupt
task0 running, tick: 10760175
SysTick interrupt
task1 running
SysTick interrupt
task0 running, tick: 10948950
SysTick interrupt
task1 running
SysTick interrupt
task0 running, tick: 11137725
SysTick interrupt
task1 running
SysTick interrupt
task0 running, tick: 11326500
SysTick interrupt
task1 running
SysTick interrupt
task0 running, tick: 11515275
SysTick interrupt
task1 running
SysTick interrupt
task0 running, tick: 11704050
SysTick interrupt
task1 running
SysTick interrupt
task0 running, tick: 11892825
SysTick interrupt
task1 running
SysTick interrupt
task0 running, tick: 12081600
SysTick interrupt
task1 running
SysTick interrupt
task0 running, tick: 12270375
SysTick interrupt
task1 running
SysTick interrupt
task0 running, tick: 12459150
SysTick interrupt
task1 running
SysTick interrupt
task0 running, tick: 12647925
SysTick interrupt
task1 running
SysTick interrupt
task0 running, tick: 12836700
SysTick interrupt
task1 running
SysTick interrupt
task0 running, tick: 13025475
SysTick interrupt
task1 running
SysTick interrupt
task0 running, tick: 13214250
SysTick interrupt
task1 running
SysTick interrupt
task0 running, tick: 13403025
SysTick interrupt
task1 running
SysTick interrupt
task0 running, tick: 13591800
SysTick interrupt
task1 running
SysTick interrupt
task0 running, tick: 13780575
SysTick interrupt
task1 running
SysTick interrupt
task0 running, tick: 13969350
SysTick interrupt
task1 running
SysTick interrupt
task0 running, tick: 14158125
SysTick interrupt
task1 running
SysTick interrupt
task0 running, tick: 14346900
SysTick interrupt
task1 running
SysTick interrupt
task0 running, tick: 14535675
SysTick interrupt
task1 running
SysTick interrupt
task0 running, tick: 14724450
SysTick interrupt
task1 running
SysTick interrupt
task0 running, tick: 14913225
SysTick interrupt
task1 running
SysTick interrupt
task0 running, tick: 15102000
SysTick interrupt
task1 running
SysTick interrupt
task0 running, tick: 15290775
SysTick interrupt
task1 running
SysTick interrupt
task0 running, tick: 15479550
SysTick interrupt
task1 running
SysTick interrupt
task0 running, tick: 15668325
SysTick interrupt
task1 running
SysTick interrupt
task0 running, tick: 15857100
SysTick interrupt
task1 running
SysTick interrupt
task0 running, tick: 16045875
SysTick interrupt
task1 running
SysTick interrupt
task0 running, tick: 16234650
SysTick interrupt
task1 running
SysTick interrupt
task0 running, tick: 16423425
SysTick interrupt
task1 running
SysTick interrupt
task0 running, tick: 16612200
SysTick interrupt
task1 running
SysTick interrupt
task0 running, tick: 16800975
SysTick interrupt
task1 running
SysTick interrupt
task0 running, tick: 16989750
SysTick interrupt
task1 running
SysTick interrupt
task0 running, tick: 17178525
SysTick interrupt
task1 running
SysTick interrupt
task0 running, tick: 17367300
SysTick interrupt
task1 running
SysTick interrupt
task0 running, tick: 17556075
SysTick interrupt
task1 running
SysTick interrupt
task0 running, tick: 17744850
SysTick interrupt
task1 running
SysTick interrupt
task0 running, tick: 17933625
SysTick interrupt
task1 running
SysTick interrupt
task0 running, tick: 18122400
SysTick interrupt
task1 running
SysTick interrupt
task0 running, tick: 18311175
SysTick interrupt
task1 running
SysTick interrupt
task0 running, tick: 18499950
SysTick interrupt
task1 running
SysTick interrupt
task0 running, tick: 18688725
SysTick interrupt
task1 running
SysTick interrupt
task0 running, tick: 18877500
SysTick interrupt
task1 running
SysTick interrupt
task0 running, tick: 19066275
SysTick interrupt
task1 running
SysTick interrupt
task0 running, tick: 19255050
SysTick interrupt
task1 running
SysTick interrupt
task0 running, tick: 19443825
SysTick interrupt
task1 running
SysTick interrupt
task0 running, tick: 19632600
SysTick interrupt
task1 running
SysTick interrupt
task0 running, tick: 19821375
SysTick interrupt
task1 running
SysTick interrupt
task0 running, tick: 20010150
SysTick interrupt
task1 running
SysTick interrupt
task0 running, tick: 20198925
SysTick interrupt
task1 running
SysTick interrupt
task0 running, tick: 20387700
SysTick interrupt
task1 running
SysTick interrupt
task0 running, tick: 20576475
SysTick interrupt
task1 running
SysTick interrupt
task0 running, tick: 20765250
SysTick interrupt
task1 running
SysTick interrupt
task0 running, tick: 20954025
SysTick interrupt
task1 running
SysTick interrupt
task0 running, tick: 21142800
SysTick interrupt
task1 running
SysTick interrupt
task0 running, tick: 21331575
SysTick interrupt
task1 running
SysTick interrupt
task0 running, tick: 21520350
SysTick interrupt
task1 running
SysTick interrupt
task0 running, tick: 21709125
SysTick interrupt
task1 running
SysTick interrupt
task0 running, tick: 21897900
SysTick interrupt
task1 running
SysTick interrupt
task0 running, tick: 22086675
SysTick interrupt
task1 running
SysTick interrupt
task0 running, tick: 22275450
SysTick interrupt
task1 running
SysTick interrupt
task0 running, tick: 22464225
SysTick interrupt
task1 running
SysTick interrupt
task0 running, tick: 22653000
SysTick interrupt
task1 running
SysTick interrupt
task0 running, tick: 22841775
SysTick interrupt
task1 running
SysTick interrupt
task0 running, tick: 23030550
SysTick interrupt
task1 running
SysTick interrupt
task0 running, tick: 23219325
SysTick interrupt
task1 running
SysTick interrupt
task0 running, tick: 23408100
SysTick interrupt
task1 running
SysTick interrupt
task0 running, tick: 23596875
SysTick interrupt
task1 running
SysTick interrupt
task0 running, tick: 23785650
SysTick interrupt
task1 running
SysTick interrupt
task0 running, tick: 23974425
SysTick interrupt
task1 running
SysTick interrupt
task0 running, tick: 24163200
SysTick interrupt
task1 running
SysTick interrupt
task0 running, tick: 24351975
SysTick interrupt
task1 running
SysTick interrupt
task0 running, tick: 24540750
SysTick interrupt
task1 running
SysTick interrupt
task0 running, tick: 24729525
SysTick interrupt
task1 running
SysTick interrupt
task0 running, tick: 24918300
SysTick interrupt
task1 running
SysTick interrupt
task0 running, tick: 25107075
SysTick interrupt
task1 running
SysTick interrupt
task0 running, tick: 25295850
SysTick interrupt
task1 running
SysTick interrupt
task0 running, tick: 25484625
SysTick interrupt
task1 running
SysTick interrupt
task0 running, tick: 25673400
SysTick interrupt
task1 running
SysTick interrupt
task0 running, tick: 25862175
SysTick interrupt
task1 running
SysTick interrupt
task0 running, tick: 26050950
SysTick interrupt
task1 running
SysTick interrupt
task0 running, tick: 26239725
SysTick interrupt
task1 running
SysTick interrupt
task0 running, tick: 26428500
SysTick interrupt
task1 running
SysTick interrupt
task0 running, tick: 26617275
SysTick interrupt
task1 running
SysTick interrupt
task0 running, tick: 26806050
SysTick interrupt
task1 running
SysTick interrupt
task0 running, tick: 26994825
SysTick interrupt
task1 running
SysTick interrupt
task0 running, tick: 27183600
SysTick interrupt
task1 running
SysTick interrupt
task0 running, tick: 27372375
SysTick interrupt
task1 running
SysTick interrupt
task0 running, tick: 27561150
SysTick interrupt
task1 running
SysTick interrupt
task0 running, tick: 27749925
SysTick interrupt
task1 running
SysTick interrupt
task0 running, tick: 27938700
SysTick interrupt
task1 running
SysTick interrupt
task0 running, tick: 28127475
SysTick interrupt
task1 running
SysTick interrupt
task0 running, tick: 28316250
SysTick interrupt
task1 running
SysTick interrupt
task0 running, tick: 28505025
SysTick interrupt
task1 running
SysTick interrupt
task0 running, tick: 28693800
SysTick interrupt
task1 running
SysTick interrupt
task0 running, tick: 28882575
SysTick interrupt
task1 running
SysTick interrupt
task0 running, tick: 29071350
SysTick interrupt
task1 running
SysTick interrupt
task0 running, tick: 29260125
SysTick interrupt
task1 running
SysTick interrupt
task0 running, tick: 29448900
SysTick interrupt
task1 running
SysTick interrupt
task0 running, tick: 29637675
SysTick interrupt
task1 running
SysTick interrupt
task0 running, tick: 29826450
SysTick interrupt
task1 running
SysTick interrupt
task0 running, tick: 30015225
SysTick interrupt
task1 running
SysTick interrupt
task0 running, tick: 30204000
SysTick interrupt
task1 running
SysTick interrupt
task0 running, tick: 30392775
SysTick interrupt
task1 running
SysTick interrupt
task0 running, tick: 30581550
SysTick interrupt
task1 running
SysTick interrupt
task0 running, tick: 30770325
SysTick interrupt
task1 running
SysTick interrupt
task0 running, tick: 30959100
SysTick interrupt
task1 running
SysTick interrupt
task0 running, tick: 31147875
SysTick interrupt
task1 running
SysTick interrupt
task0 running, tick: 31336650
SysTick interrupt
task1 running
SysTick interrupt
task0 running, tick: 31525425
SysTick interrupt
task1 running
SysTick interrupt
task0 running, tick: 31714200
SysTick interrupt
task1 running
SysTick interrupt
task0 running, tick: 31902975
SysTick interrupt
task1 running
SysTick interrupt
task0 running, tick: 32091750
SysTick interrupt
task1 running
SysTick interrupt
task0 running, tick: 32280525
SysTick interrupt
task1 running
SysTick interrupt
task0 running, tick: 32469300
SysTick interrupt
task1 running
SysTick interrupt
task0 running, tick: 32658075
SysTick interrupt
task1 running
SysTick interrupt
task0 running, tick: 32846850
SysTick interrupt
task1 running
SysTick interrupt
task0 running, tick: 33035625
SysTick interrupt
task1 running
SysTick interrupt
task0 running, tick: 33224400
SysTick interrupt
task1 running
SysTick interrupt
task0 running, tick: 33413175
SysTick interrupt
task1 running
SysTick interrupt
task0 running, tick: 33601950
SysTick interrupt
task1 running
SysTick interrupt
task0 running, tick: 33790725
SysTick interrupt
task1 running
SysTick interrupt
task0 running, tick: 33979500
SysTick interrupt
task1 running
SysTick interrupt
task0 running, tick: 34168275
SysTick interrupt
task1 running
SysTick interrupt
task0 running, tick: 34357050
SysTick interrupt
task1 running
SysTick interrupt
task0 running, tick: 34545825
SysTick interrupt
task1 running
SysTick interrupt
task0 running, tick: 34734600
SysTick interrupt
task1 running
SysTick interrupt
task0 running, tick: 34923375
SysTick interrupt
task1 running
SysTick interrupt
task0 running, tick: 35112150
SysTick interrupt
task1 running
SysTick interrupt
task0 running, tick: 35300925
SysTick interrupt
task1 running
SysTick interrupt
task0 running, tick: 35489700
SysTick interrupt
task1 running
SysTick interrupt
task0 running, tick: 35678475
SysTick interrupt
task1 running
SysTick interrupt
task0 running, tick: 35867250
SysTick interrupt
task1 running
SysTick interrupt
task0 running, tick: 36056025
SysTick interrupt
task1 running
SysTick interrupt
task0 running, tick: 36244800
SysTick interrupt
task1 running
SysTick interrupt
task0 running, tick: 36433575
SysTick interrupt
task1 running
SysTick interrupt
task0 running, tick: 36622350
SysTick interrupt
task1 running
SysTick interrupt
task0 running, tick: 36811125
SysTick interrupt
task1 running
SysTick interrupt
task0 running, tick: 37000000
SysTick interrupt
task1 running
SysTick interrupt
task0 running, tick: 37188775
SysTick interrupt
task1 running
SysTick interrupt
task0 running, tick: 37377550
SysTick interrupt
task1 running
SysTick interrupt
task0 running, tick: 37566325
SysTick interrupt
task1 running
SysTick interrupt
task0 running, tick: 37755100
SysTick interrupt
task1 running
SysTick interrupt
task0 running, tick: 37943875
SysTick interrupt
task1 running
SysTick interrupt
task0 running, tick: 38132650
SysTick interrupt
task1 running
SysTick interrupt
task0 running, tick: 38321425
SysTick interrupt
task1 running
SysTick interrupt
task0 running, tick: 38510200
SysTick interrupt
task1 running
SysTick interrupt
task0 running, tick: 38698975
SysTick interrupt
task1 running
SysTick interrupt
task0 running, tick: 38887750
SysTick interrupt
task1 running
SysTick interrupt
task0 running, tick: 39076525
SysTick interrupt
task1 running
SysTick interrupt
task0 running, tick: 39265300
SysTick interrupt
task1 running
SysTick interrupt
task0 running, tick: 39454075
SysTick interrupt
t
```

--------------------------------

### RTIC Application Example

Source: https://github.com/rtic-rs/rtic/blob/master/book/en/src/by-example/app.md

A common example demonstrating various features of an RTIC application. This snippet showcases the typical structure and usage patterns within an RTIC project. It requires the RTIC framework and a compatible peripheral access crate.

```rust
#[allow(unused_mut)]
#[entry]
fn init() -> (Dis, Option<Shared1>) {
    //... omitted for brevity
}

#[task(priority = 1, shared = [&'static mut SERIAL])]
fn task1(mut _ctx: task1::Context) {
    //... omitted for brevity
}

#[task(priority = 1, shared = [&'static mut SERIAL])]
fn task2(_ctx: task2::Context) {
    //... omitted for brevity
}

#[idle]
fn idle(_ctx: idle::Context) -> ! {
    //... omitted for brevity
}

```

--------------------------------

### Expected Output for RTIC Static Resources Example (Console)

Source: https://github.com/rtic-rs/rtic/blob/master/book/en/src/by-example/tips/static_lifetimes.md

This console output shows the result of running the RTIC example that utilizes static resources. It displays the expected behavior and messages produced by the application when executed in the QEMU environment.

```console
Dequeue: 42

```

--------------------------------

### Build Project with Cargo

Source: https://github.com/rtic-rs/rtic/blob/master/examples/stm32f1_bluepill_blinky/README.md

Compiles the Rust embedded project. The first build may take time due to dependency downloads and compilation. Subsequent builds are faster.

```shell
cargo build
```

--------------------------------

### Example: Zero Priority Task in Rust

Source: https://github.com/rtic-rs/rtic/blob/master/book/en/src/by-example/software_tasks.md

This Rust code demonstrates the implementation of a zero priority task within the RTIC framework. It showcases how to define and utilize tasks that run at the lowest priority level for background processing. Ensure you have the RTIC framework set up to run this example.

```rust
#![no_std]

extern crate panic_halt;

use core::fmt::Write;
use cortex_m_rt::entry;
use lm3s6965;
use rtic::{{Mutex, exceptions::ExceptionFrame, cyccnt::CycleCounter, Modal, Task, idle}};

const MAX_MESSAGE_LEN: usize = 64;

#[derive(Default)]
struct App {
    log: Log,
}

#[derive(Default)]
struct Log {
    buf: [u8; MAX_MESSAGE_LEN],
    /// the cursor points to the next position to write to
    cursor: usize,
}

impl Log {
    fn write_str(&mut self, s: &str) {
        for c in s.bytes() {
            if c == b'\n' {
                self.cursor = 0;
            } else {
                self.buf[self.cursor] = c;
                self.cursor = (self.cursor + 1) % MAX_MESSAGE_LEN;
            }
        }
    }

    fn write_fmt(&mut self, fmt: core::fmt::Arguments<'_>) {
        let mut buf = [0u8; 16];
        let mut s = "";
        let _ = write!(&mut s, "{{}}", fmt);
        self.write_str(s);
    }
}

impl Write for Log {
    fn write_str(&mut self, s: &str) -> core::fmt::Result {
        self.write_str(s);
        Ok(())
    }
}

#[rtic::app(device = lm3s6965)]
mod app {
    use super::{App, Log, MAX_MESSAGE_LEN};
    use rtic::cyccnt::{CycleCounter, Duration, U32};

    #[resources]
    struct Resources {
        log: Log,
        #[lock(priority = 0)]
        counter: CycleCounter<U32>,
    }

    #[init]
    fn init(ctx: init::Context) -> init::LateResources<Resources> {
        let mut log = Log::default();
        let mut counter = CycleCounter::<U32>::new(ctx.core.DCGCNT);
        counter.enable();

        log.write_fmt(format_args!("Initializing... \n"));

        init::LateResources {
            log,
            counter,
        }
    }

    #[idle(priority = 0, resources = [log])]
    fn idle(ctx: idle::Context) -> ! {
        loop {
            // idle task should not do anything
            // `idle` will be polled when there are no other tasks ready to run.
            // The executor will enter low power mode if possible.
        }
    }

    #[task(priority = 1, resources = [log])]
    fn task1(ctx: task1::Context) {
        ctx.resources.log.write_fmt(format_args!("task1 running\n"));
    }

    #[task(priority = 0, resources = [log, counter])]
    fn task0(ctx: task0::Context) {
        let counter = ctx.resources.counter;
        ctx.resources.log.write_fmt(format_args!("task0 running, tick: {{:?}} \n", counter.tick()));

        // simulate some work
        let start = counter.tick();
        while counter.tick() <= start + 10_000 {
            cortex_m::asm::nop();
        }
    }

    #[exception(resources = [log])]
    fn SysTick(ctx: SysTick::Context) {
        let mut log = ctx.resources.log;
        log.write_fmt(format_args!("SysTick interrupt\n"));
    }

    #[exception(resources = [log])]
    fn PendSV(ctx: PendSV::Context) {
        let mut log = ctx.resources.log;
        log.write_fmt(format_args!("PendSV interrupt\n"));
    }
}

```

--------------------------------

### Flash and Run with Cargo Embed

Source: https://github.com/rtic-rs/rtic/blob/master/examples/stm32f1_bluepill_blinky/README.md

Flashes the compiled firmware onto the STM32F103 board using the `cargo-embed` tool from the probe-rs suite. Requires an ST-Link v2 programmer connected to the board.

```shell
cargo embed --release
```

--------------------------------

### Smallest RTIC Application in Rust

Source: https://github.com/rtic-rs/rtic/blob/master/book/en/src/by-example/app_minimal.md

This Rust code snippet represents the absolute minimal application that can be built with RTIC. It demonstrates the framework's design for resource efficiency, requiring minimal RAM and a small flash memory footprint.

```rust
#![no_std]

use rtic::app;

#[app(device = lm3s6965)]
smod app {
    #[init]
    fn init() -> init {
        // No hardware setup needed for the minimal example
        init {}
    }

    #[idle]
    fn idle() -> ! {
        loop {
            // Minimal app does nothing
            rtic::export::wfi();
        }
    }
}

```

--------------------------------

### RTIC App Size Output Analysis

Source: https://github.com/rtic-rs/rtic/blob/master/book/en/src/by-example/app_minimal.md

This console output shows the result of the `cargo size` command for the minimal RTIC application. It details the text, data, bss, decimal, and hexadecimal sizes, confirming the small footprint.

```console
Finished release [optimized] target(s) in 0.07s
   text    data     bss     dec     hex filename
    924       0       0     924     39c smallest

```

--------------------------------

### RTIC Ceiling Analysis Example (Rust)

Source: https://github.com/rtic-rs/rtic/blob/master/book/en/src/internals/ceilings.md

Illustrates resource priority ceiling calculation and its effect on task access to shared resources within an RTIC application. It shows how tasks with priorities equal to or higher than the resource ceiling get direct mutable references, while lower-priority tasks receive proxies. The example highlights special handling for `init` and `idle` tasks.

```rust
#[rtic::app(device = ..)]
mod app {
    struct Resources {
        // accessed by `foo` (prio = 1) and `bar` (prio = 2)
        // -> CEILING = 2
        #[init(0)]
        x: u64,

        // accessed by `idle` (prio = 0)
        // -> CEILING = 0
        #[init(0)]
        y: u64,
    }

    #[init(resources = [x])] 
    fn init(c: init::Context) {
        // unique reference because this is `init`
        let x: &mut u64 = c.resources.x;

        // unique reference because this is `init`
        let y: &mut u64 = c.resources.y;

        // ..
    }

    // PRIORITY = 0
    #[idle(resources = [y])] 
    fn idle(c: idle::Context) -> !
{
        // unique reference because priority (0) == resource ceiling (0)
        let y: &'static mut u64 = c.resources.y;

        loop {
            // ..
        }
    }

    #[interrupt(binds = UART0, priority = 1, resources = [x])] 
    fn foo(c: foo::Context) {
        // resource proxy because task priority (1) < resource ceiling (2)
        let x: resources::x = c.resources.x;

        // ..
    }

    #[interrupt(binds = UART1, priority = 2, resources = [x])] 
    fn bar(c: foo::Context) {
        // unique reference because task priority (2) == resource ceiling (2)
        let x: &mut u64 = c.resources.x;

        // ..
    }

    // ..
}

```