Embedded Systems Design: An Introduction to Processes, Tools, and
by Arnold S. Berger
© 2002 (237 pages)
An easy-to-understand guidebook for those embarking upon an embedded
processor development project.
Table of Contents
Embedded Systems Design—An Introduction to Processes, Tools, and
Chapter 1 - The Embedded Design Life Cycle
Chapter 2 - The Selection Process
Chapter 3 - The Partitioning Decision
Chapter 4 - The Development Environment
Chapter 5 - Special Software Techniques
Chapter 6 - A Basic Toolset
Chapter 7 - BDM, JTAG, and Nexus
Chapter 8 - The ICE — An Integrated Solution
Chapter 9 - Testing
Chapter 10 - The Future
List of Figures
List of Tables
List of Listings
List of Sidebars
Embedded Systems Design—An
Introduction to Processes, Tools, and
CMP Media LLC
1601 West 23rd Street, Suite 200
Lawrence, Kansas 66046
Designations used by companies to distinguish their products are often claimed as
trademarks. In all instances where CMP Books is aware of a trademark claim, the
product name appears in initial capital letters, in all capital letters, or in
accordance with the vendor’s capitalization preference. Readers should contact the
appropriate companies for more complete information on trademarks and
trademark registrations. All trademarks and registered trademarks in this book are
the property of their respective holders.
Copyright © 2002 by CMP Books, except where noted otherwise. Published by CMP
Books, CMP Media LLC. All rights reserved. Printed in the United States of America.
No part of this publication may be reproduced or distributed in any form or by any
means, or stored in a database or retrieval system, without the prior written
permission of the publisher; with the exception that the program listings may be
entered, stored, and executed in a computer system, but they may not be
reproduced for publication.
The programs in this book are presented for instructional value. The programs
have been carefully tested, but are not guaranteed for any particular purpose. The
publisher does not offer any warranties and does not guarantee the accuracy,
adequacy, or completeness of any information herein and is not responsible for
any errors or omissions. The publisher assumes no liability for damages resulting
from the use of the information in this book or for any infringement of the
intellectual property rights of third parties that would result from the use of this
Editors: Matt McDonald, Julie McNamee, Rita Sooby, and
Justin Fulmer, Rita Sooby, and Michelle O’Neal
Managing Editor: Michelle O’Neal
Cover Art Design: Robert Ward
Distributed in the U.S. and Canada by:
Publishers Group West
1700 Fourth Street
Berkeley, CA 94710
This book is dedicated to
Why write a book about designing embedded systems? Because my experiences
working in the industry and, more recently, working with students have convinced
me that there is a need for such a book.
For example, a few years ago, I was the Development Tools Marketing Manager for
a semiconductor manufacturer. I was speaking with the Software Development
Tools Manager at our major account. My job was to help convince the customer
that they should be using our RISC processor in their laser printers. Since I owned
the tool chain issues, I had to address his specific issues before we could convince
him that we had the appropriate support for his design team.
Since we didn’t have an In-Circuit Emulator for this processor, we found it
necessary to create an extended support matrix, built around a ROM emulator,
JTAG port, and a logic analyzer. After explaining all this to him, he just shook his
head. I knew I was in trouble. He told me that, of course, he needed all this stuff.
However, what he really needed was training. The R&D Group had no trouble
hiring all the freshly minted software engineers they needed right out of college.
Finding a new engineer who knew anything about software development outside of
Wintel or UNIX was quite another matter. Thus was born the idea that perhaps
there is some need for a different slant on embedded system design.
Recently I’ve been teaching an introductory course at the University of
Washington-Bothell (UWB). For now, I’m teaching an introduction to embedded
systems. Later, there’ll be a lab course. Eventually this course will grow into a full
track, allowing students to earn a specialty in embedded systems. Much of this
book’s content is an outgrowth of my work at UWB. Feedback from my students
about the course and its content has influenced the slant of the book. My
interactions with these students and with other faculty have only reinforced my
belief that we need such a book.
What is this book about?
This book is not intended to be a text in software design, or even embedded
software design (although it will, of necessity, discuss some code and coding
issues). Most of my students are much better at writing code in C++ and Java
than am I. Thus, my first admission is that I’m not going to attempt to teach
software methodologies. What I will teach is the how of software development in
an embedded environment. I wrote this book to help an embedded software
developer understand the issues that make embedded software development
different from host-based software design. In other words, what do you do when
there is no printf() or malloc()?
Because this is a book about designing embedded systems, I will discuss design
issues — but I’ll focus on those that aren’t encountered in application design. One
of the most significant of these issues is processor selection. One of my
responsibilities as the Embedded Tools Marketing Manager was to help convince
engineers and their managers to use our processors. What are the issues that
surround the choice of the right processor for any given application? Since most
new engineers usually only have architectural knowledge of the Pentium-class, or
SPARC processors, it would be helpful for them to broaden their processor horizon.
The correct processor choice can be a “bet the company” decision. I was there in a
few cases where it was such a decision, and the company lost the bet.
Why should you buy this book?
If you are one of my students.
If you’re in my class at UWB, then you’ll probably buy the book because it is on
your required reading list. Besides, an autographed copy of the book might be
valuable a few years from now (said with a smile). However, the real reason is that
it will simplify note-taking. The content is reasonably faithful to the 400 or so
lectures slides that you’ll have to sit through in class. Seriously, though, reading
this book will help you to get a grasp of the issues that embedded system
designers must deal with on a daily basis. Knowing something about embedded
systems will be a big help when you become a member of the next group and start
looking for a job!
If you are a student elsewhere or a recent graduate.
Even if you aren’t studying embedded systems at UWB, reading this book can be
important to your future career. Embedded systems is one of the largest and
fastest growing specialties in the industry, but the number of recent graduates
who have embedded experience is woefully small. Any prior knowledge of the field
will make you stand out from other job applicants.
As a hiring manager, when interviewing job applicants I would often “tune out” the
candidates who gave the standard, “I’m flexible, I’ll do anything” answer. However,
once in while someone would say, “I used your stuff in school, and boy, was it ever
a kludge. Why did you set up the trace spec menu that way?” That was the
candidate I wanted to hire. If your only benefit from reading this book is that you
learn some jargon that helps you make a better impression at your next job
interview, then reading it was probably worth your the time invested.
If you are a working engineer or developer.
If you are an experienced software developer this book will help you to see the big
picture. If it’s not in your nature to care about the big picture, you may be asking:
“why do I need to see the big picture? I’m a software designer. I’m only concerned
with technical issues. Let the marketing-types and managers worry about ‘the big
picture.’ I’ll take a good Quick Sort algorithm anytime.” Well, the reality is that, as
a developer, you are at the bottom of the food chain when it comes to making
certain critical decisions, but you are at the top of the blame list when the project
is late. I know from experience. I spent many long hours in the lab trying to
compensate for a bad decision made by someone else earlier in the project’s
lifecycle. I remember many times when I wasn’t at my daughter’s recitals because
I was fixing code. Don’t let someone else stick you with the dog! This book will
help you recognize and explain the critical importance of certain early decisions. It
will equip you to influence the decisions that directly impact your success. You owe
it to yourself.
If you are a manager.
Having just maligned managers and marketers, I’m now going to take that all back
and say that this book is also for them. If you are a manager and want your
project to go smoothly and your product to get to market on time, then this book
can warn you about land mines and roadblocks. Will it guarantee success? No, but
like chicken soup, it can’t hurt.
I’ll also try to share ideas that have worked for me as a manager. For example,
when I was an R&D Project Manager I used a simple “trick” to help to form my
project team and focus our efforts. Before we even started the product definition
phase I would get some foam-core poster board and build a box with it. The box
had the approximate shape of the product. Then I drew a generic front panel and
pasted it on the front of the box. The front panel had the project’s code name, like
Gerbil, or some other mildly humorous name, prominently displayed. Suddenly, we
had a tangible prototype “image” of the product. We could see it. It got us focused.
Next, I held a pot-luck dinner at my house for the project team and their
These simple devices helped me to bring the team’s focus to
the project that lay ahead. It also helped to form the “extended support team” so
that when the need arose to call for a 60 or 80 hours workweek, the home front
support was there.
(While that extended support is important, managers should not abuse it. As an
R&D Manager I realized that I had a large influence over the engineer’s personal
lives. I could impact their salaries with large raises and I could seriously strain a
marriage by firing them. Therefore, I took my responsibility for delivering the right
product, on time, very seriously. You should too.)
Embedded designers and managers shouldn’t have to make the same mistakes
over and over. I hope that this book will expose you to some of the best practices
that I’ve learned over the years. Since embedded system design seems to lie in
the netherworld between Electrical Engineering and Computer Science, some of
the methods and tools that I’ve learned and developed don’t seem to rise to the
surface in books with a homogeneous focus.
I can't take credit for this idea. I learned if from Controlling Software Projects, by
Tom DeMarco (Yourdon Press, 1982), and from a videotape series of his lectures.
How is the book structured?
For the most part, the text will follow the classic embedded processor lifecycle
model. This model has served the needs of marketing engineers and field sales
engineers for many years. The good news is that this model is a fairly accurate
representation of how embedded systems are developed. While no simple model
truly captures all of the subtleties of the embedded development process,
representing it as a parallel development of hardware and software, followed by an
integration step, seems to capture the essence of the process.
What do I expect you to know?
Primarily, I assume you are familiar with the vocabulary of application
development. While some familiarity with C, assembly, and basic digital circuits is
helpful, it’s not necessary. The few sections that describe specific C coding
techniques aren’t essential to the rest of the book and should be accessible to
almost any programmer. Similarly, you won’t need to be an expert assembly
language programmer to understand the point of the examples that are presented
in Motorola 68000 assembly language. If you have enough logic background to
understand ANDs and ORs, you are prepared for the circuit content. In short,
anyone who’s had a few college-level programming courses, or equivalent
experience, should be comfortable with the content.
I’d like to thank some people who helped, directly and indirectly, to make this
book a reality. Perry Keller first turned me on to the fun and power of the in-circuit
emulator. I’m forever in his debt. Stan Bowlin was the best emulator designer that
I ever had the privilege to manage. I learned a lot about how it all works from
Stan. Daniel Mann, an AMD Fellow, helped me to understand how all the pieces fit
The manuscript was edited by Robert Ward, Julie McNamee, Rita Sooby, Michelle
O’Neal, and Catherine Janzen. Justin Fulmer redid many of my graphics. Rita
Sooby and Michelle O’Neal typeset the final result. Finally, Robert Ward and my
friend and colleague, Sid Maxwell, reviewed the manuscript for technical accuracy.
Thank you all.
September 27, 2001
The arrival of the microprocessor in the 1970s brought about a revolution of
control. For the first time, relatively complex systems could be constructed using a
simple device, the microprocessor, as its primary control and feedback element. If
you were to hunt out an old Teletype ASR33 computer terminal in a surplus store
and compare its innards to a modern color inkjet printer, there’s quite a difference.
Automobile emissions have decreased by 90 percent over the last 20 years,
primarily due to the use of microprocessors in the engine-management system.
The open-loop fuel control system, characterized by a carburetor, is now a fuel-
injected, closed-loop system using multiple sensors to optimize performance and
minimize emissions over a wide range of operating conditions. This type of
performance improvement would have been impossible without the microprocessor
as a control element.
Microprocessors have now taken over the automobile. A new luxury- class
automobile might have more than 70 dedicated microprocessors, controlling tasks
from the engine spark and transmission shift points to opening the window slightly
when the door is being closed to avoid a pressure burst in the driver’s ear.
The F-16 is an unstable aircraft that cannot be flown without on-board computers
constantly making control surface adjustments to keep it in the air. The pilot,
through the traditional controls, sends requests to the computer to change the
plane’s flight profile. The computer attempts to comply with those requests to the
extent that it can and still keep the plane in the air.
A modern jetliner can have more than 200 on-board, dedicated microprocessors.
The most exciting driver of microprocessor performance is the games market.
Although it can be argued that the game consoles from Nintendo, Sony, and Sega
are not really embedded systems, the technology boosts that they are driving are
absolutely amazing. Jim Turley, at the Microprocessor Forum, described a
200MHz reduced instruction set computer (RISC) processor that was going into a
next-generation game console. This processor could do a four-dimensional matrix
multiplication in one clock cycle at a cost of $25.
Why Embedded Systems Are Different
Well, all of this is impressive, so let’s delve into what makes embedded systems
design different — at least different enough that someone has to write a book
about it. A good place to start is to try to enumerate the differences between your
desktop PC and the typical embedded system.
Embedded systems are dedicated to specific tasks, whereas PCs are
generic computing platforms.
Embedded systems are supported by a wide array of processors and
Embedded systems are usually cost sensitive.
Embedded systems have real-time constraints.
Note You’ll have ample opportunity to learn about real time. For now,
real- time events are external (to the embedded system) events that
must be dealt with when they occur (in real time).
If an embedded system is using an operating system at all, it is most
likely using a real-time operating system (RTOS), rather than Windows
9X, Windows NT, Windows 2000, Unix, Solaris, or HP- UX.
The implications of software failure is much more severe in embedded
systems than in desktop systems.
Embedded systems often have power constraints.
Embedded systems often must operate under extreme environmental
Embedded systems have far fewer system resources than desktop
Embedded systems often store all their object code in ROM.
Embedded systems require specialized tools and methods to be
Embedded microprocessors often have dedicated debugging circuitry.
Embedded systems are dedicated to specific tasks, whereas PCs are
generic computing platforms
Another name for an embedded microprocessor is a dedicated microprocessor. It is
programmed to perform only one, or perhaps, a few, specific tasks. Changing the
task is usually associated with obsolescing the entire system and redesigning it.
The processor that runs a mobile heart monitor/defibrillator is not expected to run
a spreadsheet or word processor.
Conversely, a general-purpose processor, such as the Pentium on which I’m
working at this moment, must be able to support a wide array of applications with
widely varying processing requirements. Because your PC must be able to service
the most complex applications with the same performance as the lightest
application, the processing power on your desktop is truly awesome.
Thus, it wouldn’t make much sense, either economically or from an engineering
standpoint, to put an AMD-K6, or similar processor, inside the coffeemaker on your
Note That’s not to say that someone won’t do something similar. For
example, a French company designed a vacuum cleaner with an
AMD 29000 processor. The 29000 is a 32-bit RISC CPU that is far
more suited for driving laser-printer engines.
Embedded systems are supported by a wide array of processors and
Most students who take my Computer Architecture or Embedded Systems class
have never programmed on any platform except the X86 (Intel) or the Sun SPARC
family. The students who take the Embedded Systems class are rudely awakened
by their first homework assignment, which has them researching the available
trade literature and proposing the optimal processor for an assigned application.
These students are learning that today more than 140 different microprocessors
are available from more than 40 semiconductor vendors. These vendors are in a
daily battle with each other to get the design-win (be the processor of choice) for
the next wide-body jet or the next Internet- based soda machine.
In Chapter 2
, you’ll learn more about the processor-selection process. For now,
just appreciate the range of available choices.
Embedded systems are usually cost sensitive
I say “usually” because the cost of the embedded processor in the Mars Rover was
probably not on the design team’s top 10 list of constraints. However, if you save
10 cents on the cost of the Engine Management Computer System, you’ll be a hero
at most automobile companies. Cost does matter in most embedded applications.
The cost that you must consider most of the time is system cost. The cost of the
processor is a factor, but, if you can eliminate a printed circuit board and
connectors and get by with a smaller power supply by using a highly integrated
microcontroller instead of a microprocessor and separate peripheral devices, you
have potentially a greater reduction in system costs, even if the integrated device
is significantly more costly than the discrete device. This issue is covered in more
detail in Chapter 3
Embedded systems have real-time constraints
I was thinking about how to introduce this section when my laptop decided to back
up my work. I started to type but was faced with the hourglass symbol because
the computer was busy doing other things. Suppose my computer wasn’t sitting on
my desk but was connected to a radar antenna in the nose of a commercial jetliner.
If the computer’s main function in life is to provide a collision alert warning, then
suspending that task could be disastrous.
Real-time constraints generally are grouped into two categories: time- sensitive
constraints and time-critical constraints. If a task is time critical, it must take place
within a set window of time, or the function controlled by that task fails.
Controlling the flight-worthiness of an aircraft is a good example of this. If the
feedback loop isn’t fast enough, the control algorithm becomes unstable, and the
aircraft won’t stay in the air.
A time-sensitive task can die gracefully. If the task should take, for example,
4.5ms but takes, on average, 6.3ms, then perhaps the inkjet printer will print two
pages per minute instead of the design goal of three pages per minute.
If an embedded system is using an operating system at all, it is most
likely using an RTOS
Like embedded processors, embedded operating systems also come in a wide
variety of flavors and colors. My students must also pick an embedded operating
system as part of their homework project. RTOSs are not democratic. They need
not give every task that is ready to execute the time it needs. RTOSs give the
highest priority task that needs to run all the time it needs. If other tasks fail to
get sufficient CPU time, it’s the programmer’s problem.
Another difference between most commercially available operating systems and
your desktop operating system is something you won’t get with an RTOS. You
won’t get the dreaded Blue Screen of Death that many Windows 9X users see on a
The implications of software failure are much more severe in embedded
systems than in desktop systems
Remember the Y2K hysteria? The people who were really under the gun were the
people responsible for the continued good health of our computer- based
infrastructure. A lot of money was spent searching out and replacing devices with
embedded processors because the #$%%$ thing got the dates all wrong.
We all know of the tragic consequences of a medical radiation machine that
miscalculates a dosage. How do we know when our code is bug free? How do you
completely test complex software that must function properly under all conditions?
However, the most important point to take away from this discussion is that
software failure is far less tolerable in an embedded system than in your average
desktop PC. That is not to imply that software never fails in an embedded system,
just that most embedded systems typically contain some mechanism, such as a
, to bring it back to life if the software loses control. You’ll find out
more about software testing in Chapter 9
Embedded systems have power constraints
For many readers, the only CPU they have ever seen is the Pentium or AMD K6
inside their desktop PC. The CPU needs a massive heat sink and fan assembly to
keep the processor from baking itself to death. This is not a particularly serious
constraint for a desktop system. Most desktop PC’s have plenty of spare space
inside to allow for good airflow. However, consider an embedded system attached
to the collar of a wolf roaming around Wyoming or Montana. These systems must
work reliably and for a long time on a set of small batteries.
How do you keep your embedded system running on minute amounts of power?
Usually that task is left up to the hardware engineer. However, the division of
responsibility isn’t clearly delineated. The hardware designer might or might not
have some idea of the software architectural constraints. In general, the processor
choice is determined outside the range of hearing of the software designers. If the
overall system design is on a tight power budget, it is likely that the software
design must be built around a system in which the processor is in “sleep mode”
most of the time and only wakes up when a timer tick occurs. In other words, the
system is completely interrupt driven.
Power constraints impact every aspect of the system design decisions. Power
constraints affect the processor choice, its speed, and its memory architecture.
The constraints imposed by the system requirements will likely determine whether
the software must be written in assembly language, rather than C or C++,
because the absolute maximum performance must be achieved within the power
budget. Power requirements are dictated by the CPU clock speed and the number
of active electronic components (CPU, RAM, ROM, I/O devices, and so on).
Thus, from the perspective of the software designer, the power constraints could
become the dominant system constraint, dictating the choice of software tools,
memory size, and performance headroom.
Speed vs. Power
Almost all modern CPUs are fabricated using the Complementary Metal Oxide
Silicon (CMOS) process. The simple gate structure of CMOS devices consists of two
MOS transistors, one N-type and one P-type (hence, the term complementary),
stacked like a totem pole with the N-type on top and the P-type on the bottom.
Both transistors behave like perfect switches. When the output is high, or logic
level 1, the P-type transistor is turned off, and the N-type transistor connects the
output to the supply voltage (5V, 3.3V, and so on), which the gate outputs to the
rest of the circuit.
When the logic level is 0, the situation is reversed, and the P-type transistor
connects the next stage to ground while the N-type transistor is turned off. This
circuit topology has an interesting property that makes it attractive from a power-
use viewpoint. If the circuit is static (not changing state), the power loss is
extremely small. In fact, it would be zero if not for a small amount of leakage
current inherent in these devices at normal room temperature and above.
When the circuit is switching, as in a CPU, things are different. While a gate
switches logic levels, there is a period of time when the N-type and P-type
transistors are simultaneously on. During this brief window, current can flow from
the supply voltage line to ground through both devices. Current flow means power
dissipation and that means heat. The greater the clock speed, the greater the
number of switching cycles taking place per second, and this means more power
loss. Now, consider your 500MHz Pentium or Athlon processor with 10 million or so
transistors, and you can see why these desktop machines are so power hungry. In
fact, it is almost a perfect linear relationship between CPU speed and power
dissipation in modern processors. Those of you who overclock your CPUs to wring
every last ounce of performance out of it know how important a good heat sink
and fan combination are.
Embedded systems must operate under extreme environmental conditions
Embedded systems are everywhere. Everywhere means everywhere. Embedded
systems must run in aircraft, in the polar ice, in outer space, in the trunk of a
black Camaro in Phoenix, Arizona, in August. Although making sure that the
system runs under these conditions is usually the domain of the hardware designer,
there are implications for both the hardware and software. Harsh environments
usually mean more than temperature and humidity. Devices that are qualified for
military use must meet a long list of environmental requirements and have the
documentation to prove it. If you’ve wondered why a simple processor, such as the
8086 from Intel, should cost several thousands of dollars in a missile, think
paperwork and environment. The fact that a device must be qualified for the
environment in which it will be operating, such as deep space, often dictates the
selection of devices that are available.
The environmental concerns often overlap other concerns, such as power
requirements. Sealing a processor under a silicone rubber conformal coating
because it must be environmentally sealed also means that the capability to
dissipate heat is severely reduced, so processor type and speed is also a factor.
Unfortunately, the environmental constraints are often left to the very end of the
project, when the product is in testing and the hardware designer discovers that
the product is exceeding its thermal budget. This often means slowing the clock,
which leads to less time for the software to do its job, which translates to further
refining the software to improve the efficiency of the code. All the while, the
product is still not released.
Embedded systems have far fewer system resources than desktop
Right now, I’m typing this manuscript on my desktop PC. An oldies CD is playing
through the speakers. I’ve got 256MB of RAM, 26GB of disk space, and assorted
ZIP, JAZZ, floppy, and CD-RW devices on a SCSI card. I’m looking at a beautiful
19-inch CRT monitor. I can enter data through a keyboard and a mouse. Just
considering the bus signals in the system, I have the following:
An awful lot of system resources are at my disposal to make my computing chores
as painless as possible. It is a tribute to the technological and economic driving
forces of the PC industry that so much computing power is at my fingertips.
Now consider the embedded system controlling your VCR. Obviously, it has far
fewer resources that it must manage than the desktop example. Of course, this is
because it is dedicated to a few well-defined tasks and nothing else. Being
engineered for cost effectiveness (the whole VCR only cost $80 retail), you can’t
expect the CPU to be particularly general purpose. This translates to fewer
resources to manage and hence, lower cost and simplicity. However, it also means
that the software designer is often required to design standard input and output
(I/O) routines repeatedly. The number of inputs and outputs are usually so limited,
the designers are forced to overload and serialize the functions of one or two input
devices. Ever try to set the time in your super exercise workout wristwatch after
you’ve misplaced the instruction sheet?
Embedded systems store all their object code in ROM
Even your PC has to store some of its code in ROM. ROM is needed in almost all
systems to provide enough code for the system to initialize itself (boot-up code).
However, most embedded systems must have all their code in ROM. This means
severe limitations might be imposed on the size of the code image that will fit in
the ROM space. However, it’s more likely that the methods used to design the
system will need to be changed because the code is in ROM.
As an example, when the embedded system is powered up, there must be code
that initializes the system so that the rest of the code can run. This means
establishing the run-time environment, such as initializing and placing variables in
RAM, testing memory integrity, testing the ROM integrity with a checksum test,
and other initialization tasks.
From the point of view of debugging the system, ROM code has certain
implications. First, your handy debugger is not able to set a breakpoint in ROM. To
set a breakpoint, the debugger must be able to remove the user’s instruction and
replace it with a special instruction, such as a TRAP instruction or software
interrupt instruction. The TRAP forces a transfer to a convenient entry point in the
debugger. In some systems, you can get around this problem by loading the
application software into RAM. Of course, this assumes sufficient RAM is available
to hold of all the applications, to store variables, and to provide for dynamic
Of course, being a capitalistic society, wherever there is a need, someone will
provide a solution. In this case, the specialized suite of tools that have evolved to
support the embedded system development process gives you a way around this
dilemma, which is discussed in the next section
Embedded systems require specialized tools and methods to be efficiently
Chapters 4 through 8 discuss the types of tools in much greater detail. The
embedded system is so different in so many ways, it’s not surprising that
specialized tools and methods must be used to create and test embedded software.
Take the case of the previous example—the need to set a break-point at an
instruction boundary located in ROM.
A ROM Emulator
Several companies manufacture hardware-assist products, such as ROM emulators.
shows a product called NetROM, from Applied Microsystems Corporation.
NetROM is an example of a general class of tools called emulators. From the point
of view of the target system, the ROM emulator is designed to look like a standard
ROM device. It has a connector that has the exact mechanical dimensions and
electrical characteristics of the ROM it is emulating. However, the connector’s job
is to bring the signals from the ROM socket on the target system to the main
circuitry, located at the other end of the cable. This circuitry provides high-speed
RAM that can be written to quickly via a separate channel from a host computer.
Thus, the target system sees a ROM device, but the software developer sees a
RAM device that can have its code easily modified and allows debugger
breakpoints to be set.
Figure 1: NetROM.
Note In the context of this book, the term hardware-assist refers to
additional specialized devices that supplement a software-only
debugging solution. A ROM emulator, manufactured by companies
such as Applied Microsystems and Grammar Engine, is an example
of a hardware-assist device.
Embedded microprocessors often have dedicated debugging circuitry
Perhaps one of the most dramatic differences between today’s embedded
microprocessors and those of a few years ago is the almost mandatory inclusion of
dedicated debugging circuitry in silicon on the chip. This is almost counter-intuitive
to all of the previous discussion. After droning on about the cost sensitivity of
embedded systems, it seems almost foolish to think that every microprocessor in
production contains circuitry that is only necessary for debugging a product under
development. In fact, this was the prevailing sentiment for a while. Embedded-chip
manufacturers actually built special versions of their embedded devices that
contained the debug circuitry and made them available (or not available) to their
tool suppliers. In the end, most manufacturers found it more cost-effective to
produce one version of the chip for all purposes. This didn’t stop them from
restricting the information about how the debug circuitry worked, but every device
produced did contain the debug “hooks” for the hardware-assist tools.
What is noteworthy is that the manufacturers all realized that the inclusion of on-
chip debug circuitry was a requirement for acceptance of their devices in an
embedded application. That is, unless their chip had a good solution for embedded
system design and debug, it was not going to be a serious contender for an
embedded application by a product-development team facing time-to-market
Now that you know what is different about embedded systems, it’s time to see
how you actually tame the beast. In the chapters that follow, you’ll examine the
embedded system design process step by step, as it is practiced.
The first few chapters focus on the process itself. I’ll describe the design life cycle
and examine the issues affecting processor selection. The later chapters focus on
techniques and tools used to build, test, and debug a complete system.
I’ll close with some comments on the business of embedded systems and on an
emerging technology that might change everything.
Although engineers like to think design is a rational, requirements-driven process,
in the real world, many decisions that have an enormous impact on the design
process are made by non-engineers based on criteria that might have little to do
with the project requirements. For example, in many projects, the decision to use
a particular processor has nothing to do with the engineering parameters of the
problem. Too often, it becomes the task of the design team to pick up the pieces
and make these decisions work. Hopefully, this book provides some ammunition to
those frazzled engineers who often have to make do with less than optimal
1. Turley, Jim. “High Integration is Key for Major Design Wins.” A paper
presented at the Embedded Processor Forum, San Jose, 15 October
2. Levy, Marcus. “EDN Microprocessor/Microcontroller Directory.” EDN, 14
Chapter 1: The Embedded Design Life
Unlike the design of a software application on a standard platform, the design of
an embedded system implies that both software and hardware are being designed
in parallel. Although this isn’t always the case, it is a reality for many designs
today. The profound implications of this simultaneous design process heavily
influence how systems are designed.
Figure 1.1 provides a schematic representation of the embedded design life cycle
(which has been shown ad nauseam in marketing presentations).
Figure 1.1: Embedded design life cycle diagram.
A phase representation of the embedded design life cycle.
Time flows from the left and proceeds through seven phases:
Partitioning of the design into its software and hardware components
Iteration and refinement of the partitioning
Independent hardware and software design tasks
Integration of the hardware and software components
Product testing and release
On-going maintenance and upgrading
The embedded design process is not as simple as Figure 1.1
considerable amount of iteration and optimization occurs within phases and
between phases. Defects found in later stages often cause you to “go back to
square 1.” For example, when product testing reveals performance deficiencies
that render the design non-competitive, you might have to rewrite algorithms,
redesign custom hardware — such as Application-Specific Integrated Circuits
(ASICs) for better performance — speed up the processor, choose a new processor,
and so on.
Although this book is generally organized according to the life-cycle view in Figure
1.1, it can be helpful to look at the process from other perspectives. Dr. Daniel
Mann, Advanced Micro Devices (AMD), Inc., has developed a tool-based view of
the development cycle. In Mann’s model, processor selection is one of the first
tasks (see Figure 1.2
). This is understandable, considering the selection of the
right processor is of prime importance to AMD, a manufacturer of embedded
microprocessors. However, it can be argued that including the choice of the
microprocessor and some of the other key elements of a design in the specification
phase is the correct approach. For example, if your existing code base is written
for the 80X86 processor family, it’s entirely legitimate to require that the next
design also be able to leverage this code base. Similarly, if your design team is
highly experienced using the Green Hills© compiler, your requirements document
probably would specify that compiler as well.
Figure 1.2: Tools used in the design process.
The embedded design cycle represented in terms of the tools used in the
design process (courtesy of Dr. Daniel Mann, AMD Fellow, Advanced Micro
Devices, Inc., Austin, TX).
The economics and reality of a design requirement often force decisions to be
made before designers can consider the best design trade-offs for the next project.
In fact, designers use the term “clean sheet of paper” when referring to a design
opportunity in which the requirement constraints are minimal and can be strictly
specified in terms of performance and cost goals.
Figure 1.2 shows the maintenance and upgrade phase. The engineers are
responsible for maintaining and improving existing product designs until the
burden of new features and requirements overwhelms the existing design. Usually,
these engineers were not the same group that designed the original product. It’s a
miracle if the original designers are still around to answer questions about the
product. Although more engineers maintain and upgrade projects than create new
designs, few, if any, tools are available to help these designers reverse-engineer
the product to make improvements and locate bugs. The tools used for
maintenance and upgrading are the same tools designed for engineers creating
The remainder of this book is devoted to following this life cycle through the step-
by-step development of embedded systems. The following sections give an
overview of the steps in Figure 1.1
Although this book isn’t intended as a marketing manual, learning how to design
an embedded system should include some consideration of designing the right
embedded system. For many R&D engineers, designing the right product means
cramming everything possible into the product to make sure they don’t miss
anything. Obviously, this wastes time and resources, which is why marketing and
sales departments lead (or completely execute) the product-specification process
for most companies. The R&D engineers usually aren’t allowed customer contact in
this early stage of the design. This shortsighted policy prevents the product design
engineers from acquiring a useful customer perspective about their products.
Although some methods of customer research, such as questionnaires and focus
groups, clearly belong in the realm of marketing specialists, most projects benefit
from including engineers in some market-research activities, especially the
customer visit or customer research tour.
The Ideal Customer Research Tour
The ideal research team is three or four people, usually a marketing or sales
engineer and two or three R&D types. Each member of the team has a specific role
during the visit. Often, these roles switch among the team members so each has
an opportunity to try all the roles. The team prepares for the visit by developing a
questionnaire to use to keep the interviews flowing smoothly. In general, the
questionnaire consists of a set of open-ended questions that the team members fill
in as they speak with the customers. For several customer visits, my research
team spent more than two weeks preparing and refining the questionnaire.
(Considering the cost of a customer visit tour (about $1,000 per day, per person
for airfare, hotels, meals, and loss of productivity), it’s amazing how often little
effort is put into preparing for the visit. Although it makes sense to visit your
customers and get inside their heads, it makes more sense to prepare properly for
the research tour.)
The lead interviewer is often the marketing person, although it doesn’t have to be.
The second team member takes notes and asks follow-up questions or digs down
even deeper. The remaining team members are observers and technical resources.
If the discussion centers on technical issues, the other team members might have
to speak up, especially if the discussion concerns their area of expertise. However,
their primary function is to take notes, listen carefully, and look around as much as
After each visit ends, the team meets off-site for a debriefing. The debriefing step
is as important as the visit itself to make sure the team members retain the
What did each member hear?
What was explicitly stated? What was implicit?
Did they like what we had or were they being polite?
Was someone really turned on by it?
Did we need to refine our presentation or the form of the questionnaire?
Were we talking to the right people?
As the debriefing continues, team members take additional notes and jot down
thoughts. At the end of the day, one team member writes a summary of the visit’s
After returning from the tour, the effort focuses on translating what the team
heard from the customers into a set of product requirements to act on. These
sessions are often the most difficult and the most fun. The team often is
passionate in its arguments for the customers and equally passionate that the
customers don’t know what they want. At some point in this process, the
information from the visit is distilled down to a set of requirements to guide the
team through the product development phase.
Often, teams single out one or more customers for a second or third visit as the
product development progresses. These visits provide a reality check and some
midcourse corrections while the impact of the changes are minimal.
Participating in the customer research tour as an R&D engineer on the project has
a side benefit. Not only do you have a design specification (hopefully) against
which to design, you also have a picture in your mind’s eye of your team’s ultimate
objective. A little voice in your ear now biases your endless design decisions
toward the common goals of the design team. This extra insight into the product
specifications can significantly impact the success of the project.
A senior engineering manager studied projects within her company that were
successful not only in the marketplace but also in the execution of the product-
development process. Many of these projects were embedded systems. Also, she
studied projects that had failed in the market or in the development process.
Flight Deck on the Bass Boat?
Having spent the bulk of my career as an R&D engineer and manager, I am
continually fascinated by the process of turning a concept into a product. Knowing
how to ask the right questions of a potential customer, understanding his needs,
determining the best feature and price point, and handling all the other details of
research are not easy, and certainly not straightforward to number-driven
One of the most valuable classes I ever attended was conducted by a marketing
professor at Santa Clara University on how to conduct customer research. I
learned that the customer wants everything yesterday and is unwilling to pay for
any of it. If you ask a customer whether he wants a feature, he’ll say yes every
time. So, how do you avoid building an aircraft carrier when the customer really
needs a fishing boat? First of all, don’t ask the customer whether the product
should have a flight deck. Focus your efforts on understanding what the customer
wants to accomplish and then extend his requirements to your product. As a result,
the product and features you define are an abstraction and a distillation of the
needs of your customer.
A common factor for the successful products was that the design team shared a
common vision of the product they were designing. When asked about the product,
everyone involved — senior management, marketing, sales, quality assurance, and
engineering — would provide the same general description. In contrast, many
failed products did not produce a consistent articulation of the project goals. One
engineer thought it was supposed to be a low-cost product with medium
performance. Another thought it was to be a high-performance
product, with the objective to maximize the performance-to-cost ratio. A third felt
the goal was to get something together in a hurry and put it into the market as
soon as possible.
Another often-overlooked part of the product-specification phase is the
development tools required to design the product. Figure 1.2
shows the embedded
life cycle from a different perspective. This “design tools view” of the development
cycle highlights the variety of tools needed by embedded developers.
When I designed in-circuit emulators, I saw products that were late to market
because the engineers did not have access to the best tools for the job. For
example, only a third of the hard-core embedded developers ever used in-circuit
emulators, even though they were the tools of choice for difficult debugging
The development tools requirements should be part of the product specification to
ensure that unreal expectations aren’t being set for the product development cycle
and to minimize the risk that the design team won’t meet its goals.
Tip One of the smartest project development methods of which I’m
aware is to begin each team meeting or project review meeting by
showing a list of the project musts and wants. Every project
stakeholder must agree that the list is still valid. If things have
changed, then the project manager declares the project on hold until
the differences are resolved. In most cases, this means that the
project schedule and deliverables are no longer valid. When this
happens, it’s a big deal—comparable to an assembly line worker in
an auto plant stopping the line because something is not right with
the manufacturing process of the car.
In most cases, the differences are easily resolved and work continues, but not
always. Sometimes a competitor may force a re-evaluation of the product features.
Sometimes, technologies don’t pan out, and an alternative approach must be
found. Since the alternative approach is generally not as good as the primary
approach, design compromises must be factored in.
Since an embedded design will involve both hardware and software components,
someone must decide which portion of the problem will be solved in hardware and
which in software. This choice is called the "partitioning decision."
Application developers, who normally work with pre-defined hardware resources,
may have difficulty adjusting to the notion that the hardware can be enhanced to
address any arbitrary portion of the problem. However, they've probably already
encountered examples of such a hardware/software tradeoff. For example, in the
early days of the PC (i.e., before the introduction of the 80486 processor), the
8086, 80286, and 80386 CPUs didn’t have an on-chip floating-point processing
unit. These processors required companion devices, the 8087, 80287, and 80387
floating-point units (FPUs), to directly execute the floating-point instructions in the
If the PC did not have an FPU, the application code had to trap the floating-point
instructions and execute an exception or trap routine to emulate the behavior of
the hardware FPU in software. Of course, this was much slower than having the
FPU on your motherboard, but at least the code ran.
As another example of hardware/software partitioning, you can purchase a modem
card for your PC that plugs into an ISA slot and contains the
modulation/demodulation circuitry on the board. For less money, however, you can
purchase a Winmodem that plugs into a PCI slot and uses your PC’s CPU to directly
handle the modem functions. Finally, if you are a dedicated PC gamer, you know
how important a high-performance video card is to game speed.
If you generalize the concept of the algorithm to the steps required to implement a
design, you can think of the algorithm as a combination of hardware components
and software components. Each of these hardware/software partitioning examples
implements an algorithm. You can implement that algorithm purely in software
(the CPU without the FPU example), purely in hardware (the dedicated modem
chip example), or in some combination of the two (the video card example).
Laser Printer Design Algorithm
Suppose your embedded system design task is to develop a laser printer. Figure
1.3 shows the algorithm for this project. With help from laser printer designers,
you can imagine how this task might be accomplished in software. The processor
places the incoming data stream — via the parallel port, RS-232C serial port, USB
port, or Ethernet port — into a memory buffer.
Figure 1.3: The laser printer design.
A laser printer design as an algorithm. Data enters the printer and must
be transformed into a legible ensemble of carbon dots fused to a piece of
Concurrently, the processor services the data port and converts the incoming data
stream into a stream of modulation and control signals to a laser tube, rotating
mirror, rotating drum, and assorted paper-management “stuff.” You can see how
this would bog down most modern microprocessors and limit the performance of
You could try to improve performance by adding more processors, thus dividing
the concurrent tasks among them. This would speed things up, but without more
information, it’s hard to determine whether that would be an optimal solution for
When you analyze the algorithm, however, you see that certain tasks critical to the
performance of the system are also bounded and well-defined. These tasks can be
easily represented by design methods that can be translated to a hardware-based
solution. For this laser printer design, you could dedicate a hardware block to the
process of writing the laser dots onto the photosensitive surface of the printer
drum. This frees the processor to do other tasks and only requires it to initialize
and service the hardware if an error is detected.
This seems like a fruitful approach until you dig a bit deeper. The requirements for
hardware are more stringent than for software because it’s more complicated and
costly to fix a hardware defect then to fix a software bug. If the hardware is a
custom application-specificc IC (ASIC), this is an even greater consideration
because of the overall complexity of designing a custom integrated circuit. If this
approach is deemed too risky for this project, the design team must fine-tune the
software so that the hardware-assisted circuit devices are not necessary. The risk-
management trade-off now becomes the time required to analyze the code and
decide whether a software-only solution is possible.
The design team probably will conclude that the required acceleration is not
possible unless a newer, more powerful microprocessor is used. This involves costs
as well: new tools, new board layouts, wider data paths, and greater complexity.
Performance improvements of several orders of magnitude are common when
specialized hardware replaces software-only designs; it’s hard to realize 100X or
1000X performance improvements by fine-tuning software.
These two very different design philosophies are successfully applied to the design
of laser printers in two real-world companies today. One company has highly
developed its ability to fine-tune the processor performance to minimize the need
for specialized hardware. Conversely, the other company thinks nothing of
throwing a team of ASIC designers at the problem. Both companies have
competitive products but implement a different design strategy for partitioning the
design into hardware and software components.
The partitioning decision is a complex optimization problem. Many embedded
system designs are required to be
These conflicting requirements make it difficult to create an optimal design for the
embedded product. The algorithm partitioning certainly depends on which
processor you use in the design and how you implement the overall design in the
hardware. You can choose from several hundred microprocessors, microcontrollers,
and custom ASIC cores. The choice of the CPU impacts the partitioning decision,
which impacts the tools decisions, and so on.
Given this n-space of possible choices, the designer or design team must rely on
experience to arrive at an optimal design. Also, the solution surface is generally
smooth, which means an adequate solution (possibly driven by an entirely
different constraint) is often not far off the best solution. Constraints usually
dictate the decision path for the designers, anyway. However, when the design
exercise isn’t well understood, the decision process becomes much more
interesting. You’ll read more concerning the hardware/software partitioning
problem in Chapter 3
Iteration and Implementation
(Before Hardware and Software Teams Stop Communicating)
The iteration and implementation part of the process represents a somewhat
blurred area between implementation and hardware/software partitioning (refer to
on page 2) in which the hardware and software paths diverge. This
phase represents the early design work before the hardware and software teams
build “the wall” between them.
The design is still very fluid in this phase. Even though major blocks might be
partitioned between the hardware components and the software components,
plenty of leeway remains to move these boundaries as more of the design
constraints are understood and modeled. In Figure 1.2
earlier in this chapter,
Mann represents the iteration phase as part of the selection process. The hardware
designers might be using simulation tools, such as architectural simulators, to
model the performance of the processor and memory systems. The software
designers are probably running code benchmarks on self-contained, single-board
computers that use the target micro processor. These single-board computers are
often referred to as evaluation boards because they evaluate the performance of
the microprocessor by running test code on it. The evaluation board also provides
a convenient software design and debug environment until the real system
hardware becomes available.
You’ll learn more about this stage in later chapters. Just to whet your appetite,
however, consider this: The technology exists today to enable the hardware and
software teams to work closely together and keep the partitioning process actively
engaged longer and longer into the implementation phase. The teams have a
greater opportunity to get it right the first time, minimizing the risk that something
might crop up late in the design phase and cause a major schedule delay as the
teams scramble to fix it.
Detailed Hardware and Software Design
This book isn’t intended to teach you how to write software or design hardware.
However, some aspects of embedded software and hardware design are unique to
the discipline and should be discussed in detail. For example, after one of my
lectures, a student asked, “Yes, but how does the code actually get into the
microprocessor?” Although well-versed in C, C++, and Java, he had never faced
having to initialize an environment so that the C code could run in the first place.
Therefore, I have devoted separate chapters to the development environment and
special software techniques.
I’ve given considerable thought how deeply I should describe some of the
hardware design issues. This is a difficult decision to make because there is so
much material that could be covered. Also, most electrical engineering students
have taken courses in digital design and microprocessors, so they’ve had ample
opportunity to be exposed to the actual hardware issues of embedded systems
design. Some issues are worth mentioning, and I’ll cover these as necessary.
The hardware/software integration phase of the development cycle must have
special tools and methods to manage the complexity. The process of integrating
embedded software and hardware is an exercise in debugging and discovery.
Discovery is an especially apt term because the software team now finds out
whether it really understood the hardware specification document provided by the
Big Endian/Little Endian Problem
One of my favorite integration discoveries is the “little endian/big endian”
syndrome. The hardware designer assumes big endian organization, and the
software designer assumes little endian byte order. What makes this a classic
example of an interface and integration error is that both the software and
hardware could be correct in isolation but fail when integrated because the
“endianness” of the interface is misunderstood.
Suppose, for example that a serial port is designed for an ASIC with a 16-bit I/O
bus. The port is memory mapped at address 0x400000. Eight bits of the word are
the data portion of the port, and the other eight bits are the status portion of the
port. Even though the hardware designer might specify what bits are status and