QP Real-Time Embedded Frameworks & Tools / News: Recent posts

QP-bundle 6.6.0 brings simplified, one-stop download and installation of all QP frameworks, QM modelign tool and QTools in a single package.

QP/C and QP/C++ 5.6.1 provide the first production release of the new component of the QP framework called QXK ("eXtended Quantum Kernel"). QXK is a small, preemptive, priority-based, blocking kernel that provides most features you might expect of a traditional blocking RTOS.

QXK has been designed specifically for applications that need to mix event-driven active objects with traditional blocking code, such as commercial middleware (TCP/IP stacks, UDP stacks, embedded file systems, etc.) or legacy software. The QXK kernel is integrated tightly and optimally with the rest of the QP. It reuses all mechanisms already provided in QP, thus avoiding any code duplication, inefficient layers of indirection, and additional licensing costs, which are inevitable when using 3rd-party RTOS kernels to run QP applications.... read more

The QP/C 5.6.0-beta release introduces a new component of the QP/C framework called QXK ("eXtended Quantum Kernel"). QXK is a small, preemptive, priority-based, blocking kernel that provides most features you might expect of a traditional blocking RTOS kernel.

QXK has been designed specifically for applications that need to mix event-driven active objects with traditional blocking code, such as commercial middleware (TCP/IP stacks, UDP stacks, embedded file systems, etc.) or legacy software. The QXK kernel is integrated tightly and optimally with the rest of the QP. It reuses all mechanisms already provided in QP, thus avoiding any code duplication, inefficient layers of indirection, and additional licensing costs, which are inevitable when using 3rd-party RTOS kernels to run QP/C applications.... read more

The main purpose of the QP/C 5.5.2-beta release is to provide a new version of the QK ports to ARM Cortex-M, which do not use the SVC_Handler (Supervisor Call). This is done to make the QK ports compatible with various "hypervisors" (such as mbed uVisor or Nordic SoftDevice), which use the SVC exception. This release contains the updated QK ports to ARM Cortex-M for all supported compilers: ARM-Keil, GNU-ARM, IAR EWARM, and TI-CCS-ARM.... read more

The new version of "responsive" QL website went online yesterday. Please take a look (perhaps with your phone).

http://www.state-machine.com/

QP/C and QP/C++ 5.5.0 extend the QS software tracing system to bi-directional communication with embedded Targets. Specifically, the QS-RX (receive channel for QS) has been added with the following capabilities:

1.Set global QS filters inside the Target
2.Set local QS filters inside the Target
3.Inject an arbitrary event to the Target (direct post or publish)
4.Execute a user-defined callback function inside the Target with arguments supplied from QSPY
5.Peek data inside the Target and send to QSPY
6.Poke data (supplied from QSPY) into the Target
7.Execute clock tick inside the Target
8.Request target information (version, all sizes of objects, build time-stamp)
9.Remotely reset of the Target... read more

The QP open source frameworks win the the Embedded Computing Design's 2015 Top Embedded Products Award in the Software category.

You can see the full list of nominees in the June issue of Embedded Computing Design magazine.

The main focus of the 5.4.2 release is to improve the support for dual targeting of QP applications, which is developing of deeply embedded code as much as possible on the desktop OS, such as Windows. Experience shows that "dual targeting" dramatically improves productivity of embedded systems developers, perhaps more than any other technique.

This release makes it possible to use exactly the same application code, main function, and the Board Support Package interface (bsp.h) on both deeply embedded target and on Windows. The only differences between these targets can be completely encapsulated in the Board Support Package implementation (bsp.c / bsp.cpp).... read more

The QP-nano 5.4.0 release changes the basic philosophy of packaging and distributing the QP-nano framework by combining the "QP-nano Baseline Code" with all currently available "QP-nano Development Kits" (QDK-nano). This is done to eliminate any potential mistakes in downloading and installing separate pieces of code.

This release also changes the active object class hierarchy so that QMActive is now more fundamental and is the base class for QActive. (Previously QMActive was a subclass of QActive). The newly added documentation section about QP-nano Design shows the current class hierarchy.... read more

QP/C++ version 5.4.1 changes the active object class hierarchy so that QMActive is now more fundamental and is the base class for QActive. (Previously QMActive was a subclass of QActive). The newly added documentation section about QP/C++ Design shows the current class hierarchy.

---

NOTE: Because the types QMActive and QActive are equivalent in QP/C++, this change has minimal impact on the applications, but it is now more correct to use QMActive as the base class for all "opaque" active object pointers.
***... read more

The QM 3.3.0 release updates the internal models of the QP frameworks to match the recent QP 5.4.x. Specific changes include:

Updated class hierarchy such that QMActive is the superclass of QActive.
The QFsm class and state machine implementation strategy is now deprecated. Any existing models that use QFsm will still load correctly, but the code generated witll be in QHsm-style.
Implemented the following feature requests:... read more

The QP/C++ 5.4.0 release changes the basic philosophy of distributing the QP frameworks by combining the "QP/C++ Baseline Code" with all currently available "QP/C++ Development Kits" (QDK/C++). This is done to eliminate any potential mistakes in downloading and installing separate pieces of code.

Additionally, this release changes the basic philosophy of building your embedded applications with the QP/C++ framework. Starting with this release, all examples for embedded boards include the QP/C++ framework as source code within the projects, instead of statically linking with a QP/C++ library. (NOTE: It is still possible to use QP/C++ as a library, but you need to build such libraries yourself, as they are no longer provided in the QP/C++ distribution.)... read more

The QP/C 5.4.1 release changes the active object class hierarchy so that QMActive is now more fundamental and is the base class for QActive. (Previously QMActive was a subclass of QActive). The newly added documentation section about QP/C Design shows the current class hierarchy.

NOTE: Because the types QMActive and QActive are equivalent in QP/C,
this change has minimal impact on the applications, but it is now more
correct to use QMActive as the base class for all "opaque" active object
pointers.... read more

The new QP/C 5.4.0 brings several new ports, tons of new examples, and is easier to use than ever.

The release changes the basic philosophy of distributing the QP frameworks by combining the "QP/C Baseline Code" with all currently available "QP/C Development Kits" (QDK/C). This is done to eliminate any potential mistakes in downloading and intallating separate pieces of code.

Additionally, this release changes the basic philosophy of building your embedded applications with the QP/C framework. Starting with this release, all examples for embedded boards include the QP/C framework as source code within the projects, instead of statically linking with a QP/C library. (NOTE: It is still possible to use QP/C as a library, but you need to build such libraries yourself, as they are no longer provided in the QP/C distribution.)... read more

In Lesson 15 you initialize the custom vector table. You also develop fault-handler code and test it. Finally, you add all interrupt handlers and learn how to alias them such that you can override only the ones that you actually use.

In the next lesson, you will start learning about interrupts.

---

YouTube playlist of the course:
http://www.youtube.com/playlist?list=PLPW8O6W-1chwyTzI3BHwBLbGQoPFxPAPM... read more

The objective of this lesson is to replace the default vector table from the IAR library with your own.

To achieve this, you first need to understand the embedded software build process. You will look inside the object files (ELF format) to see what "relocatable code" really means. You will also see how the linker resolves the cross-module references and how the rules are different for objects included directly and object libraries.... read more

New version 3.2.1 of the QM modeling and automatic code generation tool has just been released and is available for download from:

https://sourceforge.net/projects/qpc/files/QM/3.2.1/

This release implements the feature request #100 "Conditional compilation for state machine elements" (see https://sourceforge.net/p/qpc/feature-requests/100/ ) The feature description and usage are available in the QM Help at the following URL:... read more

The QP Development Kits (QDKs) for the FreeRTOS real-time kernel have been just released. The QP-FreeRTOS integration has been designed to use the FreeRTOS hardware abstraction layer, but this port does not eliminate all dependencies on the CPU architecture. Specifically, this port has been designed for the ARM Cortex-M cores (ARM Cortex-M0/M3/M4F) and might need some changes to
work with other CPU architectures. The source code of the QP-FreeRTOS ports (for QP/C and QP/C++) should compile cleanly with all compilers for ARM Cortex-M, not just with IAR EWAR used here.... read more

The QP-Arduino integration has been completely re-done to match the new Arduino-1.5.7. Among others, the TCL build script and the code upload utility, both callable from QM, have been adapted for the new Arduino-1.5.7 code structure and requirements (such as the use of CYGWIN dynamic libraries.)

The new QP Development Kit (QDK) for the latest QP/C++ 5.3.0 and Arduino-1.5.x has been posted for download here:... read more

The QP/C framework has been ported to ERIKA Enterprise OSEK/VDX RTOS.
ERIKA is an open-source OSEK/VDX kernel started in year 2000 mainly used in automotive.

ERIKA Enterprise in its architecture is very similar to the single stack QK kernel implementation. The concepts of the FP (Fixed Priority) conformance class implementation in OSEK/VDX are really the same (run to completion, no blocking, single stack, ...). Also, ERIKA is an OSEK/VDX kernel, which makes it interesting for the Automotive Market. It has in fact been chosen by a few Tier 1, including Magneti Marelli for Powertrain controls.... read more

The QM version 3.2.0 switches from using Qt4 to the latest Qt5 toolkit. Also,
the the Qt5 toolkit is now used under the terms of the LGPL 2.1 license.
For compliance with LGPL 2.1, the QM distributions contain the LGPL
Compliance Package, which provides information how to obtain, install,
and build the Qt toolkit from sources.

In response to user requests and to ease downloading of QP and QM software, all latest Windows .EXE files available for download from

https://sourceforge.net/projects/qpc/files

have been digitally signed by Quantum Leaps, LLC.

The newly signed files are:

qm_3.1.3-win32.exe
qpc_5.3.0.exe
qpcpp_5.3.0.exe
qpn_5.3.0.exe
qtools_win32_5.3.1.exe

If you are concerned about security, the digitally signed Windows .EXEs are the recommended format to dowload. The equivalent .ZIP files are not signed, so there is no guarantee that they have not been tampered with. ... read more

New QP Development Kits for the embOS RTOS have been created. Please see: http://www.state-machine.com/embos

NOTE: Even though the QDKs use the specific embOS demo (embOS for ARM Cortex-M with IAR), the QDKs have been designed generically to rely exclusively on the embOS API. In other words, the QDKs should not require any changed to run on any CPU/Compiler supported by embOS.

Mr. Wanqiang Xia has contributed a QP active object framework implementation in JavaScript (jsqf). This is a complete framework, with the hierarchical event processor (QEP) and the event-driven framework (QF). This means that you can build systems of QP-like active objects in JavaScript!

This QP/JavaScript implementation is licensed under the very permissive 2-clause BSD open source license. The code is hosted on GitHub at the following URL:... read more

Mr. Wanqiang Xia has contributed a QP active object framework implementation in Java (jqf). This is a complete framework, with the hierarchical event processor (QEP) and the event-driven framework (QF). This means that you can build systems of QP-like active objects in Java!

This QP/Java implementation is licensed under the very permissive 2-clause BSD open source license. The code is hosted on GitHub at the following URL:... read more