Customer Reviews

C Programming for Microcontrollers Featuring ATMEL's AVR Butterfly and the free WinAVR Compiler

5 star:		(8)
4 star:		(1)
3 star:		(1)
2 star:		(4)
1 star:		(5)

 

 

I am writing this review from both the viewpoint as a student of electronics, and as a teacher of some 13 years experience.

Pros:

* Excellent value for money
* Excellent hardware available from author's website
* User-friendly style of writing
* Wide coverage of C - I am learning a lot
* CD ROM contains source code, data sheets, compiler, IDE and
terminal software, software for downloading code
* Friendly and responsive answers to questions via email
* Wide range of topics covered

Cons:

* Sloppy editing - many typos and some fundamental errors
* Weakness in communicating concepts
* Needs to explain longer/detailed code/program examples step-by-step to fully explain concepts and so students grasp program functionality and AVR architecture clearly and confidently
* Has been rushed

Mr. Pardue has written an enjoyable book. His writing style makes it easy to get through somewhat technical subject matter. There are a range of fun and practical examples to experiment with. However, more detailed examples could be broken down further and explained, which from a pedagogical perspective would be more effective for students to fully grasp and feel confident with the inner workings of programming.

If Mr. Pardue writes a sequel covering more advanced C programming and AVR microcontroller concepts, especially detailed assembly language programming and AVR architecture, and effectively explains detailed code examples and AVR architecture step-by-step I will definitely buy it.

Possible features of the next book could include hardware hacking of the AVR Butterfly to access more ports, building circuits that take advantage of ICSP, robotics such as SONAR, infra-red communication, sound sensing , using other communication protocols like I2C etc, interfacing with compass sensor, interfacing with speech recognition and text-to-speech sysnthesis, interfacing with GPS, how to write and run different software other than the built-in code of the Butterfly (customised operating system), internet/networking.

This a fun book that is great for people that want to get started in embedded programming and design. And at a low introductory affordable price.

This book, and the AVR Butterfly (~$20 at Digikey) are the best bargain you can get for getting started in Embedded programming and development. Together (the book, the AVR Butterfly and miscellaneous parts) form a complete development kit. AVR must be selling the kit for a loss to introduce their products. Buy it before they change their minds.

Although this is not a professional development kit, you will be able to do a lot. This is more like a cookbook to introduce you to the concepts and to enable to easily put a project together.

After reading through this and putting together the projects you will have the basics to understand more advanced books and enable you to design more advanced projects.

The one basic I thought the author left out that was important to include, was the C programming type qualifier "volatile". Volatile before a variable tells the compiler that a variable can have its value altered by agencies other than the program. For example you would use this when you are reading from a hardware address that is set by an interface. Otherwise the compiler may optimize the variable as a constant and not actually read the value from the hardware address on repeat iterations.

Code example: volatile int temp; Reads an 8 bit temperature code from a hadware address interfaced to a thermocouple.
So now you have it.

I found the book to be very readable, easy to understand and fun to read through.
As prerequisites for this I would recommend:

* Familiarity with the C programming language. For beginners:
I recommend the book "Practical C Programming". There are
many fine books to choose from.

* Knowledge of very basic circuits, and how to solder
wires.

* A very light knowledge of microprocessors. For
beginners: I recommend the book "Programming Embedded
Systems in C and C++", by Michael Barr. There are a few
other good beginner books to choose from.


For the beginner, this is a must have that will enable you to quickly get started and build introductory projects. If you are new to embedded programming and design I would highly recommend getting this book and the AVR butterfly.

The author bills the book as "...a low cost way to learn C programming for microcontrollers", for beginners. Low cost it is, but for beginners, it's likely not.

Pardue's book is about two things: hardware, and software.

For hardware, Pardue commendably picked Atmel's Butterfly. It's a truly amazing and compelling miniaturized machine, guaranteed to mesmerize and puzzle anyone with a desire to learn microcontrollers. For less than the cost of a dinner, one can have the Butterfly, and for a song, download the free software to program it. Pardue's book is also reasonable in cost.

What makes the Butterfly come alive is a program, a compiled C program. And the software side of Pardue's book is centered around the C language. Briefly, the author takes you through the process of learning C, writing programs, compiling them, loading them on the Butterfly, and executing them. While C is a relatively "low level" read "simple", language, it is still complex and difficult to understand for beginners.

What makes this book a bad choice for the newbie? Well, you can't teach C and microcontrollers in 269 pages, period. Basically, the author's scope for the book is simply too ambitious. But don't misunderstand: Learning C with the Butterfly is a really good idea, it's just not practical in so few pages.

For example, a good C book covers mostly C, unsurprisingly. For instance, Prata's very good "C Primer Plus", is over 700 fairly concise, but beginner friendly, pages. (Granted, Prata's book covers more C topics than Pardue's book, but the comparison is still valid and compelling.)

Contrast that to Pardue's short 269 page book, that attempts to cover appx 700 pages of C, and at the same time, covers microcontrollers. Not gonna happen.

Then there's Pardue's chapter six, which is a prime example of the problem. Until this chapter, most example programs are short, if not just fragments. And for the most part, they are easy to understand, because Pardue takes the time to explain the program verbosely. Chapter six, to the contrary, slams you in the face with nearly six pages of solid code. While it's commented inline, there is little "direct" text explanation to augment the comments. I was limping when I got through the first five chapters, but chapter six blew me away. I fully expect the majority of true newbies will be blown away also. The remainder of the book has long programs, similarly lacking in adequate explanation.

Other reviewers have mentioned the author's poor grammar and typography, so I will not harp on it here. The author also attempts to inject humor in this dry technical subject, and mostly he succeeds. The reader will have to decide if his humor is appealing though.

Pardue does some things well. He gives adequate attention to guiding the newbie through putting the semi-kit-like Butterfly together, and introducing the compiler and Atmel IDE tools. For those unfamiliar with breadboards, those images will also be helpful. Pardue is obviously a gifted engineer, programmer and teacher, and many sections of text illustrate it well.

If you insist on buying the book and the Butterfly, here is my best recipe for success:
1. Buy and read another book on C first. I found "C Primer Plus" to be outstanding.
2. After you have a handle on the elementary aspects of C, then buy Pardue's book and the Butterfly, then get the errata and pencil in the numerous changes.
3. You should expect to read each chapter at least twice, and the chapters that cover the Butterfly will likely require more readings.
4. Type the code in yourself, as opposed to copying it from another source. Add your own comments to his, to reinforce your understanding.
5. I am sure you will need to refer back to your C book, when Pardue's book covers something in typical whirlwind manner.

There is one major mitigating factor to the negatives listed above. Joe Pardue, or "Smiley" as he is called on the avrfreaks forum, is a prolific poster and easily approachable online. He has a long track record of answering questions, many of them about his book. Regardless of whether you buy his book and Butterfly kit, do yourself a favor and google avrfreaks and check out the forum. I found it indespensible in deciphering the mystery that Atmel is.

As a side note, become aquainted with the open source hardware initiative "Arduino". The key attraction here is most of the hardware complexity is shielded by excellent library functions. These functions do things like drive output, read input, PWM, timers and serial work. The downside to Arduino is you are just "holding hands" with the hardware. The Butterfly requires "intimate" contact.

Good luck.
Steve.

I think the first two reviewers are being a bit harsh. I have worked through the book and found that there were some annoying typos, but what book doesn't have them? The main thing I like is that the author has a funny and relaxed way of explaining things. Also this is a very cheap way to learn. The Butterfly is only $19.99 and the compiler is free. I was able to get some interesting programs running very quickly and I think I've got a good start on C programming. I might have given the book a 4, since there are some typos, but I've decided to give it a 5 to help balance the bad reviews.

I purchased this book and "Embedded C Programming and the Atmel AVR " by Barnett, since feedback went both ways. I must say this book appears rushed, has some crucial errors (especially for first timers), typos, poor layout in places, and a weak index. However, it does tie into the WinAVR compiler, and for those that need help there, the book is useful. All examples use the ATMEGA 169, as expected. Barnett's examples mostly use the 90S8515 (some ATMEGA 163), with the CodeVisionAVR compiler.

I can't speak for others in choosing or wanting to learn AVRs and/or C programming from this book, but i'll tell you my experience.

I bought this book to learn AVR hardware, and not the programming language as i learned the language from another book. I was open to strengthen my C language skills while learning the butterfly, but in terms of the language the book left me very frustrated and looking to my original source material to fill in/verify the gaps that were left out in this book.

So for one, his C programming explanations are vastly incomplete, presented almost delusionally, with respect to anyone who wants to learn the language with some confidence. The hardware explanations were equally bad and had I not searched the internet, i would've not understood anything that he attempted to explain. His explanations are fluffed with very little substance.

I've reached a basic understanding of the butterfly/avr hardware by reading the datasheet and reviewing Dean Camera's tutorials on AVRFREAKS.NET.

In conclusion, I think this book is deceiving for someone who really wants to understand C and AVR hardware. The programs worked and made sense to me (though very sloppy, almost careless) , only because i had a basic understanding of the C language + dean's tutorials.

I would not recommend. I've got a lot worse to say, but i'll contain myself.

I have a 2-year degree in computer science, and so I understand the basics of C, how electronics work, etc. While I'm able to wire-up interesting AVR projects from many online tutorials, I found most of the code in this book too confusing and poorly laid-out to be of any help.

What many other reviewers here say about the text is true: a little bit of basic C is covered at the beginning, and then all of a sudden you're hacking away at Atmel's own code. If I knew how to hack up code like that, I wouldn't need to learn about it!

It's possible to teach from others' code, but the author misses opportunities to help newbies as they transition into the "AVR-GCC community" -- ALL the deprecated functions and macros that are included in the Atmel code are kept, and you're given NO clue as to what the new "proper" functions are! So if you don't understand something in the book, and you check the current AVR-libc documentation, you're even more lost from the mismatch between the two.

It's difficult and confusing to complete even basic projects with the material you *should* have been able to learn with this book. I have read through it twice and I still don't understand much of the book. I'd also like to note that unless you have a butterfly setup EXACTLY as the author has it setup -- which means having a specific OLD, OUTDATED GCC compiler setup (good luck getting that if you bought the book used or in PDF) -- none of the examples work at all: they're too entangled in little shortcuts and hacks that only work for the specific setup.

I'd appreciate if, in the next edition, the author threw out a lot of the fancy tricks and hacks and instead focused on providing a solid foundation on things like interrupt handling, comprehensive bit manipulations, etc. If I can figure all this out by myself before the next edition, however, I certainly won't be buying this -- or any other -- title from this author.

While there are a few typos in the book, these do not impede learning and the text is otherwise well written. The author's humorous style eases the learning process and breaks up the boredom normally associated with education. Chapters are broken down correctly with several practical projects for the user to try, this helps reviewing the information presented.

The comments made by others that some topics are "Rushed" are unjust - I became quite confident with C after only two weeks and this book.

Definitely worth a look for those who wish to learn, but I wouldn't recommend it to those who do not possess a sense of humor.

I was very excited about this book after reading the first sample chapter. However, the rest of the book seems that it was rushed to press. The text contains many errors, important concepts are inadequately explained if at all, and many of the pages are simply code listings found on the CD. If I had not asked for the book as a gift, I would return it.

This is a hastily written book with exceptionally poor editing: the author appears to have relied on a spell checker in lieu of actually proofreading the final copy, and the later chapters provide war stories and unexplained hacks in place of careful guidance for learners like myself. In the body of the text, the errors (frequently 3, 4, or 5 per page) are merely annoying, but when the errors creep into the actual C program examples (e.g., logical "OR" when the author means logical "AND"; hexadecimal examples with misplaced digits; missing quotation marks and randomly changing variable names, etc.) they cause great, repeated frustration. To the author's credit, he engagingly and clearly explains basic concepts, and I was tempted to keep the book for its opening chapters, even despite the many errors. The book might also be handy for hobbyists who simply want to have some fun hacking an AVR Butterfly. But as a cost-effective, practical tool for learning C Programming on the AVR, it pales in comparison with Barnett's "Embedded C Programming and the Atmel AVR", even though the latter book costs ~$40 more and ignores the WinAVR compiler. If you have the money to spend, it might be worth keeping the Pardue book in your collection, so long as you have better texts to accompany it. But for my cash-strapped self, I've returned the Pardue, and have ordered Barnett's book in its stead (I've been using the local library's copy, and like it so much that I want my own).

All in all, it's a pity the Pardue book was written in such a rush. I'd love a worthy, readable, neophyte-friendly text on embedded C with the WinAVR compiler, and I had high hopes for this particular attempt. But the lack of editing, and the evident haste shown by the later chapters, pretty much killed it for me. Pity.