Readers' feedback

This book and the free QP download are your entry into the 21st century of embedded systems programming. Because the code is provided in C, porting is rather easy and running on embedded systems and desktop systems is practical and easy. I was able to build and run the code as provided without modifications on my Linux, Mac and Windows systems and on the H8S and a Microchip PIC 24 with only a minimalist porting effort of about a half a day in each case."

Rob Wehrli (Knoxville, TN), Amazon.com review

...the author brings such clarity and insight to the value and application of UML Statecharts, that this book is an essential read for anyone who is even thinking of using finite state or hierarchical state machines."

Jonathan Kaye (Philadelphia, PA USA), Amazon.com review

The QP framework is simplified to the point where the developer only focuses on the actual application and need not worry about the underlying kernel, queuing mechanisms, tasks, etc. However, if the developer decides to understand what is executing 'under the hood' per se, the book goes through in detail all the intricacies of the infrastructure."

Thanh Tieu (Los Angeles, CA USA), Amazon.com review

This book took me from being a C programming novice, to writing 1000s of lines of embedded control systems code, that has been running reliably for several years, with just one bug - my own!"

Dr. Haitham Hindi, (Palo Alto, CA), Amazon.com review

For guys like me, who have spent years searching for a way to generate powefull real-time, scalable, elegant, cost effctive (especially in memory size) and maintenable source code, this book is a real PEARL."

Ricardo D. Raupp, Amazon.com review

Framework-based software tracing generates the true, precisely timestamped records of what's happening in the system, even without adding any instrumentation to the application. This is possible because the framework controls the application."

Robert Berger, (Athens, Attika Greece), Amazon.com review

The strong point of the book are many figures which clearly illustrate the author's ideas... The C/C++ code itself is clean, nicely structured and intertwined with the explanations... Because of these features I use the book as an educational aid for the graduates who join my team and need some introduction to real commercial programming."

Cezary Zieniewicz (Wroclaw, Poland), Amazon.com review

more Amazon.com reviews

Choose the best online deal...

Practical UML Statecharts in C/C++, Chinise Translation

Practical UML Statecharts in C/C++, Second Edition: Event-Driven Programming for Embedded Systems

The most popular book about UML statecharts and event-driven programming for embedded systems. This ultimate resource describes all the related concepts and provides a very detailed design study of the QP™ frameworks.

Author:	Miro Samek
ISBN-10:	0750687061
ISBN-13:	978-0750687065
Category:	Embedded Systems / Programming / Software
Publisher:	Newnes (imprint of Elsevier)
Published:	October 1, 2008
Pages:	728 pages (paperback)

Excerpts:	Excerpts (Chinese):

Related Resources and Tools

The following table provides the links for downloading all the tools used in the book as well as other resources.

	Updates and Errata for the book provides corss-referenced error corrections and changes made to the QP frameworks since the publication of the book. The PDF document is searchable by page number, section number, and update type. Last updated for QP 4.3.00 on 09-Jan-2012. download Updates and Errata (PDF 0.8MB)
	QP™ is is a family of lightweight, open source, state machine frameworks, which are like modern real-time operating systems for executing event-driven hierarchical state machines (UML statecharts). The book provides a very detailed description and design study of the QP framewroks. download the latest version of QP™
	QM™ (QP™ Modeler) is a free graphical modeling UML tool for designing and implementing real-time embedded applications based on the QP™ state machine frameworks. QM™ provides best-in-class, intuitive diagramming environment and generates very compact C or C++ code. download the latest version of QM™
	QTools™ Collection contains various open source tools for working with the QP state machine frameworks, such as: (1) QSPY host application, (2) QCLEAN for cleanup of source code files, (3) QFSGEN for generating ROM-based file systems for embedded web servers, and (4) QUDP for testing UDP connectivity. The Qtools for Windows provides also the latest GNU make for Windows and realated file utilities (`rm`, `touch`, etc.) download the latest version of QTools™
	QP Development Kits contain QP ports to various CPUs, operating systems, and compilers. Please keep checking this webpage, as new ports are added frequently. check available QDKs
	The book describes the QP port to ARM Cortex-M3 with the cooperative kernel in Chapter 8, but the port to the preemptive QK kernel is not explained. The following Quantum Leaps Application Notes describe in detail all aspects of using QP with ARM Cortex-M0/M3 processors. download Application Note "QP and ARM Cortex-M with IAR" download Application Note "QP and ARM Cortex-M with GNU"
	To demonstrate modern embedded systems programming with QP, the accompanying code includes examples for the inexpensive ARM Corterx-M3-based Stellaris EKI-LM3S811 evaluation kit form Texas Instruments. The Cortex-M3 examples use the exact same source code as the DOS counterparts, and differ only in the Board Support Package (BSP). The complete EKI-LM3S811 development kit with cables and development tools on CD-ROM is available for around $50 from many online distributors, such as ARROW or MOUSER. Once on the distributor's website, you need to search for "EKI-LM3S811". EKI-LM3S811 Board User's Manual (0.6MB PDF) EKI-LM3S811 kit web-page
	The ARM Cortex examples for IAR require the the IAR EWARM toolset. The 32KB-limited KickStart edition of IAR toolset for ARM is included in the EKI-LM3S811 Stellaris kit and is also available for a free download from IAR. NOTE: The IAR EWARM 5.11 described in the book has now been superseded by the new version 6.30. download IAR EWARM
	The ARM Cortex examples for GNU require the GNU-based Sourcery CodeBench toolset. To dowload the code to the target board and debug it, you need the Sourcery CodeBench Professional Edition, which includes the Sourcery Debug Sprite for ARM. The 30-day evaluation version of Sourcery CodeBench for ARM is included in the EKC-LM3S811 Stellaris kit. download Sourcery CodeBench
	Much of the code accompanying the book is highly portable C or C++ independent really on any particular CPU, operating system, or compiler. However, to focus the discussion, many of the examples provided in the code are available for x86 PC running DOS or DOS emulation. The legacy 16-bit DOS has been chosen as a demonstration platform because it allows programming a standard x86-based PC at the bare-metal level. Without leaving your desktop, you can work with interrupts, directly manipulate CPU registers, and directly access the I/O space. No other modern 32-bit development environment for the standard PC allows this much so easily. The additional advantage of the legacy DOS platform is the availability of mature and free tools and DOS emulators. To that end, the examples are compiled with the Open Watcom toolchain, which is available for a free download. The DOS examples can also execute in the DOSBox x86 emulator on platforms that don't support DOS. NOTE: The Open Watcom toolchain now replaces the Turbo C++ 1.01 toolchain referenced in the book, because the Trubo C++ 1.01 compiler is no longer available for a free download. In contrast, Open Watcom is licensed under an OSI-certified open source license, which allows free commercial and non-commercial use. NOTE: The Open Watcom for DOS installer is itself a DOS application and will not run on systems that cannot execute 16-bit DOS applications. For those systems you can execute the installer in the DOSbox described below. download open-watcom-c-dos-1.9.exe (80MB)
	DOSBox emulates a full x86 PC with DOS, graphics, and sound on platforms which don't have DOS, such as 64-bit Windows, Linux/FreeBSD, and Mac OS X. Starting from release 4.1.04, all QP examples for DOS are compatible with DOSBox, which means that all DOS examples not only run in DOSBox, but you can use the provided make scripts to build the examples in DOSBox (requires the Open Watcom compiler for DOS). NOTE: DOSBox uses a keyboard mapping in which the backslash '\' is not always available. In this case, you typically can use the forward slash '/' as the directory separator. Also, to use DOSBox for executing and building QP examples, it is recommended to place the following commands in the `[autoexec]` section of the DOSBox configuration file (on Windows 7, DOSBox configuration file is located in `C:\Users\<user>\AppData\Local\DOSBox\dosbox-0.73.conf`, on Windows XP, it is located in `C:\Documents and Settings\<user>\Local Settings\Application Data\DOSBox\dosbox-0.73.conf`): [autoexec] mount c c:\ mount d d:\ path c:\tools\WATCOM\BINW download DOSBox for your platform
	Some examples in this book run on Linux, as well as any other POSIX-compliant operating system, such as BSD, QNX, Max OS X, or Solaris. You can also build the Linux examples on Windows under Cygwin.
	To demonstrate really small, ultra-low power embedded system, Chapter 12 of the book describes QP-nano examples for the inexpensive MSP430-based eZ430-F2013 USB Stick from Texas Instruments. The MSP430 examples use the free 4KB-limited KickStart edition of the IAR EW430 toolset. visit eZ430 kit website at TI
	The book uses the Micrium µC/OS-II as an example for porting QP to a conventional RTOS. µC/OS-II has been chosen, because it is superbly documented in the excellent book "MicroC-OS-II The Real Time Kernel" by Jean J. Labrosse. visit >µC/OS-II website at Micrium
	Chapter 2 of the book discusses the Visual Basic calculator sample application that shipped in millions of copies with Microsoft Visual Basic. The provided ZIP file contains the calculator source code, the executable, and the Visual Basic DLL required to run the example. download the VB calculator example
	Search our free support discussion forum on SourceForge.net for answers or post your questions to the QP community. Visit free support discussion forum

About the examples

Compared to the first edition, this book presents more examples of event-driven systems and the examples are more complete. Significant effort has been made to come up with examples that are not utterly trivial yet don't obscure the general principles in too many details. The examples have been carefully chosen so that they don't require any specific domain knowledge.

		"Fly 'n' Shoot" game example (Chapters 1, 12) The "Fly 'n' Shoot" game demonstrates a complete, non-trivial, real-time project implemented with the event-driven paradigm and UML state machines. Several version of the game are provided for QP/C, QP/C++, and QP-nano (versions for non-preemptive "vanilla" kernel and the preemptive QK kernel are provided).
		QHsmTst example (Chapter 2) The semantics of Hierarchical State Machines (UML statecharts) is rich and can raise many questions. The exhaustive QHsmTst example can answer all such questions in an interactive and fun way. To use the example, you launch the qhsmtst.exe executable (included in the accompanying code) and inject events to the state machine by typing letters a..i on your keyboard (the Esc key terminates the application). You correlate the instrumented printouts from every event action, entry/exit actions, initial transitions, and regular transitions with the state diagram in Figure 2.11 (page 88).
		Calculator example (Chapters 2, 4) The Calculator example demonstrates how to design quite a complex behavior with a hierarchical state machine and how to implement it with QEP.
		Time Bomb examples (Chapter 3) The series of four Time Bomb examples demonstrate various standard state machine implementation techniques in C and C++. The example techniques include: "Nested-switch Statement", "State-Table", the object-oriented "State" design pattern (C++ version only), and the FSM implementation with QEP.
		State pattern examples (Chapter 5) The series of five examples demonstrate all five state design patterns discussed in Chaper 5, which are: "Ultimate Hook", "Reminder", "Deferred Event", "Orthogonal Component", and "Transition to History". Executable versions for each design pattern for QP/C, QP/C++, and QP-nano are provided.
		Dining Philosopher Problem (DPP) example (Chapter 9) The DPP example shows relatively simple application used for testing various QP ports. The DPP example requires minimal target resources, such as a few LEDs to show the status of the Dining Philosophers. Executable versions of this example application are available in every QP Development Kit (QDK).
		PEdestrian LIght CONtrolled (PELICAN) crossing example (Chapter 12) The PELICAN crossing example demonstrates a non-trivial, but very lightweight hierarchical state machine that is ideal for testing QP-nano applications on very small MCUs. In Chapter 12, the PELICAN crossing example runs on the eZ430-F2013 USB-stick evaluation platform with just 128 bytes of RAM and 2KB of ROM.

About the book

PSiCC2 and Development Kits from Luminary Micro and TI

Practical UML Statecharts in C/C++, Second Edition bridges the gap between high-level abstract concepts of the Unified Modeling Language (UML) and the actual programming aspects of modern hierarchical state machines (UML statecharts). The book describes a lightweight, open source, event-driven infrastructure, called QP that enables direct manual coding UML statecharts and concurrent event-driven applications in C or C++ without big tools.

The book is presented in two parts. In Part I, you get a practical description of the relevant state machine concepts starting from traditional finite state automata to modern UML state machines followed by state machine coding techniques and state-machine design patterns, all illustrated with executable examples. In Part II, you find a detailed design study of a generic real-time framework indispensable for combining concurrent, event-driven state machines into robust applications. Part II begins with a clear explanation of the key event-driven programming concepts such as inversion of control (Hollywood Principle), blocking versus non-blocking code, run-to-completion (RTC) execution semantics, the importance of event queues, dealing with time, and the role of state machines to maintain the context from one event to the next. This background is designed to help software developers in making the transition from the traditional sequential to the modern event-driven programming, which can be one of the trickiest paradigm shifts.

The lightweight QP event-driven infrastructure goes several steps beyond the traditional real-time operating system (RTOS). In the simplest configuration, QP runs on bare-metal microprocessor, microcontroller, or DSP completely replacing the RTOS. QP can also work with almost any OS/RTOS to take advantage of the existing device drivers, communication stacks, and other middleware. The accompanying website to this book contains complete open source code for QP, ports to popular processors and operating systems, including 80x86, ARM Cortex-M3, MSP430, and Linux, as well as all examples described in the book.

About the audience

Practical UML Statecharts in C/C++, Second Edition is intended for the following software developers interested in event-driven programming and modern state machines:

Embedded programmers and consultants will find a complete, ready-to-use, event-driven infrastructure, called QP, to develop applications in C or C++. The book describes both coding strategies for implementing UML state machines (statecharts) and, equally importantly, a compatible real-time framework for executing concurrent state machines. These two elements are synergistically complementary, and one cannot reach its full potential without the other.
Embedded developers looking for a real-time kernel or RTOS will find that the QP event-driven platform can do everything what one might expect from an RTOS and that, in fact, QP actually contains a fully-preemptive real time kernel as well as a simple cooperative scheduler.
Designers of ultra low-power systems, such as wireless sensor networks, will find how to scale down the event-driven, state machine-based approach to fit the tiniest MCUs. The ultra-light QP-nano version (Chapter 12) combines a hierarchical event processor, a real-time framework, and either cooperative or fully preemptive kernel in just 1-2KB of ROM.
On the opposite end of the complexity spectrum, designers of very large-scale, massively-parallel server applications will find that the event-driven approach combined with hierarchical state machines scales up easily and is ideal for managing very large numbers of stateful components, such as client sessions, where per-component efficiency is critical.
Open source community will find that QP complements other open source software, such as Linux.
System architects might find in QP a lightweight alternative to heavyweight design automation tools.

Due to the code-centric approach, this book will primarily appeal to software developers tasked with creating actual, working code, as opposed to just modeling. This book does not provide yet another CASE tool. Instead, this book is about practical, maintainable coding techniques for UML state machines, and about combining concurrent state machines into robust event-driven systems by means of a real-time framework.

About the author

Dr. Miro Samek is founder and president of Quantum Leaps, an open source company providing lightweight, state machine-based, event-driven application frameworks for embedded systems. He is the author of Practical Statecharts in C/C++ (CMP Books, 2002), has written numerous articles for magazines, including a column for C/C++ Users Journal, is a regular speaker at the Embedded Systems Conferences, and serves on the editorial review board of the Embedded Systems Design magazine. For a number of years, he worked in various Silicon Valley companies as an embedded software architect and before that he worked as an embedded software engineer at GE Medical Systems (now GE Healthcare). Dr. Samek earned his Ph.D. in nuclear physics at GSI (Darmstadt, Germany).

Last updated: January 09, 2012