At Quantum Leaps we strongly believe that event-driven programming with active objects combined with graphical modeling based on modern hierarchical state machines (UML statecharts) is the best way to go when it comes to developing real-time embedded software. When done properly, these techniques can reduce your development time considerably, and you end up with an actual design that is safer, traceable to code, and easier to understand, test, maintain, extend, and reuse. Also, programming that way can be much more fun than the traditional approach based on "free threading" and "spaghetti code".
Nonetheless, embracing these new paradigms can be a difficult process. On top of the event-driven paradigm, you must master the new concepts of active objects, hierarchical state machines, elements of object-oriented programming and some UML notation. When done improperly, a pseudo-active-object approach can fail miserably, at considerable cost to your company.
This 2- to 3-day training uses hands-on exercises combined with instruction to illustrate the concepts underlying the QP active object frameworks and how they are applied in embedded application development requiring hard real-time performance. Upon completion of the two-day training, participants have a working knowledge of the QP frameworks, good understanding of event-driven systems, skills in designing and implementing UML state machines in C or C++, and the ability to build their own QP applications. Additionally, upon completion of the three-day training, participants gain proficiency in using the QM modeling tool to build effective models and auto-generate code.
Session 1A — Active objects:
This session is designed to help engineers through the paradigm shift from the traditional sequential programming to the modern event-driven programming with active objects. The session covers encapsulation for concurrency, inversion of control, blocking versus non-blocking code, run-to-completion (RTC) execution, asynchronous event passing, event queues, and the role of state machines.
Session 1B — UML state machines:
This session explains state machine concepts, the UML notation and the semantics, including hierarchical state nesting, entry/exit actions, internal transitions, etc. The session culminates with the design of a hierarchical state machine followed by the implementation in C based on the QEP event processor.
Session 2A — QP internals:
This session examines the inner workings of the QP framework, which due to the inversion of control can offer benefits that no traditional RTOS can. The session covers direct event passing, publish-subscribe, time events, zero-copy event management, and automatic garbage collection for events. Attendees also learn how to combine the QP framework with the cooperative "vanilla" kernel, traditional RTOS, and the preemptive, run-to-completion QK kernel.
Session 2B — QP application example:
This session uses the fun "Fly 'n' Shoot" game to explain all the steps necessary to design and hand-code a real-time QP application.
Session 2C — State design patterns:
This session presents four state machine design patterns. Every pattern is illustrated with executable code, which allows attendees to fully understand the pattern and gives them a good starting point for their own implementations.
Session 3A — Modeling with QM™:
This hands-on session introduces the QM™ graphical modeling tool. Attendees buld the complete model of the "Fly 'n' Shoot" game.
Session 3B — Auto-generating code with QM™:
In this session attendees learn how to auto-generate code from the model and how to incorporate QM™ in the full software development lifecycle to work with the third-party tools, such as compilers and debuggers to test and refine the QM model.
Session 3C — Testing and debugging QP applications:
This session discusses the Design by Contract philosophy used in QP and the powerful software tracing facility (Q-SPY) built into the framework that allows unprecedented visibility into a running application.
In order to get the best results participants should have a working knowledge of C, as well as basic knowledge of real-time embedded programming. Previous QP or UML experience is not required.
Dan Smith is an embedded software consultant specializing in bringing the modern event-driven paradigm to embedded software teams, who want to adopt hierarchical finite state machines (UML statecharts), real-time frameworks, modeling, and automatic code generation. He has been one of the earliest adopters of the QP active object frameworks and over the years has accumulated many real-life QP projects under his belt. Firmware he developed lies at the heart of many successful products including consumer electronics, telecom/datacom, industrial controls, and medical devices. Dan enjoys teaching and is a frequent speaker at the Embedded Systems Conferences, the Embedded World Conference, and various other venues. He earned his BSEE at Princeton.
The QP/QM training is delivered on-site at your location. The price of the 2-day QP training in the U.S. is $ 11,000.- and the 3-day training is $ 14,000.-. These prices include all training materials for up to 10 attendees (EFM32-SLSTK3401A development kit, course textbook in PDF, and the USB flash drive) as well as the instructor's time and travel expenses. Each additional attendee beyond the first 10 can be enrolled for $500. Training outside the U.S. can be arranged for additional fee depending on the destination to cover the extra time and travel expenses. Please contact us to reserve the dates or to request more information about the QP/QM Training.