| |
|
| Programming Embedded Systems
in C and C++ |
| By Michael Barr |
| |
|
| Publisher |
: O'Reilly |
| Pub Date |
: January 1999 |
| ISBN |
: 1-56592-354-5 |
| Pages |
: 191 |
|
This book introduces embedded systems to C and C++ programmers.
Topics include testing memory devices, writing and erasing Flash memory,
verifying nonvolatile memory contents, controlling on-chip peripherals,
device driver design and implementation, optimizing embedded code for
size and speed, and making the most of C++ without a performance penalty.
EEn |
Copyright
Copyright © 1999 O'Reilly & Associates, Inc. All rights
reserved.
Printed in the United States of America.
Published by O'Reilly & Associates, Inc., 1005 Gravenstein
Highway North, Sebastopol, CA 95472.
O'Reilly & Associates books may be purchased for educational,
business, or sales promotional use. Online editions are also available for most
titles (http://safari.oreilly.com).
For more information contact our corporate/institutional sales department:
800-998-9938 or
[email protected].
Nutshell Handbook, the Nutshell Handbook logo, and the
O'Reilly logo are registered trademarks of O'Reilly & Associates, Inc. The
association between the image of ticks and the topic of embedded systems is a
trademark of O'Reilly & Associates, Inc. Many of the designations used by
manufacturers and sellers to distinguish their products are claimed as
trademarks. Where those designations appear in this book, and O'Reilly &
Associates, Inc. was aware of a trademark claim, the designations have been
printed in caps or initial caps.
While every precaution has been taken in the preparation of
this book, the publisher and the author assume no responsibility for errors or
omissions, or for damages resulting from the use of the information contained
herein.
Dedication
For Mom and Dad
Preface
First figure out why you want the students to learn the
subject and what you want them to know, and the method will result more or
less by common sense.
—Richard Feynman
Embedded software is in almost every electronic device in use
today. There is software hidden away inside our watches, VCRs, cellular phones,
and even a few toasters. The military uses embedded software to guide missiles
and detect enemy aircraft. And communication satellites, deep-space probes, and
many medical instruments would've been nearly impossible to create without it.
Someone has to write all that software, and there are tens of
thousands of electrical engineers, computer scientists, and other professionals
who actually do. I am one of them, and I know from my personal experience just
how hard it can be to learn the craft. There aren't any embedded software
courses in school, and I've never been able to find a decent book about the
subject in any library.
Each embedded system is unique, and the hardware is highly
specialized to the application domain. As a result, embedded systems programming
can be a widely varying experience and can take years to master. However, one
common denominator across almost all embedded software development is the use of
the C programming language. This book will teach you how to use C and its
descendent C++ in any embedded system.
Even if you already know how to write embedded software, you
can still learn a lot from this book. In addition to learning how to use C and
C++ more effectively, you'll also benefit from the detailed explanations and
source code solutions to common embedded software problems. Among the advanced
topics covered in the book are memory testing and verification, device driver
design and implementation, real-time operating system internals, and code
optimization techniques.
Why I Wrote This Book
I once heard an estimate that in the United States there are
eight microprocessor-based devices for every person. At the time, I wondered how
this could be. Are there really that many computers surrounding us? Later, when
I had more time to think about it, I started to make a list of the things I used
that probably contained a microprocessor. Within five minutes, my list contained
ten items: television, stereo, coffee maker, alarm clock, VCR, microwave,
dishwasher, remote control, bread machine, and digital watch. And those were
just my personal possessions—I quickly came up with ten more devices I used at
work.
The revelation that every one of those products contains not
only a processor, but also software, was not far behind. At last, I knew what I
wanted to do with my life. I wanted to put my programming skills to work
developing embedded computer systems. But how would I acquire the necessary
knowledge? At this point, I was in my last year of college. There hadn't been
any classes on embedded systems programming so far, and I wasn't able to find
any listed in the course catalog.
Fortunately, when I graduated I found a company that let me
write embedded software while I was still learning. But I was pretty much on my
own. The few people who knew about embedded software were usually too busy to
explain things to me, so I searched high and low for a book that would teach me.
In the end, I found I had to learn everything myself. I never found that book,
and I always wondered why no one had written it.
Now I've decided to write that book myself. And in the
process, I've discovered why no one had done it before. One of the hardest
things about this subject is knowing when to stop writing. Each embedded system
is unique, and I have learned that there is an exception to every rule.
Nevertheless, I have tried to boil the subject down to its essence and present
only those things that programmers definitely need to know about embedded
systems.
Intended Audience
This is a book about programming embedded systems in C and
C++. As such, it assumes that the reader already has some programming experience
and is at least familiar with the syntax of these two languages. It also helps
if you have some familiarity with basic data structures, such as linked lists.
The book does not assume that you have a great deal of knowledge about computer
hardware, but it does expect that you are willing to learn a little bit about
hardware along the way. This is, after all, a part of the job of an embedded
programmer.
While writing this book, I had two types of readers in mind.
The first reader is a beginner—much as I was when I graduated from college. She
has a background in computer science or engineering and a few years of
programming experience. The beginner is interested in writing embedded software
for a living but is not sure just how to get started. After reading the first
five chapters, she will be able to put her programming skills to work developing
simple embedded programs. The rest of the book will act as her reference for the
more advanced topics encountered in the coming months and years of her career.
The second reader is already an embedded systems programmer.
She is familiar with embedded hardware and knows how to write software for it
but is looking for a reference book that explains key topics. Perhaps the
embedded systems programmer has experience only with assembly language
programming and is relatively new to C and C++. In that case, the book will
teach her how to use those languages in an embedded system, and the later
chapters will provide the advanced material she requires.
Whether you fall into one of these categories or not, I hope
this book provides the information you are looking for in a format that is
friendly and easily accessible.
Organization
The book contains ten chapters, one appendix, a glossary, and
an annotated bibliography. The ten chapters can be divided quite nicely into two
parts. The first part consists of
Chapter
1 through
Chapter
5 and is intended mainly for newcomers to embedded systems. These chapters
should be read in their entirety and in the order that they appear. This will
bring you up to speed quickly and introduce you to the basics of embedded
software development. After completing
Chapter
5, you will be ready to develop small pieces of embedded software on your
own.
The second part of the book consists of
Chapter
6 through
Chapter 10 and discusses advanced topics that are of interest to
inexperienced and experienced embedded programmers alike. These chapters are
mostly self-contained and can be read in any order. In addition,
Chapter
6 through
Chapter
9 contain example programs that might be useful to you on a future embedded
software project.
-
Chapter 1 introduces you to embedded systems. It defines the term, gives
examples, and explains why C and C++ were selected as the languages of the
book.
-
Chapter 2 walks you through the process of writing a simple embedded
program in C. This is roughly the equivalent of the "Hello, World" example
presented in most other programming books.
-
Chapter 3 introduces the software development tools you will be using to
prepare your programs for execution by an embedded processor.
-
Chapter 4 presents various techniques for loading your executable programs
into an embedded system. It also describes the debugging tools and techniques
that are available to you.
-
Chapter 5 outlines a simple procedure for learning about unfamiliar
hardware platforms. After completing this chapter, you will be ready to write
and debug simple embedded programs.
-
Chapter 6 tells you everything you need to know about memory in embedded
systems. The chapter includes source code implementations of memory tests and
Flash memory drivers.
-
Chapter 7 explains device driver design and implementation techniques and
includes an example driver for a common peripheral called a timer.
-
Chapter 8 includes a very basic operating system that can be used in any
embedded system. It also helps you decide if you'll need an operating system
at all and, if so, whether to buy one or write your own.
-
Chapter 9 expands on the device driver and operating system concepts
presented in the previous chapters. It explains how to control more
complicated peripherals and includes a complete example application that pulls
together everything you've learned so far.
-
Chapter 10 explains how to simultaneously increase the speed and decrease
the memory requirements of your embedded software. This includes tips for
taking advantage of the most beneficial C++ features without paying a
significant performance penalty.
Throughout the book, I have tried to strike a balance between
specific examples and general knowledge. Whenever possible, I have eliminated
minor details in the hopes of making the book more readable. You will gain the
most from the book if you view the examples, as I do, only as tools for
understanding important concepts. Try not to get bogged down in the details of
any one circuit board or chip. If you understand the general concepts, you
should be able to apply them to any embedded system you encounter.
Conventions, Typographical and Otherwise
The following typographical conventions are used throughout
the book:
- Italic
-
is used for the names of files, functions, programs,
methods, routines, and options when they appear in the body of a paragraph.
Italic is also used for emphasis and to introduce new terms.
- Constant Width
-
is used in the examples to show the contents of files and
the output of commands. In the body of a paragraph, this style is used for
keywords, variable names, classes, objects, parameters, and other code
snippets.
Constant Width Bold
-
is used in the examples to show commands and options that
you type literally.
 |
This symbol is used to indicate a tip, suggestion, or
general note. |
|
 |
This symbol is used to indicate a warning. |
|
Other conventions relate to gender and roles. With respect to
gender, I have purposefully alternated my use of the terms "he" and "she"
throughout the book. "He" is used in the odd-numbered chapters and "she" in all
of the even-numbered ones.
With respect to roles, I have occasionally distinguished
between the tasks of hardware engineers, embedded software engineers, and
application programmers in my discussion. But these titles refer only to roles
played by individual engineers, and it should be noted that it can and often
does happen that one individual fills more than one of these roles.
Obtaining the Examples Online
This book includes many source code listing, and all but the
most trivial one-liners are available online. These examples are organized by
chapter number and include build instructions (makefiles) to help you recreate
each of the executables. The complete archive is available via FTP, at
ftp://ftp.oreilly.com/pub/examples/nutshell/embedded_c/.
How to Contact Us
We have tested and verified all the information in this book
to the best of our ability, but you may find that features have changed (or even
that we have made mistakes!). Please let us know about any errors you find, as
well as your suggestions for future editions, by writing to:
- O'Reilly & Associates
- 1005 Gravenstein Highway North
- Sebastopol, CA 95472
- 800-998-9938 (in the U.S. or Canada)
- 707-829-0515 (international/local)
- 707-829-0104 (FAX)
You can also send us messages electronically. To be put on
the mailing list or request a catalog, send email to:
- [email protected]
To ask technical questions or comment on the book, send email
to:
-
[email protected]
We have a web site for the book, where we'll list examples,
errata, and any plans for future editions. You can access this page at:
-
http://www.oreilly.com/catalog/embsys/
For more information about this book and others, see the
O'Reilly web site:
-
http://www.oreilly.com
Personal Comments and Acknowledgments
As long as I can remember I have been interested in writing a
book or two. But now that I have done so, I must confess that I was naive when I
started. I had no idea how much work it would take, nor how many other people
would have to get involved. Another thing that surprised me was how easy it was
to find a willing publisher. I had expected that to be the hard part.
From proposal to publication, this project has taken almost
two years to complete. But, then, that's mostly because I worked a full-time job
throughout and tried to maintain as much of my social life as possible. Had I
known when I started that I'd still be agonizing over final drafts at this late
date, I would have probably quit working and finished the book more quickly. But
continuing to work has been good for the book (as well as my bank account!). It
has allowed me the luxury of discussing my ideas regularly with a complete cast
of embedded hardware and software professionals. Many of these same folks have
also contributed to the book more directly by reviewing drafts of some or all of
the chapters.
I am indebted to all of the following people for sharing
their ideas and reviewing my work: Toby Bennett, Paul Cabler (and the other
great folks at Arcom), Mike Corish, Kevin D'Souza, Don Davis, Steve Edwards,
Mike Ficco, Barbara Flanagan, Jack Ganssle, Stephen Harpster (who christened me
"King of the Sentence Fragment" after reading an early draft), Jonathan Harris,
Jim Jensen, Mark Kohler, Andy Kollegger, Jeff Mallory, Ian Miller, Henry
Neugauss, Chris Schanck, Brian Silverman, John Snyder, Jason Steinhorn (whose
constant stream of grammatical and technical critiques have made this book worth
reading), Ian Taylor, Lindsey Vereen, Jeff Whipple, and Greg Young.
I would also like to thank my editor, Andy Oram. Without his
enthusiasm for my initial proposal, overabundant patience, and constant
encouragement, this book would never have been completed.
Finally, I'd like to thank Alpa Dharia for her support and
encouragement throughout this long process.
Michael Barr
[email protected]
