book

Practical UML Statecharts in C/C++, 2nd Edition

Name: Practical UML Statecharts in C/C++, 2nd Edition
Author: Miro Samek
ISBN: 9781482249262

by Miro Samek

October 2008

Intermediate to advanced

728 pages

17h 36m

English

CRC Press

Read now

Unlock full access

Preface
What's New in the Second Edition?New CodeOpen Source and Dual LicensingC as the Primary Language of ExpositionMore ExamplesPreemptive Multitasking SupportTesting SupportUltra-Lightweight QP-nano VersionRemoved Quantum MetaphorWhat You Need to Use QPIntended AudienceThe Companion Websites
Acknowledgments
Copyright Page
Introduction
Inversion of ControlThe Importance of the Event-Driven FrameworkActive Object Computing ModelThe Code-Centric ApproachFocus on Real-Life ProblemsObject OrientationMore FunHow to Contact Me
I. Uml State Machines
I. UML State Machines
1. Getting Started with UML State Machines and Event-Driven Programming
1.1. Installing the Accompanying Code1.2. Let's Play1.2.1. Running the DOS Version1.2.2. Running the Stellaris Version1.3. The main() Function1.4. The Design of the “Fly ‘n’ Shoot” Game1.5. Active Objects in the “Fly ‘n’ Shoot” Game1.5.1. The Missile Active Object1.5.2. The Ship Active Object1.5.3. The Tunnel Active Object1.5.4. The Mine Components1.6. Events in the “Fly ‘n’ Shoot” Game1.6.1. Generating, Posting, and Publishing Events1.7. Coding Hierarchical State Machines1.7.1. Step 1: Defining the Ship Structure1.7.2. Step 2: Initializing the State Machine1.7.3. Step 3: Defining State-Handler Functions1.8. The Execution Model1.8.1. Simple Nonpreemptive “Vanilla” Scheduler1.8.2. The QK Preemptive Kernel1.8.3. Traditional OS/RTOS1.9. Comparison to the Traditional Approach1.10. Summary
2. A Crash Course in UML State Machines
2.1. The Oversimplification of the Event-Action Paradigm2.2. Basic State Machine Concepts2.2.1. States2.2.2. State Diagrams2.2.3. State Diagrams versus Flowcharts2.2.4. Extended State Machines2.2.5. Guard Conditions2.2.6. Events2.2.7. Actions and Transitions2.2.8. Run-to-Completion Execution Model2.3. UML Extensions to the Traditional FSM Formalism2.3.1. Reuse of Behavior in Reactive Systems2.3.2. Hierarchically Nested States2.3.3. Behavioral Inheritance2.3.4. Liskov Substitution Principle for States2.3.5. Orthogonal Regions2.3.6. Entry and Exit Actions2.3.7. Internal Transitions2.3.8. Transition Execution Sequence2.3.9. Local versus External Transitions2.3.10. Event Types in the UML2.3.11. Event Deferral2.3.12. Pseudostates2.3.13. UML Statecharts and Automatic Code Synthesis2.3.14. The Limitations of the UML State Diagrams2.3.15. UML State Machine Semantics: An Exhaustive Example2.4. Designing A UML State Machine2.4.1. Problem Specification2.4.2. High-Level Design2.4.3. Scavenging for Reuse2.4.4. Elaborating Composite States2.4.5. Refining the Behavior2.4.6. Final Touches2.5. Summary
3. Standard State Machine Implementations
3.1. The Time-Bomb Example3.1.1. Executing the Example Code3.2. A Generic State Machine Interface3.2.1. Representing Events3.3. Nested Switch Statement3.3.1. Example Implementation3.3.2. Consequences3.3.3. Variations of the Technique3.4. State Table3.4.1. Generic State-Table Event Processor3.4.2. Application-Specific Code3.4.3. Consequences3.4.4. Variations of the Technique3.5. Object-Oriented State Design Pattern3.5.1. Example Implementation3.5.2. Consequences3.5.3. Variations of the Technique3.6. QEP FSM Implementation3.6.1. Generic QEP Event Processor3.6.2. Application-Specific Code3.6.3. Consequences3.6.4. Variations of the Technique3.7. General Discussion of State Machine Implementations3.7.1. Role of Pointers to Functions3.7.2. State Machines and C++ Exception Handling3.7.3. Implementing Guards and Choice Pseudostates3.7.4. Implementing Entry and Exit Actions3.8. Summary
4. Hierarchical Event Processor Implementation
4.1. Key Features of the QEP Event Processor4.2. QEP Structure4.2.1. QEP Source Code Organization4.3. Events4.3.1. Event Signal (QSignal)4.3.2. QEvent Structure in C4.3.3. QEvent Structure in C++4.4. Hierarchical State-Handler Functions4.4.1. Designating the Superstate (Q_SUPER() Macro)4.4.2. Hierarchical State-Handler Function Example in C4.4.3. Hierarchical State-Handler Function Example in C++4.5. Hierarchical State Machine Class4.5.1. Hierarchical State Machine in C (Structure QHsm)4.5.2. Hierarchical State Machine in C++ (Class QHsm)4.5.3. The Top State and the Initial Pseudostate4.5.4. Entry/Exit Actions and Nested Initial Transitions4.5.5. Reserved Events and Helper Macros in QEP4.5.6. Topmost Initial Transition (QHsm_init())4.5.7. Dispatching Events (QHsm_dispatch(), General Structure)4.5.8. Executing a Transition in the State Machine (QHsm_dispatch(), Transition)4.6. Summary of Steps for Implementing HSMs with QEP4.6.1. Step 1: Enumerating Signals4.6.2. Step 2: Defining Events4.6.3. Step 3: Deriving the Specific State Machine4.6.4. Step 4: Defining the Initial Pseudostate4.6.5. Step 5: Defining the State-Handler Functions4.6.6. Coding Entry and Exit Actions4.6.7. Coding Initial Transitions4.6.8. Coding Internal Transitions4.6.9. Coding Regular Transitions4.6.10. Coding Guard Conditions4.7. Pitfalls to Avoid While Coding State Machines with QEP4.7.1. Incomplete State Handlers4.7.2. Ill-Formed State Handlers4.7.3. State Transition Inside Entry or Exit Action4.7.4. Incorrect Casting of Event Pointers4.7.5. Accessing Event Parameters in Entry/Exit Actions or Initial Transitions4.7.6. Targeting a Nonsubstate in the Initial Transition4.7.7. Code Outside the switch Statement4.7.8. Suboptimal Signal Granularity4.7.9. Violating the Run-to-Completion Semantics4.7.10. Inadvertent Corruption of the Current Event4.8. Porting and Configuring QEP4.9. Summary

5. State Patterns
5.1. Ultimate Hook5.1.1. Intent5.1.2. Problem5.1.3. Solution5.1.4. Sample Code5.1.5. Consequences5.2. Reminder5.2.1. Intent5.2.2. Problem5.2.3. Solution5.2.4. Sample Code5.2.5. Consequences5.3. Deferred Event5.3.1. Intent5.3.2. Problem5.3.3. Solution5.3.4. Sample Code5.3.5. Consequences5.3.6. Known Uses5.4. Orthogonal Component5.4.1. Intent5.4.2. Problem5.4.3. Solution5.4.4. Sample Code5.4.5. Consequences5.4.6. Known Uses5.5. Transition to History5.5.1. Intent5.5.2. Problem5.5.3. Solution5.5.4. Sample Code5.5.5. Consequences5.5.6. Known Uses5.6. Summary
II. Real-Time Framework
II. Real-Time Framework
6. Real-Time Framework Concepts
6.1. Inversion of Control6.2. CPU Management6.2.1. Traditional Sequential Systems6.2.2. Traditional Multitasking Systems6.2.3. Traditional Event-Driven Systems6.3. Active Object Computing Model6.3.1. System Structure6.3.2. Asynchronous Communication6.3.3. Run-to-Completion6.3.4. Encapsulation6.3.5. Support for State Machines6.3.6. Traditional Preemptive Kernel/RTOS6.3.7. Cooperative Vanilla Kernel6.3.8. Preemptive RTC Kernel6.4. Event Delivery Mechanisms6.4.1. Direct Event Posting6.4.2. Publish-Subscribe6.5. Event Memory Management6.5.1. Copying Entire Events6.5.2. Zero-Copy Event Delivery6.5.3. Static and Dynamic Events6.5.4. Multicasting Events and the Reference-Counting Algorithm6.5.5. Automatic Garbage Collection6.5.6. Event Ownership6.5.7. Memory Pools6.6. Time Management6.6.1. Time Events6.6.2. System Clock Tick6.7. Error and Exception Handling6.7.1. Design by Contract6.7.2. Errors versus Exceptional Conditions6.7.3. Customizable Assertions in C and C++6.7.4. State-Based Handling of Exceptional Conditions6.7.5. Shipping with Assertions6.7.6. Asserting Guaranteed Event Delivery6.8. Framework-Based Software Tracing6.9. Summary
7. Real-Time Framework Implementation
7.1. Key Features of the QF Real-Time Framework7.1.1. Source Code7.1.2. Portability7.1.3. Scalability7.1.4. Support for Modern State Machines7.1.5. Direct Event Posting and Publish-Subscribe Event Delivery7.1.6. Zero-Copy Event Memory Management7.1.7. Open-Ended Number of Time Events7.1.8. Native Event Queues7.1.9. Native Memory Pool7.1.10. Built-in “Vanilla” Scheduler7.1.11. Tight Integration with the QK Preemptive Kernel7.1.12. Low-Power Architecture7.1.13. Assertion-Based Error Handling7.1.14. Built-in Software Tracing Instrumentation7.2. QF Structure7.2.1. QF Source Code Organization7.3. Critical Sections in QF7.3.1. Saving and Restoring the Interrupt Status7.3.2. Unconditional Locking and Unlocking Interrupts7.3.3. Internal QF Macros for Interrupt Locking/Unlocking7.4. Active Objects7.4.1. Internal State Machine of an Active Object7.4.2. Event Queue of an Active Object7.4.3. Thread of Execution and Active Object Priority7.5. Event Management in QF7.5.1. Event Structure7.5.2. Dynamic Event Allocation7.5.3. Automatic Garbage Collection7.5.4. Deferring and Recalling Events7.6. Event Delivery Mechanisms in QF7.6.1. Direct Event Posting7.6.2. Publish-Subscribe Event Delivery7.7. Time Management7.7.1. Time Event Structure and Interface7.7.2. The System Clock Tick and the QF_tick() Function7.7.3. Arming and Disarming a Time Event7.8. Native QF Event Queue7.8.1. The QEQueue Structure7.8.2. Initialization of QEQueue7.8.3. The Native QF Active Object Queue7.8.4. The “Raw” Thread-Safe Queue7.9. Native QF Memory Pool7.9.1. Initialization of the Native QF Memory Pool7.9.2. Obtaining a Memory Block from the Pool7.9.3. Recycling a Memory Block Back to the Pool7.10. Native QF Priority Set7.11. Native Cooperative “Vanilla” Kernel7.11.1 The qvanilla.c Source File7.11.2 The qvanilla.h Header File7.12. QP Reference Manual7.13. Summary
8. Porting and Configuring QF
8.1. The QP Platform Abstraction Layer8.1.1. Building QP Applications8.1.2. Building QP Libraries8.1.3. Directories and Files8.1.4. The qep_port.h Header File8.1.5. The qf_port.h Header FileTypes of Platform-Specific QActive Data MembersBase Class for Derivation of QActiveThe Maximum Number of Active Objects in the ApplicationVarious Object Sizes Within the QF FrameworkQF Critical Section MechanismInclude Files Used by this QF PortInterface Used Only Inside QF, But Not in ApplicationsActive Object Event Queue OperationsQF Event Pool Operations8.1.6. The qf_port.c Source File8.1.7. The qp_port.h Header File8.1.8. Platform-Specific QF Callback Functionsvoid QF_onStartup(void)void QF_onCleanup(void)void QF_onIdle(void) or void QF_onIdle(QF_INT_KEY_TYPE lockKey)void Q_onAssert(char const Q_ROM * const Q_ROM_VAR file, int line)8.1.9. System Clock Tick (Calling QF_tick())8.1.10. Building the QF Library8.2. Porting the Cooperative “Vanilla” Kernel8.2.1. The qep_port.h Header File8.2.2. The qf_port.h Header File8.2.3. The System Clock Tick (QF_tick())8.2.4. Idle Processing (QF_onIdle())8.3. QF Port to μC/OS-II (Conventional RTOS)8.3.1. The qep_port.h Header File8.3.2. The qf_port.h Header File8.3.3. The qf_port.c Source File8.3.4. Building the μC/OS-II Port8.3.5. The System Clock Tick (QF_tick())8.3.6. Idle Processing8.4. QF Port to Linux (Conventional POSIX-Compliant OS)8.4.1. The qep_port.h Header File8.4.2. The qf_port.h Header File8.4.3. The qf_port.c Source File8.5. Summary
9. Developing QP Applications
9.1. Guidelines for Developing QP Applications9.1.1. Rules9.1.2. Heuristics9.2. The Dining Philosopher Problem9.2.1. Step 1: Requirements9.2.2. Step 2: Sequence Diagrams9.2.3. Step 3: Signals, Events, and Active Objects9.2.4. Step 4: State Machines9.2.5. Step 5: Initializing and Starting the Application9.2.6. Step 6: Gracefully Terminating the Application9.3. Running DPP on Various Platforms9.3.1. “Vanilla” Kernel on DOS9.3.2. “Vanilla” Kernel on Cortex-M39.3.3. μC/OS-II9.3.4. Linux9.4. Sizing Event Queues and Event Pools9.4.1. In Sizing Event Queues9.4.2. Sizing Event Pools9.4.3. System Integration9.5. Summary
10. Preemptive Run-to-Completion Kernel
10.1. Reasons for Choosing a Preemptive Kernel10.2. Introduction to RTC Kernels10.2.1. Preemptive Multitasking with a Single Stack10.2.2. Nonblocking Kernel10.2.3. Synchronous and Asynchronous Preemptions10.2.4. Stack Utilization10.2.5. Comparison to Traditional Preemptive Kernels10.3. QK Implementation10.3.1. QK Source Code Organization10.3.2. The qk.h Header File10.3.3. Interrupt Processing10.3.4. The qk_sched.c Source File (QK Scheduler)10.3.5. The qk.c Source File (QK Startup and Idle Loop)10.4. Advanced QK Features10.4.1. Priority-Ceiling Mutex10.4.2. Thread-Local Storage10.4.3. Extended Context Switch (Coprocessor Support)10.5. Porting QK10.5.1. The qep_port.h Header File10.5.2. The qf_port.h Header File10.5.3. The qk_port.h Header File10.5.4. Saving and Restoring FPU Context10.6. Testing the QK Port10.6.1. Asynchronous Preemption Demonstration10.6.2. Priority-Ceiling Mutex Demonstration10.6.3. TLS Demonstration10.6.4. Extended Context Switch Demonstration10.7. Summary
11. Software Tracing for Event-Driven Systems
11.1. Software Tracing Concepts11.2. Quantum Spy Software-Tracing System11.2.1. Example of a Software-Tracing Session11.2.2. The Human-Readable Trace Output11.3. QS Target Component11.3.1. QS Source Code Organization11.3.2. The QS Platform-Independent Header Files qs.h and qs_dummy.h11.3.3. QS Critical Section11.3.4. General Structure of QS Records11.3.5. QS FiltersGlobal On/Off FilterLocal Filters11.3.6. QS Data ProtocolTransparencyEndianness11.3.7. QS Trace BufferInitializing the QS Trace Buffer QS_initBuf()Byte-Oriented Interface: QS_getByte()Block-Oriented Interface: QS_getBlock()11.3.8. Dictionary Trace RecordsObject DictionariesFunction DictionariesSignal Dictionaries11.3.9. Application-Specific QS Trace Records11.3.10. Porting and Configuring QS11.4. The QSPY Host Application11.4.1. Installing QSPY11.4.2. Building QSPY Application from SourcesBuilding QSPY for Windows with Visual C++ 2005Building QSPY for Windows with MinGWBuilding QSPY for Linux11.4.3. Invoking QSPY11.5. Exporting Trace Data to MATLAB11.5.1. Analyzing Trace Data with MATLAB11.5.2. MATLAB Output File11.5.3. MATLAB Script qspy.m11.5.4. MATLAB Matrices Generated by qspy.m11.6. Adding QS Software Tracing to a QP Application11.6.1. Initializing QS and Setting Up the Filters11.6.2. Defining Platform-Specific QS Callbacks11.6.3. Generating QS Timestamps with the QS_onGetTime() Callback11.6.4. Generating QS Dictionary Records from Active Objects11.6.5. Adding Application-Specific Trace Records11.6.6. “QSPY Reference Manual”11.7. Summary
12. QP-nano: How Small Can You Go?
12.1. Key Features of QP-nano12.2. Implementing the “Fly ‘n’ Shoot” Example with QP-nano12.2.1. The main() function12.2.2. The qpn_port.h Header File12.2.3. Signals, Events, and Active Objects in the “Fly ‘n’ Shoot” Game12.2.4. Implementing the Ship Active Object in QP-nano12.2.5. Time Events in QP-nano12.2.6. Board Support Package for “Fly ‘n’ Shoot” Application in QP-nano12.2.7. Building the “Fly ‘n’ Shoot” QP-nano Application12.3. QP-nano Structure12.3.1. QP-nano Source Code, Examples, and Documentation12.3.2. Critical Sections in QP-nanoTask-Level Interrupt LockingISR-Level Interrupt Locking12.3.3. State Machines in QP-nano12.3.4. Active Objects in QP-nano12.3.5. The System Clock Tick in QP-nano12.4. Event Queues in QP-nano12.4.1. The Ready-Set in QP-nano (QF_readySet_)12.4.2. Posting Events from the Task Level (QActive_post())12.4.3. Posting Events from the ISR Level (QActive_postISR())12.5. The Cooperative “Vanilla” Kernel in QP-nano12.5.1. Interrupt Processing Under the “Vanilla” Kernel12.5.2. Idle Processing under the “Vanilla” Kernel12.6. The Preemptive Run-to-Completion QK-nano Kernel12.6.1. QK-nano Interface qkn.h12.6.2. Starting Active Objects and the QK-nano Idle Loop12.6.3. The QK-nano Scheduler12.6.4. Interrupt Processing in QK-nano12.6.5. Priority Ceiling Mutex in QK-nano12.7. The PELICAN Crossing Example12.7.1. PELICAN Crossing State Machine12.7.2. The Pedestrian Active Object12.7.3. QP-nano Port to MSP430 with QK-nano Kernel12.7.4. QP-nano Memory Usage12.8. Summary
A. Licensing Policy for QP and QP-nano
A.1. Open-Source LicensingA.2. Closed-Source LicensingA.3. Evaluating the SoftwareA.4. Nonprofits, Academic Institutions, and Private IndividualsA.5. GNU General Public License Version 2
B. Guide to Notation
B.1. Class DiagramsB.2. State DiagramsB.3. Sequence DiagramsB.4. Timing Diagrams
Bibliography
Bibliography

Content preview from Practical UML Statecharts in C/C++, 2nd Edition

Chapter 3. Standard State Machine Implementations

An expert is a man who has made all the mistakes which can be made, in a narrow field.
— Niels Bohr

This chapter discusses standard state machine implementation techniques, which you can find in the literature or in the working code. They are mostly applicable to the traditional nonhierarchical extended finite state machines (FSMs) because hardly any standard implementations of hierarchical state machines (HSMs) are intended for manual coding.¹ Design automation tools often use standard state machine implementation techniques to generate code for hierarchical state machines. The resulting code, however, is typically intended not for manual maintenance but rather to be regenerated every time you change ...

Become an O’Reilly member and get unlimited access to this title plus top books and audiobooks from O’Reilly and nearly 200 top publishers, thousands of courses curated by job role, 150+ live events each month,
and much more.

Read now

Unlock full access

More than 5,000 organizations count on O’Reilly

O’Reilly covers everything we've got, with content to help us build a world-class technology community, upgrade the capabilities and competencies of our teams, and improve overall team performance as well as their engagement.

Julian F.

Head of Cybersecurity

I wanted to learn C and C++, but it didn't click for me until I picked up an O'Reilly book. When I went on the O’Reilly platform, I was astonished to find all the books there, plus live events and sandboxes so you could play around with the technology.

Addison B.

Field Engineer

I’ve been on the O’Reilly platform for more than eight years. I use a couple of learning platforms, but I'm on O'Reilly more than anybody else. When you're there, you start learning. I'm never disappointed.

Amir M.

Data Platform Tech Lead

I'm always learning. So when I got on to O'Reilly, I was like a kid in a candy store. There are playlists. There are answers. There's on-demand training. It's worth its weight in gold, in terms of what it allows me to do.

Mark W.

Embedded Software Engineer

Publisher Resources

ISBN: 9780750687065

Cloud Computing

Data Engineering

Data Science

AI & ML

Programming Languages

Software Architecture

IT/Ops

Security

Design

Business

Soft Skills

Practical UML Statecharts in C/C++, 2nd Edition

by Miro Samek

Chapter 3. Standard State Machine Implementations

Become an O’Reilly member and get unlimited access to this title plus top books and audiobooks from O’Reilly and nearly 200 top publishers, thousands of courses curated by job role, 150+ live events each month,
and much more.