Skip to content

Commit

Permalink
8.0.2
Browse files Browse the repository at this point in the history
  • Loading branch information
@quantum-leaps
quantum-leaps committed Jan 21, 2025
1 parent 12c924a commit 6d29ea6
Show file tree
Hide file tree
Showing 119 changed files with 3,209 additions and 12,440 deletions.
36 changes: 17 additions & 19 deletions LICENSES/LicenseRef-QL-commercial.txt
View file
Original file line number Diff line number Diff line change
Expand Up @@ -7,16 +7,16 @@ licenses designed for licensees interested in retaining the proprietary
status of their code.

The Quantum Leaps commercial licenses expressly supersede the GPL open source
license. This means that when you license the QP/C or QP/C++ Real-Time
license. This means that when you license the QP/C or QP/C++ Real-Time
Embedded Frameworks under a Quantum Leaps commercial license, you specifically
do not use the software under the open source license and therefore you are
not subject to any of its terms.

Quantum Leaps commercial licensing options are described below:


Single Product License
----------------------
SPDX-License-Identifier: LicenseRef-QL-Single-Product
-----------------------------------------------------
Single Product License allows a given company ("Licensee") to embed the
specified type(s) of the QP Real-Time Embedded Framework(s) into one end-
product of the Licensee (Single Product). Licensee can distribute/sell an
Expand All @@ -33,8 +33,8 @@ Volume discounts are offered if several Single Products are licensed at once
with one license agreement.


Product Line License
--------------------
SPDX-License-Identifier: LicenseRef-QL-Product-Line
---------------------------------------------------
Product Line License allows a given company ("Licensee") to embed the
specified type(s) of the QP Real-Time Embedded Framework(s) into any number
of end-products within a family of related products (Product Line). Licensee
Expand All @@ -44,17 +44,17 @@ Product Line. Product Line License applies to all end-products that do
similar functions within the same Product Line.


Any-Product License
-------------------
SPDX-License-Identifier: LicenseRef-QL-Any-Product
--------------------------------------------------
Any-Product License allows a given company ("Licensee") to embed the
specified type(s) of the QP Real-Time Embedded Framework(s) into any end-
product of that company. The Licensee can distribute/sell an unlimited number
of the products containing the licensed QP framework type(s) (royalty-free
licensing).


Site License
------------
SPDX-License-Identifier: LicenseRef-QL-Site
-------------------------------------------
Site-License allows a given company ("Licensee") to embed the specified
type(s) of the QP Real-Time Embedded Framework(s) into any end-customer
product, as long as the products are designed at a given physical location
Expand All @@ -64,8 +64,8 @@ designed for development contractors and consultants, who develop embedded
software for other companies.


OEM License
-----------
SPDX-License-Identifier: LicenseRef-QL-OEM
------------------------------------------
OEM License allows a given company ("Licensee") to embed the specified
type(s) of the QP Real-Time Embedded Framework(s) in any product of that
company (Original Equipment Manufacturer) and gives limited sublicensing
Expand All @@ -74,14 +74,12 @@ affiliates. OEM licenses are customizable to match exactly the specific
licensing needs of a given Licensee.


Education License
-----------------
Education License allows a given accredited educational institution
("Licensee") to use and embed the specified type(s) of the QP Real-Time
Embedded Framework(s) in any project completed at that educational
institution. To be eligible for this license, the institution must be
focused mainly on teaching students. The Education Licenses are free
and will be granted liberally upon request.
SPDX-License-Identifier: LicenseRef-QL-Eval
-------------------------------------------
Evaluation License allows a specific company ("Licensee") to temporarily
use the specified type(s) of the QP Real-Time Embedded Framework(s) for
in-house evaluation. This license expressly prohibits any distribution
of the licensed QP software.


****
Expand Down
9 changes: 5 additions & 4 deletions LICENSES/LicenseRef-QL-dual.qlc
View file
Original file line number Diff line number Diff line change
@@ -1,6 +1,7 @@
public
qpc
2025-12-31

Copyright (C) 2005 Quantum Leaps, LLC. All rights reserved.

Q u a n t u m L e a P s
Expand All @@ -9,9 +10,9 @@ Copyright (C) 2005 Quantum Leaps, LLC. All rights reserved.

SPDX-License-Identifier: GPL-3.0-or-later OR LicenseRef-QL-commercial

The QP/C software is dual-licensed under the terms of the open-source GNU
General Public License (GPL) or under the terms of one of the closed-
source Quantum Leaps commercial licenses.
This software is dual-licensed under the terms of the open-source GNU
General Public License (GPL) or, alternatively under the terms of one of
the closed-source Quantum Leaps commercial licenses.

Redistributions in source code must retain this top-level comment block.
Plagiarizing this software to sidestep the license obligations is illegal.
Expand All @@ -25,4 +26,4 @@ closed-source distribution.
Quantum Leaps contact information:
<www.state-machine.com/licensing>
<[email protected]>
#2BACD81DCE8ED122C193E4F48A14170D660DFF1E
#1671FF5623AF7CA93973FA6EC044A008F7F65702
124 changes: 52 additions & 72 deletions README.md
View file
Original file line number Diff line number Diff line change
Expand Up @@ -16,6 +16,39 @@ git clone https://github.com/QuantumLeaps/qpc --recurse-submodules --depth 1
Alternatively, you can also download one of the stable
[QP/C Releases][QP-Rel].

# About QP/C Real-Time Embedded Framework
QP/C real-time embedded framework (RTEF) is a lightweight implementation of
the [Active Object (a.k.a. Actor) model of computation][AOmod] specifically
tailored for deeply embedded real-time systems, such as microcontrollers (MCUs).
QP/C is both a software infrastructure for building applications consisting
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
system (RTOS).

## QP Framework Family
QP/C framework is part of the larger QP family consisting of the following
QP editions:

|QP Edition | Language | API | Safety Functions |Certification Artifacts| Licensing
|:----------|:-----------:|:-----------------|:-------------------|:----------------|:---------
| QP/C | C (C11) |same as SafeQP/C |Selected Assertions |Req/Arch/Design | [dual][Lic]
| SafeQP/C | C (C11) |same as QP/C |All Safety Functions|Certification Kit| [commercial][Com]
| QP/C++ | C++ (C++17) |same as SafeQP/C++|Selected Assertions |Req/Arch/Design | [dual][Lic]
| SafeQP/C++| C++ (C++17) |same as QP/C++ |All Safety Functions|Certification Kit| [commercial][Com]

[The documentation](#documentation) of all QP editions includes the
[Requirements][SRS], [Architecture][SAS], and [Design Specifications][SDS],
which are the best source of information about the underlying concepts,
functionality, architecture, and design of the QP Frameworks and the QP
Applications based on the frameworks.

> **NOTE:** The **SafeQP** frameworks additionally contain **Safety Functions**
required to achieve the higher safety integrity levels and come with much more
extensive [Certification Kits][Cert].


# Getting Started with QP/C
The most recommended way of obtaining QP/C is by downloading the
Expand All @@ -25,7 +58,7 @@ 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"][Tutorial]
- ["QP/C Tutorial"][Tut]
describes a series of progressively advanced QP/C example applications.

- [Video: "Getting Started with QP Real-Time Embedded Frameworks"][Video]
Expand Down Expand Up @@ -67,69 +100,11 @@ have been **removed from the open-source GPL distribution**:
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
> **NOTE:** To request **evaluation** of the complete QP/C framework, please contact
Quantum Leaps at: https://www.state-machine.com/contact

# About QP/C
QP/C (Quantum Platform in C) is a lightweight, open source
[Real-Time Embedded Framework (RTEF)][RTEF] for building modern embedded
software as systems of asynchronous, event-driven [Active Objects][Active]
(actors). The [QP/C] framework is a member of a [QP] family consisting of
[QP/C] and [QP/C++] frameworks, which are strictly quality controlled,
thoroughly documented, and [commercially licensable][Lic].

## Safer Model of Concurrency
The [QP] framework family implements the
[Active Object model of computation][AO_model], which is **inherently safer**
than the traditional "shared state concurrency" based on explicit mutual
exclusion and managing RTOS threads by blocking. The Active Object model
supports and automatically enforces the following best practices
of concurrent programming:

- Keep data isolated and bound to Active Objects' threads. Threads should
hide (**encapsulate**) their private data and other resources, and not
share them with the rest of the system.

- Communicate among Active Object threads **asynchronously** via [Event
objects][Event]. Using asynchronous events keeps the threads running truly
independently, **without blocking** on each other.

- Active Object threads should spend their lifetime responding to incoming
events, so their mainline should consist of an **event-loop** that handles
events one at a time (to completion), thus avoiding any concurrency hazards
within an Active Object thread itself.

This architecture also provides higher level of abstraction and the *correct*
abstractions to effectively apply [Hierarchical State Machines][HSM],
**modeling** and **code generation** to deeply embedded real-time systems.

## Hierarchical State Machines
The behavior of Active Objects is specified in QP/C by means of
[Hierarchical State Machines][HSM] (UML statecharts). The framework
supports manual coding of UML state machines in C as well as automatic
**code generation** by means of the free [QM modeling tool][QM].

## Built-in Real-Time Kernels
The QP/C framework can run on standalone on single-chip microcontrollers,
without any traditional RTOS. The framework contains a selection of
**built-in real-time kernels**, such as the [non-preemptive QV kernel][QV],
the [preemptive non-blocking QK kernel][QK], and the preemptive,
[dual-mode QXK kernel][QXK] that provides all the features you might expect
from a traditional RTOS. Native QP ports and ready-to-use examples are provided
for major CPUs, such as ARM Cortex-M (M0/M0+/M3/M4/M7/M23/M33/...).

## Traditional RTOS/OS
QP/C can also work with a traditional RTOS, such as ThreadX, embOS, FreeRTOS,
uC/OS-II and Zephyr, as well as with (embedded) Linux (POSIX) and Windows.

## Popularity and Maturity
With 20 years of continuous development, [400+ commercial licensees][Cust],
and many times more open source users worldwide, the QP frameworks are the
most popular such offering on the market. They power countless electronic
products ranging from implantable medical devices to complex weapon systems.


# QP/C Documentation

# Documentation
The online HTML documentation for the **latest** version of QP/C is located
at: https://www.state-machine.com/qpc

Expand Down Expand Up @@ -159,20 +134,25 @@ 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>
[QS/C]: <https://www.state-machine.com/qpc/srs-qp_qs.html>
[QV]: <https://www.state-machine.com/qpc/srs-qp_qv.html>
[QK]: <https://www.state-machine.com/qpc/srs-qp_qk.html>
[QXK]: <https://www.state-machine.com/qpc/srs-qp_qxk.html>
[Cert]: <https://www.state-machine.com/products/qp#CERT>
[QM]: <https://github.com/QuantumLeaps/qm>
[QTools]: <https://github.com/QuantumLeaps/qtools>
[QP-Rel]: <https://github.com/QuantumLeaps/qpc/releases>
[Active]: <https://www.state-machine.com/qpc/srs-qp_ao.html>
[AO_model]: <https://www.state-machine.com/qpc/srs-qp_ao.html#srs-qp_ao-model>
[Event]: <https://www.state-machine.com/qpc/srs-qp_evt.html>
[HSM]: <https://www.state-machine.com/qpc/srs-qp_sm.html>
[Lic]: <https://www.state-machine.com/licensing>
[Com]: <https://www.state-machine.com/licensing#Commercial>
[Cust]: <https://www.state-machine.com/customers>
[Sup]: <mailto:[email protected]>
[AN]: <https://www.state-machine.com/doc/AN_Getting_Started_with_QP.pdf>
[Tutorial]: <https://www.state-machine.com/qpc/gs_tut.html>
[Video]: <https://youtu.be/O7ER6_VqIH0>
[QS]: <https://www.state-machine.com/qpc/srs-qp_qs.html>
[QV]: <https://www.state-machine.com/qpc/srs-qp_qv.html>
[QK]: <https://www.state-machine.com/qpc/srs-qp_qk.html>
[QXK]: <https://www.state-machine.com/qpc/srs-qp_qxk.html>
[SRS]: <https://www.state-machine.com/qpc/srs-qp.html>
[SAS]: <https://www.state-machine.com/qpc/sas-qp.html>
[SDS]: <https://www.state-machine.com/qpc/sds-qp.html>
[Active]: <https://www.state-machine.com/qpc/srs-qp_ao.html>
[AOmod]: <https://www.state-machine.com/qpc/srs-qp_ao.html#srs-qp_ao-model>
[Event]: <https://www.state-machine.com/qpc/srs-qp_evt.html>
[HSM]: <https://www.state-machine.com/qpc/srs-qp_sm.html>
[QP-Rel]: <https://github.com/QuantumLeaps/qpc/releases>
[Tut]: <https://www.state-machine.com/qpc/gs_tut.html>
2 changes: 1 addition & 1 deletion examples
Submodule examples updated 654 files
Loading

0 comments on commit 6d29ea6

Please sign in to comment.