QP-bundle release 6.6.0

Quantum Leaps — Fri, 15 Nov 2019 18:07:33 -0000

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 frameworks surpass FreeRTOS in the number of weekly downloads

Quantum Leaps — Sun, 13 Nov 2016 22:58:22 -0000

The QP actor frameworks and QM modeling tool for embedded systems have been downloaded more times during the week November 6-12 than the popular FreeRTOS kernel. The following screen shot shows the popularity ranking in the "RTOS" category on SourceForge.net (the main download site for FreeRTOS).

QP 5.6.1 adds new preemptive, blocking RTOS kernel called QXK

Quantum Leaps — Sat, 02 Jan 2016 15:53:00 -0000

The QP/C and QP/C++ 5.6.1 releases introduce 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 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 applications.

Please refer to the online QXK documentation for more details.

QP/C 5.6.0-beta adds new preemptive, blocking RTOS kernel

Quantum Leaps — Thu, 24 Dec 2015 20:00:29 -0000

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.

Please refer to the online QXK documentation for more details.

QP/C version 5.5.2-beta frees up the SVC exception in the ARM Cortex-M QK ports

Quantum Leaps — Thu, 12 Nov 2015 16:44:04 -0000

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.

NOTE: This beta release is for testing the new QK port to ARM Cortex-M and is not recommended for stable products.

Additionally, the AVR ports and examples are removed from this release. The 8-bit AVR will not be officially supported, because it cannot be programmed in Standard ANSI-C, but rather requires C language extensions, such as the extended keyword __flash in IAR EWAVR, or PROGMEM in GNU-AVR. These extensions (currently implemented as Q_ROM and Q_ROM_BYTE, macros) represent really a contamination of the QP code and will be removed in the future releases.

New responsive QL website

Quantum Leaps — Tue, 03 Nov 2015 16:16:41 -0000

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

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

QP/Qtools 5.5.0 bring bi-directional Q-SPY

Quantum Leaps — Tue, 29 Sep 2015 15:07:49 -0000

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

QP version 5.5.0 complements the recent release of Qtools 5.5.0, where the QSPY host application (http://www.state-machine.com/qspy ) has been extended with a UDP socket, which is open for communication with various Front-Ends (GUI-based or headless). An example Front-End written in Tcl/Tk called "QSpyView" has been developed to demonstrate all the features. The example application located in the directory qpcpp-cm-tm4c123gxl contains customization of the "qspyview" script for the DPP application. Please refer to the documentation of this example (http://www.state-machine.com/qpcpp/arm-cm_dpp_ek-tm4c123gxl.html ) for more information.

QP named the Top Innovative Product of 2015

Quantum Leaps — Mon, 10 Aug 2015 17:29:38 -0000

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.

QP/C, QP/C++ and QP-nano 5.4.2 released discussion

Tension — Wed, 01 Jul 2015 13:27:41 -0000

Got faster and faster.

QP/C, QP/C++ and QP-nano 5.4.2 released

Quantum Leaps — Sun, 07 Jun 2015 17:48:40 -0000

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

The support for "dual targeting" in this QP release works both for Win32 console and Win32 GUI applications. The Win32-GUI support enables developers to easily emulate the front-panels of the embedded devices, with LCD-screens (graphical and segmented), LEDs, buttons, switches, sliders, etc.

Changes in detail:

Modified the QP ports to Windows so that they support both Win32 console and Win32-GUI applications. The newly introduced pre-processor WIN32_GUI macro is now required to use the Win32-GUI facilities.
Added portable "safe" macros from <stdio.h> and <string.h> to the QP ports to Windows. These macros encapsulate the differences between Microsoft Visual C++ and other compilers (such as MinGW).
Simplified the structure of the QP Windows ports by eliminating one level of directories for the compilers used. Both VC++ and MinGW builds can now be run in the same port directory.
Modified the QF_stop() function in the QP ports to Win32-QV, so that it unblocks the QV event-loop and thus lets the application terminate.
Modified all examples for Windows to use the new port structure.
Improved all Makefiles (for the MinGW toolset) in all Windows examples, to make them easier to adapt to custom applications, both Win32 console and Win32 GUI.
Moved several examples from the examples/win32/ and examples/win32-qv/ directories to examples/arm-cm/ directory with native embedded examples for ARM Cortex-M. This co-location of the Win32 emulation with the embedded code running on the actual board demonstrates better the "dual targeting" development approach.
Updated all Windows examples to the latest QP API by compiling the code with the macro QP_API_VERSION set to 9999 (latest API without backwards compatibility)

Recent posts to news