6.9.0

Author: QL

3rd_party/stm32f4-discovery/system_stm32f4xx.c

@@ -399,7 +399,7 @@ static void SetSysClock(void)
     RCC->CFGR |= RCC_CFGR_SW_PLL;
 
     /* Wait till the main PLL is used as system clock source */
-    while ((RCC->CFGR & (uint32_t)RCC_CFGR_SWS ) != RCC_CFGR_SWS_PLL);
+    while ((RCC->CFGR & (uint32_t)RCC_CFGR_SWS ) != RCC_CFGR_SWS_PLL)
     {
     }
   }

doxygen/Doxyfile

@@ -2,6 +2,45 @@ namespace QP {
 
 /** @page history Revision History
 
+@section qpcpp_6_9_0 Version 6.9.0, 2020-08-21
+The main purpose of this release is to adjust the QP/C++ RTEF to the changes and improvements introduced in [QTools 6.9.0](https://www.state-machine.com/qtools/history.html). Specifically, QP/C++ now includes examples for the new [QView Visualization & Monitoring](https://www.state-machine.com/qtools/qview.html) as well as adjustments for the new version of [QUTest Unit Testing](https://www.state-machine.com/qtools/qutest.html).
+
+
+__Source code changes:__
+
+Added new #QS_QF_RUN trace record to [QS software tracing](https://www.state-machine.com/qtools/qs.html), which is now generated in all QP/C++ ports upon the entry to QF::run(). This trace record marks the end of the application startup, at which time all the [QS dictionaries](https://www.state-machine.com/qtools/qs.html#qs_dict) are typically produced.
+
+@note
+The addition of the #QS_QF_RUN trace record affects only the [Spy build configuration](https://www.state-machine.com/qpc/struct.html#comp_qs) and is has **no impact** on the Release or Debug build configurations.
+
+
+__Updated Ports:__
+
+  + All QP/C++ ports to 3rd-party RTOSes (embOS, FreeRTOS, ThreadX, uC/OS-II) and OSes (POSIX, POSIX-QV, WIN32, WIN32-QV) have been updated to generate the #QS_QF_RUN trace record.
+
+  + Additionally the POSIX and POSIX-QV ports have been updated to add the call to `pthread_attr_setinheritsched(&attr, PTHREAD_EXPLICIT_SCHED)` (see also [bug#276](https://sourceforge.net/p/qpc/bugs/276))
+
+
+__Updated Examples:__
+
+  + All [QUTest](https://www.state-machine.com/qtools/qutest.html) examples (`qpcpp\examples\qutest` directory) have been modified to use the new location of the `qutest.py` Python module. Also, all QUTest examples that use the `on_reset()` callback have been modified to call `expect_run()`.
+
+@note
+The #QS_QF_RUN record is now generated in [QUTest unit testing](https://www.state-machine.com/qtools/qutest.html), which requires adjustments in the existing [test scripts](https://www.state-machine.com/qtools/qutest_script.html). Specifically, the test scripts that provide their own [on_reset() callback](https://www.state-machine.com/qtools/namespacequtest__dsl.html#aa40735b0e2865f928331d30798090ee2) must now also call [expect_run()](https://www.state-machine.com/qtools/namespacequtest__dsl.html#a6a958064a793bd7edd6ecc39e03c356a).
+
+
+  + ARM Cortex-M examples for STM32 NUCLEO-L053RE (`qpcpp\examples\arm-cm\dpp_nucleo-l053r8`) and NUCLEO-L152RE (`qpcpp\examples\arm-cm\dpp_nucleo-l152re`) have been modified to support bi-directional QSPY communication. These examples now include the QView demos.
+  + Added examples of new [Sequence Diagram Generation](https://www.state-machine.com/qtools/html/qspy_seq.html) in QSPY 6.9.0
+
+
+__Bug Fixes:__
+
+  + [bug#276 "QP/C/C++ POSIX port doesn't set thread priorities correctly"](https://sourceforge.net/p/qpc/bugs/276)
+
+  + [bug#277 "QP/​C++6.8.2 game-gui and dpp-gui examples fail to compile with Visual Studio"](https://sourceforge.net/p/qpc/bugs/277)
+
+
+
 @section qpcpp_6_8_2 Version 6.8.2, 2020-07-17
 
 __Source code changes:__

doxygen/Doxyfile-CHM

@@ -3,8 +3,8 @@ namespace QP {
 /// @file
 /// command-line macros and macros for porting QP
 
-/// The preprocessor switch to disable checking assertions
-///
+//! The preprocessor switch to disable checking assertions
+//
 /// When defined, Q_NASSERT disables the following macros #Q_ASSERT,
 /// #Q_REQUIRE, #Q_ENSURE, #Q_INVARIANT, #Q_ERROR as well as
 /// #Q_ASSERT_ID, #Q_REQUIRE_ID, #Q_ENSURE_ID, #Q_INVARIANT_ID, and
@@ -16,9 +16,9 @@ namespace QP {
 /// failures when the switch Q_NASSERT is defined.
 #define Q_NASSERT
 
-/// The preprocessor switch to activate the event-constructors
-/// and destructors
-///
+//! The preprocessor switch to activate the event-constructors
+//! and destructors
+//
 /// When Q_EVT_CTOR is defined (typically in the qep_port.hpp header file),
 /// QP::QEvt becomes a class with constructor and virtual destructor.
 /// More importantly, the subclasses of QEvt (your custom events) can have
@@ -27,41 +27,42 @@ namespace QP {
 /// is invoked before recycling the event with QP::QF::gc().
 #define Q_EVT_CTOR
 
-/// The preprocessor switch to activate the QS software tracing
-/// instrumentation in the code
-///
+//! The preprocessor switch to activate the QS software tracing
+//! instrumentation in the code
+//
 /// When defined, Q_SPY activates the QS software tracing instrumentation.
 /// When Q_SPY is not defined, the QS instrumentation in the code does
 /// not generate any code.
 #define Q_SPY
 
-/// The preprocessor switch to activate the QUTest unit testing
-/// instrumentation in the code */
+//! The preprocessor switch to activate the QUTest unit testing
+//! instrumentation in the code
 ///
 /// @note
 /// This macro requires that #Q_SPY be defined as well.
 #define Q_UTEST
 
-/// This macro defines the type of the OS-Object used for blocking
-/// the native QF event queue when the queue is empty
-///
-/// In QK, the OS object is used to hold the per-thread flags, which might
-/// be used, for example, to remember the thread attributes (e.g.,
-/// if the thread uses a floating point co-processor). The OS object value
-/// is set on per-thread basis in QActive::start(). Later, the extended
-/// context switch macros (QK_EXT_SAVE() and QK_EXT_RESTORE()) might use
-/// the per-thread flags to determine what kind of extended context switch
-/// this particular thread needs (e.g., the thread might not be using the
-/// coprocessor or might be using a different one).
-#define QF_OS_OBJECT_TYPE  uint8_t
-
-/// This macro defines the type of the thread handle used for the
-/// active objects. This macro depends on the QP port.
-#define QF_THREAD_TYPE     void *
-
-/// Platform-dependent macro defining how QF should block the calling
-/// task when the QF native queue is empty
+//! This macro defines the type of the thread handle used for AOs
+#define QF_THREAD_TYPE         void*
+
+//! This macro defines the type of the event-queue used for AOs
+#define QF_EQUEUE_TYPE         QEQueue
+
+//! This macro defines the type of the OS-Object used for blocking
+// the native ::QEQueue when the queue is empty
+//
+/// @description
+/// This macro is used when ::QEQueue is used as the event-queue for AOs
+/// but also the AO queue must *block* when the queue is empty.
+/// In that case, #QF_OS_OBJECT_TYPE specifies the blocking mechanism.
+/// For examle, in the POSIX port, the blocking mechanism is a condition
+/// variable.
 ///
+#define QF_OS_OBJECT_TYPE      pthread_cond_t
+
+//! Platform-dependent macro defining how QF should block the calling
+//! task when the QF native queue is empty
+//
 /// @note This is just an example of #QACTIVE_EQUEUE_WAIT_ for the QK-port
 /// of QF. QK never activates a task that has no events to process, so in this
 /// case the macro asserts that the queue is not empty. In other QF ports you
@@ -70,9 +71,9 @@ namespace QP {
 #define QACTIVE_EQUEUE_WAIT_(me_) \
     Q_ASSERT((me_)->m_eQueue.m_frontEvt != nullptr)
 
-/// Platform-dependent macro defining how QF should signal the
-/// active object task that an event has just arrived.
-///
+//! Platform-dependent macro defining how QF should signal the
+//! active object task that an event has just arrived.
+//
 /// The macro is necessary only when the native QF event queue is used.
 /// The signaling of task involves unblocking the task if it is blocked.
 ///
@@ -89,13 +90,13 @@ namespace QP {
         uint8_t p = QK_schedPrio_();     \
         if (p != 0U) {                   \
             QK_sched_(p);                \
-        } \
-    } \
+        }                                \
+    }                                    \
 } while (false)
 
-/// This macro defines the type of the event pool used in this QF port.
-///
-/// \note This is a specific implementation for the QK-port of QF.
+//! This macro defines the type of the event pool used in this QF port.
+//
+/// @note This is a specific implementation for the QK-port of QF.
 /// In other QF ports you need to define the macro appropriately for
 /// the underlying kernel/OS you're using.
 #define QF_EPOOL_TYPE_              QMPool
@@ -110,7 +111,7 @@ namespace QP {
 
 /// Platform-dependent macro defining the event pool initialization
 ///
-/// \note This is a specific implementation for the QK-port of QF.
+/// @note This is a specific implementation for the QK-port of QF.
 /// In other QF ports you need to define the macro appropriately for
 /// the underlying kernel/OS you're using.
 #define QF_EPOOL_INIT_(p_, poolSto_, poolSize_, evtSize_) \
@@ -119,24 +120,24 @@ namespace QP {
 /// Platform-dependent macro defining how QF should obtain the
 /// event pool block-size
 ///
-/// \note This is a specific implementation for the QK-port of QF.
+/// @note This is a specific implementation for the QK-port of QF.
 /// In other QF ports you need to define the macro appropriately for
 /// the underlying kernel/OS you're using.
 #define QF_EPOOL_EVENT_SIZE_(p_) static_cast<uint32_t>((p_).getBlockSize())
 
 /// Platform-dependent macro defining how QF should obtain an event
-/// \a e_ from the event pool \a p_
+/// @a e_ from the event pool @a p_
 ///
-/// \note This is a specific implementation for the QK-port of QF.
+/// @note This is a specific implementation for the QK-port of QF.
 /// In other QF ports you need to define the macro appropriately for
 /// the underlying kernel/OS you're using.
 #define QF_EPOOL_GET_(p_, e_, m_) \
     ((e_) = static_cast<QEvt *>((p_).get((m_))))
 
 /// Platform-dependent macro defining how QF should return an event
-/// \a e_ to the event pool \a p_
+/// @a e_ to the event pool @a p_
 ///
-/// \note This is a specific implementation for the QK-port of QF.
+/// @note This is a specific implementation for the QK-port of QF.
 /// In other QF ports you need to define the macro appropriately for
 /// the underlying kernel/OS you're using.
 #define QF_EPOOL_PUT_(p_, e_)   ((p_).put(e_))