FuSa RTS (Cortex-M0) [FSRTS-CM0]
Arm FuSa RTS for Cortex-M0/M0+
ARM - FuSa RTS (Cortex-M0) [FSRTS-CM0]
Arm FuSa RTS is a set of embedded software components qualified for use in the most safety-critical applications in automotive, medical and industrial systems.
FuSa RTS components, safety-qualified Arm C/C++ compiler and Arm Keil MDK tools are natively integrated together and significantly simplify system design, development, validation and certification processes for safety applications.
Supported safety standards
Arm FuSa RTS is certified for the following safety standards:
- Automotive: ISO26262, ASIL D
- Industrial: IEC61508, SIL 3
- Railway: EN50128, SIL 4
- Medical: IEC62304, Class C
FuSa RTS safety compliance is confirmed by the TÜV Süd Certificate.
FuSa RTS fully utilizes advanced hardware features that Arm specifies for its processors. It provides support for devices with the following Arm Cortex-M cores:
FuSa RTS Components
Arm FuSa RTS package contains components as outlined by the red dotted line on the figure below:
- FuSa RTX RTOS: deterministic real-time operating system
- FuSa Event Recorder: functionality to easily record events and collect execution statistics.
- FuSa CMSIS-Core: vendor-independent software interface to the processor resources.
- FuSa C library: a subset of the C library functions verified for safety-critical applications.
- Safety Package: documentation set explaining the usage of FuSa RTS in safety context.
FuSa RTX RTOS
FuSa RTX is a deterministic real-time operating system (RTOS) that reliably manages multiple application threads with priority-based, pre-emptive scheduling.
RTX RTOS offers all services needed in complex real-time applications, such as threads, timers, memory and object management, message exchange and others.
The RTX kernel is highly optimized for Cortex-M architecture and has multiple provisions that naturally improve the reliability of an embedded application.
Strictly validated code
- MISRA C rules: RTX is written in C using C99 language extensions with MISRA C:2012 guidelines being applied to it.
- Safety compliance: FuSa RTX code has gone through stringent safety analysis and rigorous testing. It is approved for use in applications with the most demanding safety integrity levels (SIL). See FuSa RTS for the list of applicable safety standards.
Designed for engineering efficiency
- Small memory footprint: requires minimum amount of system memory, starting from 5 KB ROM
- Low-power mode: has tick-less operation mode for low power devices.
Easy to configure and use
- CMSIS-pack support: FuSa RTX is provided as a CMSIS component and can be easily managed in a µVision Run-Time Environment dialog.
- Configuration Wizard support: FuSa RTX provides a number of configuration parameters for the kernel operation as well as for the RTX objects such as threads, mutex and semaphores. Integrated support of MDK Configuration Wizard makes the parameter settings clear and intuitive.
- Time-deterministic interrupt execution: RTX utilizes the LDEX/STEX instruction available on most Cortex-M processors and therefore user interrupts are never disabled.
- Separate stacks for ISR/RTOS and threads: the RTOS kernel executes in handler mode with stack separated from user threads which avoids unexpected stack loads.
- Stack overflow checking: RTX implements a software stack overflow checking that traps stack overruns.
Runtime check of kernel objects: object identifiers are validated at run-time for type-mismatches and are protected from inadvertently accesses by the user application.
Flexible memory management
- Object-specific memory pools: dedicated fixed-size memory blocks for each object type avoids memory fragmentation during run-time and makes object creation and destruction time deterministic.
- Static object memory allocation: the user application may rely on static memory for kernel objects, which guarantees that the RTOS system can never run out of storage during run-time.
- Event Recorder support: all important internal FuSa RTX events can be logged and analyzed using MDK Event Recorder and System Analyzer. Alternatively 3rd party tools such as Percepio's Tracelyzer can be used as well.
- Stack Usage Watermark: special provisions in FuSa RTS allow MDK debugger to determine during run-time the current and the maximum stack usage for each thread.
- Object Memory Usage Counters: built-in mechanism that helps to analyze the maximum memory usage for each RTX object type.
|MCU architecture (FuSa)||Cortex-M0/M0+|
|Product Type (FuSa)||Embedded software|
|ARM Product Type||New License|
|License Type||Node Locked|
|ARM License Type||Node Locked|