Embedded software is in almost every electronic device we use today. There is software hidden away inside our watches, VCR’s, cellular phones, and even some toasters. The military uses embedded software to guide missiles and detect enemy aircraft. And communication satellites, deep space probes, and many medical instruments would be nearly impossible to create without embedded software.
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 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 still pretty much on my own. The few people that 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 helps too if they have some familiarity with basic data structures like linked lists. The book does not assume 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’ve 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 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 remainder 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 may be looking for a reference book with explanations of 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 that 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, an annotated bibliography, and a glossary. The ten chapters can be divide quite nicely into two parts. The first part consists of Chapters 1-5 and is intended primarily for embedded systems newcomers. 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 Chapters 6-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, Chapters 6-9 contain example programs that may be useful to you on a future embedded project.
Chapter 1, Introduction, 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, Your First Embedded Program, 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, Compiling, Linking, and Locating, introduces the software development tools you will be using to prepare your programs for execution by an embedded processor.
Chapter 4, Downloading and Debugging, presents various techniques for loading your executable programs into an embedded system. It also describes the debugging tools and techniques that may be available to you.
Chapter 5, Getting to Know the Hardware, 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, Memory, 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, Peripherals, explains device driver design and implementation techniques and includes an example driver for a common peripheral called a timer.
Chapter 8, Operating Systems, 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, Putting it All Together, 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 everything you’ve learned so far together.
Chapter 10, Optimizing Your Code, 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:
Italics are use for the names of functions and files, when they appear in the body of a paragraph.
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 variable names and other code snippets.
strong> is used in the examples to show commands and options that you type literally.
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 within the odd-numbered chapters and ‘she’ in all of the even 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.