Book Image

Embedded Programming with Modern C++ Cookbook

By : Igor Viarheichyk

Book Image

Embedded Programming with Modern C++ Cookbook

By: Igor Viarheichyk

Overview of this book

Developing applications for embedded systems may seem like a daunting task as developers face challenges related to limited memory, high power consumption, and maintaining real-time responses. This book is a collection of practical examples to explain how to develop applications for embedded boards and overcome the challenges that you may encounter while developing. The book will start with an introduction to embedded systems and how to set up the development environment. By teaching you to build your first embedded application, the book will help you progress from the basics to more complex concepts, such as debugging, logging, and profiling. Moving ahead, you will learn how to use specialized memory and custom allocators. From here, you will delve into recipes that will teach you how to work with the C++ memory model, atomic variables, and synchronization. The book will then take you through recipes on inter-process communication, data serialization, and timers. Finally, you will cover topics such as error handling and guidelines for real-time systems and safety-critical systems. By the end of this book, you will have become proficient in building robust and secure embedded applications with C++.

Preface

Who this book is for

What this book covers

To get the most out of this book

Fundamentals of Embedded Systems

Fundamentals of Embedded Systems

Exploring embedded systems

Working with limited resources

Looking at performance implications

Working with different architectures

Working with hardware errors

Using C++ for embedded development

Deploying software remotely

Running software remotely

Logging and diagnostics

Free Chapter

Setting Up the Environment

Setting Up the Environment

Setting up the build system in a Docker container

Working with emulators

Cross-compilation

Connecting to the embedded system

Debugging embedded applications

Using gdbserver for remote debugging

Using CMake as a build system

Working with Different Architectures

Working with Different Architectures

Exploring fixed-width integer types

Working with the size_t type

Detecting the endianness of the platform

Converting the endianness

Working with data alignment

Working with packed structures

Aligning data with cache lines

Handling Interrupts

Handling Interrupts

Interrupt service routines

General considerations for ISRs

8051 microcontroller interrupts

Implementing an interrupt service routine

Generating a 5 kHz square signal using 8-bit auto-reload mode

Using Timer 1 as an event counter to count a 1 Hz pulse

Receiving and transmitting data serially

Debugging, Logging, and Profiling

Debugging, Logging, and Profiling

Technical requirements

Running your applications in the GDB

Working with breakpoints

Working with core dumps

Using gdbserver for debugging

Adding debug logging

Working with debug and release builds

Memory Management

Memory Management

Using dynamic memory allocation

Exploring object pools

Using ring buffers

Using shared memory

Using specialized memory

Multithreading and Synchronization

Multithreading and Synchronization

Exploring thread support in C++

Exploring data synchronization

Using condition variables

Using atomic variables

Using the C++ memory model

Exploring lock-free synchronization

Using atomic variables in shared memory

Exploring async functions and futures

Communication and Serialization

Communication and Serialization

Using inter-process communication in applications

Exploring the mechanisms of inter-process communication

Learning about message queue and publisher-subscriber models

Using C++ lambdas for callbacks

Exploring data serialization

Using the FlatBuffers library

Peripherals

Controlling devices connected via GPIO

Exploring pulse-width modulation

Using ioctl to access a real-time clock in Linux

Using libgpiod to control GPIO pins

Controlling I2C peripheral devices

Reducing Power Consumption

Reducing Power Consumption

Technical requirements

Exploring power-saving modes in Linux

Waking up using RTC

Controlling the autosuspend of USB devices

Configuring CPU frequency

Using events for waiting

Profiling power consumption with PowerTOP

Time Points and Intervals

Time Points and Intervals

Exploring the C++ Chrono library

Measuring time intervals

Working with delays

Using the monotonic clock

Using POSIX timestamps

Error Handling and Fault Tolerance

Error Handling and Fault Tolerance

Working with error codes

Using exceptions for error handling

Using constant references when catching exceptions

Tackling static objects

Working with watchdogs

Exploring heartbeats for highly available systems

Implementing software debouncing logic

Guidelines for Real-Time Systems

Guidelines for Real-Time Systems

Using real-time schedulers in Linux

Using statically allocated memory

Avoiding exceptions for error handling

Exploring real-time operating systems

Guidelines for Safety-Critical Systems

Guidelines for Safety-Critical Systems

Using the return values of all functions

Using static code analyzers

Using preconditions and postconditions

Exploring the formal validation of code correctness

Microcontroller Programming

Microcontroller Programming

Setting up the development environment

Compiling and uploading a program

Debugging microcontroller code

Other Books You May Enjoy

Other Books You May Enjoy

Leave a review - let other readers know what you think

Customer Reviews

5 star

0

4 star

0

3 star

0

2 star

0

1 star

0

Detecting the endianness of the platform

Endianness defines the order in which bytes that represent large numerical values are stored in memory.

There are two types of endianness:

Big-endian: The most significant byte is stored first. A 32-bit value, 0x01020304, is stored at the ptr address, as follows:

Offset in memory (byte) Value

ptr 0x01

ptr + 1 0x02

ptr + 2 ox03

ptr + 3 0x04

Examples of big-endian architectures include AVR32 and Motorola 68000.

Little-endian: The least significant byte is stored first. A 32-bit value, 0x01020304, is stored at the ptr address, as follows:

Offset in memory (byte) Value

ptr 0x04

ptr + 1 0x03

ptr + 2 0x02

ptr + 3 0x01

The x86 architecture is little-endian.

Taking care of endianness is especially essential when exchanging data with other systems. If a developer sends a 32...