Beningo J. Reusable Firmware Development. A Practical Approach to APIs, HALs and Drivers

New York: Apress, 2017. — 315 p.Since the turn of the twenty-first century, microcontroller-based systems have become extremely complex. Microcontrollers started out as simple 8-bit devices running at bus speeds in the 8 MHz to 48 MHz range. Since then, microcontrollers have become complex and powerful 32-bit devices running at clock speeds faster than 200 MHz with every imaginable peripheral, including USB, TCP/IP, and Wi-Fi, and some microcontrollers now even have an internal cache. This dramatic explosion of capability and complexity has left the embedded software developer scrambling to understand how to do the following:
Shorten time to market
Keep budgets under control
Get to market on time
Manage their system’s complexity
Meet the client’s feature and innovation needs
Traditionally, many embedded systems were written in such a way that the code was used once, on a single platform, and then tossed out. Software, for the most part, could be referred to as spaghetti code and did not follow any object-oriented or software-reuse model. In today’s development environment, developers need to write their software with reusability and portability in mind. The teams that are the most successful can leverage existing intellectual property and quickly innovate on it.
The purpose of this book is to help the embedded software engineer learn and understand how they can develop reusable firmware that can be used across multiple microcontroller platforms and software products. The fundamental pieces to firmware reuse that we will be focusing on are HALs, APIs, and drivers. These are the core pieces that will allow us to develop a layered software architecture and define how those different layers interact with each other.
Chapters 1 through 5 lay the foundation on which a developer can start writing reusable firmware. In these chapters, we examine the C constructs that best lend themselves to portability and define what a hardware abstraction layer (HAL) is and how it differs from application programming interfaces (APIs). We will discuss different design methodologies developers can use to write low-level drivers and examine the design patterns, along with their pros and cons. Along the way, we’ll look at realworld examples and even take a chapter to discuss how reusable firmware should be documented.
With the foundation laid, Chapters 6 through 10 examine the processes that can be followed to create HALs and APIs. We examine common elements, such as GPIO, SPI, and external memory devices, before moving on to looking at high-level application frameworks that can aid reuse and accelerate software design. Chapter 11 discusses how developers should develop tests to ensure that their reusable software remains usable with a minimal bug count. Finally, Chapter 12 walks developers through how they can start developing reusable software no matter the environment or challenges that they may be facing and how they can succeed in those environments.
The chapters don’t necessarily need to be read in order, but they are put together in an order that builds upon what came before. A developer with reasonable experience developing reusable software could easily skip around whereas developers new to writing reusable software should read the chapters in order.