This repository contains an example demonstrating how to use a Mutex to safely share and update a u32 counter variable between interrupt context and the main loop on the Tiva C Series microcontroller using the Rust Embedded ecosystem.
Concurrency is a common challenge in embedded systems, especially when sharing data between the main application and interrupt service routines (ISRs). Rust’s ownership model helps enforce safe concurrency, and the Mutex abstraction from the cortex_m::interrupt module enables safe shared access to data.
In this example, a u32 counter is protected by a Mutex, allowing both the main loop and an interrupt handler (e.g., triggered by a button press or timer event) to safely access and modify the shared variable.
This is a departure from simpler examples that only toggle or read a bool flag. Using a u32 demonstrates how to work with more complex shared data and atomic-style updates in an embedded Rust environment.
- Safe sharing of a
u32counter between main and interrupt contexts. - Uses
Mutexfromcortex_m::interruptto guarantee data race freedom. - Runs on the Tiva C Series TM4C123G microcontroller.
- Illustrates best practices for writing concurrent embedded Rust code.
- Tiva C Series LaunchPad (TM4C123GXL)
- Rust toolchain with target support for
thumbv7em-none-eabi - TivaCRustWare as the base project template
probe-rsoropenocdfor flashing the firmware
# Add target if you haven't already
rustup target add thumbv7em-none-eabi
# Build the project
cargo build --release
# Flash to device (example using probe-rs)
cargo run --release- A global static
Mutex<RefCell<Option<u32>>>wraps the counter variable. - The main loop and an interrupt handler both enter critical sections to access and update the counter.
- This ensures the shared
u32is never accessed concurrently from multiple contexts.
This example is designed for students and embedded systems developers looking to understand how to safely share data between threads of execution in Rust, specifically in environments where standard threading libraries are unavailable and concurrency is managed through interrupts.
MIT License