Author: Danielle Lacamera
Target Audience: Entry-level Engineers (0 – 3 Years’ Experience)
Jacob’s Rating: 5 Stars
Embedded Systems Architecture is an excellent book for entry-level engineers who are looking to gain a deeper understanding of microcontroller hardware. The book covers all the fundamentals that are often either quickly covered in college covers or skipped completely. For example, in Chapter 5 on memory management, the author starts at general level to describe the memory model for a microcontroller using the Arm Cortex-M as a reference. He examines the different memory regions, explains how they map into the linker file and then discusses in great detail the stack, heap and memory pools. At the very end of the chapter, memory protection units are even covered with example code on how to use them.
The book does a good job balancing the theory on how a microcontroller works with code examples on how to get things done. For example, in Chapter 4, The Boot-Up Procedure, each element of the boot process was discussed such as the .bss section initialization which was then followed by example code showing how the code in a real system looks. I particularly liked that the book showed an example how you can locate shared libraries that can be used by a bootloader and the application code in order to remove code duplication. This is something that I cover in my Bootloader Design Techniques for MCU’s course, but that I have not seen mentioned in any embedded systems literature that I recall reading.
Chapters 6 and 7 do a good job providing the reader with an overview and example code on how to work within microcontroller peripherals. There are several peripherals that are examined which include example code such as GPIO, SPI, UART and I2C. There is also some time spent on the watchdog timer which is a critical component in every embedded system and requires thoughtfulness to implement correctly. (You might want to check-out my watchdog paper here).
My favorite part of the book was Chapter 10, Parallel Tasks and Scheduling because it provides developers with a foundational understanding about how to schedule tasks in their system. The chapter covers how to write a task scheduler and goes beyond the simple, high-level treatment is often given to cooperative schedulers. The chapter demonstrates how to write a scheduler that treats each task, or thread, as its own semi-independent program and must make calls to yield the CPU. What’s interesting is the discussion about how to properly perform a context switch by saving and restoring the CPU registers for the tasks and maintain the states for various tasks. This chapter is important because it provides a developer with the foundational understanding necessary to write an RTOS or at least realize what is going on behind the scenes of a commercial or open source RTOS.
I would highly recommend that if you are new to embedded systems and are interested in learning more about low-level microcontroller hardware and software that you read this book. This is the most comprehensive book I’ve seen to date that covers microcontroller start-up, booting, memory and task management. If you are already an experienced developer, Chapter 10 will be the most interesting to you, but also may not be necessary unless you have a interest in scheduling algorithms and how scheduling works behind the scenes on an Arm Cortex-M processor.