TivaC Mutex Counter Example

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.

Overview

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.

Features

Safe sharing of a u32 counter between main and interrupt contexts.
Uses Mutex from cortex_m::interrupt to guarantee data race freedom.
Runs on the Tiva C Series TM4C123G microcontroller.
Illustrates best practices for writing concurrent embedded Rust code.

Requirements

Tiva C Series LaunchPad (TM4C123GXL)
Rust toolchain with target support for thumbv7em-none-eabi
TivaCRustWare as the base project template
probe-rs or openocd for flashing the firmware

Building and Flashing

# 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

How It Works

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 u32 is never accessed concurrently from multiple contexts.

Educational Value

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.

License

MIT License

wang32/TivaCMutexCNT

About

Resources

Stars

Watchers

Forks

Releases

Languages