1.5 A Guided Tour of This Book
The most efficient way to learn all the necessary concepts is to move from the bottom up. This book is arranged so that you learn about the properties of components and build toward more complex systems and a more complete view of the system design process. Veteran designers have learned enough bottom-up knowledge from experience to know how to use a top-down approach to designing a system, but when learning things for the first time, the bottom-up approach allows you to build more sophisticated concepts on the basis of lower-level ideas.
We will use several organizational devices throughout the book to help you. Application Examples focus on a particular end-use application and how it relates to embedded system design. We will also make use of Programming Examples to describe software designs. In addition to these examples, most of the chapters will use a significant system design example to demonstrate the major concepts of the chapter.
Each chapter includes questions that are intended to be answered on paper as homework assignments. The chapters also include lab exercises. These are more open ended and are intended to suggest activities that can be performed in the lab to help illuminate various concepts in the chapter.
Throughout the book, we will use several CPUs as examples: the ARM RISC processor, the Texas Instruments C55x digital signal processor (DSP), the PIC16F, and the Texas Instruments C64x. All are well-known microprocessors used in many embedded applications. Using real microprocessors helps make concepts more concrete. However, our aim is to learn concepts that can be applied to all sorts of microprocessors. Although microprocessors will evolve over time (Warhol’s Law of Computer Architecture [Wol92] states that every microprocessor architecture will be the price/performance leader for fifteen minutes), the concepts of embedded system design are fundamental and long term.
1.5.1 Chapter 2: Instruction Sets
In Chapter 2, we begin our study of microprocessors by concentrating on instruction sets. The chapter covers the instruction sets of the ARM, PIC16F, TI C55x, and TI C64x microprocessors in separate sections. All these microprocessors are very different. Understanding all details of both is not strictly necessary to the design of embedded systems. However, comparing them does provide some interesting lessons in instruction set architectures.
Understanding some aspects of the instruction set is important both for concreteness and for seeing how architectural features can affect performance and other system attributes. But many mechanisms, such as caches and memory management, can be understood in general before we go on to details of how they are implemented in these three microprocessors.
We do not introduce a design example in this chapter—it is difficult to build even a simple working system without understanding other aspects of the CPU that will be introduced in Chapter 3. However, understanding instruction sets helps us to understanding problems such as execution speed and code size that we study throughout the book.
1.5.2 Chapter 3: CPUs
Chapter 3 rounds out our discussion of microprocessors by focusing on the following important mechanisms that are not part of the instruction set itself:
We also begin to consider how the CPU hardware affects important characteristics of program execution. Program performance and power consumption are very important parameters in embedded system design. An understanding of how architectural aspects such as pipelining and caching affect these system characteristics is a foundation for analyzing and optimizing programs in later chapters.
Our study of program performance will begin with instruction-level performance. The basics of pipeline and cache timing will serve as the foundation for our studies of larger program units.
We use as an example a simple data compression unit, concentrating on the programming of the core compression algorithm.
1.5.3 Chapter 4: Computing Platforms
Chapter 4 looks at the combined hardware and software platform for embedded computing. The microprocessor is very important, but only part of a system that includes memory, I/O devices, and low-level software. We need to understand the basic characteristics of the platform before we move on to build sophisticated systems.
The basic embedded computing platform includes a microprocessor, I/O hardware, I/O driver software, and memory. Application-specific software and hardware can be added to this platform to turn it into an embedded computing platform. The microprocessor is at the center of both the hardware and software structure of the embedded computing system. The CPU controls the bus that connects to memory and I/O devices; the CPU also runs software that talks to the devices. In particular, I/O is central to embedded computing. Many aspects of I/O are not typically studied in modern computer architecture courses, so we need to master the basic concepts of input and output before we can design embedded systems.
Chapter 4 covers several important aspects of the platform:
• We study in detail how the CPU talks to memory and devices using the microprocessor bus.
• Based on our knowledge of bus operation, we study the structure of the memory system and types of memory components.
• We look at basic techniques for embedded system design and debugging.
• We will study system-level performance analysis to see how bus and memory transactions affect the execution time of systems.
We illustrate these principles using two design examples: an alarm clock and a digital audio player.
1.5.4 Chapter 5: Program Design and Analysis
Chapter 5 moves to the software side of the computer system to understand how complex sequences of operations are executed as programs. Given the challenges of embedded programming—meeting strict performance goals, minimizing program size, reducing power consumption—this is an especially important topic. We build upon the fundamentals of computer architecture to understand how to design embedded programs.
• We will develop some basic software components—data structures and their associated routines—that are useful in embedded software.
• As part of our study of the relationship between programs and instructions, we introduce a model for high-level language programs known as the control/data flow graph (CDFG). We use this model extensively to help us analyze and optimize programs.
• Because embedded programs are increasingly written in higher-level languages, we will look at the processes for compiling, assembling, and linking to understand how high-level language programs are translated into instructions and data. Some of the discussion surveys basic techniques for translating high-level language programs, but we also spend time on compilation techniques designed specifically to meet embedded system challenges.
• We develop techniques for performance analysis of programs. It is difficult to determine the speed of a program simply by examining its source code. We learn how to use a combination of the source code, its assembly language implementation, and expected data inputs to analyze program execution time. We also study some basic techniques for optimizing program performance.
• An important topic related to performance analysis is power analysis. We build on performance analysis methods to learn how to estimate the power consumption of programs.
• It is critical that the programs that we design function correctly. The control/data flow graph and techniques we have learned for performance analysis are related to techniques for testing programs. We develop techniques that can methodically develop a set of tests for a program in order to excise likely bugs.
At this point, we can consider the performance of a complete program. We will introduce the concept of worst-case execution time as a basic measure of program execution time.
We will use two design examples in Chapter 5. The first is a simple software modem. A modem translates between the digital world of the microprocessor and the analog transmission scheme of the telephone network. Rather than use analog electronics to build a modem, we can use a microprocessor and special-purpose software. Because the modem has strict real-time deadlines, this example lets us exercise our knowledge of the microprocessor and of program analysis. The second is a digital still camera, which is considerably more complex than the modem both in the algorithms it must execute and the variety of tasks it must perform.
1.5.5 Chapter 6: Processes and Operating Systems
Chapter 6 builds on our knowledge of programs to study a special type of software component, the process, and operating systems that use processes to create systems. A process is an execution of a program; an embedded system may have several processes running concurrently. A separate real-time operating system (RTOS) controls when the processes run on the CPU. Processes are important to embedded system design because they help us juggle multiple events happening at the same time. A real-time embedded system that is designed without processes usually ends up as a mess of spaghetti code that doesn’t operate properly.
We will study the basic concepts of processes and process-based design in this chapter:
• We begin by introducing the process abstraction. A process is defined by a combination of the program being executed and the current state of the program. We will learn how to switch contexts between processes.
• In order to make use of processes, we must be able to schedule them. We discuss process priorities and how they can be used to guide scheduling.
• We cover the fundamentals of interprocess communication, including the various styles of communication and how they can be implemented. We will also look at various uses of these interprocess communication mechanisms in systems.
• The real-time operating system is the software component that implements the process abstraction and scheduling. We study how RTOSs implement schedules, how programs interface to the operating system, and how we can evaluate the performance of systems built from RTOSs. We will also survey some example RTOSs.
Tasks introduce a new level of complexity to performance analysis. Our study of real-time scheduling provides an important foundation for the study of multitasking systems.
Chapter 6 analyzes two design examples: a digital telephone answering machine and an engine control unit. The answering machine must juggle several real-time tasks simultaneously: voice compression, voice data storage, and user interface. To emphasize the role of processes in structuring real-time computation, we compare the answering machine design with and without processes. We will see that the implementation that does not use processes will be considerably harder to design and debug. An engine controller must control the fuel injectors and spark plugs of an engine based upon a set of inputs. Relatively complex formulas govern its behavior, all of which must be evaluated in real time. The deadlines for these tasks vary over several orders of magnitude.
1.5.6 Chapter 7: System Design Techniques
Chapter 7 studies the design of large, complex embedded systems. We introduce important concepts that are essential for the successful completion of large embedded system projects, and we use those techniques to help us integrate the knowledge obtained throughout the book.
This chapter delves into several topics related to large-scale embedded system design:
• We revisit the topic of design methodologies. Based on our more detailed knowledge of embedded system design, we can better understand the role of methodology and the possible variations in methodologies.
• We study system specification methods. Proper specifications become increasingly important as system complexity grows. More formal specification techniques help us capture intent clearly, consistently, and unambiguously. System analysis methodologies provide a framework for understanding specifications and assessing their completeness.
• We look at quality assurance techniques. The program testing techniques covered in Chapter 5 are a good foundation but may not scale easily to complex systems. Additional methods are required to ensure that we exercise complex systems to shake out bugs.
1.5.7 Chapter 8: Networks and Multiprocessors
The final chapter is an advanced topic that may be left out of initial studies and introductory classes without losing the basic principles underlying embedded computing. Many embedded systems are multiprocessors—computer systems with more than one processing element. The multiprocessor may use CPUs and DSPs; it may also include non-programmable elements known as accelerators. Multiprocessors are often more energy-efficient and less expensive than platforms that try to do all the required computing on one big CPU.
Chapter 8 studies the design of networked and multiprocessor embedded systems. We will look at the components of several types of multiprocessors, including both single-chip multiprocessors and distributed embedded systems with multiple chips connected by a network. We will look at the structure of some important networks used in distributed embedded computing such as the CAN network widely used in cars and the I2C network for consumer electronics. We will also consider the programming challenges of single-chip multiprocessors.
We will study two design examples. The first is an accelerator for use in a video compression system. Digital video requires performing a huge number of operations in real time; video also requires large volumes of data transfers. As such, it provides a good way to study not only the design of the accelerator itself but also how it fits into the overall system. The second is a compact disc player. Although very low cost, a CD player includes a single-chip multiprocessor that performs very sophisticated real-time functions using a combination of a CPU, DSP, and accelerators.