Our products form a comprehensive suite of embedded software and tools wrapped around the QP™ active object frameworks — the unique asynchronous event-driven platform designed to provide the architectural reuse and enforcement of the best practices of concurrent programming, which leads to safer code with high conceptual integrity and dramatic improvement of software quality.
QP™ (Quantum Platform) is a family of lightweight software frameworks for building responsive and modular real-time embedded applications as systems of asynchronous event-driven active objects (actors). The QP family consists of QP/C, QP/C++, and QP-nano frameworks, which are all strictly quality controlled, thoroughly documented, and available in full source code.
The behavior of active objects is specified in QP by means of hierarchical state machines (UML statecharts). The frameworks support manual coding of UML state machines in C or C++ as well as automatic code generation by means of the free QM modeling tool.
All QP™ frameworks can run on bare-metal single-chip microcontrollers, completely replacing a traditional RTOS. The frameworks contain a selection of built-in real-time kernels, such as the cooperative QV kernel, the preemptive non-blocking QK kernel, and the preemptive, blocking QXK kernel that provides all the features you might expect from a traditional RTOS kernel. Native QP ports and ready-to-use examples are provided for major CPU families.
With almost 60,000 downloads a year, the QP™ framework family is the most popular such solution on the embedded software market. It provides a modern, reusable architecture of embedded applications, which combines the active-object model of concurrency with hierarchical state machines. This architecture is generally safer, more responsive and easier to understand than shared-state concurrency of a conventional Real-Time Operating System (RTOS). It also provides higher level of abstraction and the right abstractions to effectively apply modeling and code generation to deeply embedded systems.
|Most Recent Version (Download) / |
Release Date (Revision History)
|Intended target systems / |
|32-bit/16-bit MCUs |
|32-bit/16-bit MCUs |
|8-bit/16-bit MCUs |
|Programming language||C (C89)||C++ (C++98)||C (C89)|
|Code (ROM) / Data (RAM) footprint||4KB / 1KB||5KB / 1KB||2KB / 0.5KB|
|Supported by the free QM modeling tool|
|Maximum number of active objects||64||64||8|
|Dynamic events with arbitrary parameters||0..4 bytes|
|Automatic event recycling||not needed|
|Direct event posting (FIFO)|
|Direct event posting (LIFO)|
|Publish-Subscribe event delivery|
|Number of system clock tick rates||0..N||0..N||0..4|
|Number of time events per active object||Unlimited||Unlimited||1 per tick rate|
|Hierarchical State Machines (QHsm-strategy)|
|Hierarchical State Machines (QMsm-strategy)|
|Sub-machines and sub-machine states|
|Cooperative kernel (QV)|
|Preemptive non-blocking kernel (QK)|
|Preemptive blocking dual-mode kernel (QXK)|
|Portable to 3rd-party RTOS kernels|
|Available port to POSIX (Linux, etc.)|
|Available port to Windows|
|QS (Quantum Spy) software tracing|
|QSPY host application and QSpyView extension|
|Source Code Quality|
|PC-Lint/FlexeLint support package|
QM (QP Modeler) is a freeware, graphical modeling tool for designing and implementing real-time embedded applications based on the QP frameworks and hierarchical state machines (UML statecharts). QM is available for Windows, Linux, and macOS.
The QTools™ Collection contains various open source host-based tools for working with the QP frameworks, such as: QSPY software tracing system, QWIN GUI for prototyping embedded systems on Windows,
qclean for cleanup of source code files,
qfsgen for generating ROM-based file systems for embedded web servers, etc. The Qtools Collection for Windows provides also the MinGW C/C++ compiler (GNU GCC) and GNU
make for Windows, as well as the related file utilities (
QSPY is the software tracing system built into the QP/C and QP/C++ active object frameworks. QSPY consists of a console application (available for Windows and Linux hosts) and the code instrumentation inside QP/C and QP/C++. The job of QSPY is to receive the trace data produced by an instrumented QP/C or QP/C++ application running on an embedded Target, visualize the data, and optionally to save the data in various formats (such as MATLAB or MscGen). QSPY can also send commands to the Target for testing and control (bi-directional QSPY).
The QSPY host application is easily adaptable to various target-host communication links. Out of the box, the QSPY host application supports serial (RS232), TCP/IP, and file communication links. Adding other communication links is straightforward, because the data link is accessed only through a generic Platform Abstraction Layer (PAL).
QWIN GUI is a simple, free software toolkit for prototyping (dual-targeting) embedded systems on Windows in the C programming language. QWIN allows you to build realistic embedded front panels consisting of LCD displays (both graphical and segmented), buttons, and LEDs. QWIN is based on the raw Win32 API to provide direct mapping to C for easy integration with embedded code.
QP Development Kits (QDKs) are separate QP ports and examples for various embedded processors, toolsets, and boards.
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 .
All "legacy QDKs" are distributed in ZIP archives named according to the following general convention:
qdkxxxdenotes the QP framework type, whereas
qdkcstands for QDK for QP/C,
qdkcppfor QP/C++, and
<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 boars, such as SKP3607, YRDKRX62N, etc.
<version>denotes the compatible version of the QP framework.
<version>of the QP framework. A QDK might work with the newer QP version as well, but might require some modifications.
The installation procedure for most "legacy QDKs" is as follows:
<version>. For example, if your QDK file starts with
qdkcpp_and ends with
_4.5.02, you should download and install QP/C++ version 4.5.02.
qdkcpp_avr-iar_4.5.02, you should copy the content of this directory inside the QP/C++ installation folder (typically, inside
C:/qp/qpcpp/). Note that you will need to give your consent to overwrite the already existing directories
Every "legacy QDK" contains the "QDK Manual" in PDF in the main directory of the ZIP archive.
If you are interested in the latest QP code, even before it is officially released, the complete QP source code trees, including all ports and examples, are available in SourceForge Git repositories as well as on GitHub. The Application Note Accessing QP Git Repositories on SourceForge describes how to access the QP source code via Git repositories on SourceForge.
|SourceForge Git Repo||GitHub Repo|