A Practical Look at Embedded Systems by Rajkamal
I picked up the second edition of Embedded Systems by Rajkamal when I was trying to fill gaps in my understanding of microcontroller architecture and embedded C programming. The book is dense but straightforward. It covers 8051, ARM, and PIC architectures with enough depth to actually be useful on the job, not just for passing exams. The full title is Embedded Systems: Architecture, Programming and Design, second edition, published by Tata McGraw-Hill. It was originally written for Indian engineering curricula, which means the pacing is a bit different from Western textbooks like Patterson & Hennessy. That said, the technical content holds up well. Chapters on 8051 memory mapping, interrupt handling, and serial communication are some of the clearest I have found. One thing beginners miss: the book assumes you already know basic digital logic and have touched assembly language before. If you jump straight into the ARM chapters without having worked through the 8051 material, you will struggle. The author builds complexity slowly across the first half of the book. Skipping ahead breaks the thread.
What the Book Actually Covers
It is split into three parts. The first part deals with the 8051 microcontroller — architecture, instruction set, memory organization, timers, interrupts, and serial communication. The second part moves to ARM Cortex-M processors, covering GPIO programming, interrupt controllers, and peripheral interfaces. The third part touches on PIC and gives practical embedded C programming guidance. The embedded C section is where this book earns its keep. Most textbooks treat C as an afterthought. Rajkamal integrates it throughout. You see register-level C code alongside assembly, which is exactly how you will write firmware in the real world.
Where I Hit a Wall and How I Got Past It
When I was working through the 8051 interrupt programming chapter, I kept getting stuck on how the interrupt vector addresses map to actual hardware. The book lists the addresses — 0003H for INT0, 000BH for TF0, and so on — but does not explain why those specific addresses exist or how they relate to the interrupt service routine chaining problem. In practice this matters because if you do not understand the vector table layout, your code will silently jump to the wrong handler and you will waste hours debugging. My workaround was to write a small test program that deliberately misaligned the interrupt vectors and observed the crash behavior on an actual 8051 dev board. Flashing incorrect vector addresses made the MCU jump to reset instead of the ISR, which immediately made the concept click. I then cross-referenced the datasheet for the AT89S52 to see how the manufacturer defined the same vector table. Reading both the textbook explanation and the raw datasheet together closed the gap.
Get the Full Details
Common Pitfalls When Using This Book
The biggest issue is the code examples. They are written for older compilers and some syntax patterns are outdated. The book uses keil C51 style conventions that differ slightly from modern toolchains. If you copy the examples directly into a newer IDE like STM32CubeIDE or platformIO, you will hit compilation errors around header file includes and register naming. I spent about an hour just tracking down why several register definitions did not match what the compiler expected. The fix was straightforward — replace the legacy header references with the current vendor-provided headers for your specific MCU. This is not a flaw in the book itself, it is just a product of when it was published. Another issue: the ARM section is thinner than the 8051 section. If you are primarily interested in ARM-based development, you will need supplementary material. The book covers the basics adequately but does not go deep into topics like cache architecture, MPU configuration, or RTOS integration on Cortex-M. For those, you should pair it with something like Andrew N. Sloss's ARM System Developer's Guide.
How to Use This Book Effectively
Do not read it cover to cover in one sitting. The material is technical and cumulative. Work through one chapter, write the accompanying code, and flash it to hardware before moving on. Even a cheap 8051 development board or an STM32 blue pill will let you validate most of the examples. Sitting and reading passiveely without hands-on verification leaves you with fragile understanding that disappears under interview pressure or real project work. The exercises at the end of each chapter are worth doing. They are not trivial. Some of them simulate actual embedded debugging scenarios rather than pure theory questions.
Verdict
This is a solid reference for anyone serious about embedded systems, especially if you are coming from an academic background and need a structured path from 8051 to ARM. It is not the most engaging read. The prose is utilitarian. But the technical accuracy is dependable and the progression from architecture to programming to design is logical. I keep it on my desk because it fills gaps that other books leave open. For a download link, I am not going to provide a direct source since I cannot verify the legality of any file hosted online. The second edition is available through Amazon, Flipkart, and the TMH website. Used copies are often significantly cheaper and perfectly adequate since the core content has not changed meaningfully between print runs.
