嵌入式软件PDF电子书下载

第1章 嵌入式编程的基本概念 1

1.1 数字系统 1

1.2 符号二进制数 3

1.2.1 定点二进制数 4

1.2.2 浮点二进制数 5

1.2.3 交互数字系统 5

1.2.4 二—十进制编码 6

1.2.5 ASCII 7

1.2.6 错误检测 7

1.3 数据结构 8

1.3.1 简单数据类型 9

1.3.2 复杂数据类型 13

1.4 通信协议 18

1.4.1 简单数据广播 18

1.4.2 事件驱动简单传输 19

1.4.3 事件驱动多元传输 20

1.5 数学 22

1.5.1 二进制加法和减法 23

1.5.2 二进制乘法 24

1.5.3 二进制除法 25

1.6 数值比较 27

1.6.1 条件语句 28

1.6.2 循环 33

1.6.3 其他流控制语句 34

1.7 状态机 35

1.7.1 数据索引状态机 38

1.7.2 执行索引状态机 40

1.7.3 混合状态机 43

1.8 多任务 44

第2章 设备驱动 50

2.1 本章梗概 50

2.2 实例1：中断处理的设备驱动程序 53

2.2.1 中断优先级 56

2.2.2 上下文切换 59

2.2.3 中断设备驱动程序的伪代码实例 59

2.2.4 中断处理和性能 66

2.3 实例2：存储器设备驱动程序 67

2.4 实例3：板级总线设备驱动程序 83

2.5 板级I/O驱动程序实例 88

2.5.1 实例4：初始化一个以太网驱动程序 89

2.5.2 实例5：初始化一个RS-232驱动程序 102

2.6 本章小结 106

第3章 嵌入式操作系统 107

3.1 本章梗概 107

3.2 什么是进程 110

3.3 多任务和进程管理 112

3.3.1 进程执行 112

3.3.2 进程调度 122

3.3.3 任务间通信和同步 129

3.4 内存管理 135

3.4.1 用户内存空间 136

3.4.2 内核内存空间 145

3.5 I/O和文件系统管理 145

3.6 操作系统标准实例：POSIX（可移植操作系统接口） 147

3.7 操作系统性能指南 148

3.8 操作系统和板级支持包（BSP） 149

3.9 本章小结 150

第4章 组网 151

4.1 RCM3200 Rabbit Core的介绍 152

4.2 Dynamic C开发环境介绍 153

4.2.1 开发 153

4.2.2 调试 153

4.3 Dynamic C库简介 154

4.4 Dynamic C的内存空间 154

4.4.1 Rabbit的内存分段 155

4.4.2 Dynamic C中无独立的指令和数据空间时的内存使用 155

4.4.3 把函数放入XMEM 157

4.4.4 独立的指令和数据内存 158

4.4.5 综合所有内容 159

4.5 代码是如何编译和运行的 160

4.5.1 在传统开发环境下代码是如何被构建的 160

4.5.2 代码是如何在Dynamic C下构建的 161

4.6 将一台电脑设置为RCM3200开发系统 161

4.7 开始编写代码 162

4.7.1 项目：第一个Rabbit程序 162

4.7.2 Dynamic C的调试特性 163

4.7.3 Dynamic C帮助 163

4.7.4 单步调试 164

4.7.5 增加断点 165

4.7.6 监视表达式 165

4.7.7 Dynamic C不是ANSI C 166

4.7.8 Dynamic C存储空间 168

4.8 嵌入式网络 171

4.9 Dynamic C对于网络协议的支持 172

4.9.1 通用网络协议 172

4.9.2 Dynamic C库的可选模块 174

4.10 典型的网络设置 174

4.10.1 典型的企业网络 174

4.10.2 典型的家庭网络 176

4.11 建立核心模块的网络设置 176

4.11.1 设置IP地址 177

4.11.2 链路层的选择 178

4.11.3 在编译时定义TCP/IP 178

4.11.4 程序运行时的TCP/IP定义 179

4.11.5 调试网络宏命令 179

4.12 项目1：建立用于网络的Rabbit核心模块 180

4.12.1 静态地址的配置 180

4.12.2 配置动态地址 182

4.12.3 动态地址分配的特殊情况 183

4.13 客户端／服务器范例 183

4.14 Berkeley Sockets接口 184

4.15 嵌入式应用程序中TCP和UDP的比较 186

4.16 Socket编程中重要的Dynamic C库函数 187

4.16.1 用于通信初始化或通信终止的函数 187

4.16.2 用于确定Socket状态的函数 188

4.16.3 用于发送和接收数据的函数 188

4.16.4 阻塞函数和非阻塞函数 188

4.17 项目2：实现RabbitTCP/IP服务器 188

4.17.1 服务器的TCP/IP状态机 189

4.17.2 和通用TCP工具一起工作 191

4.17.3 和Java TCP/IP客户端一起工作 191

4.17.4 和C++ TCP/IP客户端一起工作 192

4.18 项目3：实现一个Rabbit TCP/IP客户端 194

4.18.1 关闭Windows XP防火墙 196

4.18.2 检查客户端代码 197

4.18.3 与Java TCP/IP服务器一起工作 198

4.18.4 使用C＃实现的TCP/IP服务器一起工作 200

4.19 项目4：实现一个Rabbit UDP服务器 201

4.19.1 与Java UDP客户端一起工作 203

4.19.2 与C++ UDP客户端一起工作 204

4.20 一些有用（并免费）的网络工具 204

4.20.1 Ping 204

4.20.2 Traceroute 205

4.20.3 Ethereal 206

4.20.4 Netcat 206

4.20.5 在线工具 207

4.21 最后的思考 207

第5章 错误处理和调试 208

5.1 嵌入式系统开发和故障排除之道 208

5.1.1 开发者 208

5.1.2 回归测试——早测试、常测试 209

5.1.3 案例分析——一次性集成和无回归测试套件 209

5.1.4 发现者 210

5.1.5 修复者 211

5.2 避免集中调试——灵巧地编码 212

5.2.1 准则＃1：使用小函数 212

5.2.2 准则＃2：使用指针格外小心 212

5.2.3 准则＃3：良好的注释代码 212

5.2.4 准则＃4：避免“幻数” 212

5.3 主动调试 212

5.4 栈和堆 213

5.5 植入内存 214

5.6 逃逸代码 215

5.7 专用解码器 216

5.8 MMU 217

5.9 小结 217

5.10 用闪存实现可下载固件 218

5.11 微程序器 218

5.12 微程序器的优点 219

5.13 微程序器的不足 219

5.14 接收一个微程序器 219

5.15 基本的微程序器 220

5.16 常见问题及其解决方案 221

5.16.1 调试者不喜欢可写的代码空间 221

5.16.2 调试者不喜欢自我重定位的代码 222

5.16.3 无法生成位置独立的代码 224

5.16.4 启动时无固件 224

5.16.5 无限的看门狗超时 224

5.16.6 意外断电 225

5.17 硬件上的选择 226

5.17.1 隔离代码和数据 226

5.17.2 灵活安全 227

5.18 内存诊断 228

5.19 ROM测试 228

5.20 RAM测试 229

5.21 非易失性存储器 232

5.22 监督电路 232

5.23 多字节写 234

5.24 测试 236

5.25 小结 236

5.26 构建一个强大的看门狗 236

5.27 内部WDT 238

5.28 外部WDT 240

5.29 强大WDT的特征 241

5.30 使用内部WDT 243

5.31 使用外部WDT 244

5.32 用于多任务的WDT 245

5.33 总结和其他思路 246

第6章 软／硬件协同验证 248

6.1 嵌入式系统设计过程 248

6.1.1 需求 248

6.1.2 系统架构 248

6.1.3 选择微处理器 248

6.1.4 硬件设计 249

6.1.5 软件设计 249

6.1.6 软／硬件的整合 249

6.2 验证和确认 249

6.2.1 验证 249

6.2.2 确认 250

6.3 人际交互 250

6.4 协同验证 252

6.4.1 软／硬件协同验证的历史 252

6.4.2 协同验证的定义 254

6.4.3 协同验证方法 257

6.4.4 协同验证法样例 260

6.4.5 协同验证指标（协同验证参数） 270

第7章 嵌入式媒体处理技术 275

7.1 媒体处理系统简介 276

7.1.1 核心处理过程 276

7.1.2 输入／输出子系统——外设接口 277

7.1.3 存储子系统 279

7.2 系统资源的划分和代码优化 280

7.3 事件产生和处理 280

7.4 编程方法 282

7.5 高效编程的结构特点 283

7.5.1 单周期多重操作 283

7.5.2 硬件循环结构 284

7.5.3 专用寻址模式 285

7.5.4 联锁指令流水线 287

7.6 为达到有效编程，编译器的考虑因素 288

7.7 系统和内核同步 292

7.7.1 存取同步 292

7.7.2 排序 293

7.7.3 原子操作 294

7.8 存储结构——管理所需 294

7.8.1 存储器访问权衡 294

7.8.2 指令存储管理——高速缓存或DMA 295

7.8.3 数据存储管理 296

7.8.4 选择DMA和cache的系统方针 297

7.8.5 内存管理单元（MMU） 300

7.9 物理数据传输 301

7.9.1 分组转换到最小化内存总线翻转 301

7.9.2 了解内核和DMA SDRM的存取 303

7.9.3 保持SDRAM行开放，实现数据的多通路 303

7.9.4 优化系统时钟设置，确保刷新率，调整SDRAM运行时的速率 304

7.9.5 利用系统资源之间的优先权和仲裁策略 305

7.10 媒体处理框架 305

7.11 定义框架 306

7.12 非对称和对称的双核处理器 311

7.13 编程模型 312

7.13.1 非对称编程模型 312

7.13.2 均匀的编程模型 313

7.14 构建框架的策略 314

7.14.1 实时处理数据 314

7.14.2 编程轻便型胜过性能 316

7.14.3 基于性能的框架 317

7.14.4 框架提示 320

7.15 关于媒体框架的其他问题 320

7.15.1 音频、视频同步 320

7.15.2 管理系统流 322

7.15.3 框架和算法的复杂性 323

第8章 嵌入式系统中的DSP 324

8.1 嵌入式系统及实时系统概述 328

8.2 实时系统 328

8.3 硬件实时系统和软件实时系统 329

8.3.1 简介 329

8.3.2 实时系统和分时系统的区别 329

8.3.3 DSP系统是硬实时系统 329

8.3.4 实时事件的特点——实时事件的分类 330

8.4 有效执行和执行环境 331

8.4.1 效率概述 331

8.4.2 资源管理 331

8.5 实时系统设计挑战 332

8.5.1 响应时间 332

8.5.2 从故障中恢复 332

8.5.3 分布式和多处理器的体系结构 333

8.5.4 嵌入式系统 333

8.6 总结 337

8.7 运用DSP的嵌入式系统研发周期概述 338

8.8 使用DSP的嵌入式系统研发周期 338

8.8.1 步骤1：研究系统所有的功能需要 339

8.8.2 步骤2：选择系统需要的硬件组件 340

8.8.3 硬件门 340

8.8.4 软件可编程化 340

8.8.5 通用处理器 340

8.8.6 微控制器 341

8.8.7 FPGA解决方案 341

8.8.8 数字信号处理器 342

8.8.9 通用信号处理解决方案 342

8.8.10 DSP加速上的选择 343

8.8.11 步骤3：了解DSP的基础和体系结构 345

8.8.12 DSP处理模式 347

8.8.13 输入／输出选择 348

8.8.14 计算DSP性能 348

8.8.15 DSP软件 351

8.8.16 DSP构架 352

8.9 优化数字信号处理（DSP）软件 354

8.10 什么是优化 354

8.11 处理过程 354

8.12 加快经常性事件的速度 356

8.13 加快经常性事件的速度——DSP体系架构 356

8.14 加快经常性事件的速度——DSP算法 358

8.15 加快经常性事件的速度——DSP编译器 358

8.16 DSP优化的深入讨论 363

8.17 直接存储器访问 363

8.18 使用DMA 364

8.18.1 将数据分段 365

8.18.2 挂起和轮询 367

8.18.3 管理内部存储器 368

8.19 循环展开 369

8.19.1 填充执行单元 370

8.19.2 减少循环开销 371

8.19.3 让循环适合寄存器的空间 372

8.19.4 折中 373

8.20 软件流水线化 374

8.20.1 一个例子 375

8.20.2 使软件流水线化 379

8.20.3 中断和流水线代码 379

8.21 更多的关于DSP的编译器和优化技术 380

8.21.1 编译器架构和流 380

8.21.2 编译器优化 380

8.21.3 编译进行时的选项 386

8.22 程序员协助编译器 387

8.22.1 附注 387

8.22.2 内联函数 388

8.22.3 关键字 390

8.22.4 函数内嵌 390

8.22.5 减少堆栈存取时间 391

8.22.6 程序员协助编译器 392

8.22.7 编码建议总结 392

8.23 基于剖面的编译 395

8.23.1 优点 395

8.23.2 调试优化代码的问题 396

8.23.3 代码优化过程总结 396

8.23.4 总结 399

第9章 实用嵌入式编码技术 400

9.1 重入 400

9.2 原子变量 400

9.3 另两个规则 401

9.4 保持代码为重入 402

9.5 递归 403

9.6 异步硬件／固件 403

9.7 竞争条件 404

9.8 选项 405

9.9 其他RTOS 406

9.10 亚稳态 407

9.11 固件，非硬件 408

9.12 中断延迟 410

9.13 取数据 412

9.14 理解C编译器：如何最小化代码大小 413

9.15 现代的C编译器 413

9.15.1 编译器的结构 414

9.15.2 程序的含义 415

9.15.3 基本转换 415

9.15.4 寄存器分配 416

9.15.5 函数调用 417

9.15.6 函数内联 417

9.15.7 低级代码压缩 418

9.15.8 链接器 418

9.15.9 编译器优化控制 418

9.15.10 内存模型 419

9.16 编程建议 419

9.16.1 使用正确的数据尺寸 419

9.16.2 使用最好的指针类型 419

9.16.3 结构和填充 420

9.16.4 使用函数原型 421

9.16.5 使用参数 421

9.16.6 不要取地址 421

9.16.7 不要使用内联汇编语言 422

9.16.8 不要写聪明的代码 422

9.16.9 为跳转表使用switch 423

9.16.10 在使用位域前先检查 423

9.16.11 心库函数 423

9.16.12 使用额外的提示 424

9.17 最后说明 424

9.18 致谢 424

第10章 开发技术及趋势 425

10.1 如何为片上系统设计选择CPU 425

10.1.1 设计复杂度 425

10.1.2 设计重用 425

10.1.3 内存架构和保护 425

10.1.4 CPU性能 426

10.1.5 功耗 426

10.1.6 成本 426

10.1.7 软件因素 426

10.1.8 多核SoC 427

10.1.9 小结 427

10.2 嵌入式系统软件开发的新兴技术 427

10.2.1 微处理器设备技术 427

10.2.2 系统架构 428

10.2.3 设计构成 428

10.2.4 软件内容 429

10.2.5 编程语言 429

10.2.6 软件团队规模和分布 430

10.2.7 UML和建模 430

10.2.8 关键技术 430

10.2.9 小结 431

10.3 选择开发工具 431

10.3.1 开发工具链 431

10.3.2 编译特性 432

10.3.3 嵌入式系统的扩展 432

10.3.4 优化 433

10.3.5 构建工具：关键点重述 434

10.3.6 调试 434

10.3.7 调试工具：关键点重述 437

10.3.8 标准和开发工具的集成 437

10.3.9 选择建议 437

10.3.10 小结 438

10.4 Eclipse——将嵌入式工具集中 438

10.4.1 Eclipse平台的理念 439

10.4.2 平台 439

10.4.3 Eclipse如何变成嵌入式的 440

10.4.4 小结 441

10.5 嵌入式软件和UML 441

10.5.1 为什么使用UML建模 441

10.5.2 将应用程序和体系结构分离 443

10.5.3 xtUML代码生成 446

10.5.4 小结 449

10.6 用xtUML进行基于模型的系统开发 449

10.6.1 为什么构建嵌入式系统如此困难 449

10.6.2 更好的解决方案 451

10.6.3 经验到此为止 451

10.7 展望未来 451