Products Overview

Our products form a comprehensive suite of modern embedded software and host-based tools wrapped around the QP™ Real-Time Embedded Frameworks (RTEFs) — the unique reactive 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.

Quantum Leaps Products

QP™ Real-Time Embedded Frameworks

QP™ (Quantum Platform) is a family of lightweight Real-Time Embedded Frameworks (RTEFs) for building reactive embedded software as systems of asynchronous event-driven active objects (actors). The QP™ family consists of QP/C and QP/C++ 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 QP™ frameworks support manual coding of UML state machines in C or C++ as well as Model-Based Design (MBD) and automatic code generation by means of the free QM™ Model-Based Design tool.

The QP™ RTEFs can run on bare-metal single-chip microcontrollers, completely replacing a traditional RTOS. The frameworks contain a selection of built-in real-time kernels (RTOS kernels), such as the cooperative QV kernel, the preemptive non-blocking QK kernel, and the unique preemptive, dual-mode (blocking/non-blocking) QXK kernel. Native QP ports and ready-to-use examples are provided for ARM Cortex-M (M0/M0+/M3/M4F/M7) as well as other CPUs.

The QP™ RTEFs can also work with many traditional RTOSes and desktop OSes (such as Linux and Windows).

With over 30,000 downloads a year from SourceForge alone and even greater number of downloads from GitHub, the QP™ RTEF 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, such as ARM Cortex-M-based microcontrollers.

QP™ Real-Time Embedded Frameworks Feature Comparison

You can hover the mouse pointer over the highlighted items to see additional information related to the feature.
Feature QP/C QP/C++
Most Recent Version (Revision History) /
Latest Release Date
Intended target systems /
(Representative hardware)
32-bit/16-bit MCUs
(ARM Cortex-M)
32-bit/16-bit MCUs
(ARM Cortex-M)
Programming language C (C90) C++ (C++11)
Code (ROM) / Data (RAM) footprint 4KB / 1KB 5KB / 1KB
Supported by the free QM™ Model-Based Design tool
Active Objects
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 0..15 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
Cooperative kernel (QV)
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, etc.)
Available port to Windows
QP/Spy™ software tracing
QUTest™ Unit Testing Harness
Source Code Quality
MISRA compliance MISRA-C:2004 MISRA-C++:2008
PC-Lint/FlexeLint support package
Open Source Licensing (GPL)
Closed Source (Commercial) Licensing

QM™ Model-Based Design Tool

QM™ (QP Modeler) is a freeware Model-Based Design (MBD) and automatic code generation tool for software based on the QP™ Real-Time Embedded Frameworks and hierarchical state machines (UML statecharts). QM™ is available for Windows, Linux and MacOS.

  The QM™ modeling tool is offered under a simple click-through EULA license.
QM screen shot

QTools™ Collection

QTools™ is a collection of various open source host-based tools for working with the QP frameworks, such as: QP/Spy™ software tracing and testing system, QWin™ GUI toolkit 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 (rm, touch, etc.)

  Most tools included in the QTools collection are distributed under the terms of the GNU General Public License (GPL) as published by the Free Software Foundation, either version 2 of the License, or (at your option) any later version.

The Python package is distributed under the terms of the PYTHON LICENSE AGREEMENT, included in the file PYTHON_LICENSE.txt in the qtools/open-source subdirectory.

QSPY QP/Spy™ Tracing and Testing System

QP/Spy™ is a software tracing and testing system built into the QP/C and QP/C++ Real-Time Embedded Frameworks. QP/Spy consists of the code instrumentation inside QP/C and QP/C++ and the console application called QSPY (available for Windows, Linux and MacOS hosts). The job of QP/Spy 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). QP/Spy can also send commands to the Target for unit testing (QUTest™) and monitoring (QView™).

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).

QSPY QUTest™ Unit Testing Harness

QUTest™ (pronounced cutest) is a powerful Unit Testing Harness, which is specifically designed for deeply embedded systems, but also supports unit testing of embedded code on host computers ("dual targeting"). QUTest™ is the fundamental tooling for Test-Driven Development (TDD) of QP/C/C++ applications, which is a highly recommended best-practice.

QUTest™ separates the execution of the CUT (Code Under Test) from checking of the test expectations. The embedded target is concerned only with running a test fixture that exercises the CUT and produces QP/Spy™ trace, but it does not check the "test assertions". Generating test inputs and checking the "test assertions" against the expectations is performed on the host computer by means of test scripts, which are written in Python.

QView QView™ Visualization & Monitoring

QView™ is a powerful visualization and monitoring facility, which allows embedded developers to rapidly create virtual Graphical User Interfaces to monitor and control their embedded devices from a host (desktop) computer. The interfaces created by QView™ can visualize the tracing data produced by QP/Spy™ and can also send various commands to the embedded target.


Dual Targeting

Dual Targeting is a powerful technique for avoiding the "target system bottleneck" in embedded software development. Dual targeting simply means that from day one, your embedded code (typically in C or C++) is designed to run on at least two platforms: the final target hardware and your development workstation. All you really need for this is two C compilers: one for the development computer and another for the embedded device. The dual targeting strategy does require a specific way of designing the embedded software such that any target hardware dependencies are handled through a well-defined interface. The QP RTEFs support Dual Targeting by providing ready-to-use ports that run on the desktop platforms, such as Windows and POSIX (Linux, MacOS).

QWIN QWin™ GUI Toolkit

QWin™ is a simple GUI 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.

Legacy QDKs

Legacy QP Development Kits (QDKs)

QP Development Kits (QDKs) are separate QP ports and examples for various embedded processors, toolsets, and boards.

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 denotes the QP framework type, whereas qdkc stands for QDK for QP/C, qdkcpp for QP/C++, and qdkn 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.
  NOTE: 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:

  1. Download the QDK that you like and check its <version> number.
  2. Download and install (unzip) the corresponding QP <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.
  3. Unzip the QDK to a temporary directory.
  4. 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, inside C:/qp/qpcpp/). Note that you will need to give your consent to overwrite the already existing directories examples/ and ports/.

QDK Documentation

Every "legacy QDK" contains the "QDK Manual" in PDF in the main directory of the ZIP archive.