|
QP/C
|
QP/C Revision History =====================
The main purpose of this release is adding support for the ARM Cortex-M4F processors with the hardware Floating-Point Unit (FPU). The QP/C ports to Cortex-M4F take full advantage of the "lazy stacking" feature of the FPU registers, and by doing so offer the most efficient preemptive multitasking on this processor.
Changes in detail:
1. Added ports and examples for ARM Cortex-M4F with the EK-LM4F120XL board (Stellaris Launchpad).
2. Added the macro QF_LOG2(), which can be re-implemented in the QP ports, if the CPU supports special instructions, such as CLZ (count leading zeros in Cortex-M3/M4). If the macro is not defined in the QP port, the default implementation uses a lookup table.
3. Updated all ARM Cortex-M ports and examples to the latest IAR EWARM 6.50 and Sourcery CodeBench 2012.09-85.
4. Updated App Notes "QP and ARM Cortex-M with IAR" and "QP and ARM Cortex-M with GNU".
5. Updated the PC-Lint support files (include\lib-qpc.lnt, au-misra2.lnt) to the latest PC-Lint 9.00j.
6. Updated the Application Note: "QP/C MISRA-C:2004 Compliance Matrix".
7. Spell-checked the comments in all QP/C source files and removed several typos.
8. Removed the Qt ports and examples from the QP/C Baseline Code and moved them to the separate QDK/C-Qt.
This release changes the directory structure of QP ports to various operating systems, such as POSIX (Linux, BSD, etc.), Win32 (Windows), Qt, etc. The OS ports are moved from the ports\80x86\ directory one level up to ports\. Also, the OS examples are moved from the examples\80x86\ directory one level up to examples\.
The main purpose of this release is better, more comprehensive support for (rapid) prototyping of embedded QP applications on the desktop with the Win32 API and with Qt. Among others, this release adds a complete toolkit for creating realistic embedded front panels with pure Win32-GUI API and free Visual C++ Express and ResEdit. An extensive Application Note "QP and Win32" is included in this release.
This release simplifies the QP ports to desktop OSs, such as Windows (Win32), Linux, BSD, Mac OSX (POSIX) and combines 32-bit and 64-bit ports in one with conditional compilation.
This release also adds an option for using constructors for dynamically allocated events. When the configuration macro Q_EVT_CTOR is defined, the Q_NEW() macro becomes variadic and takes the arguments for the event constructor. This generally allows creating dynamic events "on-the-fly" without a temporary pointer to the event. This QP configuration is demonstrated only in the QP port to Qt, but can be used in any other port. NOTE: The event constructor feature is NOT backward-compatible with the existing applications.
This release also adds a new macro QF_MPOOL_EL, which is intended for allocating properly aligned storage for memory pools and event pools.
All QP ports included in this release use only a single QP library, rather than separate libraries for QEP, QF, QK, and QS.
Finally, this release adds QM models, created with the new QM 2.2.00 to most of the examples. The code generated by this new QM version complies with MISRA-C:2004 rules.
Changes in detail:
1. Modified QP port to Win32 and used the free Visual C++ Express 2010 with Platform SDK rather than Visual C++ Pro 2008. Renamed the port directory from vc2008\ to vc\. Provided a completely revised App Note "QP and Win32".
2. Eliminated QP port to Win32 with one thread (Win32-1T).
3. Consolidated all QP ports to POSIX OSs (Linux, Linux64, Mac_OSX) into a single port to POSIX and placed it in the directory posix\.
4. Renamed the port directory qt_1t\ to qt\.
5. Added event constructor to qevt.h (controlled by the configuration macro Q_EVT_CTOR).
6. Added new variadic version of the Q_NEW() macro in qf.h when Q_EVT_CTOR is defined.
7. Added macro QF_MPOOL_EL to qmpool.h. Modified all examples to demonstrate the use of this macro to allocate properly aligned storage for event pools.
8. Added new typedef 'enum_t' and modified signatures of functions taking event signals from QSignal to enum_t. This was done to significantly reduce the number of casts necessary when enumerated signals were passed to QP functions.
9. Modified all QP ports distributed in the QP/C baseline code to generate only a single QP library, rather than separate libraries for QEP, QF, QK, and QS. This includes all QP ports to the desktop (ports\80x86\ directory) and ARM Cortex-M ports (ports-cortex\ directory).
10. Modified all examples to link only one QP library.
11. Added QM models to most examples and used the automatically generated code from the models instead of the hand-written code.
12. Modified Qt ports to use the new "event constructors" and modified examples for Qt to demonstrate this feature.
13. Added .ui files to the Qt examples for generating UIs graphically with the Qt Designer tool. Revised and updated the App Note "QP and Qt".
14. Added new macro QS_USR_DICTIONARY() to QS for providing symbolic names for user-defined trace records
15. Added new macro QS_RESET() to QS for telling the QSPY application when the target resets. This allows QSPY to reset its internal state.
The main purpose of this minor release is providing improved MISRA-compliant state machine implementation. Specifically, a new macro Q_UNHANDLED() has been added for a situation when a guard condition evaluates to FALSE, but the state model does not prescribe the explicit [else] case for this guard. In this case, the state handler can return Q_UNHANDLED(), which will cause the QEP event processor to propagate the event to the superstate, which is what UML semantics prescribes.
NOTE: These change to the QEP event processor is completely backwards-compatible. All state handler functions coded the old way will continue to handle the guard conditions correctly and in accordance with the UML specification. The new Q_UNHANDLED() macro is necessary only for MISRA-compliant state handler coding, which will be applied in the upcoming release of the QM modeling and code generation tool.
Changes in detail:
1. Added macro Q_UNHANDLED() and return value Q_RET_UNHANDLED in qep.h.
2. Modified qhsm_dis.c to handle the Q_RET_UNHANDLED return value.
3. Updated the QP/C MISRA-C:2004 compliance matrix to include the new MISRA-compliant way of coding guard conditions.
4. Modified qs.h and qs_dummy.h to add new trace record type QS_QEP_UNHANDLED, which is generated when the state handler returns Q_RET_UNHANDLED.
5. Modified qs.h and qs_dummy.h to add the User record dictionary trace record and macro QS_USR_DICTIONARY().
NOTE: This new trace record requires the updated QSPY 4.5.01.
6. Corrected qfsm_dis.c, which did not generate QS trace records for entry and exit from non-hierarchical states.
7. Updated the IAR ARM compiler used in the ARM Cortex-M examples to the latest version IAR EWARM 6.40.
8. Modified the Qt port not to define the QPApp::onClockTick() slot function, but instead to allow defining this slot function in the BSP of the application.
The main pupose of this relase is to improve host-based development of QP applications, which is critical for Test-Driven Development (TDD). Among others, this release provides integration between QP and the popular Qt GUI framework, which allows developers to easily build host-based simulations of the embedded systems with the realistic user interfaces.
This realase also simplifies implementing transitions to history, which is a preparation to providing this feature in the QM modeling tool.
Changes in detail:
1. Renamed the event class from QEvent to QEvt to avoid a name conflict with the Qt framework. Also, for consistency, renamed the file qevent.h to qevt.h and the macro Q_EVENT_CAST() to Q_EVT_CAST().
NOTE: To minimize impact of this change on the existing QP ports and applications, the name QEvent is provided as well, but this can be suppressed by defining the configuration macro Q_NQEVENT in qep_port.h.
2. Changed the design of QF_tick() (file qf_tick.c) to better support calling this function from low-priority tasks (as opposed to interrupts and highest-priority tasks), which often happens when QP is executed on the desktop operating systems. In this design only QF_tick() can remove time events from the active linked list, so no unexpected changes to the list structure are eliminated.
3. Simplified the QTimeEvt class by removing the 'prev' link pointer, as the new design no longer needs a bi-directional list. These changes impact the files: qte_*.c.
4. Added return value to QF_run() to allow transfer of the exit status to the destop operating systems.
NOTE: This modification haves impact on most QP/C ports, because the QF_run() function must now return a int16_t value.
5. Eliminated the 'running' member of the QActive class, which has been used only in the QP ports to "big" OSes such as Linux or Windows.
6. Added member 'temp' to the QHsm and QFsm base classes to prevent clobbering the current state (the 'state' member) during transitons. This change allows keeping the current state unchanged during the entire transition chain, which in turn allows easy and generic access to the state information to store the state history in the exit actions from states. Additional bonus of this re-design is the opportunity of testing for stable state configuration in assertions added to the qhsm_*.c and qfsm_*.c files.
7. Added the QHsm_state() and QFsm_state() accessor macros.
8. Modified the "Transition to History" pattern implementation to use the simplified technique of obtaining the current state in the exit action from the superstate rather than all the exit actions from the substates. Modified the "State-Local Storage" (SLS) pattern as well, because it was using the transition to history constructs.
9. Re-designed the implementation of the QSPY host application, so that it can be convenienty included as part of the QP library. This allows direct QS tracing output to the screen for QP applications running on the desktop.
NOTE: This change is part of the Qtools release 4.5.00.
10. Modified the QP ports to Win32_1t (both the MinGW and VC2008) to output QS trace data directly to the stdout via the QSPY host-application interface. Modified the DPP examples for Win32_1T to demonstrate the direct QS output to the screen.
11. Added QP port to Qt_1t (Qt with one thread) and two example applications (DPP and PELICAN crossing).
12. Added GNU compiler option -pthread to QP ports for POSIX with P-threads, including QP ports and examples for Linux and Mac OS X.
The relase fixes a bug in Q-SPY software tracing, which caused the linking error: "QS_SIG_() not defined". This release also includes a few cosmetic changes, which the Microchip C18 compiler didn't like.
1. Moved QS_SIG_() definition from qep.h to qs.h 2. Changed (QEvent *)0 to (QEvent const *)0 in source files qeq_get.c, qeq_init.c, and qa_get_.c.
The main pupose of this relase is MISRA-C:2004 compliance, strong-type checking compliance, update of PC-Lint option files and tests, and general cleanup.
1. Moved the qp_port.h header file from the port directories to the qcp directory. Also, moved the inclusion of the QS (Spy) header files (qs_port.h/qs_dummy.h) from qep.h, qf.h, and qk.h headers to qp_port.h. These structural changes were made to reduce the number of preprocessor #if nesting levels below 8, which is the ANSI-C limit. This was done to comply with the MISRA-C rule 1.1 (all code shall conform to ANSI/ISO C).
NOTE: This modifications have impact on most QP/C ports, because the qp_port.h header file must be removed from the port.
2. Added the PC-Lint option files std.lnt and lib-qpc.lnt to the qcp/include/ directory.
3. Cleaned the whole QP/C code from lint comments. All PC-Lint options have been moved to PC-Lint option files.
4. Modified QP assertion macro Q_DEFINE_THIS_MODULE() to avoid using the # operator (MISRA rule 19.13). This macro now requires the argument enclosed in doble quotes "".
NOTE: This modification has impact on some QP/C ports.
4. Added typedefs for char_t, int_t, float32_t, and float64_t to event.h header file for compliance with MISRA-C:2004 rules 6.1 and 6.3.
5. Added macros Q_STATE_CAST() and Q_EVENT_CAST() to qep.h to encapsulate deviation from MISRA-C rule 11.4.
6. Added macro Q_UINT2PTR_CAST() to encapsulate casting unsigned integers to pointers, which deviates from MISRA-C rule 11.3. This macro has been added for *application-level* code.
7. Updated ARM Cortex-M examples with the latest CMSIS v3.0, which complies with more MISRA-C:2004 rules.
8. Added DPP examples for MISRA-C:2004 compliant applications (for IAR-ARM and GNU-ARM).
9. Added testing of PC-Lint option files against the MISRA-C Exemplar Suite.
10. Updated ARM-Cortex-M3 port with GNU to the latest Sourcery CodeBench 2011.09-60.
11. Added QP/C port to Win32-1t and examples (Windows with 1 thread). This port is useful for testing embedded QP/C applications on windows.
12. Added documentation to QP/C distribution in the directory qpc/doc/, with the following Application notes: "MISRA-C:2004 Compliance Matrix", "Quantum Leaps Coding Standard", "QP and ARM Cortex-M, and QP and Windows",
1. This release changes the names of critical section macros and introduces macros for unconditional interrupt disabling/enabling. This is done to simplify and speed up the built-in Vanilla and QK kernels, which no longer are dependent on the interrupt locking policy.
NOTE: The change in handling the critical section in the Vanilla and QK kernels can break QP ports, which use the "save and restore interrupt lock" policy, because all such ports must also define unconditional interrupt disabling and enabling.
2. This release changes the partitioning of the QK scheduler. Specifically, the QK scheduler is now divided between two functions QK_schedPrio_() and QK_sched_(), to calculate the highest-priority task ready to run and to perform scheduling, respectively. The function QK_schedPrio_() is useful to determine if scheduling is even necessary.
3. Updated all QP ports to comply with the new critical section names and policies.
4. Modified the ARM Cortex-M port qk_port.s to take advantage of the new structure of the QK scheduler.
5. Upgraded the examples for ARM Cortex with IAR EWARM to the latest IAR EWARM version 6.30.
6. Upgraded the examples for ARM Cortex with GNU (CodeSourcery) to the latest Sourcery CodeBench 2011.07-60.
The main pupose of this relase is to provide a bug fix for the QK port to ARM Cortex processors. The bug fix addresses a very rare and undocumented behavior of late-arrival of an interrupt while entering the PendSV exception. In this case the PENDSVSET bit in the NVIC-ICSR register is *not* cleared when finally PendSV is entered, so the PendSV exception is entered in a *different* state when it is entered via the late-arrival mechanism versus the normal activation of the exception through tail-chaining. The consequence of this undocumented and inconsistent hardware behavior, PendSV could be re-entered again before the SVCall exception cleans up the stack. The bug fix is implemented in the qk_port.s file and consists of clearing the PENDSVSET bit programmatically inside PendSV_Handler.
1. The main pupose of this relase is to repackage the default QP/C distribution to contain the single root directory qpc/ in the archive. That way, unziping the archive will produce only one directory (qpc/), which can be then changed by the user.
2. This release also changes the ARM Cortex QP ports with GNU. The suffix "_cs" has been added to all QP libraries generated by the Code Sourcery toolset (now Mentor Sourcery CodeBench). This is to distinguish libraries generated by different GNU-toolchains (such as CodeRed, Attolic, DevKit ARM, etc.)
1. Modified file qassert.h to add assertion macros Q_ASSERT_ID, Q_REQUIRE_ID, Q_ENSURE_ID, Q_INVARIANT_ID, and Q_ERROR_ID, which are better suited for unit testig, because they avoid the volatility of line numbers for indentifying assertions.
2. Added QP port and examples for Mac OS X on 80x86.
The goal of this milestone release is to extend the number of event pools (theoretically up to 255 pools) instead of just three event pools available up til now. Also, this release adds several improvements to the QS/QSPY software tracing, such as adding sender information to event posting so that sequence diagrams could be easily and automatically reconstructed from tracing data. Also, the tracing now supports 64-bit targets, such as embedded Linux 64-bit. Finally, this milestone release migrates the examples to use the environment variable QPC instead of relying on the relative path to the QP/C framework. This allows easier adaptation of the examples for real projects, which don't really belong to the examples directory.
The changes in detail are:
1. Changed the QEvent base struct (file qevent.h). The private member 'dynamic_' has been replaced by two members 'poolId_' and 'refCtr_'.
2. Added configuration macro QF_MAX_EPOOL (file qf.h) to define the maximum number of event pools in the QP application (default to 3). The maximum theoretical number of this macro is 255.
3. Made algorithmic changes in the QF source code related to the change of storing the event pool-IDs and reference counters inside QEvent.
4. Changed the default signal size (macro Q_SIGNAL_SIZE in the file qevent.h) from 1 to 2 bytes.
5. Changed the signature of QActive_recall() to return uint8_t instead of QEvent*, which this could encourage incorrect usage (processing of the event at the point of recalling it). Now, the function only returns 1 (TRUE) if the event was recalled and 0 (FALSE) if the event was not recalled.
6. Added the function QTimeEvt_ctr() and new source file qte_ctr.c. The function returns the counter of a time event, which allows using a time event for measuring the time.
7. Added new QF macros QF_TICK, QF_PUBLISH, and QACTIVE_POST in file qf.h to provide sender of the events for software tracing.
8. Added new QS macros (files qs.h and qs_dummy.h) for handling 64-bit integers.
9. Added the functions QS_u64() and QS_u64_() and new source file qs_u64.c.
10. Added the QS macro QS_U32_HEX_T for hexadecimal formatting of integer numbers in the user-defined trace records.
11. Added the new port linux64 for 64-bit Linux. Also added the corresponding examples for 64-bit Linux.
12. Adapted the QSPY host application for 64-bit pointer sizes and the changed layout of trace records that contain event information (such as PoolID and RefCtr). Also added the backwards-compatibility option (-v) for switching the tool to the previous data format.
13. Removed the tools directory from the QPC distribution and moved the QSPY host application to the QTOOLS distribution, which now also contains the GNU make tools for Windows.
14. Modified the make files and project files to use the environment variable QPC instead of relying on the relative path to the QP/C framework.
15. Upgraded the examples for ARM Cortex with IAR EWARM to the latest IAR EWARM 6.20.
The goal of this release is to improve the ease of experimenting with QP/C on the desktop. This release adds support for Windows (Win32) to the baseline code. Two most popular compilers for Windows are supported: Microsoft Visual Studio and MinGW (GNU). The support for Linux has been improved by including pre-built QP/C libraries and improving makefiles for Eclipse compatibility.
The changes in detail are:
1. Added Win32 port with the Visual C++ 2008 (ports/80x86/win32/vc2008). This directory contains the Visual Studio solution all_qp.sln for building all QP/C libraries from the IDE. Three build configurations (Debug, Release, and Spy) are supported.
2. Added Win32 port with the MinGW comiler (ports/80x86/win32/mingw). This directory contains the Makefile for building all QP/C libraries. Three build configurations (dbg, rel, and spy) are supported. NOTE: the Makefile assumes that the MinGW/bin directory is added to the PATH.
3. Added Win32 examples for Visual C++ 2008 (examples/80x86/win32/ vc2008/dpp and examples/80x86/win32/vc2008/qhsmtst). Visual Studio soultions are provides for all build configurations.
4. Added Win32 examples for MinGW (examples/80x86/win32/mingw/dpp and examples/80x86/win32/mingw/qhsmtst). Eclipse-compatible makefiles are provided for all build configurations. NOTE: the Makefiles assume that the MinGW/bin directory is added to the PATH.
5. Removed memory alignment correction in the file qmp_init.c. This correction required casting of pointers to integers and was problematic on 64-bit targets (such as 64-bit Linux).
6. Upgraded the examples for ARM Cortex with CodeSourcery to the latest Sourcery G++ 2011.02-2.
1. Made cosmetic improvements to the example QM models of the "Fly 'n' Shoot" game.
2. Made improvements in make.bat files for building the examples for DOS/Open Watcom to run better in DosBox on Linux.
3. Upgraded the examples for ARM Cortex with IAR to the latest IAR EWARM version 6.10.
4. Upgraded the examples for ARM Cortex with CodeSourcery to the latest Sourcery G++ 2010.09-66.
This release is adds examples for the QM (QP Modeler) graphical modeling and code generation tool. The examples are based on the "Fly 'n' Shoot" game described in the QP/C Tutorial and in Chapter 1 of the PSiCC2 book.
Specifically, the directory <qpc>/examples/80x86/dos/watcom/l/game-qm/ contains the "Fly 'n' Shoot" game model file "game.qm". This model, when opened in the QM tool contains all state machine diagrams and generates code into the subdirectory qm_code/. This code can then be built and executed on any 80x86 machine (newer versions of Windows or Linux require the DOSbox application, see http://www.dosbox.com).
The directory <qpc>/examples/arm-cortex/vanilla/iar/game-ev-lm3s811-qm/ contains the version of the game for the EV-LM3S811 ARM Cortex-M3 board. This directory contains the model file "game.qm", which is actually identical as the model in the DOS version. The LM3S811 version needs to be compiled with the IAR compiler and executed on the EV-LM3S811 board.
Additionally, the QP/C baseline code has been slighlty modified for better conformance to the MISRA C 2004 rules and the latest PC-Lint 9.x.
This release is adds compatibility of all examples for DOS with the DOSBox emulator (http://www.dosbox.com/) that recreates a MS-DOS compatible environment on all versions of Windows, including 64-bit Windows that don't run 16-bit DOS applications anymore.
Also, this release includes QP ports and examples for EV-LM3S811 board with the GNU-based Code Sourcery G++ toolset. Support for Sourcery G++ provides a very cost-effective option for developing QP applications for ARM Cortex MCUs.
Finally, this release improves the Cortex Microcontroller Software Interface Standard (CMSIS) for the whole family of the Stellaris LM3Sxxx MCUs. The improvement extends the CMSIS from Sandstorm to Fury, DustDevil, and Tempest Stellaris families.
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/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 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/DOS, 80x86/qk, and 80x86/ucos2 ports and examples for Turbo C++ 1.01 have been replaced with ports and examples for Open Watcom. The make.bat scripts are provided to build the QP/C libraries and examples.
In the process of converting the examples to Open Watcom two new examples have been added to the standard QP/C distribution. The Calc2 example located in <qpc>/examples/80x86/dos/watcom/l/calc2 shows how to derive state machine classes with QP 4.x. The SLS example located in <qpc>/examples/80x86/dos/watcom/l/sls shows the implemenation of the new State-Local Storage state design pattern.
The release brings a number of improvements to QP/C and updates the QP/C ARM Cortex-M3 examples for the EK-LM3S811 board to the latest IAR EWARM 5.40.
This maintenance release does not change the QP/C API in any way, so the release has NO IMPACT on the QP/C applications.
The main changes in QP v4.1.00 with respect to 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/C API in any way, so the release has NO IMPACT on the QP/C applications.
The main changes in QP v4.0.04 with respect to earlier version are as follows:
The main purpose of this release is to fix a bug in the QK preemptive kernel, which occurs only when the advanced QK features are used. Specifically, the QK priority-ceiling mutex could interfere with QK thread-local storage (TLS) or QK extended context switch. When the QK mutex is in use, the TLS or the extended context for this task could get saved to an incorrect priority level.
The release 4.0.03 fixes the bug by strictly preserving the semantics of QK_currPrio_ variable. The mutex locking now uses a different variable QK_ceilingPrio_, which represents the ceiling-priority locked by the mutex. The QK scheduler and extended scheduler now perform an additional check to make sure that only tasks with priorities above the ceiling can run. To avoid that additional overhead, the user can define the macro QK_NO_MUTEX, which eliminates the QK mutex API and eliminates the additional tests in the QK schedulers.
This maintenance release does not change the QP/C API in any way, so the release has NO IMPACT on the QP/C applications.
The main changes in QP v4.0.03 with respect to earlier version are as follows:
This maintenance release does not change the QP/C API in any way, so the release has NO IMPACT on the QP/C applications.
The main changes in QP v4.0.02 with respect to earlier version are as follows:
This maintenace release is made to allow using QS software tracing with the GNU compiler for AVR (WinAVR). Specifically, the output of the strings residing in ROM has been fixed.
This maintenance release does not change the QP/C API in any way, so the release has NO IMPACT on the QP/C applications.
The main changes in QP v4.0.01 with respect to earlier version are as follows:
This milestone release is made for the book /ref PSiCC2. The book describes in great detail this new release. The older "QP Programmer's Manual" is now phased out and is replaced with this hyper-linked /ref main_page "QP/C Reference Manual", which provides very detailed, easily searchable reference to the software. The book /ref PSiCC2 provies in-depth discussion of the relevant concepts as well as the design study of QP v4.0.
The main changes in QP v4.0 with respect to earlier versions are as follows:
Release date: Sep 25, 2007
This product release adds the backward-compatibility layer so that previous QP/C ports continue to work with the new version.
This product release also comes with the updated "QP Programmer's Manual", which now includes the QS target component and the QSpy host application.
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/C facilities that typically should not be used by the application programmer.
The main changes are made to the QEP component. The "static transition optimization" has been removed altogether. This simplifies significantly the state machine structure (which now contains just the currently active state). Also, the efficiency is improved for processing the dynamic transitions and the stack usage is lower. This change brings the QEP/C implementation much closer to QEP-nano.
The other big change in this release is including the Quantum Spy (QS) component in the distribution. Previously, the QS component was available only under the commercial licensing. It is now open source, just as the rest of QP.
In, the QF/C component, the QTimerEvt_publishIn() and QTimeEvt_publishEvery() have been removed, because they introduced a coupling between time events and publish-subscribe. This is undesirable for projects that do not want to include the publish-subscribe facilty.
Finally, the revision history for individual QP/C components has been moved from the header files and is now consolidated in the header file doxygen/qpc_rev.h.
Release date: Mar 17, 2007
The main change in this release is removing the 'const' declaration of two temporary variables inside QHsm_dispatch() and QHsm_tran() functions. This was necessary to compile the code with the MPLAB C18 compiler for PIC18 devices.
Other minor changes include adding the 'U' suffix (unsigned) to several numerical literals to avoid MPLAB C18 compiler warnings.
The changes in release 3.3.01 have NO impact on the existing QP/C ports.
Release date: Jan 22, 2007
The main change in this release is removing #include <stdint.h> from the qep.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 qpc_port.h file before including qep.h. For compilers that do provide the <stdint.h> header file, you simply include this file in the qpc_port.h header file before including qep.h.
The changes in release 3.3.00 have impact on all QP ports, because you need to modify the qpc_port.h file in all these ports.
The other significant 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).
Finally, in release 3.3.00 the build strategy for QP ports has been simplified as well. Instead of separate Makefile for every QP component, such as QEP, QF, QK, and QS, not the "ports" directory contains a batch file "make.bat" that builds all the libraries at once.
Release date: Dec 08, 2006
This QF release rolls back the changes made to the reference-counting policy. The reference count of a dynamic event is incremented when the event is posted, but is NOT decremented when the event is retreived from the queue. The reference count is decremented only later, in the garbage collector (QF_gc()).
This release adds direct support for event deferral (the "Deferred Event" state pattern) through methods QActive_defer_() and QActive_recall_().
Also this release adapts the QS code to the specifics of the Keil C51 compiler for 8051/251. In particular, the C51 compiler treats the identifier "data" as an extended keyword. To make the QS code compile with C51, all "data" used as a formal function parameter have been renamed. Additionally, this release fixes a minor bug in the QS_FUN_DICTIONARY macro.
Release date: Dec 01, 2006
This QF release changes the internal policy of reference-counting for dynamic events. The reference count of a dynamic event is now incremented when the event is posted to a queue and decremented when the event is later retreived from the queue. This policy pertains to both active object queues and native QF thread-safe queues (QEQueue).
Previously, the reference count of a dynamic event was not decremented upon retreival of the event from the event queue, but rather in the garbage collector (QF_gc()).
This QK release adds two new features in QK.
The first feature added is the extended context switch for CPUs with co-processors, such as the x87 FPU accompanying the x86 CPU. As a fully- preemptive kernel, QK needs to save and restore the context of the co- processor accrosss the asynchronous preemption. This QK release adds a generic mechanism for saving and restoring extened context in the extended scheduler (QK_scheduleExt_()), which is used only at the exit from the interrupts (asynchronous preemptions).
The second feature added is the Thread-Local Storage (TLS) for reentrant libraries, such as the NewLib. This feature allows assigning per-thread memory and providing a hook (callback) activated at every context switch.
Release date: Nov 15, 2006
The main purpose of this release is to adapt the 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 __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/C 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.
This release also fixes a few minor inconsistencies in the code (see the list below):/
Release date: Oct 30, 2006
Release date: Sep 01, 2006
Release date: Aug 07, 2006
Release date: Jul 14, 2006
Release date: Feb 08, 2006
Release date: Dec 08, 2005
Release date: Nov 18, 2005
Release date: Feb 08, 2006
Release date: Oct 18, 2005
Release date: Oct 03, 2005
Release date: Aug 14, 2005
Release date: Aug 06, 2005
This release contains completely redesigned Quantum Event Processor (QEP). The main focus is on compliance with standards (MISRA, Lint, Coding Standard), better portability, stack-use efficiency.
1.7.6.1