
QP™ Real-Time Embedded Frameworks (RTEFs)
Real-Time Embedded Frameworks for MCUs

QP™ High-Level Structure and Components

QP™ Highlights
Lightweight
Hard Real-Time
Market Leadership
Support for Modern State Machines
Standalone (Bare-Metal) Operation
You do not need to use a traditional RTOS just to achieve preemptive multitasking with QP. The built-in, preemptive QK and QXK kernels, support preemptive priority-based multitasking that is fully compatible with Rate Monotonic Scheduling to achieve guaranteed, hard real-time performance. These preemptive kernels perfectly match the run-to-completion execution semantics of active objects, yet are simpler, faster, and more efficient than the traditional blocking RTOS kernels.
Example Evaluation Boards
Traditional RTOS Integration

The QP™ RTEFs can also work with many traditional third-party RTOSes. QP ports and ready-to-use examples are provided for several RTOSes:
- embOS
- FreeRTOS
- uC/OS-II
- ThreadX
- Zephyr
The most important reason why you might consider using a traditional RTOS kernel for executing event-driven QP™ applications is compatibility with the existing software. For example, many communication stacks (TCP/IP, USB, CAN, etc.) are designed for a traditional blocking kernel. In addition, a lot of legacy code requires blocking mechanisms, such as semaphores or time-delays. A traditional RTOS allows you to run the existing software components as regular “blocking” threads in parallel to the event-driven QP™ active objects.

QP™ Certification Packs
The QP™ real-time embedded frameworks are frequently used in safety-critical systems, such as medical, defense, transportation, and industrial applications. Software that controls safety-critical devices must go through stringent certification process according to various functional safety standards, such as: IEC 61508 for electrical systems, IEC 62304 for medical devices, FDA510(k) for medical devices (U.S.), DO-178B for airborne systems, etc. To manage the software certification process, the industry increasingly turns to formal methods, such as software modeling as the means to maintain and objectively prove traceability from requirements specification, through system design, to final implementation.
The QP™ frameworks based on the UML concepts of active objects and hierarchical state machines, directly support the modern modeling approach and automatic code generation. Additionally, the QP/Spy software tracing provides the ready-to-use infrastructure for unit testing, verification and validation.
To help companies in their certification process, the QP™/C and QP™/C++ online manuals contain Certification Packs that comprise the following documents:
Our open and freely available Cert Packs are a unique offering in a traditionally secretive and expensive market for functional-safety documentation. At Quantum Leaps we have a long standing tradition to disrupt such entrenched markets. We've done it with the open source QP real-time embedded frameworks, the freeware QM model-based design tool, and the open-source QTools collection. Now we are committed to do this again with the QP Cert Packs.
QP™/C and QP™/C++ Feature Comparison
Feature | QP/C | QP/C++ |
---|---|---|
Most Recent Version (Revision History) Latest Release Date | 7.2.1 2023-01-15 | 7.2.1 2023-01-15 |
Intended target systems (Representative hardware) | 32-bit/16-bit MCUs (ARM Cortex-M) | 32-bit/16-bit MCUs (ARM Cortex-M) |
Supported by the free QM™ Model-Based Design tool | ||
Maximum number of active objects | 64 | 64 |
Dynamic events with arbitrary parameters | ||
Automatic event recycling | ||
Direct event posting (FIFO) | ||
Direct event posting (LIFO) | ||
Publish-Subscribe event delivery | ||
Event deferral | ||
Number of system clock tick rates | configurable (0..15) | configurable (0..15) |
Number of time events per active object | Unlimited | Unlimited |
----------------------------------------------- State Machines ----------------------------------------------- | ||
Hierarchical State Machines (QHsm-strategy) | ||
Hierarchical State Machines (QMsm-strategy) | ||
Sub-machines and sub-machine states | ||
----------------------------------------------- Built-in Kernels ----------------------------------------------- | ||
Preemptive non-blocking kernel (QK) | ||
Preemptive blocking dual-mode kernel (QXK) | ||
----------------------------------------------- 3rd-Party RTOS/OS ----------------------------------------------- | ||
Portable to 3rd-party RTOS kernels | ||
Available port to POSIX (Linux, QNX, INTEGRITY, etc.) | ||
Available port to Windows | ||
----------------------------------------------- Testing/Profiling ----------------------------------------------- | ||
QP/Spy™ software tracing | ||
QUTest™ Unit Testing Harness | ||
MISRA compliance | MISRA-C:2012 | |
AUTOSAR-C++ compliance | AUTOSAR-C++14 | |
PC-Lint-Plus support package | ||
-----------------------------------------------Licensing ----------------------------------------------- | ||
Open Source Licensing (GPL) | ||
Closed Source (Commercial) Licensing |

Legacy QP™ Development Kits (QDKs)
Why "Legacy"?
Starting with QP release 5.4.0, all officially supported ports and examples are bundled into the QP downloads, as opposed to being distributed as separate QP Development Kits (QDKs). The QDKs released for earlier QP versions are called “legacy-QDKs” and are available for download from SourceForge.
The "legacy-QDKs" are not recommended for new projects. The "legacy-QDKs" do not come with commercial support from Quantum Leaps, although questions about "legacy-QDKs" are welcome on the Free QP Support Forum
How to Find QDK You Want?
All “legacy QDKs” are distributed in ZIP archives named according to the following general convention:
qdkxxx_<cpu/rtos>-<toolset>-<board>_<version>.zip
qdkxxx
denotes the QP framework type, whereasqdkc
stands for QDK for QP/C,qdkcpp
for QP/C++, andqdkn
for QP-nano<cpu>
denotes a QDK for standalone QP for the given embedded CPU type, such as AVR, M16C, R8C, etc.<rtos>
denotes a QDK for QP running on top of a given RTOS, such as eCos, VxWorks, etc.<toolset>
denotes a port to specific toolset, such a IAR, GNU, Renesas, etc.<board>
denotes that the examples are for the specified boards, such as SKP3607, YRDKRX62N, etc.<version>
denotes the compatible version of the QP framework.
All QDKs have been developed and tested with the specified <version>
of the QP framework. A QDK might work with the newer QP version as well, but might require some modifications.
QDK Installation
The installation procedure for most “legacy QDKs” is as follows:
- Download the QDK that you like and check its
<version>
number. - Download and install (unzip) the corresponding QP
<version>
. For example, if your QDK file starts withqdkcpp_
and ends with_4.5.02
, you should download and install QP/C++ version 4.5.02. - Unzip the QDK to a temporary directory.
- Copy the contents of the QDK directory to the QP installation directory. For example, if your QDK unzipped into directory
qdkcpp_avr-iar_4.5.02
, you should copy the content of this directory inside the QP/C++ installation folder (typically, insideC:/qp/qpcpp/
). Note that you will need to give your consent to overwrite the already existing directoriesexamples/
andports/
.
QDK Documentation
Every “legacy QDK” contains the “QDK Manual” in PDF in the main directory of the ZIP archive.