Hands-On Embedded Programming with C++17电子书

Title Page

Copyright and Credits

Hands-On Embedded Programming with C++17

About Packt

Why subscribe?

Packt.com

Contributors

About the author

About the reviewers

Packt is searching for authors like you

Preface

Who this book is for

What this book covers

To get the most out of this book

Download the example code files

Conventions used

Get in touch

Reviews

Section 1: The Fundamentals - Embedded programming and the role of C++

What Are Embedded Systems?

The many faces of embedded systems

Microcontrollers

TMS 1000

Intel MCS-48

Intel MCS-51

PIC

AVR

M68k and Z80-based

ARM Cortex-M

H8 (SuperH)

ESP8266/ESP32

Others

Challenges

System-on-Chip/Single Board Computer

Challenges

Summary

C++ as an Embedded Language

C++ relative to C

C++ as an embedded language

C++ language features

Namespaces

Strongly typed

Type conversions

Classes

Inheritance

Virtual base classes

Function inlining

Runtime type information

Exception handling

Templates

The standard template library

Maintainability

Summary

Developing for Embedded Linux and Similar Systems

Embedded operating systems

Real-time OSes

Custom peripherals and drivers

Adding an RTC

Custom drivers

Resource limitations

Example – club room monitoring

Hardware

Relays

Debounce

Debounce HAT

Power

Implementation

Listener

Club

HTTP request handler

Status handler

Data handler

Service configuration

Permissions

Final results

Example – basic media player

Summary

Resource-Restricted Embedded Systems

The big picture for small systems

Example – Machine controller for a laser cutter

Functional specification

The design requirements

Implementation-related choices

Embedded IDEs and frameworks

Programming MCUs

Memory programming and device debugging

Boot loader

Memory management

Stack and heap

Interrupts, ESP8266 IRAM_ATTR

Concurrency

AVR development with Nodate

Enter Nodate

Example – CMOS IC Tester

Usage

ESP8266 development with Sming

ARM MCU development

RTOS usage

Summary

Example - Soil Humidity Monitor with Wi-Fi

Keeping plants happy

Our solution

The hardware

The firmware

Setting up Sming

Plant module code

Makefile-user.mk

Main

OtaCore

BaseModule

PlantModule

Index.html

Compiling and flashing

First-time configuration

Using the system

Taking it further

Complications

Summary

Section 2: Testing, Monitoring

Testing OS-Based Applications

Avoiding real hardware

Cross-compiling for SBCs

Integration test for club status service

Mock versus hardware

Testing with Valgrind

Multi-target build system

Remote testing on real hardware

Summary

Testing Resource-Restricted Platforms

Reducing wear

Planning out a design

Platform-independent build systems

Using cross-compilers

Local and on-chip debugging

Example – ESP8266 integration test

The server

Makefile

The node

Makefile

Building the project

Summary

Example - Linux-Based Infotainment System

One box that does everything

Hardware needed

Software requirements

Bluetooth audio sources and sinks

Online streaming

Voice-driven user interface

Usage scenarios

Source code

Building the project

Extending the system

Summary

Example - Building Monitoring and Control

Plants, rooms, and beyond

Developmental history

Functional modules

Firmware source

Core

Modules

CO2 module

Jura

JuraTerm

Motion

PWM

I/O

Switch

Command and control server

Administration tool

Air-conditioning service

InfluxDB for recording sensor readings

Security aspects

Future developments

Summary

Section 3: Integration with other tools and frameworks

Developing Embedded Systems with Qt

The power of the right framework

Qt for command-line use

GUI-based Qt applications

Embedded Qt

Custom GUIs with stylesheets

QML

3D designer

An example of adding a GUI to the infotainment system

Main

QmlInterface

QML

Summary

Developing for Hybrid SoC/FPGA Systems

Going extremely parallel

Hardware description languages

FPGA architecture

Hybrid FPGA/SoC chips

Example – basic oscilloscope

The hardware

The VHDL code

The C++ code

Building the project

Summary

Best Practices

All the best-laid plans

Working with the hardware

The confusing world of peripherals

Knowing your tools

Choosing asynchronous methods

Reading the datasheet

Keeping interrupt handlers short

8-bit means 8 bits

Don't reinvent the wheel

Think before you optimize

Requirements are not optional

Documentation saves lives

Testing code means trying to destroy it

Summary

Other Books You May Enjoy

Leave a review - let other readers know what you think