Brought to you by:

---

Super-Simple Tasker (SST)

Super-Simple Tasker (SST) is an event-driven, preemptive, priority-based real-time operating system (RTOS) kernel that is fully compatible with the requirements of Rate Monotonic Analysis/Scheduling (RMA/RMS).

The tasks in SST are non-blocking and run-to-completion, which are also known as basic tasks in the OSEK/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 and run-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-preemptive implementation of basic tasks called SST0:

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

NOTE
The preemptive SST and non-preemptive SST0 implement actually the same SST API (either in C or C++).

Related Approaches

The SST RTOS kernel is related to, although not based on, the following approaches:

• 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)

Hardware RTOS for ARM Cortex-M

SST for ARM Cortex-M provides a unique hardware 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 fully compatible with the requirements of Rate Monotonic Analysis/Scheduling (RMA/RMS).

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

Hardware RTOS for Microchip dsPIC

The contributed SST port for dsPIC provides a unique hardware implementation of the SST API for Microchip dsPIC. The SST "hardware RTOS" for dsPIC is fully compatible with the requirements of Rate Monotonic Analysis/Scheduling (RMA/RMS).

SST Videos

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

SST History

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

Over the years, more complete SST-like kernels have been developed for 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 now included in the QP/C and QP/C++ Real-Time Embedded Frameworks:

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

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

• QV priority-based, cooperative kernel works like SST0 and is available as one of the built-in kernels in the QP Real-Time Embedded Frameworks (RTEFs)

Non-Preemptive SST0

This repository contains also the non-preemptive implementation of the SST API, called SST0. SST0 is also a priority-based RTOS kernel, but the scheduling is non-preemptive. SST0 scheduler always executes the highest-priority basic task ready to run, but the scheduling is performed only 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)

Getting Started / Examples

The best way to get started with SST is to build and run the provided examples. This repository contains several versions of the "blinky-button" example, which contains several SST tasks running concurrently and communicating with each other. The "blinky-button" example demonstrates real-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
|

For every of these cases the projects to build the examples are provided for 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)

Licensing

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

Invitation to Collaborate

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 is intended to remain the home of SST. To contribute, please clone, fork, and submit pull requests to incorporate your changes.

How to Help this Project?

If you like this project, please spread the word about SST on various forums, social media, and other venues frequented by embedded folks!

Also, please give this repository a star (in the upper-right corner of your browser window)