ProgrammingEmbeddedSystemswithCandGNUDevelopment.Tools英文pdf资源-CSDN文库

共1个文件

pdf：1个

Programming

Embedded

Systems

with

5星 · 超过95%的资源需积分: 14 173 浏览量 2010-10-05 17:01:10 上传评论 1 收藏 5.77MB RAR 举报

《Programming Embedded Systems with C and GNU Development Tools》是一本专注于嵌入式系统编程的书籍，主要使用C语言并结合GNU开发工具进行讲解。该书的英文PDF版本为学习者提供了全面了解和实践嵌入式系统开发的资源。在这个压缩包中包含的文件是“Programming.Embedded.Systems.with.C.and.GNU.Development.Tools.(OReilly-2nd.Ed-2006).pdf”，这表明它是该书的第二版，由O'Reilly出版社出版。在嵌入式系统编程中，C语言是广泛使用的编程语言，因为它简洁、高效且易于理解。本书将教你如何利用C语言来设计和实现嵌入式系统的软件部分。C语言的特性使其非常适合在资源有限的嵌入式硬件上运行，如微控制器和其他嵌入式处理器。 GNU开发工具是嵌入式开发中的关键组成部分，包括GCC（GNU Compiler Collection）用于编译代码，GDB（GNU Debugger）用于调试，以及Make工具用于构建过程自动化。这些工具的使用是本书的一个重要主题，它们能帮助开发者有效地构建、测试和优化代码。书中可能会涵盖以下知识点： 1. **嵌入式系统基础**：介绍嵌入式系统的定义、特点、工作原理以及它们在日常生活中的应用。 2. **C语言在嵌入式中的应用**：深入理解C语言的关键概念，如指针、内存管理、结构体、函数等，以及如何在嵌入式环境中优化使用。 3. **汇编语言基础**：虽然主要使用C语言，但理解汇编语言对于优化性能和理解底层硬件操作至关重要。 4. **GNU工具链**：详细讲解GCC的编译过程，包括预处理、编译、汇编和链接阶段，以及如何使用GDB进行有效的调试。 5. **嵌入式程序设计**：涵盖中断服务例程、实时性、中断驱动编程、设备驱动开发等内容。 6. **内存管理**：讨论嵌入式系统中的内存限制，如何有效地分配和管理内存。 7. **调试技巧**：使用GDB进行远程调试，如何设置断点、查看变量值和跟踪调用堆栈。 8. **构建系统与Makefile**：编写和使用Makefile自动化构建过程，提高开发效率。 9. **系统级编程**：涉及中断处理、时钟和定时器、中断服务例程以及中断安全的编程实践。 10. **硬件接口编程**：通过GPIO、串行通信、I2C、SPI等接口与硬件设备进行通信。 11. **实时操作系统（RTOS）**：简述RTOS的基本概念，如任务调度、信号量和互斥锁等。通过学习这本书，读者不仅可以掌握嵌入式系统编程的基础知识，还能获得使用GNU工具链进行开发的实战经验。这对于想要从事嵌入式系统开发的工程师来说是一份宝贵的资源，无论是初学者还是有经验的开发者都能从中受益。

资源推荐

资源详情

资源评论

收起资源包目录

Programming.Embedded.Systems.with.C.and.GNU.Development.Tools.(OReilly-2nd.Ed-2006).rar （1个子文件）

Programming.Embedded.Systems.with.C.and.GNU.Development.Tools.(OReilly-2nd.Ed-2006).pdf 76.38MB

Programming Embedded Systems

By Michael Barr, Anthony Massa

...............................................

Publisher: O'Reilly

Pub Date: October 01, 2006

ISBN: 0-596-00983 -6

Pages: 304

Table of Contents

Index

If you have programming experience and a familiarity with C

the dominant language in embedded systems

Programming Embedded Systems

, Second Edition is exactly what you need to get started with embedded

software. This software is ubiquitous, hidden away inside our watches, DVD players, mobile phones, anti

lock

brakes, and even a few toasters. The military uses embedded software to guide missiles, detect enemy aircraft,

and pilot UAVs. Communication satellites, deep

space probes, and many medical instruments would have been

nearly impossible to create without embedded software.

The first edition of

Programming Embedded Systems

taught the subject to tens of thousands of people around the

world and is now considered the bible of embedded programming. This second edition has been updated to cover all

the latest hardware designs and development methodologies.

The techniques and code examples presented here are directly applicable to real

world embedded software

projects of all sorts. Examples use the free GNU software programming tools, the eCos and Linux operating

systems, and a low

cost hardware platform specially developed for this book. If you obtain these tools along with

Programming Embedded Systems

, Second Edition, you'll have a full environment for exploring embedded systems in

depth. But even if you work with different hardware and software, the principles covered in this book apply.

Whether you are new to embedded systems or have done embedded work before, you'll benefit from the topics in

this book, which include:

How building and loading programs differ from desktop or server computers

Basic debugging techniques

a critical skill when working with minimally endowed embedded systems

Handling different types of memory

Interrupts, and the monitoring and control of on

chip and external peripherals

Determining whether you have real

time requirements, and whether your operating system and application

can meet those requirements

Task synchronization with real

time operating systems and embedded Linux

Optimizing embedded software for size, speed, and power consumption

Working examples for eCos and embedded Linux

So whether you're writing your first embedded program, designing the latest generation of hand

held

whatchamacalits, or managing the people who do, this book is for you.

Programming Embedded Systems

will help

you develop the knowledge and skills you need to achieve proficiency with embedded software.

Praise for the first edition:

"This lively and readable book is the perfect introduction for those venturing into

embedded systems software development for the first time. It provides in one place all the important topics

necessary to orient programmers to the embedded development process. --

Lindsey Vereen, Editor

Chief,

Embedded Systems Programming

This document is created with trial version of CHM2PDF Pilot 2.11.

Programming Embedded Systems

By Michael Barr, Anthony Massa

...............................................

Publisher: O'Reilly

Pub Date: October 01, 2006

ISBN: 0-596-00983 -6

Pages: 304

Table of Contents

Index

Foreword

Preface

Chapter 1. Introduction

Section 1.1. What Is an Embedded System?

Section 1.2. Variations on a Theme

Section 1.3. Embedded Design Examples

Section 1.4. Life As an Embedded Software Developer

Section 1.5. The C Language: The Lowest Common Denominator

Section 1.6. A Few Words About Hardware

Chapter 2. Getting to Know the Hardware

Section 2.1. Understanding the Big Picture

Section 2.2. Hardware Basics

Section 2.3. Examine the Landscape

Section 2.4. Learn How to Communicate

Section 2.5. Getting to Know the Processor

Section 2.6. Study the External Peripherals

Section 2.7. Initialize the Hardware

Chapter 3. Your First Embedded Program

Section 3.1. Hello, World!

Section 3.2. The Blinking LED Program

Section 3.3. The Role of the Infinite Loop

Chapter 4. Compiling, Linking, and Locating

Section 4.1. The Build Process

Section 4.2. Building the Blinking LED Program

Section 4.3. A Quick Look at Makefiles

Chapter 5. Downloading and Debugging

Section 5.1. Downloading the Blinking LED Program

Section 5.2. Remote Debuggers

Section 5.3. Emulators

Section 5.4. Other Useful Tools

Section 5.5. Dig into the Hardware

Chapter 6. Memory

Section 6.1. Types of Memory

Section 6.2. Direct Memory Access

Section 6.3. Endian Issues

Section 6.4. Memory Testing

Section 6.5. Validating Memory Contents

Section 6.6. Using Flash Memory

Chapter 7. Peripherals

Section 7.1. Control and Status Registers

Section 7.2. The Device Driver Philosophy

Section 7.3. Device Driver Design

Chapter 8. Interrupts

Section 8.1. Overview

Section 8.2. Interrupt Map

Section 8.3. Interrupt Service Routine

Section 8.4. The Improved Blinking LED Program

Section 8.5. Summary of Interrupt Issues

Chapter 9. Putting It All Together

Section 9.1. Application Overview

Section 9.2. Working with Serial Ports

Section 9.3. Command

-Line Interface Processing

Chapter 10. Operating Systems

Section 10.1. History and Purpose

Section 10.2. The Scheduler

Section 10.3. Tasks

Section 10.4. Task Synchronization

Section 10.5. Message Passing

Section 10.6. Other Functionality

Section 10.7. Interrupt Handling

Section 10.8. Real

-Time Characteristics

Section 10.9. To Use or Not to Use an RTOS

This document is created with trial version of CHM2PDF Pilot 2.11.

Section 10.9. To Use or Not to Use an RTOS

Section 10.10. Additional Resources

Chapter 11. eCos Examples

Section 11.1. Introduction

Section 11.2. Task Mechanics

Section 11.3. Mutex Task Synchronization

Section 11.4. Semaphore Task Synchronization

Section 11.5. Message Passing

Section 11.6. eCos Interrupt Handling

Chapter 12. Embedded Linux Examples

Section 12.1. Introduction

Section 12.2. Accessing Hardware in Linux

Section 12.3. Task Mechanics

Section 12.4. Mutex Task Synchronization

Section 12.5. Semaphore Task Synchronization

Section 12.6. Message Passing

Chapter 13. Extending Functionality

Section 13.1. Common Peripherals

Section 13.2. Networking for All Devices Great and Small

Chapter 14. Optimization Techniques

Section 14.1. Increasing Code Efficiency

Section 14.2. Decreasing Code Size

Section 14.3. Problems with Optimizing Compilers

Section 14.4. Reducing Memory Usage

Section 14.5. Power-Saving Techniques

Section 14.6. Limiting the Impact of C++

Appendix 1. The Arcom VIPER

Lite Development Kit

Appendix 2. Setting Up Your Software Development Environment

Section 'B'.1. Windows Host Installation

Section 'B'.2. Linux Host Installation

Section 'B'.3. Example Code Installation

Appendix 3. Building the GNU Software Tools

Section 'C'.1. Extracting the Source Files

Section 'C'.2. Building the Toolchain

Appendix 4. Setting Up the eCos Development Environment

Section 'D'.1. The eCos Build Environment

Appendix 5. Setting Up the Embedded Linux Development Environment

Section 'E'.1. Linux Build Environment Setup

Section 'E'.2. Embedded Linux Examples

Index

This document is created with trial version of CHM2PDF Pilot 2.11.

Foreword

If you mention the word

embedded

to most people, they'll assume you're talking about reporters in a war zone. Few

dictionariesincluding the canonical

Oxford English Dictionary

link

embedded

to computer systems. Yet embedded

systems underlie nearly all of the electronic devices used today, from cell phones to garage door openers to medical

instruments. By now, it's nearly impossible to build anything electronic without adding at least a small microprocessor

and associated software.

Vendors produce some nine billion microprocessors every year. Perhaps 100 or 150 million of those go into PCs.

That's only about one percent of the units shipped. The other 99 percent go into embedded systems; clearly, this

stealth business represents the very fabric of our highly technological society.

And use of these technologies will only increase. Solutions to looming environmental problems will surely rest on the

smarter use of resources enabled by embedded systems. One only has to look at the network of 32

bit processors in

Toyota's hybrid Prius to get a glimpse of the future.

Though prognostications are difficult, it is absolutely clear that consumers will continue to demand ever

brainier

products requiring more microprocessors and huge increases in the corresponding software. Estimates suggest that

the firmware content of most products doubles every 10 to 24 months. While the demand for more code is

increasing, our productivity rates creep up only slowly. So it's also clear that the industry will need more embedded

systems people in order to meet the demand.

What skills will these people need? In the PC world, one must be a competent C/C++ programmer. But embedded

developers must have a deep understanding of both the programming languages and the hardware itself; no one can

design, code, and test an interrupt service routine, for instance, without knowing where the interrupts come from,

how the hardware prioritizes them, the tricks behind servicing that hardware, and machine

level details about saving

and preserving the system's context. A firmware developer must have detailed insight into the hardware

implementation of his system's peripherals before he can write a single line of driver code.

In the PC world, the magic of the hardware is hidden behind an extensive API. In an embedded system, that API is

always written by the engineers that are developing the product.

In this book, Michael Barr and Anthony Massa show how the software and hardware form a synergistic gestalt. They

don't shy away from the intricacies of interrupts and I/O, or priority inversion and mutexes.

The authors appropriately demonstrate building embedded systems using a variety of open source tools, including

the GNU compiler suite, which is a standard tool widely used in this industry. eCos and Linux, both free/open source

products, are used to demonstrate small and large operating systems.

The original version of this book used an x86 target board, which has been replaced in this edition by an ARM

based

product. Coincidently, as this volume was in production, Intel made an end

-of-

life announcement for all of its

embedded x86 processors. Readers can be assured that the ARM will be around for a very long time, as it's

supported by an enormous infrastructure of vendors.

The hardware is inexpensive and easily available; the software is free. Together they represent the mainstream of

embedded systems development. Readers can be sure they'll use these tools in the future.

Buy the development kit, read the book, and execute the examples. You'll get the hands

on experience that

employers demand: building and working with real embedded applications.

Jack Ganssle

This document is created with trial version of CHM2PDF Pilot 2.11.

Preface

First figure out why you want the students to learn the subject and what you want them to know, and the method

will result more or less by common sense.

Richard Feynman

Embedded software is in almost every electronic device in use today. There is software hidden away inside our

watches, DVD players, mobile phones, antilock brakes, and even a few toasters. The military uses embedded

software to guide missiles, detect enemy aircraft, and pilot UAVs. Communication satellites, deep

-space probes, and

many medical instruments would've been nearly impossible to create without it.

Someone has to write all that software, and there are tens of thousands of electrical engineers, computer

scientists, and other professionals who actually do. We are two of them, and we know from our personal experiences

just how hard it can be to learn the craft.

Each embedded system is unique, and the hardware is highly specialized to the application domain. As a result,

embedded systems programming can be a widely varying experience and can take years to master. However, one

common denominator across almost all embedded software development is the use of the C programming language.

This book will teach you how to use C in any embedded system.

Even if you already know how to write embedded software, you can still learn a lot from this book. In addition to

learning how to use C more effectively, you'll also benefit from the detailed explanations and source code associated

with common embedded software problems. Among the advanced topics covered in the book are memory testing and

verification, device driver design and implementation, real

time operating system internals, and code optimization

techniques.

Why We Wrote This Book

Each year, globally, approximately one new processor is manufactured per person. That's more than six billion new

processors each year, fewer than two percent of which are the Pentiums and PowerPCs at the heart of new

personal computers. You may wonder whether there are really that many computers surrounding us. But we bet that

within five minutes you can probably spot dozens of products in your own home that contain processors: televisions,

stereos, MP3 players, coffee makers, alarm clocks, VCRs, DVD players, microwaves, dishwashers, remote controls,

bread machines, digital watches, and so on. And those are just the personal possessionsmany more such devices are

used at work. The fact that every one of those products contains not only a processor, but also software, is the

impetus for this book.

One of the hardest things about this subject is knowing when to stop writing. Each embedded system is unique, and

we have therefore learned that there is an exception to every rule. Nevertheless, we have tried to boil the subject

down to its essence and present the things that programmers definitely need to know about embedded systems.

Intended Audience

This is a book about programming embedded systems in C. As such, it assumes that the reader already has some

programming experience and is at least familiar with the syntax of the C language. It also helps if you have some

familiarity with basic data structures, such as linked lists. The book does not assume that you have a great deal of

knowledge about computer hardware, but it does expect that you are willing to learn a little bit about hardware

along the way. This is, after all, a part of the job of an embedded programmer.

While writing this book, we had two types of readers in mind. The first reader is a beginnermuch as we were once.

He has a background in computer science or engineering and a few years of programming experience. The beginner is

interested in writing embedded software for a living but is not sure just how to get started. After reading the first

several chapters, he will be able to put his programming skills to work developing simple embedded programs. The

rest of the book will act as a reference for the more advanced topics encountered in the coming months and years

of his career.

The second reader is already an embedded systems programmer. She is familiar with embedded hardware and knows

how to write software for it but is looking for a reference book that explains key topics. Perhaps the embedded

systems programmer has experience only with assembly language programming and is relatively new to C. In that

case, the book will teach her how to use the C language effectively in an embedded system, and the later chapters

will provide advanced material on real

time operating systems, peripherals, and code optimizations.

Whether you fall into one of these categories or not, we hope this book provides the information you are looking for

in a format that is friendly and easily accessible.

Organization

The book contains 14 chapters and 5 appendixes. The chapters can be divided quite nicely into two parts. The first

part consists of Chapters 1 through 5 and is intended mainly for newcomers to embedded systems. These chapters

should be read in their entirety and in the order that they appear. This will bring you up to speed quickly and

introduce you to the basics of embedded software development. After completing

Chapter 5

, you will be ready to

develop small pieces of embedded software on your own.

This document is created with trial version of CHM2PDF Pilot 2.11.

评论收藏

内容反馈

xuraoqing

2014-08-12

很不错，讲解很全面，涉及到内容比较多，对于进一步深入的地方都给出相关链接。
hansen9035148

2015-02-27

还不错部分插图没有了
舟海

2013-08-06

chm格式，比较方便阅读，很不错
love_home

2015-03-26

I was learning knowledge from this book. It's important to me, and I believe you, too.
libing2008fei

2014-03-05

学习知识的同时，练习下专业英语。