Repository files navigation

Super-Simple Tasker (SST) is an event-driven, preemptive, priority-basedreal-time operating system (RTOS) kernel that is fully compatible withthe requirements ofRate Monotonic Analysis/Scheduling (RMA/RMS).

The tasks in SST are non-blocking and run-to-completion, which are also knownasbasic tasks in theOSEK/VDX Operating System Specification. SST corresponds to the BCC2 conformance class in OSEK/VDX.SST provides the following features:

• basic tasks (non-blocking, run-to-completion)
• preemptive, priority-based scheduling
• multiple tasks per priority level
• multiple "activations" per task (event queues)
• selective scheduler locking according to "Stack Resource Policy" (SRP)
  (a non-blocking mutual exclusion mechanism for protecting shared resources)

NOTE
The execution profile of SST tasks perfectly matches the non-blocking andrun-to-completion semantics of event-driven state machines(a.k.a."Active Objects" or "Actors).

This repository contains the SST following implementations:

• preemptive SST in C
• preemptive SST in C++

Additionally, this repository contains the even simpler,non-preemptiveimplementation of basic tasks calledSST0:

• non-preemptive SST0 in C
• non-preemptive SST0 in C++

NOTE
The preemptive SST and non-preemptive SST0 implement actuallythe sameSST API(either in C or C++).

The SST RTOS kernel is related to, althoughnot based on, the followingapproaches:

• Operating System - OSEK VDX
• A Stack-Based Resource Allocation Policy for Realtime Processes
• Real-Time For the Masses
• crect: A C++, compile-time, reactive RTOS
• Rust's Real Time For the Masses (RTFM)
• Real-Time Interrupt-driven Concurrency (RTIC)

SST for ARM Cortex-M provides a uniquehardware implementation of the SST API for ARM Cortex-M (M0, M0+, M3,M4, M7, M23, M33). The SST "hardware RTOS" for ARM Cortex-M is fullycompatible with the requirements ofRate Monotonic Analysis/Scheduling (RMA/RMS).

NOTE
The SST hardware implementation is likely the most performant and efficienthard-real time RTOS kernel for ARM Cortex-M.

The contributedSST port for dsPIC provides a uniquehardware implementation of the SST API forMicrochip dsPIC.The SST "hardware RTOS" for dsPIC is fully compatible with the requirements ofRate Monotonic Analysis/Scheduling (RMA/RMS).

SST has been presented at the Embedded Online Conference 2023 and the videosare available on YouTube:

SST has been originally published as a cover-story article"Build a Super-Simple Tasker" in theEmbedded Systems Design magazine inJuly 2006.That original version of SST (now called "Legacy SST") isstill available and is provided for historical reference.

Over the years, more complete SST-like kernels have been developedfor a number of embedded processors, such as: ARM7TDMI, ARM Cortex-M (M0-M7),ARM Cortex-R, MSP430, PIC24/dsPIC, PIC32, etc. All these kernels are nowincluded in theQP/C and QP/C++ Real-Time Embedded Frameworks:

• QK preemptive, priority-based, non-blocking kernelworks like SST and is available as one of the built-in kernels in theQP Real-Time Embedded Frameworks (RTEFs).

• QXK preemptive, dual-mode kernelcombines the basic-tasks of SST with traditional blocking tasks (a.k.a.extended tasks in OSEK/VDX) and is available as one of thebuilt-in kernels in theQP Real-Time Embedded Frameworks (RTEFs)

• QV priority-based, cooperative kernelworks likeSST0 and is available as one of the built-inkernels in theQP Real-Time Embedded Frameworks (RTEFs)

This repository contains also the non-preemptive implementation of theSST API, calledSST0. SST0 is also apriority-based RTOS kernel,but the scheduling is non-preemptive. SST0 scheduler always executes thehighest-priority basic task ready to run, but the scheduling is performedonly after voluntary completion of each task (run-to-completion execution).

SST0 provides the following features:

• basic tasks (non-blocking, run-to-completion)
• priority-based, non-preemptive (cooperative) scheduling
• only one task per priority level
• multiple "activations" per task (event queues)

The best way to get started with SST is to build and run the providedexamples. This repository contains several versions of the"blinky-button" example, which contains several SST tasks runningconcurrently and communicating with each other. The "blinky-button" exampledemonstratesreal-time capabilities of SST and uses a logic analyzer.(REMARK: Logic analyzer is not necessary to build and run the examples.)

The "blinky-button" example is provided for:

Super-Simple-Tasker/|+---sst_c/// preemptive SST/C|+----examples/// examples for SST/C|   |+----blinky_button/// "blinky-button" example|   |    |+----armclang/// project for ARM/KEIL|   |    |+----gnu/// makefile for GNU-ARM|   |    |+----iar/// project for IAR EWARM|+---sst_cpp/// preemptive SST/C++|+----examples/// examples for SST/C++|   |+----blinky_button/// "blinky-button" example|   |    |+----armclang/// project for ARM/KEIL|   |    |+----gnu/// makefile for GNU-ARM|   |    |+----iar/// project for IAR EWARM|+---sst0_c/// non-preemptive SST0/C|+----examples/// examples for SST0/C|   |+----blinky_button/// "blinky-button" example|   |    |+----armclang/// project for ARM/KEIL|   |    |+----gnu/// makefile for GNU-ARM|   |    |+----iar/// project for IAR EWARM|+---sst0_cpp/// non-preemptive SST0/C++|+----examples/// examples for SST0/C++|   |+----blinky_button/// "blinky-button" example|   |    |+----armclang/// project for ARM/KEIL|   |    |+----gnu/// makefile for GNU-ARM|   |    |+----iar/// project for IAR EWARM|

Forevery of these cases the projects to build the examples are providedfor the following embedded boards:

• STM32 NUCLEO-C031C6 (ARM Cortex-M0+)
• STM32 NUCLEO-L053R8 (ARM Cortex-M0+)
• STM32 NUCLEO-H743ZI (ARM Cortex-M7 with double-precision FPU)
• TivaC LaunchPad (EK-TM4C123GXL) (ARM Cortex-M4 with single-precision FPU)

The SST source code and examples are released under the terms of thepermissiveMIT open source license. Please note that theattribution clause in the MIT license requires you to preserve theoriginal copyright notice in all changes and derivate works.

This project welcomes collaboration! Please help to improve SST,port it to other processors, integrate it with other embedded software,add interesting examples, etc. To avoid fragmentation, this repository isintended to remain the home of SST. To contribute, please clone, fork,and submitpull requests to incorporate your changes.

If you like this project, pleasespread the word about SST on variousforums, social media, and other venues frequented by embedded folks!

Also, please givethis repositorya star (in the upper-right corner of your browser window)