Embedded Software

Author： Walls, Colin

Publishers： Elsevier Science

Publishing year： 2012

ISBN： 9780124159693

Subject： [TP 自动化技术、计算机技术]

Language： ENG

Introduction

As the embedded world expands, developers must have a strong grasp of many complex topics in order to make faster, more efficient and more powerful microprocessors to meet the public’s growing demand. Embedded Software: The Works covers all the key subjects embedded engineers need to understand in order to succeed, including Design and Development, Programming, Languages including C/C++, and UML, Real Time Operating Systems Considerations, Networking, and much more. New material on Linux, Android, and multi-core gives engineers the up-to-date practical know-how they need in order to succeed.

Colin Walls draws upon his experience and insights from working in the industry, and covers the complete cycle of embedded software development: its design, development, management, debugging procedures, licensing, and reuse. For those new to the field, or for experienced engineers looking to expand their skills, Walls provides the reader with detailed tips and techniques, and rigorous explanations of technologies.

Key features include:

  • New chapters on Linux, Android, and multi-core – the cutting edge of embedded software development!

  • Introductory roadmap guides readers through the book, providing a route through the separate chapters and showing how they are linked

About the Author

Colin Walls has over twenty-five years experience in the electronics industry, largely dedicated to embedded software. A frequent prese

Chapter

  • Front Cover

  • Embedded Software: The Works

  • Copyright Page

  • Dedication

  • Contents

  • Foreword

  • What Do You Expect—Perfection?

  • Preface to the First Edition

  • How This Book Came About

  • Where This Book Came From

  • What You Will Find Here

  • Who This Book Is For

  • How to Use This Book

  • Acknowledgments

  • Contributors

  • A Good Cause

  • Contact Me

  • Preface to the Second Edition

  • What’s on the Website?

  • Code Fragments

  • Training Materials

  • Roadmap to Embedded Software Development

  • Embedded Versus Desktop Software

  • Memory Size

  • CPU Power

  • Code Optimization

  • Operating System

  • Real-Time Behavior

  • Development Paradigm

  • Execution Paradigm

  • Every Embedded System Is Different

  • Embedded Software Tools and Components

  • Development Tools

  • Software Components

  • 1 Embedded Software

  • 1.1 What Makes an Embedded Application Tick?

  • 1.1.1 Development Challenges

  • Multiple Processors

  • Limited Memory

  • User Interface

  • 1.1.2 Reusable Software

  • Software Components

  • 1.1.3 Real-Time Operating System

  • RTOS Selection Factors

  • RTOS Standards

  • 1.1.4 File System

  • 1.1.5 USB

  • 1.1.6 Graphics

  • 1.1.7 Networking

  • IPv6

  • Who Needs a Web Server?

  • SNMP

  • 1.1.8 Conclusion

  • 1.2 Memory in Embedded Systems

  • 1.2.1 Memory

  • What Is Memory?

  • Memory in Embedded Systems

  • 1.2.2 Implementation Challenges

  • ROMable Code

  • Program Sections

  • Static Variables

  • 1.2.3 When All Goes Wrong

  • 1.2.4 When All Goes Right

  • 1.3 Memory Architectures

  • 1.3.1 The Options

  • 1.3.2 Flat Single-Space Memory

  • 1.3.3 Segmented Memory

  • 1.3.4 Bank-Switched Memory

  • 1.3.5 Multiple-Space Memory

  • 1.3.6 Virtual Memory

  • 1.3.7 Cache Memory

  • 1.3.8 Memory Management Units

  • 1.3.9 Conclusions

  • 1.4 How Software Influences Hardware Design

  • 1.4.1 Who Designs the Hardware?

  • 1.4.2 Software Leading Hardware

  • 1.4.3 Software/Hardware Trade-Offs

  • Processor Selection

  • Memory Size and Mix

  • Peripheral Implementation

  • 1.4.4 Debug Hardware

  • In-Circuit Emulators

  • Monitor Debuggers

  • JTAG Support

  • 1.4.5 Self-Test Support

  • I/O Circuits

  • On-Board Switches

  • Status Displays

  • 1.4.6 Conclusions

  • 1.5 Migrating Your Software to a New Processor Architecture

  • 1.5.1 Target Specifics

  • Code

  • Data and Variables

  • Data and Function Parameters

  • Data and Register Usage

  • Data and Endianness

  • Real-Time Concerns

  • 1.5.2 RTOS Issues

  • 1.5.3 Processor Migration and Open Standards

  • EABI—Introduction

  • EABI and Register Usage

  • EABI and Stack Frames

  • EABI and Data Types

  • EABI and File/Debug Formats

  • 1.5.4 Conclusions

  • 1.6 Embedded Software for Transportation Applications

  • 1.6.1 Introduction

  • 1.6.2 Transportation System Characteristics

  • 1.6.3 Programming Issues

  • 1.6.4 Real-Time Operating System Factors

  • RTOS Requirements

  • OSEK/VDX

  • 1.6.5 Conclusions

  • 1.7 How to Choose a CPU for Your System on Chip Design

  • 1.7.1 Design Complexity

  • 1.7.2 Design Reuse

  • 1.7.3 Memory Architecture and Protection

  • 1.7.4 CPU Performance

  • 1.7.5 Power Consumption

  • 1.7.6 Costs

  • 1.7.7 Software Issues

  • 1.7.8 Multicore SoCs

  • 1.7.9 Conclusions

  • 1.8 An Introduction to USB Software

  • 1.8.1 What Is USB?

  • 1.8.2 A USB Peripheral

  • 1.8.3 USB Communications

  • 1.8.4 USB Software

  • 1.8.5 USB and Embedded Systems

  • 1.8.6 Conclusions

  • 1.9 Toward USB 3.0

  • 1.9.1 Introduction

  • 1.9.2 Bus Architecture

  • 1.9.3 Cables and Connectors

  • 1.9.4 Packet Routing

  • 1.9.5 Bidirectional Protocol Flow

  • 1.9.6 Bulk Streaming

  • 1.9.7 USB 3.0 Power Management

  • 1.9.8 USB 3.0 Hubs

  • 1.9.9 xHCI—New Host Controller Interface

  • 1.9.10 Future Applications for USB

  • Storage

  • Multimedia

  • USB Device Authentication

  • 1.9.11 Conclusions

  • Further Reading

  • 2 Design and Development

  • 2.1 Emerging Technology for Embedded Systems Software Development

  • 2.1.1 Microprocessor Device Technology

  • 2.1.2 System Architecture

  • 2.1.3 Design Composition

  • 2.1.4 Software Content

  • 2.1.5 Programming Languages

  • 2.1.6 Software Team Size and Distribution

  • 2.1.7 UML and Modeling

  • 2.1.8 Key Technologies

  • 2.1.9 Conclusions

  • 2.2 Making Development Tool Choices

  • 2.2.1 The Development Tool Chain

  • 2.2.2 Compiler Features

  • 2.2.3 Extensions for Embedded Systems

  • Impact of Real-Time Systems

  • 2.2.4 Optimizations

  • 2.2.5 Build Tools: Key Issues Recapped

  • 2.2.6 Debugging

  • Debugger Features

  • Development Phases

  • Native Debugger

  • Debugger with Simulator

  • Debugger with Monitor

  • JTAG Debugger

  • Debugger with RTOS

  • 2.2.7 Debug Tools: Key Issues Recapped

  • 2.2.8 Standards and Development Tool Integration

  • 2.2.9 Implications of Selections

  • Target Chips

  • Host Computers

  • RTOS

  • 2.2.10 Conclusions

  • 2.3 Eclipse—Bringing Embedded Tools Together

  • 2.3.1 Introduction

  • 2.3.2 Eclipse Platform Philosophy

  • 2.3.3 Platform

  • 2.3.4 How Eclipse Gets Embedded

  • 2.3.5 Conclusions

  • 2.4 A Development System That Crosses RTOS Boundaries

  • 2.4.1 Are Standards the Solution?

  • 2.4.2 The Eclipse Solution

  • 2.4.3 Eclipse Plug-Ins

  • 2.4.4 Eclipse Licensing

  • 2.4.5 Eclipse User Advantages

  • Cell Phone Example

  • 2.4.6 Perspectives

  • 2.4.7 Nonembedded Plug-Ins

  • 2.5 Embedded Software and UML

  • 2.5.1 Why Model in UML?

  • 2.5.2 Separating Application from Architecture

  • Blueprint Development

  • What’s Wrong with That?

  • Model Compilers

  • Sets, States, and Functions

  • Rules

  • Open Translation

  • 2.5.3 xtUML Code Generation

  • 2.5.4 Conclusions

  • 2.6 User Interface Development

  • 2.6.1 User Interface Diversity

  • No UI

  • Buttons and Lights

  • Buttons and Simple Alphanumeric Displays

  • Buttons, Lights, and a Network

  • Buttons and Simple Graphical Displays

  • Buttons, Pointing Devices, and Simple Graphic Displays

  • Buttons and Full-Size, High-Resolution Displays

  • 2.6.2 Implementing a User Interface

  • Lights and Buttons

  • Network Interfaces

  • Menu and Information-Oriented UIs

  • 2.6.3 A Rationalized UI Solution

  • Designing an Interface

  • Support for 3D Rendering

  • Usage Models

  • 2.6.4 Conclusions

  • 2.7 Software and Power Consumption

  • 2.7.1 Introduction

  • State of the Art—Hardware Versus Software Effort

  • Why Power Matters

  • 2.7.2 Software Issues

  • Software Architecture

  • Power Issues

  • 2.7.3 Power Control in Software

  • Sleep/Suspend

  • Dynamic Voltage and Frequency Scaling

  • 2.7.4 Multicore

  • 2.7.5 Hardware Issues

  • Hardware Architecture

  • Factors That Affect Power Consumption

  • 2.7.6 Virtual Programming

  • 2.7.7 Conclusions

  • 3 Programming

  • 3.1 Programming for Exotic Memories

  • 3.1.1 Exotic Memories

  • 3.1.2 Nonvolatile RAM

  • 3.1.3 Shared Memory

  • 3.1.4 Conclusions

  • 3.2 Self-Testing in Embedded Systems

  • 3.2.1 Memory Testing

  • RAM—Start-up

  • RAM—Testing on the Fly

  • PROM—Checksum

  • Special Memory Types

  • 3.2.2 Input/Output Devices

  • 3.2.3 Multithreading Issues

  • RAM Testing Reentrancy

  • Stack Limits

  • 3.2.4 Watchdogs

  • 3.2.5 Self-Test Failures

  • 3.2.6 Final Points

  • 3.3 A Command-Line Interpreter

  • 3.3.1 Embedded Systems Diagnostics

  • 3.3.2 An Embedded System Comes Alive

  • 3.3.3 A Command-Line Interpreter—Requirements

  • 3.3.4 Designing a Command-Line Interpreter

  • 3.3.5 A CLI Implementation

  • 3.3.6 CLI Prototype Code

  • 3.3.7 Conclusions

  • 3.4 Traffic Lights: An Embedded Software Application

  • 3.4.1 The Application

  • 3.4.2 Hardware Configuration

  • 3.4.3 Program Implementation

  • 3.4.4 Main Loop

  • 3.4.5 Interrupts

  • 3.4.6 Time Delays

  • 3.4.7 Lights

  • 3.4.8 Using Global Variables

  • 4 C Language

  • 4.1 C Common

  • 4.2 Using C Function Prototypes

  • 4.2.1 Before Prototypes

  • 4.2.2 Applying Prototypes

  • 4.2.3 Prototypes in Use

  • 4.3 Interrupt Functions and ANSI Keywords

  • 4.3.1 Interrupt Functions

  • 4.3.2 ANSI C const Keyword

  • 4.3.3 ANSI C Volatile Keyword

  • 4.4 Bit by Bit

  • 4.4.1 Bitwise Operators

  • 4.4.2 Binary Constants

  • 4.4.3 Bit Fields in Structures

  • 4.4.4 Microprocessor Bit-Field Instructions

  • 4.4.5 I/O Devices and Bit Fields

  • 4.4.6 Conclusions

  • 4.5 Programming Floating-Point Applications

  • 4.5.1 A Test Case

  • 4.5.2 Running the Test Case

  • 4.5.3 Troubleshooting

  • 4.5.4 Lessons Learned

  • 4.6 Looking at C—A Different Perspective

  • 4.6.1 Static Things

  • 4.6.2 All Those Semicolons

  • 4.6.3 Pointers and Pointer Arithmetic

  • 4.6.4 When Being Clever Is Not Being Smart

  • 4.6.5 Conclusions

  • 4.7 Reducing Function Call Overhead

  • 4.7.1 Compilers and Structured Code

  • 4.7.2 Inline Functions

  • 4.7.3 Function Calls

  • 4.7.4 Parameter Passing

  • 4.7.5 Local Storage

  • 4.7.6 Stack Frame Generation

  • 4.7.7 Return Values

  • 4.7.8 Conclusions

  • 4.8 Structure Layout—Become an Expert

  • 4.8.1 Key Concepts

  • Data Bus Width

  • Natural Boundaries

  • Unpacked Structures

  • Packed Structures

  • Unpacked Inside Packed

  • 4.8.2 Bit Fields

  • 4.8.3 Tips and Techniques

  • Quick Detection of Size

  • Detection of Offsets and Alignments

  • Tight Packing

  • Inflating Structures

  • Managing Alignment

  • Forcing Identical Layout Across BUS16 and BUS32

  • Forcing Identical Layout Across BUS32 and BUS64

  • 4.9 Memory and Programming in C

  • 4.9.1 Memory

  • 4.9.2 Sections

  • 4.9.3 Conclusions

  • 4.10 Pointers and Arrays in C and C++

  • 4.10.1 Pointers and Pointer Arithmetic

  • 4.10.2 Arrays and Pointers

  • 4.10.3 Conclusions

  • 4.11 Using Dynamic Memory in C and C++

  • 4.11.1 C/C++ Memory Spaces

  • 4.11.2 Dynamic Memory in C

  • 4.11.3 Dynamic Memory in C++

  • 4.11.4 Issues and Problems

  • Stacks

  • Use of malloc()

  • 4.11.5 Memory Fragmentation

  • 4.11.6 Memory with an RTOS

  • RTOS Block/Partition Memory Allocation

  • Memory Leak Detection

  • 4.11.7 Real-Time Memory Solutions

  • Stacks

  • Dynamic Memory

  • 4.11.8 Conclusions

  • 5 C++

  • 5.1 C++ in Embedded Systems—A Management Perspective

  • 5.1.1 Embedded Systems Development Teams

  • 5.1.2 Object-Oriented Programming

  • 5.1.3 Team Management and Object-Oriented Techniques

  • 5.1.4 C++ as an Object-Oriented Language

  • 5.1.5 Overheads

  • 5.1.6 The Way Forward

  • 5.2 Why Convert from C to C++?

  • 5.2.1 Hide Implementation Details

  • 5.2.2 Reuse Class Code

  • 5.2.3 Reuse Generic Classes

  • 5.2.4 Extend Operators

  • 5.2.5 Derive Classes from Base Classes

  • 5.2.6 Avoid Errors Through Function Prototyping

  • 5.2.7 Add Parameters Without Changing Function Calls

  • 5.2.8 Using Safer, Simpler I/O

  • 5.2.9 Improve Performance with Fast Inline Functions

  • 5.2.10 Overload Function Names

  • 5.2.11 Embedded System Support

  • 5.2.12 Change Involves Effort

  • 5.2.13 Massage C Code into C++

  • 5.2.14 The Hard Part: Designing Objects

  • 5.2.15 If It Ain’t Broke, Don’t Fix it

  • 5.3 Clearing the Path to C++

  • 5.3.1 A Strategy for Transition

  • 5.3.2 Evolutionary Steps

  • 5.3.3 Applying Reusability

  • 5.3.4 Writing Clean C

  • Type Checking

  • Casting

  • Enumerated Types

  • Character Strings

  • Scope of Struct and Enum

  • Multiple Declarations

  • Extra Keywords

  • Compiler Assistance

  • 5.3.5 C+—Nearly C++

  • Comment Notation

  • Reference Parameters

  • Placement of Variable Definitions

  • Constructor Functions

  • Dynamic Memory

  • Error Handling

  • 5.3.6 Conclusions—The Path Ahead

  • 5.4 C++ Templates—Benefits and Pitfalls

  • 5.4.1 What Are Templates?

  • Using Function Templates

  • 5.4.2 Template Instantiation

  • 5.4.3 Problems with Templates

  • Program Overhead

  • Duplicate Instantiations

  • 5.4.4 Multiple Template Parameters

  • 5.4.5 Other Template Applications

  • 5.4.6 Conclusions

  • 5.4.7 Postscript

  • 5.5 Exception Handling in C++

  • 5.5.1 Error Handling in C

  • 5.5.2 Does Not Involve Interrupts

  • 5.5.3 C++ Exception Handling

  • Keywords

  • An Example of Exception Handling

  • Multiple Catch Blocks

  • 5.5.4 Special Cases

  • No Matching Catch Block

  • Catch Everything

  • Exception Objects

  • 5.5.5 EHS and Embedded Systems

  • Overheads

  • 5.5.6 Conclusions

  • 5.6 Looking at Code Size and Performance with C++

  • 5.6.1 How Efficient Is C++ Compared to C?

  • 5.6.2 How C++ Affects Application Memory Requirements

  • Templates

  • Inline Functions

  • Virtual Functions

  • Inheritance

  • Duplicate Debug Information Impacts Productivity

  • 5.6.3 Doing C++ Right

  • Faster Compile and Link Times

  • Reduced Program Size

  • 5.6.4 Conclusions

  • 5.7 Write-Only Ports in C++

  • 5.7.1 Encapsulating Expertise

  • 5.7.2 Defining the Problem

  • 5.7.3 A Solution in C

  • 5.7.4 A First Attempt in C++

  • 5.7.5 Using Overloaded Operators

  • 5.7.6 Enhancing the wop Class

  • 5.7.7 Addressing Reentrancy

  • 5.7.8 Using an RTOS

  • 5.7.9 Expertise Encapsulated

  • 5.7.10 Other Possibilities

  • 5.7.11 The Way Forward

  • 5.8 Using Nonvolatile RAM with C++

  • 5.8.1 Requirements of Using Nonvolatile RAM with C++

  • 5.8.2 NVRAM Implementation

  • 5.8.3 A C++ nvram Class

  • 5.8.4 Enhancing the nvram Class

  • 5.8.5 Conclusions

  • Further Reading

  • 6 Real Time

  • 6.1 Real-Time Systems

  • 6.1.1 Implementing an RTS

  • 6.1.2 A Processing Loop

  • 6.1.3 Interrupts

  • 6.1.4 Multitasking

  • 6.1.5 Using an RTOS

  • 6.2 Visualizing Program Models of Embedded Systems

  • 6.2.1 Which Programming Model Is Best for Building Real-Time Systems?

  • 6.2.2 What Purpose Do Models Serve for a Real-Time System?

  • 6.2.3 What Differences Exist Between Models, and What Gains Require What Sacrifices?

  • 6.2.4 What Is the Single-Threaded Programming Model?

  • 6.2.5 What Are the Advantages and Disadvantages of the Single-Threaded Programming Model?

  • 6.2.6 Is a Polling Loop a Single-Threaded Program?

  • 6.2.7 Is a State Machine a Single-Threaded Program?

  • 6.2.8 What Is a Multi-Threaded System?

  • 6.2.9 What Are the Advantages and Disadvantages of the Multi-Threaded Programming Model?

  • 6.2.10 Can Multiple Threads of Execution Really Run Simultaneously on One CPU?

  • 6.2.11 How Can a Multi-Threaded Environment for a Real-Time System Be Acquired?

  • 6.3 Event Handling in Embedded Systems

  • 6.3.1 What Is an Event?

  • 6.3.2 Is a Signal the Same Thing as an Event?

  • 6.3.3 What Events Are the Most Time Critical?

  • 6.3.4 What Does the Microprocessor Do When it Detects an Exception?

  • 6.3.5 Are All Exceptions the Same?

  • 6.3.6 What Is a Synchronous Exception?

  • 6.3.7 What Is an Asynchronous Exception?

  • 6.3.8 How Do Interrupts Get Generated and Serviced?

  • 6.3.9 What State Gets Saved by the CPU?

  • 6.3.10 Is the Machine State the Same as the Thread State?

  • 6.3.11 Should I Write Exception Handlers in Assembly Language or in C?

  • 6.3.12 How Do I Avoid Doing Work in the Exception Handler?

  • 6.4 Programming for Interrupts

  • 6.4.1 Setting up Interrupts

  • 6.4.2 Interrupt Service Routines

  • 6.4.3 Interrupt Vector

  • 6.4.4 Initialization

  • 6.4.5 Conclusions

  • 7 Real-Time Operating Systems

  • 7.1 Debugging Techniques with an RTOS

  • 7.1.1 Introduction

  • 7.1.2 Multiprocess Concept

  • Apparent Simultaneity

  • True Simultaneity

  • 7.1.3 Execution Environment

  • Simulation

  • Hardware Available

  • 7.1.4 Target Connection

  • Dedicated Debugging Connection

  • Communications Link

  • 7.1.5 Debugging Modes

  • Stop Mode

  • Run Mode

  • 7.1.6 RTOS-Aware Debugging Functionality

  • Viewing

  • Controlling

  • 7.1.7 Shared Code

  • 7.1.8 Task-Aware Breakpoints

  • Target

  • Host

  • Breakpoint Scope/Action

  • 7.1.9 Dependent Tasks

  • Synchronized Breakpoints

  • 7.1.10 Memory Management Units

  • Simple Memory Protection

  • The Process Model

  • 7.1.11 Multiple Processors

  • 7.1.12 Conclusions

  • 7.2 A Debugging Solution for a Custom Real-Time Operating System

  • 7.2.1 Implementing Task-Aware Debugging

  • Example Target Device

  • Example Debugger

  • Example RTOS

  • 7.2.2 Task-Awareness Facilities

  • Task Information Display

  • Task-Aware Breakpoints

  • 7.2.3 Conclusions

  • 7.3 Debugging—Stack Overflows

  • 7.3.1 Conclusions

  • 7.4 Bring in the Pros—When to Consider a Commercial RTOS

  • 7.4.1 Commercial and Custom RTOSes

  • 7.4.2 Advantages of a Commercial RTOS

  • 7.4.3 Commercial RTOS Downsides

  • 7.4.4 Why Write a Custom RTOS?

  • 7.4.5 Reasons Not to Create a Custom RTOS

  • 7.4.6 Conclusions

  • 7.5 On the Move

  • 7.5.1 Migrating from One RTOS to Another

  • 7.5.2 Code Migration

  • 7.5.3 Wrappers

  • Strategies

  • Implementation

  • Overhead

  • Challenges

  • API Availability

  • 7.5.4 Drivers and More

  • 7.5.5 Debugging Issues

  • 7.5.6 Conclusions

  • 7.6 Introduction to RTOS Driver Development

  • 7.6.1 The Two Sides of a Device Driver

  • 7.6.2 Data Corruption

  • 7.6.3 Thread Control

  • 7.6.4 Program Logic

  • 7.6.5 Conclusions

  • 7.7 Scheduling Algorithms and Priority Inversion

  • 7.7.1 Introduction

  • 7.7.2 Real-Time Requirements

  • 7.7.3 Scheduling Algorithms

  • Rate Monotonic

  • Deadline Driven

  • 7.7.4 Implications for Operating Systems and Applications

  • The Priority Inversion Problem

  • 7.7.5 Conclusions

  • 7.8 Time Versus Priority Scheduling

  • 7.8.1 RTOS Scheduling

  • 7.8.2 Perfect World

  • 7.8.3 Real World with Priority Scheduling

  • Program Priority

  • 7.8.4 Time Domain Bounded Without Relinquish

  • 7.8.5 Time Domain Bounded with Relinquish

  • 7.8.6 Conclusions

  • 7.9 An Embedded File System

  • 7.9.1 Requirements of an Embedded File System

  • 7.9.2 MS-DOS File System Overview

  • 7.9.3 Long Filenames

  • 7.9.4 Formatting

  • 7.9.5 Partitioning

  • 7.9.6 Devices

  • 7.10 OSEK—An RTOS Standard

  • 7.10.1 About OSEK

  • 7.10.2 OSEK Requirements

  • 7.10.3 OSEK Tasks

  • Task Types

  • Conformance Classes

  • Scheduling Policy

  • Synchronization Mechanisms

  • 7.10.4 Alarms

  • 7.10.5 Error Treatment

  • 8 Networking

  • 8.1 What’s Wi-Fi?

  • 8.1.1 Wireless Datacom

  • Wireless Personal Area Network (WPAN)

  • Wireless Local Area Network (WLAN)

  • Wireless Metropolitan Area Network (WMAN)

  • Cellular Network

  • 8.1.2 IEEE 802.11

  • 802.11b

  • 802.11a

  • 802.11g

  • 802.11i

  • 8.1.3 802.11 Basics

  • 8.1.4 Wi-Fi and Bluetooth

  • Range

  • Topology

  • Power Consumption

  • 8.1.5 Where Next?

  • 8.2 Who Needs a Web Server?

  • 8.2.1 Introduction

  • 8.2.2 Three Primary Capabilities

  • Serve Web Pages to a Web Browser

  • Monitor a Device

  • Control a Device

  • 8.2.3 Web Servers at Work

  • Serving Pages

  • Using the Web Server to Provide Dynamic Information to a Web Browser

  • Using the Web Server to Control an Embedded System

  • 8.2.4 Brief Summary of the Web Server’s Capabilities

  • 8.2.5 What Else Should You Consider?

  • 8.2.6 Conclusion

  • 8.3 Introduction to SNMP

  • 8.3.1 Why SNMP?

  • 8.3.2 The Role of Network Manager

  • 8.3.3 Architectural Model

  • 8.3.4 A Common Misperception

  • 8.3.5 Application-Level Manager-Agents

  • 8.3.6 How to Write Your MIB

  • 8.3.7 Terminology

  • 8.3.8 Conclusions

  • 8.4 IPv6—The Next Generation Internet Protocol

  • 8.4.1 Limitations of the Internet Protocol

  • Depleted Address Space

  • Flawed Addressing Architecture

  • High Cost

  • 8.4.2 Introduction to IP Version 6

  • 8.4.3 Dual Stack Eases Transition

  • 8.4.4 How IPv6 Works

  • Neighbor Discovery

  • Stateless Address Autoconfiguration

  • Duplicate Address Detection

  • Router Discovery

  • Prefix Discovery

  • Address Expiration

  • Address Resolution

  • Header Format Simplification

  • Neighbor Unreachability Detection

  • Multicast Listener Discovery

  • Tunneling

  • Configured Tunneling

  • 6to4 Tunneling

  • DNS for IPv6

  • IPv6 Extension Headers

  • Ancillary Data

  • 8.4.5 RFC Support

  • 8.5 The Basics of DHCP

  • 8.5.1 A DHCP Server

  • Flexible Address Assignment

  • Support for Multiple Subnets

  • 8.5.2 Theory of Operation

  • 8.5.3 RFC Support

  • 8.6 NAT Explained

  • 8.6.1 NAT Explained

  • The Portmap Service

  • 8.6.2 RFC Support

  • 8.6.3 Protocol Support

  • 8.6.4 Application Level Gateways

  • 8.6.5 The Private Network Address Assignment

  • 8.7 PPP—Point-to-Point Protocol

  • 8.7.1 Introduction

  • Abstracted Link-Layer Interface

  • HDLC and Modem Support

  • 8.7.2 How PPP Works

  • Theory of Operation

  • Application Development

  • 8.7.3 PPP Details

  • NCP/IPCP/IPV6CP

  • Authentication

  • LCP

  • HDLC

  • PPPoE

  • Support for Both Hosts and Access Concentrators

  • Support for MSS Replacement

  • L2TP

  • Multilink Protocol

  • PPP MIB Support

  • 8.7.4 RFC Support

  • 8.8 Introduction to SSL

  • 8.8.1 Introduction

  • 8.8.2 How SSL Works

  • Certificates

  • Initial Handshake

  • SSL API

  • 8.8.3 Some SSL Details

  • Client and Server

  • Encryption

  • Certificate Request

  • SSL and Web Servers

  • Export Restraints

  • 8.9 DHCP Debugging Tips

  • 8.10 IP Multicasting

  • 8.10.1 Initializing Multicasting

  • 8.10.2 IGMP Protocol

  • 8.10.3 Implementing Multicasting

  • Receiving

  • Transmitting

  • 8.10.4 Bringing it All Together

  • 9 Open Source, Embedded Linux, and Android

  • 9.1 GNU Toolchain for Embedded Development: Build or Buy

  • 9.1.1 Introduction

  • 9.1.2 Toolchain Components

  • GNU C/C++ Compilers

  • GNU Binary Utilities

  • Runtime Libraries

  • GNU Debugger

  • Debug Stub

  • Eclipse IDE

  • 9.1.3 Building the Toolchain

  • Build Environment

  • Source Code and Patches

  • Configuration Options

  • Build Process

  • Packaging

  • 9.1.4 Validating the Toolchain

  • GNU Regression Test Suites

  • Conformance Test Suites

  • Performance Test Suites

  • 9.1.5 Testing Multiple Options

  • Analyzing and Correcting Failures

  • 9.1.6 Conclusions

  • 9.2 Introduction to Linux for Embedded Systems

  • 9.2.1 Introduction

  • 9.2.2 Challenges Using Open Source

  • Embedded Presents Unique Challenges

  • One Size Does Not Fit All

  • Large Scope of Expertise Required

  • 9.2.3 OpenEmbedded

  • OE Project Goals

  • OE Components

  • Attributes of Open Embedded

  • 9.2.4 Understanding Metadata

  • Recipe Basics

  • Tasks

  • Classes

  • 9.2.5 Project Workflow

  • 9.2.6 Summary

  • 9.3 Android Architecture and Deployment

  • 9.3.1 What Is Android?

  • 9.3.2 Android Architecture

  • Libraries

  • Android Runtime

  • Application Framework

  • Applications

  • 9.3.3 Application Development

  • Development Environment

  • Programming Model

  • 9.3.4 The Android UI

  • 9.3.5 Extending Android Beyond Mobile

  • 9.3.6 Conclusion

  • 9.4 Android, MeeGo, and Embedded Linux in Vertical Markets

  • 9.4.1 Introduction

  • 9.4.2 How Vertical Markets Are Different

  • 9.4.3 The Appeal of Android

  • 9.4.4 The Promise of MeeGo

  • 9.4.5 The Versatility of Embedded Linux

  • 9.4.6 Conclusion

  • 10 Multicore Embedded Systems

  • 10.1 Introduction to Multicore

  • 10.1.1 System Architecture

  • 10.1.2 Power

  • 10.1.3 Challenges

  • 10.2 Multiple Cores: Multiple Operating Systems

  • 10.2.1 SMP Hardware for AMP

  • 10.2.2 AMP Hardware Architecture

  • 10.2.3 AMP Software Architecture

  • 10.2.4 The Importance of Inter-Process Communication

  • 10.2.5 AMP Development Tools

  • 10.2.6 Difficulties

  • 10.2.7 AMP Use Cases

  • 10.2.8 The Use of a Hypervisor

  • 10.2.9 Conclusions

  • 10.3 Selecting Multiple Operating Systems for Multiple Cores

  • 10.3.1 Introduction

  • 10.3.2 Types of OS

  • Real-Time Operating Systems

  • Linux

  • 10.3.3 OS Selection

  • 10.3.4 Multicore Systems

  • Inter-Core Communications

  • Examples

  • 10.3.5 Conclusions

  • 10.4 CPU to CPU Communication: MCAPI

  • 10.4.1 Introduction

  • 10.4.2 Multicore

  • AMP and SMP

  • Multicore Processors

  • 10.4.3 The MCAPI

  • What MCAPI Is Not

  • The MCAPI Design

  • MCAPI Concepts

  • Data Transfer

  • API Call Example

  • MCAPI Implementation

  • 10.4.4 Conclusion

  • Afterword

  • Great Expectations

  • Index

    • 服务邮箱： whx@cnpiec.com.cn

    联系电话：010-65063046；65001305

    京ICP备09090397号-16 京公网安备 11010502049547号