QP/C Revision History

Version 4.0.03 (Product) Release date: Dec 27, 2008

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:

• in qk.h file made the QK mutex API only visible when the macro QK_NO_MUTEX is *not* defined.
• in qk_pkg.h file, added the QK_ceilingPrio_ external declaration when the macro QK_NO_MUTEX is not defined.
• in qk_mutex.c file, changed priority-ceiling mutex implementation to use the QK_ceilingPrio_ instead of QK_currPrio_. Also, added compiler error when the macro QK_NO_MUTEX is definedthis and this file is included in the build.
• in qk_sched.c file added testing priority against the QK_ceilingPrio_, when the macro QK_NO_MUTEX is not defined.
• in qk_ext.c file added testing priority against the QK_ceilingPrio_, when the macro QK_NO_MUTEX is not defined.

Version 4.0.02 (Product) Release date: Nov 15, 2008

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:

• in qep.h file, added comments to macros Q_TRAN() and Q_SUPER() to suppress the PC-lint warining about using the comma-operator (MISRA rule 42).
• in qhsm_in.c file, fixed a bug in the QHsm_isIn() function.
• fixed a bug in tunnel.c file ("Fly 'n' Shoot" game). The constant event HIT_WALL was not declared static.

Version 4.0.01 (Product) Release date: June 09, 2008

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:

• in qs_.c file, updated the function QS_str_ROM_().
• in qs_str.c file, updated the function QS_str_ROM().
• in qvanilla.c file, funciton QF_run(), declared the temporary variables as static to save stack space, because QF_run() never returns and is not reentrant.

Version 4.0.00 (Product) 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 Programmer's Manual" is now phased out and is replaced with this hyper-linked QP/C 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.

The main changes in QP v4.0 with respect to earlier versions are as follows:

• the coding techniques for hierarchical state machines (HSMs) and the simpler finite state machines (FSMs) have changed. While the changes are quite simple, the backward compatibility with QEP 3.x has been broken, meaning that some manual changes to the state machines implemented with earlier versions are necessary. Please refer to the "QP/C Tutorial" Section 7. Coding Hierarchical State Machines for more information about coding state machines with QEP 4.x.
  • The main change is the signature of a state-handler function, which now returns simply a byte. This return type (typedef'ed as QState) is the status of the event-handling that the state handler conveys to the QEP event processor.
  • The macro Q_TRAN() must now always follow the return statement.
  • The new macro Q_SUPER() designates the superstate of the given state. Again, this macro must follow the return statement.
  • Then two new macros Q_HANDLED() and Q_IGNORED() have been added to return the status of event handled and event ignored, respectively.

• all callback functions are now consistently called XXX_onYYY():
  • Q_assert_handler() is now Q_onAssert()
  • QF_start() is now QF_onStartup()
  • QF_cleanup() is now QF_onCleanup()

• the new header file qevent.h has been broken off the qep.h header file. qevent.h contains the QEvent class and other basic facilities used in the whole QP. This new file allows easier replacement of the entire QEP event processor with custom event processors, if you wish do so.
• the macro QEP_SIGNAL_SIZE is renamed to Q_SIGNAL_SIZE.
• the data type QSTATE is now deprecated. Please use QState.
• the "protected" in C don't no longer have the trailing underscore. For example, QHsm_ctor_() is replaced with QHsm_ctor(), etc.
• the QF_FSM_ACTIVE macro is now deprecated. Instead, you have the family of macros QF_ACTIVE_SUPER_, QF_ACTIVE_CTOR_, QF_ACTIVE_INIT_, QF_ACTIVE_DISPATCH_, QF_ACTIVE_STATE_, which allow replacing the base class for active objects in QF. By default, these macros are defined to use the QHsm class from the QEP hierarchical event processor, but you can replace the event processor, if you wish.
• the internal macro QACTIVE_OSOBJECT_WAIT_() is now QACTIVE_EQUEUE_WAIT_().
• the internal macro QACTIVE_OSOBJECT_SIGNAL_() is now QACTIVE_EQUEUE_SIGNAL_().
• the internal macro QACTIVE_OSOBJECT_ONIDLE_() is now QACTIVE_EQUEUE_ONEMPTY_().
• the data mebers QActive.osObject and QActive.thread are now present only if the macros QF_OS_OBJECT_TYPE and QF_THREAD_TYPE are defined.
• the QPSet class has been renamed to QPSet64.
• the QPSet_hasElements() has been renamed QPSet64_notEmpty()
• the QS software tracing is now better integrated with all QP components. You no longer need to explicitly include qs_port.h, because it is automatically included when you define the macro Q_SPY. Also the file qs_dummy.h is included automatically when the macro Q_SPY is not defined.
• the new header file qvanilla.h now replaces the file qsched.h.
• the file qa_ctor.c is now obsolete.
• the macros QF_SCHED_LOCK() and QF_SCHED_UNLOCK() are now obsolete.
• the native QF event queues (both the active object event queues and the "raw" thread-safe queues) are slightly more efficient by counting down the head and tail pointers rather than up. This leads to wrap-around at zero, which is easier (faster) to test than any other wrap-around point. Also the native QF event queues maintain the minimum of the free events in the queue rather the maximum of used events.
• the data member of QEQueue.nTot class is removed.
• the QF_publish() function has been re-written so that QF no does not need to lock the scheduler. The QF_publish() function posts events to active objects with scheduler unlocked starting from the highest-priority active objects. However, the event is protected from inadvertent recycling by incrementing its reference counter before the publish operation. After the event is posted to all subscribers, the garbage collector QF_gc() is called to decrement the reference counter and recycle the event, if necessary.
• the qf_run.c file is obsolete. The QF_run() function for the cooperative "vanilla" kernel is now implemented in the file qvanilla.c.
• the QF_tick() function has been rewritten to allow calling QF_tick() from the task context as well as from the interrupt context. The nested critical section around QF_tick() is no longer needed when it is called from the task level. Among others, this re-design eliminates the need for the recursive mutex in the POSIX QF port.
• the QMPool_init() function has been re-designed to optimally align the memory buffer in a portable and platform-independent way. This should bring some performance improvements on some CPUs (e.g., 80x86).
• the extended QK scheduler has been re-designed to save stack space. The extended context (e.g., coprocessor registers) are no longer saved on the precious stack, but rather in the active object.
• a bug has been fixed in handling of Thread-Local Storage (TLS) in the QK scheduler and extended scheduler.

• the -q (quiet) flag has been added to the QSPY host application.
• the support for two new compilers for Windows has been added for the QSPY host application. The application can now be build with the MinGW GNU compiler for Windows as well as the Microsoft Visual C++ 2005.

• the QP port to Linux has been improved by eliminating the need for recursive P-Thread mutex.

• the QP port to MicroC/OS-II has been upgraded to the latest version 2.86.

• all examples in the standard QP distribution have been cleaned up and updated to the latest QP API changes.
• all examples that use QF now contain the QS software tracing support.

Version 3.4.01 (Product)

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.

Version 3.4.00 (Beta)

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.

Version 3.3.01 (Product)

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.

1. in file qhsm_dis.c:80 removed 'const' from the declaration of '*c'.
2. in file qhsm_tra.c:69 removed 'const' from the declaration of 'src'.
3. in file qep.c changed the version number to "3.3.01".
4. added the 'U' suffix to several numerical literals in files: qa_defer.c, qa_usuba.c, qf_gc.c, qf_pool.c, qf_run.c
5. in file qf_act.c changed the version number to "3.3.01".
6. added the cast to (uint8_t) to several numerical literals in the file qk.c.
7. in file qk.c changed the version number to "3.3.01".
8. added the 'U' suffix to several numerical literals in file qs.h.
9. in files qs_.c and qs_str.c added explicit casting to (char const).
10. in file qs.c changed the version number to "3.3.01".

Version 3.3.00 (Product)

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.

1. in file qep.h removed "#include <stdint.h>".
2. in file qassert.h added macro Q_ROM_VAR for objects allocated in ROM and to signatures of functions accessing these objects.
3. in file qep.h added macro Q_ROM_VAR for objects allocated in ROM and to signatures of functions accessing these objects.
4. in file qep.h added default empty definitions and Doxygen comments for macros Q_ROM and Q_ROM_VAR.
5. in file qep.c added macro Q_ROM_VAR for objects allocated in ROM and to signatures of functions accessing these objects.
6. in file qf.c added macro Q_ROM_VAR for objects allocated in ROM and to signatures of functions accessing these objects.
7. in file qk.c added macro Q_ROM_VAR for objects allocated in ROM and to signatures of functions accessing these objects.
8. in file qep.c added Q_ROM_VAR to the signature of QEP_getVersion().
9. in file qep.c changed the version number to "3.3.00".
10. in file qf.h added macro Q_ROM_VAR for objects allocated in ROM and to signatures of functions accessing these objects.
11. in file qf.h removed method QF_getTime() and deleted external variable QF_tickCtr_.
12. deleted obsolete file qa_fifo_.c
13. deleted obsolete file qa_lifo_.c
14. deleted obsolete file qf_time.c
15. in file qf_act.c added Q_ROM_VAR to the signature of QEP_getVersion().
16. in file qf_log2.c added Q_ROM_VAR to the definition of the lookup table.
17. in file qf_pwr2.c added Q_ROM_VAR to the definition of the lookup tables.
18. in file qf_tick.c removed incrementing QF_tickCtr_.
19. In file qf_act.c updated version number to 3.3.00
20. in file qk.h added macro Q_ROM_VAR for objects allocated in ROM and to signatures of functions accessing these objects.
21. In file qk.c added Q_ROM_VAR to the signature of QK_getVersion().
22. In file qk.c updated version number to 3.3.00
23. in file qs.h added macro QS_ROM_VAR for objects allocated in ROM and to signatures of functions accessing these objects.
24. In file qs.h added default definitions of the QS macros Q_ROM, Q_ROM_VAR, and Q_ROM_BYTE.
25. In file qs.h added declaration of QS_tickCtr_.
26. In file qs.c added Q_ROM_VAR to the signature of QS_getVersion().
27. In file qs_.c added Q_ROM_VAR to the signature of QS_str_ROM_().
28. In file qs_.c added definition of QS_tickCtr_.
29. In file qs_str.c added Q_ROM_VAR to the signature of QS_str_ROM().
30. In file qs.c updated version number to 3.3.00
31. Updated the "QP Programmer's Manaul" to Revision E

Version 3.2.05 (Product)

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.

1. In file qf.h added methods QActive_defer_() and QActive_recall_().
2. In file qa_get_.c removed decrementing the reference count of a dynamic event.
3. In file qeq_get.c removed decrementing the reference count of a dynamic event.
4. In file qf_gc.cpp restored decrementing of the reference count of a dynamic event.
5. Added new file qa_defer.c that implements QActive_defer_() and QActive_recall_().
6. In file qf_act.c updated version number to 3.2.05
7. In file qs.h removed all instances of indentifier "data"
8. In file qs.h fixed a bug in the definition of macro QS_FUN_DICTIONARY.
9. In file qs_.c renamed all instances of identifier "data".
10. In file qs_f32.c renamed all instances of identifier "data".
11. In file qs_f64.c renamed all instances of identifier "data".
12. In file qs.c, in functions QS_filterOn() and QS_filterOff() moved the declaration of the temporary variable 'i' from the inner scope to the function scope. The C51 compiler was crushing with variables at inner scope.
13. In file qs.c updated version number to 3.2.05
14. Updated the "QP Programmer's Manaul" to Revision D

Version 3.2.04 (Beta)

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.

1. In file qf.h eliminated methods QActive_postFIFO_() and QActive_postLIFO_().
2. In file qf.h changed method QActive_get__() to QActive_get_() (protected scope) to make it available to various thread-run routines.
3. In file qa_fifo.c changed the implementation of QActive_postFIFO() to represent the native QF event queue of an active object.
4. In file qa_fifo_.c removed the implementation of QActive_postFIFO__() and declared the file obsolete (will be removed in future releases).
5. In file qa_lifo.c changed the implementation of QActive_postLIFO() to represent the native QF event queue of an active object.
6. In file qa_lifo_.c removed the implementation of QActive_postLIFO__() and declared the file obsolete (will be removed in future releases).
7. In file qa_get_.cpp added decrementing the reference count of a dynamic event.
8. In file qf_gc.c removed decrementing of the reference count of a dynamic event. Also changed the test for recycling an event (reference count of zero).
9. In file qf_pspub.c removed incrementing the reference count of a dynamic event.
10. Removed all uses of the macros QACTIVE_POST_FIFO_, QACTIVE_POST_LIFO_, and QACTIVE_GET_. These macros are made now obsolete.
11. In file qsched.h removed definitions of the obsolete macros QACTIVE_POST_FIFO_, QACTIVE_POST_LIFO_, and QACTIVE_GET_.
12. In file qf_pspub.c replaced the macro QACTIVE_POST_FIFO_() with the direct call to the function QActive_postFIFO(QF_active_[p], e).
13. In file qf_tick.c replaced the macro QACTIVE_POST_FIFO_() with the direct call to the function QActive_postFIFO(QF_active_[p], e).
14. Changed the uC/OS-II port to reflect new policy of handling reference counters inside the dynamic events. Also removed files qa_fifo.c and qa_lifo.c from the uC/OS-II build.
15. In file qf_act.c updated version number to 3.2.04
16. In file qk.h updated revision history and added the prototype for the extended scheduler QK_scheduleExt_(). This scheduler implements the generic extended context via macros QK_EXT_TYPE, QK_EXT_SAVE, and QK_EXT_RESTORE.
17. In file qk.h removed definitions of the obsolete macros QACTIVE_POST_FIFO_, QACTIVE_POST_LIFO_, and QACTIVE_GET_.
18. In file qk_sched.c added logic for handling the TLS via the macro QK_TLS.
19. Added new file qk_ext.c with the definition of the extended scheduler QK_scheduleExt_().
20. Added the file qk_ext.c to the Makefile for QK port to 80x86 with Turbo C++ 1.01.
21. Extended the QK port to 80x86 with Turbo C++ 1.01 to handle the x87 FPU context.
22. Extended the QDPP example for QK with Turbo C++ 1.01 to demonstrate threads that use the FPU and require the extended context switch.
23. In file qk.c updated version number to 3.2.04
24. Updated the "QP Programmer's Manaul" to Revision C

Version 3.2.03 (Product)

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):\

1. In file qf.h added default definition of macro Q_ROM_BYTE
2. In file qf_set.h added macro Q_ROM_BYTE to access the lookup tables allocated in ROM (several places).
3. In file qf_sched.h changed types QF_OS_OBJECT_TYPE and QF_THREAD_TYPE to uint8_t from int8_t
4. In file qs_dummy.h added dummy definitions of some missing QS macros
5. In file qa_sub.c added macro Q_ROM_BYTE to access the lookup tables allocated in ROM (several places).
6. In file qa_usub.c added macro Q_ROM_BYTE to access the lookup tables allocated in ROM (several places).
7. In file qf_usuba.c added macro Q_ROM_BYTE to access the lookup tables allocated in ROM (several places).
8. In file qf_pspub.c added macro Q_ROM_BYTE to access the lookup tables allocated in ROM (several places).
9. In file qf_act.c updated version number to 3.2.03
10. In file qs_pkg.h added default definition of macro Q_ROM_BYTE
11. In file qa_sub.c added macro Q_ROM_BYTE to access the lookup tables allocated in ROM (several places).
12. In file qs_.c added macro Q_ROM_BYTE to access the string allocated in ROM
13. In file qs_str.c added macro Q_ROM_BYTE to access the string allocated in ROM.
14. In file qs.h changed the include file name from "qs_dummy" to "qs_dummy.h".
15. In file qs.c updated version number to 3.2.03

Version 3.2.02 (Product)

Release date: Oct 30, 2006

1. In file qs.h replaced macro Q_ROM with QS_ROM
2. In file qs.h added methods QS_str_ROM_() and QS_str_ROM()
3. In file qs.h added macros QS_STR_ROM_() and QS_STR_ROM()
4. In file qs.h modified macros QS_???_DICTIONARY() to use ROM strings
5. In file qs.h included qs_dummy.h instead of the dummy definitions of the QS macros
6. In file qs_pkg.h added ifndef Q_SPY before definition of macro Q_SPY
7. In file qs_.c added definition of the function QS_str_ROM_()
8. In file qs_str.cpp added definition of the function QS_str_ROM()
9. In file qs.c updated version number to 3.2.02

Version 3.2.01 (Product)

Release date: Sep 01, 2006

1. In file qep.c updated version number to 3.2.01
2. Added makefiles for building ports of all QP/C libraries at once.
3. Created the consolidated manual "QP/C Programmer's Manual".
4. In file qf_act.c updated version number to 3.2.01
5. Added makefiles for building ports of all QP/C libraries at once.
6. Created the consolidated manual "QP/C Programmer's Manual".
7. In file qk.c updated version number to 3.2.01
8. Added makefiles for building ports of all QP/C libraries at once.
9. In file qs.c updated version number to 3.2.01
10. In file qs.c removed superfluous semicolons after QS_INSERT...() macros
11. In file qs_.c removed superfluous semicolons after QS_INSERT...() macros
12. In file qs_str.c removed superfluous semicolons after QS_INSERT...() macros
13. In file qs_mem.c removed superfluous semicolons after QS_INSERT...() macros
14. In file qs_f32.c removed superfluous semicolons after QS_INSERT...() macros
15. In file qs_f64.c removed superfluous semicolons after QS_INSERT...() macros
16. Added makefiles for building ports of all QP/C libraries at once.
17. Created the consolidated manual "QP/C Programmer's Manual".

Version 3.2.00 (Product)

Release date: Aug 07, 2006

1. In file qep.h added the default definition of Q_ROM in case it's not defined by the user.
2. In file qassert.h added the macro Q_ROM to allocate constant strings to ROM.
3. In file qep.c updated version number to 3.2.00
4. Updated the "QEP/C Programmer's Manual".
5. In file qf.h changed the semantics of the QF_onIdle() callback. This callback is now invoked with interrupts LOCKED from the non-preemptive scheduler used in the "vanilla" QF ports to "bare metal" target boards.
   
   The modification changes the 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.
   
   Also, the signature of QF_onIdle() now depends on the interrupt locking policy. In case of the "save and restore interrupt status" policy, the QF_onIdle() callback takes the interrupt lock key as parameter (to be able to unlock the interrups correctly).
6. In file qf.h used the macro Q_ROM to allocate constant objects to ROM (

   See also:

   qep.h). Objects allocated to ROM are: the version strings, and the lookup tables (QF_log2Lkup[], QF_pwr2Lkup[], QF_invPwr2Lkup, and QF_div8Lkup[].

7. Added new platform-independent header file qsched.h to provide the interface to the simple non-preemptive scheduler used in the "vanilla" ports of QF to "bare metal" targets. This header file is only applicable to the "vanilla" ports.
8. Added new platform-independent implementation file qf_run.c to implement the simple non-preemptive scheduler used in the "vanilla" ports of QF to "bare metal" targets. This implementation file eliminates the need for qf_port.c file in the "vanilla" ports of QF. Also, the qf_run.c module should only be placed in the QF library in the vanilla QF ports.
9. Simplified all "vanilla" ports of QF to use the common platform- independent implementation provided in qf_run.c.
10. Updated QF_onIdle() callback in all examples of "vanilla" ports of QF to unlock interrupts.
11. Modified file qf_pspub.c to allow allocating a temporary stack variable inside the macro QF_SCHED_LOCK(). This change is related to modification in QK v 3.2.00.
12. Updated the "QF/C Programmer's Manual".
13. in file qk.h added new idle callback QK_onIdle(), which in contrast to QF_onIdle() is invoked with interrupts unlocked.
14. in file qk.h removed QK_schedLock()/QK_schedUnlock() and replaced them with QK_mutexLock()/QK_mutexUnlock(), with the semantics of returning the mutex.
15. in file qk.h changed the definitions of macros QF_SCHED_LOCK/ QF_SCHED_UNLOCK to use the new QK mutex API.
16. In file qk.h used the macro Q_ROM to allocate constant objects to ROM (

    See also:

    qep.h).

17. in file qk.h added the typedef for QMutex.
18. in file qk.c replaced the callback QF_onIdle() with the new one QK_onIdle().
19. removed source file qk_lock.c
20. added source file qk_mutex.c
21. in file qk.c changed the version number to 3.2.00
22. Updated "QK/C Programmer's Manual"
23. In file qs.h replaced QS_QK_SCHED_LOCK/UNLOCK with QS_QK_MUTEX_LOCK/UNLOCK. Also, changed data accompanying the trace records QS_QK_MUTEX_LOCK/UNLOCK.
24. In file qs.h used the macro Q_ROM to allocate constant objects to ROM (

    See also:

    qep.h).

25. in file qs.c changed the version number to 3.2.00
26. Updated "QS/C Programmer's Manual" in PDF.

Version 3.1.06 (Product)

Release date: Jul 14, 2006

1. In file qf.h added function QF_stop() to be called from the application code to stop the framework.
2. In file qf.h added callback function QF_cleanup() to be called from the QF port to cleanup before exiting to the OS.
3. In file qf.h deprecated the function QF_exit().
4. In file qk_sched.c removed unlocking of interrupts upon exit from QK_schedule_(). Now QK_schedule_() enters and exits with interrupts LOCKED.
5. In file qk.h modified macro QACTIVE_OSOBJECT_SIGNAL_() to always unlock the interrupts, regardless if QK_schedule_() has been called or not.
6. In file qk.c added unlocking interrupts after the call to QK_SCHEDULE_() in the function QF_run().
7. In file qk_lock.c modified the function QK_schedUnlock() to always unlock the interrupts upon exit.
8. Updated licensing information.
9. Updated "QS Programmer's Manual" in PDF.

Version 3.1.05 (Product)

Release date: Feb 08, 2006

1. In file qf_act.c added the Revision History Doxygen comment, which was previously in doxygen/qp.h
2. In file qf.h augmented comment for QF_run() to cover the case when QF is used with QK.
3. In file qf.h added the extern declarations of QF_tickCtr_, QF_intLockNest, and QF_isrNest_, which were previously declared in qf_pkg.h.
4. In file qf.h added macros QF_QS_INT_LOCK, QF_QS_INT_UNLOCK(), QF_QS_ISR_ENTRY, and QF_QS_ISR_EXIT, which were previously declared in qs_port.h.
5. In file ports/linux/gcc/qf_port.h added extern uint8_t QF_running_.
6. In file qf/80x86/dos/tcpp101/l/qf_port.c replaced deprecated QPSet_hasElements() to QPSet_isEmpty().
7. In file qf/80x86/linux/gcc/qf_port.c added QF_run()
8. In file qeq_init.c:186 changed QS_OBJ(me) to QS_OBJ(qSto) to consistently refer to a queue by the ring buffer object
9. In file qf_pkg.h removed extern QF_tickCtr_.
10. In file qk.h removed extern QK_intLockNest_ and QK_isrNest_. These counters have been moved to QF and renamed in the process to QF_intLockNest_ and QF_isrNest_, respectively.
11. In file qk.h added QS instrumentatin to QF_INT_LOCK and QF_INT_UNLOCK macros for tracing interrupt locking/unlocking. The QS interrupt locking/ unlocking instrumentation has been previously added at the QK port level.
12. In file qk.h removed macros QK_QS_INT_LOCK()/ QK_QS_INT_UNLOCK(), QK_QS_ISR_ENTRY()/ QK_QS_ISR_EXIT(). These macros have been moved to QF and renamed in the process to QF_QS_INT_LOCK()/ QF_QS_INT_UNLOCK(), QF_QS_ISR_ENTRY()/ QF_QS_ISR_EXIT(), respectively.
13. In file ports/80x86/qk/tcpp101/l/qk_port.h simplified the definition of the macros QK_INT_LOCK/ QK_INT_UNLOCK to NOT contain the QS instrumenation.
14. In file ports/80x86/qk/tcpp101/l/qk_port.h changed the definitions of QK_ISR_ENTRY and QK_ISR_EXIT to use QF_QS_ISR_ENTRY/ QF_QS_ISR_EXIT.
15. In file qk.c added the Revision History Doxygen comment
16. In file qk_pkg.h changed the definition of internal QK macros QK_INT_LOCK_/ QK_INT_UNLOCK_ to use the QS-instrumented QF_INT_LOCK/ QF_INT_UNLOCK.
17. In file qk_lock.c corrected a comment
18. In file qk_sched.c corrected a comment
19. Provided "QS/C Programmer's Manual" in PDF.
20. In file qs.h changed around the pre-defined records. Added records: QS_QF_INT_LOCK, QS_QF_INT_UNLOCK, QS_QF_ISR_ENTRY, QS_QF_ISR_EXIT. Removed records QS_QK_INT_LOCK, QS_QK_INT_UNLOCK, QS_QK_ISR_ENTRY, QS_QK_ISR_EXIT.
21. In file qs.h renamed functions QS_filterIn()/ QS_filerOut() to QS_filterOn()/ QS_filerOff(). Correspondingly, changed macros QS_FILTER_IN(), QS_FILTER_OUT(), to QS_FILTER_ON(), QS_FILTER_OFF().
22. In file qs.h changed the signature and semantics of QS_getByte() to return QS_EOD (End-Of-Data).
23. In file qs.h changed the signature of QS_getBlock() to take a pointer to uint16_t rather than uint32_t.
24. In file qs.h eliminated the callback QS_newRecord()
25. In file qs.h added new callback QS_flush()
26. In file qs.h added application-level local filter object QS_apObj_. Consistently, added macro QS_FILTER_AP_OBJ() to set the new local filter. Consistently, added object argument to macros QS_BEGIN() and QS_BEGIN_NOLOCK().
27. In files qs.c, qs_.c, qs_blk.c, qs_byte.c, qs_pkg.h renamed some variables and adjusted comments.
28. Ported the QSpy host applicatoin to Linux. Added TCP/IP input to QSpy. Added new options.
29. Added redesigned QS port to Linux with TCP/IP data link.

Version 3.1.04 (Beta)

Release date: Dec 08, 2005

1. In file qmpool.h changed the definition of the QF_MPOOL_SIZ_SIZE macro to remove the dependency on the QF_EVENT_SIZ_SIZE. Macro QF_EVENT_SIZ_SIZE might not be defined by the time qmpool.h is included.
2. Added explicit definition of the configuration macro QF_EVENT_SIZ_SIZE to all qf_port.h files.
3. Fixed a bug in function QMPool_init() (file qmp_init.c) by changing the type of variable n from uint8_t to QMPoolCtr. The uint8_t data type was failing for bigger block sizes.
4. Added the QF_onIdle() callback to qf.h
5. Improved comments in qpset.h
6. Corrected dependencies in the Makefile for QDPP example (directory 80x86/dos/tcpp101/l and 80x86/dos/tcpp101/s)
7. Added Linux QF port to the standard QF/C distribution.
8. Released the "QF/C Programmer's Manual"
9. Released "QK/C Programmer's Manual" in PDF.
10. In file qk.h removed callbacks QK_init(), QK_start(), QK_idle(), QK_exit(), because they duplicate the QF callbacks.
11. Modified qk.c to define the following QF "callbacks": QF_getPortVersion(), QF_run(), QActive_start(), and QActive_stop_().
12. Added an argument to the signature of QK_schedLock() to allow selective QK scheduler locking up to the specified priority level.
13. Changed the implementation of QK_schedLock() in file qk_lock.c.
14. Eliminated the need for qf_port.c in the QF/C ports for QK.
15. Simplified elements that go into qk_port.c in the QK/C ports.
16. Added the ARM-Simulator port to the standard QK/C distribution.
17. Cleaned-up the 80x86 QK port.

Version 3.1.03 (Beta)

Release date: Nov 18, 2005

1. Added Doxygen documentation to the source code
2. Added running__ member to the QActive structure
3. Added QF_EVENT_SIZ_SIZE configuration macro and related data type QEventSize. Made the following changes to the signatures: void QF_poolInit(void *poolSto, uint32_t poolSize, QEventSize evtSize); QEvent *QF_new_(QEventSize evtSize, QSignal sig);
4. Changed the name of protected function from QF_new() to QF_new_().
5. Added the QK component (Beta)
6. Added Doxygen documentation to the source code

Version 3.1.02 (Beta)

Release date: Feb 08, 2006

1. In file qep.c added the Revision History Doxygen comment, which was previously in doxygen/qp.h
2. updated the QBomb example to use the key events described in the "QEP/C Programmer's Manual"
3. changed C++ comments to C-comments in main.c of the QHsmTst example

Version 3.1.01 (Beta)

Release date: Oct 18, 2005

1. Removed Quantum Spy (QS) dependency from the examples

Version 3.1.00 (Beta)

Release date: Oct 03, 2005

1. Applied new directory structure desribed in Application Note: QP Directory Structure -# Added Quantum Spy instrumentation. -# Removed file qfsm_tra.c. -# Introduced file qfsm_dis.c. -# Applied new directory structure desribed in Application Note: QP Directory Structure -# Added Quantum Spy instrumentation.

Version 3.0.11 (Beta)

Release date: Aug 14, 2005

1. Fixed potential race condition for static transitions
2. Changed names of helper function QFsm_tran_()/QHsm_tran_() to QFsm_execTran()/QHsm_execTran() to match the QEP/C++ version.
3. Added assertion in QHsm_execTran() to catch potential path[] array overrun that previously could go undetected.

Version 3.0.10 (Beta)

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. This release includes a comprehensive "QEP/C v3.0 Programmer's Manual" in PDF.
2. This release contains in-source comments for automatic generation of this Reference Manual with doxygen.
3. This release includes re-packaging the code into much larger number of modules (.c files) with typically one function per module. This fine-granularity packaging allows for better automatic elimination of unused code at link time and fine-tuning by applying different compiler options to different files.
4. This release is 98% compliant with the Motor Industry Software Reliability Association (MISRA) "Guidelines for the Use of the C Language in Vehicle Based Software", April 1998, ISBN 0-9524156-9-0 (see also See also http://www.misra.org.uk). A separate Application Note "QEP/C MISRA Compliance Matrix" contains detailed account how QEP/C compiles with the 127 MISRA rules (See http://www.state-machine.com/doc/AN_QP_C_MISRA.pdf). -# This release is now "lint-free". The source code has been thoroughly checked with the latest version of PC-lint(TM) (version 8.00q) from Gimpel Software (www.gimpel.com). The PC-lint configuration files and output files are included in the distribution. A separate Application Note "QEP/C PC-Lint Compliance" contains detailed account how QEP/C compiles with PC-Lint. (See http://www.state-machine.com/doc/AN_QP_C_PC-Lint.pdf). -# This release is compliant with the "Quantum Leaps Coding C/C++ Standard" (http://www.state-machine.com/resources/QL_coding_standard.pdf). Among others, all public names are prefixed by "Q_", or "QEP_" to minimize compile-time and link-time name conflicts. In addition, QEP/C uses the C99 standard include file <stdint.h> (C99 Standard, Section 7.18). Pre-standard compilers are still supported by placing <stdint.h> in the compiler's header file directory. -# The QEvent structure has been redesigned to use memory more efficiently. QEvent takes up only 2 bytes now. -# The QHsm structure now derives from the QFsm structure, which promotes better code re-use. In particular, macros Q_INIT() and Q_TRAN() are now common for both traditional non-hierarchical FSMs and for HSMs. -# The QFsm class has been redesigned to allow using entry and exit actions. Now the QFsm class strictly avoids recursion, just as QHsm does (MISRA rule 70). -# The QPseudoState type has been eliminated and replaced by QState. -# The central QHsm class in QEP has been completely redesigned. The basic transition algorithm is essentially the same as described in "PSiCC", however the implementation is very different. The redesign was necessary to comply with the MISRA rules and to eliminate Lint warnings. -# The event processor is now strictly non-recursive (MISRA rule 70), that is, event handlers never call themselves, even indirectly. (Previous algorithm required one-level of indirect recursion.) -# Dynamic state transition is now default. Static transition optimization is still supported, but considered optional for performance tuning. -# The artificial limitation of initial transitions targeting only immediate substate of a composite state has been removed (see "PSiCC" Figure 5.4[a]). Initial transitions can now target any substate, arbitrarily nested within the composite state. -# This distribution uses the legacy Borland Turbo C++ 1.01 as the default compiler. Port to DOS with Turbo C++ 1.01 is provided along with GNU-compatible makefiles for the QEP library and sample applications. This compiler is not C99-compliant and does not provide the <stdint.h> header file. However, the port of QEP includes a minimal <stdint.h>, which should be placed into the INCLUDE directory of the Borland Turbo C++ 1.01 installation. -# This distribution contains three sample applications: A simple time bomb (QBomb) to demonstrate use of QFsm, a calculator (QCalc), and an exhaustive test of the QHsm class (QHsmTst). All examples are implemented as text-only application compiled with Turbo C++ 1.01. The QHsmTst sample application supports interactive and batch mode for exhaustive testing of the event processor. The source code for QHsmTst demonstrates also how QEP/C application code can be MISRA-compliant. -# This distribution contains make files for the Turbo C++ 1.01 make utility, as well as GNU-compatible Makefiles.

---