File Structure

The Flexible Safety RTOS is a standalone software module that does not rely on external projects or libraries. For your evaluation, we compile the component in advance and offer a comprehensive library with all services enabled.

Note

The RTOS is compiled as part of your application and is integrated in your application image.

Supported Microcontrollers

The Flexible Safety RTOS depends on the microcontroller CPU core, and the cross-compiler environment. Therefore, packaging for this RTOS is a compination of one microcontroller CPU core (e.g. Cortex-M7) with one cross-compiler environment (e.g. STM32CubeIDE using the GCC compiler).

The following combinations are prepared and ready for your Flexible Safety RTOS evaluation today:

CPU core	MKD-ARM (`arm`)	GCC (`gcc`)	IAR EWARM (`iar`)
Cortex-M3 (`cm3`)	yes	yes	yes
Cortex-M4 (`cm4`)	yes	yes	yes
Cortex-M7, 8 MPU regions (`cm7`)	yes	yes	yes
Cortex-M7, 16 MPU regions (`cm7h`)	yes	yes	yes

Evaluation Package

The evaluation package includes all required files for building applications with a preconfigured and precompiled Flexible Safety RTOS library.

+- fs-rtos                        : Flexible Safety RTOS evaluation package
|  +- include/<core>-<env>        : interface header files for core and environment
|  |  +- ucos_ii.h                : main interface header for RTOS kernel
|  |  +- sp_type.h                : space protection data types
|  |  +- sp_trace.h               : trace interface for space protection
|  |  +- sp_private.h             : internal types and definitions
|  |  +- sp_osapi.h               : interface to kernel API
|  |  +- sp_mon_cfg.h             : configuration for monitoring
|  |  +- sp_mon.h                 : monitoring types and definitions
|  |  +- sp_intrinsics.h          : environment specific low-level functions
|  |  +- sp_env.h                 : environment abstraction
|  |  +- sp_cpu.h                 : space protection CPU adaption
|  |  +- sp_core.h                : space protection API functions
|  |  +- sp_cfg.h                 : configuration of space protection
|  |  +- os_trace.h               : trace interface for RTOS kernel
|  |  +- os_private.h             : internal types and definitions
|  |  +- os_cpu.h                 : RTOS kernel CPU adaption
|  |  +- os_cfg.h                 : configuration of RTOS kernel
|  |  +- app_cfg.h                : application configuration (unused)
|  +- lib                         : configured and precompiled libraries

Warning

You can’t change the configuration, because the Flexible Safety RTOS use compile time configurations. Therefore, use the configuration files as a reference only, and do not change them!

Licensed Package

If you purchase a commercial license, you will receive the complete source code. This allows you to change all configuration settings and fine-tune the Flexible Safety RTOS for your project needs. You can also step through the RTOS itself to see and understand how the internals work.

There are multiple commercial license options available. Please tell us your microcontroller CPU core and cross-compiler environment combination via the official Embedded Office website:

Contact Form

The Embedded Office sales team will provide you more details and best matching offers.

Basic Usage

The basic use begins with the integration of the interface header files of the RTOS in your source file:

#include "ucos_ii.h"     /* RTOS Kernel API Functions */
#include "sp_core.h"     /* Space Protection API Functions */
#include "sp_osapi.h"    /* API Functions for Unprivileged Tasks */

Now we can initialize and start the RTOS during the startup phase of your application. This is done typically in the entry function: main()

void main(void)
{
    /* setup your board support package */
    :
    OSInit();         /* Initialize RTOS */
    :        
    /* here we need to create at least one task */
    /* and assign this task to a process space  */
    :
    OSStart();        /* Start Multitasking */
}

Tip

Look further to the examples in section Demo Applications for details in how to organize the memory and running tasks in the Flexible Safety RTOS.