This release is concerned with the ARM Cortex ports and examples. Specifically, this release contains the following improvements:
1. Unified source code for ARM Cortex-M3 and the new ARM Cortex-M0 cores, including the code for the preemptive QK kernel.
2. Compliance with the Cortex Microcontroller Software Interface Standard (CMSIS) in all ARM Cortex examples.
3. Backward-compatible support for the new LM3S811 EVAL Rev C board with different OLED display than previous revisions. (NOTE: The OSRAM 96x16x1 OLED used in REV A-B boards has been replaced RITEK 96x16x1 OLED used in Rev C.)
In the process of making the examples CMSIS-compliant, the dependency on the Luminary Micro driver library (driverlib.a) has been completely removed.
Additionally, the screen saver of the "Fly 'n' Shoot" game has been improved to periodically switch off the power of the OLED display, which better protects the display from burn-in. The affected file is tunnel.c.
Finally, this release introduces the QP_VERSION macro, which identifies the QP version. Otherwise, this maintenance release does not change the QP/C API in any way, so the release has NO IMPACT on the QP/C applications except for the ARM Cortex ports and applications.
The purpose of this minor maintenance release is the change in the directory structure for the ARM Cortex ports and examples. As new ARM Cortex cores are becoming available, the old port name "cortex-m3" could be misleading, because it actually applies to wider range of ARM Cortex cores. Consequently, all ARM Cortex ports and examples are hosted in the directory tree called "arm-cortex".
This maintenance release does not change the QP-nano API in any way, so the release has NO IMPACT on the QP-nano applications except for the ARM Cortex ports and applications.
The main purpose of this release is to replace the Turbo C++ 1.01 toolset with the Open Watcom C/C++ toolset, because Turbo C++ 1.01 is no longer available for a free download. In contrast, Open Watcom is distributed under an OSI-certified open source license, which permits free commercial and non-commercial use. Open Watcom can be downloaded from www.openwatcom.org.
All 80x86 examples (vanilla and QK-nano) for Turbo C++ 1.01 have been replaced with examples for Open Watcom. The make.bat scripts are provided to build the examples.
In the process of converting the examples to Open Watcom a new SLS example have been added to the standard QP-nano distribution. The SLS example located in <qpn>\* shows the QP-nano implemenation of the new State-Local Storage state design pattern.
The main purpose of this release is to fix a bug in event posting, which could cause corruption of the event signal. Such corruption could occur when an event was posted to an empty event queue, in which case it was written directly to the internal event stored in the state machine, bypassing the ring-buffer. However, the signal of the internal event could also be changed by the QEP-nano event processor during execution of transitions.
The bug fix is to always pass events through the ring buffer and never overwrite the internal event during event posting (both from the task level and from the ISR level). The update of the ring buffer always occurs within a critical section and is safe from interruptions.
This bug fix also allows posting of events from the top-most initial transitions of active objects during the initialization phase. Previously, the execution of the top-most initial transition corrupted the signal of the internal event.
The bug fix enables also self-posting of events from entry/exit actions and internal initial transitions. Again, the QEP event processor corrupted the internal signal.
This release also replaces the static variables 'p' (priority) and 'a' (active object pointer) with automatic variables. This change results in more efficient code, because the frequently used variables can be kept in registers and do not need to be read/written from/to memory by each use.
Additionally, this release updates the QP-nano ARM Cortex-M3 examples for the EK-LM3S811 board to the latest IAR EWARM 5.40. Due to the acquisition of Liminary Micro by Texas Instruments the directory IAR structure for the examples and drivers has changed and the QP-nano examples had to be changed accordingly.
Finally, this release fixes a bug in the "Fly 'n' Shoot" game example for QP-nano, which caused an assertion if the Ship was moved to the very top of the Tunnel. This was due to the y-coordinate of the ship explosion becomoming negative.
NOTE: This release does not change the QP-nano API, but all event queues are effectively shortened by one event. Also it is no longer possible to declare an active object without a ring buffer (zero-sized queue), because the internal event no longer counts towards the queue depth.
The main changes in QP v4.1.00 with respect to the earlier versions are as follows:
The maintenance release provides a fix for the compile-time assertions, which did not work correctly for the GNU compiler family. Also, the ARM Cortex-M3 examples have been recompiled with the newer IAR EWARM v5.30.
This maintenance release does not change the QP-nano API in any way, so the release has NO IMPACT on the QP-nano applications.
The main changes in QP v4.0.04 with respect to earlier version are as follows:
Release date: August 06, 2008
The main purpose of this release is to "future-proof" the QK-nano preemptive kernel. The release 4.0.03 strictly preserves the semantics of QK_currPrio_ variable, which was violated by the previous QK mutex implementation. The mutex locking now uses a different variable QK_ceilingPrio_, which represents the ceiling-priority locked by the mutex. When the mutex is configured (the macro QK_MUTEX is defined), the QK-nano scheduler performs an additional check to make sure that only tasks with priorities above the ceiling can run. This additional overhead is not present when QK_MUTEX is not defined.
This maintenance release does not change the QP-nano API in any way, so the release has NO IMPACT on the QP-nano applications.
The main changes in QP v4.0.03 with respect to earlier version are as follows:
This maintenace release is made to allow posting events from any active object to any active object from the top-most initial transtions.
This maintenance release does not change the QP-nano API in any way, so the release has NO IMPACT on the QP-nano applications.
The main changes in QP v4.0.02 with respect to earlier version are as follows:
This maintenace release is made to allow compiling QP-nano with the GNU compiler for AVR (WinAVR). Specifically, some changes were necessary to accomodate the non-standard way of hanlding constant data objects allocated in ROM (PROGMEM) in the GNU compiler for AVR.
This maintenance release does not change the QP-nano API in any way, so the release has NO IMPACT on the QP-nano applications.
The main changes in QP v4.0.01 with respect to earlier version are as follows:
Release date: Apr 07, 2008
This milestone release is made for the book Practical UML Statecharts in C/C++, Second Edition. The book describes in great detail this new release. The older "QP-nano Programmer's Manual" is now phased out and is replaced with this hyper-lirenked QP-nano Reference Manual, which provides very detailed, easily searchable reference to the software. The book Practical UML Statecharts in C/C++, Second Edition provies in-depth discussion of the relevant concepts as well as the design study of QP v4.0, including QP-nano v4.0 in Chapter 12.
The main changes in QP v4.0 with respect to earlier versions are as follows:
XXX_onYYY():XXX_onYYY():Release date: Sep 25, 2007
This product release adds the backward-compatibility layer so that previous QP-nano ports continue to work with the new version.
This product release also comes with the updated "QP-nano Programmer's Manual" that now includes the QK-nano preemptive kernel.
Release date: Sep 03, 2007
This release brings several changes with the overall goal of simplifying and improving consistency across the whole QP family of frameworks (QP/C, QP/C++, and QP-nano).
This release includes simplifying of the C naming conventions (see the updated Application Note "QL C/C++ Coding Standard"). The double-underscore suffix for private data members of structures is no longer used. Single underscore is used still only for internal QP-nano facilities that typically should not be used by the application programmer.
The main changes are made to the QEP-nano component. The new functions QFsm_init() and QHsm_init() have been added for FSMs and HSMs, respectively. These APIs are for initializing a state machine by triggering the top-most initial transition. The application programmer now needs to provide the top-most initial *pseudostate* that defines the initial transition, just like it is done in QP/C and QP/C++.
NOTE: the previous QP-nano technique of providing the whole top-most initial state handler will still work, but it takes more code and is not recommended in the future designs.
The other big change in this release is including the QK-nano component in the distribution. Previously, the QK-nano component was available only under the commercial licensing. It is now open source, just as the rest of QP-nano.
Release date: Mar 08, 2007
The only change in this release is removing the 'const' declaration of a temporary variable inside QHsm_dispatch() function. This was necessary to compile the code with the MPLAB C18 compiler for PIC18 devices.
The changes in release 1.5.07 have NO impact on the existing QP-nano ports.
Release date: Jan 28, 2007
The main change in this release is adding the macro Q_REENTRANT for all functions that might be called from various threads of control (when the preemptive QK-nano is used). The macro Q_REENTRANT is used in the postfix syntax, which is how the Keil C51 compiler uses the extended keyword "reentrant" to indicate reentrant functions.
The changes in release 1.5.06 have NO impact on the existing QP-nano ports, because the empty default definition for the Q_REENTRANT macro provided in "qeph.h" should be adequate for all these ports.
Release date: Dec 13, 2006
The main change in this release is adding the macro Q_ROM_VAR for all constant objects allocated in ROM. The Q_ROM_VAR macro has been added for the compilers like Freescale HC(S)08, which require far pointers to access the objects in ROM. Please note that specifying the pointer size for accessing a ROM objects is syntactically different than specifying that the object is allocated in ROM (see macro Q_ROM).
The changes in release 1.5.05 have NO impact on the existing QP-nano ports, because the empty default definition for the Q_ROM_VAR macro should be adequate for all these ports.
Release date: Dec 11, 2006
The main change in this release is removing "#include <stdint.h>" from the qepn.h header file. This has been done becasue vast majority of embedded compilers for small MCUs actually do not provide the C-99 Standard header file <stdint.h>. Worse, compilers such as Freescale HC(S)08 C/C++ compiler will not include <stdint.h> unless it's in the compilers's include directory, even though the stdint.h file might be in the compiler include path.
Removing the "#include <stdint.h>" from qep.h header file allows more flexibility in the way the standard exact-width integer types are defined. For compilers that do not provide the <stdint.h> file, you provide the typedef's in the qpn_port.h file before including qepn.h. For compilers that do provide the <stdint.h> header file, you simply include this file in the qpn_port.h header file before including qepn.h.
The changes in release 1.5.04 have impact on all QP-nano ports, because you need to modify the qpn_port.h file in all these ports.
Release date: Nov 12, 2006
This release adapts the QP-nano code to the shortcomings of the gcc compiler for handling data in program ROM for Harvard architecture CPUs, such as the Atmel's AVR or the 8051. In such machines, the data space (RAM) and program space (ROM) are accessed with different instructions. The gcc compiler does not automatically synthesize the correct code for accessing data placed in the program ROM, even though the __attribute__((__progmem__)) is used. The workaround for the gcc is to add special assembly instructions to transfer the data from the program space to the data space. This version of QP-nano adds macros for each data element allocated to the program space (delcared with the Q_ROM attribute).
Please note that commercial compilers, such as IAR, handle data allocated in the program space (ROM) correctly and do not need any workarounds.
Release date: Nov 04, 2006
This release corrects the initial transition processing in the QK-nano configuration. Also, a new interrupt locking policy inside interrups is introduced (inside the QF_postISR() function). This locking policy corresponds to "saving and restoring interrupt status", which is useful to unlock interrupts only to a certain level, but keep the interrupts locked below that level.
Release date: Oct 16, 2006
This release makes no changes to the core QP-nano code, but corrects nested interrupt handling in the 80x86 example of PELICAN crossing with QK-nano. Additionally, alternative interrupt handling without allowing the interrupt nesting is demonstrated.
Release date: Sep 17, 2006
This release changes the licensing of QP-nano. The QEP-nano and QF-nano components are released under the dual-license (GPL and commercial). The QK-nano component is left as commercial only.
To enable the separate use of QEP-nano, QF-nano, and QK-nano, the header file qpn.h has been split into three files qepn.h, qfn.h, and qkn.h.
Release date: Aug 20, 2006
This release addresses the potential initialization problem, when active objects want to post events to each other or to self during the top-most initial transition.
The initialization sequence now requires only calling the QActive_ctor() constructor, but you no longer need to explicitly call QHsm_init() (or QFsm_init() for the non-hierarchical state machine) to trigger the top-most initial transition. The top-most initial transition is now executed automatically by the framework.
removed unlocking interrupts before invoking the QF_onIdle() callback. This was done to prevent a race condition in determining the idle condition. The idle condition (no events in any event queues) can be changed at any time by an interrupt. If interrupts were unlocked before calling QF_onIdle(), and interrupt could post an event to a queue, but the QF_onIdle() would put the CPU to low-power mode, thus preventing the processing of the event until the next interrupt.
The modification changes the semantics and responsibilities of QF_onIdle(), which now MUST at least unlock interrupts. A failure to unlock interrupts in QF_onIdle() will leave the interrupts locked all the time and would prevent the application from running.
Release date: Jul 27, 2006
Release date: May 31, 2006
Release date: May 20, 2006
Release date: May 15, 2006
1.6.2