C语言嵌入式系统编程修炼[整理]

C语言嵌入式系统编程修炼

数据指针

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

　　(1) 某I/O芯片被定位在CPU的存储空间而非I/O空间，而且寄存器对应于某特定地址；

　　(2) 两个CPU之间以双端口RAM通信，CPU需要在双端口RAM的特定单元（称为mail box）书写内容以在对方CPU产生中断；

　　(3) 读取在ROM或FLASH的特定单元所烧录的汉字和英文字模。

　　譬如：

 

 

unsigned char *p = (unsigned char *)0xF000FF00;

*p=11;

 

 

 

　　以上程序的意义为在绝对地址0xF0000+0xFF00(80186使用16位段地址和16位偏移地址)写入11。

　　在使用绝对地址指针时，要注意指针自增自减操作的结果取决于指针指向的数据类别。上例中p++后的结果是p= 0xF000FF01，若p指向int，即：

 

 

int *p = (int *)0xF000FF00;

 

 

 

　　p++(或++p)的结果等同于：p = p+sizeof(int)，而p-(或-p)的结果是p = p-sizeof(int)。

　　同理，若执行：

 

 

long int *p = (long int *)0xF000FF00;

 

 

 

　　则p++(或++p)的结果等同于：p = p+sizeof(long int) ，而p-(或-p)的结果是p = p-sizeof(long int)。

　　记住：CPU以字节为单位编址，而C语言指针以指向的数据类型长度作自增和自减。理解这一点对于以指针直接操作内存是相当重要的。

　　函数指针

　　首先要理解以下三个问题：

　　（1）C语言中函数名直接对应于函数生成的指令代码在内存中的地址，因此函数名可以直接赋给指向函数的指针；

　　（2）调用函数实际上等同于"调转指令＋参数传递处理＋回归位置入栈"，本质上最核心的操作是将函数生成的目标代码的首地址赋给CPU的PC寄存器；

 

　　（3）因为函数调用的本质是跳转到某一个地址单元的code去执行，所以可以"调用"一个根本就不存在的函数实体，晕？请往下看：

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

 

 

typedef void (*lpFunction) ( ); /* 定义一个无参数、无返回类型的 */

/* 函数指针类型 */

lpFunction lpReset = (lpFunction)0xF000FFF0; /* 定义一个函数指针，指向*/

/* CPU启动后所执行第一条指令的位置 */

lpReset(); /* 调用函数 */

 

 

 

　　在以上的程序中，我们根本没有看到任何一个函数实体，但是我们却执行了这样的函数调用：lpReset()，它实际上起到了"软重启"的作用，跳转到CPU启动后第一条要执行的指令的位置。

　　记住：函数无它，唯指令集合耳；你可以调用一个没有函数体的函数，本质上只是换一个地址开始执行指令！

　　数组vs.动态申请

　　在嵌入式系统中动态内存申请存在比一般系统编程时更严格的要求，这是因为嵌入式系统的内存空间往往是十分有限的，不经意的内存泄露会很快导致系统的崩溃。

　　所以一定要保证你的malloc和free成对出现，如果你写出这样的一段程序：

 

 

char * function(void)

{

　char *p;

　p = (char *)malloc(…);

　if(p==NULL)

　　…;

　　… /* 一系列针对p的操作 */

　return p;

}

 

 

 

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

 

 

char *q = function();

…

free(q);

 

 

 

　　上述代码明显是不合理的，因为违反了malloc和free成对出现的原则，即"谁申请，就由谁释放"原则。不满足这个原则，会导致代码的耦合度增大，因为用户在调用function函数时需要知道其内部细节！

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

 

 

char *p=malloc(…);

if(p==NULL)

…;

function(p);

…

free(p);

p=NULL;

 

 

 

　　而函数function则接收参数p，如下：

 

 

void function(char *p)

{

　… /* 一系列针对p的操作 */

}

 

 

 

　　基本上，动态申请内存方式可以用较大的数组替换。对于编程新手，笔者推荐你尽量采用数组！嵌入式系统可以以博大的胸襟接收瑕疵，而无法"海纳"错误。毕竟，以最笨的方式苦练神功的郭靖胜过机智聪明却范政治错误走反革命道路的杨康。

　　给出原则：

　　（1）尽可能的选用数组，数组不能越界访问（真理越过一步就是谬误，数组越过界限就光荣地成全了一个混乱的嵌入式系统）；

　　（2）如果使用动态申请，则申请后一定要判断是否申请成功了，并且malloc和free应成对出现！

2、关键字const

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

 

 

const int a;

int const a;

const int *a;

int * const a;

int const * a const;

 

 

 

　　（1）关键字const的作用是为给读你代码的人传达非常有用的信息。例如，在函数的形参前添加const关键字意味着这个参数在函数体内不会被修改，属于"输入参数"。在有多个形参的时候，函数的调用者可以凭借参数前是否有const关键字，清晰的辨别哪些是输入参数，哪些是可能的输出参数。

 

　　（2）合理地使用关键字const可以使编译器很自然地保护那些不希望被改变的参数，防止其被无意的代码修改，这样可以减少bug的出现。

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

 

 

const int SIZE = 10;

char a[SIZE]; /* 非法：编译阶段不能用到变量 */

 

 

 

　　关键字volatile

 

　　C语言编译器会对用户书写的代码进行优化，譬如如下代码：

 

 

int a,b,c;

a = inWord(0x100); /*读取I/O空间0x100端口的内容存入a变量*/

b = a;

a = inWord (0x100); /*再次读取I/O空间0x100端口的内容存入a变量*/

c = a;

 

 

 

　　很可能被编译器优化为：

 

 

int a,b,c;

a = inWord(0x100); /*读取I/O空间0x100端口的内容存入a变量*/

b = a;

c = a;

 

 

 

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

 

 

volatile int a；

 

 

 

　　volatile变量可能用于如下几种情况：

　　(1) 并行设备的硬件寄存器（如：状态寄存器，例中的代码属于此类）；

　　(2) 一个中断服务子程序中会访问到的非自动变量(也就是全局变量)；

　　(3) 多线程应用中被几个任务共享的变量。

　　CPU字长与存储器位宽不一致处理

　　在背景篇中提到，本文特意选择了一个与CPU字长不一致的存储芯片，就是为了进行本节的讨论，解决CPU字长与存储器位宽不一致的情况。80186的字长为16，而NVRAM的位宽为8，在这种情况下，我们需要为NVRAM提供读写字节、字的接口，如下：

 

 

typedef unsigned char BYTE;

typedef unsigned int WORD;

/* 函数功能：读NVRAM中字节

* 参数：wOffset，读取位置相对NVRAM基地址的偏移

* 返回：读取到的字节值

*/

extern BYTE ReadByteNVRAM(WORD wOffset)

{

　LPBYTE lpAddr = (BYTE*)(NVRAM + wOffset * 2); /* 为什么偏移要×2? */

 

　return *lpAddr;

}

 

/* 函数功能：读NVRAM中字

* 参数：wOffset，读取位置相对NVRAM基地址的偏移

* 返回：读取到的字

*/

extern WORD ReadWordNVRAM(WORD wOffset)

{

　WORD wTmp = 0;

　LPBYTE lpAddr;

　/* 读取高位字节 */

　lpAddr = (BYTE*)(NVRAM + wOffset * 2); /* 为什么偏移要×2? */

　wTmp += (*lpAddr)*256;

　/* 读取低位字节 */

　lpAddr = (BYTE*)(NVRAM + (wOffset +1) * 2); /* 为什么偏移要×2? */

　wTmp += *lpAddr;

　return wTmp;

}

 

/* 函数功能：向NVRAM中写一个字节

*参数：wOffset，写入位置相对NVRAM基地址的偏移

* byData，欲写入的字节

*/

extern void WriteByteNVRAM(WORD wOffset, BYTE byData)

{

　…

}

 

/* 函数功能：向NVRAM中写一个字 */

*参数：wOffset，写入位置相对NVRAM基地址的偏移

* wData，欲写入的字

*/

extern void WriteWordNVRAM(WORD wOffset, WORD wData)

{

　…

}

 

 

 

　　子贡问曰：Why偏移要乘以2?

　　子曰：请看图1，16位80186与8位NVRAM之间互连只能以地址线A1对其A0,CPU本身的A0与NVRAM不连接。因此，NVRAM的地址只能是偶数地址，故每次以0x10为单位前进！

3、汉字处理

　　现在要解决的问题是，嵌入式系统中经常要使用的并非是完整的汉字库，往往只是需要提供数量有限的汉字供必要的显示功能。例如，一个微波炉的LCD上没有必要提供显示"电子邮件"的功能；一个提供汉字显示功能的空调的LCD上不需要显示一条"短消息"，诸如此类。但是一部手机、小灵通则通常需要包括较完整的汉字库。

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

　　对于包含较完整汉字库的系统而言，我们可以以上述规则计算字模的位置。但是如果仅仅是提供少量汉字呢？譬如几十至几百个？最好的做法是：

　　定义宏：

 

 

# define EX_FONT_CHAR(value)

# define EX_FONT_UNICODE_VAL(value) (value),

# define EX_FONT_ANSI_VAL(value) (value),

 

 

　　定义结构体：

 

 

typedef struct _wide_unicode_font16x16

{

　WORD value; /* 内码 */

　BYTE data[32]; /* 字模点阵 */

}Unicode;

#define CHINESE_CHAR_NUM … /* 汉字数量 */

 

 

　　字模的存储用数组：

 

 

Unicode chinese[CHINESE_CHAR_NUM] =

{

{

EX_FONT_CHAR("业")

EX_FONT_UNICODE_VAL(0x4e1a)

{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}

},

{

EX_FONT_CHAR("中")

EX_FONT_UNICODE_VAL(0x4e2d)

{0x01, 0x00, 0x01, 0x00, 0x21, 0x08, 0x3f, 0xfc, 0x21, 0x08, 0x21, 0x08, 0x21, 0x08, 0x21, 0x08, 0x21, 0x08,

0x3f, 0xf8, 0x21, 0x08, 0x01, 0x00, 0x01, 0x00, 0x01, 0x00, 0x01, 0x00, 0x01, 0x00}

},

{

EX_FONT_CHAR("云")

EX_FONT_UNICODE_VAL(0x4e91)

{0x00, 0x00, 0x00, 0x30, 0x3f, 0xf8, 0x00, 0x00, 0x00, 0x00, 0x00, 0x0c, 0xff, 0xfe, 0x03, 0x00, 0x07, 0x00,

 

0x06, 0x40, 0x0c, 0x20, 0x18, 0x10, 0x31, 0xf8, 0x7f, 0x0c, 0x20, 0x08, 0x00, 0x00}

},

{

EX_FONT_CHAR("件")

EX_FONT_UNICODE_VAL(0x4ef6)

{0x10, 0x40, 0x1a, 0x40, 0x13, 0x40, 0x32, 0x40, 0x23, 0xfc, 0x64, 0x40, 0xa4, 0x40, 0x28, 0x40, 0x2f, 0xfe,

 

0x20, 0x40, 0x20, 0x40, 0x20, 0x40, 0x20, 0x40, 0x20, 0x40, 0x20, 0x40, 0x20, 0x40}

}

}

 

 

 

　　要显示特定汉字的时候，只需要从数组中查找内码与要求汉字内码相同的即可获得字模。如果前面的汉字在数组中以内码大小顺序排列，那么可以以二分查找法更高效的查找到汉字的字模。

　　这是一种很有效的组织小汉字库的方法，它可以保证程序有很好的结构。

　　系统时间显示

　　从NVRAM中可以读取系统的时间，系统一般借助NVRAM产生的秒中断每秒读取一次当前时间并在LCD上显示。关于时间的显示，有一个效率问题。因为时间有其特殊性，那就是60秒才有一次分钟的变化，60分钟才有一次小时变化，如果我们每次都将读取的时间在屏幕上完全重新刷新一次，则浪费了大量的系统时间。

　　一个较好的办法是我们在时间显示函数中以静态变量分别存储小时、分钟、秒，只有在其内容发生变化的时候才更新其显示。

 

 

extern void DisplayTime(…)

{

　static BYTE byHour,byMinute,bySecond;

　BYTE byNewHour, byNewMinute, byNewSecond;

　byNewHour = GetSysHour();

　byNewMinute = GetSysMinute();

　byNewSecond = GetSysSecond();

　

　if(byNewHour!= byHour)

　{

　　… /* 显示小时 */

　　byHour = byNewHour;

　}

　if(byNewMinute!= byMinute)

　{

　　… /* 显示分钟 */

　　byMinute = byNewMinute;

　}

　if(byNewSecond!= bySecond)

　{

　　… /* 显示秒钟 */

　　bySecond = byNewSecond;

　}

}

 

 

 

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

4、动画显示

　　动画是无所谓有，无所谓无的，静止的画面走的路多了，也就成了动画。随着时间的变更，在屏幕上显示不同的静止画面，即是动画之本质。所以，在一个嵌入式系统的LCD上欲显示动画，必须借助定时器。没有硬件或软件定时器的世界是无法想像的：

　　（1） 没有定时器，一个操作系统将无法进行时间片的轮转，于是无法进行多任务的调度，于是便不再成其为一个多任务操作系统；

　　（2） 没有定时器，一个多媒体播放软件将无法运作，因为它不知道何时应该切换到下一帧画面；

　　（3） 没有定时器，一个网络协议将无法运转，因为其无法获知何时包传输超时并重传之，无法在特定的时间完成特定的任务。

　　因此，没有定时器将意味着没有操作系统、没有网络、没有多媒体，这将是怎样的黑暗？所以，合理并灵活地使用各种定时器，是对一个软件人的最基本需求！

　　在80186为主芯片的嵌入式系统中，我们需要借助硬件定时器的中断来作为软件定时器，在中断发生后变更画面的显示内容。在时间显示"xx:xx"中让冒号交替有无，每次秒中断发生后，需调用ShowDot：

 

 

void ShowDot()

{

　static BOOL bShowDot = TRUE; /* 再一次领略static关键字的威力 */

　if(bShowDot)

　{

　　showChar(’:’,xPos,yPos);

　}

　else

　{

　　showChar(’ ’,xPos,yPos);

　}

　bShowDot = ! bShowDot;

}

 

 

　　菜单操作

　　无数人为之绞尽脑汁的问题终于出现了，在这一节里，我们将看到，在C语言中哪怕用到一丁点的面向对象思想，软件结构将会有何等的改观！

　　笔者曾经是个笨蛋，被菜单搞晕了，给出这样的一个系统：

 

 

 

图1 菜单范例

 

 

　　要求以键盘上的"← →"键切换菜单焦点，当用户在焦点处于某菜单时，若敲击键盘上的OK、CANCEL键则调用该焦点菜单对应之处理函数。我曾经傻傻地这样做着：

 

 

/* 按下OK键 */

void onOkKey()

{

　/* 判断在什么焦点菜单上按下Ok键，调用相应处理函数 */

　Switch(currentFocus)

　{

　　case MENU1:

　　　menu1OnOk();

　　　break;

　　case MENU2:

　　　menu2OnOk();

　　　break;

　　…

　}

}

/* 按下Cancel键 */

void onCancelKey()

{

　/* 判断在什么焦点菜单上按下Cancel键，调用相应处理函数 */

　Switch(currentFocus)

　{

　　case MENU1:

　　　menu1OnCancel();

　　　break;

　　case MENU2:

　　　menu2OnCancel();

　　　break;

　　…

　}

}

 

 

　　终于有一天，我这样做了：

 

 

/* 将菜单的属性和操作"封装"在一起 */

typedef struct tagSysMenu

{

　char *text; /* 菜单的文本 */

　BYTE xPos; /* 菜单在LCD上的x坐标 */

　BYTE yPos; /* 菜单在LCD上的y坐标 */

　void (*onOkFun)(); /* 在该菜单上按下ok键的处理函数指针 */

　void (*onCancelFun)(); /* 在该菜单上按下cancel键的处理函数指针 */

}SysMenu, *LPSysMenu;

 

 

　　当我定义菜单时，只需要这样：

 

 

static SysMenu menu[MENU_NUM] =

{

　{

　　"menu1", 0, 48, menu1OnOk, menu1OnCancel

　}

　,

　{

　　" menu2", 7, 48, menu2OnOk, menu2OnCancel

　}

　,

　{

　　" menu3", 7, 48, menu3OnOk, menu3OnCancel

　}

　,

　{

　　" menu4", 7, 48, menu4OnOk, menu4OnCancel

　}

　…

};

 

 

 

　　OK键和CANCEL键的处理变成：

 

 

/* 按下OK键 */

void onOkKey()

{

　menu[currentFocusMenu].onOkFun();

}

/* 按下Cancel键 */

void onCancelKey()

{

　menu[currentFocusMenu].onCancelFun();

}

 

 

 

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

　　面向对象，真神了！

模拟MessageBox函数

 

　　MessageBox函数，这个Windows编程中的超级猛料，不知道是多少入门者第一次用到的函数。还记得我们第一次在Windows中利用MessageBox输出 "Hello,World!"对话框时新奇的感觉吗？无法统计，这个世界上究竟有多少程序员学习Windows编程是从MessageBox ("Hello,World!",…)开始的。在我本科的学校，广泛流传着一个词汇，叫做"’Hello,World’级程序员"，意指入门级程序员，但似乎"’Hello,World’级"这个说法更搞笑而形象。

 

 

　

图2 经典的Hello,World!

 

 

 

　　图2给出了两种永恒经典的Hello,World对话框，一种只具有"确定"，一种则包含"确定"、"取消"。是的，MessageBox的确有，而且也应该有两类！这完全是由特定的应用需求决定的。

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

 

 

/******************************************

/* 函数名称: MessageBox

/* 功能说明: 弹出式对话框,显示提醒用户的信息

/* 参数说明: lpStr --- 提醒用户的字符串输出信息

/* TYPE --- 输出格式(ID_OK = 0, ID_OKCANCEL = 1)

/* 返回值: 返回对话框接收的键值,只有两种 KEY_OK, KEY_CANCEL

/******************************************

typedef enum TYPE { ID_OK,ID_OKCANCEL }MSG_TYPE;

extern BYTE MessageBox(LPBYTE lpStr, BYTE TYPE)

{

　BYTE keyValue = -1;

 

　ClearScreen(); /* 清除屏幕 */

　DisplayString(xPos,yPos,lpStr,TRUE); /* 显示字符串 */

　/* 根据对话框类型决定是否显示确定、取消 */

　switch (TYPE)

　{

　　case ID_OK:

　　　DisplayString(13,yPos+High+1, " 确定 ", 0);

　　　break;

　　case ID_OKCANCEL:

　　　DisplayString(8, yPos+High+1, " 确定 ", 0);

　　　DisplayString(17,yPos+High+1, " 取消 ", 0);

　　　break;

　　default:

　　　break;

　}

　DrawRect(0, 0, 239, yPos+High+16+4); /* 绘制外框 */

　/* MessageBox是模式对话框，阻塞运行，等待按键 */

　while( (keyValue != KEY_OK) || (keyValue != KEY_CANCEL) )

　{

　　keyValue = getSysKey();

　}

　/* 返回按键类型 */

　if(keyValue== KEY_OK)

　{

　　return ID_OK;

　}

　else

　{

　　return ID_CANCEL;

　}

}

 

 

 

　　上述函数与我们平素在VC++等中使用的MessageBox是何等的神似啊？实现这个函数，你会看到它在嵌入式系统中的妙用是无穷的。

　　总结

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

　　屏幕乃嵌入式系统生存之重要辅助，面目可憎之显示将另用户逃之夭夭。屏幕编程若处理不好，将是软件中最不系统、最混乱的部分，笔者曾深受其害。

1.使用宏定义

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

写一个“标准”宏MIN ，这个宏输入两个参数并返回较小的一个：

 

 

    错误做法：

 

 

#define MIN(A,B) 　( A <= B ? A : B )

 

 

正确做法：

 

 

#define MIN(A,B) （（A）<= (B) ? (A) : (B) )

 

 

对于宏，我们需要知道三点：

 

 

(1)宏定义“像”函数；

 

 

(2)宏定义不是函数，因而需要括上所有“参数”；

 

 

(3)宏定义可能产生副作用。

 

 

下面的代码：

 

 

least = MIN(*p++, b);

 

 

将被替换为：

 

 

( (*p++) <= (b) ?(*p++):(b) )

 

 

发生的事情无法预料。

 

 

因而不要给宏定义传入有副作用的“参数”。

 

 

2.使用寄存器变量

 

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

 

 

(1)                 只有局部自动变量和形参才可以定义为寄存器变量。因为寄存器变量属于动态存储方式，凡需要采用静态存储方式的量都不能定义为寄存器变量，包括：模块间全局变量、模块内全局变量、局部static变量；

 

 

(2)                 register是一个“建议”型关键字，意指程序建议该变量放在寄存器中，但最终该变量可能因为条件不满足并未成为寄存器变量，而是被放在了存储器中，但编译器中并不报错（在C++语言中有另一个“建议”型关键字：inline）。

 

 

下面是一个采用寄存器变量的例子：

 

 

/* 求1+2+3+….+n的值 */

 

 

WORD Addition(BYTE n)

 

 

{

 

 

register i,s=0;

 

 

for(i=1;i<=n;i++)

 

 

{

 

 

s=s+i;

 

 

}

 

 

return s;

 

 

}

 

 

本程序循环n次，i和s都被频繁使用，因此可定义为寄存器变量。

 

 

3.内嵌汇编

 

程序中对时间要求苛刻的部分可以用内嵌汇编来重写，以带来速度上的显著提高。但是，开发和测试汇编代码是一件辛苦的工作，它将花费更长的时间，因而要慎重选择要用汇编的部分。

 

 

在程序中，存在一个80-20原则，即20%的程序消耗了80%的运行时间，因而我们要改进效率，最主要是考虑改进那20%的代码。

 

 

嵌入式C程序中主要使用在线汇编，即在C程序中直接插入_asm{ }内嵌汇编语句：

 

 

/* 把两个输入参数的值相加，结果存放到另外一个全局变量中 */

 

 

int result; 

 

 

void Add(long a, long *b) 

 

 

{ 

 

 

    _asm 

 

 

   { 

 

 

     MOV       AX, a     

 

 

     MOV       BX, b     

 

 

     ADD       AX, [BX]

 

 

     MOV       result, AX

 

 

   } 

 

 

}    

 

 

4.利用硬件特性

 

首先要明白CPU对各种存储器的访问速度，基本上是：

 

 

CPU内部RAM　>　外部同步RAM　>　外部异步RAM　>　FLASH/ROM

 

 

对于程序代码，已经被烧录在FLASH或ROM中，我们可以让CPU直接从其中读取代码执行，但通常这不是一个好办法，我们最好在系统启动后将FLASH或ROM中的目标代码拷贝入RAM中后再执行以提高取指令速度；

 

 

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

 

 

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

5.活用位操作

 

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

 

 

/* 方法1 */

 

 

int i,j;

 

 

i = 879 / 16;

 

 

j = 562 % 32;

 

 

 

 

 

 

/* 方法2 */

 

 

int i,j;

 

 

i = 879 >> 4;

 

 

j = 562 - (562 >> 5 << 5);

 

 

对于以2的指数次方为“*”、“/”或“%”因子的数学运算，转化为移位运算“<< >>”通常可以提高算法效率。因为乘除运算指令周期通常比移位运算大。

 

 

C语言位运算除了可以提高运算效率外，在嵌入式系统的编程中，它的另一个最典型的应用，而且十分广泛地正在被使用着的是位间的与（&）、或（|）、非（~）操作，这跟嵌入式系统的编程特点有很大关系。我们通常要对硬件寄存器进行位设置，譬如，我们通过将AM186ER型80186处理器的中断屏蔽控制寄存器的第低6位设置为0（开中断2），最通用的做法是：

 

 

#define INT_I2_MASK      0x0040  

 

 

wTemp = inword(INT_MASK);

 

 

outword(INT_MASK, wTemp &~INT_I2_MASK);

 

 

而将该位设置为1的做法是：

 

 

#define INT_I2_MASK      0x0040  

 

 

wTemp = inword(INT_MASK);

 

 

outword(INT_MASK, wTemp | INT_I2_MASK);

 

 

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

 

 

#define INT_I2_MASK      0x0040  

 

 

wTemp = inword(INT_MASK);

 

 

if(wTemp & INT_I2_MASK)

 

 

{

 

 

   …     /* 该位为1 */

 

 

}

 

 

上述方法在嵌入式系统的编程中是非常常见的，我们需要牢固掌握。

 

 

总结

在性能优化方面永远注意80-20准备，不要优化程序中开销不大的那80%，这是劳而无功的。

 

宏定义是C语言中实现类似函数功能而又不具函数调用和返回开销的较好方法，但宏在本质上不是函数，因而要防止宏展开后出现不可预料的结果，对宏的定义和使用要慎而处之。很遗憾，标准C至今没有包括C++中inline函数的功能，inline函数兼具无调用开销和安全的优点。

 

使用寄存器变量、内嵌汇编和活用位操作也是提高程序效率的有效方法。

 

除了编程上的技巧外，为提高系统的运行效率，我们通常也需要最大可能地利用各种硬件设备自身的特点来减小其运转开销，例如减小中断次数、利用DMA传输方式等。