This book integrates new ideas and topics from real time systems, embedded systems, and software engineering to give a complete picture of the whole process of developing software for real-time embedded applications. You will not only gain a thorough understanding of concepts related to microprocessors, interrupts, and system boot process, appreciating the importance of real-time modeling and scheduling, but you will also learn software engineering practices such as model documentation, model analysis, design patterns, and standard conformance.
This book is split into four parts to help you learn the key concept of embedded systems; Part one introduces the development process, and includes two chapters on microprocessors and interrupts---fundamental topics for software engineers; Part two is dedicated to modeling techniques for real-time systems; Part three looks at the design of software architectures and Part four covers software implementations, with a focus on POSIX-compliant operating systems.
With this book you will learn:
- The pros and cons of different architectures for embedded systems
- POSIX real-time extensions, and how to develop POSIX-compliant real time applications
- How to use real-time UML to document system designs with timing constraints
- The challenges and concepts related to cross-development
- Multitasking design and inter-task communication techniques (shared memory objects, message queues, pipes, signals)
- How to use kernel objects (e.g. Semaphores, Mutex, Condition variables) to address resource sharing issues in RTOS applications
- The philosophy underpinning the notion of 'resource manager' and how to implement a virtual file system using a resource manager
- The key principles of real-time scheduling and several key algorithms
- Coverage of the latest UML standard (UML 2.4)
- Over 20 design patterns which represent the best practices for reuse in a wide range of real-time embedded systems
- Example codes which have been tested in QNX---a real-time operating system widely adopted in industry
Dr. Xiaocong (Simon) Fan is an Associate Professor of Computer Science and Software Engineering at Pennsylvania State University. He received his Ph.D. in Software Engineering from Nanjing University, China. He has been an active researcher in the fields of Multi-Agent Systems, Formal Methods in Software Engineering, and Advanced Decision-Support Systems. He is a key architect of several intelligent agent systems, including RCAST and SMMall. Dr. Fan is a Senior Member of IEEE.
This book integrates new ideas and topics from real time systems, embedded systems, and software engineering to give a complete picture of the whole process of developing software for real-time embedded applications. You will not only gain a thorough understanding of concepts related to microprocessors, interrupts, and system boot process, appreciating the importance of real-time modeling and scheduling, but you will also learn software engineering practices such as model documentation, model analysis, design patterns, and standard conformance.This book is split into four parts to help you learn the key concept of embedded systems; Part one introduces the development process, and includes two chapters on microprocessors and interrupts---fundamental topics for software engineers; Part two is dedicated to modeling techniques for real-time systems; Part three looks at the design of software architectures and Part four covers software implementations, with a focus on POSIX-compliant operating systems.With this book you will learn:The pros and cons of different architectures for embedded systems POSIX real-time extensions, and how to develop POSIX-compliant real time applications How to use real-time UML to document system designs with timing constraintsThe challenges and concepts related to cross-development Multitasking design and inter-task communication techniques (shared memory objects, message queues, pipes, signals)How to use kernel objects (e.g. Semaphores, Mutex, Condition variables) to address resource sharing issues in RTOS applications The philosophy underpinning the notion of "e;resource manager"e; and how to implement a virtual file system using a resource manager The key principles of real-time scheduling and several key algorithms Coverage of the latest UML standard (UML 2.4) Over 20 design patterns which represent the best practices for reuse in a wide range of real-time embedded systems Example codes which have been tested in QNX---a real-time operating system widely adopted in industry
Front Cover 1
Real-Time Embedded Systems: Design Principles and Engineering Practices 4
Copyright 5
Contents 6
Preface 16
Acknowledgments 20
Dedication 22
Acronyms 24
Part I: Introduction 26
Chapter 1: Introduction to Embedded and Real-Time Systems 28
1.1 Embedded Systems 28
1.2 Real-Time Systems 30
1.2.1 Soft Real-Time Systems 30
1.2.2 Hard Real-Time Systems 31
1.2.3 Spectrum of Real-Time Systems 32
1.3 Case Study: Radar System 33
Problems 38
Chapter 2: Cross-Platform Development 40
2.1 Cross-Platform Development Process 41
2.2 Hardware Architecture 42
2.3 Software Development 43
2.3.1 Software Design 43
2.3.2 System Programming Language C/C++ 43
2.3.2.1 Declarations and definitions 45
2.3.2.2 Scope regions 46
2.3.2.3 Storage duration 47
2.3.2.4 Linkage 47
2.3.2.5 Storage-class specifiers 48
2.3.3 Test Hardware-Independent Modules 50
2.4 Build Target Images 50
2.4.1 Cross-Development Toolchain 50
2.4.1.1 Cross compiler/assembler 50
2.4.1.2 Linker 52
2.4.1.3 Dynamic linker 53
2.4.2 Executable and Linking Format 53
2.4.2.1 Linking view 55
2.4.2.2 Execution view 57
2.4.3 Memory Mapping 59
2.4.4 Case Study: Building a QNX Image 61
2.5 Transfer Executable File Object to Target 63
2.6 Integrated Testing on Target 64
2.7 System Production 64
Problems 65
Chapter 3: Microprocessor Primer 66
3.1 Introduction to Microprocessors 67
3.1.1 Commonly Used Microprocessors 67
3.1.2 Microprocessor Characteristics 69
3.1.2.1 Architectures 69
3.1.2.2 Processing width 71
3.1.2.3 I/O addressing 71
3.1.2.4 Reset vector 71
3.1.2.5 Endianness 72
3.2 Microchip PIC18F8720 73
3.2.1 Memory Organization 73
3.2.2 Word Write Mode 77
3.2.3 Byte Select Mode 79
3.2.4 Byte Write Mode 82
3.3 Intel 8086 83
3.3.1 Memory Organization 85
3.3.2 Separate I/O Address Space 86
3.3.2.1 Timing clock 87
3.3.2.2 External bus 88
3.3.2.3 I/O device: UART 88
3.3.3 Memory Address Space 89
3.3.4 Wait States 90
3.4 Intel Pentium 93
3.4.1 Bus State Transition 96
3.4.2 Memory Organization 100
3.5 ARM926EJ-S 102
3.5.1 TCM Interface 103
Problems 106
Chapter 4: Interrupts 110
4.1 Introduction to Interrupts 111
4.2 External Interrupts 111
4.2.1 Nonvectored Interrupting 112
4.2.2 PIC and Vectored Interrupting 113
4.2.2.1 Maskable interrupts 114
4.2.2.2 Interrupt priorities 115
4.2.2.3 Interrupt source mode 116
4.2.2.4 Interrupt vectoring process 118
4.3 Software Interrupts 120
4.4 Internal Interrupts 121
4.5 Design Patterns for ISRs 122
4.5.1 General ISR Design Pattern 122
4.5.2 ISR with a Server Task 123
4.5.3 ISR Chaining 124
4.5.4 ISR Cascading 125
4.5.5 Data Sharing with ISRs 126
4.6 Interrupt Response Time 129
4.7 Case Study: x86 130
4.7.1 Hardware Interrupts 133
4.7.2 Put It All Together 135
4.8 Case Study: ARM Processor 136
4.8.1 Hardware Interrupts 138
4.8.2 Put It All Together 140
Problems 142
Chapter 5: Embedded System Boot Process 144
5.1 System Bootloader 144
5.2 System Boot Process 145
5.2.1 Load Embedded Software 145
5.2.1.1 From host node 146
5.2.1.2 From NVM on board 147
5.2.2 Prepare Embedded Software for Execution 147
5.2.2.1 Decode compressed ELF object 147
5.2.2.2 Create executable image 147
5.3 Case Study: AT91SAM9G45 Boot Process 148
5.4 Load ELF Objects Embedded Within an OS Image 149
5.5 Case Study: Boot Process of QNX-based Embedded Systems 150
Problems 152
Part II: Real-Time System Modeling 154
Chapter 6: Fundamental UML Structural Modeling 156
6.1 Unified Modeling Language 157
6.2 Class Diagram and Class Modeling 158
6.2.1 Class 161
6.2.1.1 OCL constraints on classes 163
6.2.1.2 Template class 165
6.2.2 Instance-Level Relationships 166
6.2.2.1 Association 166
Binary association 166
Association class 170
N-ary association 173
6.2.2.2 Aggregation 175
6.2.2.3 Composition 175
6.2.2.4 OCL expressions for association navigation 177
6.2.3 Dependency Relationships 181
6.2.3.1 Abstraction 181
6.2.3.2 Interface realization 183
6.2.3.3 Comparison: interface and abstract class 183
6.2.3.4 Usage 184
6.2.4 Generalization 186
6.2.4.1 Inheritance as subcontracting 188
6.2.4.2 Liskov substitution principle 189
6.3 Class Modeling Principles 191
6.3.1 Model Evolution 191
6.3.2 Subclassing 192
6.3.3 Minimum Information Redundancy 195
6.3.4 Refactoring 198
6.4 Object Diagram 202
6.5 Package Diagram 202
6.5.1 Package Import 204
6.5.2 Package Merge 205
Problems 208
Chapter 7: Architecture Modeling in UML 210
7.1 Levels of Architectural Abstraction 210
7.2 UML Structure Diagram 211
7.3 Modeling Components 217
7.4 Modeling Subsystems 220
7.4.1 Class Diagram Versus Subsystem Diagram 222
7.5 Modeling a Complete System 224
7.6 Deployment Diagram 225
Problems 226
Chapter 8: Fundamental UML Behavioral Modeling 228
8.1 Use Case Diagram and Use Case Modeling 228
8.1.1 Use Case Diagram 228
8.1.2 Use Case Descriptions 232
8.1.3 Use Case Levels 234
8.2 Sequence Diagram 235
8.3 Activity Diagram 239
Problems 246
Chapter 9: Modeling Stateful Behaviors in UML 248
9.1 Basics of a State Machine Diagram 248
9.1.1 States 249
9.1.2 Transitions and Events 249
9.1.3 Pseudostates 251
9.1.4 A Network Protocol Modeled by State Machines 253
9.2 Composite States 255
9.2.1 Entry Point, Exit Point, and History 255
9.2.2 Concurrency 258
9.3 Inheritance of State Behavior 259
9.4 Stateful Object Timing Diagrams 261
9.5 Example: Modeling Stateful Behavior of a Radar System 262
9.5.1 Modeling the Transceiver 264
9.5.2 Modeling the Link Driver 266
9.5.3 Modeling the Command Messenger 268
Problems 270
Chapter 10: Real-Time UML: General Resource Modeling 272
10.1 Real-Time UML Profile 272
10.1.1 Meta Modeling, UML Stereotypes, and Tags 273
10.2 Resource Modeling 276
10.2.1 UML Core Resource Model 277
10.2.2 Action and Action Execution 279
10.2.3 UML Stereotypes for Protected Resources 280
10.2.4 Resource Usage 282
10.2.5 Resource-Client Graph 284
10.3 Time Modeling 285
10.3.1 The Notion of Time 285
10.3.2 Timing Mechanisms 286
10.3.3 Time Modeling Stereotypes 289
10.4 Concurrency Modeling 291
Problems 295
Chapter 11: Real-Time UML: Model Analysis 296
11.1 Elicitation of Timing Constraints 296
11.2 RT-UML Profile Schedulability Modeling Subprofile 300
11.2.1 RT-UML Profile Metaconcepts for Schedulability Analysis 300
11.2.1.1 Concepts for schedulability contexts 300
11.2.1.2 Actions 304
11.2.1.3 Scheduling job 305
11.2.2 Schedulability Stereotypes 306
11.2.3 Using the Schedulability Subprofile 309
11.3 RT-UML Profile Performance Modeling Subprofile 311
11.3.1 RT-UML Profile Metaconcepts for Performance Analysis 311
11.3.2 Performance Stereotypes 314
11.3.3 Using the Performance Subprofile 316
Problems 321
Part III: Real-Time System Design 326
Chapter 12: Software Architectures for Real-Time Embedded Systems 328
12.1 Real-Time Tasks 329
12.1.1 Worst-Case Task Execution Time 329
12.1.2 Task Specification 331
12.1.3 Task Timing Diagrams 331
12.1.4 Worst-Case Response Time 334
12.1.5 Task Implementation 335
12.2 Round-Robin Architecture 335
12.2.1 Case Study: Body Thermometer 335
12.2.1.1 Hardware design 336
12.2.1.2 Design of software architecture 336
12.2.1.3 Worst-case task response time 338
12.2.1.4 Hardware concurrency 340
12.2.2 General Round-Robin Architecture 345
12.2.3 Worst-Case Event Response Time 347
12.3 Round Robin with Interrupts 349
12.3.1 Case Study: The Simon Game 349
12.3.1.1 Hardware design 350
12.3.1.2 Software architecture design 350
12.3.2 General Architecture 353
12.3.3 Worst-Case Event Response Time 356
12.4 Queue-Based Architecture 358
12.4.1 Nonpreemptive FIFO Queue 359
12.4.2 Nonpreemptive Priority Queue 360
Problems 362
Chapter 13: POSIX and RTOS 364
13.1 Introduction to POSIX 364
13.1.1 POSIX Processes and Threads 365
13.1.1.1 Process creation 366
13.1.1.2 Thread creation 367
13.1.2 POSIX Real-Time Extensions 367
13.1.2.1 Priority-based scheduling 368
13.1.2.2 Task synchronization 371
13.1.2.3 Other services 372
13.1.3 POSIX Compliance and Conformance 375
13.2 Task Statics and Dynamics 376
13.2.1 General Task Structure 376
13.2.2 Task State Transition 378
13.3 Real-Time OSs 380
13.4 POSIX Real-Time Scheduling Policies 383
13.4.1 FIFO Scheduling Policy 384
13.4.2 Round-Robin Scheduling Policy 385
13.4.3 Sporadic Server Scheduling Policy 386
13.5 Other Real-Time Scheduling Policies 389
13.5.1 Minimum Laxity First 389
13.5.2 Earliest Deadline First 390
13.5.3 Scheduling with Deadline-Monotonic Assignment 391
13.5.4 Scheduling with Rate-Monotonic Assignment 392
Problems 393
Chapter 14: Multitasking 394
14.1 Introduction to Multitasking 394
14.2 Multitask Design 395
14.2.1 Task Identification 396
14.2.1.1 System context diagram 396
14.2.1.2 Task diagram 399
14.2.2 Task Transformation 400
14.2.2.1 Serial port design pattern 400
14.2.2.2 Task splitting strategies 404
14.2.3 Task Parameter Estimation 405
14.3 Multitask Resource Sharing 406
14.3.1 Resource Deadlocks 408
14.3.2 Priority Inversion 409
14.4 Addressing Resource Deadlocks 411
14.4.1 Deadlock Prevention 411
14.4.2 Deadlock Detection 412
14.4.3 Deadlock Avoidance 413
14.4.3.1 Safe state 413
14.4.3.2 The banker’s algorithm 414
14.5 Addressing Priority Inversion 415
14.5.1 Priority Inheritance Protocol 416
14.5.2 Highest Locker Protocol 417
14.5.3 Priority Ceiling Protocol 419
Problems 422
Chapter 15: Real-Time Scheduling: Clock-Driven Approach 424
15.1 Introduction to Cyclic Scheduling 424
15.1.1 Assumptions 425
15.1.2 Preemptable Aperiodic Jobs 426
15.2 Ad-hoc Clock-Driven Scheduling 427
15.2.1 Ad-hoc Clock-Driven Scheduler 428
15.2.2 Execution Overhead 429
15.3 Frame-Based Scheduling 430
15.3.1 Constraints on Frame Size 430
15.3.2 Robust Frame-Based Schedule 434
15.3.3 Frame-Based Scheduler 436
15.4 Scheduling Aperiodic Jobs 437
15.5 Task Splitting 439
Problems 442
Chapter 16: Real-Time Scheduling: Rate-Monotonic Approach 444
16.1 Priority Assignment 444
16.2 RMA Principle 446
16.3 Rate-Monotonic Analysis 449
16.4 Completion-Time Test 451
16.5 Period Transformation 454
16.6 Generalized Schedulability Analysis 459
16.6.1 Tasks with Blocking Time 459
16.6.1.1 Generalized bound test 460
16.6.1.2 Generalized completion-time test 461
16.6.2 Tasks with Earlier Deadlines 463
16.6.3 Example 465
16.6.3.1 Rough bound test 465
16.6.3.2 Generalized bound test 466
16.6.3.3 Generalized completion-time test 467
16.6.4 Tasks with Equal Priorities 469
Problems 470
Chapter 17: Real-Time Scheduling: Sporadic Server 474
17.1 Sporadic Tasks 474
17.2 Sporadic Server 475
17.2.1 Task Design for Sporadic Servers 476
17.2.2 Acceptance Test 477
17.3 A Naive Sporadic Server 481
17.3.1 Task Design 482
17.3.2 Acceptance Test 482
17.4 A Fixed-Priority Sporadic Server 483
17.5 A Dynamic-Priority Sporadic Server 490
Problems 493
Chapter 18: Resource Sharing 498
18.1 Shared Variables 498
18.2 Shared Memory 502
18.2.1 Mapping File Objects 503
18.2.2 Shared Memory Objects 506
18.3 Semaphore 508
18.3.1 Task Synchronization 510
18.3.2 Flow Control 512
18.3.3 Resource Protection 513
18.3.4 POSIX Functions for Semaphores 515
18.3.5 Semaphore Examples 516
18.3.5.1 Use a named semaphore to protect a memory-mapped file 516
18.3.5.2 Use a named semaphore to protect a shared memory object 518
18.3.5.3 Use an unnamed semaphore embedded in a shared memory object 522
18.4 Mutex 524
18.4.1 Mutex Usage Pattern 525
18.4.2 POSIX Functions for Mutexes 528
18.4.3 An Example of Using a Mutex 529
18.5 Condition Variable 532
18.5.1 Barrier Synchronization 534
18.5.2 Producer-Consumer Pattern 539
18.5.3 Read-Write Locks 544
Problems 550
Chapter 19: Intertask Communication: Message Queue 552
19.1 Introduction to Message Queues 552
19.2 Message Queue Statics and Dynamics 553
19.3 Message Queue Usage Patterns 556
19.3.1 Unidirectional Communication 557
19.3.2 Acked-Unidirectional Communication 558
19.3.3 Bidirectional Communication 559
19.3.4 Client-Server Communication 561
19.4 POSIX Functions for Message Queues 563
19.5 An Example of Using Message Queues 566
Problems 572
Chapter 20: Intertask Communication: Pipe 574
20.1 Introduction to Pipes 574
20.2 Pipe Statics and Dynamics 575
20.3 Pipe Usage Patterns 577
20.4 POSIX Functions for Pipes 578
20.4.1 Multiple Writers and Readers 580
20.4.2 POSIX Select Operation on Pipes 582
20.5 An Example of Using Pipes 583
Problems 588
Chapter 21: Intertask Communication: Signaling 590
21.1 Introduction to POSIX Signals 590
21.2 Signal Handling 592
21.3 Signal Vector Table and Handlers 593
21.4 POSIX Signal Functions 594
21.5 QNX Implementation of POSIX Signals 595
21.5.1 Example: Handling Signals in Different Processes 595
21.5.2 Example: Controlling a Task Server 598
21.6 Spinlocks and Interrupt Events from ISRs 602
21.6.1 POSIX Spinlocks 602
21.6.2 QNX Event Structure 602
21.6.3 Interrupt Handling in QNX Applications 603
21.6.4 Example: Interrupt Events from ISRs 604
21.7 QNX Pulses 612
21.7.1 QNX Synchronous Message Passing 612
21.7.1.1 Channels and connections 613
21.7.1.2 Synchronous communication 614
21.7.2 QNX Asynchronous Pulsing Mechanism 616
21.7.3 Hierarchical Messaging Pattern 618
21.7.4 Priority Inheritance by Message Receivers 619
21.7.5 Example: A Simple Timer Manager 619
Problems 630
Chapter 22: Software Timer Management 632
22.1 Hardware Timer and Software Timer 632
22.2 Software Timer Manager 635
22.2.1 Chain a Dedicated Timer ISR 636
22.2.2 Use an OS Timer 637
22.3 Timing Wheels 637
22.3.1 Precision Error 640
22.3.2 Timers with Wide Ranges 642
22.4 Hierarchical Timing Wheels 643
22.4.1 Reference Context and Timer Management 644
22.4.2 Implementation 645
Problems 649
Chapter 23: QNX Resource Management 650
23.1 Introduction to QNX Resource Management 650
23.2 Resource Manager Architecture 651
23.2.1 Control Structure 653
23.2.2 Key Data Structures 654
23.3 Example 1: Calculator as a Resource Manager 655
23.3.1 Superstructure 655
23.3.2 Handle Messages from Clients 657
23.3.3 Register to Process Manager 664
23.3.4 Use Resource Manager 665
23.4 Example 2: Device Drivers 667
23.4.1 Joysticks 667
23.4.2 LEDs 668
23.4.3 Polling-Based Input Event Detection 670
Problems 673
References 674
Index 678
Preface
Xiaocong Fan, Erie, PA
An embedded system is an electronic system that is designed to perform a dedicated function within a larger system. Real-time systems are those that can provide guaranteed worst-case response times to critical events, as well as acceptable average-case response times to noncritical events. When a real-time system is designed as an embedded component, it is called a real-time embedded system. Real-time embedded systems are widespread in consumer, industrial, medical, and military applications.
As more and more of our daily life depends on embedded technologies, the demand for engineers with the skill set for the development of real-time embedded software has soared in recent years. As a consequence, preparing students for the design and implementation of embedded software is becoming increasingly important. This textbook is written especially for advanced undergraduates or master-level students who are pursuing a major in software engineering, computer engineering, or a related discipline. The textbook may also benefit practicing engineers with a concentration in embedded software development.
This book takes a synergetic approach to introducing ideas and topics from real-time systems, embedded systems, and software development principles. Readers will not only gain a thorough understanding of concepts related to microprocessors, interrupts, and the cross-platform development process, and appreciate the importance of real-time modeling and scheduling, they will also be trained in good software engineering practices such as model documentation, model analysis, design patterns, and system standard conformance.
This textbook features three aspects that are essential for the development of real-time embedded software.
First, developing software for real-time embedded systems involves many activities, including specification of requirements, timing analysis, architecture design, multitasking design, and cross-platform testing and debugging. This book covers the whole process of embedded software development, with some topics fully explained and others only briefly mentioned (e.g., debugging and testing). In particular, this book presents various embedded software architectures in a systematic way, with a focus on a real-time operating system, which is the most advanced architecture adopted in large real-time embedded systems. Moreover, we have chosen to place significant emphasis on reusable design solutions. As shown in Table 0.1, this book introduces many design patterns, which represent the best practices that can be reused in a wide range of real-time embedded systems.
Table 0.1
Summary of design patterns
| Category | Pattern Name | Where in the Book |
| ISR | ISR-Pattern-min | Section 4.5.1 |
| ISR-Pattern-server | Section 4.5.2 |
| Interrupt chaining | Figure 4.7 in Section 4.5.3 |
| Interrupt cascading | Figure 4.9 in Section 4.5.4 |
| Interrupt disabling | Figure 4.11 in Section 4.5.5 |
| Double buffering | Figure 4.12 in Section 4.5.5 |
| Honor first request | Figure 12.17 in Section 12.3.2 |
| Subclassing | Abstraction-occurrence | Figure 6.25 in Section 6.3.4 |
| General hierarchy | Figure 6.27 in Section 6.3.4 |
| Software architecture | Round-robin DAS | Figure 12.10 in Section 12.2.2 |
| Round robin with interrupts | Figure 12.16 in Section 12.3.2 |
| FIFO queuing | Figure 12.20 in Section 12.4.1 |
| Priority queuing | Figure 12.21 in Section 12.4.2 |
| Serial port design pattern | Figure 14.5 in Section 14.2.2.1 |
| Static task scheduler | Clock based | Section 15.2 |
| Frame based | Section 15.3 |
| Timing wheel | Section 22.3 |
| Semaphore/mutex | Rendezvous synchronization pattern | Figure 18.8 in Section 18.3.1 |
| Multi-instance resource protection | Figure 18.19 in Section 18.4.1 |
| Condition variable | Barrier synchronization pattern | Figure 18.24 in Section 18.5.1 |
| Producer-consumer pattern | Figure 18.25 in Section 18.5.2 |
| Read-write lock pattern | Figure 18.30 in Section 18.5.3 |
| Message queue | Unidirectional queuing pattern | Figure 19.5 in Section 19.3.1 |
| Acked-unidirectional queuing pattern | Figure 19.6 in Section 19.3.2 |
| Bidirectional queuing pattern | Figure 19.7 in Section 19.3.3 |
| Client-server queuing pattern | Figure 19.10 in Section 19.3.4 |
| Pipe | Unidirectional piping pattern | Figure 20.4 in Section 20.3 |
| Bidirectional piping pattern | Figure 20.4 in Section 20.3 |
| Deadlock avoidance | Hierarchical messaging pattern | Figure 21.8 in Section 21.7.3 |
DAS, detect-acknowledge-service; FIFO, first in first out; ISR, interrupt service routine.
Second, Unified Modeling Language (UML) is a graphical language for specifying, visualizing, constructing, and documenting software systems. UML is useful in a variety of engineering problems, from single-process, embedded systems and stand-alone user applications to concurrent, distributed systems. This text features UML 2.4, the latest UML standard as of this writing. Throughout the book, UML diagrams are used for both system designs and concept illustrations. In particular, the UML real-time profile is carefully presented so that students can learn how to document their designs of real-time systems in a professional way.
Third, POSIX (for “portable operating system interface”) is an open operating system interface standard that has been developed to promote interoperability and portability of applications across variants of Unix operating systems. Software systems built upon one real-time operating system can be easily ported to other POSIX-compliant operating systems. This text features POSIX.1-2008 (2013 edition). The operating system services and concepts covered in this book are fully compatible with the POSIX.1-2008 standard. The example codes provided in this book have been tested in QNX—a real-time operating system widely adopted in industry. Since QNX is POSIX compliant, the programs may also be compiled, without changing the source code, for execution on another POSIX-compliant operating system.
Briefly, this textbook consists of four parts:
• Part I is dedicated to a basic introduction to real-time embedded systems and the iterative development process. Although our emphasis is on the software aspects, complete isolation from the underlying hardware is neither feasible nor desirable. For such a reason, this part also contains two chapters on microprocessors and interrupts—fundamental topics for software engineers who wish to build embedded systems.
• Part II is dedicated to modeling techniques for real-time systems. In particular, we introduce the modeling tools covered by UML—a standard widely adopted in both academia and the software industry. Moreover, we introduce real-time UML—a profile for specifying real-time-related constraints in system models. UML diagrams are consistently used throughout the book to illustrate key concepts and design patterns.
• Part III is dedicated to the design of software architectures for real-time embedded systems. We start with generic architectures, which lead us to the most complicated architecture—a real-time operating system. The focus is then switched to multitasking and real-time scheduling—two critical issues to be addressed by any designers of real-time embedded systems.
• Part IV is dedicated to system implementation. We especially focus on those mechanisms available on any POSIX-compliant operating systems; this means that the design/implementation patterns given in this book are applicable to other POSIX-compliant operating systems as well.
The four parts together have 23 chapters. A one-semester course can use selected chapters/sections to suit the interests of the instructor and students. For instance, some microprocessor types in Chapter 3 can be skipped in order to fit the materials in one or two lecture time. If UML basic modeling concepts have been covered in a prerequisite...
| Erscheint lt. Verlag | 25.2.2015 |
|---|---|
| Sprache | englisch |
| Themenwelt | Mathematik / Informatik ► Informatik ► Software Entwicklung |
| Informatik ► Weitere Themen ► Hardware | |
| Technik ► Bauwesen | |
| Technik ► Elektrotechnik / Energietechnik | |
| ISBN-10 | 0-12-801718-X / 012801718X |
| ISBN-13 | 978-0-12-801718-0 / 9780128017180 |
| Haben Sie eine Frage zum Produkt? |
PDF (Adobe DRM)Größe: 52,7 MB
Kopierschutz: Adobe-DRM
Adobe-DRM ist ein Kopierschutz, der das eBook vor Mißbrauch schützen soll. Dabei wird das eBook bereits beim Download auf Ihre persönliche Adobe-ID autorisiert. Lesen können Sie das eBook dann nur auf den Geräten, welche ebenfalls auf Ihre Adobe-ID registriert sind.
Details zum Adobe-DRM
Dateiformat: PDF (Portable Document Format)
Mit einem festen Seitenlayout eignet sich die PDF besonders für Fachbücher mit Spalten, Tabellen und Abbildungen. Eine PDF kann auf fast allen Geräten angezeigt werden, ist aber für kleine Displays (Smartphone, eReader) nur eingeschränkt geeignet.
Systemvoraussetzungen:
PC/Mac: Mit einem PC oder Mac können Sie dieses eBook lesen. Sie benötigen eine
eReader: Dieses eBook kann mit (fast) allen eBook-Readern gelesen werden. Mit dem amazon-Kindle ist es aber nicht kompatibel.
Smartphone/Tablet: Egal ob Apple oder Android, dieses eBook können Sie lesen. Sie benötigen eine
Geräteliste und zusätzliche Hinweise
Buying eBooks from abroad
For tax law reasons we can sell eBooks just within Germany and Switzerland. Regrettably we cannot fulfill eBook-orders from other countries.
EPUB (Adobe DRM)Größe: 35,9 MB
Kopierschutz: Adobe-DRM
Adobe-DRM ist ein Kopierschutz, der das eBook vor Mißbrauch schützen soll. Dabei wird das eBook bereits beim Download auf Ihre persönliche Adobe-ID autorisiert. Lesen können Sie das eBook dann nur auf den Geräten, welche ebenfalls auf Ihre Adobe-ID registriert sind.
Details zum Adobe-DRM
Dateiformat: EPUB (Electronic Publication)
EPUB ist ein offener Standard für eBooks und eignet sich besonders zur Darstellung von Belletristik und Sachbüchern. Der Fließtext wird dynamisch an die Display- und Schriftgröße angepasst. Auch für mobile Lesegeräte ist EPUB daher gut geeignet.
Systemvoraussetzungen:
PC/Mac: Mit einem PC oder Mac können Sie dieses eBook lesen. Sie benötigen eine
eReader: Dieses eBook kann mit (fast) allen eBook-Readern gelesen werden. Mit dem amazon-Kindle ist es aber nicht kompatibel.
Smartphone/Tablet: Egal ob Apple oder Android, dieses eBook können Sie lesen. Sie benötigen eine
Geräteliste und zusätzliche Hinweise
Buying eBooks from abroad
For tax law reasons we can sell eBooks just within Germany and Switzerland. Regrettably we cannot fulfill eBook-orders from other countries.
aus dem Bereich
