Customer Reviews

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

5 star:		(11)
4 star:		(0)
3 star:		(0)
2 star:		(0)
1 star:		(0)

 

 

If you are an accomplished or aspiring embedded systems programmer and resort to the "superloop" as your foremost implementation method, you absolutely MUST read this book.

While not new concepts to the industry, the concepts presented in Miro's book are certainly not commonplace in many of the embedded systems code I've seen over many years in the industry.

While UML makes for a clean, now defacto standard for presenting concepts, the real beauty in Miro's book is the use of a readily-available frameworks for immediately adopting the many lessons-learned and provided in the book. These complete, well written and excellently coded frameworks are available under the GPL and an alternate, low-cost license for those who wish to keep their code private.

For strong C programmers, the implementation of the frameworks is a delight as one reads through the code and is treated to an incredibly simple, lightweight and extremely powerful system that will forever put an end to your future plans to "superloop" again--albeit for any system where C (or C++) is adequately supported by the hardware. For anyone admitting that "we've always done superloop and it has always worked in the past," get ready for a real-time, highly responsive system that actually IS event driven and thrives in as little as a few bytes of RAM and perhaps a K of ROM.

For those who must hold on to the "superloop is king" mindset, consider the consequences of adding to your superloop an entirely new set of features and how that may affect the timing through your loop. I started with the "dining philosophers" example code discussed in the book and ported it to my own board (using a Renesas H8S-2166 microcontroller) and augmented the code to be responsive to external events (mechanical switches). This required software debouncing. While my "example" was somewhat "trivial" in terms of what the functionality actually did, it is, in my opinion, extremely typical of changing requirements of both new and legacy code in the day-to-day evolution of embedded systems programming.

My changes to the example code were to implement a "bike light" feature set. That is, whenever a switched was pressed, the bike light--if off--would illuminate. An LED on the board was used for this purpose. Pressed again, the light would blink. Pressed and held for 1 second while on or blinking, the light would turn off.

The typical implementation in superloop would often require a considerate approach to ensure that the new functionality was "injected" into the "right" part of the loop, so as to be of minimal impact to other areas of critical timing code. If any kind of action within the new code delayed the loop processing, then the whole of the superloop could come under further scrutiny and therefore cause more pain as one trials and tests system responsiveness on a number of potential new fronts.

Atop of this new functionality, the frameworks-provided QSpy code instrumentation system, which allows one to have a stream of information about the system states and transitions, was ported to use a UART on the H8S. Imagine adding all of this new functionality in a traditional superloop body of code. Now, imagine adding it in a matter of perhaps two hours using the frameworks AND not adversely impacting the "legacy" application code at all!

One of the most beautiful aspects of these frameworks is the ability to focus strictly on the code necessary for the task at hand instead of the entire system as a whole. The frameworks substantially frees the programmer from having to manually manage system responsiveness typical of the superloop.

Using UML to design and document an embedded system is relatively new to many embedded systems programmers. Miro also provides a free download stencil set for MS Visio for easily implementing statecharts, which should help those interested in pursuing the many benefits of the technology included in this book.

I first met Miro at a developer's conference in San Diego, CA. One thing that comes out in his book and his discussions of this exciting technology is his passion for it. I was very interested in it, as he was displaying his software running on a very resource constrained microcontroller--all in about 40 bytes of RAM or a bit less.

Drawn to his topic by his enthusiasm, I admired the frameworks even more as I began looking at the implementation and design of the code. The entire C bundle, with royalty-free 'private commerical use' license, one of either cooperative or preemptive schedulers (both are provided), event processor, code instrumentation support and more is all for under $2K. Of course, one may explore the entire frameworks for the cost of only a free download before ever making a licensing decision for a given product.

Combined with the low-cost solution of using such powerful frameworks in conjunction with learning the valuable content of this book, teams everywhere can exploit the years of experience and very robust, capable code in a matter of hours instead of weeks, months and even years of doing things the "old school" way using superloops and other facilities instead of truly event-driven designs.

This book and the free QF 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. Imagine being able to run an entire real-time system that features excellent extensibility while freeing you from the rigors of managing superloop timing on your own hardware all within a few hours. Then, spend a couple of hours extending the system without impacting the rest of it? Lather, rinse, repeat...it is truly that simple and robust.

Best of all, this book will open your eyes to modern methods and concepts for programming event-driven embedded systems. That is, systems that respond to internal and external events that naturally occur in all embedded systems designs. It is my firm belief that after reading this book and exploring the code on your own, you'll discover why I so heartily endorse it and now share the passion Miro has for this wonderful, very lightweight but robust, complete solution for modern embedded systems programming.

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! This book has been an indispensable resource to me in my work.

Embedded systems programming can be such a perilous task, riddled with potential pitfalls an mistakes that can lead to potentially catastrophic bugs that are virtually impossible to track down. Throughout the text, important practical lessons and good design practices are shared, based on years of real-world experience, which can save novices from countless hours of painful debugging.

The book is amazingly thorough, not only showing you "how", but also teaching you "why". All of the details of the framework and its implementation are clearly described, and the source code is available in the book and online, ready for immediate use on real applications.

Samek does a truly masterful job of constructing an extremely lean yet very powerful framework for safe embedded systems programming. The approach is based on both on proven practical and solid academic foundations, such as: actor oriented programming, UML statecharts, publish-subscribe, design patterns, realtime operating systems, design by contract, etc.

This second edition contains a lot of new material, including: new support for software tracing in event driven systems, along with interfaces to Matlab; a new chapter on QP-nano, an ultra-lightweight event driven infrastructure, that can run on low-end 8- and 16-bit MCUs; the first chapter, which introduces the main ideas and techniques in the book via real-time fly&shoot game was so much fun to read; and numerous new explanations. In addition, the emphasis has shifted from C++ to C, with C++ codes available online. The first edition hit the markets around 2002, and became and instant classic; this second edition will no doubt continue that trend.

- H.H., (Xerox) PARC.

Many years ago Finite State Machine concept saved my life in an embedded software project. Thanks to this practical experience I realized how powerful the state machine concept used in software construction is. At that time the famous "C User Journal" was for me the only source of knowledge about state machines programming.

That is why I was excited when I spotted and read the first edition of the book a few years ago.
The current edition is much thicker - 700 pages in total.
State machines stuff occupy the first 250 pages and in my opinion, this is the mandatory reading for any embedded software engineer. The author starts from "A Crash Course in UML State Machines" which teaches a reader the skills needed to describe Finite State Machines and Hierarchical State Machines in UML.
The next chapter describes a few approaches to FSM implementation. Chapter 4 introduces Hierarchical State Machine implementation using QEP processor . Chapter 5 ends the "State Machine" part of the book with the detailed description of 5 state design patterns.
Going through these 5 chapters gives the reader the deep understanding of how to design state machines using UML and how they can be coded. This knowledge is universal and can be used with any CASE tool as well as for manual coding only.

The second part (nearly 450 pages) is devoted to the description of an inner construction and possible implementations of some kind of RTOS called QP. QP itself consists of Q Event Processor, Q event-driven Framework and Q preemptive Kernel. Part two is opened by the chapter called `Real-Time Framework Concepts'. It is especially useful for somebody who has so far used only home grown embedded systems with main loop and ISR. The chapter makes it clear to the reader what the benefits of using such infrastructure over homemade solution are.
The rest of the book is the detailed description of QP in action. The good information is that the reader learns a lot even if he is not going to use QP. The reason for that is a lot of information which describes general concepts e.g. `Synchronous and Asynchronous Preemptions' which are not specific for QP only.

The strong point of the book are many figures which clearly illustrate the author's ideas. The UML diagrams are used for state machines and class relationships descriptions. For data structures relations non UML notation is used just to show the concept in a convenient way. 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.

Despite the FIRST book was great but I just managed to finish 1/3 of it. The main reasons are the code was mainly in C++ which I didn't know at that time and wasn't very popular in embedded programming; and poor coding style that made coding reading extremely difficult. If you read the first edition and share the same view with me, then now you MUST get the 2nd Edition!!

I'm glad that Miro got rid of the quantum mechanical metaphor :) The biggest change in this book is the code is mainly in C, which make much more sense for embedded programmer. There are line-by-line comments and the descriptions are very detail, I had no problem reading the code, in fact it was quite an pleasant experience.

The hierarchical event processor and real-time framework described are very powerful yet simple tools once you understand it. I applied the technique in creating menu selection, and found adding/deleting nested sub menu incredibly simple. Despite C++ is no longer the main programming language in this book, the concept of the framework still uses object-oriented concept and pointers a lot. In order to fully appreciate the wisdom of the author in writing the code, you should have expert knowledge in using pointers and good understanding in OO. Miro doesn't just want to 'sell' his quantum statechart, he also explains other fundamental yet essential concepts that form the entire ecosystem which includes UML, design pattern and real-time kernel.

This is definitely 'the' software design book that every embedded programmer should have on their bookself.

I first met Dr. Samek at the Embedded Systems Conference in San Francisco, CA. I was drawn in by how simple his QP infrastructure was. Immediately upon reading the 1st edition of his book, I was able to get an embedded system up and running. Not only was the source code helpful, but the examples in the book provided real world applications. With this new 2nd edition, there are even more real world examples to learn from. In addition, the examples are utilizing many different MCU's - e.g. MSP430, ARM Cortex-M3, 80x86, etc.

I have used QP during the last few years both in the professional arena and as a hobbyist. Still today, the state machine framework is executing flawlessly. The concept of having decoupled state machines used to be mainly in academia while industry was more observant of the typical main() + ISR environments. But the trend is moving more toward event driven programming. UML in general can be rather convoluted with nomenclature and semantics that leave the developer questioning what they are getting themselves into. But with QP, the 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.

Furthermore, the GNU GPL provides a great way for new comers to view the source code and see what the platform is all about.

I will not repeat all the details of the book as previous reviewers have. However, I will note that this book is as comprehensive as can be for any embedded engineer who is interested in developing in a revolutionizing environment. Kudos to Dr. Samek!

Reading the other reviews, one might get the impression that this book is mostly geared to embedded systems. If you are an embedded systems developer, this is a no-brainer. However, you might be inclined to pass this up if you do not develop for embedded systems, and that would be a HUGE mistake.

On the surface, this is a technical book geared towards good software practice development on embedded systems, but 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. It seems that statecharts get short-shrift in other books on UML, and certainly don't give the kind of detail as this book in terms of how one implements such an engine (though it seemed more discussion about the implementation were provided in his first book, another must read). I think he wisely focuses on his C implementation, because of its relevance to the Embedded Systems world, but he provides C++ implementations/ports on his web site, [...]. You should also check that out because he also has an active discussion board, so you can communicate directly with him and his team. It was a bit hidden, but here is the page with ports to other languages -- [...]

With this book, you get a rare perspective/combingation of someone who truly understands UML Statecharts and a savvy developer/architect who demonstrates how to exploit the methodology for practical purposes. The implementation is flexible, precise, and elegant -- a true model for professional software development.

For guys, like me, who has spent the last years searching, and coding at the same time!, for a way to generate powefull realtime, scalable, elegant, cost eefctive (memories size) and specially maintenance source code, this book is really a"PEARL".
In fact, you can collect many of Samek approachings over the net, but,have it all inside a book is simply perfect.
It seems you have a big buffet, ranging from hotdogs to salmon speciallities dishes under the same table :)
State machines is a very powerfull approach wich any designer should use extensively, since the begining, for almost everything.
After many years (unfurtenely) I got it ...
Samek put it to work in the middle of a "complete EMBEDDED" system context, I mean, events handling, objects / tasks switching, system exchanging messages etc etc.
He also shows the "prices" to pay for simple vesrsus more sophisticated issues, like cooperative x preemptive OS , simple versus hierarchical state machines.It is a very important point if you don't have endless memory devices.
Well, sometimes to make the thing work is easier then to explain anothers to how and why it is working...Samek made it clearly.
I really appreciated this book and strongly recommend it.

I had the pleasure to get my hands on this book before my talk at the Embedded World Conference about debugging and avoiding bugs [[...]] and discovered framework-based software tracing in it. 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. Only to understand this concept is worth buying the book. Besides we (embedded) software people tried to improve productivity and quality and failed in both. Maybe the framework based approach for state machines besides just the tracing as described in this book is towards the right way out of the software crises?

--
Robert Berger
Embedded Software Specialist

Reliable Embedded Systems
Consulting Training Engineering
Tel.: (+30) 697 593 3428
Fax.:(+30) 210 684 7881
email: info@reliableembeddedsystems.com
URL: [...]

Just a few notes right off the bat:

- check out the other reviews of this book - as of this writing, *every single review* is 5 stars (perfect)

- if you're doing embedded development, your system is almost certainly event-based, whether you know it or not

- this book, and the code framework it describes, provide you with the most elegant, intuitive, and useful framework I've ever used for embedded systems.

I'll try to keep the review about the book, as opposed to the actual Quantum Platform (QP) event-driven framework that the book describes. However, the book benefits from the elegance and functionality of the framework's code, and the code's use and implementation are described in exquisite detail in the book, so it's difficult to discuss one without the other.

The first version of this book was released in ~2002, and when I first became aware of it, I bought it immediately. Prior to this, I'd implemented many embedded systems with a "poor man's" version of the QP framework. Basically, I typically used an RTOS, and each task in the system was a state machine which pended on an event queue in a single place (i.e. no blocking in multiple places). This approach just seemed intuitive to me. But the approach had its limitations (which I won't go into here, the book describes them in detail). For example, all of our state machines were "ad hoc" - there was no common "base class" for a state machine, and there was no common approach to event dispatch & processing across state machines (10 developers, 10 approaches). It was only after seeing the author's approach to event-driven state machine based systems that I realized there was a "better way".

So when I picked up the original version of "PUSiCC", I immediately realized that it solved many of the problems I'd been wrestling with, and gave me a consistent approach to implementing state machines for event-driven systems. However, at that time, the book was a little more geared towards C++ than C, and I had trouble getting others to consider using the QP. Even though C could be used, the book's text was most useful to developers familiar with C++.

Fast forward to 2008. The 2nd edition of the book is released (this edition) along with a re-vamped version of the QP. The QP (book & code) now were more geared to C than C++. That eliminated one of the biggest obstacles to learning & using the QP (even though I'm a fan of C++ in embedded systems, that puts me in the minority). But now the QP was even more packed with functionality, easier to use, more traceable, etc. And the book, at over 700 pages, does a fantastic job of explaining the QP: how to use it, what *NOT* to do, design patterns, event tracing with the new (and included) Q-SPY functionality, and much more.

Furthermore, the book explains the actual QP implementation, with annotated source code in the book. This is extremely helpful and valuable. Such detail helps a developer understand the rationale behind certain implementation decisions, as well as also helping "internalize" the framework details.

A couple more major points that must be mentioned. First, the book covers a tremendous amount of ground beyond state machines & event-driven systems (both of which are explained extremely well). The book covers topics such as the run-to-completion paradigm, object-oriented principles, design patterns, pre-emptive multitasking systems, different scheduling approaches, encapsulation, and much much more. Anyone wanting to learn about UML statecharts - particularly hierarchical state machines (HSMs) - read Chapter 2, it is a very thorough treatment of the topic. Actually in my opinion, you won't find a better treatment of the topic anywhere.

Secondly, the actual writing is outstanding. The language is clear, the author almost seems to anticipate your questions, addressing them in the very next sentence as you're reading. The diagrams are very illustrative and uncluttered, the typesetting is extremely easy on the eyes, and book is full of cross-references and notes. Code listings are called out in specially-formatted text boxes, and notes and warnings are also treated specially. The table of contents & index are extremely comprehensive.

In short, it's clear that Dr. Samek has poured a tremendous amount of effort into this framework and the book(s) describing it, probably for more than a decade. I have contacted the author with questions and he has always been extremely responsive and helpful, his knowledge on the subject matter is masterful.

This book and this framework are must-haves for any embedded developer. Even if circumstances prevent you from using the QP on your current project, still get a copy of this book - the content and concepts are eye-opening and will make you a better developer.

(Parting note: I'm a consultant & visit many different companies. Since 2008, I think I've seen copies of this book at every site I've visited, and that's quite a few places, across many industries, at many different scales.)

Great book with solid examples and you finish understanding a working set of components. This is the way to end spaghetti code and make your system more reliable.