Books

MicroC OS II: The Real Time Kernel (With CD-ROM)

Average customer rating:

Best so far in learning practical RTOS
uC/OS-II documentation + RTOS book
Quality of the book is very good
Good Book
It's a good book, but ...

MicroC OS II: The Real Time Kernel (With CD-ROM)
Jean J. Labrosse
Manufacturer: CMP Books
ProductGroup: Book
Binding: Hardcover

General | Programming | Computers & Internet | Subjects | Books

General | Computers & Internet | Subjects | Books

General | Operating Systems | Computers & Internet | Subjects | Books

General | Software | Computers & Internet | Subjects | Books

Look Inside Computer Books | Trip | Specialty Stores | Books

Qualifying Textbooks - Spring 2007 | Stores | Books

General | Software Books | Custom Stores | Stores | Software
Similar Items:

Embedded Systems Building Blocks: Complete and Ready-to-Use Modules in C
An Embedded Software Primer
Practical Statecharts in C/C++: Quantum Programming for Embedded Systems with CDROM
Real-Time Concepts for Embedded Systems
Embedded Systems Architecture: A Comprehensive Guide for Engineers and Programmers (Embedded Technology)

ASIN: 1578201039

Book Description

MicroC/OS II Second Edition describes the design and implementation of the MicroC/OS-II real-time operating system (RTOS). In addition to its value as a reference to the kernel, it is an extremely detailed and highly readable design study particularly useful to the embedded systems student. While documenting the design and implementation of the kernel, the book also walks the reader through the many related development issues: how to adapt the kernel for a new microprocessor, how to install the kernel, and how to structure the applications that run on the kernel. This edition features documentation for several important new features of the software, including new real-time services, floating points, and coding conventions. The accompanying CDROM includes complete code for the MicroC/OS-II kernel.

Customer Reviews:

Best so far in learning practical RTOS.......2007-05-11

I've learn more about embedded operating systems and kernels from this book and playing with MicroC/OS II than I ever had by working with uCos, vxworks, embedded Linux, and BSD.

uC/OS-II documentation + RTOS book.......2007-01-18

This book is not only the documentation of the uC/OS-II RTOS. It also presents many of the general real-time programming concepts in a very pedagogical manner.
I found the book very helpful.

Quality of the book is very good.......2006-11-04

The book has brand new look and feel. Its very well maintained and delivered on time. Extremely pleased with the service.

Good Book.......2006-07-03

A good book for who wanna learn about Real Time Operative Systems. Easy to read and full of interesting information

It's a good book, but ..........2006-02-21

Actually I think that it's a great book only if you have a strong background about how a kernel or RTOS works. I've spent a lot of time reading a theoretical books that teach you what a kernel is about, so for me the reading was easy. The fact that the book includes the source code makes it awesome, 'cause you can see inside a truly real kernel, and eventually write your own (what is I want to do). But if you are an unexperienced user of kernels, or just want to learn something about it, you should start somewhere else. The one a recomend you is that of Andy Tanenbaum, the creator of MINIX (minix is a tiny unix running in an intel 8086 cpu), and this other one that I bought here: Real-Time Concepts for Embedded Systems by Qing Li, Caroline Yao. After you deeply understand what a pipe o scheduler is, among other things, then you should start thinking about coding, because the book has some lack of theory. Anyway I strongly recomend it for experienced users. Have a nice coding =)

3D Game Engine Architecture: Engineering Real-Time Applications with Wild Magic (The Morgan Kaufmann Series in Interactive 3D Technology)

Average customer rating:

Good software engineering book
Acceptable book with some significant failings
3d Game Engine Architecture
Best documentation for a software architecture ever written?
Finally!

3D Game Engine Architecture: Engineering Real-Time Applications with Wild Magic (The Morgan Kaufmann Series in Interactive 3D Technology)
David H. Eberly
Manufacturer: Morgan Kaufmann
ProductGroup: Book
Binding: Hardcover

Programming | Games & Strategy Guides | Computers & Internet | Subjects | Books

Game Programming | Programming | Computers & Internet | Subjects | Books

General | Graphic Design | Computers & Internet | Subjects | Books

General | Computers & Internet | Subjects | Books

General | Software | Computers & Internet | Subjects | Books

Look Inside Computer Books | Trip | Specialty Stores | Books

All Amazon Upgrade | Amazon Upgrade | Stores | Books

Computers & Internet | Amazon Upgrade | Stores | Books

Qualifying Textbooks - Spring 2007 | Stores | Books

General | Software Books | Custom Stores | Stores | Software
Similar Items:

Real-Time Collision Detection (The Morgan Kaufmann Series in Interactive 3-D Technology) (The Morgan Kaufmann Series in Interactive 3D Technology)
3D Game Engine Design, Second Edition: A Practical Approach to Real-Time Computer Graphics (The Morgan Kaufmann Series in Interactive 3D Technology)
Essential Mathematics for Games and Interactive Applications: A Programmer's Guide (The Morgan Kaufmann Series in Interactive 3d Technology) (The Morgan Kaufmann Series in Interactive 3d Technology)
Game Physics (Interactive 3d Technology Series)
Real-Time Rendering (2nd Edition)

ASIN: 012229064X

Book Description

Dave Eberly's 3D Game Engine Design was the first professional guide to the essential concepts and algorithms of real-time 3D engines and quickly became a classic of game development. Dave's new book 3D Game Engine Architecture continues the tradition with a comprehensive look at the software engineering and programming of 3D engines. This book is a complete guide to the engineering process, starting with a walk-through of the graphics pipeline showing how to construct the core elements of 3D systems, including data structures, the math system, and the object system. Dave explains how to manage data with scene graphs, how to build rendering and camera systems, and how to handle level of detail, terrain, and animation. Advanced rendering effects such as vertex and pixel shaders are also covered as well as collision detection and physics systems. The book concludes with a discussion of application design, development tools, and coding standards for the source code of the new version of the Wild Magic engine included on the CD-ROM. Wild Magic is a commercial-quality game engine used by many companies and is a unique resource for the game development community.

*CD-ROM with the complete C++ source code for Wild Magic version 3, a commercial-quality game engine for Windows, Linux, and OS X.
*A comprehensive, practical guide to all the steps necessary to build professional-quality real-time simulations with just minimal mathematics required.
*Emphasizes the application of software engineering principles and describes the architecture of large libraries.

Customer Reviews:

Good software engineering book.......2006-01-03

Well, needless to say, Eberly rocks. This is a great book on game engine architecture - even though it's less mathematically intensive than Eberly's other books (which, for many, is a good thing), it has a very good coverage of software engineering aspects of game engines, as it explains in detail how (and why) the WildMagic engine is organized. Do keep in mnid, though, that the book's purpose is not teacing how to develop games or algorithms for that - it's a software engineering book, and a good one at that.

Acceptable book with some significant failings.......2005-11-09

This is an acceptable introductory book for the architecture of an AAA-quality game engine, under the consideration that it has so little competition.

The most significant criticism I have of the book is its repeated digression of topics into a documentation of the Wild Magic engine. If you intend to use the Wild Magic engine, I highly recommend the book, but for anyone not using it, this book saves far too few pages for discussions of general engine architecture.

For example, the entire second chapter is basically a documentation of the basic types defined for the Wild Magic engine. If you are architecting a large scale project, you do not want to start the discussion with talk of a smart pointer class. Or an array class. Unfortunately, this is exactly how the book begins.

Throughout the book, the reader is constantly forced to shift through documentation for each Wild Magic class. While the author does use the engine to illustrate points, often the point is so heavily mixed with the documentation that it is tedious to pick out the general discussion.

My secondary criticism of the book is that too many words are used in specific (but uncommon) ways - making it hard to follow at times. The sad part is that the author acknowledges this for some words (which helps the reader) but fails to for others. An example of the latter is when the author concedes that he uses the word `animation' to mean any event that happens over a period of time. You will not find that definition in any dictionary, but at least he specifies his intent, which is slightly forgivable. What is not forgivable is the other phrases/words that are not acknowledged as being uncommonly used, such as `world bounds' and `local bounds'. Too often I found myself carefully following discussions not because I found the material difficult, but because I needed to extract the context for which the author is using a word or phrase. In this sense it makes it hard for anyone to simply use the book for reference purposes.

This book deserves three stars because it is a good (although sometimes short) treatment of the many subjects that are part of a 3D game engine. It loses one star for trying to combine two related, but what should be separate discussions - general engine architecture and documenting Wild Magic. It loses another for being overly verbose and dry (see my secondary criticism). It has so few competitors that you might just have to accept its failings and shift through the material to dig out the general architecture nuggets that are dispersed throughout the book.

3d Game Engine Architecture.......2005-06-03

The title says everything, this book treats most aspects concerning game engine design architecture and programming. Although not focusing in the next generation graphics architectures and shaders, it does provide an excellent basis for core engine and underlying graphics architecture design. General programming topics such as memory layout and shared object references are also discussed. A great book for begginers and a nice reading for professionals.

Best documentation for a software architecture ever written?.......2005-04-26

I don't know if this book the best documentation of a software architecture ever written, but its gotta rate up there. Probably its only rivals would be some of the foundational papers about the design of UNIX.

Why are there so few good contenders? Well, the genre of documentation for software architecture is a demanding one, because you need to master of so many skills in order to do it right. What makes it even harder is that the codebase is always changing in response to bugfixes and enhancements, which puts the documentation in continual jeopardy of drifting away from the codebase it describes.

Yes, this volume is a bit more plodding than Eberly's usual effortless writing style, but remember, he's documenting a software architecture, which is an inherently plodding task. Its ploddinghood is therefore a feature, not a bug. Moreover, he is never gratuitously plodding.

f you want to be a great documentor of software architectures, then pay close attention to the techniques Eberly uses here. Notice how, by casting the documentation in a tutorial form, he simultaniously makes it (1) a much more interesting read, and (2) makes it a dual-use document, invaluable both to newbies getting up to speed and to old pro's wanting to refresh their memory.

Budding game engine developers will find this book invaluable, but they are not the only ones who would benefit from reading it. This book could be profitably used in a general software architecture class, as an example of how to really document a software architecture.

In addition, a game engine's architecture is a superset of many other software architectures. For example, someone who is building a large-scale CAD system, or an EDA package, or an event-driven simulation package, or a physics simulation package, would also save themselves from many unanticipated "gotchas" by giving this book a close read.

Finally!.......2005-04-17

One of the criticisms I had of Dave Eberly's previous 3D Game Engine Design is that it didn't really say much about how to design an engine. Rather, it focused mostly on the programming/implementation details, which was disappointing to some. This new book is what many people expected from the older book.

In this book, the author walks through the design and architecture of a 3D game engine, using his Wild Magic engine as an example, but also drawing on his experience developing NDL's NetImmerse. Throughout, he describes why each design decision was made, and in many cases alternative solutions are discussed as well. This isn't just a high level discussion, however, as ample source code, figures, equations, and sample applications are included to get you started with implementation.

The topics covered include the core engine systems, scene graphs, renderers, cameras, LOD, animation, terrain, special effects, physics and collision detection. Numerous sample applications and tools are also included. Dave's writing style is clear and minimally conversational, and he's kept the math to a minimum, making this a remarkably easy read.

This isn't a complete treatment of a game engine, since some important topics (e.g. scripting, audio) aren't included, but the material it does cover is worth it. Whether you're currently working on a game engine, planning to start one, or just want to have a better understanding of how they work, you'll be happy with this book.

Average customer rating:

Only for frsh graduates.
Good book for novice embedded programmers
Excellent book for people new to Embedded Systems
Helped make the transition from "programming" to "embedded programming"
Good introduction in embedded systems

An Embedded Software Primer
David E. Simon
Manufacturer: Addison-Wesley Professional
ProductGroup: Book
Binding: Paperback

General | Programming | Computers & Internet | Subjects | Books

General | Software | Computers & Internet | Subjects | Books

General | Operating Systems | Computers & Internet | Subjects | Books

Look Inside Computer Books | Trip | Specialty Stores | Books

Qualifying Textbooks - Spring 2007 | Stores | Books

General | Software Books | Custom Stores | Stores | Software
Similar Items:

Embedded Systems Design: An Introduction to Processes, Tools and Techniques
Embedded Systems Architecture: A Comprehensive Guide for Engineers and Programmers (Embedded Technology)
Programming Embedded Systems in C and C ++
Real-Time Concepts for Embedded Systems
MicroC OS II: The Real Time Kernel (With CD-ROM)

ASIN: 020161569X

Book Description

An Embedded Software Primer is a clearly written, insightful manual for engineers interested in writing embedded-system software. The example-driven approach puts you on a fast track to understanding embedded-system programming and applying what you learn to your projects. This book will give you the necessary foundation to work confidently in this field.

Building on your basic knowledge of computer programming concepts, this book is right for you will help you to:

* Learn core principles and advanced techniques of embedded-system software.
* Find out what a real-time operating system (RTOS) does and how to use one effectively.
* Experiment with sample code and the (C/OS RTOS version 1.11 (on the accompanying CD).
* Apply what you learn, no matter which microprocessor or RTOS you use.

After reading this book, you will be able to tackle the challenges of embedded system programming and quickly reap the benefits of your new skills.

Customer Reviews:

Only for frsh graduates........2006-08-02

I am in embedded world for 8 good years and brought this book to know something which I dont know. This book is purely for fresh graduates out college.(that too only when they havnt worked hard in their courses) also if you have been in industry but didnt get chance to work on actual system then this can be of little help for you.

Dont buy it if you have already spent a couple of years on actual systems. You wont benefit much.

Good book for novice embedded programmers.......2006-06-17

This is my current recommended title for newcomers to embedded programming. It is thorough enough to keep as a reference for a while.

BUT:

1) It should be updated to discuss use of C++ and update other topics.
2) Don't ever use the horrible hungarian notation even if you are Hungarian!

Excellent book for people new to Embedded Systems.......2006-03-03

I am just begining my studies of embedded systems, and this book has be invaluable. Very readable, and structured in a reasonable way. The only thing lacking from this book is a chapter on networked embedded systems. This is a "primer", however, and one can't expect to many advanced topics in such a book. Other than that small gripe, this book is excellent and I highly recomend it for someone begining their studies of embedded systems.

Helped make the transition from "programming" to "embedded programming".......2006-02-01

This book is a great way to get used to the idea of embedded systems programming. It doesn't actually have the code in there, but it is called a primer. It definitely primes you for thinking like an embedded programmer. Good chapters on hardware and the basics. Nice lists of things to watch out for. I think it was the perfect first book to read before making an attempt to enter the embedded systems world.

Good introduction in embedded systems.......2004-09-15

This book is a GREAT introductory book into the embedded world. Even if you are an experienced embedded engineer, you'll find this book useful to remember basic concepts you might have forgotten with time, but maybe you'll find it TOO BASIC for you.

Programming Embedded Systems: With C and GNU Development Tools, 2nd Edition

Average customer rating:

Great Introduction to Embedded Systems Programming.
A classroom and lending collection standard.
Great guide to developing embedded systems

Programming Embedded Systems: With C and GNU Development Tools, 2nd Edition
Michael Barr , and Anthony Massa
Manufacturer: O'Reilly Media, Inc.
ProductGroup: Book
Binding: Paperback

General | Hardware | Computers & Internet | Subjects | Books

General | Programming | Computers & Internet | Subjects | Books

Systems Analysis & Design | Computer Science | Computers & Internet | Subjects | Books

General | Computer Science | Computers & Internet | Subjects | Books

General | Computers & Internet | Subjects | Books

General | Software | Computers & Internet | Subjects | Books

C & C++ | Programming | O'Reilly | By Publisher | Books

General | Programming | O'Reilly | By Publisher | Books

Look Inside Computer Books | Trip | Specialty Stores | Books

Qualifying Textbooks - Spring 2007 | Stores | Books

General | Software Books | Custom Stores | Stores | Software
Similar Items:

Designing Embedded Hardware
Embedded Linux Primer: A Practical Real-World Approach (Prentice Hall Open Source Software Development Series)
Embedded Systems Architecture: A Comprehensive Guide for Engineers and Programmers (Embedded Technology)
An Embedded Software Primer
Embedded Linux System Design and Development

ASIN: 0596009836
Release Date: 2006-10-01

Book Description

If you have programming experience and a familiarity with C--the dominant language in embedded systems--Programming Embedded Systems, Second Edition is exactly what you need to get started with embedded software. This software is ubiquitous, hidden away inside our watches, DVD players, mobile phones, anti-lock brakes, and even a few toasters. The military uses embedded software to guide missiles, detect enemy aircraft, and pilot UAVs. Communication satellites, deep-space probes, and many medical instruments would have been nearly impossible to create without embedded software.

The first edition of Programming Embedded Systems taught the subject to tens of thousands of people around the world and is now considered the bible of embedded programming. This second edition has been updated to cover all the latest hardware designs and development methodologies.

The techniques and code examples presented here are directly applicable to real-world embedded software projects of all sorts. Examples use the free GNU software programming tools, the eCos and Linux operating systems, and a low-cost hardware platform specially developed for this book. If you obtain these tools along with Programming Embedded Systems, Second Edition, you'll have a full environment for exploring embedded systems in depth. But even if you work with different hardware and software, the principles covered in this book apply.

Whether you are new to embedded systems or have done embedded work before, you'll benefit from the topics in this book, which include:

How building and loading programs differ from desktop or server computers
Basic debugging techniques--a critical skill when working with minimally endowed embedded systems
Handling different types of memory
Interrupts, and the monitoring and control of on-chip and external peripherals
Determining whether you have real-time requirements, and whether your operating system and application can meet those requirements
Task synchronization with real-time operating systems and embedded Linux
Optimizing embedded software for size, speed, and power consumption
Working examples for eCos and embedded Linux

So whether you're writing your first embedded program, designing the latest generation of hand-held whatchamacalits, or managing the people who do, this book is for you. Programming Embedded Systems will help you develop the knowledge and skills you need to achieve proficiency with embedded software.

Praise for the first edition:

"This lively and readable book is the perfect introduction for those venturing into embedded systems software development for the first time. It provides in one place all the important topics necessary to orient programmers to the embedded development process.
--Lindsey Vereen, Editor-in-Chief, Embedded Systems Programming

Customer Reviews:

Great Introduction to Embedded Systems Programming........2006-12-17

This book gives an excellent overview of programming embedded systems. It provides numerous examples of real-world hands-on embedded programming. I'd recommend that you have experience in C. Experience with operating systems concepts (such as interrupt service routines) would also be helpful.

Unlike usual programming books, you won't be able to pick up the book, download something, and start working. You'll need to have an embedded system that you can use. The authors use a system from Arcom that will run you about $300. I've not used it and was very wary about it when I first started reading, but as I read through the various examples I gained a great appreciation for the system. It looks like a great way to gain hands-on experience with embedded programming.

Before getting this book I read through the Lego Mindstorm NXT documentation and felt very lost. I didn't understand the symbols on the schematics and they used strange acronyms (like I2C and PWM). I also have an Iguanaworks USB infrared transceiver. I bought it to use in a MythTV system I am building. This book has enabled me to understand the schematics of both the Mindstorm and the transceiver as well as the documentation of both systems. I now feel ready to do my own embedded systems programming.

That said, I did not like everything in this book. They gloss over areas that I felt would have helped me (such as how to use a JTAG adapter and how to create an interrupt service routine under Linux). There are areas where the writing does not flow well and is redundant. The book switched from using an embedded x86 processor in the first edition to using an ARM processor in the second and there are still references to the old processor.

Even with its faults I am glad I got this book. It filled in many of the gaps that I have as a software engineer who is wanting to learn about embedded systems programming. I feel a whole new world has just been opened up to me and I can't wait to jump in.

A classroom and lending collection standard........2006-12-11

Programming Embedded Systems with C and GNU Development Tools appears in its second updated edition to include even more real-world and Linux examples, and is a recommended pick for programmers with a familiarity with C. It's been used as a college textbook and covers everything from basic debugging skills to determining the applications and needs of real-time projects. In updating details and clarifying routines, the 2nd edition of Programming Embedded Systems should be considered both a classroom and lending collection standard.

Diane C. Donovan
California Bookwatch

Great guide to developing embedded systems.......2006-11-08

This book is the much needed update to the book on embedded systems also published by O'Reilly. This book assumes that the reader already has some programming experience and is at least familiar with the syntax of the C language. 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.

The book contains 14 chapters and 5 appendixes. The chapters can be divided into two parts. The first part consists of Chapters 1 through 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 Chapters 6 through 14 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 through 12 contain example programs that might be useful to you on a future embedded software project.

Throughout the book, the authors strike a balance between specific examples and general information. Minor details have been eliminated making the book more readable, at least in my opinion. You will gain the most from the book if you view the examples primarily 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 C programming concepts, you should be able to apply them to any embedded system you encounter. To focus the book's example code on specific concepts, these examples have been left intentionally incomplete. For example, certain include files and redundant variable declarations are omitted. For complete details about the code, you can refer to the full example source code on the book's web site. I discuss this book further in the context of its table of contents:

Chapter 1, Introduction - Explains the field of embedded programming and lays out the parameters of the book, including the reference hardware used for examples.

Chapter 2, Getting to Know the Hardware - Shows how to explore the documentation for your hardware and represent the components you need to interact with in C.

Chapter 3, Your First Embedded Program - Creates a simple blinking light application that illustrates basic principles of embedded programming.

Chapter 4, Compiling, Linking, and Locating - Goes over the ways that embedded systems differ from conventional computer systems during program building steps, covering such issues as cross-compilers.

Chapter 5, Downloading and Debugging - Introduces the tools you'll need in order to iron out problems in both hardware and software.

Chapter 6, Memory - Describes the different types of memory that developers choose for embedded systems and the issues involved in using each type.

Chapter 7, Peripherals - Introduces the notion of a device driver, along with other coding techniques for working with devices.

Chapter 8, Interrupts - Covers this central area of working with peripherals.

Chapter 9, Putting It All Together - Combines the concepts and code from the previous chapter with convenience functions and a main program, to create a loadable, testable application.

Chapter 10, Operating Systems - Introduces common operating system concepts, including tasks and synchronization mechanisms, along with the reasons for adding a real-time operating system.

Chapter 11, eCos Examples - Shows how to use some features of the eCos real-time operating system.

Chapter 12, Embedded Linux Examples - Accomplishes the same task as the previous chapter, but for the embedded Linux operating system.

Chapter 13, Extending Functionality - Describes options for adding buses, networking, and other communication features to a system.

Chapter 14, Optimization Techniques - Describes ways to decrease code size, reduce memory use, and conserve power.

Appendix A, The Arcom VIPER-Lite Development Kit - Describes the board used for the examples in this book and how to order one for yourself.

Appendix B, Setting Up Your Software Development Environment - Gives instructions for loading the software described in this book on your host Windows or Linux computer.

Appendix C, Building the GNU Software Tools - Shows you how to compile the GNU development tools

Appendix D, Setting Up the eCos Development Environment - Shows you how to build an eCos library appropriate for your embedded system so you can compile programs to run on your system.

Appendix E, Setting Up the Embedded Linux Development Environment - Describes how to install the embedded Linux tools for your Arcom system and build and run a program on it.

Real-Time Design Patterns: Robust Scalable Architecture for Real-Time Systems

Average customer rating:

Not just for real-time
Dedication
A Useful Book
Great Book - Belongs on everyone's reference shelf
Disappointing book

Real-Time Design Patterns: Robust Scalable Architecture for Real-Time Systems
Bruce Powel Douglass
Manufacturer: Addison-Wesley Professional
ProductGroup: Book
Binding: Paperback

General | Programming | Computers & Internet | Subjects | Books

General | Computers & Internet | Subjects | Books

General | Operating Systems | Computers & Internet | Subjects | Books

General | Software | Computers & Internet | Subjects | Books

Look Inside Computer Books | Trip | Specialty Stores | Books

Qualifying Textbooks - Spring 2007 | Stores | Books

General | Software Books | Custom Stores | Stores | Software
Similar Items:

Real Time UML: Advances in the UML for Real-Time Systems (3rd Edition) (The Addison-Wesley Object Technology Series)
Doing Hard Time: Developing Real-Time Systems with UML, Objects, Frameworks and Patterns
Real Time UML Workshop for Embedded Systems (Embedded Technology)
Design Patterns: Elements of Reusable Object-Oriented Software (Addison-Wesley Professional Computing Series)
Practical Statecharts in C/C++: Quantum Programming for Embedded Systems with CDROM

ASIN: 0201699567

Customer Reviews:

Not just for real-time.......2004-10-21

Douglass' book does present a number of patterns useful in embedded, hardware-rich, and resource-constrained environments. More than that, though, he gives background material and discussion that work in OS and application environments, too.

Chapters 4 to 9 lays out a number of patterns that work well in embedded environments. Patterns for any one aspect of the system (memory, safety/reliability, etc.) are grouped into chapters, allowing easy understanding of the relationships between patterns that differ only subtly. Ch.7, especially, covers a number of related patterns that address to dealock avoidance - good stuff, but a bit more comparison between patterns and discussion of how to select between them would have helped. The discussion on deadlock in general is good too, but a standard OS textbook might cover aspects of deadlock in more detail.

Ch.6, on memory, will be a revelation to people who just use malloc() and free() without thinking. There are lots more ways of handling memory. His discussions of different patterns are good but there's always more to say. Memory pools, for example, may have many different meanings: different memory regions (cache vs. main memory) may have different performance features, or (as in DOS or Windows before about Win95) implications for the instruction sets required for memory access. Harvard and multi-bus architectures may use memory pools to reflect different memory accessibility rules. The "fixed-size buffer" pattern is another great one. I've seen it implemented in hardware, for on-chip buffers in network controllers, and in operating systems where objects of a specific data type are reused frequently. (This can overlap with the pool pattern, when there are different pools for buffers of different fixed sizes.)

Ch.3 talks about patterns in general, and the discussion ranges widely. It includes a fairly good discussion of using multiple patterns in one application, but stops short of the tricky cases where one object participates in two different patterns.

On the whole, this is a very useful book. It does presuppose some background in system (as opposed to software) design. That means it's not for the raw beginner, but it doesn't pretend to be. Some of the discussions of low-level system design suffer from shallowness, and some embedded topics are simply never discussed. Memory structures for block-erasable FLASH, for example, may resemble those used in writable CD-ROMs. Every book has bounds, though, and Douglass has done a good job within the bounds he chose.

//wiredweird

Dedication.......2003-07-28

Software engineer
Good at what you do
Avoid Haiku like the plague

A Useful Book.......2003-03-07

This book covers design patterns that address common problems in real time systems (memory leeks, resouce sharing, ISRs ...). As the name implies it does so at an Architecture rather than code level. The book seems to be best targeted toward medium or large systems in that some of the patterns (such as those dealing with distribution) might not apply to simple 8-bit micro system. It may be a difficult read for someone with limited real time development experience in that it covers complex real time problems in a variety of areas.

Great Book - Belongs on everyone's reference shelf.......2002-11-28

I *strongly* disagree with the other reviewer here. This book IS, of course, a collection of real-time architecture patterns (see the author's other books for tutorial info on these topics), and it is the *ONLY* such collection of design patterns for real-time systems. There is a lot of tutorial and reference material out there on these topics but nothing that serves as a pattern reference for the topics that we real-timers care so much about - safety and reliability architectures, concurrency patterns, resource and memory management, distributed architectures, and so on. Each pattern is provided with useful example of its application as well as the pros and cons of each. Where else can you even find a pattern-oriented discussion of the pros and cons of using priority ceiling versus simultaneous locking versus ordered locking for the protection of resources? And there are patterns discussed here that I haven't seen elsewhere. I feel that I now *finally* really understand the issues of software architecture for real-time systems and have a place to find solutions to my problems on my upcoming project. This book is fantastic for the more-than-beginner and belongs on everyone's reference shelf. Highly recommended!

Disappointing book.......2002-11-22

The title of this book promises insights how to build architecture for embedded real-time systems. Of course the book lists lots of patterns and follows the way such patterns are usually described (Problem, Structure, Consequences). Unfortunately this list is not new at all and the descriptions are not going into a level of detail to really help in practice. E.g. in Concurrency Patterns beside others the round robin pattern and static priority pattern are described. Later under Resource Patterns the priority ceiling pattern is presented. I would recommend reading the book from Burns and Wellings or one about RMA to learn how to build real-time systems. Such books present real-time systems in a much more structured way and present the common problems and solutions in more detail. Patterns are important, but just listing patterns to fill a book is not enough.

Real-Time Programming: A Guide to 32-bit Embedded Development

Average customer rating:

Appropriately titled
Good Book, Wrong Title
More like a huge advert for proprietary software
Not much about real-time programming

Real-Time Programming: A Guide to 32-bit Embedded Development
Rick Grehan , Robert Moote , and Ingo Cyliax
Manufacturer: Addison-Wesley Professional
ProductGroup: Book
Binding: Paperback

General | Programming | Computers & Internet | Subjects | Books

Systems Analysis & Design | Computer Science | Computers & Internet | Subjects | Books

General | Computers & Internet | Subjects | Books

Look Inside Computer Books | Trip | Specialty Stores | Books

An Embedded Software Primer
USB Complete: Everything You Need to Develop Custom USB Peripherals (Complete Guides series)

ASIN: 0201485400

Amazon.com

Real-time embedded systems (microprocessors that work in real-time) are all around us--in our cars, microwaves, and video games. Real-Time Programming: A Guide to 32-Bit Embedded Development uses the 32-bit Intel x86 platform to show that it's possible to learn the essence of writing embedded systems without a degree in engineering.

The authors first explain what embedded systems are and the strict constraints that developers face when creating embedded software. (Obviously, the failure of an embedded system for a medical or security device will have disastrous consequences.) Next, they introduce a little analysis and design, since questions on hardware and performance requirements are particularly important for embedded systems. The authors use the Phar Lap Realtime ETS ToolSuite Lite as their platform of choice (included on the CD-ROM), along with Microsoft Visual C++. A simple Point of Sale (POS) simulation is the first example, giving the authors a chance to explore keyboard, screen, and file input/output (I/O). Another example, an uninterruptible power supply (UPS), is used to illustrate the thornier topics in real-time programming, such as interrupt handling, timers, threads, and multithreading.

Next, the book shows you how to get embedded systems to communicate, including material on RS-232 serial communications (and UARTs). As the UPS sample gets more enhanced, it becomes network enabled with support for sending and receiving data using IP and HTTP.

The book rounds off with an introduction to Java for embedded systems and other specialized topics (such as floating-point processing) and advice for deploying software in ROM. By avoiding a lot of theory and stressing practical examples, Real-Time Programming puts embedded development into the hands of everyday C++ programmers. --Richard Dragan

Customer Reviews:

Appropriately titled.......2001-02-16

Description of reviewer: Computer Science (BS Hons). Commercial software engineering experience of 1.5 years. Experience with x86 assembler, VGA graphics subsystem, C/C++, Win32/MFC, WDM, and Java. Completely new to embedded systems.

Reviewer's goals: Looking to learn basic theories on what makes a good real-time operating system (RTOS). Ideally, I wanted to gain a good background for determining whether WinCE 3.0 is a viable RTOS, and when it should/could be used.

Did I achieve my goal? No. Only chapters 1 and 2 provided any theory chunks, and even then it was more common sense than an epiphany. My fault for assuming that I would abstract tested theory from an instructional handbook. I still learned a few nibbles about what a good RTOS needs to have though.

Do I recommend this book to others? Yes - but match your expectations with what it delivers. While I did not achieve my goal of understanding RTOS requirements, the book does provide a nice guide to how one would build a real-time embedded system from components. Provides good insights into the types of questions one needs to ask when building such a system. The methodology is not philosophical and steers clear from that rancor and leaves the reader to balance their intellect, creativity, and intuition for achieving their needs and wants in a real-time system.

Consider this book to be appropriately titled. It's a guide. It's not a definitive guide. It doesn't tell you, "do this for this application"... Indeed, I don't recommend this book if you need to create some kind of commercial embedded system. This book is for learning and toying around.

Now, if you intend to do anything with Phar Lap's ETS kernel, this book is a great beginner's resource for you.

The usefulness is a bit limited because the lessons that really apply outside of the ETS kernel are really theoretically based. Theory is extremely useful, but RTS theory may be a bit much for a beginner since there's a lot of "bla bla bla, my idea is better" - just visit comp.realtime if you have any doubts.

As an instructional manual, this book does a good job at being agnostic about RTS philosophies and evades a lot of "this is the best thingy" type claims. As a result it does well instructing on basics (versus indoctrinating), but you'll need more if you want to do anything really useful.

Were this book to have delved more into a couple of strong RTS theories and why there are so many arguments in different areas, I would have rated it a 5. This would have allowed the book to have use beyond the novice stage of embedded development.

Were this book to have used focused on an open RTOS, like embedded linux, (which consequently means there's a lot of additional wealth provided from geeks on the net), I would have given this a 4.

Alas, this book gets a 3. It's nowhere near being as bad as a 2. It's a solid 3 because it's usefulness is limited but it gets the job done in teaching basics.

Good Book, Wrong Title.......2000-10-17

What this book is: An introduction to developing for single-board computer (SBC) platforms (Intel x86), including interesting topics like connecting to pushbuttons and LCD displays. I personally found the book very interesting, as it's focused on x86-based embedded systems, rather than traditional embedded processors.

What this book is not: It's not about real-time programming - it's about SBC programming and the nuances of embedded systems. Coverage of true real-time techniques is very cursory, as mentioned here in another review about scheduling (likewise for subjects like de-bouncing of inputs and watchdog circuitry).

On the positive side, there is a progressive collection of examples that implement each of the principles presented. The code is included on the CD, along with a demo development library to build the examples. By including the demo library, the reader can get kick-started, even if they ultimately switch to another kernel.

On the negative side, the entire book is a heavily product-specific discussion around the PharLap RTOS kernel included on the CD (which is a crippled license for prototyping only). All the examples are dependent upon the reader using the PharLap kernel and a Windows-based machine with Microsoft's Visual C++ compiler.

In short: All in all, I found this book was a worthy addition to my library, and a great introduction to some of the issues and techniques that are unique to programming embedded PCs.

I'm glad I bought it, but I would have been happier if it had included coverage of other kernels (like embedded Linux), and an intro to some of the alternatives to x86-based CPUs. I was also disappointed that PharLap disabled Borland C++ support in the demo license - the logic for this escapes me.

More like a huge advert for proprietary software.......1999-05-23

I applaud the goal as stated in the book's title, and we very much need such a book. For me, this isn't it. I felt that their synopsis claims were not entirely honest: not only is this book based entirely on a proprietary operating system, but the learning version included with the book has been hamstrung to protect the full version. This makes sense, but their chosen method was to prevent you from being able to save your programming to disk or ROM; in other words, so that it can't be embedded. Seems difficult at best to learn embedded programming with software that can't be embedded. And the retail version of the tools on which this book is based cost a fortune. I suppose you could filter for more generally applicable information, but for me it just wasn't worth it. If you were going to pony up the dough for their OS, it would definitely be useful, but in that case they should give it to you as a manual!

Not much about real-time programming.......1999-01-30

For a book that claims to be about real-time programming, this book fails miserably. An example, the discussion of scheduling describes a round-robin scheduler and says "[f]or other scheduling algorithms, refer to any good book on operating systems."

I really expected more from Addison-Wesley.

Oh, ok... and here I thought scheduling had something to do with real-time systems, guess I was wrong.

A general overview of development and design, a couple details-free chapters on hardware, a few brief words about operating systems (in about the same depth as schedulers), then networking, HTTP and Java. The common thread that runs throgh all of these is their proprietary system which they refrain from disclosing any of the details of, but do provide you with some nice UPS simulators and software that runs only under windows.

Ada 2005 Reference Manual. Language and Standard Libraries: International Standard ISO/IEC 8652/1995(E) with Technical Corrigendum 1 and Amendment 1 (Lecture Notes in Computer Science)

Average customer rating:

Ada 2005 Reference Manual. Language and Standard Libraries: International Standard ISO/IEC 8652/1995(E) with Technical Corrigendum 1 and Amendment 1 (Lecture Notes in Computer Science)

Manufacturer: Springer
ProductGroup: Book
Binding: Paperback

General | Programming | Computers & Internet | Subjects | Books

General | Computers & Internet | Subjects | Books

General | Reference | Subjects | Books

Look Inside Computer Books | Trip | Specialty Stores | Books

Look Inside Reference Books | Trip | Specialty Stores | Books

Programming in Ada 2005 with CD (International Computer Science)

ASIN: 3540693351

Book Description

The Ada 2005 Reference Manual combines the International Standard ISO/IEC 8652/1995(E) for the programming language Ada with the corrections of the Technical Corrigendum 1 approved by ISO in February 2001 and with the Amendment 1 expected to be approved by ISO in late 2006 or early 2007. Both the Technical Corrigendum 1 and the Amendment 1 list only the changes made to the International Standard.

The Ada 2005 Reference Manual incorporates these changes in the overall standard text and thus will replace the former versions as an indispensable working companion for anybody using Ada professionally or learning and studying the language systematically. In naming this version, we have chosen the vernacular term Ada 2005 used by the Ada community to refer to the interesting extensions made to the language Ada by the Amendment 1.

DSP Software Development Techniques for Embedded and Real-Time Systems (Embedded Technology)

Average customer rating:

Too vague and general to be helpful

DSP Software Development Techniques for Embedded and Real-Time Systems (Embedded Technology)
Robert Oshana
Manufacturer: Newnes
ProductGroup: Book
Binding: Paperback

General | Computer Science | Computers & Internet | Subjects | Books

General | Science | Subjects | Books

Look Inside Computer Books | Trip | Specialty Stores | Books

Look Inside Science Books | Trip | Specialty Stores | Books

All Amazon Upgrade | Amazon Upgrade | Stores | Books

Computers & Internet | Amazon Upgrade | Stores | Books

Engineering | Amazon Upgrade | Stores | Books

Professional & Technical | Amazon Upgrade | Stores | Books

Science | Amazon Upgrade | Stores | Books

Qualifying Textbooks - Spring 2007 | Stores | Books

The DSP Handbook: Algorithms, Applications and Design Techniques
An Embedded Software Primer
Rapid System Prototyping with FPGAs: Accelerating the Design Process (Embedded Technology)
Applied Control Theory for Embedded Systems (Embedded Technology)
Real-Time Digital Signal Processing from Matlab to C with the TMS320C6x DSK

ASIN: 0750677597
Release Date: 2005-09-29

Book Description

Today's embedded and real-time systems contain a mix of processor types: off-the-shelf microcontrollers, digital signal processors (DSPs), and custom processors. The decreasing cost of DSPs has made these sophisticated chips very attractive for a number of embedded and real-time applications, including automotive, telecommunications, medical imaging, and many othersincluding even some games and home appliances. However, developing embedded and real-time DSP applications is a complex task influenced by many parameters and issues.

This introduction to DSP software development for embedded and real-time developers shows how to use digital signal processors efficiently in embedded and real-time systems. It covers software and firmware design principles, from processor architectures and basic theory to the selection of appropriate languages and basic algorithms. The reader will find practical guidelines, diagrammed techniques, tool descriptions, and code templates for developing and optimizing DSP software and firmware. The book also covers integrating and testing DSP systems as well as managing the DSP development effort. The accompanying CDROM contains the code from the design examples as well as design tools and product demos.

*Digital signal processors (DSPs) are the future of microchips!

*Includes practical guidelines, diagrammed techniques, tool descriptions, and code templates to aid in the development and optimization of DSP software and firmware

*Accompanying CD-ROM contains code from the design examples used in the book, so developers can easily use it in their own designs

Customer Reviews:

Too vague and general to be helpful.......2007-01-17

This book is tremendously vague. It is fairly thick, but in all its pages it never really manages to tell you anything you probably didn't already know. Everything is at such a high level it is more like a broad overview of the subject. It is practically devoid of any mathematical details of DSP. Given its title, that is probably not what the reader was bargaining for. There are better books on DSP, better books on embedded systems, and better books on real-time systems. What about better books that integrate all three subjects? I can't think of any, but that would include this book too. If you want an introduction to DSP and interfacing it to a microprocessor try "Digital Signal Processing and the Microcontroller". It talks about the basics of DSP, uses a little math but not calculus, and demonstrates how to build a DSP system using a M68HC16 16-bit microcontroller. Code examples are included. You'll then be ready for more mathematical treatments of DSP in other books. In summary, don't waste your money on this one.

Programming in the OSEK/VDX Environment (With CD-ROM)

Average customer rating:

Programming in the OSEK/VDX Environment (With CD-ROM)
Joseph Lemieux
Manufacturer: CMP Books
ProductGroup: Book
Binding: Paperback

Distributed Databases | Databases | Computers & Internet | Subjects | Books

General | Hardware | Computers & Internet | Subjects | Books

General | Programming | Computers & Internet | Subjects | Books

Systems Analysis & Design | Computer Science | Computers & Internet | Subjects | Books

General | Computers & Internet | Subjects | Books

General | Operating Systems | Computers & Internet | Subjects | Books

General | Software | Computers & Internet | Subjects | Books

Look Inside Computer Books | Trip | Specialty Stores | Books

General | Software Books | Custom Stores | Stores | Software
Similar Items:

Real-Time Concepts for Embedded Systems

ASIN: 1578200814

Book Description

Achieve efficiencies in programming your embedded communications and control systems by using the OSEK/VDX open standard. Developed by the automotive industry to increase productivity through the use of a standard architectural system and re-useable code,

Use the OSEK/VDX open standard to program embedded computer control systems. Each of the three OSEK/VDX standards are presented independently so you can refer to the sections pertinent to your project. Features an example application that demonstrates all aspects of the standard without focusing on its automotive origins.

Average customer rating:

A Note from the Author
Real lack of effort in publishing
Major printing errors
An excellent book for ameatures on both eCos and RTOS
Embedded Software Development using an OS

Embedded Software Development with eCos
Anthony J. Massa , and Anthony Massa
Manufacturer: Prentice Hall PTR
ProductGroup: Book
Binding: Paperback

General | Programming | Computers & Internet | Subjects | Books

General | Software | Computers & Internet | Subjects | Books

Look Inside Computer Books | Trip | Specialty Stores | Books

Qualifying Textbooks - Spring 2007 | Stores | Books

General | Software Books | Custom Stores | Stores | Software
Similar Items:

Building Embedded Linux Systems
Embedded System Design on a Shoestring (Embedded Technology)
Programming Embedded Systems: With C and GNU Development Tools, 2nd Edition
ARM Architecture Reference Manual (2nd Edition)
Embedded Linux System Design and Development

ASIN: 0130354732

Customer Reviews:

A Note from the Author.......2005-09-20

I am happy to report that the printing problems have finally been resolved. I have reviewed the latest copies of the book and the text seems fine.

Sorry about this.

Thanks,
Anthony Massa

======
======
I apologize for the lack of effort on the part of the publisher. Please know that I have nothing to do with the publishing process at this point. I have been begging Prentice Hall to fix these errors and have forwarded on the comments I have received from readers. It seems these comments are falling on deaf ears. Please contact Prentice Hall directly if you receive a book that contains printing errors.

I hope the content in the book is still valuable to all eCos developers.

Thanks,
Anthony

Real lack of effort in publishing.......2005-04-29

To follow up on the printing. The copy I got was very, very bad. Pretty much every page has multiple printing errors making the book very difficult to read and in some places you need to understand the content already to make headway.

The book used to ship with a CD. Now there's a sheet saying to go look at phptr.com for a download. I could not find the CD download, but I did find the book in pdf. At least the pdf can be read.

Bad job Prentice Hall!

Major printing errors.......2005-04-16

Be aware. The current printing of this book has some serious typesetting problems. Nearly every page has "garbled" text where letters overlap. The publisher responded by stating: "The book which you are referring is now temporary unavailable due to major printing errors."

An excellent book for ameatures on both eCos and RTOS.......2004-11-11

I recommend this book not only to those who are just beginning to use eCos but also ameatures in the world of RTOS. The audience is treated like a 'child' as Anthony goes on to explain step by step. The accompanying software is complete and gets perfectly installed as described.
There are good illustrations accompanying the text that help in understanding the text. It is written more like a story rather than a manual, so it is difficult to put it down once you start reading it.

Embedded Software Development using an OS.......2004-02-15

This book gives a step by step method of getting an embedded system up and running using ecos OS. Explains very well in simple terminology "how to put various components together to create what you need". In short, a very good book on ecos in nutshell.

Books:

Books