|Written in||QP/C in C, QP/C++ in C++|
|OS family||Framework / RTOS|
|Source model||Open source|
|Marketing target||Embedded systems|
|License||GPL and Commercial (Dual licensing)|
QP ("Quantum Platform") is a family of open source real-time embedded frameworks (RTEFs) and runtime environments based on active objects (actors) and hierarchical state machines (UML statecharts). The QP family consists of the lightweight QP/C and QP/C++ frameworks, written in C (C99) and C++ (C++11), respectively.
Active Objects (Actors) For Real-Time
The QP RTEFs are an implementation of the Active Object (Actor) model of computation, specifically tailored for real-time embedded (RTE) systems.
Active Objects (Actors) can be combined with a wide variety of threading models, including real-time kernels (RTOS kernels). In the latter case, the combination, carefully designed for deterministic performance, is called the Real-Time Embedded Framework (RTEF).
The Active Object architecture inherently supports and automatically enforces the best practices of concurrent programming. This results in applications that are safer, more responsive, and easier to manage than the "naked" threads and the myriad of blocking mechanisms of a traditional Real-Time Operating System (RTOS). The QP frameworks also provide a higher level of abstraction and the right abstractions to effectively apply graphical modeling and code generation to deeply embedded systems.
Framework, NOT a Library
The main difference between an RTOS and a (real-time) framework is that when you use a "naked" RTOS, you write the main body of each and every thread in the application and from there, you call the various RTOS services (e.g., a time-delay or a semaphore).
When you use a framework, you reuse the overall architecture (such as the event loop for all private threads of Active Objects) and you only write the code that the RTEF calls. This leads to inversion of control, which allows the RTEF to automatically enforce the best practices of concurrent programming. In contrast, a “naked” RTOS lets you do anything and offers no help or automation for the best practices.
Hierarchical State Machines
The behavior of active objects (actors) 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 fully automatic code generation by means of the free graphical QM modeling tool.
The QP frameworks and the QM modeling tool are used in medical devices, defense & aerospace, robotics, consumer electronics, wired and wireless telecommunication, industrial automation, transportation, and many more.
QP architecture and components
QP consists of a universal UML-compliant event processor (QEP), a portable, event-driven, real-time framework (QF), a selection of built-in real-time kernels (QV, QK, or QXK), and software tracing system (QS).
QEP (QP Event Processor) is a universal UML-compliant event processor that enables direct coding of UML state machines (UML statecharts) in highly maintainable C or C++, in which every state machine element is mapped to code precisely, unambiguously, and exactly once (traceability). QEP fully supports hierarchical state nesting, which enables reusing behavior across many states instead of repeating the same actions and transitions over and over again.
QXK (Dual-Mode Kernel) is a tiny preemptive blocking kernel designed for hybrid applicatinons consisting of active objects and traditional blocking threads.
QS (QP/Spy) is a software tracing system that enables live monitoring of event-driven QP applications with minimal target system resources and without stopping or significantly slowing down the code.
Standalone (Bare-Metal) Operation
The QP RTEFs can run standalone, completely replacing the 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 unique preemptive, dual-mode (blocking/non-blocking) QXK kernel. Standalone QP ports and ready-to-use examples are provided for ARM Cortex-Mas well as other CPUs.
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 (such as Segger Microcontroller Systems#embOS, ThreadX, FreeRTOS, uC/OS-II, etc.)
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.
General Purpose OS Integration
The QP ports to the general purpose operating systems are interesting in their own right. For example, the QP port to POSIX supports real-time extensions and works with embedded Linux, and POSIX subsystems of such RTOSes as: QNX, INTEGRITY, VxWorks, etc. Similarly, QP port to Windows can work with Windows IoT or Windows Embedded Compact.
But the OS support can be also interesting for developing of deeply embedded code on the desktop workstations, which is called "dual-targeting".
QP framework are dual-licensed under the open source GPLv3 and a selection of traditional, closed-source licenses. Users who wish to distribute QP (e.g. embedded inside devices) can retain the proprietary status of their code by applying for a commercial license.
- Miro Samek (2008). Practical UML Statecharts in C/C++, Second Edition: Event-Driven Programming for Embedded Systems (PDF). Newnes. ISBN 978-0-7506-8706-5.
- Herb Sutter (June 14, 2010). "Prefer Using Active Objects Instead of Naked Threads" (PDF).
- Sutter, Herb. "Use Threads Correctly = Isolation + Asynchronous Messages". Dr. Dobb's. Retrieved 2022-09-27.
- "freeware graphical QM modeling tool".
- "Dual Targeting and Agile Prototyping of Embedded Software".
- QP frameworks on GitHub
- QP frameworks on SourceForge
- qf4net: Quantum Framework for .Net
- qfj: Quantum Framework for Java on SourceForge.net
- Miros: a hierarchical state machine module in Python
- Miros: a hierarchical state machine module in Lua
- State-Oriented Programming (Groovy)
- ACCU Overload Journal #64 "Yet Another Hierarchical State Machine"
- C/C++ Users Journal "Who Moved My State?"
- C/C++ Users Journal "Deja Vu"
- Research on Open CNC System Based on Quantum Framework
- Active Objects by Schmidt