QDK-nano AVR-GNU - Quantum Leaps

QP-nano state machine framework for AVRQDK-nanoAtmel AVR-GNUDocument Revision IMarch 2014Copyright © Quantum Leaps, LLCwww.quantum-leaps.comwww.state-machine.com

Table of Contents1 Introduction ..................................................................................................................................................... 11.1 About QP-nano ........................................................................................................................................... 21.2 About QM ................................................................................................................................................... 31.3 What’s Included in the QDK-nano? ................................................................................................................ 31.4 Licensing QP-nano ..................................................................................................................................... 41.5 Licensing QM .............................................................................................................................................. 42 Getting Started ................................................................................................................................................ 52.1 Installation ...................................................................................................................................................... 52.2 Building the Examples .................................................................................................................................... 62.3 Programming and Debugging the AVR Device .............................................................................................. 73 Non-Preemptive Configuration of QP-nano .................................................................................................. 83.1 ISRs in the Non-preemptive “Vanilla” Configuration ....................................................................................... 93.2 QP Idle Loop Customization in QF_onIdle() ................................................................................................... 104 Preemptive Configuration with QK-nano ...................................................................................................... 124.1 ISRs in the Preemptive Configuration with QK-nano ...................................................................................... 134.2 Idle Loop Customization in the QK Port ......................................................................................................... 135 BSP for AVR .................................................................................................................................................... 145.1 Board Initialization and the Timer Tick ........................................................................................................... 145.2 Starting Interrupts in QF_onStartup() ............................................................................................................. 145.3 Assertion Handling Policy in Q_onAssert() .................................................................................................... 146 Related Documents and References ............................................................................................................. 157 Contact Information ........................................................................................................................................ 16Copyright © Quantum Leaps, LLC. All Rights Reserved.i

1 IntroductionThis QP-nano Development Kit (QDK-nano) describes how to use QP-nano state machineframework with the Atmel AVR and the Atmel Studio 6 and the GNU AVR compiler. The actualhardware/software used to test this QDK as shown in Figure 1 and described below:Figure 1: Atmel AVR Butterfly evaluation board connected to the AVR Dragon emulator, theRS232, external power, and external LEDs for PORTD.Powerfrom PCvia USBPowerswitchJTAGICEmkIISTK600-ATMEGA2560cardAtmega2560deviceJTAGconnectorPORTDconnectionfor LEDsUserswitchesUserLEDsThe actual hardware/software used to test this QDK is described below:Copyright © Quantum Leaps, LLC. All Rights Reserved.1 of 16

QDK-nanoAVR-GNUwww.state-machine.com/avr• STK600 board with STK600-ATMEGA2560 routing board• JTAGICE mkII debugger• Atmel Studio 6• AVR-GCC for windows (bundled with Atmel Studio 6.0)• QP-nano 5.2.1 or higher and QM v 2.2.03 or higher.As shown in Figure 1, the Atmel’s STK600 is powered via a USB cable and is connected to the JTAGmkIIemulator via the JTAG ribbon cable. This QDK has been tested on the ATmega2560 device with8KB of RAM and 256KB of on-board flash. However, the described port should be applicable to mostAVRmega devices (such as ATtiny and ATmega families) big enough to accommodate QP-nano.1.1 About QP-nanoQP-nano is an ultra-lightweight, open source, state machineframework and RTOS for developing real-time embeddedapplications. QP-nano has been specifically designed to enable eventdrivenprogramming with concurrent hierarchical state machines (UMLstatecharts) on low-end 8- and 16-bit single-chip MCUs and DSPs,such as AVR. All versions of QP, including QP-nano, are described indetail in the book "Practical UML Statecharts in C/C++, 2nd Edition:Event-Driven Programming for Embedded Systems" [PSiCC2]The QP-nano framework can manage up to 8 concurrently executinghierarchical state machines and requires only 1-2KB of code (ROM)and just several bytes of RAM. As shown in Figure 2, QP-nanoconsists of a universal UML-compliant event processor (QEP-nano), ahigly portable event-driven framework (QF-nano), and a tiny run-tocompletionkernel (QK-nano).Figure 2: QP-nano components and their relationship with the target hardware, board supportpackage (BSP), and the application comprised of state machinesStateMachineStateMachineStateMachineStateMachineApplication(Your code)QEP-nano UML-CompliantEvent ProcessorQF-nano Event-DrivenFrameworkBSPQK-nano Preemptive Kernel,Cooperative Kernel,or other OS/RTOSTargetCopyright © Quantum Leaps, LLC. All Rights Reserved.2 of 16

QDK-nanoAVR-GNUwww.state-machine.com/avr1.2 About QMQM (QP Modeler) is a free, cross-platform, graphical UML modeling tool fordesigning and implementing real-time embedded applications based on theQP state machine frameworks. QM is available for Windows, Linux, andMac OS X. QM provides intuitive diagramming environment for creating goodlooking hierarchical state machine diagrams and hierarchical outline of yourentire application. QM eliminates coding errors by automatic generation ofcompact C or C++ code that is 100% traceable from your design. Please visitstate-machine.com/qm for more information about QM.1.3 What’s Included in the QDK-nano?This QDK-nano provides the QP-nano port to AVR with the GNU compiler, the Board Support Package(BSP) and two versions of the PEdestrian LIght CONtrolled (PELICAN) crossing example applicationdescribed in the Application Note “PELICAN Crossing Example” [QL AN-PELICAN 08], for cooperativeand preemptive kernels, respectively.Figure 3: The example model opened in the QM modeling toolNOTE: The entire source code included with this QDK can be edited manually in a traditional codeeditor. However, significant parts of the code have been generated automatically by the QMCopyright © Quantum Leaps, LLC. All Rights Reserved.3 of 16

QDK-nanoAVR-GNUwww.state-machine.com/avrmodeling tool from the pelican.qm model file included in the QDK. The preferred way of developingQP applications is to make all the changes in the model and generate the code automatically..1.4 Licensing QP-nanoThe Generally Available (GA) distribution of QP-nano available for download from the www.statemachine.com/downloadswebsite is offered with the following two licensing options:• The GNU General Public License version 2 (GPL) as published by the FreeSoftware Foundation and appearing in the file GPL.TXT included in the packaging ofevery Quantum Leaps software distribution. The GPL open source license allowsyou to use the software at no charge under the condition that if you redistribute theoriginal software or applications derived from it, the complete source code for yourapplication must be also available under the conditions of the GPL (GPL Section2[b]).• One of several Quantum Leaps commercial licenses, which are designed forcustomers who wish to retain the proprietary status of their code and therefore cannotuse the GNU General Public License. The customers who license Quantum Leapssoftware under the commercial licenses do not use the software under the GPL andtherefore are not subject to any of its terms.For more information, please visit the licensing section of our website at: www.statemachine.com/licensing.1.5 Licensing QMThe QM graphical modeling tool available for download from the www.statemachine.com/downloadswebsite is free to use, but is not open source. During theinstallation you will need to accept a basic End-User License Agreement (EULA),which legally protects Quantum Leaps from any warranty claims, prohibits removingany copyright notices from QM, selling it, and creating similar competitive products.Copyright © Quantum Leaps, LLC. All Rights Reserved.4 of 16

QDK-nanoAVR-GNUwww.state-machine.com/avr2 Getting StartedThis section describes how to install, build, and use QDK-nano-AVR-GNU based on two examples.NOTE: Every QDK-nano contains only example(s) pertaining to the specific MCU and compiler, butdoes not include the platform-independent baseline code of QP-nano, which is available for aseparate download. It is strongly recommended that you read Chapter 12 in [PSiCC2] before youstart with this QDK-nano.2.1 InstallationThe QDK-nano code is distributed in a ZIP archive (qdkn_AVR-GNU.zip. You should uncompress thearchive into the same directory in which you’ve installed QP-nano. The QP-nano installation will bereferred henceforth as QP-nano Root Directory qpn.Listing 1: Directories and files after installing QP-nano baseline code and the QDK-nano-AVR-GNUdistribution. The highlighted directories and files are provided in the QDK-nano-AVR-GNU ZIP file.qpn\- QP-nano Root Directory|+-examples\- QP-nano examples| +-avr\ - examples for AVR| | +-gnu\ - examples compiled with the GNU (WinAVR) compiler| | | +-pelican-stk600-atmega2560/ - PELICAN example for AVR STK600-ATMEGA2560| | | | +-dbg\ - directory containing the debug build| | | | +-rel\ - directory containing the release build| | | | +-pelican-stk600-atmega2560.cproj – Atmel Studio 6 project| | | | +-pelican-stk600-atmega2560.atsln – Atmel Studio 6 solution| | | | +-pelican.qm - QM model for the PELICAN application| | | | +-bsp.h - Board Support Package include file| | | | +-bsp.c - Board Support Package implementation| | | | +-pelican.h| | | | +-main.c| | | | +-pelican.c| | | | +-ped.c| | | | +-qpn_port.h – QP-nano port| | | || | | +-pelican-qk-stk600-atmega2560/ - PELICAN example for AVR STK600-ATMEGA2560| | | | +-dbg\ - directory containing the debug build| | | | +-rel\ - directory containing the release build| | | | +-pelican-qk-stk600-atmega2560.cproj – Atmel Studio 6 project| | | | +-pelican-qk-stk600-atmega2560.atsln – Atmel Studio 6 solution| | | | +-pelican.qm - QM model for the PELICAN application| | | | +-bsp.h - Board Support Package include file| | | | +-bsp.c - Board Support Package implementation| | | | +-pelican.h| | | | +-main.c| | | | +-pelican.c| | | | +-ped.c| | | | +-qpn_port.h – QP-nano port|+-include\- subdirectory containing the QP-nano public interface| +-qassert.h - embedded-systems-friendly assertions used in QP-nano| +-qepn.h - The platform-independent QEP-nano header fileCopyright © Quantum Leaps, LLC. All Rights Reserved.5 of 16

QDK-nanoAVR-GNUwww.state-machine.com/avr| +-qfn.h - The platform-independent QF-nano header file| +-qkn.h - The platform-independent QK-nano header file|+-source/- QP-nano source files| +-qepn.c - QEP-nano| +-qfn.c - QF-nano| +-qkn.c - QK-nano (required only in QK-nano configuration)2.2 Building the ExamplesThe QDK-nano contains the Atmel Studio solution located in \examples\avr\gnu\pelicanstk600-atmega2560\pelican-stk600-atmega2560.avrslnfor the “vanilla” version, and in \-examples\avr\gnu\pelican-qk-stk600-atmega2560\pelican-qk-stk600-atmega2560.avrsln forthe QK-nano version, respectively.Figure 4: The PELICAN example project opened in Atmel Studio 6.Select buildconfigurationCopyright © Quantum Leaps, LLC. All Rights Reserved.6 of 16

QDK-nanoAVR-GNUwww.state-machine.com/avr3 Non-Preemptive Configuration of QP-nanoThe example of using QP-nano with the cooperative “Vanilla” kernel is located in the directory: \-examples\arm\gnu\pelican-stk600-atmega2560\. This section describes the generic QP-nanoconfiguration, which consist of the qpn_port.h header file. The board-specific elements are common forboth the non-preemptive and preemptive (QK-nano) configuration and will be covered in Section 5.You configure and customize QP-nano through the header file qpn_port.h, which is included by the QPnanosource files (qepn.c and qfn.c) as well as in all your application C modules.NOTE: The QP-nano port to the cooperative “Vanilla” kernel qpn_port.h is generic and should notneed to change (except for the QF_MAX_ACTIVE definition) for other AVR projects.Listing 2: qpn_port.h header file for the non-preemptive QF-nano configuration and GNU compiler#ifndef qpn_port_h#define qpn_port_h(1) #define Q_ROM PROGMEM(2) #define Q_ROM_BYTE(rom_var_) pgm_read_byte_near(&(rom_var_))(3) #define Q_ROM_PTR(rom_var_) pgm_read_word_near(&(rom_var_))(4) #define Q_NFSM(5) #define Q_PARAM_SIZE 1(6) #define QF_TIMEEVT_CTR_SIZE 2/* maximum # active objects--must match EXACTLY the QF_active[] definition */(7) #define QF_MAX_ACTIVE 2/* interrupt disabling policy for GNU compiler */(8) #define QF_INT_DISABLE() cli()(9) #define QF_INT_ENABLE() sei()/* interrupt disabling policy for interrupt level */(10) /* #define QF_ISR_NEST */ /* nesting of ISRs not allowed */(11) #include #include /* cli()/sei() */#include /* accessing data in the program memory (PROGMEM) */(12) #include /* Exact-width integer types. WG14/N843 C99 Standard */(13) #include "qepn.h" /* QEP-nano platform-independent public interface */(14) #include "qfn.h" /* QF-nano platform-independent public interface */#endif /* qpn_port_h */(1) The macro Q_ROM allows enforcing placing the constant objects, such as lookup tables, constantstrings, etc. in ROM, rather than in the precious RAM. On CPUs with the Harvard architecture (suchas Atmel AVR or 8051), the code and data spaces are separate and are accessed through differentCPU instructions. Various compilers often provide specific extended keywords to designate code ordata space, such as the “PROGMEM” macro in the GNU-AVR compiler.Copyright © Quantum Leaps, LLC. All Rights Reserved.8 of 16

QDK-nanoAVR-GNUwww.state-machine.com/avr(2) The macro Q_ROM_BYTE() encapsulates a custom mechanism of retrieving a data byte from thegiven ROM address. GNU-AVR cannot generate code for accessing data allocated in the programspace (ROM), even though the compiler can allocate constants in ROM. The workaround for GNU-AVR is to explicitly add custom assembly code to access data allocated in the program space.(3) The macro Q_ROM_PTR() encapsulates a custom mechanism of retrieving a data pointer from thegiven ROM address. GNU-AVR cannot generate code for accessing data allocated in the programspace (ROM), even though the compiler can allocate constants in ROM. The workaround for GNU-AVR is to explicitly add custom assembly code to access data allocated in the program space.(4) Defining the macro Q_NFSM eliminates the code for the simple non-hierarchical FSMs.(5) The macro Q_PARAM_SIZE defines the size (in bytes) of the scalar event parameter. The allowedvalues are 0 (no parameter), 1, 2, or 4 bytes. If you don’t define this macro in qpn_port.h, thedefault of 0 (no parameter) will be assumed.(6) The macro QF_TIMEEVT_CTR_SIZE defines the size (in bytes) of the time event down-counter. Theallowed values are 0 (no time events), 1, 2, or 4 bytes. If you don’t define this macro in qpn_port.h,the default of 0 (no time events) will be assumed.(7) You must define the QF_MAX_ACTIVE macro as the exact number of active objects used in theapplication. The provided value must be between 1 and 8 and must be consistent with the definitionof the QF_active[] array in main.c.(8-9) The macros QF_INT_DISABLE/QF_INT_ENABLE define the task-level interrupt disabling policy forQP-nano (see Section 12.3.2 in Chapter 12 in [PSiCC2]).(10) This QP-nano port to AVR does not allow nesting of interrupts.AVR does not provide any support for prioritizing interrupts in hardware. Therefore, enabling interruptsinside ISRs (the AVR hardware automatically disables interrupts upon entry to an ISR) is not advisable.Allowing interrupts to nest can lead to all sorts of priority inversions, including the pathological case of aninterrupt preempting itself.NOTE: This QP-nano port assumes that you never enable interrupts inside ISRs.(11) These header files are necessary for supporting interrupts in C an well as accessing the PROGMEMspace.(12) The GNU compiler provides the C99-standard exact-width integer types are defined in the standard header file.(13) The qpn_port.h must include the QEP-nano event processor interface qepn.h.(14) The qpn_port.h must include the QF-nano real-time framework interface qfn.h.3.1 ISRs in the Non-preemptive “Vanilla” ConfigurationThe GNU-AVR compiler supports writing interrupts in C. In the “vanilla” port, the ISRs are identical as inthe simplest of all “superloop” (main+ISRs), and there is nothing QP-specific in the structure of the ISRs.The only QP-specific requirement is that you provide a periodic time-tick ISR and you invoke QF_tick()in it.Copyright © Quantum Leaps, LLC. All Rights Reserved.9 of 16

QDK-nanoAVR-GNUwww.state-machine.com/avrListing 3: Time tick interrupt calling QF_tick() function to manage armed time events.(1) ISR(TIMER2_COMPA_vect) {/* No need to clear the interrupt source since the Timer0 compare* interrupt is automatically cleard in hardware when the ISR runs.*/(2) QF_tick();}(1) The definition of the interrupt function must begin with the ISR() macro.(2) The time-tick ISR must invoke QF_tick(), and can also perform other actions, if necessary. Thefunction QF_tick() cannot be reentered, that is, it necessarily must run to completion and returnbefore it can be called again. This requirement is automatically fulfilled, because here interrupts aredisabled throughout the interrupt processing.3.2 QP Idle Loop Customization in QF_onIdle()The cooperative “vanilla” kernel can very easily detect the situation when no events are available, inwhich case QF_run() calls the QF_onIdle() callback. You can use QF_onIdle() to suspended the CPUto save power, if your CPU supports such a power-saving mode. Please note that QF_onIdle() is calledrepetitively from the event loop whenever the event loop has no more events to process, in which caseonly an interrupt can provide new events. The QF_onIdle() callback is called with interrupts disableded,because the determination of the idle condition might change by any interrupt posting an event.AVR supports several power-saving levels (consult the AVR data sheet for details). The following piece ofcode shows the QF_onIdle() callback that puts AVR into the idle power-saving mode. Please note thatAVR architecture allows for very atomic setting the low-power mode and enabling interrupts at the sametime.Listing 4: QF_onIdle() for the non-preemptive (“vanilla”) QP-nano port to AVR.(1) void QF_onIdle(void) { /* entered with interrupts DISABLED, see NOTE01 */(2) LED_ON(7);LED_OFF(7);/* toggle the LED number 7 on and then off, see NOTE02 */#ifdef NDEBUG(3) SMCR = (0

QDK-nanoAVR-GNUwww.state-machine.com/avr(2) The LED[7] is turned on and off to visualize the idle loop activity. Note that the LED is toggled withinterrupts locked, to the period of the LED turned on is constant and does not include any time spentin the ISRs.(3) The SMCR register is loaded with the desired sleep mode (idle mode in this case) and the SleepEnable (SE) bit is set. Please note that the sleep mode is not active until the SLEEP command.(4) The interrupts are unlocked with the SEI instruction.(5) The sleep mode is activated with the SLEEP instruction.NOTE: The AVR datasheet is very specific about the behavior of the SEI-SLEEP instruction pair. Dueto pipelining of the AVR core, the SLEEP instruction is guaranteed to execute before entering anypotentially pending interrupt. This means that enabling interrupts and activating the sleep mode isatomic, as it should be to avoid non-deterministic sleep.(6) As recommended in the AVR datasheet, the SMCR register should be explicitly cleared upon the exitfrom the sleep mode.(7) In the DEBUG configuration the interrupts are simply unlocked.NOTE: Every path through QF_onIdle() callback function must ultimately unlock interrupts.Copyright © Quantum Leaps, LLC. All Rights Reserved.11 of 16

QDK-nanoAVR-GNUwww.state-machine.com/avr4 Preemptive Configuration with QK-nanoThe QP port with the preemptive kernel (QK) is remarkably simple and very similar to the “vanilla” port. Inparticular, the interrupt locking/unlocking policy is the same, and the BSP is identical, except some smalladditions to the ISRs. The PELICAN example for the QK port is provided in the directory\examples\avr\gnu\pelican-qk-stk600-atmega2560.You configure and customize QP-nano through the header file qpn_port.h, which is included by the QPnanosource files (qepn.c, qfn.c, and qkn.c) as well as in all your application C modules. The followingListing 5 shows the qpn_port.h header file for the QK-nano port. Except for the highlighted fragments,the listing is identical as in the non-preemptive case (Listing 2)Listing 5: qpn_port.h header file for the preemptive QK-nano configuration#define Q_ROM#define Q_ROM_BYTE(rom_var_)#define Q_ROM_PTR(rom_var_)#define Q_NFSM#define Q_PARAM_SIZE 1#define QF_TIMEEVT_CTR_SIZE 2PROGMEMpgm_read_byte_near(&(rom_var_))pgm_read_word_near(&(rom_var_))/* maximum # active objects--must match EXACTLY the QF_active[] definition */#define QF_MAX_ACTIVE 2#define QF_INT_DISABLE()#define QF_INT_ENABLE()/* interrupt disabling policy for GNU compiler */cli()sei()/* interrupt disabling policy for interrupt level *//* #define QF_ISR_NEST */ /* nesting of ISRs not allowed */(1) #define QK_ISR_ENTRY() ((void)0)(2) #define QK_ISR_EXIT() do { \uint8_t p = QK_schedPrio_(); \if (p != (uint8_t)0) { \QK_sched_(p); \} \} while (0)/* interrupt entry/exit for QK-nano */#include #include /* cli()/sei() */#include /* accessing data in the program memory (PROGMEM) */#include /* Exact-width integer types. WG14/N843 C99 Standard */#include "qepn.h" /* QEP-nano platform-independent public interface */#include "qfn.h" /* QF-nano platform-independent public interface */(3) #include "qkn.h" /* QK-nano platform-independent public interface */(1-2) The interrupt entry and exit macro for QK-nano are defined consistently with the interrupt nestingpolicy, which does not allow interrupt nesting.(3) The preemptive configuration of QP-nano is selected by including the qkn.h header file.Copyright © Quantum Leaps, LLC. All Rights Reserved.12 of 16

QDK-nanoAVR-GNUwww.state-machine.com/avrWhen interrupt nesting is not allowed (the macro QF_ISR_NEST is not defined in qpn_port.h), QK-nanoallows for a simpler interrupt handling compared to the full-version QK. Specifically, when interruptscannot nest you don’t need to increment the interrupt nesting counter (QK_intNest_) upon the ISRentry, and you don’t need to decrement it upon the ISR exit. In fact, when the macro QF_ISR_NEST notdefined, the QK_intNest_ counter is not even available. This simplification is possible, because QPnanouses special ISR-version of the event posting function QActive_postISR(), which does not callthe QK-nano scheduler. Consequently, there is no need to prevent the synchronous preemption withinISRs.4.1 ISRs in the Preemptive Configuration with QK-nanoAs all preemptive kernels, QK-nano must be notified about interrupt entry and exit. You achieve this bymeans of the QK-nano macros QK_ISR_ENTRY() and QK_ISR_EXIT(), as shown in Listing 6.Listing 6: Time tick interrupt calling QF_tick() function to manage armed time events and QK-nanoISR entry/exit macros.ISR(TIMER2_COMPA_vect) {/* No need to clear the interrupt source since the Timer0 compare* interrupt is automatically cleard in hardware when the ISR runs.*/QK_ISR_ENTRY(); /* inform QK about entering the ISR */QF_tick();}QK_ISR_EXIT(); /* inform QK about exiting the ISR */NOTE: This QP-nano port assumes that you never enable interrupts inside ISRs.4.2 Idle Loop Customization in the QK PortAs described in Chapter 10 of [PSiCC2], the QK idle loop executes only when there are no events toprocess. The QK allows you to customize the idle loop processing by means of the callbackQK_onIdle(), which is invoked by every pass through the QK idle loop. You can define the platformspecificcallback function QK_onIdle() to save CPU power, or perform any other “idle” processing (suchas Quantum Spy software trace output).NOTE: The idle callback QK_onIdle() is invoked with interrupts unlocked (which is in contrast toQF_onIdle() that is invoked with interrupts dissabled, see Section 3.2).Copyright © Quantum Leaps, LLC. All Rights Reserved.13 of 16

QDK-nanoAVR-GNUwww.state-machine.com/avr5 BSP for AVRThe Board Support Package (BSP) for AVR is very simple. However, there are some important detailsthat you need to pay attention to.5.1 Board Initialization and the Timer TickThe BSP is minimal, but generic for most AVR devices. The most important step is initialization of Timer 0to deliver the time tick interrupt at the desired rate (BSP_TICKS_PER_SEC):void BSP_init(void) {DDRD = 0xFF; /* All PORTD pins are outputs for LEDs */LED_OFF_ALL(); /* trun off all LEDs */}5.2 Starting Interrupts in QF_onStartup()QP-nano invokes the QF_onStartup() callback just before starting the event loop inside QF_run(). TheQF_onStartup() function must start the interrupts configured earlier. In this BSP only the timer tickinterrupt is started.Listing 7: Configuring and enabling interrupts in the QF_onStartup() callback.void QF_onStartup(void) {/* set Timer2 in CTC mode, 1/1024 prescaler, start the timer ticking */TCCR2A = ((1

QDK-nanoAVR-GNUwww.state-machine.com/avr7 Contact InformationQuantum Leaps, LLC103 Cobble Ridge DriveChapel Hill, NC 27516USA+1 866 450 LEAP (toll free, USA only)+1 919 869-2998 (FAX)e-mail: info@quantum-leaps.comWEB : http://www.quantum-leaps.comhttp://www.state-machine.com“Practical UMLStatecharts inC/C++, SecondEdition: EventDrivenProgramming forEmbeddedSystems”,by Miro Samek,Newnes, 2008Copyright © Quantum Leaps, LLC. All Rights Reserved.16 of 16