从零开始构建Android嵌入式系统

需积分: 9 121 浏览量更新于2024-07-17 1 收藏 4.76MB PDF 举报

"Embedded Programming with Android: Bringing Up an Android System from Scratch" 本书《嵌入式编程与Android：从零开始构建Android系统》是Addison-Wesley出版的Android Deep Dive系列的第一本，专为中级和高级Android开发者设计，作者Roger Ye在电信和移动设备领域有着丰富的实践经验。本书旨在教授如何编写高效的嵌入式代码，以实现未来Android设备的功能。首先，Ye引导读者了解裸机编程的基础，即如何编写直接在硬件上运行的汇编语言代码。这部分内容对于理解设备底层操作至关重要，因为它是所有嵌入式系统的基石。接着，作者将这个基础扩展到使用C语言创建硬件接口，以便用流行的U-Boot引导加载程序启动Linux内核。这对于任何Android硬件开发者来说都是一个关键步骤，因为Android系统通常基于Linux内核运行。然后，书中详细介绍了如何使用文件系统映像来启动Android，并学习如何构建定制的ROM以支持新的Android设备。定制ROM的开发能力使得开发者能够根据特定硬件需求进行适配和优化。在全书过程中，Ye提供了大量的可下载代码示例，读者可以运行、探索并适应这些代码，从而加深对概念的理解和实际应用。这些实践性的练习对于提升技能和解决问题能力非常有帮助。通过阅读本书，读者将获得以下关键知识点： 1. 嵌入式系统编程基础：学习汇编语言和C语言，以及如何与硬件直接交互。 2. Linux内核启动：理解如何使用U-Boot引导加载程序启动Linux内核。 3. Android启动流程：学习如何构建和使用文件系统映像来启动Android操作系统。 4. 定制ROM开发：掌握如何根据特定硬件需求构建和修改Android ROM。 5. 调试技巧：学习在嵌入式环境中调试代码和解决问题的方法。 Android Deep Dive系列的目标是提供深入的专业知识、模式、框架和工程方法，帮助读者避免常见错误，提高项目质量。随着Android系统的不断更新，此系列书籍也会跟进行业发展，避免过时的API部分。《嵌入式编程与Android》是一本实用的指南，它不仅涵盖了从零开始构建Android系统所需的技能，还为那些希望在穿戴技术、物联网等领域创新的开发者提供了宝贵的资源。通过这本书，读者可以深化对Android底层机制的理解，提升自己的嵌入式系统编程能力。

Preface

Computing is becoming more and more pervasive. Computing devices are evolving from

traditional desktop computers to tablets and mobile devices. With the newer platforms,

embedded computing is playing a more important role than the traditional mainframe-

and desktop-based computing. Embedded system programming looks very different in

various usage scenarios. In some cases, it consists of application programming using the

assembly and C languages on top of the hardware directly. In other cases, it takes place

on top of a real-time operating system (RTOS). In the most complicated case, it can be a

desktop-based system using a modern operating system such as Linux or Windows.

Due to the many different usage scenarios and hardware architectures that are possible,

it is very difficult to teach embedded programming in a standard way in a school or uni-

versity. There are simply too many hardware platforms based on a multitude of very dif-

ferent architectures. The processors or microprocessors can be as simple as 8-bit models or

as complicated as 32-bit or even 64-bit devices. In most cases, students learn about em-

bedded programming on a dedicated hardware reference board and use the compiler and

debugger from a particular company. Obviously, this kind of development environment is

unique and difficult to duplicate. To overcome these challenges, this book uses virtualiza-

tion technology and open source tools to provide a development environment that any

programmer can easily obtain from the Internet.

Who Should Read This Book

If you want to learn embedded system programming, especially embedded system pro-

gramming on Android, this is the book for you. For starters, you may want to get some

hands-on experience while you read a book. This book includes plenty of examples for

you to try out. The good thing is that you don’t need to worry about having a hardware

platform or development tools. All examples in this text are built using open source tools

that you can download from the Internet, and all of them can be tested on the Android

emulator. The source code is hosted in GitHub. Appendix A describes the build environ-

ment setup and explains how to work with the source code in GitHub.

Note

Git is a version control tool used by many open source projects. If you are new to it, you

can search for “git” or “GitHub” on the Internet to find tutorials on its use. A free book on

GitHub, Pro Git by Scott Chacon, can also be downloaded from the following address:

http://git-scm.com/book/en/v2

GitHub is a free git repository on the Internet that can be used to host open source

projects. You can find the git repositories in this book at the following address:

https://github.com/shugaoye/

xvi Preface

If you have just started your career as an embedded system software engineer, your

first project may be porting U-Boot to a new hardware platform. This book gives you the

detailed steps on how to port U-Boot to the Android emulator.

If you are an experienced software developer, you may know that it is quite difficult to

debug a complex device driver in your project. In this book, we explore a way to separate

the debugging of the hardware interface from the device driver development. We explain

how to debug serial ports, interrupt controllers, timers, the real-time clock, and NAND

flash in a bare metal environment. We then explain how to integrate these examples

with U-Boot drivers. The same method can also be used for Linux or Windows driver

development.

To take full advantage of this book, you should be familiar with the C language, basic

operating system concepts, and ARM assembly language. Ideally, readers will be graduates

in computer science or experienced software developers who want to explore low-level

programming knowledge. For professionals who work on Android system development,

this is also a good reference book.

How This Book Is Organized

In this book, we discuss the full spectrum of embedded system programming—from the

fundamental bare metal programming to the bootloader to the boot-up of an Android

system. The focus is on instilling general programming knowledge as well as developing

compiler and debugging skills. The objective is to provide basic knowledge about embed-

ded system programming as a good foundation, thereby providing a path to the more

advanced areas of embedded system programming.

The book is organized in a very process-oriented way. You can decide how to read this

book based on your individual circumstance—that is, in which order to read chapters and

explore subtopics. An explanation of how each part of the book relates to the others will

help you make this decision.

The book consists of three parts. Part I focuses on so-called bare metal programming,

which includes the fundamentals of low-level programming and Android system program-

ming. Chapters 1 through 4 provide essential knowledge related to bare metal program-

ming, including how to run programs on the hardware directly using assembly language

code. In Chapter 5, the focus moves to the C programming language. The rest of Part I

explores the minimum set of hardware interfaces necessary to boot a Linux kernel using

U-Boot. In Chapters 5 to 8, we focus on the hardware interface programming of serial

ports, interrupt controllers, the real-time clock, and NAND flash controllers in the bare

metal programming environment.

Part II begins with Chapter 9, which covers how to port U-Boot to the goldfish plat-

form. Using U-Boot, we can boot the Linux kernel and Android system, as explained in

Chapter 10. The work completed in Chapters 5 through 8 can contribute to the U-Boot

porting by isolating the hardware complexity from the driver framework in U-Boot. The

same technique can be used in the Linux driver development as well. In Part II, we also

use the file system images from the Android SDK to boot the Android system. To support

How This Book Is Organized xvii

two different boot processes (NOR and NAND flash), we must customize the file system

from the Android SDK. Because this work takes place at the binary level, we are restricted

to performing customization at the file level; that is, we cannot change the content of any

files. Strategies to customize the file system are covered in Part III.

In Part III, we move from the bootloader to the kernel to the file system. We use a

virtual device to demonstrate how to build a customized ROM for an Android device.

We explore ways to support a new device and to integrate the bootloader and Linux ker-

nel in the Android source code tree. In Chapter 11, we delve into the environment setup

process and the standard build process for the Android emulator. In Chapter 12, we create

a customized ROM for the virtual device including the integration of U-Boot and the

Linux kernel. At the end of this chapter, readers will have a complete picture just like the

Android system developers do at the mobile device manufacturing level.

A detailed introduction to each of the book’s chapters follows. Part I, “Bare Metal

Programming” consists of Chapters 1 to 8 focusing on so-called bare metal programming:



Chapter 1, “Introduction to Embedded System Programming,” gives a general intro-

duction to embedded system programming. It also explains the scope of this book.



Chapter 2, “Inside Android Emulator,” introduces the Android emulator and gives

a brief introduction to the hardware interfaces used throughout the book.



Chapter 3, “Setting Up the Development Environment,” details the development

environment and tools used in our project. It also provides the first example, which

gives us a chance to test our environment.



Chapter 4, “Linker Script and Memory Map,” covers the basics of developing an

assembly program. We use two examples to analyze how a program is assembled and

linked. After we have a binary image, we analyze how it is loaded into the Android

emulator and then started.



Chapter 5, “Using the C Language,” introduces the C startup code and explains

how we move from assembly language to a C language environment. We also begin

to explore the goldfish hardware interfaces of the goldfish platform. Likewise, we

explore the serial port of the goldfish platform.



Chapter 6, “Using the C Library,” presents details on how to integrate a C runtime

library into a bare metal programming environment. We introduce different flavors

of C runtime libraries and use Newlib as an example to illustrate how to integrate

a C runtime library.



Chapter 7, “Exception Handling and Timer,” explores the interrupt controllers,

timer, and real-time clock (RTC) of the goldfish platform. We work through various

examples that demonstrate ways to handle these hardware interfaces. All example

code developed in the chapter can subsequently be used for U-Boot porting in

Chapter 9.



Chapter 8, “NAND Flash Support in Goldfish,” explores the NAND flash inter-

face of the goldfish platform. This is also an important part of U-Boot porting. In

Chapter 10, we explore how to boot the Android system from NAND flash.

xviii Preface

Part 2, “U-Boot” consists of Chapters 9 and 10, which introduce the processes of U-Boot

porting and debugging. After we have a working U-Boot image, we can use it to boot our

own goldfish kernel and the Android image.



Chapter 9, “U-Boot Porting,” gives the details on U-Boot porting.



Chapter 10, “Using U-Boot to Boot the Goldfish Kernel,” discusses how to build

a goldfish Linux kernel on our own. This kernel image is then used to demonstrate

the various scenarios to boot the goldfish Linux kernel using U-Boot. Both the

NOR flash and NAND flash boot-up processes are discussed.

Part 3, “Android System Integration” considers how to integrate U-Boot and the Linux

kernel into the Android Open Source Project (AOSP) and CyanogenMod source trees.



Chapter 11, “Building Your Own AOSP and CyanogenMod,” gives the details on

Android emulator builds in AOSP and CyanogenMod.



Chapter 12, “Customizing Android and Creating Your Own Android ROM,”

teaches you how to create your own Android ROM on a virtual Android device.

This Android ROM can be brought up by U-Boot, which we created in Chapter 9.

Example Code

Throughout this book, many examples are available to test the content in each chapter.

It is recommended that you input and run the example code while you read this book.

Doing so will give you good hands-on experiences and provide you with valuable insight

so that you will better understand the topics covered in each chapter.

For Chapters 3 through 8, the directory structure organizes the code by chapter. Some

folders are common to all of the examples, such as those containing include and driver

files. All other folders are chapter specific, such as

c03

c04

, and

c05

; these folders contain

the example code in that chapter.

The common makefile is

makedefs.arm

, which is found in the top-level directory.

Individual makefiles are also provided for each example. Following is a template of the

makefile for example code. The

PROJECTNAME

is defined as the filename of an example

code. This makefile template is used for the individual projects in Chapters 3 through 8.

# The base directory relative to this folder

ROOT=../..

PROJECTNAME=

# Include the common make definitions.

include ${ROOT}/makedefs.arm

剩余399页未读，继续阅读

ALo54

粉丝: 5
资源: 111

从零开始构建Android嵌入式系统

[Roger_Ye]_Android_System_programming(z-lib.org).pdf

Learning Embedded Android N Programming 无水印pdf

Embedded Programming with android Bringing up and android system from scratch

Embedded Programming with Android:使用 Android 进行嵌入式编程-开源

Programming with MicroPython Embedded Programming with Microcontrollers and epub

Programming with MicroPython Embedded Programming with Microcontrollers and azw3

miniflux-embedded-android:适用于Miniflux的Android应用

Mobile Applications Development with Android: Technologies and Algorithms

modern-embedded-programming-course:“现代嵌入式系统编程”视频课程的配套资料库

embedded programming with the microsoft .net micro framework

最新资源