• Stars
    star
    111
  • Rank 314,510 (Top 7 %)
  • Language
    C
  • License
    MIT License
  • Created about 4 years ago
  • Updated over 1 year ago

Reviews

There are no reviews yet. Be the first to send feedback to the community and the maintainers!

Repository Details

Event-driven, preemptive, priority-based, hardware RTOS for ARM Cortex-M.

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)
  • selective scheduler locking according to "Stack Resource Policy" (SRP)
    (a non-blocking mutual exclusion mechansim 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:

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++).

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

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:

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

More Repositories

1

qpc

QP/C Real-Time Embedded Framework/RTOS for embedded systems based on active objects (actors) and hierarchical state machines
C
788
star
2

modern-embedded-programming-course

Companion repository to the "Modern Embedded Systems Programming" video course.
C
358
star
3

qpcpp

QP/C++ Real-Time Embedded Framework/RTOS for embedded systems based on active objects (actors) and hierarchical state machines
C++
316
star
4

OOP-in-C

Simple and efficient implementation of OOP in C suitable for real-time embedded systems.
C
159
star
5

qpn

QP-nano real-time embedded framework/RTOS for embedded systems based on active objects (actors) and hierarchical state machines
C
148
star
6

qtools

QTools collection of open source tools for embedded systems development on Windows, Linux and MacOS
C
113
star
7

qm

QM model-based design tool and code generator based on UML state machines
Shell
107
star
8

MiROS

MiROS (Minimal Real-Time Operating System) for ARM Cortex-M
C
65
star
9

FreeAct

FreeAct is a minimal Active Object (Actor) framework for FreeRTOS
C
65
star
10

lock-free-ring-buffer

"Lock-Free Ring Buffer" (LFRB) is a minimal, customizable implementation of a ring buffer (a.k.a. circular buffer) in C, specifically suitable for embedded systems.
C
60
star
11

qp-arduino

QP real-time embedded frameworks/RTOS for Arduino (AVR and SAM)
C++
41
star
12

State-Oriented-Programming

State-Oriented Programming: was a cover story article about Hierarchical State Machines in C and C++ published originally in "Embedded Systems Programming" magazine in August 2000. This repository contains the article PDF and the updated code.
C
25
star
13

embedded-coding-style

Embedded C and C++ Coding Style
CSS
14
star
14

Embedded-Test

Embedded Test (ET) -- The Super-Simple Embedded Test
C
8
star
15

DBC-for-embedded-C

Design By Contract (DBC) for embedded C and C++
C
4
star
16

qpc-zephyr-app

Example project and starting point for creating QP/C-Zephyr applications.
C
4
star
17

contributed

Software contributed to the QP framework ecosystem
3
star
18

qpcpp-zephyr-app

Example project and starting point for creating QP/C++-Zephyr applications.
C++
3
star
19

3rd_party

3rd-party code used in the QP/C and QP/C++ examples
C
2
star
20

cmsis-packs

CMSIS packs released by Quantum Leaps
2
star
21

spexygen

Traceable specifications based on Doxygen
CSS
2
star
22

ql-doxygen

Doxygen customization based on doxygen-awesome-css
CSS
2
star
23

spexygen1

Traceable specifications based on Doxygen.
CSS
2
star
24

ET

ET (Embedded Test) -- The Super-Simple Embedded Test
C
1
star
25

.github

Quantum Leaps' profile
1
star