嵌入式软件开发精解PDF电子书下载

第1章 嵌入式软件 1

1.1 嵌入式应用的影响 1

1.1.1 来自开发的挑战 1

1.1.2 软件复用 3

1.1.3 实时操作系统 3

1.1.4 文件系统 4

1.1.5 USB 4

1.1.6 图形 5

1.1.7 网络 5

1.1.8 小结 6

1.2 嵌入式系统的存储器 7

1.2.1 存储器 7

1.2.2 软件开发面临的挑战 8

1.2.3 所有东西都会出错 9

1.2.4 好的解决方法 10

1.3 存储器架构 10

1.3.1 选项 10

1.3.2 平面单一地址空间存储器 11

1.3.3 分段空间存储器 11

1.3.4 单元切换空间存储器 12

1.3.5 多地址空间存储器 13

1.3.6 虚拟空间存储器 14

1.3.7 高速缓冲存储器 14

1.3.8 存储器管理单元 14

1.3.9 小结 15

1.4 软件是如何影响硬件设计的 15

1.4.1 谁在设计硬件 15

1.4.2 软件主导硬件 16

1.4.3 软硬件的均衡 16

1.4.4 硬件调试 16

1.4.5 自检 17

1.4.6 小结 18

1.5 将软件移植到新处理器架构上 18

1.5.1 特定目标 19

1.5.2 RTOS问题 21

1.5.3 处理器移植和开放标准 22

1.5.4 小结 24

1.6 汽车电子的嵌入式软件 24

1.6.1 概要 24

1.6.2 汽车电子特征 24

1.6.3 编程问题 25

1.6.4 实时操作系统因素 25

1.6.5 小结 26

1.7 芯片设计时如何选择CPU 27

1.7.1 设计复杂度 27

1.7.2 设计复用性 28

1.7.3 存储器架构和保护 28

1.7.4 CPU性能 29

1.7.5 功耗 29

1.7.6 成本 29

1.7.7 软件问题 29

1.7.8 多核SoC 29

1.7.9 小结 30

1.8 USB软件的介绍 30

1.8.1 什么是USB 30

1.8.2 USB外设 31

1.8.3 USB通信 32

1.8.4 USB软件 32

1.8.5 USB和嵌入式系统 33

1.8.6 小结 33

1.9 走向USB 3.0时代 34

1.9.1 概述 34

1.9.2 总线架构 34

1.9.3 线缆和连接器 34

1.9.4 封包路由 34

1.9.5 双向协议流 35

1.9.6 批量流 35

1.9.7 USB 3.0电源管理 36

1.9.8 USB 3.0集线器 36

1.9.9 xHCI：新型主控制器接口 36

1.9.10 USB的未来应用 36

1.9.11 小结 37

扩展阅读 37

第2章 设计和开发 38

2.1 嵌入式系统软件开发的新兴技术 38

2.1.1 微处理器技术 39

2.1.2 系统架构 39

2.1.3 设计组合性 40

2.1.4 软件内容 40

2.1.5 编程语言 41

2.1.6 软件团队的规模和分布 41

2.1.7 UML和建模 42

2.1.8 关键技术 42

2.1.9 小结 42

2.2 选择开发工具 43

2.2.1 开发工具链 43

2.2.2 编译器特征 44

2.2.3 嵌入式系统的扩展 44

2.2.4 优化 45

2.2.5 构建工具：简要介绍关键问题 46

2.2.6 调试 46

2.2.7 调试工具：关键问题的回顾 49

2.2.8 标准和开发工具集成 49

2.2.9 选择的暗示 50

2.2.1 0小结 51

2.3 Eclipse：集成嵌入式开发工具 51

2.3.1 介绍 51

2.3.2 Eclipse平台的思想 52

2.3.3 平台 52

2.3.4 使用Eclipse进行嵌入式开发 53

2.3.5 小结 54

2.4 跨越RTOS界限的开发系统 54

2.4.1 标准化是解决之道 54

2.4.2 Eclipse解决方案 55

2.4.3 Eclipse插件 55

2.4.4 Eclipse授权 56

2.4.5 Eclipse用户优势 56

2.4.6 视图 56

2.4.7 非嵌入式插件 57

2.5 嵌入式软件和UML 57

2.5.1 为什么要用UML建模 58

2.5.2 从架构中分离应用 60

2.5.3 xtUML代码生成 64

2.5.4 小结 66

2.6 用户界面开发 67

2.6.1 用户界面的多样性 67

2.6.2 用户界面的实现 68

2.6.3一个合理化的UI解决方案 70

2.6.4 小结 71

2.7 软件和功耗 71

2.7.1 介绍 71

2.7.2 软件问题 73

2.7.3 软件中的功耗控制 74

2.7.4 多核 75

2.7.5 硬件问题 76

2.7.6 虚拟编程 78

2.7.7 小结 78

第3章 编程 79

3.1 为特殊存储器编程 79

3.1.1 特殊存储器 79

3.1.2 非易失性RAM 79

3.1.3 共享存储器 81

3.1.4 小结 82

3.2 嵌入式系统中的自检 82

3.2.1 存储器测试 83

3.2.2 I/O设备 85

3.2.3 多线程问题 85

3.2.4 看门狗 86

3.2.5 自检失败 86

3.2.6 最后一些要点 86

3.3 命令行解释器 86

3.3.1 嵌入式系统的诊断功能 87

3.3.2 让嵌入式系统开始运行 87

3.3.3 命令行解释器——需求 87

3.3.4 设计命令行解释器 88

3.3.5 命令行解释器的实现 88

3.3.6 命令行解释器的原型代码 89

3.3.7 小结 94

3.4 嵌入式软件应用：交通信号灯 94

3.4.1 应用程序 94

3.4.2 硬件配置 94

3.4.3 程序的实现 95

3.4.4 主循环 95

3.4.5 中断 96

3.4.6 延时 97

3.4.7 信号灯 97

3.4.8 使用全局变量 97

第4章 C语言 99

4.1 共同变量 99

4.2 C函数的原型 101

4.2.1 在函数原型之前 102

4.2.2 函数原型的应用 102

4.2.3 使用函数原型 102

4.3 中断函数和ANSI关键字 103

4.3.1 中断函数 103

4.3.2 ANSI C const关键字 104

4.3.3 ANSI C volatile关键字 105

4.4 从位开始 106

4.4.1 位运算 106

4.4.2 二进制常量 107

4.4.3 结构体中的位域 107

4.4.4 微处理器位域指令 108

4.4.5 I/O设备和位域 108

4.4.6 小结 109

4.5 浮点数在编程中的应用 109

4.5.1 示例 110

4.5.2 程序实测 110

4.5.3 问题的解答 111

4.5.4 从教训中学习 111

4.6 从不同的角度看待C语言 111

4.6.1 静态数据 112

4.6.2 关于分号 112

4.6.3 指针和指针运算 113

4.6.4 聪明反被聪明误 113

4.6.5 小结 114

4.7 减少函数调用的开销 114

4.7.1 编译器和结构化代码 114

4.7.2 内联函数 114

4.7.3 函数调用 115

4.7.4 参数传递 115

4.7.5 局部存储 115

4.7.6 生成堆栈帧 116

4.7.7 返回值 117

4.7.8 小结 117

4.8 精通结构布局 117

4.8.1 关键概念 118

4.8.2 位域 121

4.8.3 提示和技巧 122

4.9 C语言编程和存储器 130

4.9.1 存储器 131

4.9.2 段 131

4.9.3 小结 131

4.10 C/C＋＋中的指针和数组 132

4.10.1 指针和指针运算 132

4.10.2 数组和指针 133

4.10.3 小结 133

4.11 C/C＋＋中的动态存储 133

4.11.1 C/C＋＋存储空间 134

4.11.2 C语言中的动态存储 134

4.11.3 C＋＋中的动态存储 136

4.11.4 和动态存储相关的问题 136

4.11.5 存储空间碎片化 137

4.11.6 RTOS中的存储管理 138

4.11.7 实时存储解决方案 139

4.11.8 小结 140

第5章 C＋＋ 141

5.1 从管理的角度看嵌入式系统中的C＋＋ 141

5.1.1 嵌入式系统开发团队 141

5.1.2 面向对象编程 141

5.1.3 团队管理和面向对象方法 142

5.1.4 作为面向对象语言的C＋＋ 142

5.1.5 开销 142

5.1.6 前方的路 142

5.2 为什么要从C转向C＋＋ 143

5.2.1 隐藏具体实现的细节 143

5.2.2 重用类的代码 144

5.2.3 重用通用的类 144

5.2.4 扩展操作符的功能 144

5.2.5 从基类中衍生新的类 144

5.2.6 通过函数原型避免错误 145

5.2.7 增加函数参数而不改变调用语句 145

5.2.8 使用更加简单和安全的I/O 145

5.2.9 通过内联函数提升性能 146

5.2.10 重载函数名 146

5.2.11 对嵌入式系统的支持 146

5.2.12 转变的代价 147

5.2.13 向C＋＋中引入C代码 147

5.2.14 难点：设计对象 147

5.2.15 如果没有出现问题，就不要去改变 148

5.3 扫清通向C＋＋的障碍 148

5.3.1 过渡策略 148

5.3.2 循序渐进 148

5.3.3 实现可重用性 149

5.3.4 编写Clean C代码 150

5.3.5 C＋：接近C＋＋ 153

5.3.6 小结：前方的路 156

5.4 C＋＋模板的优势与劣势 156

5.4.1 什么是模板 156

5.4.2 模板的实例化 158

5.4.3 模板带来的问题 158

5.4.4 多个模板参数 159

5.4.5 模板的其他应用 159

5.4.6 小结 160

5.4.7 后记 160

5.5 C＋＋的异常处理 160

5.5.1 C语言中的错误处理 160

5.5.2 异常和中断无关 161

5.5.3 C＋＋的异常处理 161

5.5.4 特殊情况 163

5.5.5 EHS和嵌入式系统 165

5.5.6 小结 166

5.6 C＋＋的代码大小和性能 166

5.6.1 C＋＋比C语言更高效吗 167

5.6.2 C＋＋对内存需求的影响 167

5.6.3 正确使用C＋＋ 170

5.6.4 小结 171

5.7 C＋＋中的只写端口 171

5.7.1 封装专业知识 171

5.7.2 问题的定义 172

5.7.3 C语言的解决方案 173

5.7.4 使用C＋＋进行尝试 173

5.7.5 重载操作符 174

5.7.6 对wop类进行增强 175

5.7.7 可重入性 176

5.7.8 使用RTOS 178

5.7.9 封装专业知识 179

5.7.10 其他的可能性 179

5.7.11 前方的路 179

5.8 在C＋＋中使用非易失性RAM 180

5.8.1 程序编制对类定义的需求 180

5.8.2 NVRAM的实现 180

5.8.3 C＋＋的nvram类 181

5.8.4 继续改进nvram类 183

5.8.5 小结 183

扩展阅读 183

第6章 实时性 184

6.1 实时系统 184

6.1.1 实时系统的实现 184

6.1.2 处理循环 185

6.1.3 中断 185

6.1.4 多任务 185

6.1.5 使用实时操作系统 186

6.2 嵌入式系统的可视化程序模型 186

6.2.1 哪种程序模型最适合用来构建实时系统 187

6.2.2 为何要为实时系统建立模型 187

6.2.3 各种模型之间有什么不同，各有什么优缺点 187

6.2.4 什么是单线程程序模型 187

6.2.5 单线程程序模型有什么优缺点 187

6.2.6 轮询循环是不是一个单线程程序 187

6.2.7 状态机是不是一个单线程程序 188

6.2.8 什么是多线程系统 188

6.2.9 多线程程序模型有哪些优缺点 188

6.2.10 多线程真的同时运行吗 189

6.2.11 如何获取实时系统的多线程环境 189

6.3 嵌入式系统的事件处理 189

6.3.1 事件 189

6.3.2 信号和事件是不是同一回事 190

6.3.3 什么样的事件是时间敏感的 190

6.3.4 当侦测到一个异常，微处理器如何处理 190

6.3.5 所有的异常都一样吗 190

6.3.6 同步异常 190

6.3.7 异步异常 190

6.3.8 中断是如何产生的和服务的 191

6.3.9 CPU保存的状态是什么 191

6.3.10 机器状态就是线程状态吗 191

6.3.11 异常处理程序应该用汇编语言还是C语言来写 191

6.3.12 怎样避免在异常处理程序上花费时间 192

6.4 中断程序 192

6.4.1 设置中断 192

6.4.2 中断服务例程 193

6.4.3 中断向量 193

6.4.4 初始化 194

6.4.5 小结 194

第7章 实时操作系统 195

7.1 RTOS的调试技术 195

7.1.1 概要 195

7.1.2 多进程的概念 195

7.1.3 执行环境 196

7.1.4 与目标机连接 197

7.1.5 调试模式 198

7.1.6 RTOS级的调试功能 199

7.1.7 代码共享 200

7.1.8 任务级的断点 201

7.1.9 任务相关性 202

7.1.10 内存管理单元 202

7.1.11 多处理器 203

7.1.12 小结 203

7.2 自己开发的RTOS调试解决方案 204

7.2.1 任务级调试的实现 204

7.2.2 任务级调试工具 205

7.2.3 小结 207

7.3 调试：堆栈溢出 208

7.4 何时考虑使用商业化RTOS 208

7.4.1 商用化RTOS和自己开发RTOS 209

7.4.2 商业化RTOS的优点 209

7.4.3 商业化RTOS的缺点 210

7.4.4 为什么要自己开发RTOS 211

7.4.5 不自己开发RTOS的理由 211

7.4.6 小结 212

7.5 移植RTOS 213

7.5.1 从一个RTOS转移到另一个RTOS 213

7.5.2 代码移植 214

7.5.3 封装 214

7.5.4 驱动和其他 217

7.5.5 调试问题 217

7.5.6 小结 217

7.6 RTOS驱动程序开发简介 219

7.6.1 设备驱动的两个方面 219

7.6.2 数据损坏 220

7.6.3 线程控制 220

7.6.4 程序逻辑 220

7.6.5 小结 221

7.7 调度算法和优先级反转 221

7.7.1 概要 222

7.7.2 实时性需求 222

7.7.3 调度算法 222

7.7.4 操作系统和应用的含义 223

7.7.5 小结 224

7.8 时间与优先级调度比较 224

7.8.1 RTOS调度 224

7.8.2 理想世界 225

7.8.3 现实世界中的优先级调度 225

7.8.4 不释放控制权的时域限制 226

7.8.5 释放控制权的时域限制 226

7.8.6 小结 227

7.9 嵌入式文件系统 227

7.9.1 嵌入式文件系统的需求 228

7.9.2 MS-DOS文件系统介绍 228

7.9.3 长文件名 229

7.9.4 格式化 229

7.9.5 分区 229

7.9.6 设备 229

7.10 OSEK：一种RTOS标准 230

7.10.1 OSEK简介 230

7.10.2 OSEK需求 231

7.10.3 OSEK的任务 231

7.10.4 报警 232

7.10.5 错误处理 232

第8章 网络 233

8.1 Wi-Fi简介 233

8.1.1 无线数据通信 234

8.1.2 IEEE 802.11 234

8.1.3 802.11基础知识 235

8.1.4 Wi-Fi和蓝牙 236

8.1.5 发展前景 236

8.2 哪些人需要Web服务器 237

8.2.1 简介 237

8.2.2 三个重要的功能 237

8.2.3 Web服务器的运行 239

8.2.4 Web服务器功能总结 241

8.2.5 其他需要考虑的地方 241

8.2.6 小结 242

8.3 SNMP介绍 242

8.3.1 为什么使用SNMP 242

8.3.2 网络管理者的职责 243

8.3.3 架构模型 243

8.3.4 公众的误解 244

8.3.5 应用级的管理者和代理 244

8.3.6 如何编写MIB 244

8.3.7 术语 244

8.3.8 结论 245

8.4 下一代互联网协议：IPv6 246

8.4.1 互联网协议的局限 246

8.4.2 IP第6版介绍 247

8.4.3 双栈简化过渡 247

8.4.4 IPv6如何工作 247

8.4.5 RFC支持 251

8.5 DHCP基础 251

8.5.1 DHCP服务器 252

8.5.2 工作原理 252

8.5.3 RFC支持 256

8.6 NAT详解 256

8.6.1 NAT详解 256

8.6.2 RFC支持 258

8.6.3 支持的协议 258

8.6.4 应用级网关 258

8.6.5 私有网络地址分配 258

8.7 PPP：点对点协议 259

8.7.1 介绍 259

8.7.2 PPP如何工作 259

8.7.3 PPP详解 261

8.7.4 RFC支持 263

8.8 SSL介绍 264

8.8.1 介绍 264

8.8.2 SSL如何工作 265

8.8.3 一些SSL细节 266

8.9 DHCP调试小技巧 267

8.10 IP多播 269

8.10.1 多播初始化 270

8.10.2 IGMP协议 270

8.10.3 多播的实现 271

8.10.4 小结 272

第9章 开源软件、嵌入式Linux和Android 273

9.1 嵌入式开发的GNU工具链：构建还是购买 273

9.1.1 介绍 273

9.1.2 工具链的组件 274

9.1.3 构建工具链 276

9.1.4 验证工具链 279

9.1.5 测试的各种选择 281

9.1.6 小结 283

9.2 嵌入式Linux简介 283

9.2.1 简介 283

9.2.2 使用开源的挑战 283

9.2.3 OpenEmbedded 285

9.2.4 理解元数据 286

9.2.5 项目流程 287

9.2.6 小结 288

9.3 Android架构和开发 288

9.3.1 Android技术简介 288

9.3.2 Android架构 289

9.3.3 应用开发 289

9.3.4 AndroidUI 291

9.3.5 在移动设备以外的市场拓展Android 291

9.3.6 总结 292

9.4 垂直市场上的Android、Meego和嵌入式Linux 292

9.4.1 介绍 292

9.4.2 垂直市场有什么不同 292

9.4.3 Android的吸引力 293

9.4.4 MeeGo的前途 294

9.4.5 多才多艺的嵌入式Linux 294

9.4.6 小结 295

第10章 多核嵌入式系统 296

10.1 多核简介 296

10.1.1 系统架构 296

10.1.2 功耗 297

10.1.3 挑战 297

10.2 多核：多个操作系统 297

10.2.1 AMP的SMP硬件 298

10.2.2 AMP硬件系统 298

10.2.3 AMP软件架构 299

10.2.4 IPC的重要性 300

10.2.5 AMP开发工具 300

10.2.6 困难 301

10.2.7 AMP应用案例 302

10.2.8 使用Hypervisor 302

10.2.9 小结 303

10.3 选择多核的多操作系统 303

10.3.1 介绍 303

10.3.2 操作系统的类型 304

10.3.3 选择操作系统 304

10.3.4 多核系统 306

10.3.5 小结 306

10.4 CPU与CPU的通信：MACPI 306

10.4.1 介绍 307

10.4.2 多核 307

10.4.3 MACPI 307

10.4.4 小结 310

后记 311