/*! @mainpage About QP/C™
@tableofcontents
@section ab_about What is it?
QP/C™ (Quantum Platform in C) is a lightweight, open source active object (actor) framework for building responsive and modular real-time embedded applications as systems of cooperating, event-driven active objects (actors). The QP/C™ framework is a member of a larger family consisting of QP/C, QP/C++, and QP-nano frameworks, which are all strictly quality controlled, thoroughly documented, and available under @ref licensing "dual licensing model".
@attention
To use QP/C™ effectively, you need to understand the key concepts that underline the architecture of the framework and your applications based on the framework.
------------------------------------------------------------------------------
@htmlonly
@endhtmlonly
@section ab_goals What does it do?
The main goals of the QP/C™ framework are:
- to provide a reusable **architecture** based on active objects (actors), which is _safer_ and easier to understand than "free-threading" with a traditional RTOS.
- to provide a simple-to-use coding techniques for hierarchical state machines, with which to implement the behavior of active objects.
- to provide efficient and thread-safe event-driven mechanisms for active objects to communicate, such as direct event passing and publish-subscribe.
- to provide event-driven timing services (time events).
- to provide a selection of built-in real-time kernels to run the QP applications, such as the cooperative @ref qv "QV kernel", the preemptive non-blocking @ref qk "QK kernel", and the preemptive blocking @ref qxk "QXK kernel".
- to provide testing support for applications based on software tracing (@ref qs "Q-Spy").
- to provide portability layer and ready-to-use ports to @ref ports_rtos "3rd-party RTOSes" and desktop operating systems such as @ref posix "Linux" and @ref win32 "Windows".
- to provide a target for modeling and automatic code generation from the QM modeling tool.
------------------------------------------------------------------------------
@section ab_special What's special about it?
The QP/C™ framework is a unique offering on the embedded software market. It provides a modern, reusable **architecture** of embedded applications, which combines object-orientation with the particular model of concurrency, known as active objects (actors). This architecture is generally **safer**, more responsive and easier to understand than naked threads of a Real-Time Operating System (RTOS).
@subsection oop Object Orientation
Even though it is written in @ref misra "MISRA-compliant" ANSI-C, QP/C™ is fundamentally an **object-oriented** framework, which means that the framework itself and your applications derived from the framework are fundamentally composed of classes and only classes can have @ref sm "state machines" associated with them.
@note
If you program in C and object-oriented programming is new to you, please refer to the Application Note "Simple Object-Oriented Programming in C", which describes how you can implement the concepts of _classes_, _inheritance_, and _polymorphism_ to portable ANSI-C.
@htmlonly
Application Note: Object-Oriented Programming in C
@endhtmlonly
@subsection lightweight Lightweight
The most unique characteristic of the QP/C™ framework is its very small footprint, especially in RAM. In this respect, QP/C™ requires less resources than even the smallest conventional Real-Time Operating System (RTOS) kernel. At the same time, QP gives you a much higher level of abstraction than a conventional RTOS. With QP, you work at the level of active objects, state machines and events, as opposed to "naked" threads of an RTOS.
@subsection hsms Hierarchical State Machines
The behavior of active objects is specified in QP by means of
hierarchical state machines (UML statecharts). The frameworks support manual coding of UML state machines in C or C++ as well as fully automatic code generation by means of the free graphical QM™ modeling tool.
@subsection kernels Built-in Kernels
All QP/C™ framework can run on @ref exa_native "bare-metal single-chip microcontrollers", completely replacing a traditional RTOS. The framework contain a selection of built-in real-time kernels, such as the cooperative @ref comp_qv "QV kernel", the preemptive non-blocking @ref comp_qk "QK kernel", and the preemptive, blocking @ref comp_qxk "QXK kernel", which provides all the features you might expect from a traditional RTOS kernel. @ref ports_native "Native QP ports" and ready-to-use @ref exa_native "examples" are provided for major @ref exa_ref_mcu "CPU families".
@subsection inter Interoperability
QP/C can also work with many traditional @ref exa_rtos "RTOSes" and @ref exa_rtos "desktop OSes" (such as Windows and Linux).
@subsection maturity Maturity
The QP™ family of embedded active object frameworks is one of the most mature in its class. It has been developed and refined for over 15 years.
The QP™ frameworks are used in millions of products worldwide in aerospace, medical devices, consumer electronics, wired and wireless telecommunications, industrial automation, transportation, robotics, and many more. The QP™ frameworks and the QM™ modeling tool receive over 40,000 downloads a year.
@subsection psicc2 Book
The book, Practical UML Statecharts in C/C++, 2nd Edition provides a detailed design study of the QP frameworks and explains all the related concepts.
@image html PSiCC2-3D.jpg "Practical UML Statecharts in C/C++, 2nd Edition"
------------------------------------------------------------------------------
@section licensing How is it licensed?
QP/C is licensed under the increasingly popular dual licensing model, in which both the open source software distribution mechanism and traditional closed source software distribution models are combined.
@note If your company has a policy forbidding open source in your product, all QP frameworks can be licensed commercially, in which case you don't use any open source license and you do not violate your policy.
@subsection open-source Open Source Projects
If you are developing and distributing open source applications under the GNU General Public License (GPL), as published by the Free Software Foundation, then you are free to use the Quantum Leaps software under the GPL version 3 of the License, or (at your option) any later version. Please note that GPL requires that all modifications to the original code as well as your application code (Derivative Works as defined in the Copyright Law) must also be released under the terms of the GPL open source license.
@subsection closed-source Closed Source Projects
If you are developing and distributing traditional closed source applications, you can purchase one of Quantum Leaps commercial licenses, which are specifically designed for users interested in retaining the proprietary status of their code. All Quantum Leaps commercial licenses expressly supersede the GPL open source license. This means that when you license Quantum Leaps software under a 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.
------------------------------------------------------------------------------
@section help How to get help?
Please post any **technical questions** to the Free Support Forum hosted on SourceForge.net. Posts to this forum benefit the whole community and are typically answered the same day.
Direct **Commercial Support** is available to the commercial licensees. Every commercial license includes one year of Technical Support for the licensed software. The support term can be extended annually.
Training and consulting services are also available from Quantum Leaps. Please refer to the Contact web-page for more information.
------------------------------------------------------------------------------
@section contact Contact Information
- Quantum Leaps Web site: www.state-machine.com
- Quantum Leaps licensing: www.state-machine.com/licensing
- QP/QM on SourceForge.net: sourceforge.net/projects/qpc
- e-mail: info@state-machine.com
@image html logo_ql_TM.jpg
Copyright © 2002-2016 Quantum Leaps, LLC. All Rights Reserved.
@next{gs}
*/