8.1.0

Author: quantum-leaps

.gitignore

@@ -1,4 +1,7 @@
 *.qms
+*.cov
+*.gcov
+*.log
 *.obj
 *.o
 *.d
@@ -29,17 +32,37 @@
 *.chw
 *.sfr
 *.ewt
+*.csv
 *.user
 *.avrsuo
 *.Debug
 *.Release
 *.bak
 version-*
 JLink*.*
+*.host
+*.trg
+
+dbg/
+rel/
+spy/
+build*/
+settings/
+.settings/
+targetConfigs/
+Debug/
+Release/
+Spy/
+QSpy/
+
+lib/
+obj/
+output/
 
 include/qs.hpp
 include/qs_pkg.hpp
 include/qxk.hpp
+
 src/qs/qs.cpp
 src/qs/qs_64bit.cpp
 src/qs/qs_fp.cpp
@@ -49,29 +72,14 @@ src/qxk/qxk.cpp
 src/qxk/qxk_mutex.cpp
 src/qxk/qxk_sema.cpp
 src/qxk/qxk_xthr.cpp
-zephyr/qutest_port.cpp
 
 ports/arm-cm/qxk/
 ports/arm-cm/qutest/
 ports/posix-qutest/
 ports/win32-qutest/
+zephyr/qutest_port.cpp
 
-priv/
-html/
-latex/
-dbg/
-rel/
-spy/
-build*/
-settings/
-.settings/
-targetConfigs/
-
-Debug/
-Release/
-Spy/
-QSpy/
+static-analysis/pclp/
 
-lib/
-obj/
-output/
+tests/TIN*/
+tests/TUN*/

3rd_party

@@ -13,8 +13,10 @@ it is recommended that you clone this repo like that:
 git clone https://github.com/QuantumLeaps/qpcpp --recurse-submodules --depth 1
 ```
 
-Alternatively, you can also download one of the stable
-[QP/C++ Releases][QP-Rel].
+However, the easiest and most recommended way of
+[getting started with QP/C++](#getting-started-with-qpcpp) is to download
+the QP-bundle, as [described below](#getting-started-with-qpcpp).
+
 
 # About QP/C++ Real-Time Event Framework
 QP/C++ real-time event framework (RTEF) is a lightweight implementation of
@@ -25,7 +27,7 @@ of Active Objects (Actors) and a runtime environment for executing the Active
 Objects in a deterministic, real-time fashion. Additionally, QP/C++ Framework
 supports Hierarchical State Machines with which to specify the behavior of
 Active Objects [UML 2.5], [Sutter:10], [ROOM:94]. The QP/C++ Framework can be
-viewed as a modern, asynchronous, and truly event driven real-time operating
+viewed as a modern, asynchronous, and truly event-driven real-time operating
 system (RTOS).
 
 ## QP Framework Family
@@ -36,14 +38,14 @@ QP editions:
 |:----------|:-----------:|:-----------------|:-------------------|:----------------|:---------
 | QP/C      | C (C11)     |same as SafeQP/C  |Selected Assertions |Req/Arch/Design  | [dual][Lic]
 | QP/C++    | C++ (C++17) |same as SafeQP/C++|Selected Assertions |Req/Arch/Design  | [dual][Lic]
-| SafeQP/C  | C (C11)     |same as QP/C      |All Safety Functions|Extensive<br>Certification Kit| [commercial][Com]
-| SafeQP/C++| C++ (C++17) |same as QP/C++    |All Safety Functions|Extensive<br>Certification Kit| [commercial][Com]
+| SafeQP/C  | C (C11)     |same as QP/C      |All Safety Functions|Complete<br>Certification Kit| [commercial][Com]
+| SafeQP/C++| C++ (C++17) |same as QP/C++    |All Safety Functions|Complete<br>Certification Kit| [commercial][Com]
 
 The **SafeQP/C** and **SafeQP/C++** frameworks were originally derived from QP/C and QP/C++,
 respectively, but were extensively reengineered for the safety market using compliant
 Software Safety Lifecycle (SSL). In this process, the QP framework functional model has been
 subjected to a full Hazard and Risk Analysis, which identified all areas of weakness within
-the functional model and API. These findings led to creation of Safety Requirements and risk
+the functional model and API. These findings led to the creation of Safety Requirements and risk
 mitigation by Safety Functions, which were subsequently implemented, verified, and validated.
 The SafeQP frameworks are accompanied by the "SafeQP Certification Kits", which provide
 developers with ready-to-use artifacts, enabling them to save time, mitigate risk, and reduce
@@ -54,27 +56,64 @@ for more information about the SafeQP frameworks and the "Certification Kits".
 > **NOTE:** The SafeQP/C++ edition remain fully API- and functionally compatible with the
 corresponding standard QP/C++ framework. This ensures existing QP/C Applications can transition
 seamlessly to SafeQP/C++ without requiring any modifications. SafeQP/C edition retain QP/C++
-Frameworks' hallmark features, including a small memory footprint, excellent efficiency,
-and hard real-time functionality.
+Frameworks' hallmark features: a small memory footprint, excellent efficiency, and hard
+real-time performance.
 
 
 # Getting Started with QP/C++
-The most recommended way of obtaining QP/C++ is by downloading the
-[QP-bundle](https://www.state-machine.com/#Downloads), which includes QP/C++
-as well as the [QM modeling tool][QM] and the [QTools collection][QTools].
-The main advantage of obtaining QP/C++ bundled together like that is
-that you get all components, tools and examples ready to go.
-
-### Getting Started Resources
-- ["QP/C++ Tutorial"][Tut]
-describes a series of progressively advanced QP/C++ example applications.
-
+The most recommended way to get started with QP/C++ is by
+[__downloading the QP-bundle__](https://www.state-machine.com/#Downloads),
+which includes QP/C as well as the [QM modeling tool][QM] and the
+[QTools collection][QTools]. The main advantage of obtaining QP/C bundled
+together is that you get all components, tools, and _examples_ all ready to go.
+
+> **NOTE:**
+Perhaps the most important fact to remember is that in embedded systems,
+nothing works until everything works. This means that you should always start
+with a _working system_ and gradually evolve it, changing one thing at a time
+and making sure that it keeps working every step of the way.
+
+The provided [__QP/C++ example projects__](examples), such as the super-simple
+[Blinky](examples/arm-cm/blinky_nucleo-u545re/), or a bit more advanced
+[Dining Philosophers Problem (DPP)](examples/arm-cm/dpp_nucleo-u545re/),
+allow you to get started with a __working project__ rather than starting from
+scratch. You should also always try one of the unmodified examples on one
+of the very inexpensive evaluation boards (such as
+[STM32 NUCLEO-U545RE](examples/arm-cm/dpp_nucleo-u545re/stm32-nucleo-u545re.webp))
+that it was designed for, _before_ attempting to immediately adapt the projects
+to your specific hardware. Only once an example project is built and runs on
+the evaluation board, can you use it as a starting point for your specific hardware
+and software development.
+
+
+## Getting Started Resources
 - [Video: "Getting Started with QP Real-Time Event Frameworks"][Video]
 provides instructions on how to download, install, and get started with QP.
 
 - [AppNote: "Getting Started with QP Real-Time Event Frameworks"][AN]
 contains also a tutorial, in which you build a simple "Blinky" application.
 
+- ["QP/C++ Tutorial"][Tut]
+describes a series of progressively advanced QP/C++ example applications.
+
+## QP/C++ Extras
+The open source GPL distribution of QP/C++ can be augmented by the
+["QP/C++ Extras"][QPX/C++], which provide more advanced QP/C++ features, such as:
+- [QS software tracing][QS] component (QP Spy)
+- [QXK real-time kernel][QXK] component
+- Static-analysis configuration and automation scripts for PC-Lint-Plus
+- Test suite (based on the [QUTest trace-based test harness][QUTest])
+that demonstrates 100% lines of code and 100% MC/DC code coverage for QP/C++.
+
+> **NOTE:** The ["QP/C++ Extras"][QPX/C++] are [licensed commercially][Lic] only
+and available to the commercial licensees with the active Support Term. Please contact
+[Quantum Leaps technical support][Sup] to get the matching ["QP/C++ Extras"][QPX/C++]
+for the public QP/C++ version.
+
+> **NOTE:** The ["QP/C++ Extras"][QPX/C++] are also __available for evaluation__
+([upon request][ReqForm]).
+
+
 # Licensing
 The QP/C++ real-time event framework is licensed under the
 [dual licensing model](https://www.state-machine.com/licensing), with
@@ -101,21 +140,6 @@ any open source license and you do not violate your policy.
 are licensed commercially only.
 
 
-## Files Removed from the QP/C++ Open Source GPL Distribution
-Due to the widespread non-compliance with the GPL, as well as infringement on the
-[dual-licensing model of QP frameworks][Lic], the following QP/C++ components
-have been **removed from the open-source GPL distribution**:
-- QS target-resident software tracing component
-- QXK dual-mode kernel
-
-> NOTE: These components are available to the [commercial licensees][Cust] with
-the active Support Term. Please contact [Quantum Leaps technical support][Sup]
-to get the complete QP/C++ framework distribution.
-
-> **NOTE:** To request **evaluation** of the complete QP/C++ framework, please contact
-Quantum Leaps at: https://www.state-machine.com/contact
-
-
 # Documentation
 The online HTML documentation for the **latest** version of QP/C++ is located
 at: https://www.state-machine.com/qpcpp
@@ -146,11 +170,15 @@ If you like this project, please give it a star (in the upper-right corner of yo
    [QP]:     <https://www.state-machine.com/products/qp>
    [QP/C]:   <https://github.com/QuantumLeaps/qpc>
    [QP/C++]: <https://github.com/QuantumLeaps/qpcpp>
+   [QPX/C]:  https://www.state-machine.com/qpc/gs_extras.html>
+   [QPX/C++]: https://www.state-machine.com/qpcpp/gs_extras.html>
    [Cert]:   <https://www.state-machine.com/products/qp#CERT>
    [QM]:     <https://github.com/QuantumLeaps/qm>
    [QTools]: <https://github.com/QuantumLeaps/qtools>
+   [QUTest]: <https://www.state-machine.com/qtools/qutest.html>
    [Lic]:    <https://www.state-machine.com/licensing>
    [Com]:    <https://www.state-machine.com/licensing#Commercial>
+   [ReqForm]: <https://www.state-machine.com/licensing#RequestForm>
    [Cust]:   <https://www.state-machine.com/customers>
    [Sup]:    <mailto:[email protected]>
    [AN]:     <https://www.state-machine.com/doc/AN_Getting_Started_with_QP.pdf>

README.md

@@ -64,30 +64,24 @@ class QEQueue {
         QEvt const * const e,
         std::uint_fast8_t const qsId) noexcept;
     QEvt const * get(std::uint_fast8_t const qsId) noexcept;
-    QEQueueCtr getNFree() const noexcept {
-        return m_nFree;
-    }
-    QEQueueCtr getNMin() const noexcept {
-        return m_nMin;
-    }
-    bool isEmpty() const noexcept {
-        return m_frontEvt == nullptr;
-    }
-    QEvt const *peekFront() const noexcept {
-        return m_frontEvt;
-    }
+    std::uint16_t getFree() const noexcept;
+    std::uint16_t getUse() const noexcept;
+    std::uint16_t getMin() const noexcept;
+    bool isEmpty() const noexcept;
+    QEvt const *peekFront() const &;
+    QEvt const *peekFront() &&
+        // ref-qualified reference (MISRA-C++:2023 Rule 6.8.4)
+        = delete;
 
 private:
-    QEvt const * volatile m_frontEvt;
+    QEvt const * m_frontEvt;
     QEvt const * * m_ring;
     QEQueueCtr m_end;
-    QEQueueCtr volatile m_head;
-    QEQueueCtr volatile m_tail;
-    QEQueueCtr volatile m_nFree;
+    QEQueueCtr m_head;
+    QEQueueCtr m_tail;
+    QEQueueCtr m_nFree;
     QEQueueCtr m_nMin;
 
-    QEQueue(QEQueue const & other) = delete;
-    QEQueue & operator=(QEQueue const & other) = delete;
     void postFIFO_(
         QEvt const * const e,
         void const * const sender);

examples

@@ -31,7 +31,7 @@
 
 namespace QP {
 
-using QSchedStatus = std::uint_fast8_t;
+using QSchedStatus = std::uint8_t;
 
 } // namespace QP
 
@@ -58,7 +58,7 @@ extern QK_Attr QK_priv_;
 namespace QP {
 namespace QK {
 
-QSchedStatus schedLock(std::uint_fast8_t const ceiling) noexcept;
+QSchedStatus schedLock(std::uint8_t const ceiling) noexcept;
 void schedUnlock(QSchedStatus const prevCeil) noexcept;
 void onIdle();
 
@@ -97,14 +97,17 @@ void onIdle();
     } \
 } while (false)
 
-// QF event pool customization for QK...
-#define QF_EPOOL_TYPE_ QMPool
+// QMPool operations
+#define QF_EPOOL_TYPE_  QMPool
 #define QF_EPOOL_INIT_(p_, poolSto_, poolSize_, evtSize_) \
     (p_).init((poolSto_), (poolSize_), (evtSize_))
-#define QF_EPOOL_EVENT_SIZE_(p_) ((p_).getBlockSize())
+#define QF_EPOOL_EVENT_SIZE_(p_)  ((p_).getBlockSize())
 #define QF_EPOOL_GET_(p_, e_, m_, qsId_) \
     ((e_) = static_cast<QEvt *>((p_).get((m_), (qsId_))))
 #define QF_EPOOL_PUT_(p_, e_, qsId_) ((p_).put((e_), (qsId_)))
+#define QF_EPOOL_USE_(ePool_)   ((ePool_)->getUse())
+#define QF_EPOOL_FREE_(ePool_)  ((ePool_)->getFree())
+#define QF_EPOOL_MIN_(ePool_)   ((ePool_)->getMin())
 
 #endif // QP_IMPL