Linux for embedded and real-time applications / Doug Abbott.

Format:

Book

Author/Creator:

Abbott, Doug, author.

Language:

English

Subjects (All):

Linux.

Operating systems (Computers).

Embedded computer systems--Programming.

Embedded computer systems.

Physical Description:

1 online resource (1 volume) : illustrations

Edition:

Fourth edition.

Place of Publication:

Oxford, England ; Cambridge, Massachusetts : Newness, 2018.

System Details:

text file

Summary:

Linux for Embedded and Real-Time Applications, Fourth Edition, provides a practical introduction to the basics, covering the latest developments in this rapidly evolving technology. Ideal for those new to the use of Linux in an embedded environment, the book takes a hands-on approach that covers key concepts of building applications in a cross-development environment. Hands-on exercises focus on the popular open source BeagleBone Black board. New content includes graphical programming with QT as well as expanded and updated material on projects such as Eclipse, BusyBox – configuring and building, the U-Boot bootloader – what it is, how it works, configuring and building, and new coverage of the Root file system and the latest updates on the Linux kernel.. Provides a hands-on introduction for engineers and software developers who need to get up to speed quickly on embedded Linux, its operation and capabilities Covers the popular open source target boards, the BeagleBone and BeagleBone Black Includes new and updated material that focuses on BusyBox, U-Boot bootloader and graphical programming with QT

Contents:

Front Cover

Linux for Embedded and Real-time Applications

Copyright Page

Dedication

Contents

Preface

Audience and Prerequisites

What's New in this Edition

Personal Biases

Organization

I. Introduction

1 The embedded and real-time space

What is Embedded?

What is Real-Time?

How and Why Does Linux Fit in?

Open Source

Portable and Scalable

Where is Linux Embedded?

Open Source Licensing

Legal Issues

Alternatives to Linux

FreeRTOS

MicroC/OS

Resources

2 Installing linux

Distributions

Linux Mint

Debian GNU/Linux

Ubuntu

Red Hat Enterprise Linux

Fedora

CentOS

SUSE

Hardware Requirements

Installation Scenarios

Stand-Alone

Dual-Booting

Virtualization

Installing VirtualBox

DVD or Live CD?

Installation Process

3 Introducing linux

Running Linux-KDE

File Manager

Shell Window

Linux Features

Protected Mode Architecture

Real Mode

Protected Mode

"Flat" Versus Segmented Memory Models

Paging

64-Bit Paging

The Linux Process Model

The Fork() Function

The Execve() Function

The Linux File System

File Permissions

The "Root" User

The /Proc File System

The Filesystem Hierarchy Standard

The /usr hierarchy

"Mounting" File Systems

System Configuration

The Shell

Getting Help

4 The host development environment

Cross-Development Tools: the GNU Tool Chain

Gnu Compiler Collection

Make

Gnu DeBugger

Getting and Installing the Software

Install Cross-Tool Chain

The Terminal Emulator, minicom

Networking

Network Address

What About Wireless?

Network File System

Trivial File Transfer Protocol

5 Eclipse integrated development environment

Overview

Plug-ins

Workbench

Installation

Using Eclipse.

The C Development Environment (CDT)

Creating a New Project

Adding Source Code to the Project

Content Assist

Code Templates

Automatic Closing

The Program

Building the Project

Debugging With CDT

The Debug View

Variables View

Breakpoints View

Memory View

Finish Debugging

Additional Plug-ins

Summary

6 The hardware

The ARM Architecture

Open Source Hardware

BeagleBoard

Specifications (Rev. C4)

BeagleBoard-xM

BeagleBone

BeagleBone Black

Gumstix

Additional specifications

Raspberry Pi

Specifications

Setting up the BeagleBone Black

Flash Memory and File Systems

BeagleBone Black Memory Configuration

Preparing the Board

Caveat

The Boot Process

Differences Between Version 7.4 and Version 8.7

The Root File System Image

Boot to the NFS File System

What Can Go Wrong?

II. Application programming in a cross-development environment

7 Accessing hardware

Review

ARM I/O Architecture

LEDs

Accessing I/O From Linux: Our First Program

Creating a Project

The Target Execution Environment

The led Program

The Makefile

A Data Acquisition Example

Set Up the Hardware

Accessing the Analog Subsystem

8 Debugging embedded software

Remote Debugging With Eclipse

Remote Debug Launch Configuration

A Thermostat

Host Workstation as Debug Environment

Advanced Breakpoint Features

Debugger Services Framework

Configuring Remote System Explorer

Debugging With Remote System Explorer

9 Posix threads

Threads

Thread Attributes

Synchronization: Mutexes

Mutex Attributes

Problems With Solving the Resource Sharing Problem: Priority Inversion

Communication: Condition Variables

Condition Variable Attributes

Thread Termination and Cancellation.

Cleanup Handlers

Pthreads Implementations

Upgrading the Thermostat

Changes Required in Thermostat.c

Debugging Multithreaded Programs

10 Embedded networking

Sockets

The Server Process

The Client Process

Socket Attributes

A Simple Example

The Server

The Client

Try it Out

A Remote Thermostat

Multiple Monitor Threads

Embedded Web Servers

Background on HTTP

A Web-Enabled Thermostat

Dynamic Web Content

Forms and the POST Method

Build and Try it

"Real" Web Servers

Apache

Lighttpd

Node.js

11 Graphics programming with QT

Getting and Installing QT

QT Basics

Signals and Slots

QT Designer

Putting QT on the ARM

Build the Target Libraries

Create Build Environment for Target Applications

A Graphical Thermostat

III. Components and tools

12 Configuring and building the Linux kernel

Getting Started

Where's the Source Code? Upstream versus Downstream Kernels

Kernel Version Numbering

Additional Tools

Getting and Installing the BeagleBone Kernel

Patching the Kernel

The Kernel Source Tree

Kernel Makefile

Configuring the Kernel: make config, menuconfig, xconfig

Xconfig Options

.config File

A Problem

Building the Kernel

Workstation Digression

Booting the New Kernel

Behind the Scenes: What's Really Happening

13 Integrated build environments

The Problem

Buildroot

Open Embedded

OE Metadata

Testing the New Image: Quick EMUlator

Personal Observations

Yocto Project

Application Development with Yocto: The Software Development Kit and Eclipse

14 BusyBox and Linux initialization

Introducing BusyBox

Configuring and Installing BusyBox

BusyBox Settings

Applets.

Building and Installing

Using BusyBox

User Space Initialization

Stage 1 Boot Loader

Stage 2 MLO

U-Boot

Linux Kernel

Systemd

User Space Initialization, the "Old Way"

15 U-boot boot loader and getting ready to ship

Background

Installing and Configuring U-Boot

Testing a New U-Boot

The "Sandbox"

Device Trees

Putting the Application in eMMC Flash

16 Source code control - GIT

Introducing git

File states and life cycle

Branching and merging

Configuring git

Graphical git

Creating a new repository

17 Linux and real-time

Hard versus Soft Real-Time

Why Linux is Not Real-Time

Measuring Latency: Cyclictest

Improving Linux Latency

Two Approaches

Preemption Improvement

Interrupt Abstraction

A Third Way: Xenomai

Working With PREEMPT_RT

Wrap Up

Appendix A: U-boot Commands

Information Commands

Memory Commands

NAND Flash Memory Commands

Execution Control Commands

Download Commands

Environment Variable Commands

Environment Variables

Appendix B: Why Software Should Not Have Owners

Index

Back Cover.

Notes:

Includes index.

Includes bibliographical references at the end of each chapters and index.

Description based on online resource; title from PDF title page (EBC, viewed December 11, 2017).

ISBN:

9780128112779

0128112778

OCLC:

1017738662