Embedded systems architecture : explore architectural concepts, pragmatic design patterns, and best practices to produce robust system / Daniele Lacamera.

Format:

Book

Author/Creator:

Lacamera, Daniele, author.

Language:

English

Subjects (All):

Embedded computer systems.

Physical Description:

1 online resource (317 pages)

Edition:

1st ed.

Place of Publication:

Birmingham ; Mumbai : Packt, 2018.

Biography/History:

Lacamera Daniele: Daniele Lacamera is a software technologist and researcher with vast experience in software design and development on embedded systems for different industries, currently working as freelance software developer and trainer. He is a worldwide expert in TCP/IP and transport protocol design and optimization, with more than 20 academic publications on the topic. He supports free software by contributing to several projects, including the Linux kernel, and his involvement within a number of communities and organizations that promote the use of free and open source software in the IoT.

Summary:

Embedded systems are self-contained units that have a dedicated purpose within a device. We come across a variety of applications of embedded systems in navigation tools, telecom applications, and networking equipment, to name just a few. This book will help you create your own parallel and distributed embedded systems.

Contents:

Cover

Title Page

Copyright and Credits

Packt Upsell

Contributors

Table of Contents

Preface

Chapter 1: Embedded Systems - A Pragmatic Approach

Domain definition

Embedded Linux systems

Low-end 8-bit microcontrollers

Hardware architecture

Understanding the challenge

Multithreading

RAM

Flash memory

Interfaces and peripherals

Asynchronous UART-based serial communication

SPI

I2C

USB

Connected systems

The reference platform

ARM reference design

The Cortex-M microprocessor

Summary

Chapter 2: Work Environment and Workflow Optimization

Workflow overview

C compiler

Linker

Build automation

Debugger

Embedded workflow

The GCC toolchain

The cross-compiler

Compiling the compiler

Linking the executable

Binary format conversion

Interacting with the target

The GDB session

Validation

Functional tests

Hardware tools

Testing off-target

Emulators

Chapter 3: Architectural Patterns

Configuration management

Revision control

Tracking activities

Code reviews

Continuous integration

Source code organization

Hardware abstraction

Middleware

Application code

The life cycle of an embedded project

Defining project steps

Prototyping

Refactoring

API and documentation

Chapter 4: The Boot-Up Procedure

The interrupt vector table

Startup code

Reset handler

Allocating the stack

Fault handlers

Memory layout

Building and running the boot code

The makefile

Running the application

Multiple boot stages

Bootloader

Building the image

Debugging a multi-stage system

Shared libraries

Chapter 5: Memory Management

Memory mapping

Memory model and address space

The code region

The RAM regions

Peripheral-access regions.

The system region

Order of memory transactions

The execution stack

Stack placement

Stack overflows

Stack painting

Heap management

Custom implementation

Using newlib

Limiting the heap

Multiple memory pools

Common heap usage errors

The memory protection unit

MPU configuration registers

Programming the MPU

Chapter 6: General-Purpose Peripherals

The interrupt controller

Peripherals interrupt configuration

System time

Adjusting the flash wait states

Clock configuration

Clock distribution

Enabling the SysTick

Generic timers

General-purpose I/O

Pin configuration

Digital output

PWM

Digital input

Interrupt-based input

Analog input

The watchdog

Chapter 7: Local Bus Interfaces

Introducing serial communication

Clock and symbol synchronization

Bus wiring

Programming the peripherals

UART-based asynchronous serial bus

Protocol description

Programming the controller

Hello world!

Newlib printf

Receiving data

Interrupt-based input/output

SPI bus

Programming the transceiver

SPI transactions

Interrupt-based SPI transfers

I2C bus

Clock stretching

Multi-master

Interrupt handling

Chapter 8: Low-Power Optimizations

System configuration

Hardware design

Clock management

Voltage control

Low-power operating modes

Deep-sleep configuration

Stop mode

Standby mode

Wake-up intervals

Measuring power

Development boards

Designing low-power embedded applications

Replacing busy loops with sleep mode

Deep sleep during longer inactivity periods

Choosing the clock speed

Power state transitions

Chapter 9: Distributed Systems and IoT Architecture

Network interfaces.

Media Access Control

Ethernet

Wi-Fi

Low-Rate Wireless Personal Area Networks (LR-WPAN)

LR-WPAN industrial link-layer extensions

6LoWPAN

Bluetooth

Mobile networks

Low-power Wide Area Networks (LPWANs)

Selecting the appropriate network interfaces

The Internet Protocols

TCP/IP implementations

Network device drivers

Running the TCP/IP stack

Socket communication

Mesh networks and dynamic routing

Transport Layer Security

Securing socket communication

Application protocols

Message protocols

REST architectural pattern

Distributed systems - single points of failure

Chapter 10: Parallel Tasks and Scheduling

Task management

The task block

Context switch

Creating tasks

Scheduler implementation

Supervisor calls

Cooperative scheduler

Concurrency and timeslices

Blocking tasks

Waiting for resources

Real-time scheduling

Synchronization

Semaphore

Mutex

Priority inversion

System resource separation

Privilege levels

Memory segmentation

System calls

Chapter 11: Embedded Operating Systems

Real-time application platforms

FreeRTOS

ChibiOS

Low-power IoT systems

Contiki OS

Riot OS

POSIX-compliant systems

NuttX

Frosted

The future of safe embedded systems

Process isolation - Tock

Other Books You May Enjoy

Index.

Notes:

Description based on print version record.

ISBN:

9781788830287

1788830288

OCLC:

1039686589