Skip to content

Super-Simple Tasker (SST) is a preemptive, priority-based RTOS kernel fully compatible with the requirements of Rate Monotonic Analysis/Scheduling (RMA/RMS). This repository contains the modern version of SST (version 2).

License

QuantumLeaps/Super-Simple-Tasker

main
Switch branches/tags

Name already in use

A tag already exists with the provided branch name. Many Git commands accept both tag and branch names, so creating this branch may cause unexpected behavior. Are you sure you want to create this branch?
Code

Latest commit

2.0.2

2.0.2

Improved BSPs, added EK-TM4C123GXL

2.0.2
d54613a

Git stats

Files

Permalink
Failed to load latest commit information.
Type
Name
Latest commit message
Commit time
Jan 30, 2023
img
Jan 30, 2023
Jan 30, 2023
Jan 24, 2023
Jan 30, 2023
Jan 30, 2023
Jan 30, 2023
Jan 30, 2023
Jan 30, 2023
Jan 24, 2023
Jan 30, 2023

Brought to you by:

Quantum Leaps


GitHub release (latest by date) GitHub

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 prioriy level
  • multiple "activations" per task (event queues)

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:

Additionally, this repository contains the even simpler, non-preemptive implementation of basic tasks called SST0:

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

Hardware RTOS for ARM Cortex-M

SST for ARM Cortex-M provides a unique hardware implementation of SST 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.

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: ARM Cortex-M (M0-M7), MSP430, PIC24/dsPIC, PIC32, etc. Examples include: QP Real-Time Embedded Frameworks

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 higest-priority basic task ready to run, but the scheduling is performed only after every the completion of the 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 prioriy 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_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
|
+---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 examples are built for the following embedded boards:

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

About

Super-Simple Tasker (SST) is a preemptive, priority-based RTOS kernel fully compatible with the requirements of Rate Monotonic Analysis/Scheduling (RMA/RMS). This repository contains the modern version of SST (version 2).

Topics

Resources

License

Stars

Watchers

Forks

Packages

No packages published