C语言是一门通用计算机编程语言，应用广泛。C语言的设计目标是提供一种能以简易的方式编译、处理低级存储器、产生少量的机器码以及不需要任何运行环境支持便能运行的编程语言。
; {8 u, O7 ?8 V+ C( j6 P2 J

尽管C语言提供了许多低级处理的功能，但仍然保持着良好跨平台的特性，以一个标准规格写出的C语言程序可在许多电脑平台上进行编译，甚至包含一些嵌入式处理器（单片机或称MCU）以及超级电脑等作业平台。20世纪80年代，为了避免各开发厂商用的C语言语法产生差异，由美国国家标准局为C语言订定了一套完整的国际标准语法，称为ANSI C，作为C语言最初的标准。
8 U! H+ Z; A  c6 B
& p* W4 x, D, F, `1 C2 p# Y, X
　　

2 D' @4 W5 u$ aC语言嵌入式系统编程注意事项
6 X# c* j/ ]4 h0 u6 S

不同于一般形式的软件编程，嵌入式系统编程建立在特定的硬件平台上，势必要求其编程语言具备较强的硬件直接操作能力。无疑，汇编语言具备这样的特质。但是，归因于汇编语言开发过程的复杂性，它并不是嵌入式系统开发的一般选择。而与之相比，C语言--一种“高级的低级”语言，则成为嵌入式系统开发的最佳选择。笔者在嵌入式系统项目的开发过程中，一次又一次感受到C语言的精妙，沉醉于C语言给嵌入式开发带来的便利。
9 X# X. X0 L7 y, u" z5 i" L; I
. v2 ]% ?$ a9 [
+ [* K2 [) k, c) B2 n大多数嵌入式系统的硬件平台。它包括两部分：
) p5 {5 f# n4 n! u5 }
+ P0 V+ n5 z% h  I2 v3 k
（1） 以通用处理器为中心的协议处理模块，用于网络控制协议的处理；
（2） 以数字信号处理器（DSP）为中心的信号处理模块，用于调制、解调和数/模信号转换。

. h! Q4 R4 H0 u, r; |
本文的讨论主要围绕以通用处理器为中心的协议处理模块进行，因为它更多地牵涉到具体的C语言编程技巧。而DSP编程则重点关注具体的数字信号处理算法，主要涉及通信领域的知识，不是本文的讨论重点。

! k6 r& }. w' Q: z4 H
2 w% U# t: c5 V/ p0 z着眼于讨论普遍的嵌入式系统C编程技巧，系统的协议处理模块没有选择特别的CPU，而是选择了众所周知的CPU芯片--80186，每一位学习过《微机原理》的读者都应该对此芯片有一个基本的认识，且对其指令集比较熟悉。80186的字长是16位，可以寻址到的内存空间为1MB，只有实地址模式。C语言编译生成的指针为32位（双字），高16位为段地址，低16位为段内编译，一段最多64KB。

: [4 X- E6 C' D
+ I0 F4 V7 J8 L5 |, q' F: X; ?协议处理模块中的FLASH和RAM几乎是每个嵌入式系统的必备设备，前者用于存储程序，后者则是程序运行时指令及数据的存放位置。系统所选择的FLASH和RAM的位宽都为16位，与CPU一致。
0 x2 [+ B. x6 w2 j
2 l2 H, }. P0 g6 d: h0 s$ S
实时钟芯片可以为系统定时，给出当前的年、月、日及具体时间（小时、分、秒及毫秒），可以设定其经过一段时间即向CPU提出中断或设定报警时间到来时向CPU提出中断（类似闹钟功能）。


: u# D5 v. D  j2 ?/ X5 C) _NVRAM（非易失去性RAM）具有掉电不丢失数据的特性，可以用于保存系统的设置信息，譬如网络协议参数等。在系统掉电或重新启动后，仍然可以读取先前的设置信息。其位宽为8位，比CPU字长小。文章特意选择一个与CPU字长不一致的存储芯片，为后文中一节的讨论创造条件。
6 A% c. z6 V4 x4 `+ Z( A
' s- Y" U! C% ^5 _  Q: v% |2 @. e
UART则完成CPU并行数据传输与RS-232串行数据传输的转换，它可以在接收到［1~MAX_BUFFER］字节后向CPU提出中断，MAX_BUFFER为UART芯片存储接收到字节的最大缓冲区。


4 Z  ~( Q0 Q& R+ }8 Z# {: e1 L键盘控制器和显示控制器则完成系统人机界面的控制。


0 V4 y& U- W2 S4 U以上提供的是一个较完备的嵌入式系统硬件架构，实际的系统可能包含更少的外设。之所以选择一个完备的系统，是为了后文更全面的讨论嵌入式系统C语言编程技巧的方方面面，所有设备都会成为后文的分析目标。

% K1 q9 k* L0 Y. I/ C$ X' b" {2 D
1 I; {+ P  i, ~嵌入式系统需要良好的软件开发环境的支持，由于嵌入式系统的目标机资源受限，不可能在其上建立庞大、复杂的开发环境，因而其开发环境和目标运行环境相互分离。因此，嵌入式应用软件的开发方式一般是，在宿主机（Host）上建立开发环境，进行应用程序编码和交叉编译，然后宿主机同目标机（Target）建立连接，将应用程序下载到目标机上进行交叉调试，经过调试和优化，最后将应用程序固化到目标机中实际运行。


$ ~5 n) d& }+ u4 }CAD-UL是适用于x86处理器的嵌入式应用软件开发环境，它运行在Windows操作系统之上，可生成x86处理器的目标代码并通过PC机的COM口（RS-232串口）或以太网口下载到目标机上运行。其驻留于目标机FLASH存储器中的monitor程序可以监控宿主机Windows调试平台上的用户调试指令，获取CPU寄存器的值及目标机存储空间、I/O空间的内容。
+ T5 E$ i) @; u

后续章节将从软件架构、内存操作、屏幕操作、键盘操作、性能优化等多方面阐述C语言嵌入式系统的编程技巧。软件架构是一个宏观概念，与具体硬件的联系不大；内存操作主要涉及系统中的FLASH、RAM和NVRAM芯片；屏幕操作则涉及显示控制器和实时钟；键盘操作主要涉及键盘控制器；性能优化则给出一些具体的减小程序时间、空间消耗的技巧。
) B6 S8 V! X0 d" N5 g

5 q$ @: h5 N' M! C0 A在我们的修炼旅途中将经过25个关口，这些关口主分为两类，一类是技巧型，有很强的适用性；一类则是常识型，在理论上有些意义。
% l; C/ v* g: `( C/ P; N

3 X4 J' n; X( L4 KSo， let’s go.

  [) u2 ?; n  h/ c# O0 x
' V, ^! s$ X- _& F7 m" k& XC语言嵌入式系统编程注意事项之软件架构篇
3 r' o' W$ p' z) b9 o
; N+ M% d, |% Z* d
模块划分的“划”是规划的意思，意指怎样合理的将一个很大的软件划分为一系列功能独立的部分合作完成系统的需求。
4 ~0 m) f- ^& C. R! @

模块划分


模块划分的“划”是规划的意思，意指怎样合理的将一个很大的软件划分为一系列功能独立的部分合作完成系统的需求。C语言作为一种结构化的程序设计语言，在模块的划分上主要依据功能（依功能进行划分在面向对象设计中成为一个错误，牛顿定律遇到了相对论），C语言模块化程序设计需理解如下概念：


（1） 模块即是一个.c文件和一个.h文件的结合，头文件（.h）中是对于该模块接口的声明；
% `" ]: B# h6 @* S3 n' x0 c# Y' Z（2） 某模块提供给其它模块调用的外部函数及数据需在.h中文件中冠以extern关键字声明；
（3） 模块内的函数和全局变量需在.c文件开头冠以staTIc关键字声明；
/ |* j0 u* m; ]/ E5 k+ R（4） 永远不要在.h文件中定义变量！定义变量和声明变量的区别在于定义会产生内存分配的操作，是汇编阶段的概念；而声明则只是告诉包含该声明的模块在连接阶段从其它模块寻找外部函数和变量。如：

, G2 N' w8 X$ b' V4 D  n; W

1. 
   
2. 　　/*module1.h*/
   4 i5 T3 {; i. J+ m1 ^- H! D
3. 　　int a = 5; /* 在模块1的.h文件中定义int a */
   9 S* c; r9 x3 C/ A4 n' M: x
4. 　　/*module1 .c*/
   
5. 　　#include “module1.h” /* 在模块1中包含模块1的.h文件 */
   
6. 　　/*module2 .c*/
   
7. 　　＃include “module1.h” /* 在模块2中包含模块1的.h文件 */
   
8. 　　/*module3 .c*/
   6 ]' m. J; [2 A5 s7 q: M5 B
9. 　　＃include “module1.h” /* 在模块3中包含模块1的.h文件 */

复制代码

以上程序的结果是在模块1、2、3中都定义了整型变量a，a在不同的模块中对应不同的地址单元，这个世界上从来不需要这样的程序。正确的做法是：
% c$ u% ~9 z3 p  X

1. 
   
2. 　　/*module1.h*/
   
3. 　　extern int a; /* 在模块1的.h文件中声明int a */
   
4. 　　/*module1 .c*/
   
5. 　　＃include “module1.h” /* 在模块1中包含模块1的.h文件 */
   
6. 　　int a = 5; /* 在模块1的.c文件中定义int a */
   
7. 　　/*module2 .c*/
   2 n9 @( w4 g' J3 |0 A. q) S$ l
8. 　　＃include “module1.h” /* 在模块2中包含模块1的.h文件 */
   0 t9 J/ @+ i9 ~; \) r+ ~
9. 　　/*module3 .c*/
   
10. 　　＃include “module1.h” /* 在模块3中包含模块1的.h文件 */

复制代码

这样如果模块1、2、3操作a的话，对应的是同一片内存单元。
' V$ e4 F6 N- H! ~: {/ m

一个嵌入式系统通常包括两类模块：


! c1 y4 @; |& j$ `$ @（1）硬件驱动模块，一种特定硬件对应一个模块；
- x0 p% p0 J/ B8 T2 X（2）软件功能模块，其模块的划分应满足低偶合、高内聚的要求。


( x5 h4 }: g3 ^& m1 }6 z, X* R多任务还是单任务
; z% B" G( n% z7 q$ d) }( i* U

5 h4 ~$ N( N" ~' W( w" d5 m所谓“单任务系统”是指该系统不能支持多任务并发操作，宏观串行地执行一个任务。而多任务系统则可以宏观并行（微观上可能串行）地“同时”执行多个任务。
! E# p) ?3 x( T& a" z% E7 L
/ P  K; [5 t+ o% [. \# E
多任务的并发执行通常依赖于一个多任务操作系统（OS），多任务OS的核心是系统调度器，它使用任务控制块（TCB）来管理任务调度功能。TCB包括任务的当前状态、优先级、要等待的事件或资源、任务程序码的起始地址、初始堆栈指针等信息。调度器在任务被激活时，要用到这些信息。此外，TCB还被用来存放任务的“上下文”（context）。任务的上下文就是当一个执行中的任务被停止时，所要保存的所有信息。通常，上下文就是计算机当前的状态，也即各个寄存器的内容。当发生任务切换时，当前运行的任务的上下文被存入TCB，并将要被执行的任务的上下文从它的TCB中取出，放入各个寄存器中。


5 c4 d2 H  x* x4 A1 w嵌入式多任务OS的典型例子有Vxworks、ucLinux等。嵌入式OS并非遥不可及的神坛之物，我们可以用不到1000行代码实现一个针对80186处理器的功能最简单的OS内核，作者正准备进行此项工作，希望能将心得贡献给大家。

9 j% D+ `% g5 Z$ q' |3 e
2 p' q* `7 {/ _# s; n究竟选择多任务还是单任务方式，依赖于软件的体系是否庞大。例如，绝大多数手机程序都是多任务的，但也有一些小灵通的协议栈是单任务的，没有操作系统，它们的主程序轮流调用各个软件模块的处理程序，模拟多任务环境。

1 u6 i& d2 q! t& u/ j) y3 w
- a% W& L1 c  F) n4 U1 C2 c单任务程序典型架构

' _( c. {( }: ]3 S7 X& D
（1）从CPU复位时的指定地址开始执行；
' f' F/ e9 C. C% i% o$ |（2）跳转至汇编代码startup处执行；
* P  ?; Z& M0 [" D（3）跳转至用户主程序main执行，在main中完成：
4 z- O* X. s5 s' B+ c: f. k       a.初试化各硬件设备；
" E' c) P& f3 V6 L　　b.初始化各软件模块；
　　c.进入死循环（无限循环），调用各模块的处理函数


用户主程序和各模块的处理函数都以C语言完成。用户主程序最后都进入了一个死循环，其首选方案是：
$ M- s$ R- k& R2 R$ ]
7 r- z3 j; c. @; K/ Y

1. <font color="#003000">
   # ]! T9 Q  t+ P0 v/ e2 |. b
2. 　　while（1）
   # y$ i( E( K- N
3. 　　{
   
4. 　　}</font>
   

复制代码

有的程序员这样写：
0 ^' _/ d# }5 M+ l; F9 s) E

1. 
   0 {( [9 Q+ p6 I3 N) f* y& Y# U
2. 　　for（;;）
   
3. 　　{
   , O; @! F3 s9 e3 j5 n$ o
4. 　　}

复制代码

% O. |( [6 u) O" b7 l: o4 l, ~这个语法没有确切表达代码的含义，我们从for（;;）看不出什么，只有弄明白for（;;）在C语言中意味着无条件循环才明白其意。


8 V$ x  c5 S, X9 j/ `5 @下面是几个“著名”的死循环：
; T* z, Y3 B- Q& ]/ [
9 r$ D* u. H# x* a" I, h, l
（1）操作系统是死循环；
（2）WIN32程序是死循环；
（3）嵌入式系统软件是死循环；
（4）多线程程序的线程处理函数是死循环。
3 I% Y/ P  X' m0 C

你可能会辩驳，大声说：“凡事都不是绝对的，2、3、4都可以不是死循环”。Yes，you are right，但是你得不到鲜花和掌声。实际上，这是一个没有太大意义的牛角尖，因为这个世界从来不需要一个处理完几个消息就喊着要OS杀死它的WIN32程序，不需要一个刚开始RUN就自行了断的嵌入式系统，不需要莫名其妙启动一个做一点事就干掉自己的线程。有时候，过于严谨制造的不是便利而是麻烦。君不见，五层的TCP/IP协议栈超越严谨的ISO/OSI七层协议栈大行其道成为事实上的标准？

' N  K7 y! O1 q7 w5 T' A* k4 M- J
经常有网友讨论：
+ W9 Y' N4 A2 I0 K
/ b! K/ w' X. V) @' _4 t- m5 a

1. 
   
2. 　　printf（“%d，%d”，++i，i++）; /* 输出是什么？*/
   
3. 　　c = a+++b; /* c=？ */

复制代码

4 d( \5 b( R! ]! A等类似问题。面对这些问题，我们只能发出由衷的感慨：世界上还有很多有意义的事情等着我们去消化摄入的食物。
1 [, S  o. }3 o
& X' }5 Q% Y4 Y
2 z# G+ D- \: ^' q/ y: M) Y实际上，嵌入式系统要运行到世界末日。

1 ^% R2 x& s* h" B
中断服务程序
4 I+ Y0 t, D" r& V9 o: y
: @* C$ N" S( v& J. g
8 v) b  @* {. m0 h9 l$ w3 ~9 a中断是嵌入式系统中重要的组成部分，但是在标准C中不包含中断。许多编译开发商在标准C上增加了对中断的支持，提供新的关键字用于标示中断服务程序（ISR），类似于__interrupt、#program interrupt等。当一个函数被定义为ISR的时候，编译器会自动为该函数增加中断服务程序所需要的中断现场入栈和出栈代码。
! Y* \2 ^! v5 v8 y& _, I% _

2 ]- K8 T9 k% C+ @3 S3 Z; d中断服务程序需要满足如下要求：
) T# v) b$ M' s6 [( n

（1）不能返回值；
（2）不能向ISR传递参数；
6 X5 _8 u& ~: [' K  T" Q9 ]& T8 H（3） ISR应该尽可能的短小精悍；
8 \6 M2 o$ H, G& ~9 Q! W3 ~1 Y（4） printf（char * lpFormatString，…）函数会带来重入和性能问题，不能在ISR中采用。


5 b9 b! a' Y$ l! s在某项目的开发中，我们设计了一个队列，在中断服务程序中，只是将中断类型添加入该队列中，在主程序的死循环中不断扫描中断队列是否有中断，有则取出队列中的第一个中断类型，进行相应处理。
! s- s6 J- l/ B$ G9 o4 R: V

1. 
   
2. 　　/* 存放中断的队列 */
   - R& ^; p* p& r5 i1 k
3. 　　typedef struct tagIntQueue
   
4. 　　{
   
5. 　　int intType; /* 中断类型 */
   
6. 　　struct tagIntQueue *next;
   - ~: \3 V5 m' D
7. 　　}IntQueue;
   0 ]3 S* ^$ p+ x" P8 T
8. 　　IntQueue lpIntQueueHead;
   8 `2 p5 p3 m8 X# `
9. 　　__interrupt ISRexample （）
   . S1 H1 {& Q6 G/ M" z. [
10. 　　{
    
11. 　　int intType;
    
12. 　　intType = GetSystemType（）;
    % X0 F: w/ k8 B2 B; i- y
13. 　　QueueAddTail（lpIntQueueHead， intType）；/* 在队列尾加入新的中断 */
    
14. 　　}

复制代码

1 E! m7 H8 G8 i$ F! E& t( v7 I; R在主程序循环中判断是否有中断：
+ N( o, I# E) k% F" }5 {" m5 Q

1. 
   $ O/ N$ r6 f6 p2 \! y- O
2. 　　While（1）
   7 G" X) {8 S( x. b/ w: f4 G
3. 　　{
   1 l! u: O8 k8 K) x% z
4. 　　If（ ！IsIntQueueEmpty（） ）
   
5. 　　{
   4 l4 L/ b! \) j( k) w' m6 l
6. 　　intType = GetFirsTInt（）;
   
7. 　　switch（intType） /* 是不是很象WIN32程序的消息解析函数？ */
   4 ^* m% a" Z' |+ R5 ]% j! ^
8. 　　{
   9 m* l/ L7 ]# l) N
9. 　　/* 对，我们的中断类型解析很类似于消息驱动 */
   0 ]( ~, T3 }( E+ l# p; c
10. 　　case xxx： /* 我们称其为“中断驱动”吧？ */
    3 B* F+ p1 R9 H! K2 M3 A4 ~: u
11. 　　…
    * W; f7 T7 n5 j& @' Q; S7 a
12. 　　break;
    0 r) o  i" f/ v4 ]# P$ u% f
13. 　　case xxx：
    5 a- l4 g7 W$ p- k8 ~& R$ G. `
14. 　　…
    
15. 　　break;
    - [" v; E( L( \0 z- R! O( F' s
16. 　　…
    3 @* z% T# P6 }' g: r, y' f
17. 　　}
    
18. 　　}
    
19. 　　}

复制代码

: ^2 p3 l% [3 L( O4 f按上述方法设计的中断服务程序很小，实际的工作都交由主程序执行了。
6 U: X5 J: D5 [$ h$ M. u' B! ?

: X7 G' r1 @! H7 e. \8 c模块划分的“划”是规划的意思，意指怎样合理的将一个很大的软件划分为一系列功能独立的部分合作完成系统的需求

8 z/ d9 W1 J) N5 q' ?$ H; g
4 K7 U' Y$ n9 i硬件驱动模块


- p% `* {3 [2 }- A$ v8 M一个硬件驱动模块通常应包括如下函数：
" _) o& D2 x) I5 h6 R& [

（1）中断服务程序ISR
/ f1 {9 a8 J' w3 ?! k- p9 Y（2）硬件初始化
/ ~  ]6 |( T  f* r% M　　a.修改寄存器，设置硬件参数（如UART应设置其波特率，AD/DA设备应设置其采样速率等）；
　　b.将中断服务程序入口地址写入中断向量表：

1. 
   
2. 　　/* 设置中断向量表 */
   
3. 　　m_myPtr = make_far_pointer（0l）; /* 返回void far型指针void far * */
   
4. 　　m_myPtr += ITYPE_UART; /* ITYPE_UART： uart中断服务程序 */
   $ w" X% v/ [7 T
5. 　　/* 相对于中断向量表首地址的偏移 */
   ' R0 f& o+ j3 B  g  N3 u8 W# O
6. 　　*m_myPtr = &UART _Isr; /* UART _Isr：UART的中断服务程序 */

复制代码

. ^6 c7 J2 C4 s* |( H7 m
8 a0 N& d1 \! ?4 X' s
（3）设置CPU针对该硬件的控制线
　　a.如果控制线可作PIO（可编程I/O）和控制信号用，则设置CPU内部对应寄存器使其作为控制信号；
! w' ~3 n! w/ i$ }. F- Y　　b.设置CPU内部的针对该设备的中断屏蔽位，设置中断方式（电平触发还是边缘触发）。

& D) M1 f. ]' S
- {, l4 G* l  h; j# ~" X  p（4）提供一系列针对该设备的操作接口函数。例如，对于LCD，其驱动模块应提供绘制像素、画线、绘制矩阵、显示字符点阵等函数；而对于实时钟，其驱动模块则需提供获取时间、设置时间等函数。
. i! v8 \# H0 y2 z1 [
8 @3 [" g! i- W% t/ S2 `) G5 s$ E' c
C的面向对象化
$ s- j* w6 l& S8 B
& S8 @1 ^9 E7 I" j' F
" ?% ]( j+ H3 S( B: h( _在面向对象的语言里面，出现了类的概念。类是对特定数据的特定操作的集合体。类包含了两个范畴：数据和操作。而C语言中的struct仅仅是数据的集合，我们可以利用函数指针将struct模拟为一个包含数据和操作的“类”。下面的C程序模拟了一个最简单的“类”：

1. 
     N$ _. r- M! x7 l5 A, U3 G
2. 　　#ifndef C_Class
   
3. 　　#define C_Class struct
   
4. 　　#endif
   
5. 　　C_Class A
   
6. 　　{
   
7. 　　C_Class A *A_this; /* this指针 */
   # i, _5 m4 ~. k3 v: S4 G
8. 　　void （*Foo）（C_Class A *A_this）; /* 行为：函数指针 */
   3 P; h8 Y! w+ H% j
9. 　　int a; /* 数据 */
   
10. 　　int b;
    
11. 　　};

复制代码

2 Z/ b0 v) `# ^- k$ x- t
我们可以利用C语言模拟出面向对象的三个特性：封装、继承和多态，但是更多的时候，我们只是需要将数据与行为封装以解决软件结构混乱的问题。C模拟面向对象思想的目的不在于模拟行为本身，而在于解决某些情况下使用C语言编程时程序整体框架结构分散、数据和函数脱节的问题。我们在后续章节会看到这样的例子。
  l! `1 J0 N; [7 j

总结
$ P+ L9 c6 K, \& V- ?9 I- x" |

本篇介绍了嵌入式系统编程软件架构方面的知识，主要包括模块划分、多任务还是单任务选取、单任务程序典型架构、中断服务程序、硬件驱动模块设计等，从宏观上给出了一个嵌入式系统软件所包含的主要元素。


1 p4 n4 \$ Y) _0 c) Q% p- [请记住：软件结构是软件的灵魂！结构混乱的程序面目可憎，调试、测试、维护、升级都极度困难。


# ?' J0 s' S  a$ YC语言嵌入式系统编程注意事项之内存操作
& P: R2 ?+ _+ Q! X5 V5 ~* C
' _7 K9 e- d" ~5 b3 n
# d! @" N- z1 t8 t1 y2 R. A在嵌入式系统的编程中，常常要求在特定的内存单元读写内容，汇编有对应的MOV指令，而除C/C++以外的其它编程语言基本没有直接访问绝对地址的能力
* t: u9 n0 m/ N

) n6 a  v) L& J# C6 w数据指针
, e/ D5 M) S0 N

7 s& V) I+ s  m8 a0 m在嵌入式系统的编程中，常常要求在特定的内存单元读写内容，汇编有对应的MOV指令，而除C/C++以外的其它编程语言基本没有直接访问绝对地址的能力。在嵌入式系统的实际调试中，多借助C语言指针所具有的对绝对地址单元内容的读写能力。以指针直接操作内存多发生在如下几种情况：

# V/ I" }9 [6 L9 g) c6 X& M
$ |( L; ]1 C: w% \6 u* Y（1） 某I/O芯片被定位在CPU的存储空间而非I/O空间，而且寄存器对应于某特定地址；
# g( T7 T+ U9 l（2） 两个CPU之间以双端口RAM通信，CPU需要在双端口RAM的特定单元（称为mail box）书写内容以在对方CPU产生中断；
" C+ F; L: ?0 f（3） 读取在ROM或FLASH的特定单元所烧录的汉字和英文字模。
譬如：
7 o% B9 `5 O' p$ |2 S

1. 
   1 c' q' M* L" l: @6 l. ?) A
2. 　　unsigned char *p = （unsigned char *）0xF000FF00;
   , @. h) X  E! a: H- t7 U) Y; e
3. 　　*p=11;

复制代码

, O9 S8 E& G5 o0 F9 J0 ^: M8 F
以上程序的意义为在绝对地址0xF0000+0xFF00（80186使用16位段地址和16位偏移地址）写入11。
$ W% S/ Y% Y8 w+ b7 `+ ^1 U/ R
# }! ~# T" w! g) d
- V5 J$ L- c5 G& c在使用绝对地址指针时，要注意指针自增自减操作的结果取决于指针指向的数据类别。上例中p++后的结果是p= 0xF000FF01，若p指向int，即：
' d4 _" w& ?5 f( P$ _) `# A

1. 
   
2. 　　int *p = （int *）0xF000FF00;
   

复制代码

( |2 z0 x) S( [; G

　　p++（或++p）的结果等同于：p = p+sizeof（int），而p-（或-p）的结果是p = p-sizeof（int）。
/ b0 g+ {5 q; t+ v( C! h9 `

同理，若执行：
9 d2 \3 Z$ s" p4 s: t. Y. E- w

1. 
   
2. 　　long int *p = （long int *）0xF000FF00;

复制代码

) |4 |  y% Y4 Q$ A4 h& H9 D2 F则p++（或++p）的结果等同于：p = p+sizeof（long int） ，而p-（或-p）的结果是p = p-sizeof（long int）。
" b3 K% t4 @. E  i0 F
, F& ~' M6 l$ x. R& L  l* Z
4 f* u5 D% Y+ @# I9 Z: s! _  t7 ]记住：CPU以字节为单位编址，而C语言指针以指向的数据类型长度作自增和自减。理解这一点对于以指针直接操作内存是相当重要的。


函数指针
( ^8 a1 e) ^% m0 `% h; t' v  Y8 _5 Y

$ J- g1 {' m! j$ i0 d, Q首先要理解以下三个问题：
5 a5 A0 l& u" N& E

' W4 y% u7 ]3 u4 O6 j" {* Q  A, h（1）C语言中函数名直接对应于函数生成的指令代码在内存中的地址，因此函数名可以直接赋给指向函数的指针；
（2）调用函数实际上等同于“调转指令＋参数传递处理＋回归位置入栈”，本质上最核心的操作是将函数生成的目标代码的首地址赋给CPU的PC寄存器；（3）因为函数调用的本质是跳转到某一个地址单元的code去执行，所以可以“调用”一个根本就不存在的函数实体，晕？请往下看：


) b% o6 J7 M+ H请拿出你可以获得的任何一本大学《微型计算机原理》教材，书中讲到，186 CPU启动后跳转至绝对地址0xFFFF0（对应C语言指针是0xF000FFF0，0xF000为段地址，0xFFF0为段内偏移）执行，请看下面的代码：

1. 
   
2. 　　typedef void （*lp） （ ）; /* 定义一个无参数、无返回类型的 */
   
3. 　　/* 函数指针类型 */
   
4. 　　lp lpReset = （lp）0xF000FFF0; /* 定义一个函数指针，指向*/
   
5. 　　/* CPU启动后所执行第一条指令的位置 */
   ' f/ c4 Z) _8 D) i- y" \! J
6. 　　lpReset（）; /* 调用函数 */

复制代码

) M6 e8 A) V$ G, \/ L

# W* d8 E6 R% J在以上的程序中，我们根本没有看到任何一个函数实体，但是我们却执行了这样的函数调用：lpReset（），它实际上起到了“软重启”的作用，跳转到CPU启动后第一条要执行的指令的位置。
2 {! _6 h5 }% M8 E* A! u

记住：函数无它，唯指令集合耳；你可以调用一个没有函数体的函数，本质上只是换一个地址开始执行指令！
( ?- C8 J- ]6 H! M* l

; y* a- L* R' x* f) E, U1 |数组vs动态申请
- z  z# }" H5 L* u
1 D1 Y5 v2 I% `% ]! W
4 }# a& t& l' w$ V6 f# s9 |3 ~" a5 ^在嵌入式系统中动态内存申请存在比一般系统编程时更严格的要求，这是因为嵌入式系统的内存空间往往是十分有限的，不经意的内存泄露会很快导致系统的崩溃。


所以一定要保证你的malloc和free成对出现，如果你写出这样的一段程序：
+ @7 O" {# o4 M3 _0 a5 j6 O( Y
- l0 d% k  e! D9 L- Z

1. 
   ' [  P0 n$ j' W: G2 W1 Q% O7 q# z3 k
2. 　　char * （void）
   
3. 　　{
   % n- F4 j6 _+ v# e' [: x
4. 　　char *p;
   * h7 M+ `8 ?9 r$ y# v: A
5. 　　p = （char *）malloc（…）;
   % w" q. f7 _8 d: E3 X' Z
6. 　　if（p==NULL）
   , @9 c+ A/ }' p6 n) r0 J
7. 　　…;
   
8. 　　… /* 一系列针对p的操作 */
   
9. 　　return p;
   . B2 m, U& O8 e7 x' v' y/ Z
10. 　　}

复制代码

在某处调用（），用完中动态申请的内存后将其free，如下：

1. 
   
2. 　　char *q = （）;
   
3. 　　…
   
4. 　　free（q）;

复制代码

* U- ?, F! w' C0 M) {上述代码明显是不合理的，因为违反了malloc和free成对出现的原则，即“谁申请，就由谁释放”原则。不满足这个原则，会导致代码的耦合度增大，因为用户在调用函数时需要知道其内部细节！
. W1 [; `6 o* q9 A( y; U5 F

正确的做法是在调用处申请内存，并传入函数，如下：

1. 
   
2. 　　char *p=malloc（…）;
   
3. 　　if（p==NULL）
   
4. 　　…;
   
5. 　　（p）;
   ; y  p/ t& Z' y3 U
6. 　　…
   
7. 　　free（p）;
   
8. 　　p=NULL;

复制代码

. |4 g5 H+ q& \/ @' `而函数则接收参数p，如下：
  i( Q5 F3 P0 P7 |( C& _

1. 
   / n: \5 ?6 x$ j
2. 　　void （char *p）
   
3. 　　{
   # L/ `% C9 |# \! m- P; G
4. 　　… /* 一系列针对p的操作 */
   7 L; _0 q* N' b2 Y
5. 　　}

复制代码

) V" p0 i2 i- R% ?5 m基本上，动态申请内存方式可以用较大的数组替换。对于编程新手，笔者推荐你尽量采用数组！嵌入式系统可以以博大的胸襟接收瑕疵，而无法“海纳”错误。毕竟，以最笨的方式苦练神功的郭靖胜过机智聪明却范政治错误走反革命道路的杨康。
5 ^% p# o0 {! I; E" k
+ i  H9 s% T4 o+ a9 s
0 A0 k; a* |3 I' W2 G( A给出原则：


（1）尽可能的选用数组，数组不能越界访问（真理越过一步就是谬误，数组越过界限就光荣地成全了一个混乱的嵌入式系统）；
7 K* M- u$ U4 Q$ q) L) x* N（2）如果使用动态申请，则申请后一定要判断是否申请成功了，并且malloc和free应成对出现！
: @9 J0 ^: k5 S% N+ V" E

在嵌入式系统的编程中，常常要求在特定的内存单元读写内容，汇编有对应的MOV指令，而除C/C++以外的其它编程语言基本没有直接访问绝对地址的能力

% \, Z3 ]7 f, A  o0 S5 [
关键字constconst
7 `' Z) S; ~' }6 J

意味着“只读”。区别如下代码的功能非常重要，也是老生长叹，如果你还不知道它们的区别，而且已经在程序界摸爬滚打多年，那只能说这是一个悲哀：

1. 
   , i, c  I6 G" ]& w9 k8 y" K0 h
2. 　　const int a;
   
3. 　　int const a;
   
4. 　　const int *a;
   1 @& m, }! z' C' F$ q4 E% r- a
5. 　　int * const a;
   8 g: _: {5 B/ h0 B2 Z
6. 　　int const * a const;

复制代码

* D/ z: _7 F0 V4 T! E（1） 关键字const的作用是为给读你代码的人传达非常有用的信息。例如，在函数的形参前添加const关键字意味着这个参数在函数体内不会被修改，属于“输入参数”。在有多个形参的时候，函数的调用者可以凭借参数前是否有const关键字，清晰的辨别哪些是输入参数，哪些是可能的输出参数。
4 p& D* f. J0 T" H) Z( t% g
9 a6 D& `1 Q) C8 [1 ~' a, O+ |3 i
（2）合理地使用关键字const可以使编译器很自然地保护那些不希望被改变的参数，防止其被无意的代码修改，这样可以减少bug的出现。
! k: J8 B1 f6 C. k' y% ?# b& v

const在C++语言中则包含了更丰富的含义，而在C语言中仅意味着：“只能读的普通变量”，可以称其为“不能改变的变量”（这个说法似乎很拗口，但却最准确的表达了C语言中const的本质），在编译阶段需要的常数仍然只能以#define宏定义！故在C语言中如下程序是非法的：

1. <font color="#003000">
   0 D" p3 t6 b, D& f* r5 I
2. 　　const int SIZE = 10;
   
3. 　　char a［SIZE］; /* 非法：编译阶段不能用到变量 */
   
4. 　　关键字volaTIle
   8 S4 `/ q: F6 E6 h/ Z
5. 　　C语言编译器会对用户书写的代码进行优化，譬如如下代码：
   % D% f, p  q. u; _. D4 i9 G. T
6. 　　int a，b，c;
   
7. 　　a = inWord（0x100）; /*读取I/O空间0x100端口的内容存入a变量*/
   
8. 　　b = a;
   
9. 　　a = inWord （0x100）; /*再次读取I/O空间0x100端口的内容存入a变量*/
   
10. 　　c = a;</font>
    

复制代码

　　很可能被编译器优化为：

1. 
   
2. 　　int a，b，c;
   6 G) R- @5 U  ]( t9 W) K
3. 　　a = inWord（0x100）; /*读取I/O空间0x100端口的内容存入a变量*/
   " c; ]' W5 e7 A0 v) O/ f! \
4. 　　b = a;
   ) I$ }- s, S5 O5 d; f; r# X/ a
5. 　　c = a;

复制代码

但是这样的优化结果可能导致错误，如果I/O空间0x100端口的内容在执行第一次读操作后被其它程序写入新值，则其实第2次读操作读出的内容与第一次不同，b和c的值应该不同。在变量a的定义前加上volaTIle关键字可以防止编译器的类似优化，正确的做法是：
7 k8 f* t1 n( i) I/ d6 w1 c" ^

1. 
   
2. 　　volatile int a；

复制代码

volatile变量可能用于如下几种情况：
% y. ?% f0 w6 L# R+ U

（1） 并行设备的硬件寄存器（如：状态寄存器，例中的代码属于此类）；
& C) X' d- J) f" C（2） 一个中断服务子程序中会访问到的非自动变量（也就是全局变量）；
（3） 多线程应用中被几个任务共享的变量。


0 ^3 l/ _+ t/ N' T# x1 b+ _! o2 g+ [7 ]CPU字长与存储器位宽不一致处理
$ h# j4 Y5 R. m' r! p8 u2 B7 _; C0 Y
" |. h5 e  ?+ `+ h% U. T& b8 _
" c/ ~2 t& _5 w: d4 _$ |/ q在背景篇中提到，本文特意选择了一个与CPU字长不一致的存储芯片，就是为了进行本节的讨论，解决CPU字长与存储器位宽不一致的情况。80186的字长为16，而NVRAM的位宽为8，在这种情况下，我们需要为NVRAM提供读写字节、字的接口，如下：
6 C  M& A1 P( o2 w% q, s: e& ]3 Y

1. 
   
2. 　　typedef unsigned char BYTE;
   
3. 　　typedef unsigned int WORD;
   
4. 　　/* 函数功能：读NVRAM中字节
   
5. 　　* 参数：wOffset，读取位置相对NVRAM基地址的偏移
   0 q, W- Z4 v- Z6 ]9 b1 P
6. 　　* 返回：读取到的字节值
   ' M$ B' h8 y2 J  o4 m
7. 　　*/
   3 n4 B* Y  L# Y! U
8. 　　extern BYTE ReadByteNVRAM（WORD wOffset）
   
9. 　　{
   
10. 　　LPBYTE lpAddr = （BYTE*）（NVRAM + wOffset * 2）; /* 为什么偏移要×2？ */
    9 l. c( z- B/ V. ~2 m+ @" }% G- g
11. 　　return *lpAddr;
    / c, G0 X- p) U$ e5 g3 @
12. 　　}
    
13. 　　/* 函数功能：读NVRAM中字
    
14. 　　* 参数：wOffset，读取位置相对NVRAM基地址的偏移
    0 [2 E& U8 C! S) l, j( S8 H
15. 　　* 返回：读取到的字
    7 ^# V8 o: Q8 W# W: C  [& D
16. 　　*/
    ) T5 z0 z+ l# A/ k
17. 　　extern WORD ReadWordNVRAM（WORD wOffset）
    
18. 　　{
    
19. 　　WORD wTmp = 0;
    5 \# H) \' w" p6 W0 D, }
20. 　　LPBYTE lpAddr;
    " {* N# y* g# d- U2 F
21. 　　/* 读取高位字节 */
    
22. 　　lpAddr = （BYTE*）（NVRAM + wOffset * 2）; /* 为什么偏移要×2？ */
    1 P( k  Y1 k: }. ^  Q6 |
23. 　　wTmp += （*lpAddr）*256;
    1 c5 T# n- O; j0 z" Y" ]* p
24. 　　/* 读取低位字节 */
    ' ]9 ^4 s: Z" t
25. 　　lpAddr = （BYTE*）（NVRAM + （wOffset +1） * 2）; /* 为什么偏移要×2？ */
    # \; G  y. o- `. O+ }  W: t! {
26. 　　wTmp += *lpAddr;
    - e# [* V: z6 z7 ]) _& |% W
27. 　　return wTmp;
    0 s0 p1 Y0 _" {: ~/ Y  r
28. 　　}
    
29. 　　/* 函数功能：向NVRAM中写一个字节
    
30. 　　*参数：wOffset，写入位置相对NVRAM基地址的偏移
    
31. 　　* byData，欲写入的字节
    ) m3 n3 _. g3 B
32. 　　*/
    3 W& Y6 m5 N! C7 W% s+ O% b  V" o% S& B
33. 　　extern void WriteByteNVRAM（WORD wOffset， BYTE byData）
    
34. 　　{
    
35. 　　…
    / n0 j! M- r0 b8 Y7 Q$ b( x
36. 　　}
    
37. 　　/* 函数功能：向NVRAM中写一个字 */
    
38. 　　*参数：wOffset，写入位置相对NVRAM基地址的偏移
      G+ w) y: O& {, }, d: l  s  m
39. 　　* wData，欲写入的字
    ) B5 H5 [+ X2 I  J  @0 {* J
40. 　　*/
    7 W/ p: ^, [, \$ |/ Y7 @" A! s
41. 　　extern void WriteWordNVRAM（WORD wOffset， WORD wData）
    
42. 　　{
    . Y; u0 Y* r4 A/ V
43. 　　…
    
44. 　　}

复制代码

. ^3 \0 A2 r3 t" p- P+ r子贡问曰：Why偏移要乘以2？

# t5 E  _$ _% l) t8 X! U
子曰：16位80186与8位NVRAM之间互连只能以地址线A1对其A0，CPU本身的A0与NVRAM不连接。因此，NVRAM的地址只能是偶数地址，故每次以0x10为单位前进！

4 L0 y3 N2 K; o
$ V- M: W3 w" m; k, q. U; t  q' \子贡再问：So why 80186的地址线A0不与NVRAM的A0连接？


) ]/ _7 p7 w& U: r! C7 B+ u子曰：请看《IT论语》之《微机原理篇》，那里面讲述了关于计算机组成的圣人之道。
' n( O% G. C# m" ~5 V* ?

7 u' L# y1 Z7 F+ b  q总结


  f* R" k  ^% L7 J: Z( d本篇主要讲述了嵌入式系统C编程中内存操作的相关技巧。掌握并深入理解关于数据指针、函数指针、动态申请内存、const及volatile关键字等的相关知识，是一个优秀的C语言程序设计师的基本要求。当我们已经牢固掌握了上述技巧后，我们就已经学会了C语言的99%，因为C语言最精华的内涵皆在内存操作中体现。


我们之所以在嵌入式系统中使用C语言进行程序设计，99%是因为其强大的内存操作能力！

6 s7 k& ~# H/ Q  F
如果你爱编程，请你爱C语言；
" n' z$ `1 M4 F0 v  I如果你爱C语言，请你爱指针；
如果你爱指针，请你爱指针的指针！
( n- N1 m5 d+ I& R" |" V  p. m
8 {" p2 T1 N# E
C语言嵌入式系统编程注意事项之屏幕操作


, v6 r7 ]% [. B. X. |! ^+ i* n现在要解决的问题是，嵌入式系统中经常要使用的并非是完整的汉字库，往往只是需要提供数量有限的汉字供必要的显示功能

0 U6 P. ]  e1 V. t  I) s, V
汉字处理

6 A1 j2 I/ a9 R
+ {! n. t1 y- A$ ?8 F% i. G' ~  v' X现在要解决的问题是，嵌入式系统中经常要使用的并非是完整的汉字库，往往只是需要提供数量有限的汉字供必要的显示功能。例如，一个微波炉的LCD上没有必要提供显示“电子邮件”的功能；一个提供汉字显示功能的空调的LCD上不需要显示一条“短消息”，诸如此类。但是一部手机、小灵通则通常需要包括较完整的汉字库。
3 i* y* Q$ v" W: s( C( p) `8 z

如果包括的汉字库较完整，那么，由内码计算出汉字字模在库中的偏移是十分简单的：汉字库是按照区位的顺序排列的，前一个字节为该汉字的区号，后一个字节为该字的位号。每一个区记录94个汉字，位号则为该字在该区中的位置。因此，汉字在汉字库中的具体位置计算公式为：94*（区号-1）+位号-1。减1是因为数组是以0为开始而区号位号是以1为开始的。只需乘上一个汉字字模占用的字节数即可，即：（94*（区号-1）+位号-1）*一个汉字字模占用字节数，以16*16点阵字库为例，计算公式则为：（94*（区号-1）+（位号-1））*32。汉字库中从该位置起的32字节信息记录了该字的字模信息。
$ T% \6 A6 }9 K4 @9 k- C

' B( ?: e3 K- ^' R) o) X3 U. Q对于包含较完整汉字库的系统而言，我们可以以上述规则计算字模的位置。但是如果仅仅是提供少量汉字呢？譬如几十至几百个？最好的做法是：
, E4 ]% I4 a" f7 Z4 D

' F) m/ y9 v7 j% {2 ]0 o# g定义宏：

1. 
   ' E# }, r2 a# T8 K1 P7 m
2. 　　# define EX_FONT_CHAR（）
   7 |& L! t4 }7 _/ C) Q
3. 　　# define EX_FONT_UNICODE_VAL（） （），
   
4. 　　# define EX_FONT_ANSI_VAL（） （），

复制代码

% F3 _8 Q+ W5 s7 K
8 g9 }8 C, e. I( @1 e: s定义结构体：

1. <font color="#003000">
     u7 z7 l7 c9 T  c" j: [
2. 　　typedef struct _wide_unicode_font16x16
   . o" B" f, h0 T" a7 A' n
3. 　　{
   7 ~! L, u& M8 U7 u0 F
4. 　　WORD ; /* 内码 */
   & {6 C1 {% H- V& W( N2 W: b5 d
5. 　　BYTE data［32］; /* 字模点阵 */
   8 n) ?  L: R# a; T& n
6. 　　}Unicode;
   
7. </font><div><font color="#003000">　　#define CHINESE_CHAR_NUM … /* 汉字数量 */</font></div><div><font color="#003000"><b><font face="Tahoma">
   
8. </font></b></font></div>

复制代码

5 n3 m3 b3 c; p6 O

字模的存储用数组：

1. 
   
2. 　　Unicode chinese［CHINESE_CHAR_NUM］ =
   ) D  n6 O9 G) g7 O) c
3. 　　{
   
4. 　　{
   0 g3 M' N$ _3 ]3 B8 ~1 J9 T; d+ W
5. 　　EX_FONT_CHAR（“业”）
   
6. 　　EX_FONT_UNICODE_VAL（0x4e1a）
   ! }4 u' i! x9 N
7. 　　{0x04， 0x40， 0x04， 0x40， 0x04， 0x40， 0x04， 0x44， 0x44， 0x46， 0x24， 0x4c， 0x24， 0x48， 0x14， 0x50， 0x1c， 0x50， 0x14， 0x60， 0x04， 0x40， 0x04， 0x40， 0x04， 0x44， 0xff， 0xfe， 0x00， 0x00， 0x00， 0x00}
   
8. 　　}，
   & E* w" D" U4 m
9. 　　{
   ; |5 l& O) ^0 p. \8 k) ~
10. 　　EX_FONT_CHAR（“中”）
    
11. 　　EX_FONT_UNICODE_VAL（0x4e2d）
    ; Q& l& L; U" h/ @
12. 　　{0x01， 0x00， 0x01， 0x00， 0x21， 0x08， 0x3f， 0xfc， 0x21， 0x08， 0x21， 0x08， 0x21， 0x08， 0x21， 0x08， 0x21， 0x08，
    
13. 　　0x3f， 0xf8， 0x21， 0x08， 0x01， 0x00， 0x01， 0x00， 0x01， 0x00， 0x01， 0x00， 0x01， 0x00}
    8 I+ k8 p$ {1 k( {7 U6 Z' H8 C% e
14. 　　}，
    
15. 　　{
    
16. 　　EX_FONT_CHAR（“云”）
    
17. 　　EX_FONT_UNICODE_VAL（0x4e91）
    6 m  j, \; j# P9 V# }- {" W8 I* u
18. 　　{0x00， 0x00， 0x00， 0x30， 0x3f， 0xf8， 0x00， 0x00， 0x00， 0x00， 0x00， 0x0c， 0xff， 0xfe， 0x03， 0x00， 0x07， 0x00，
    2 H. e1 Z/ L) i! Y* d9 {. T% y
19. 　　0x06， 0x40， 0x0c， 0x20， 0x18， 0x10， 0x31， 0xf8， 0x7f， 0x0c， 0x20， 0x08， 0x00， 0x00}
    
20. 　　}，
    
21. 　　{
    
22. 　　EX_FONT_CHAR（“件”）
    
23. 　　EX_FONT_UNICODE_VAL（0x4ef6）
    
24. 　　{0x10， 0x40， 0x1a， 0x40， 0x13， 0x40， 0x32， 0x40， 0x23， 0xfc， 0x64， 0x40， 0xa4， 0x40， 0x28， 0x40， 0x2f， 0xfe，
    # k6 M5 ^1 A  F  T' _" }
25. 　　0x20， 0x40， 0x20， 0x40， 0x20， 0x40， 0x20， 0x40， 0x20， 0x40， 0x20， 0x40， 0x20， 0x40}
    % J, }" B3 }* l: \# c/ E7 q
26. 　　}
    9 n$ F4 W& a& Q/ f4 A
27. 　　}

复制代码

要显示特定汉字的时候，只需要从数组中查找内码与要求汉字内码相同的即可获得字模。如果前面的汉字在数组中以内码大小顺序排列，那么可以以二分查找法更高效的查找到汉字的字模。
5 U2 V7 p0 J3 x! ^# Z4 I
8 |" g4 K" l1 ~7 f( Y
这是一种很有效的组织小汉字库的方法，它可以保证程序有很好的结构。


系统时间显示

3 O- Z* P/ Y2 W5 J% \
从NVRAM中可以读取系统的时间，系统一般借助NVRAM产生的秒中断每秒读取一次当前时间并在LCD上显示。关于时间的显示，有一个效率问题。因为时间有其特殊性，那就是60秒才有一次分钟的变化，60分钟才有一次小时变化，如果我们每次都将读取的时间在屏幕上完全重新刷新一次，则浪费了大量的系统时间。
% ~1 T% {7 H% m5 J, {) y' n0 w

9 |$ M1 K& r* q$ N一个较好的办法是我们在时间显示函数中以静态变量分别存储小时、分钟、秒，只有在其内容发生变化的时候才更新其显示。
1 A' ~& A' D6 t9 \' q6 a

1. 
   ) T' }5 H. i- _3 n
2. 　　extern void DisplayTime（…）
   6 i* P1 c8 P+ @1 n: k0 L) Q
3. 　　{
   
4. 　　static BYTE byHour，byMinute，bySecond;
   
5. 　　BYTE byNewHour， byNewMinute， byNewSecond;
   , v: z& h, X7 k8 w: {; N3 g' I
6. 　　byNewHour = GetSysHour（）;
   
7. 　　byNewMinute = GetSysMinute（）;
   
8. 　　byNewSecond = GetSysSecond（）;
   9 ~- A4 u' j0 A/ t
9. 　　if（byNewHour！= byHour）
   
10. 　　{
    
11. 　　… /* 显示小时 */
    ' J; \: s; a+ P! K0 w8 \2 d9 h
12. 　　byHour = byNewHour;
    1 y! P9 i$ d1 ^' q. J* _- o
13. 　　}
    + s8 o/ c* S0 |. o$ B1 |3 d
14. 　　if（byNewMinute！= byMinute）
    " W* z6 l  |: s& W
15. 　　{
    - t& ]3 K) _7 B9 J
16. 　　… /* 显示分钟 */
    # G9 }8 ?$ m( u5 [
17. 　　byMinute = byNewMinute;
    9 }/ C, F5 T7 d- t! M( z
18. 　　}
    
19. 　　if（byNewSecond！= bySecond）
    
20. 　　{
    
21. 　　… /* 显示秒钟 */
    
22. 　　bySecond = byNewSecond;
    ( p- p3 x! H2 v$ u% t4 ]
23. 　　}
    + e6 p1 [9 c5 f$ P6 F, z" N
24. 　　}

复制代码

这个例子也可以顺便作为C语言中static关键字强大威力的证明。当然，在C++语言里，static具有了更加强大的威力，它使得某些数据和函数脱离“对象”而成为“类”的一部分，正是它的这一特点，成就了软件的无数优秀设计。
: T7 w" Y! Q! o9 u

/ g+ `# {6 Q! o6 X/ C- B7 G动画显示
% v, j7 Y9 R4 Q' b# v
7 \# q" j9 k8 V  C9 A: Y. S
动画是无所谓有，无所谓无的，静止的画面走的路多了，也就成了动画。随着时间的变更，在屏幕上显示不同的静止画面，即是动画之本质。所以，在一个嵌入式系统的LCD上欲显示动画，必须借助定时器。没有硬件或软件定时器的世界是无法想像的：
) Y/ a* ~$ x+ [# f+ z  F$ L( M8 \) N

（1） 没有定时器，一个操作系统将无法进行时间片的轮转，于是无法进行多任务的调度，于是便不再成其为一个多任务操作系统；
（2） 没有定时器，一个多媒体播放软件将无法运作，因为它不知道何时应该切换到下一帧画面；
$ P8 E2 ]; i* H（3） 没有定时器，一个网络协议将无法运转，因为其无法获知何时包传输超时并重传之，无法在特定的时间完成特定的任务。
$ R! p, n3 v, X. D

! a3 B/ x* M% U( {0 W: h因此，没有定时器将意味着没有操作系统、没有网络、没有多媒体，这将是怎样的黑暗？所以，合理并灵活地使用各种定时器，是对一个软件人的最基本需求！


+ x; m; ]$ t, I1 J' T& P在80186为主芯片的嵌入式系统中，我们需要借助硬件定时器的中断来作为软件定时器，在中断发生后变更画面的显示内容。在时间显示“xx:xx”中让冒号交替有无，每次秒中断发生后，需调用ShowDot：
4 z5 x# t% ~( e1 C3 g
( r0 i0 K/ x" T; B

1. 
   
2. 　　void ShowDot（）
   ) `# y' L0 S! C& P4 e
3. 　　{
   / i2 G* _/ ?) G' E8 {2 l
4. 　　static BOOL bShowDot = TRUE; /* 再一次领略static关键字的威力 */
   + n: G9 I1 u1 d2 Q
5. 　　if（bShowDot）
   & r2 E3 T& w8 m* [
6. 　　{
   
7. 　　showChar（’：’，xPos，yPos）;
   " Q6 o3 b2 Y( \: |) R/ F- c9 w
8. 　　}
   6 ~$ q. c7 {1 u  E8 i4 l  x6 V
9. 　　else
   9 b: A5 o* e* Z( s! r) U% e8 c
10. 　　{
    
11. 　　showChar（’ ’，xPos，yPos）;
    
12. 　　}
    
13. 　　bShowDot = ！ bShowDot;
    1 V1 r  j8 m8 L  E6 Z+ g! ~
14. 　　}

复制代码

菜单操作
- q6 e) P5 N1 e2 j( `& n& i
! L. N& s( G5 ~4 G6 O  B9 U  J
. h6 A  w9 X! i无数人为之绞尽脑汁的问题终于出现了，在这一节里，我们将看到，在C语言中哪怕用到一丁点的面向对象思想，软件结构将会有何等的改观！

+ P; G5 n% J+ p$ X$ V) N
! W3 Q! Z- r( l/ i4 O要求以键盘上的“← →”键切换菜单焦点，当用户在焦点处于某菜单时，若敲击键盘上的OK、CANCEL键则调用该焦点菜单对应之处理函数。我曾经傻傻地这样做着：
6 m2 c  A" x/ A5 w

1. 
   ; n+ u: t2 f% T- z
2. 　　/* 按下OK键 */
   ) ~1 r6 V, }) }1 ~  H! X
3. 　　void onOkKey（）
   ) _# |7 e2 V- ~5 W
4. 　　{
   
5. 　　/* 判断在什么焦点菜单上按下Ok键，调用相应处理函数 */
   
6. 　　Switch（currentFocus）
   
7. 　　{
   ) L( p& j# N: U0 t7 s
8. 　　case MENU1：
   * P: [. j( x9 i% c% h1 A$ q3 }
9. 　　menu1OnOk（）;
   2 m" g% m/ L: F. `. m
10. 　　break;
    " ?; q, k& N1 C5 j/ I7 U" O, U6 h
11. 　　case MENU2：
    
12. 　　menu2OnOk（）;
    
13. 　　break;
    " `+ A# w) c1 I8 z6 G
14. 　　…
    
15. 　　}
    
16. 　　}
    " E* k" D0 J/ V  ^
17. 　　/* 按下Cancel键 */
    
18. 　　void onCancelKey（）
    1 {8 y1 m* i& ~
19. 　　{
    
20. 　　/* 判断在什么焦点菜单上按下Cancel键，调用相应处理函数 */
    
21. 　　Switch（currentFocus）
    
22. 　　{
    ) o- h# |! m1 k
23. 　　case MENU1：
    
24. 　　menu1OnCancel（）;
    , n* g, A8 H4 E6 G5 j7 c0 G
25. 　　break;
    
26. 　　case MENU2：
    
27. 　　menu2OnCancel（）;
    3 K# p" [, v; ^1 c( Y& n5 A" f
28. 　　break;
    8 c  @2 c" S& X4 j* U$ h  I
29. 　　…
    
30. 　　}
    
31. 　　}
    7 }  C3 B* S, g/ x4 e7 y
32. 　　终于有一天，我这样做了：
    & r9 C  U' I& R" i* ~5 `
33. 　　/* 将菜单的属性和操作“封装”在一起 */
    2 M" A" Y: o" }+ f. h, t$ g+ x6 j/ `
34. 　　typedef struct tagSysMenu
    2 c1 x5 l& }* M# [; J: _* S" K
35. 　　{
    
36. 　　char *text; /* 菜单的文本 */
    5 d9 a. s, ?- _4 d6 X$ g9 u8 n# h7 B
37. 　　BYTE xPos; /* 菜单在LCD上的x坐标 */
    
38. 　　BYTE yPos; /* 菜单在LCD上的y坐标 */
    
39. 　　void （*onOkFun）（）; /* 在该菜单上按下ok键的处理函数指针 */
    
40. 　　void （*onCancelFun）（）; /* 在该菜单上按下cancel键的处理函数指针 */
    , n5 T3 L# t2 j5 J% R2 @3 z; _
41. 　　}SysMenu， *LPSysMenu;
    - y; H# p7 e3 }& y1 g
42. 当我定义菜单时，只需要这样：
    % a* q0 t/ }$ i+ o, X% _
43. 　　static SysMenu menu［MENU_NUM］ =
    
44. 　　{
    2 L/ e* d# B; D6 y5 H
45. 　　{
    6 ]6 p, _6 f. J: N* K0 f1 r5 g5 P
46. 　　“menu1”， 0， 48， menu1OnOk， menu1OnCancel
    * _& W6 Z; n0 X3 a# l8 \9 R
47. 　　}
    
48. 　　，
    
49. 　　{
    
50. 　　“ menu2”， 7， 48， menu2OnOk， menu2OnCancel
    
51. 　　}
    + ]+ t* V6 Y0 Z  r7 R
52. 　　，
    " L' h# g3 p4 ^: e3 t5 `0 a
53. 　　{
    2 {6 p: d+ D* q: O1 ?
54. 　　“ menu3”， 7， 48， menu3OnOk， menu3OnCancel
    7 z. s6 [; D6 `, s& E5 q9 r
55. 　　}
    
56. 　　，
    " i9 d, K3 O% z* A0 C0 d. Y
57. 　　{
    ! x/ K/ f" \  r; ^
58. 　　“ menu4”， 7， 48， menu4OnOk， menu4OnCancel
    
59. 　　}
    
60. 　　…
    4 t) b" m( G# {+ N% S
61. 　　};
    
62. OK键和CANCEL键的处理变成：
    
63. 　　/* 按下OK键 */
    : Z. j: X" K6 e: \3 {
64. 　　void onOkKey（）
    ( m5 a9 j( j+ j) r
65. 　　{
    
66. 　　menu［currentFocusMenu］.onOkFun（）;
    
67. 　　}
    
68. 　　/* 按下Cancel键 */
    
69. 　　void onCancelKey（）
    
70. 　　{
    ( `: x0 m) F9 s, a0 t' Q
71. 　　menu［currentFocusMenu］.onCancelFun（）;
    . [) F# C7 `1 \  _% g8 x/ _5 k
72. 　　}

复制代码

程序被大大简化了，也开始具有很好的可扩展性！我们仅仅利用了面向对象中的封装思想，就让程序结构清晰，其结果是几乎可以在无需修改程序的情况下在系统中添加更多的菜单，而系统的按键处理函数保持不变。


: D* Q4 }3 b/ D9 E1 m/ A$ q面向对象，真神了！
6 E! f' W$ _( \4 ]' k
2 v, {! U: n# Y
+ Q9 B. |1 y$ D! J模拟MessageBox函数
9 u: V* V5 b% b
5 T( C7 v, K4 K. h  u8 o
MessageBox函数，这个Windows编程中的超级猛料，不知道是多少入门者第一次用到的函数。还记得我们第一次在Windows中利用MessageBox输出 “Hello，World！”对话框时新奇的感觉吗？无法统计，这个世界上究竟有多少程序员学习Windows编程是从MessageBox（“Hello，World！”，…）开始的。在我本科的学校，广泛流传着一个词汇，叫做“’Hello，World’级程序员”，意指入门级程序员，但似乎“’Hello，World’级”这个说法更搞笑而形象。
4 ^: L- a% L, _% G& C9 K# p4 Y  e) ^

嵌入式系统中没有给我们提供MessageBox，但是鉴于其功能强大，我们需要模拟之，一个模拟的MessageBox函数为：

1. 
   
2. 　　/******************************************
   4 u* N/ W* V' u
3. 　　/* 函数名称： MessageBox
   
4. 　　/* 功能说明： 弹出式对话框，显示提醒用户的信息
   " K9 m" H7 o; i
5. 　　/* 参数说明： lpStr --- 提醒用户的字符串输出信息
   
6. 　　/* TYPE --- 输出格式（ID_OK = 0， ID_OKCANCEL = 1）
   
7. 　　/* 返回值： 返回对话框接收的键值，只有两种 KEY_OK， KEY_CANCEL
   
8. 　　/******************************************
   
9. 　　typedef enum TYPE { ID_OK，ID_OKCANCEL }MSG_TYPE;
   
10. 　　extern BYTE MessageBox（LPBYTE lpStr， BYTE TYPE）
    ! a6 A5 f' y3 t9 L0 O7 }$ @$ W
11. 　　{
    : B: P: @! j$ m2 A0 G  s; Z5 B2 N
12. 　　BYTE key = -1;
    
13. 　　ClearScreen（）; /* 清除屏幕 */
    $ t, p" r4 N8 n, z, w; Y  S
14. 　　DisplayString（xPos，yPos，lpStr，TRUE）; /* 显示字符串 */
    
15. 　　/* 根据对话框类型决定是否显示确定、取消 */
    
16. 　　switch （TYPE）
    
17. 　　{
    
18. 　　case ID_OK：
    : V: \4 M3 S9 d( V; q
19. 　　DisplayString（13，yPos+High+1， “ 确定 ”， 0）;
    
20. 　　break;
    
21. 　　case ID_OKCANCEL：
    
22. 　　DisplayString（8， yPos+High+1， “ 确定 ”， 0）;
    , ?) ^6 t: f- ?( P/ f" Z
23. 　　DisplayString（17，yPos+High+1， “ 取消 ”， 0）;
    
24. 　　break;
    
25. 　　default：
    
26. 　　break;
    
27. 　　}
    , a" |2 m7 D, c: X5 |8 E
28. 　　DrawRect（0， 0， 239， yPos+High+16+4）; /* 绘制外框 */
    3 @. A7 x# N$ u/ X  G/ E* [
29. 　　/* MessageBox是模式对话框，阻塞运行，等待按键 */
    
30. 　　while（ （key ！= KEY_OK） || （key ！= KEY_CANCEL） ）
    
31. 　　{
    0 j7 ~6 X- a. M5 {; K2 ~% A- }9 M9 N! m
32. 　　key = getSysKey（）;
    
33. 　　}
    , y6 U8 G1 ^5 ]# _
34. 　　/* 返回按键类型 */
    
35. 　　if（key== KEY_OK）
    4 V5 q# g4 h8 c1 y
36. 　　{
    
37. 　　return ID_OK;
    $ l1 p9 H5 ?, V2 @; ?( l- }& _8 M
38. 　　}
    9 O4 J0 Q7 }! w; m
39. 　　else
    
40. 　　{
    
41. 　　return ID_CANCEL;
    
42. 　　}
    
43. 　　}

复制代码

上述函数与我们平素在VC++等中使用的MessageBox是何等的神似啊？实现这个函数，你会看到它在嵌入式系统中的妙用是无穷的。
3 C, j$ G) |# d  @& e
8 o- ^1 K  ?: a


; y& P: W: ]8 z! k% z: I* m1 Y9 D总结


本篇是本系列文章中技巧性最深的一篇，它提供了嵌入式系统屏幕显示方面一些很巧妙的处理方法，灵活使用它们，我们将不再被LCD上凌乱不堪的显示内容所困扰。

& J3 W) Z% o9 L  v4 w
2 u: E1 i. _. t/ q! p+ O! t1 X& P; y屏幕乃嵌入式系统生存之重要辅助，面目可憎之显示将另用户逃之夭夭。屏幕编程若处理不好，将是软件中最不系统、最混乱的部分，笔者曾深受其害。
$ y0 t- q4 g; w

C语言嵌入式系统编程注意事项之键盘操作


处理功能键
- o  t6 k0 m8 u* W! H+ R
+ K3 T$ o5 e0 q0 ^' F
$ m. u( n3 J" V: Z+ ~. r让我们来看看WIN32编程中用到的“窗口”概念，当消息（message）被发送给不同窗口的时候，该窗口的消息处理函数（是一个callback函数）最终被调用，而在该窗口的消息处理函数中，又根据消息的类型调用了该窗口中的对应处理函数。通过这种方式，WIN32有效的组织了不同的窗口，并处理不同窗口情况下的消息。


我们从中学习到的就是：
) V" E8 Y% H/ W9 z; C9 K
& n% @) Z; H! }2 a' I3 W& i7 \, o
（1）将不同的画面类比为WIN32中不同的窗口，将窗口中的各种元素（菜单、按钮等）包含在窗口之中；
（2）给各个画面提供一个功能键“消息”处理函数，该函数接收按键信息为参数；
（3）在各画面的功能键“消息”处理函数中，判断按键类型和当前焦点元素，并调用对应元素的按键处理函数。
1 A( T; F% a/ h+ `9 F; ?( O. N
5 q) N+ y5 O! K& N+ V* U5 X) l1 t3 C

1. 
   
2. 　　/* 将窗口元素、消息处理函数封装在窗口中 */
   9 E" w0 j+ f+ y
3. 　　struct windows
   % f, l5 _) e1 Z+ Y+ |
4. 　　{
   $ X2 `3 k( a2 `2 p8 |# w
5. 　　BYTE currentFocus;
   - Q8 X6 C/ c% {+ n7 d! U; s
6. 　　ELEMENT element［ELEMENT_NUM］;
   , x2 G8 p" A. W& t. `
7. 　　void （*messageFun） （BYTE key）;
   : X- K$ J/ w3 A) K% R$ _
8. 　　…
     E# |, R7 L+ ~& Y
9. 　　};
   
10. 　　/* 消息处理函数 */
    + O0 U  N' [1 n7 V4 o7 S5 s) F' x
11. 　　void message（BYTE key）
    
12. 　　{
    
13. 　　BYTE i = 0;
    
14. 　　/* 获得焦点元素 */
    
15. 　　while （ （element .ID！= currentFocus）&& （i 《 ELEMENT_NUM） ）
    
16. 　　{
    " g( d, o: e3 }% `1 ?0 A
17. 　　i++;
    
18. 　　}
    $ _3 h. e: B$ u; s) |  C3 X
19. 　　/* “消息映射” */
    2 X  v' b) j; p
20. 　　if（i 《 ELEMENT_NUM）
    
21. 　　{
    
22. 　　switch（key）
    
23. 　　{
    0 p6 y% D" g1 m
24. 　　case OK：
    3 l! u! `4 u8 A
25. 　　element.OnOk（）;
    0 e! \! Y3 w4 l! p2 l6 ]( T
26. 　　break;
    
27. 　　…
    
28. 　　}
    / r) E. I% X* a  G
29. 　　}
    
30. 　　}

复制代码

在窗口的消息处理函数中调用相应元素按键函数的过程类似于“消息映射”，这是我们从WIN32编程中学习到的。编程到了一个境界，很多东西都是相通的了。其它地方的思想可以拿过来为我所用，是为编程中的“拿来主义”。

% v2 v# {- N/ z- h  \! m
在这个例子中，如果我们还想玩得更大一点，我们可以借鉴MFC中处理MESSAGE_MAP的方法，我们也可以学习MFC定义几个精妙的宏来实现“消息映射”。
# y$ u" }7 n4 o! @0 R& ~
% j/ P% N: W5 u2 E! W
" G7 i$ A& m3 i' m处理数字键
! ]$ ?& ?/ H" ]& Y& I  L8 F

用户输入数字时是一位一位输入的，每一位的输入都对应着屏幕上的一个显示位置（x坐标，y坐标）。此外，程序还需要记录该位置输入的值，所以有效组织用户数字输入的最佳方式是定义一个结构体，将坐标和数值捆绑在一起：

; E8 N# I, w) W

1. <font color="#003000">
   ; R5 m& g7 N. M, S6 ?
2. 　　/* 用户数字输入结构体 */
   + L' h; b: W, p0 R' h' p+ C- {
3. 　　typedef struct tagInputNum
   9 m2 `$ v& z( c; R: j  W+ A- T
4. 　　{
   % A5 A! q  O% K5 o- M# T
5. 　　BYTE byNum; /* 接收用户输入赋值 */
   
6. 　　BYTE xPos; /* 数字输入在屏幕上的显示位置x坐标 */
   
7. 　　BYTE yPos; /* 数字输入在屏幕上的显示位置y坐标 */
   
8. </font><div><font color="#003000">　　}InputNum， *LPInputNum;</font></div><div><font color="#003000"><font face="Tahoma">
   
9. </font></font></div>

复制代码

那么接收用户输入就可以定义一个结构体数组，用数组中的各位组成一个完整的数字：

3 b4 p- M' o  a4 R3 j

1. 
   
2. 　　InputNum inputElement［NUM_LENGTH］; /* 接收用户数字输入的数组 */
   6 }/ ~3 T" m% a( n) o7 g
3. 　　/* 数字按键处理函数 */
   
4. 　　extern void onNumKey（BYTE num）
   
5. 　　{
   % M4 K6 c# v: y( ]
6. 　　if（num==0|| num==1） /* 只接收二进制输入 */
   
7. 　　{
   
8. 　　/* 在屏幕上显示用户输入 */
   1 w1 v# ^' \% c& J4 S  ?, g
9. 　　DrawText（inputElement［currentElementInputPlace］.xPos， inputElement［currentElementInputPlace］.yPos， “%1d”， num）;
   
10. 　　/* 将输入赋值给数组元素 */
    
11. 　　inputElement［currentElementInputPlace］.byNum = num;
    
12. 　　/* 焦点及光标右移 */
    
13. 　　moveToRight（）;
    
14. 　　}
    
15. 　　}

复制代码

" e0 d9 M" q3 v/ L
+ G. Y) ]! p( X# h0 T9 T  w将数字每一位输入的坐标和输入值捆绑后，在数字键处理函数中就可以较有结构的组织程序，使程序显得很紧凑。
' N8 T7 I. |/ ?( k5 h  C% G, D" A

整理用户输入
8 A2 a& j0 C; b" r! f% N6 |
1 j4 g; ]; m$ j9 f* |
* U& L2 K, s- X6 q  {+ Q继续第2节的例子，在第2节的onNumKey函数中，只是获取了数字的每一位，因而我们需要将其转化为有效数据，譬如要转化为有效的XXX数据，其方法是：

9 d% m5 J: k, L  K- p

1. 
   5 L2 k8 y% k1 }! L
2. 　　/* 从2进制数据位转化为有效数据：XXX */
   
3. 　　void convertToXXX（）
   
4. 　　{
   : x- E! e3 w8 |1 l' w
5. 　　BYTE i;
   3 H: K; i6 S, b: c% _2 M( L
6. 　　XXX = 0;
   
7. 　　for （i = 0; i 《 NUM_LENGTH; i++）
   
8. 　　{
   ; e8 }8 b6 V. U8 f/ m7 J
9. 　　XXX += inputElement.byNum*power（2， NUM_LENGTH - i - 1）;
   7 _1 s4 I- W+ V
10. 　　}
    
11. 　　}

复制代码

反之，我们也可能需要在屏幕上显示那些有效的数据位，因为我们也需要能够反向转化：

1. 
   
2. 　　/* 从有效数据转化为2进制数据位：XXX */
   $ X8 K  q7 T1 E* ^, J1 ?
3. 　　void convertFromXXX（）
   $ e: {7 _/ v) a% f) S+ ^- e8 S; _
4. 　　{
   4 V% k/ o) ~% _# ^: b8 @7 U6 f
5. 　　BYTE i;
   
6. 　　XXX = 0;
   
7. 　　for （i = 0; i 《 NUM_LENGTH; i++）
   8 k1 B% e, D4 F' S/ u2 _) v; W
8. 　　{
   
9. 　　inputElement.byNum = XXX / power（2， NUM_LENGTH - i - 1） % 2;
   
10. 　　}
    # y  e# B1 W# J8 @' C( a( c& t: b
11. 　　}

复制代码

当然在上面的例子中，因为数据是2进制的，用power函数不是很好的选择，直接用“《《 》》”移位操作效率更高，我们仅是为了说明问题的方便。试想，如果用户输入是十进制的，power函数或许是唯一的选择了。


总结
1 ~4 R9 o1 ~' p/ U+ s
/ v! V1 c7 k9 I, ?% m6 P( b$ m
4 p3 Z! K% U3 W+ u- i) b4 A本篇给出了键盘操作所涉及的各个方面：功能键处理、数字键处理及用户输入整理，基本上提供了一个全套的按键处理方案。对于功能键处理方法，将LCD屏幕与Windows窗口进行类比，提出了较新颖地解决屏幕、键盘繁杂交互问题的方案。

& o+ U+ P6 b2 `- l
计算机学的许多知识都具有相通性，因而，不断追赶时髦技术而忽略基本功的做法是徒劳无意的。我们最多需要“精通”三种语言（精通，一个在如今的求职简历里泛滥成灾的词语），最佳拍档是汇编、C、C++（或JAVA），很显然，如果你“精通”了这三种语言，其它语言你应该是可以很快“熟悉”的，否则你就没有“精通”它们。
4 w# z5 p% {8 U) D+ G' h) u- N' U8 n: A

C语言嵌入式系统编程注意事项之性能优化
" g5 o3 ~4 b" c% b% X" F

3 L! H6 ~! Z# ^8 G9 y& I在C语言中，宏是产生内嵌代码的唯一方法。对于嵌入式系统而言，为了能达到性能要求，宏是一种很好的代替函数的方法

* @# q% s' T) l& X
使用宏定义


在C语言中，宏是产生内嵌代码的唯一方法。对于嵌入式系统而言，为了能达到性能要求，宏是一种很好的代替函数的方法。

0 [: }" E4 B6 J7 `4 t2 \& q
9 P1 z# O8 o( m写一个“标准”宏MIN ，这个宏输入两个参数并返回较小的一个：


错误做法：
3 T$ m8 R9 H. ~0 U  t, a- `& g( j　　#define MIN（A，B） 　（ A 《= B ？ A ： B ）

+ m+ ^, d2 B/ k) a+ W
% B. v! W* o$ h1 l7 W" Q- u正确做法：
　　#define MIN（A，B） （（A）《= （B） ？ （A） ： （B） ）

9 j" ?2 W- O5 K7 k; C
0 X  b$ ], Y6 G; Q; e& W3 V对于宏，我们需要知道三点：


- ?0 E: `9 F! x, M（1）宏定义“像”函数；
) i8 L) ?' v$ o& I（2）宏定义不是函数，因而需要括上所有“参数”；
（3）宏定义可能产生副作用。


. n" T/ c; y# ~5 ~下面的代码：
6 ~8 L& r- t5 K8 o3 a　　least = MIN（*p++， b）;


5 h: S' H8 _6 Z+ u. Z! w将被替换为：
. r+ V" }& R1 [  ~( L! x0 J　　（ （*p++） 《= （b） ？（*p++）：（b） ）

$ z# m5 \, x% l
% |/ O8 u$ T' x. F发生的事情无法预料。因而不要给宏定义传入有副作用的“参数”。
- f& n) N% ~, _9 S# ~  {. O7 w, B2 A

使用寄存器变量


当对一个变量频繁被读写时，需要反复访问内存，从而花费大量的存取时间。为此，C语言提供了一种变量，即寄存器变量。这种变量存放在CPU的寄存器中，使用时，不需要访问内存，而直接从寄存器中读写，从而提高效率。寄存器变量的说明符是register。对于循环次数较多的循环控制变量及循环体内反复使用的变量均可定义为寄存器变量，而循环计数是应用寄存器变量的最好候选者。
8 Y9 [( P0 s2 o, V

$ w8 @4 Z3 c' O* K1 D8 Y（1） 只有局部自动变量和形参才可以定义为寄存器变量。因为寄存器变量属于动态存储方式，凡需要采用静态存储方式的量都不能定义为寄存器变量，包括：模块间全局变量、模块内全局变量、局部static变量；

. c! @! m  N& M- L
（2） register是一个“建议”型关键字，意指程序建议该变量放在寄存器中，但最终该变量可能因为条件不满足并未成为寄存器变量，而是被放在了存储器中，但编译器中并不报错（在C++语言中有另一个“建议”型关键字：inline）。
7 _' D+ t2 t- P2 G$ R+ e
: r3 z2 f& B; M$ X& ^$ m/ ?5 a5 b
下面是一个采用寄存器变量的例子：
! y) G. {7 {1 W+ b* |
6 i: }3 i. v! \. \$ t

1. <font color="#003000">
   
2. 　　/* 求1+2+3+….+n的值 */
   
3. 　　WORD Addition（BYTE n）
   % m' ?, J) U; P9 C6 W6 t+ G
4. 　　{
   1 s9 u, d, b7 O( n
5. 　　register i，s=0;
   
6. 　　for（i=1;i《=n;i++）
   
7. 　　{
   - C' s9 K$ C- d3 t3 b8 h
8. 　　s=s+i;
   2 N0 _# A: n$ T
9. 　　}
   
10. 　　return s;
    
11. 　　}</font>
    

复制代码

本程序循环n次，i和s都被频繁使用，因此可定义为寄存器变量。
7 g! ~8 y" L  Z. s2 _6 L4 u* Y# z

+ o) _; {3 R2 {- e9 O: B( `内嵌汇编
% Y+ R- m, J: d" |

, u' b8 e8 @- x程序中对时间要求苛刻的部分可以用内嵌汇编来重写，以带来速度上的显著提高。但是，开发和测试汇编代码是一件辛苦的工作，它将花费更长的时间，因而要慎重选择要用汇编的部分。
: T/ g# j. P. N9 T9 z5 J
3 j8 y6 W7 X7 ]0 a
在程序中，存在一个80-20原则，即20%的程序消耗了80%的运行时间，因而我们要改进效率，最主要是考虑改进那20%的代码。

0 n+ v  a$ R! x# C9 Q# L
嵌入式C程序中主要使用在线汇编，即在C程序中直接插入_asm{ }内嵌汇编语句：
& b7 ~; w# G  g. @
6 H. \* U( u/ d, u

1. 
   
2. 　　/* 把两个输入参数的值相加，结果存放到另外一个全局变量中 */
   
3. 　　int result;
   . p7 ]& x5 B: S' g
4. 　　void Add（long a， long *b）
   6 T8 j& w$ S" y( c
5. 　　{
   $ E# h. x7 M4 E, T1 \$ y
6. 　　_asm
   
7. 　　{
     h% `' @0 W6 q; \5 W& a/ B
8. 　　MOV AX， a
   
9. 　　MOV BX， b
   
10. 　　ADD AX， ［BX］
    
11. 　　MOV result， AX
    
12. 　　}
    + H5 G9 a1 Q2 z6 k
13. 　　}

复制代码

利用硬件特性


首先要明白CPU对各种存储器的访问速度，基本上是：
0 Y# Z6 E+ U9 H

( U  r1 g+ d  G3 k8 ?# |CPU内部RAM》外部同步RAM》外部异步RAM》FLASH/ROM
) o) W, j* D9 f, l
  r) H0 z+ e. Y8 a6 R9 a
对于程序代码，已经被烧录在FLASH或ROM中，我们可以让CPU直接从其中读取代码执行，但通常这不是一个好办法，我们最好在系统启动后将FLASH或ROM中的目标代码拷贝入RAM中后再执行以提高取指令速度；

$ e( U, n7 b! G: x
对于UART等设备，其内部有一定容量的接收BUFFER，我们应尽量在BUFFER被占满后再向CPU提出中断。例如计算机终端在向目标机通过RS-232传递数据时，不宜设置UART只接收到一个BYTE就向CPU提中断，从而无谓浪费中断处理时间；


: l' j" }) u% Q0 T9 c. q2 ?7 W( `% X如果对某设备能采取DMA方式读取，就采用DMA读取，DMA读取方式在读取目标中包含的存储信息较大时效率较高，其数据传输的基本单位是块，而所传输的数据是从设备直接送入内存的（或者相反）。DMA方式较之中断驱动方式，减少了CPU 对外设的干预，进一步提高了CPU与外设的并行操作程度。


活用位操作
$ E- @, O, l; r" ]/ U# o

使用C语言的位操作可以减少除法和取模的运算。在计算机程序中数据的位是可以操作的最小数据单位，理论上可以用“位运算”来完成所有的运算和操作，因而，灵活的位操作可以有效地提高程序运行的效率。举例如下：
9 F; h5 E8 O; k

1. 
   
2. 　　/* 方法1 */
   
3. 　　int i，j;
   3 U- B4 M( z- \4 u3 I
4. 　　i = 879 / 16;
   4 P# ~& x, w9 R) M/ z; U
5. 　　j = 562 % 32;
   5 M6 {8 L+ Z6 }% O8 Z
6. 　　/* 方法2 */
   4 x- ~0 s8 i2 O  }" }# d% V" E: s
7. 　　int i，j;
   ! Y3 y& W' M; n" D1 @
8. 　　i = 879 》》 4;
   & H# X; `! K  p: }' L: ?, e
9. 　　j = 562 - （562 》》 5 《《 5）;

复制代码

0 x6 z3 x- L5 y1 [对于以2的指数次方为“*”、“/”或“%”因子的数学运算，转化为移位运算“《《 》》”通常可以提高算法效率。因为乘除运算指令周期通常比移位运算大。
- |& \0 ]+ R4 L4 _! e
/ `1 S8 T6 O' P3 ~& P& O7 f
C语言位运算除了可以提高运算效率外，在嵌入式系统的编程中，它的另一个最典型的应用，而且十分广泛地正在被使用着的是位间的与（&）、或（|）、非（~）操作，这跟嵌入式系统的编程特点有很大关系。我们通常要对硬件寄存器进行位设置，譬如，我们通过将AM186ER型80186处理器的中断屏蔽控制寄存器的第低6位设置为0（开中断2），最通用的做法是：

3 d7 t7 c. A5 A) F# g* J+ n

1. 
   * a' P% i1 W# l7 D' w
2. 　　#define INT_I2_MASK 0x0040
   
3. 　　wTemp = inword（INT_MASK）;
   
4. 　　outword（INT_MASK， wTemp &~INT_I2_MASK）;
   
5. 　　而将该位设置为1的做法是：
   
6. 　　#define INT_I2_MASK 0x0040
   6 B  d6 K4 Z! N& ]7 R/ p
7. 　　wTemp = inword（INT_MASK）;
   
8. 　　outword（INT_MASK， wTemp | INT_I2_MASK）;

复制代码

判断该位是否为1的做法是：

1. 
   
2. 　　#define INT_I2_MASK 0x0040
   ( m8 W- |: M9 x% Q* m  o+ ]
3. 　　wTemp = inword（INT_MASK）;
   
4. 　　if（wTemp & INT_I2_MASK）
   
5. 　　{
   2 g- B  `& w+ j$ z- l
6. 　　… /* 该位为1 */
   
7. 　　}

复制代码

- ?% @! \3 r" ~9 U$ I0 j$ C上述方法在嵌入式系统的编程中是非常常见的，我们需要牢固掌握。

4 J  B/ v. Q: N
总结
- @4 H: \) L8 |" S' t/ Z. z

* e: S0 M: q* `) g9 C3 k, d, }在性能优化方面永远注意80-20准备，不要优化程序中开销不大的那80%，这是劳而无功的。

( z) c* h/ x1 \# j9 `. W
* Z' N. E$ R8 q! s; L7 o7 I宏定义是C语言中实现类似函数功能而又不具函数调用和返回开销的较好方法，但宏在本质上不是函数，因而要防止宏展开后出现不可预料的结果，对宏的定义和使用要慎而处之。很遗憾，标准C至今没有包括C++中inline函数的功能，inline函数兼具无调用开销和安全的优点。
/ N8 d+ J% }/ G/ t3 q- K& W# ~
6 Y3 w$ e: F. n/ U/ _! S
使用寄存器变量、内嵌汇编和活用位操作也是提高程序效率的有效方法。
2 O" L* y; `8 q+ c$ p
8 B. R" Q! Q3 f) e
除了编程上的技巧外，为提高系统的运行效率，我们通常也需要最大可能地利用各种硬件设备自身的特点来减小其运转开销，例如减小中断次数、利用DMA传输方式等。
, b3 L4 w+ P. ?5 Y0 v4 \. i  {

学习了

+ Z! H6 P0 }  `8 E( @8 Y" o; A学习了

非常赞

学习了

学习了