Best Embedded Systems Books

I've spent a lot of hours looking for the "perfect" embedded system textbook for my teaching. Of course the perfect book never really exists, but I've read a lot of them. Below are my subjective impressions of a number of books that might be useful in learning more about embedded systems.

Books on embedded computing systems generally take one of several starting points, depending on the intended audience and the background of the author. None of these approaches is inherently better than the others, but it helps a lot to know where the books are coming from when you pick one.

Embedded Software:

This book talks about embedded software at a high level. (This is my book and I put it first in the list; you were expecting something else?)

Better Embedded System Software Philip Koopman, 2010, 397 pages, ISBN-13: 978-0-9844490-0-2 This book distills the experience of more than 90 design reviews on real embedded system products into a set of bite-size lessons learned in the areas of software development process, requirements, architecture, design, implementation, verification & validation, and critical system properties. Each chapter describes an area that tends to be a problem in embedded system design, symptoms that tend to indicate you need to make changes, the risks of not fixing problems in this area, and concrete ways to make your embedded system software better. Each chapter is relatively self-sufficient, permitting developers with a busy schedule to cherry-pick the best ideas to make their systems better right away. This book is about the bigger picture on embedded software design and how to get it right in an industry setting. There is also an accompanying blog. You can also get this from Amazon if you prefer, but usually the price is higher than with the author discount.

Computer Architecture and Embedded Systems:

These books generally assume you have some knowledge of digital hardware design and want to start with how "bare metal" programming is done. So they start with a CPU and its assembly language, and work up from there. Books of this type often are associated with classical "Intro to Microprocessors" courses in undergraduate computer engineering programs.

Computers as Components: principles of embedded computing system design Wayne Wolf, 2001, 662 pages This book was written by one of the leading academics in the field of embedded systems, at Princeton University. It comes from the point of computer hardware design (intended audience: undergraduate computer engineering students), and so starts with CPUs and assembly language. It moves on to cover the main points in CPU accelerators, software design, operating systems, networks, and system design techniques. This is one of the more thorough embedded systems books and one of the few that is a comprehensive text. The first portion of the book has solid coverage on microcontroller operation and usage. The back half of the book gradually turns into a survey of advanced topics at a higher level. Examples are for the relatively high-end ARM and SHARC processors, in both assembly language and C. But the book is not overly dependent on the specifics of examples and could be used fairly easily with other processors as well. Probably this is the best current big-CPU text in this category.

Embedded Microcomputer Systems: real time interfacing Jonathan Valvano, 2006, 840 pages This is a text for a relatively traditional microcontrollers course by a professor at UT Austin. It seems mostly intended for third- and fourth-year undergraduate students. It has very extensive coverage of assembly language, interfacing, interrupts, timing, I/O and the like. The emphasis is on understanding all the gory details as a way to see how things really work, although some readers find the approach concentrates too much on details and not enough on the big picture. The book uses extensive examples from the Motorola 6811 and 6812 family of 8- and 16-bit processors (more recently known as Freescale processors, such as the MC68HC12) and probably would only be useful in conjunction with that family of processors programmed in assembly language or C. Probably this is the best current small-CPU text in this category.

C/C++ Programming and Embedded Systems:

These books assume you know some C or C++ programming, but don't know a lot about the underlying hardware. If you have done desktop programming and want to learn embedded systems these are a reasonable starting point. Often this is where computer scientists start.

Programming Embedded Systems: With C and GNU Development Tools, 2nd Edition Michael Barr, 2006, 301 pages. Michael Barr was editor of Embedded Systems Programming magazine for many years, and certainly knows how to write well. This book is a gentle introduction to the world of embedded computing (and system programming) that lies beyond ordinary desktop programming. It really more about how system programming works (operating systems, memory management, tool chains) than it is about embedded hardware. It is more about having common ideas, tricks, and techniques than comprehensive coverage -- so you'll want to move on to another book after you digest this one. But, it is well written and is justifiably popular as a first introduction. The book is in general independent of which CPU you are using, although with GNU tools I'd expect the second edition emphasizes 32-bit processors. Examples are in the C programming language. This is a good place to start if you want to transition from desktop to embedded C programming. (This review is based on the first edition; the second edition includes GNU development tools)

Real Time and Embedded Systems:

These books emphasize the operating system and real time scheduling aspects of embedded system design. Some of them put equal emphasis on software development practices.

Software Engineering for Real-Time Systems Jim Cooling, 2002, 787 pages This thick book covers the real time programming aspects of embedded systems, with particular emphasis on software design techniques within the context of using a real time operating system (RTOS). This is a nice book for developers who are going to spend most of their time writing code for a fairly complex, "big" embedded system, especially in the aerospace and defense domains. There is a heavy emphasis on concepts and diagrams. There is almost no emphasis on writing actual code (which can be a good thing, since good design and architecture skills are much more important than mere ability to write code). Because there isn't really any coding, the book is processor and language independent. There are no homework questions and no problem assignments, so it is not a ready-made textbook, but it looks reasonable for use as a text if accompanied by instructor-created assignments.

Real-Time Systems Jane Liu, 2000, 610 pages This book is about mechanisms and theory underlying real time operating systems, such as scheduling theory, resource management, and access control. It's a solid textbook for a fourth-year undergraduate or Master-level college student. The book is largely language and processor independent, since it is about math and theory more than actually writing code. If you want to learn real time theory, this is a good starting point.

An Embedded Software Primer David Simon, 1999, 448 pages This book provides an introduction to hardware, and discusses software development. But the heart of the book is embedded software in the context of real time operating systems, including interrupts, multitasking approaches, and real time operating system services. It uses the uCOS-II RTOS, but is processor-independent due to the use of the "C!!" programming language ("!!" comment is used to describe hardware-dependent actions in English text). It's popular based on the accessibility of both its writing and the included software tools that will run on a PC.

Embedded Systems: Architecture, Programming, and Design Raj Kamal, 2006, 672 pages This text by an Indian professor covers aspects of creating software for embedded systems built on top of a real time operating system (RTOS). The main concentration areas of the book are software design, device drivers, and using RTOS services. Examples are in C and C++ and there are some brief problem sections.

Hardware/Software Codesign:

Some high-end embedded systems involve creating both customized hardware and software to run on that hardware. These books look at embedded systems from the point of view of customized hardware (often in the form of a "system on chip") or FPGAs as augmentation to a standard processor.

Embedded System Design: a unified hardware/software introduction Frank Vahid, Tony Givargis, 2001, 352 pages. The authors of this book developed it as an introduction to embedded systems text at UC Irvine and UC Riverside. It does a high-level overview of embedded systems, with an emphasis on building such systems out of a combination of a standard microcontroller and an FPGA for accelerating key computational functions. This book is a good starting point for someone who wants to progress to semi-custom chip design as a next step. The book is processor-independent. There is some example C code but that language is not essential to understanding the book.

Lots of Example Code:

These books emphasizing providing a substantial amount of working code, usually for a specific processor. In general these books are best for two purposes, although some are broader than this: (1) a source of code as a starting point for a project; and (2) examples of code to study to see how others do things.

Patterns for Time-Triggered Embedded Systems Michael Pont, 2001, 1024 pages. The author of this book is at the University of Leicester, in the UK. The emphasis is on using C code in two ways. First, a very extensive set of chapters explains how to interface with an impressive array of I/O devices (the most complete such list I can recall seeing). The second emphasis is on how to build a time-triggered architecture, which is a generalization of cyclic executives that has some significant advantages for embedded control systems. The examples are for an 8051, and the portions of the code that deal with setting up control registers and so on are specific to that architecture. However, the discussions of how I/O devices work and the general code flow are still useful for understanding other processors. This is probably the "full of code" book I like the most.

Safety and Critical Systems:

These books emphasizing creating embedded systems that are safe, dependable, or otherwise have higher integrity than ordinary "desktop-quality" software.

Safety-Critical Computer Systems Neil Storey, 1996, 453 pages. Although it has been a while since it was written, I consider this the most practical and useful textbook on safety critical computer systems. It covers all the aspects of safety-critical design, based mostly on hardware approaches. While software is certainly discussed, it is not so easy to apply these techniques to software in practice -- but that situation hasn't changed all that much in the decade since the book was written. It is independent of programming language and processor. The biggest gap is that IEC 61508 happened after this book was written, so it isn't discussed. If you want to learn about how to deal with safety in an embedded system context, this is the best book to start with.

Other Books:

These books don't really aim to teach embedded systems, but can be useful supplemental and reference materials.

Embedded Systems Dictionary Jack Ganssle & Michael Barr, 2003, 291 pages This book is an extended glossary of over 4500 terms relevant embedded systems. Coverage includes hardware, software, controls, real time systems, and program management. If you aren't sure where the holes in your knowledge are, you can learn a lot just by browsing through to see what concepts you've been missing. The authors have both been writing (and editing) for years, so readability is excellent.

Sponsored Advertisement: