Embedded Books

This is the most useful book on embedded programming that I've ever read. The reason for this is its practical aspects.

First it talks about what is probably (certainly the one I use so I guess I'm prejudiced) the most CPU used in widest range of embedded applications.

Second it picks one of the standard real time operating systems (ThreadX -- and includes a demo system of the RTOS on the bound in CD).

The book gives a clear introduction into the goals and techniques used in embedded programming.

Finally it discusses in detail a case study of the design of a typical embedded system. In fact the device they are building looks so useful that I wonder if it isn't a real product.

Again, this is an excellent introduction, suitable for the engineering being assigned to a project or the manager beginning to specify one.

I was very pleasantly surprised with how well this book performed at 2 very different levels. It provided a very simple introduction to Real Time programming (with a definite focus on the ThreadX OS) as well as being a very useful reference for an experienced ThreadX user.

I have been using ThreadX for several years (although not on the ARM processor) and I wanted the book to help with training some new programmers as well as to evaluate the option of using the ARM on a new project. I was impressed as to how well the book helped to achieve these goals.

The book gives a clear explanation on how the various Operating System services are used and where they are appropriate. The demonstration version of ThreadX was very useful for playing with the concepts and getting a "hands on" feel for how things worked without having to deal with all the details of how to get a program running on an embedded system.

I also liked the description of how the system is implemented on the ARM processor, it gave enough detail that I could understand the interaction with the hardware and made it much simpler to introduce a non-ARM architecture as part of the training.

As useful as the book was for the introduction and training aspect, I have noticed that it has also become my standard ThreadX reference at work, which was not what I expected. While the ThreadX documentation does have more detail I have found it much simpler to use this book and I have only needed to refer to the "official" documentation once or twice since I got this book. I have also found the demonstration OS very useful for prototyping and testing.

The only group that I think may not find this book as useful a reference, is the knowledgable embedded developer who is not working with ThreadX and wants to find out more about the OS or about the ARM processor. For this audience there is probably insufficient depth and more detail than they require, but for anyone who is entering the field or is working with ThreadX regularly I would highly reccomend this book.

All you need to know, Dear Reader, is that this book is -- literally -- a selective reprint of Express Logic's ThreadX User's Guide that is available for free download on their site. Differences? It's pared down a bit and a perfunctory chapter on ARM hardware is tacked on. What did the author actually contribute to this book? His 'PhD' for the cover?

Also, nearly one third (100 out of 350 pages) of this book is padding: an API reference, a more comprehensive version of which is, yes, again, available for free download from Express Logic.

Bottom line: I CANNOT in good conscience recommend this book: first and foremost because 99% of its content is excerpted verbatim from the freely available ThreadX User's Guide and the remaining 1% is covered better elsewhere (for example, in _ARM System Developer's Guide_ by Sloss -- a fundamental, extensive, and very well-written book).

PS. A side observation: I've never seen a good book from this publisher, CMP (formerly R&D). I just thought I'd share.

This book provides a solid introduction to embedded kernel mechanics and a detailed discussion of the ThreadX operating system. The first five chapters present a light overview of real-time operating system concepts, the ThreadX kernel and the ARM processor. The next seven chapters focus on classic issues faced by kernel designers, including critical sections, mutual exclusion, synchronization, inter-thread communication and memory management. Another chapter discusses ARM exception handling, and the final one provides a complete implementation of a real-time system in C using ThreadX system calls to illustrate the utility of an embedded kernel. The book concludes with a number of detailed appendices documenting the ThreadX API.

Each fundamental RTOS concept (eg mutual exclusion, memory management) receives a balanced, detailed treatment that explores generic OS issues and corresponding ThreadX-specific services. The text is straightforward and non-academic, aimed more at engineer-practitioners than at students of operating system theory. Essentially this is a technical discussion of ThreadX, demonstrating that the kernel provides clean solutions to classic real-time design challenges.

Another review indicates that padded appendices contain API reference material which can be freely downloaded from a vendor website. Given that the appendices account for appx 25% of content, I agree that buyers should be informed. I also think that the appendices are very helpful to those of us who prefer the convenience of self-contained material, and who prefer to avoid the inconvenience of downloading/printing/handling an additional document. All-in-all I like the API section and consider this a matter of personal preference.

I have one minor quibble with the equal emphasis given to ThreadX and ARM in the title. The book is clearly RTOS-centric, much more concerned with operating system concepts than with details of the ARM core. The light ARM material mainly illustrates the coupling of ThreadX to a particular processor architecture, and readers should not expect an ARM technical guide.

This book was ok, but you need borland C++ unless you want to do some major porting... The back said that you only need borland OR microsoft c, but that is a lie. The only reasion I gave it a 4 was becouse of this. You could tell that a program wrote it and not an author. If you want a book on os programing get it

The author really made the text flow by providing a high level view and then peeling back each layer to reveal the working of the kernel. In addition, he judiciously intermixed, text (historical, theoretical, practical, opinions) with diagrams, and code segments, which made the book easy to read, and concepts easy to follow.

The code was written in a clean and consistant style, amply annotated with comments which explain what the code does, as opposed to just paraphrasing it. A student or inexperienced "C" coder will see the practical uses of portability techniques, ifdef debugs, type defs, etc., which are frequently ignored in academic works.

Lastly, I'm glad the author resisted the current trend of dumping everything but the kitchen sink into a text just to see how much shelf space he could take up (most professionals are to busy for that nonsense). This is a nuts-and-bolts approach; what are the concepts, why is done, how is done, here's the code (and its all on a companion disk).

If your looking to learn about DOS, kernel implementations, or some good "C" code examples/idioms, this book is highly recommended.

This is my second pass on this book.And each pass gives more pleasure.Excellently designed while obeying ms-dos compatability.Excellent explanations.Highly commented programs.I have got the overall picture.But the f-node related functions are somehow harder to understand and needs more explanation.I have made pass 1 on Podanoffsky's dissecting dos.This book is much better than the latter.If there had been a table showing the functions and the files they are in it would have been better. I am looking for a similar book on a multiprogramming OS and as easy to grasp as this one.

Good book for everyone who want to start development using Microsoft Platform Builder 6.0 and Windows Embedded CE 6.0. This book is good point for jump start. You can use it as excellent guide for development tool. If you want to get deep knowledge about Windows Embedded CE internals then this book is not for you.

This book is a "must have" for developers who need to get a good introduction to the Windows Embedded CE developement process. The chapters are following the process one has to do when creating a Windows Embedded CE solution.
I recommend this book to all development managers who need to understand what has to be done when doing Windows Embedded CE business.
The autors are providing additional book links which I recommand to read before starting a project.

It's about time a book like this was written.

Imagine that you are an experienced developer who has been assigned to move a driver from the desktop to CE or that you want to transfer a maintenance CE project to another experienced engineer. What is the fastest way to get up to speed on the build environment so that you can actually get to work on your code?

The answer is definitely NOT to read the Microsoft documentation. The Windows CE build environment is a hodge-podge of many different files, registry keys, tools, and sequences. Save yourself months of frustration and get this short book which will probably answer all your questions. And with the chapters on the CE architecture you will be up to speed on the platform in no time.

The only reason I can't give the book five stars is that, for me, it is a little short at 240 pages. Some more of the unique debugging tools available for the platform could be covered (and the value of the shared source should probably be highlighted more, possibly in an appendix), and the book would feel more complete.

With their knowledge of CE and straightforward writing style I only hope we see a second edition (or more books) from this writing team.

I recently purchased this book and i think it is wonderful. The author is also a teacher, therfore he knows how to present the information in an easy to read format. I would give it 10 starz if i could!!

Clearly this book was meant for hands-on laboratory instruction. Without the lecture and other visual aids, the book is no more than a repeat of material, that can be found elsewhere, and better presented. The schematics are hand drawn, without benefit of drafting expertise!. If you want to fluf up your bookshelf then buy it but otherwise, don't expect to learn too much from it!

The average person in the US now uses a computer. Typically running a Microsoft operating system or unix or linux. Yet there is an entire ecosystem of embedded computers out there, invisible to most people. Wolf's text explains how you can program such computers as well as design the circuitry in which they might exist. Here, "computer" in the book essentially means microprocessor plus some off-chip memory. The book surveys two main microprocessor families - ARM and SHARC. These are not the most common microprocessors. (Which might be by Motorola.). But Wolf chooses them to illustrate different design ideals for their instruction sets.

One nice thing about the book is that you get a direct grasp of the hierarchy of design and logic. Climbing from the low level devices of latches, gates, flip-flops and the like, to the microprocessor and its machine language, to the corresponding and far easier to use assembly language. Then, upwards to an operating system.

Do you know what percentage of all computers run Windows or some kind of Unix? Guess. I'll give you the answer later.

This book is about all the other computers out there - the ones in your car's airbags and antilock brakes; in your watch, cellphone, TV and its remote, CD player, and computer keyboard; in your implanted defibrillator.

Wolf starts with an introduction in terms of a personal-scale, practical example. Next he goes into what a CPU is in lots more detail than most programmers ever think about - the kind of detail you need when the CPU interacts so intimately with the other components in the system. Maybe you never heard of the ARM or SHARC processors (unless you already do embedded work), but they're good representative choices. ARM is an incredibly common core architecture, with supervisor mode and memory mapping, what it takes to run a "real" OS, whether it does or not. SHARC is a signal processor - a real processor, but with extras for fast artihmetic processing. Together, the two stand adequately for a large fraction of the embedded processors in use.The next chapter goes over hardware basics: the bus, memory mapped IO, interface issues, and in-circuit debugging.

The rest of the book generally covers higher level issues: software design, embedded and real-time OSs, coprocessors, and networks. Although coverage of IIC and similar board-level communication is good, I found the ethernet discussion weak. Anyone working at this level is likely to need 802.2 protocols, which I did not see mentioned. The book's strengths far outnumber its occasional soft spots, though.

Embedded computing is a huge, many faceted field, so no book can cover more than a tiny fraction of what it means. Still, this addresses a broad, useful range what you need to program 99% of the computers out there - because only about 1% run Windows or Unix.

//wiredweird

This book is difficult to read but is detailed, but many techqniues are new and different. Some of them are similar to compiler optimizations well known but many are new like memory size analysis and data layout technique. So it is interesting and useful for advanced engineers.

This book presents lots of interesting insights into low power software development. It will be of interest to embedded software engineers wanting to program at a higher level and develop skills related to architectures and compilers. The case study and the data layout optimization techniques are interesting. The language is a little tough to understand. Surely a good book to have for practising embedded software engineers.

This book describes some practical debugging techniques. The reading is not very heavy. My biggest complaint is that the author appears to carry a big chip on his shoulder regarding the relationship between engineering and marketing, sales, and management. Unfortunately, this detracts from what would otherwise be a good book. Some of the comments made against management and marketing indicate quite a bit of resentment that has built up over the years. This book should not have been the vehicle to express it.

Having being inolved in debugging embedded systems from a hardware and software perspective for a number of years, I found it amusing that someone else out there shared my sentiments.

Mr. Ball has a good logical approach to fault finding and these techniques can be learnt saving years of 'doing it the hard way'.
As for Mr. Ball's attitude towards marketing\management, well I found it amusing and unless you are very lucky, always present to some extent in the workplace.

I would strongly recommend buying this book as hardware and software are so closely related in an embedded system that coverage of both disciplines in extremely valuable.

Learning about the stunts that Management can pull is generally not covered outside of a Dilbert strip.

I bought the book because the table of contents showed that the book covered the topics comprehensively. However, there is a serious lack of depth. I think the book is good for students who are just learning about linux and embedded systems, but not as useful for the more serious and experienced developer.

I take this opportunity to congratulate authors on the job WELL DONE. This book emphasizes on "programming" aspect of embedded Linux which is missing from earlier books like one from karim yaghmour. The topics such as MTD, real time, embedded graphics, uclinux are presented very clearly and in detailed manner. Overall, it's GOOD.

This book was really helpful when I was first getting up to speed on Embedded Visual Basic development. The chapter discussing what could be done in VB but not in EVB was very useful. The samples in the book are useful.
Once you have a good grasp of EVB though this book seems to be lacking the more advanced issues you'll run into. It doesn't cover near enough of the API calls and how to use them in EVB. It doesn't talk about building an install. It doesn't discuss the remote API. It doesn't discuss tricks on how to get your application working across different platforms.
If you're getting started check this book out, if you've been programming for awhile and need a good reference book on all topics look elsewhere.

I really enjoyed reading this well-written book on eMbedded Visual Basic. I particularly liked the chapter on SQL Server CE. The reader is well-served by the clear implementation of a complicated feature like SQL Server Replication. The author leaves no stone unturned in his coverage of POOM development. This book is a must-read!

This is an Excellent Book for the dsPIC Enthusiast Interested in Intelligent Sensor Design. The book really does deserve 5 stars. The reason I rated the book 4 stars is that there are a few errors that, once corrected will go a long way to a 5 star rating.

I sometimes get frustrated with an author that makes errors. This book is not riddled with errors like some I've read. In this case, the errors are forgivable as it is obvious that they were made in the effort to get this book to print. The first error has to do with the Nyquist theorem. The author states, "As one can easily see, a problem arises when the highest frequency component in the original signal is greater than twice the sampling frequency, a sample rate known as the Nyquist rate." Opps; the maximum frequency in an analog signal, f1, is often referred to as the `Nyqust frequency'. The minimum sampling rate (2 *f1 samples per second) at which a signal can be recovered is known as the `Nyquist rate'. The `folding frequency', which is one-half the sampling frequency used, is the highest frequency which can be recovered according to the Sampling Theorem (See Lynn and Fuerst, "Introductory to Digital Signal Processing, 2nd ed., p11). Hence, I believe the author meant to say, "As one can easily see, a problem arises when the highest frequency component in the original signal is greater than one-half the sampling frequency, a sample rate known as the Nyquist rate." The other factual error I found was stating that the dsPICDEM Demo board has a temperature sensor with SPI. The board I believe the author is referring to (dsPICDEM 1.1) has a TC1047A which is an analog sensor, not SPI. Neither error is worth rating a book lower, I just wanted to point out two errors that may, at first, puzzle a reader.

So, why is the book excellent? After reading the book, I believe it is fair to say Creed Huddleston is an experienced embedded veteran with a disciplined code style. Creed has mastered the dsPIC and can teach you a lot about using the dsPIC in intelligent sensor designs. That is, if you have an open mind, take the time to read and use the code on included CD, you will learn a lot. The code in the book is very well organized. You will need access to 1) Microchip's C30 GNU C compiler (a free student version is available); 2) the dsPIC Digital filter software (a lite version is available at a modest cost), 3) MPLAB (Free download from Microchip); 4) The dsPICDEM 1.1 demo board (unless you have the time to build your own circuit or adapt the code to another); 5) Time to build an interface circuit to the sensor of your choice. Creed takes you though the rational for intelligent sensors in the early part of the book, though a brief introduction to DSP (this is NOT a DSP tutorial book), though a brief introduction the dsPIC architecture, and finally to sensor interface by example of three projects; a temperature sensor, pressure and load sensors, and flow sensors.

In the latter half of the book, you are introduced to a dsPIC `toolkit', created by the author organized in a framework that you can use in your own projects. The beginning dsPIC developer or an intermediate developer would most likely benefit from learning from the code style, rational behind the code organization, and examples the author demonstrates. The framework is state machine driven using a simplistic approach and is not a UML diagram-based. That is, the style is common sense and low-key to allow the reader to understand the intelligent sensor concept, not software design theory.

The chapters are:
1. What Are Intelligent Sensors, and Why Should I Care about Them?
2. Intuitive Digital Signal Processing
3. Underneath the Hood of the dsPIC DSC
4. Learning to be a Good Communicator
5. A Basic Toolkit for the dsPIC DSC
6. Sensor Application - Temperature Sensor
7. Sensor Application - Pressure and Load Sensors
8. Sensor Application - Flow Sensors
9. Where are We Headed?
10. Appendix A: Software on the Included CD-ROM
11. Appendix B: Initialization of the dsPIC DSC and the System Start-up Code
12. Appendix C: Buffered, Interrupt-driven Serial I/O

This is an introductory text on making sensors "intelligent". It meets that need well.

This book is not a text on DSP. If you need a text book on DSP, get a DSP text book.

This is not a text on PIC microcontrollers. There are several from introductory to advanced in print.