n-k / cortexm-threads

Simple context switching library for ARM Cortex-M MCUs in Rust

CORTEXM_THREADS

A simple library for context-switching on ARM Cortex-M ( 0, 0+, 3, 4, 4F ) micro-processors

Supports pre-emptive, priority based switching

This project is meant for learning and should be used only at the user's risk. For practical and mature rust alternatives, see Awesome Embedded Rust

Current State

Processor support:

• Cortex-M0
• Cortex-M0+
• Cortex-M3
• Cortex-M4
• Cortex-M4F

Features:

• Preemptive, priority-based switching
• Efficient sleep
• Accept stack memory area as a vec (arrayvec?, smallvec?) instead of &[]
• Non-privileged mode
• Mutex implementation aware of thread scheduling

Examples

The example_crates folder contains crates showing how to use cortexm-threads for different boards.

Available examples:

• stm32f3 - 2 threads with one thread running an LED roulette, and the other periodically printing magnetometer readings. Currently compiles for target thumbv7m-none-eabi instead of thumbv7em-none-eabihf. See Roadmap#1
• microbit - 2 threads printing messages with co-operative context switching
• qemu-m4 - (set up to run on qemu) 2 threads printing messages via semi-hosting. Run cargo run from example_crates/qemu-m4 directory to see it running. You must have qemu-system-arm on the system PATH.

Sample:

#![no_std]
#![no_main]
extern crate panic_semihosting;
use cortex_m::peripheral::syst::SystClkSource;
use cortex_m_rt::{entry, exception};
use cortex_m_semihosting::{hprintln};
use cortexm_threads::{init, create_thread, create_thread_with_config, sleep};

#[entry]
fn main() -> ! {
	let cp = cortex_m::Peripherals::take().unwrap();
	let mut syst = cp.SYST;
	syst.set_clock_source(SystClkSource::Core);
	syst.set_reload(80_000);
	syst.enable_counter();
	syst.enable_interrupt();
	let mut stack1 = [0xDEADBEEF; 512];
	let mut stack2 = [0xDEADBEEF; 512];
	let _ = create_thread(
		&mut stack1, 
		|| {
			loop {
				let _ = hprintln!("in task 1 !!");
				sleep(50); // sleep for 50 ticks
			}
		});
	let _ = create_thread_with_config(
		&mut stack2, 
		|| {
			loop {
				let _ = hprintln!("in task 2 !!");
				sleep(30); // sleep for 30 ticks
			}
		},
		0x01, // priority, higher numeric value means higher priority
		true  // privileged thread
		);
    init();
}

License

See LICENSE.md

cortexm-threads's Issues

Add docker file for bringing up repeatable dev environment

Also add vscode dev-container config

Export __CORTEXM_THREADS_cpsid and __CORTEXM_THREADS_cpsie

From #5 , it would be better to export these 2 functions as disable_threads/enable_threads

is the repo alive?

Good day,

I'm looking for a lightweight thread or async solution for our plc rtos project, your seems to work pretty fine.

It misses a couple of things, e.g. support of more CPUs. It would be also nice to let it have own mutex / rwlock with specified cycle delays between locking attempts. And of course, docs + cargo crate.

If you're going to support it, I'll send pull requests. Or it's better to just do a fork?

Optional feature to integrate https://crates.io/crates/spin

Related to #5 :
Add feature 'spinlocks' which adds https://crates.io/crates/spin crate, and re-export any symbols which should be useful with this crate

Test spin::Mutex and investigate reported freeze.