With this book, you will learn the fundamentals of developing a real-time system. The book relies heavily on diagrams to make the learning process easier and more interesting for you.

• Cover
• FM
• Copyright
• Table of Contents
• Preface
• Chapter 1: Real-Time Systems – Setting the Scene
  • 1.1 Categorizing Computer Systems
  • 1.2 Real-Time Computer Systems
    • 1.2.1 Time and Criticality Issues
    • 1.2.2 Real-Time System Structures
    • 1.2.3 Characteristics of Embedded Systems
  • 1.3 The Computing Elements of Real-Time Systems
    • 1.3.1 Overview
    • 1.3.2 General-Purpose Microprocessors
    • 1.3.3 Highly Integrated Microprocessors
    • 1.3.4 Single-Chip Microcomputers
    • 1.3.5 Single-Chip Microcontrollers
    • 1.3.6 Digital Signal Processors
    • 1.3.7 Mixed-Signal Processors
    • 1.3.8 System-On-Chip Designs – Overview
    • 1.3.9 Programmable SOCs – FPGA-Embedded Processors
    • 1.3.10 SOC Devices – Single and Multicore
  • 1.4 Software for Real-Time Applications – Some General Comments
  • 1.5 Review
  • 1.6 Useful Reading Material
• Chapter 2: The Search for Dependable Software
  • 2.1 What Do We Want in Our Software?
  • 2.2 Software Errors
    • 2.2.1 Overview
    • 2.2.2 System Design Errors
    • 2.2.3 Design and Coding Errors
    • 2.2.4 Environmental Factors
    • 2.2.5 Why Do We Get Poor Software?
    • 2.2.6 Testing – How Useful?
  • 2.3 The Basics of Good Software
    • 2.3.1 General
    • 2.3.2 Specification Correctness
    • 2.3.3 Feasibility and Suitability
    • 2.3.4 Modularization
    • 2.3.5 Portability and Reusability
    • 2.3.6 Error Avoidance and Defensive Programming – Robust Programs
    • 2.3.7 Design Codes of Practice – Style, Clarity, and Documentation
  • 2.4 A Final Comment
  • 2.5 Review
  • 2.6 References
• Chapter 3: First Steps – Requirements Analysis and Specification
  • 3.1 The Software Life Cycle
    • 3.1.1 Introduction
    • 3.1.2 A Mythical Model of the Software Life Cycle
    • 3.1.3 Bringing Realism to the Life Cycle
    • 3.1.4 Requirements Issues – a Practical Approach
  • 3.2 The Importance of the Requirements Stage
  • 3.3 Making Mistakes – Sources and Causes
    • 3.3.1 A General Comment
    • 3.3.2 Problems in Formulating Specifications
    • 3.3.3 Problems in Communicating Requirements
    • 3.3.4 Problems in Understanding Requirements
  • 3.4 Practical Approaches to Analysis and Specification
    • 3.4.1 General Aspects
    • 3.4.2 Tool Support and Automation
    • 3.4.3 Viewpoint Analysis
    • 3.4.4 Viewpoints – Analysis versus Specification
    • 3.4.5 Use Case Analysis
    • 3.4.6 Functional, Non-Functional, and Development Requirements Specifications
  • 3.5 Communication Aspects – the Role of Prototyping
    • 3.5.1 Prototyping – an Introduction
    • 3.5.2 Software Prototyping
    • 3.5.3 Requirements Prototyping
    • 3.5.4 Practical Rapid Prototyping of System Requirements
    • 3.5.5 Animation Prototyping – Concepts and Application
  • 3.6 Review
  • 3.7 Exercises
  • 3.8 References and Further Reading
• Chapter 4: Software and Program Design Concepts
  • 4.1 Design Fundamentals
    • 4.1.1 The Design and Development Process – an Introduction
    • 4.1.2 Fundamental Design Strategies
    • 4.1.3 How to Generate Abysmal Software – the Good Kludge Guide
  • 4.2 The Elements of Modular Design
    • 4.2.1 Introduction
    • 4.2.2 Modules and Modularization
    • 4.2.3 Coupling – a Measure of Module Independence
    • 4.2.4 Cohesion – a Measure of Module Binding
    • 4.2.5 Size and Complexity
    • 4.2.6 Some General Comments on Modules
  • 4.3 Program Control Structures – the Influence of Structured Programming
    • 4.3.1 Introductory Comments
    • 4.3.2 Fundamental Control Structures
    • 4.3.3 Uncontrolled Branching of Control – the Great GOTO Debate
  • 4.4 Structured Software Designs
    • 4.4.1 Background
    • 4.4.2 Problem Decomposition Using Abstract Machines
    • 4.4.3 Example Implementation
  • 4.5 Object-Oriented Design
    • 4.5.1 An Introduction
    • 4.5.2 Object-Oriented Design – the Identification Process
    • 4.5.3 Relationships and Communication between Objects
    • 4.5.4 Object Interfaces
    • 4.5.5 Object-Oriented Design – Implementation-Related Issues
    • 4.5.6 Reuse and Runtime Flexibility Issues
    • 4.5.7 Composite Objects – Aggregation
    • 4.5.8 Devising the Object Model – a Responsibility-Based Technique
  • 4.6 Functionally Structured Design and Functional Flow Modeling
    • 4.6.1 Software Design and Structured Charts – Limitations
    • 4.6.2 The Materials Flow Model of Software Processing
    • 4.6.3 Software Design Using Functionally Structured Techniques
    • 4.6.4. Organizing the Execution Sequence of the Software Machines
    • 4.6.5 Functional Flow Design Using Graphical Techniques
  • 4.7 Design Patterns
    • 4.7.1 Introduction and Basic Concepts
    • 4.7.2 Program-Level Patterns
    • 4.7.3 System-Level Patterns for Real-Time Embedded Systems
  • 4.8 Review
  • 4.9 Exercises
  • 4.10 Useful Reading Material
• Chapter 5: Multitasking Systems – an Introduction
  • 5.1 The Task Model of Software
    • 5.1.1 Modeling – What and Why
    • 5.1.2 Modeling Executing Software – the Single-Task Structure
    • 5.1.3 Multiple Tasks – Why?
    • 5.1.4 Using Interrupts to Concurrent Task Operations
    • 5.1.5 Introduction to the Operating System
  • 5.2 Controlling Task Execution – Scheduling
    • 5.2.1 Scheduling and Time Slicing Operations
    • 5.2.2 Scheduling and Priority-Driven Operations
    • 5.2.3 System Responsiveness and Mixed Scheduling Policies
  • 5.3 Sharing Resources in Multitasking Systems
    • 5.3.1 Problems with Sharing Resources
    • 5.3.2 The Binary Semaphore
    • 5.3.3 The General or Counting Semaphore
    • 5.3.4 Semaphore Weaknesses
    • 5.3.5 The Mutex
    • 5.3.6 The Simple Monitor
  • 5.4 Contention Problems in Multitasking Systems
    • 5.4.1 Resource Contention and Deadlocks
    • 5.4.2 The Priority Inversion Problem
    • 5.4.3 The Priority Ceiling Protocol
  • 5.5 Inter-task Communication
    • 5.5.1 Introduction
    • 5.5.2 Task Coordination and Synchronization without Data Transfer – General Aspects
    • 5.5.3 Task Interaction without Data Transfer
    • 5.5.4 Data Transfer without Task Synchronization or Coordination
    • 5.5.5 Task Synchronization with Data Transfer
  • 5.6 Review
  • 5.7 Background Reading Material
• Chapter 6: Diagramming – an Introduction
  • 6.1 Diagrams – Why?
    • 6.1.1 Introduction
    • 6.1.2 Diagrams as a Design Tool
    • 6.1.3 Diagrams for Design Documentation
    • 6.1.4 Diagrams for Maintenance
    • 6.1.5 Diagrams for Communication
  • 6.2 The Essentials of Software Diagrams
    • 6.2.1 Fundamentals
    • 6.2.2 Basic Qualities
    • 6.2.3 Real-Time Systems Diagramming – Matching Ends to Needs
    • 6.2.4 Practical Diagramming Techniques – a General Comment
  • 6.3 Review
  • 6.4 Exercises
  • 6.5 References and Further Reading
• Chapter 7: Practical Diagramming Methods
  • 7.1 Introduction
  • 7.2 Diagrams for Functionally Structured Methods
    • 7.2.1 Context Diagrams
    • 7.2.2 Entity-Relationship Diagrams (ERDs)
    • 7.2.3 State Transition Diagrams and State Transition Tables
    • 7.2.4 Functional and Data Flow Diagrams
    • 7.2.5 Specifying Program Structures – Structure Charts, Flowcharts, and Program Description Languages
    • 7.2.6 Message Sequence Diagrams
    • 7.2.7 SDL (Specification and Description Language) Process Diagrams
    • 7.2.8 Event-Response Lists
  • 7.3 UML Diagrams for Object-Oriented Designs
    • 7.3.1 Use Case Diagrams
    • 7.3.2 Deployment Diagrams
    • 7.3.3 Packages and Package Diagrams
    • 7.3.4 Class Diagrams
    • 7.3.5 Object and Object Communication Diagrams
    • 7.3.6 Wiring Objects Together – Ports and Interfaces
    • 7.3.7 Statecharts
    • 7.3.8 Sequence Diagrams
    • 7.3.9 Activity Diagrams
    • 7.3.10 Components and Component Diagrams
    • 7.3.11 Artifacts
  • 7.4 Extensions, Variations, and Project-Specific Diagrams
  • 7.5 Diagrams and the Design Process
  • 7.6 Review
  • 7.7 Exercises
  • 7.8 References and Further Reading
• Chapter 8: Designing and Constructing Software – Code-Related Issues
  • 8.1 Fundamental Design and Construction Methods
    • 8.1.1 Introduction
    • 8.1.2 An Evaluation of Design and Construction Methods
  • 8.2 Code Development and Packaging
    • 8.2.1 Code Development and the Physical Software Model
    • 8.2.2 Software Construction Methods – General
    • 8.2.3 Introduction to Component Technology
    • 8.2.4 Code Packaging and Components
    • 8.2.5 Classes, Packages, and Artifacts
  • 8.3 Important Features of Programming Languages
    • 8.3.1 Introduction
    • 8.3.2 Choosing a Programming Language – the Real Questions
    • 8.3.3 High-Level Languages – General Requirements
    • 8.3.4 Modularity, Encapsulation, and Information Hiding
    • 8.3.5 Program Syntax and Layout Rules – the Readability Factor
    • 8.3.6 Variable Usage – Scope, Visibility, Lifetime, and Declaration.
    • 8.3.7 Data Types – Concepts and Uses
    • 8.3.8 Program Flow Control
    • 8.3.9 Interfacing to Other Languages
    • 8.3.10 Exception Handling
    • 8.3.11 Accessing Processor Hardware – Low-Level Facilities
    • 8.3.12 Assembly Language Programming
    • 8.3.13 Miscellaneous Items
  • 8.4 Choosing a High-Level Language for Embedded Systems
    • 8.4.1 Basic Requirements
    • 8.4.2 Assessed Languages – Background
    • 8.4.3 Assessed Languages – Comparison and Comment
    • 8.4.4 Python and MicroPython
  • 8.5 Review
  • 8.6 Important and Useful Reading
• Chapter 9: Software Analysis and Design – Methods and Methodologies
  • 9.1 The Development Process
    • 9.1.1 General Description
    • 9.1.2 Methods, Methodologies, and Tools
  • 9.2 Viewpoint Analysis for Deriving Requirements
    • 9.2.1 Viewpoint Analysis and CORE
    • 9.2.2 CORE Fundamentals
    • 9.2.3 Detailed Aspects and Notation
    • 9.2.4 Design Example – Steam Propulsion System
    • 9.2.5 A Comment on Analysis Tools
  • 9.3. Design Implementation Using Functionally Structured Techniques
    • 9.3.1 Overview of the Design Process
    • 9.3.2 Developing the Ideal Model
    • 9.3.3 Developing the Practical Model
  • 9.4 Object-Oriented Analysis and Design
    • 9.4.1 Design Example – Dipmeter Wireline Logging Tool
    • 9.4.2 A Practical OOAD Development Process
    • 9.4.3 Defining System Usage
    • 9.4.4 Developing the Subsystem Structures
    • 9.4.5 Developing the Ideal Model Object Structures
    • 9.4.6 Developing the Specification Model Object Structures
    • 9.4.7 Developing the Individual Processor Object Models
    • 9.4.8 Developing the Multitasking Model
    • 9.4.9 Developing Individual Tasks
    • 9.4.10 Packaging the Software
  • 9.5 Model-Driven Architecture
    • 9.5.1 Fundamental Concepts
    • 9.5.2 The PIM in Detail
    • 9.5.3 Example Structural Model – from PIM to PSM to Code
    • 9.5.4 Closing Comments
  • 9.6 Model-Based Design (MBD)
    • 9.6.1 MBD versus MDA
    • 9.6.2 MBD – an Overview
    • 9.6.3 Applying the MBD Process – a Brief Outline
  • 9.7 Agile Software Development
    • 9.7.1 Introduction and Basic Concepts
    • 9.7.2 Agile Methods for Embedded Applications – the Interface Issue
    • 9.7.3 The Issue of Project Development Methods – Agile versus Embedded
    • 9.7.4 Practical Incremental Development Methods for Embedded Systems
  • 9.8 Review
  • 9.9 Further Useful Reading
• Chapter 10: Analyzing and Testing Source Code
  • 10.1 Introduction
    • 10.1.1 General Concepts
    • 10.1.2 Software Evaluation Issues
    • 10.1.3 Software Testing – the Broader Issues
  • 10.2 Static Analysis
    • 10.2.1 Introduction
    • 10.2.2 Manual Static Analysis Methods
    • 10.2.3 Automated Static Analysis Methods
  • 10.3 Source Code Metrics – Code Size, Content, and Complexity
    • 10.3.1 General
    • 10.3.2 Halstead Software Metrics
    • 10.3.3 The McCabe Cyclomatic Complexity Metric
  • 10.4 Dynamic Analysis – Testing and Coverage Analysis
    • 10.4.1 Overview of Dynamic Testing
    • 10.4.2 Dynamic Testing in a Manual Environment
    • 10.4.3 Dynamic Testing in an Automated Environment
    • 10.4.4. Coverage Analysis
    • 10.4.5. Practical Automated Dynamic Analysis
  • 10.5 Integration Testing
    • 10.5.1 Fundamentals
    • 10.5.2 Integration and Test Strategies (1) – Combined Module and Integration Testing
    • 10.5.3 Integration and Test Strategies (2) – Integration Testing Based on Unit Calls
    • 10.5.4 Integration Complexity
  • 10.6 Metrics for OO Designs
    • 10.6.1 General Aspects
    • 10.6.2 Inheritance, Polymorphism, and Testing Issues
  • 10.7 Review
  • 10.8 Further Reading
• Chapter 11: Development Tools
  • 11.1 An Outline of the Modern Development Process for Embedded Systems
  • 11.2 The Software Development Process for Embedded Systems
    • 11.2.1 The Software Production Cycle
    • 11.2.2 Programming the Target Microcontroller
    • 11.2.3 Simplifying the Process – Processor Configuration Tools
    • 11.2.4 Finding and Fixing Software Problems
    • 11.2.5 The Basics of Efficient Development Processes
  • 11.3 Software Debugging – What and Why?
    • 11.3.1 Debugging – Fundamental Concepts
    • 11.3.2 Debugger – Basic Requirements and Operation
    • 11.3.3 Development and Debugging Environments
  • 11.4 Software Debugging on the Host
    • 11.4.1 Host System Debugging – a Broad Overview
    • 11.4.2 The Pros and Cons of Host System Debugging
  • 11.5 Software Debugging on the Target – Software-Based Techniques
    • 11.5.1 General
    • 11.5.2 A Simple Monitor Program
    • 11.5.3 In-Target Source-Level Debugging
    • 11.5.4 The Last Comment
  • 11.6 Software Debugging in the Target – Hardware-Based Methods
    • 11.6.1 Introduction
    • 11.6.2 A Basic Test Tool – the Bus Monitor
    • 11.6.3 The Logic Analyzer
    • 11.6.4 The In-Circuit Emulator
  • 11.7 Software Debugging in The Target – Combined Hardware/Software Techniques
    • 11.7.1 Host/Target Interactive Debugging – Software Tracing
    • 11.7.2 On-Chip Debugging Methods – Overview
    • 11.7.3 Simple Static On-Chip Debugging Methods
    • 11.7.4 Dynamic OCD Schemes
  • 11.8 Debugging in Host-As-Target Combinations
    • 11.8.1 Background
    • 11.8.2 PC-Based Targets – The Embedded PC
    • 11.8.3 A PC as a Target
  • 11.9 Testing Multitasking Software
    • 11.9.1 Basic Issues
    • 11.9.2 Practical Tool Aspects
  • 11.10 Installing Code on the Target – Non-Volatile Software (Firmware)
    • 11.10.1 Overview
    • 11.10.2 The PROM Programmer
    • 11.10.3 EPROM Emulators
    • 11.10.4 In-Circuit Programming
  • 11.11 Integrated Development Toolsets
    • 11.11.1 Backend Toolsets
    • 11.11.2 Fully Integrated Real-Time Development Environments
  • 11.12 Review
• Chapter 12: Mission-Critical and Safety-Critical Systems
  • 12.1 Introduction
    • 12.1.1 Overview of Critical Systems
    • 12.1.2 How Critical is Critical?
    • 12.1.3 Improving System Reliability and Availability – General Strategies
  • 12.2 System Specification Aspects
    • 12.2.1 The Specification Problem – Again
    • 12.2.2 Why Mathematics?
    • 12.2.3 Formal Methods – General Concepts
    • 12.2.4 Formal Specification Languages
    • 12.2.5 An Example Formal Specification Using VDM
  • 12.3 Numerical Issues
    • 12.3.1 Problems in Disguise
    • 12.3.2 Making Measurements
    • 12.3.3 Basic Number Representation and Arithmetic
    • 12.3.4 The Limitations of Finite Number Systems – General Points
    • 12.3.5 Infinite Numbers, Model Numbers, and Error Bounds
    • 12.3.6 Problems in Floating-Point Working
    • 12.3.7 Problems in Fixed-Point Working
    • 12.3.8 Internal Representation and Binary Notation
  • 12.4 Application Software Aspects
    • 12.4.1 Basic Design and Programming Issues (or Doing It Right in the First Place)
    • 12.4.2 Dealing with Runtime Problems
  • 12.5 Real-World Interfacing
    • 12.5.1 Background
    • 12.5.2 Fault Types and Identification – Inputs
    • 12.5.3 Fault Detection Methods – Inputs
    • 12.5.4 Fault Handling – Outputs
  • 12.6 Operating Systems Aspects
    • 12.6.1 General
    • 12.6.2 Protection Techniques
    • 12.6.3 Tasking Models and Scheduling
    • 12.6.4 Operating Systems and Critical Distributed Applications
  • 12.7 Processor Problems
    • 12.7.1 Overview
    • 12.7.2 Power-On Aspects
    • 12.7.3 Runtime Issues
  • 12.8 Hardware-Based Fault Tolerance
    • 12.8.1 General Aspects
    • 12.8.2 Fault-Tolerant Structures
    • 12.8.3 Matching Structures to Requirements
  • 12.9 Review
  • 12.10 References and Further Reading
  • 12.11 Some Important Standards
• Chapter 13: Performance Engineering
  • 13.1 Why Performance Engineering Is Important
    • 13.1.1 Time as a Design Driver
    • 13.1.2 Ignore Performance at Your Peril – Reactive versus Proactive Techniques
  • 13.2 Performance Engineering – Requirements, Targets, and Achievables
  • 13.3 Top-Down (Requirements-Driven) Performance Modeling
    • 13.3.1 Specifying Targets – the Project-Management Analogy
    • 13.3.2 Performance Targets and Time Budgeting in Real-Time Systems
  • 13.4 Bottom-Up (Results-Driven) Performance Modeling
  • 13.5 Middle-Out (Risk-Driven) Performance Modeling
  • 13.6 Some Practical Issues in Performance Engineering
    • 13.6.1 A General Comment
    • 13.6.2 Modeling and Simulation Options
  • 13.7 Review
  • 13.8 References and Further Reading
• Chapter 14: Documentation
  • 14.1 Documentation – What and Why?
    • 14.1.1 The Role of Documentation
    • 14.1.2 Documentation – Its Structure
    • 14.1.3 A Model for System Documentation
  • 14.2 Software Life Cycle Documentation – Overview
  • 14.3 System Functional Specifications
    • 14.3.1 Overview
    • 14.3.2 Block Diagram Description
    • 14.3.3 Functional Diagram Description
    • 14.3.4 Requirements Specification
  • 14.4 Software System Specifications
  • 14.5 Source Code Aspects
    • 14.5.1 Source Code Documentation – a Philosophy
    • 14.5.2 Source Code Documentation – Practice
    • 14.5.3 Source Code Review Documentation
  • 14.6 Configuration Management and Version Control
    • 14.6.1 General Aspects
    • 14.6.2 More on Source Code Version Control
  • 14.7 Review
  • 14.8 Further Information
• Glossary of terms
• Index