嵌入式 C/C++語言精華文章集錦

2019-11-14 09:20:56

字體：大中小

供稿：網(wǎng)友

C/C+語言 struct 深層探索 ............................................................................2C++中 extern "C"含義深層探索........................................................................7C 語言高效編程的幾招...............................................................................11想成為嵌入式程序員應知道的 0x10 個基本問題 .........................................................15C 語言嵌入式系統(tǒng)編程修煉...........................................................................22C 語言嵌入式系統(tǒng)編程修煉之一:背景篇............................................................22C 語言嵌入式系統(tǒng)編程修煉之二:軟件架構篇........................................................24C 語言嵌入式系統(tǒng)編程修煉之三:內(nèi)存操作..........................................................30C 語言嵌入式系統(tǒng)編程修煉之四:屏幕操作..........................................................36C 語言嵌入式系統(tǒng)編程修煉之五:鍵盤操作..........................................................43C 語言嵌入式系統(tǒng)編程修煉之六:性能優(yōu)化..........................................................46C/C++語言 void 及 void 指針深層探索 .................................................................50C/C++語言可變參數(shù)表深層探索 .......................................................................54C/C++數(shù)組名與指針區(qū)別深層探索 .....................................................................60C/C++程序員應聘常見面試題深入剖析(1) ..............................................................62C/C++程序員應聘常見面試題深入剖析(2) ..............................................................67一道著名外企面試題的抽絲剝繭 ......................................................................74C/C++結(jié)構體的一個高級特性――指定成員的位數(shù) .......................................................78C/C++中的近指令、遠指針和巨指針 ...................................................................80從兩道經(jīng)典試題談 C/C++中聯(lián)合體（union）的使用......................................................81基于 ARM 的嵌入式 linux 移植真實體驗 ................................................................83基于 ARM 的嵌入式 Linux 移植真實體驗（1）――基本概念 ...........................................83基于 ARM 的嵌入式 Linux 移植真實體驗（2）――BootLoader .........................................96基于 ARM 的嵌入式 Linux 移植真實體驗（ 3）――操作系統(tǒng) ..........................................111基于 ARM 的嵌入式 Linux 移植真實體驗（4）――設備驅(qū)動 ..........................................120基于 ARM 的嵌入式 Linux 移植真實體驗（5）――應用實例 ..........................................135深入淺出 Linux 設備驅(qū)動編程 .......................................................................1441.Linux 內(nèi)核模塊..............................................................................1442.字符設備驅(qū)動程序 ...........................................................................1463.設備驅(qū)動中的并發(fā)控制 .......................................................................1514.設備的阻塞與非阻塞操作 .....................................................................157C/C+語言 struct 深層探索出處：PConline 作者：宋寶華1. struct 的巨大作用面對一個人的大型 C/C++程序時，只看其對 struct 的使用情況我們就可以對其編寫者的編程經(jīng)驗進行評估。因為一個大型的 C/C++程序，勢必要涉及一些(甚至大量)進行數(shù)據(jù)組合的結(jié)構體，這些結(jié)構體可以將原本意義屬于一個整體的數(shù)據(jù)組合在一起。從某種程度上來說，會不會用 struct，怎樣用struct 是區(qū)別一個開發(fā)人員是否具備豐富開發(fā)經(jīng)歷的標志。在網(wǎng)絡協(xié)議、通信控制、嵌入式系統(tǒng)的 C/C++編程中，我們經(jīng)常要傳送的不是簡單的字節(jié)流（char型數(shù)組），而是多種數(shù)據(jù)組合起來的一個整體，其表現(xiàn)形式是一個結(jié)構體。經(jīng)驗不足的開發(fā)人員往往將所有需要傳送的內(nèi)容依順序保存在 char 型數(shù)組中，通過指針偏移的方法傳送網(wǎng)絡報文等信息。這樣做編程復雜，易出錯，而且一旦控制方式及通信協(xié)議有所變化，程序就要進行非常細致的修改。一個有經(jīng)驗的開發(fā)者則靈活運用結(jié)構體，舉一個例子，假設網(wǎng)絡或控制協(xié)議中需要傳送三種報文，其格式分別為 packetA、packetB、packetC：struct structA{int a;char b;};struct structB{char a;short b;};struct structC{int a;char b;float c;}優(yōu)秀的程序設計者這樣設計傳送的報文：struct CommuPacket{3int ipacketType; //報文類型標志union //每次傳送的是三種報文中的一種，使用 union{struct structA packetA; struct structB packetB;struct structC packetC;}};在進行報文傳送時，直接傳送 struct CommuPacket 一個整體。假設發(fā)送函數(shù)的原形如下：// pSendData：發(fā)送字節(jié)流的首地址，iLen：要發(fā)送的長度Send(char * pSendData, unsigned int iLen);發(fā)送方可以直接進行如下調(diào)用發(fā)送 struct CommuPacket 的一個實例 sendCommuPacket：Send( (char *)&sendCommuPacket , sizeof(CommuPacket) );假設接收函數(shù)的原形如下：// PRecvData：發(fā)送字節(jié)流的首地址，iLen：要接收的長度//返回值：實際接收到的字節(jié)數(shù)unsigned int Recv(char * pRecvData, unsigned int iLen)；接收方可以直接進行如下調(diào)用將接收到的數(shù)據(jù)保存在 struct CommuPacket 的一個實例 recvCommuPacket 中：Recv( (char *)&recvCommuPacket , sizeof(CommuPacket) );接著判斷報文類型進行相應處理：switch(recvCommuPacket. iPacketType){case PACKET_A:… //A 類報文處理break;case PACKET_B:… //B 類報文處理break;case PACKET_C:… //C 類報文處理break;}以上程序中最值得注意的是Send( (char *)&sendCommuPacket , sizeof(CommuPacket) );Recv( (char *)&recvCommuPacket , sizeof(CommuPacket) );中的強制類型轉(zhuǎn)換：(char *)&sendCommuPacket、(char *)&recvCommuPacket，先取地址，再轉(zhuǎn)化為 char 型指針，這樣就可以直接利用處理字節(jié)流的函數(shù)。利用這種強制類型轉(zhuǎn)化，我們還可以方便程序的編寫，例如要對 sendCommuPacket 所處內(nèi)存初始化為 0，可以這樣調(diào)用標準庫函數(shù) memset()：memset((char *)&sendCommuPacket,0, sizeof(CommuPacket));2. struct的成員對齊Intel、微軟等公司曾經(jīng)出過一道類似的面試題：#include <iostream.h>4#pragma pack(8)struct example1{short a;long b;};struct example2{char c;example1 struct1;short e;};#pragma pack()int main(int argc, char* argv[]){example2 struct2;cout << sizeof(example1) << endl;cout << sizeof(example2) << endl;cout << (unsigned int)(&struct2.struct1) - (unsigned int)(&struct2) << endl;return 0;}問程序的輸入結(jié)果是什么？答案是：8164不明白？還是不明白？下面一一道來：2.1 自然對界struct 是一種復合數(shù)據(jù)類型，其構成元素既可以是基本數(shù)據(jù)類型（如 int、long、float 等）的變量，也可以是一些復合數(shù)據(jù)類型（如 array、struct、union 等）的數(shù)據(jù)單元。對于結(jié)構體，編譯器會自動進行成員變量的對齊，以提高運算效率。缺省情況下，編譯器為結(jié)構體的每個成員按其自然對界（natural alignment）條件分配空間。各個成員按照它們被聲明的順序在內(nèi)存中順序存儲，第一個成員的地址和整個結(jié)構的地址相同。自然對界(natural alignment)即默認對齊方式，是指按結(jié)構體的成員中 size 最大的成員對齊。例如：struct naturalalign{char a;short b;char c;};在上述結(jié)構體中，size 最大的是 short，其長度為 2 字節(jié)，因而結(jié)構體中的 char 成員 a、c 都以 2 為單位對齊，sizeof(naturalalign)的結(jié)果等于 6；如果改為：struct naturalalign5{char a;int b;char c;};其結(jié)果顯然為 12。2.2 指定對界一般地，可以通過下面的方法來改變?nèi)笔〉膶鐥l件：· 使用偽指令#pragma pack (n)，編譯器將按照 n 個字節(jié)對齊；· 使用偽指令#pragma pack ()，取消自定義字節(jié)對齊方式。注意：如果#pragma pack (n)中指定的 n 大于結(jié)構體中最大成員的 size，則其不起作用，結(jié)構體仍然按照 size 最大的成員進行對界。例如：#pragma pack (n)struct naturalalign{char a;int b;char c;};#pragma pack ()當 n 為 4、8、16 時，其對齊方式均一樣，sizeof(naturalalign)的結(jié)果都等于 12。而當 n 為 2時，其發(fā)揮了作用，使得 sizeof(naturalalign)的結(jié)果為 6。在 VC++ 6.0 編譯器中，我們可以指定其對界方式（見圖 1），其操作方式為依次選擇 projetct >setting > C/C++菜單，在 struct member alignment 中指定你要的對界方式。圖 1 在 VC++ 6.0 中指定對界方式6另外，通過__attribute((aligned (n)))也可以讓所作用的結(jié)構體成員對齊在 n 字節(jié)邊界上，但是它較少被使用，因而不作詳細講解。2.3 面試題的解答至此，我們可以對 Intel、微軟的面試題進行全面的解答。程序中第 2 行#pragma pack (8)雖然指定了對界為 8，但是由于 struct example1 中的成員最大size 為 4（long 變量 size 為 4），故 struct example1 仍然按 4 字節(jié)對界，struct example1 的 size為 8，即第 18 行的輸出結(jié)果；struct example2 中包含了 struct example1，其本身包含的簡單數(shù)據(jù)成員的最大 size 為 2 （short變量 e），但是因為其包含了 struct example1，而 struct example1 中的最大成員 size 為 4，structexample2 也應以 4 對界，#pragma pack (8)中指定的對界對 struct example2 也不起作用，故 19 行的輸出結(jié)果為 16；由于 struct example2 中的成員以 4 為單位對界，故其 char 變量 c 后應補充 3 個空，其后才是成員 struct1 的內(nèi)存空間，20 行的輸出結(jié)果為 4。3. C 和 C++間 struct 的深層區(qū)別在 C++語言中 struct 具有了“類” 的功能，其與關鍵字 class 的區(qū)別在于 struct 中成員變量和函數(shù)的默認訪問權限為 public，而 class 的為 private。例如，定義 struct 類和 class 類：struct structA{char a;…}class classB{char a;…}則：structA a;a.a = 'a'; //訪問 public 成員，合法classB b;b.a = 'a'; //訪問 private 成員，不合法許多文獻寫到這里就認為已經(jīng)給出了 C++中 struct 和 class 的全部區(qū)別，實則不然，另外一點需要注意的是：C++中的 struct 保持了對 C 中 struct 的全面兼容（這符合 C++的初衷——“a better c”），因而，下面的操作是合法的：//定義 structstruct structA{char a;char b;int c;};7structA a = {'a' , 'a' ,1}; // 定義時直接賦初值即 struct 可以在定義的時候直接以{ }對其成員變量賦初值，而 class 則不能，在經(jīng)典書目《thinking C++ 2nd edition》中作者對此點進行了強調(diào)。4. struct 編程注意事項看看下面的程序：1. #include <iostream.h>2. struct structA3. {4. int iMember;5. char *cMember;6. };7. int main(int argc, char* argv[])8.{9. structA instant1,instant2;10. char c = 'a';11. instant1.iMember = 1;12. instant1.cMember = &c;13. instant2 = instant1;14. cout << *(instant1.cMember) << endl;15. *(instant2.cMember) = 'b';16. cout << *(instant1.cMember) << endl;17. return 0;}14 行的輸出結(jié)果是：a16 行的輸出結(jié)果是：bWhy?我們在 15 行對 instant2 的修改改變了 instant1 中成員的值！原因在于 13 行的 instant2 = instant1 賦值語句采用的是變量逐個拷貝，這使得 instant1 和instant2 中的 cMember 指向了同一片內(nèi)存，因而對 instant2 的修改也是對 instant1 的修改。在 C 語言中，當結(jié)構體中存在指針型成員時，一定要注意在采用賦值語句時是否將 2 個實例中的指針型成員指向了同一片內(nèi)存。在 C++語言中，當結(jié)構體中存在指針型成員時，我們需要重寫 struct 的拷貝構造函數(shù)并進行“=”操作符重載。C++中 extern "C"含義深層探索作者：宋寶華 e-mail:21cnbao@21cn.com出處：太平洋電腦網(wǎng)1.引言C++語言的創(chuàng)建初衷是“a better C”，但是這并不意味著 C++中類似 C 語言的全局變量和函數(shù)所采用的編譯和連接方式與 C 語言完全相同。作為一種欲與 C 兼容的語言，C++保留了一部分過程式語言的特點（被世人稱為“不徹底地面向?qū)ο蟆保蚨梢远x不屬于任何類的全局變量和函數(shù)。8但是，C++畢竟是一種面向?qū)ο蟮某绦蛟O計語言，為了支持函數(shù)的重載，C++對全局函數(shù)的處理方式與 C有明顯的不同。2.從標準頭文件說起某企業(yè)曾經(jīng)給出如下的一道面試題：面試題為什么標準頭文件都有類似以下的結(jié)構？#ifndef __INCvxWorksh#define __INCvxWorksh#ifdef __cplusplusextern "C" {#endif/*...*/#ifdef __cplusplus}#endif#endif /* __INCvxWorksh */分析顯然，頭文件中的編譯宏“#ifndef __INCvxWorksh、#define __INCvxWorksh、#endif” 的作用是防止該頭文件被重復引用。那么#ifdef __cplusplusextern "C" {#endif#ifdef __cplusplus}#endif的作用又是什么呢？我們將在下文一一道來。3.深層揭密 extern "C"extern "C" 包含雙重含義，從字面上即可得到：首先，被它修飾的目標是“extern”的；其次，被它修飾的目標是“C”的。讓我們來詳細解讀這兩重含義。（1）被 extern "C"限定的函數(shù)或變量是 extern 類型的；extern 是 C/C++語言中表明函數(shù)和全局變量作用范圍（可見性）的關鍵字，該關鍵字告訴編譯器，其聲明的函數(shù)和變量可以在本模塊或其它模塊中使用。記住，下列語句：extern int a;僅僅是一個變量的聲明，其并不是在定義變量 a，并未為 a 分配內(nèi)存空間。變量 a 在所有模塊中作為一種全局變量只能被定義一次，否則會出現(xiàn)連接錯誤。通常，在模塊的頭文件中對本模塊提供給其它模塊引用的函數(shù)和全局變量以關鍵字 extern 聲明。例如，如果模塊 B 欲引用該模塊 A 中定義的全局變量和函數(shù)時只需包含模塊 A 的頭文件即可。這樣，模塊 B 中調(diào)用模塊 A 中的函數(shù)時，在編譯階段，模塊 B 雖然找不到該函數(shù)，但是并不會報錯；它會在連接階段中從模塊 A 編譯生成的目標代碼中找到此函數(shù)。與 extern 對應的關鍵字是 static，被它修飾的全局變量和函數(shù)只能在本模塊中使用。因此，一個函數(shù)或變量只可能被本模塊使用時，其不可能被 extern “C”修飾。（2）被 extern "C"修飾的變量和函數(shù)是按照 C 語言方式編譯和連接的；未加 extern “C”聲明時的編譯方式9首先看看 C++中對類似 C 的函數(shù)是怎樣編譯的。作為一種面向?qū)ο蟮恼Z言，C++支持函數(shù)重載，而過程式語言 C 則不支持。函數(shù)被 C++編譯后在符號庫中的名字與 C 語言的不同。例如，假設某個函數(shù)的原型為：void foo( int x, int y );該函數(shù)被 C 編譯器編譯后在符號庫中的名字為_foo，而 C++編譯器則會產(chǎn)生像_foo_int_int 之類的名字（不同的編譯器可能生成的名字不同，但是都采用了相同的機制，生成的新名字稱為“mangledname”）。_foo_int_int 這樣的名字包含了函數(shù)名、函數(shù)參數(shù)數(shù)量及類型信息，C++就是靠這種機制來實現(xiàn)函數(shù)重載的。例如，在 C++中，函數(shù) void foo( int x, int y )與 void foo( int x, float y )編譯生成的符號是不相同的，后者為_foo_int_float。同樣地，C++中的變量除支持局部變量外，還支持類成員變量和全局變量。用戶所編寫程序的類成員變量可能與全局變量同名，我們以"."來區(qū)分。而本質(zhì)上，編譯器在進行編譯時，與函數(shù)的處理相似，也為類中的變量取了一個獨一無二的名字，這個名字與用戶程序中同名的全局變量名字不同。未加 extern "C"聲明時的連接方式假設在 C++中，模塊 A 的頭文件如下：// 模塊 A 頭文件 moduleA.h#ifndef MODULE_A_H#define MODULE_A_Hint foo( int x, int y );#endif在模塊 B 中引用該函數(shù)：// 模塊 B 實現(xiàn)文件 moduleB.cpp#include "moduleA.h"foo(2,3);實際上，在連接階段，連接器會從模塊 A 生成的目標文件 moduleA.obj 中尋找_foo_int_int 這樣的符號！加 extern "C"聲明后的編譯和連接方式加 extern "C"聲明后，模塊 A 的頭文件變?yōu)椋?/ 模塊 A 頭文件 moduleA.h#ifndef MODULE_A_H#define MODULE_A_Hextern "C" int foo( int x, int y );#endif在模塊 B 的實現(xiàn)文件中仍然調(diào)用 foo( 2,3 )，其結(jié)果是：（1）模塊 A 編譯生成 foo 的目標代碼時，沒有對其名字進行特殊處理，采用了 C 語言的方式；（2）連接器在為模塊 B 的目標代碼尋找 foo(2,3)調(diào)用時，尋找的是未經(jīng)修改的符號名_foo。如果在模塊 A 中函數(shù)聲明了 foo 為 extern "C"類型，而模塊 B 中包含的是 extern int foo( int x,int y ) ，則模塊 B 找不到模塊 A 中的函數(shù)；反之亦然。所以，可以用一句話概括 extern “C”這個聲明的真實目的（任何語言中的任何語法特性的誕生都不是隨意而為的，來源于真實世界的需求驅(qū)動。我們在思考問題時，不能只停留在這個語言是怎么做的，還要問一問它為什么要這么做，動機是什么，這樣我們可以更深入地理解許多問題）：實現(xiàn) C++與 C 及其它語言的混合編程。明白了 C++中 extern "C"的設立動機，我們下面來具體分析 extern "C"通常的使用技巧。4.extern "C"的慣用法10（1）在 C++中引用 C 語言中的函數(shù)和變量，在包含 C 語言頭文件（假設為 cExample.h）時，需進行下列處理：extern "C"{#include "cExample.h"}而在 C 語言的頭文件中，對其外部函數(shù)只能指定為 extern 類型，C 語言中不支持 extern "C"聲明，在.c 文件中包含了 extern "C"時會出現(xiàn)編譯語法錯誤。筆者編寫的 C++引用 C 函數(shù)例子工程中包含的三個文件的源代碼如下：/* c 語言頭文件：cExample.h */#ifndef C_EXAMPLE_H#define C_EXAMPLE_Hextern int add(int x,int y);#endif/* c 語言實現(xiàn)文件：cExample.c */#include "cExample.h"int add( int x, int y ){return x + y;}// c++實現(xiàn)文件，調(diào)用 add：cppFile.cppextern "C"{#include "cExample.h"}int main(int argc, char* argv[]){add(2,3);return 0;}如果 C++調(diào)用一個 C 語言編寫的.DLL 時，當包括.DLL 的頭文件或聲明接口函數(shù)時，應加 extern "C"{ }。（2）在 C 中引用 C++語言中的函數(shù)和變量時，C++的頭文件需添加 extern "C"，但是在 C 語言中不能直接引用聲明了 extern "C"的該頭文件，應該僅將 C 文件中將 C++中定義的 extern "C"函數(shù)聲明為extern 類型。筆者編寫的 C 引用 C++函數(shù)例子工程中包含的三個文件的源代碼如下：//C++頭文件 cppExample.h#ifndef CPP_EXAMPLE_H#define CPP_EXAMPLE_Hextern "C" int add( int x, int y );#endif//C++實現(xiàn)文件 cppExample.cpp#include "cppExample.h"int add( int x, int y )11{return x + y;}/* C 實現(xiàn)文件 cFile.c/* 這樣會編譯出錯：#include "cExample.h" */extern int add( int x, int y );int main( int argc, char* argv[] ){add( 2, 3 );return 0;}如果深入理解了第 3 節(jié)中所闡述的 extern "C"在編譯和連接階段發(fā)揮的作用，就能真正理解本節(jié)所闡述的從 C++引用 C 函數(shù)和 C 引用 C++函數(shù)的慣用法。對第 4 節(jié)給出的示例代碼，需要特別留意各個細節(jié)。C 語言高效編程的幾招編寫高效簡潔的 C語言代碼，是許多軟件工程師追求的目標。本文就工作中的一些體會和經(jīng)驗做相關的闡述，不對的地方請各位指教。第 1 招：以空間換時間計算機程序中最大的矛盾是空間和時間的矛盾，那么，從這個角度出發(fā)逆向思維來考慮程序的效率問題，我們就有了解決問題的第 1 招--以空間換時間。例如：字符串的賦值。方法 A，通常的辦法：#define LEN 32char string1 [LEN];memset (string1,0,LEN);strcpy (string1,"This is an example!!"方法 B:const char string2[LEN]="This is an example!"char*cp;cp=string2;(使用的時候可以直接用指針來操作。 )從上面的例子可以看出， A和 B的效率是不能比的。在同樣的存儲空間下， B 直接使用指針就可以操作了，而A 需要調(diào)用兩個字符函數(shù)才能完成。 B 的缺點在于靈活性沒有A 好。在需要頻繁更改一個字符串內(nèi)容的時候，A 具有更好的靈活性；如果采用方法 B，則需要預存許多字符串，雖然占用了大量的內(nèi)存，但是獲得了程序執(zhí)行的高效率。如果系統(tǒng)的實時性要求很高，內(nèi)存還有一些，那我推薦你使用該招數(shù)。12該招數(shù)的邊招--使用宏函數(shù)而不是函數(shù)。舉例如下：方法 C:#define bwMCDR2_ADDRESS 4#define bsMCDR2_ADDRESS 17int BIT_MASK (int_bf){return ((IU<<(bw##_bf))-1)<<(bs##_bf);}void SET_BITS(int_dst,int_bf,int_val){_dst=((_dst) & ~ (BIT_MASK(_bf)))I/(((_val)<<<(bs##_bf))&(BIT_MASK(_bf)))}SET_BITS(MCDR2,MCDR2_ADDRESS,RegisterNumber);方法 D:#define bwMCDR2_ADDRESS 4#define bsMCDR2_ADDRESS 17#define bmMCDR2_ADDRESS BIT_MASK(MCDR2_ADDRESS)#define BIT_MASK(_bf)(((1U<<(bw##_bf))-1)<<(bs##_bf)#define SET_BITS(_dst,_bf,_val)/((_dst)=((_dst)&~(BIT_MASK(_bf)))I(((_val)<<(bs##_bf))&(BIT_MASK(_bf))))SET_BITS(MCDR2,MCDR2_ADDRESS,RegisterNumber);函數(shù)和宏函數(shù)的區(qū)別就在于，宏函數(shù)占用了大量的空間，而函數(shù)占用了時間。大家要知道的是，函數(shù)調(diào)用是要使用系統(tǒng)的棧來保存數(shù)據(jù)的，如果編譯器里有棧檢查選項，一般在函數(shù)的頭會嵌入一些匯編語句對當前棧進行檢查；同時， CPU也要在函數(shù)調(diào)用時保存和恢復當前的現(xiàn)場，進行壓棧和彈棧操作，所以，函數(shù)調(diào)用需要一些 CPU時間。而宏函數(shù)不存在這個問題。宏函數(shù)僅僅作為預先寫好的代碼嵌入到當前程序，不會產(chǎn)生函數(shù)調(diào)用，所以僅僅是占用了空間，在頻繁調(diào)用同一個宏函數(shù)的時候，該現(xiàn)象尤其突出。D 方法是我看到的最好的置位操作函數(shù)，是ARM 公司源碼的一部分，在短短的三行內(nèi)實現(xiàn)了很多功能，幾乎涵蓋了所有的位操作功能。 C 方法是其變體，其中滋味還需大家仔細體會。第 2 招：數(shù)學方法解決問題現(xiàn)在我們演繹高效 C 語言編寫的第二招--采用數(shù)學方法來解決問題。數(shù)學是計算機之母，沒有數(shù)學的依據(jù)和基礎，就沒有計算機的發(fā)展，所以在編寫程序的時候，采用一些數(shù)學方法會對程序的執(zhí)行效率有數(shù)量級的提高。舉例如下，求 1~100 的和。

方法 Eint I,j;

方法 Fint I;

for (I=1; I<=100; I++){j+=I;}

I=(100*(1+100))/2

這個例子是我印象最深的一個數(shù)學用例，是我的餓計算機啟蒙老師考我的。當時我只有小學三年級，可惜我當時不知道用公式 Nx(N+1)/2 來解決這個問題。方法E 循環(huán)了100 次才解決問題，也就是說最少用了100 個賦值、100 個判斷、200個加法(I和 j)；而方法F 僅僅用了1 個加法、1 個乘法、1 次除法。效果自然不言而喻。所以，現(xiàn)在我在編程序的時候，更多的是動腦筋找規(guī)律，最大限度地發(fā)揮數(shù)學的威力來提高程序運行的效率。第 3 招：使用位操作實現(xiàn)高效的 C 語言編寫的第三招--使用位操作，減少除法和取模的運算。在計算機程序中，數(shù)據(jù)的位是可以操作的最小數(shù)據(jù)單位，理論上可以用“位運算”來完成所有的運算和操作。一般的位操作是用來控制硬件的，或者做數(shù)據(jù)變換使用，但是，靈活的位操作可以有效地提高程序運行的效率。舉例臺如下：方法 Gint I,J;I=257/8;J=456%32;方法 Hint I,J;I=257>>3;J=456-(456>>4<<4);在字面上好象 H比 G麻煩了好多，但是，仔細查看產(chǎn)生的匯編代碼就會明白，方法G 調(diào)用了基本的取模函數(shù)和除法函數(shù)，既有函數(shù)調(diào)用，還有很多匯編代碼和寄存器參與運算；而方法 H則僅僅是幾句相關的匯編，代碼更簡潔、效率更高。當然，由于編譯器的不同，可能效率的差距不大，但是，以我目前遇到的 MS C,ARM C來看，效率的差距還是不小。相關匯編代碼就不在這里列舉了。運用這招需要注意的是，因為 CPU 的不同而產(chǎn)生的問題。比如說，在PC 上用這招編寫的程序，并在PC 上調(diào)試通過，在移植到一個 16 位機平臺上的時候，可能會產(chǎn)生代碼隱患。所以只有在一定技術進階的基礎下才可以使用這招。第 4 招：匯編嵌入高效 C 語言編程的必殺技，第四招--嵌入?yún)R編。“在熟悉匯編語言的人眼里，C 語言編寫的程序都是垃圾”。這種說法雖然偏激了一些，但是卻有它的道理。匯編語言是效率最高的計算機語言，但是，不可能靠著它來寫一個操作系統(tǒng)吧？所以，為了獲得程序的高效率，我們只好采用變通的方法--嵌入?yún)R編、混合編程。舉例如下，將數(shù)組一賦值給數(shù)組二，要求每一個字節(jié)都相符。 char string1[1024], string2[1024];14方法 Iint I;for (I=0; I<1024; I++)*(string2+I)=*(string1+I)方法 J#int I;for(I=0; I<1024; I++)*(string2+I)=*(string1+I);#else#ifdef_ARM__asm{MOV R0,string1MOV R1,string2MOV R2,#0loop:LDMIA R0!,[R3-R11]STMIA R1!,[R3-R11]ADD R2,R2,#8CMP R2, #400BNE loop}#endif方法 I是最常見的方法，使用了 1024次循環(huán)；方法 J則根據(jù)平臺不同做了區(qū)分，在 ARM平臺下，用嵌入?yún)R編僅用 128次循環(huán)就完成了同樣的操作。這里有朋友會說，為什么不用標準的內(nèi)存拷貝函數(shù)呢？這是因為在源數(shù)據(jù)里可能含有數(shù)據(jù)為0 的字節(jié)，這樣的話，標準庫函數(shù)會提前結(jié)束而不會完成我們要求的操作。這個例程典型應用于LCD 數(shù)據(jù)的拷貝過程。根據(jù)不同的 CPU，熟練使用相應的嵌入?yún)R編，可以大大提高程序執(zhí)行的效率。雖然是必殺技，但是如果輕易使用會付出慘重的代價。這是因為，使用了嵌入?yún)R編，便限制了程序的可移植性，使程序在不同平臺移植的過程中，臥虎藏龍、險象環(huán)生！同時該招數(shù)也與現(xiàn)代軟件工程的思想相違背，只有在迫不得已的情況下才可以采用。切記。使用 C 語言進行高效率編程，我的體會僅此而已。在此已本文拋磚引玉，還請各位高手共同切磋。希望各位能給出更好的方法，大家一起提高我們的編程技巧。摘自《單片機與嵌入式系統(tǒng)應用》 2003.915想成為嵌入式程序員應知道的 0x10 個基本問題-|endeaver發(fā)表于 2006-3-8 16:16:00C 語言測試是招聘嵌入式系統(tǒng)程序員過程中必須而且有效的方法。這些年，我既參加也組織了許多這種測試，在這過程中我意識到這些測試能為帶面試者和被面試者提供許多有用信息，此外，撇開面試的壓力不談，這種測試也是相當有趣的。從被面試者的角度來講，你能了解許多關于出題者或監(jiān)考者的情況。這個測試只是出題者為顯示其對 ANSI標準細節(jié)的知識而不是技術技巧而設計嗎？這個愚蠢的問題嗎？如要你答出某個字符的 ASCII值。這些問題著重考察你的系統(tǒng)調(diào)用和內(nèi)存分配策略方面的能力嗎？這標志著出題者也許花時間在微機上而不上在嵌入式系統(tǒng)上。如果上述任何問題的答案是"是"的話，那么我知道我得認真考慮我是否應該去做這份工作。從面試者的角度來講，一個測試也許能從多方面揭示應試者的素質(zhì)：最基本的，你能了解應試者 C語言的水平。不管怎么樣，看一下這人如何回答他不會的問題也是滿有趣。應試者是以好的直覺做出明智的選擇，還是只是瞎蒙呢？當應試者在某個問題上卡住時是找借口呢，還是表現(xiàn)出對問題的真正的好奇心，把這看成學習的機會呢？我發(fā)現(xiàn)這些信息與他們的測試成績一樣有用。有了這些想法，我決定出一些真正針對嵌入式系統(tǒng)的考題，希望這些令人頭痛的考題能給正在找工作的人一點幫住。這些問題都是我這些年實際碰到的。其中有些題很難，但它們應該都能給你一點啟迪。這個測試適于不同水平的應試者，大多數(shù)初級水平的應試者的成績會很差，經(jīng)驗豐富的程序員應該有很好的成績。為了讓你能自己決定某些問題的偏好，每個問題沒有分配分數(shù)，如果選擇這些考題為你所用，請自行按你的意思分配分數(shù)。預處理器（ Preprocessor）1 . 用預處理指令#define聲明一個常數(shù)，用以表明 1年中有多少秒（忽略閏年問題）#define SECONDS_PER_YEAR (60 * 60 * 24 * 365)UL我在這想看到幾件事情：?; #define 語法的基本知識（例如：不能以分號結(jié)束，括號的使用，等等）?; 懂得預處理器將為你計算常數(shù)表達式的值，因此，直接寫出你是如何計算一年中有多少秒而不是計算出實際的值，是更清晰而沒有代價的。?; 意識到這個表達式將使一個16 位機的整型數(shù)溢出-因此要用到長整型符號L,告訴編譯器這個常數(shù)是的長整型數(shù)。?; 如果你在你的表達式中用到UL（表示無符號長整型），那么你有了一個好的起點。記住，第一印象很重要。2 . 寫一個"標準"宏MIN ，這個宏輸入兩個參數(shù)并返回較小的一個。#define MIN(A,B) （（A）<= (B) ? (A) : (B))這個測試是為下面的目的而設的：?; 標識#define在宏中應用的基本知識。這是很重要的，因為直到嵌入(inline)操作符變?yōu)闃藴蔆的一部分，宏是方便產(chǎn)生嵌入代碼的唯一方法，對于嵌入式系統(tǒng)來說，為了能達到要求的性能，嵌入代碼經(jīng)常是必須的方法。?; 三重條件操作符的知識。這個操作符存在C 語言中的原因是它使得編譯器能產(chǎn)生比if-then-else 更優(yōu)化的代碼，了解這個用法是很重要的。?; 懂得在宏中小心地把參數(shù)用括號括起來?; 我也用這個問題開始討論宏的副作用，例如：當你寫下面的代碼時會發(fā)生什么事？least = MIN(*p++, b);3. 預處理器標識#error的目的是什么？如果你不知道答案，請看參考文獻 1。這問題對區(qū)分一個正常的伙計和一個書呆子是很有用的。只有書呆子才會讀C 語言課本的附錄去找出象這種問題的答案。當然如果你不是在找一個書呆子，那么應試者最好希望自己不要知道答案。死循環(huán)（ Infinite loops）4. 嵌入式系統(tǒng)中經(jīng)常要用到無限循環(huán)，你怎么樣用C 編寫死循環(huán)呢？16這個問題用幾個解決方案。我首選的方案是：while(1){?}一些程序員更喜歡如下方案：for(;;){?}這個實現(xiàn)方式讓我為難，因為這個語法沒有確切表達到底怎么回事。如果一個應試者給出這個作為方案，我將用這個作為一個機會去探究他們這樣做的基本原理。如果他們的基本答案是： "我被教著這樣做，但從沒有想到過為什么。"這會給我留下一個壞印象。第三個方案是用 gotoLoop:...goto Loop;應試者如給出上面的方案，這說明或者他是一個匯編語言程序員（這也許是好事）或者他是一個想進入新領域的BASIC/FORTRAN 程序員。數(shù)據(jù)聲明（ Data declarations）5. 用變量a 給出下面的定義a) 一個整型數(shù)（An integer）b)一個指向整型數(shù)的指針（A pointer to an integer）c)一個指向指針的的指針，它指向的指針是指向一個整型數(shù)（A pointer to a pointer to an intege）rd)一個有 10個整型數(shù)的數(shù)組（An array of 10 integers）e) 一個有10 個指針的數(shù)組，該指針是指向一個整型數(shù)的。（An array of 10 pointers to integers）f) 一個指向有10 個整型數(shù)數(shù)組的指針（A pointer to an array of 10 integers）g) 一個指向函數(shù)的指針，該函數(shù)有一個整型參數(shù)并返回一個整型數(shù)（A pointer to a function that takes an integer as an argumentand returns an integer）h)一個有10 個指針的數(shù)組，該指針指向一個函數(shù)，該函數(shù)有一個整型參數(shù)并返回一個整型數(shù)（An array of ten pointers to functions that take an integer argument and return an integer ）答案是：a) int a; // An integerb) int *a; // A pointer to an integerc) int **a; // A pointer to a pointer to an integerd) int a[10]; // An array of 10 integerse) int *a[10]; // An array of 10 pointers to integersf) int (*a)[10]; // A pointer to an array of 10 integersg) int (*a)(int); // A pointer to a function a that takes an integer argument and returns an integerh) int (*a[10])(int); // An array of 10 pointers to functions that take an integer argument and return an integer人們經(jīng)常聲稱這里有幾個問題是那種要翻一下書才能回答的問題，我同意這種說法。當我寫這篇文章時，為了確定語法的正確性，我的確查了一下書。但是當我被面試的時候，我期望被問到這個問題（或者相近的問題）。因為在被面試的這段時間里，我確定我知道這個問題的答案。應試者如果不知道所有的答案（或至少大部分答案），那么也就沒有為這次面試做準備，如果該面試者沒有為這次面試做準備，那么他又能為什么出準備呢？17Static6. 關鍵字 static的作用是什么？這個簡單的問題很少有人能回答完全。在 C 語言中，關鍵字 static有三個明顯的作用：?; 在函數(shù)體，一個被聲明為靜態(tài)的變量在這一函數(shù)被調(diào)用過程中維持其值不變。?; 在模塊內(nèi)（但在函數(shù)體外），一個被聲明為靜態(tài)的變量可以被模塊內(nèi)所用函數(shù)訪問，但不能被模塊外其它函數(shù)訪問。它是一個本地的全局變量。?; 在模塊內(nèi)，一個被聲明為靜態(tài)的函數(shù)只可被這一模塊內(nèi)的其它函數(shù)調(diào)用。那就是，這個函數(shù)被限制在聲明它的模塊的本地范圍內(nèi)使用。大多數(shù)應試者能正確回答第一部分，一部分能正確回答第二部分，同是很少的人能懂得第三部分。這是一個應試者的嚴重的缺點，因為他顯然不懂得本地化數(shù)據(jù)和代碼范圍的好處和重要性。Const7．關鍵字 const有什么含意？我只要一聽到被面試者說： "const 意味著常數(shù)"，我就知道我正在和一個業(yè)余者打交道。去年Dan Saks 已經(jīng)在他的文章里完全概括了const的所有用法，因此 ESP(譯者：Embedded Systems Programming)的每一位讀者應該非常熟悉const 能做什么和不能做什么.如果你從沒有讀到那篇文章，只要能說出 const 意味著"只讀"就可以了。盡管這個答案不是完全的答案，但我接受它作為一個正確的答案。（如果你想知道更詳細的答案，仔細讀一下 Saks 的文章吧。）如果應試者能正確回答這個問題，我將問他一個附加的問題：下面的聲明都是什么意思？const int a;int const a;const int *a;int * const a;int const * a const;/******/前兩個的作用是一樣， a是一個常整型數(shù)。第三個意味著 a是一個指向常整型數(shù)的指針（也就是，整型數(shù)是不可修改的，但指針可以）。第四個意思 a 是一個指向整型數(shù)的常指針（也就是說，指針指向的整型數(shù)是可以修改的，但指針是不可修改的）。最后一個意味著a 是一個指向常整型數(shù)的常指針（也就是說，指針指向的整型數(shù)是不可修改的，同時指針也是不可修改的）。如果應試者能正確回答這些問題，那么他就給我留下了一個好印象。順帶提一句，也許你可能會問，即使不用關鍵字 const，也還是能很容易寫出功能正確的程序，那么我為什么還要如此看重關鍵字 const 呢？我也如下的幾下理由：?; 關鍵字const 的作用是為給讀你代碼的人傳達非常有用的信息，實際上，聲明一個參數(shù)為常量是為了告訴了用戶這個參數(shù)的應用目的。如果你曾花很多時間清理其它人留下的垃圾，你就會很快學會感謝這點多余的信息。（當然，懂得用 const的程序員很少會留下的垃圾讓別人來清理的。）?; 通過給優(yōu)化器一些附加的信息，使用關鍵字const 也許能產(chǎn)生更緊湊的代碼。?; 合理地使用關鍵字const 可以使編譯器很自然地保護那些不希望被改變的參數(shù)，防止其被無意的代碼修改。簡而言之，這樣可以減少bug的出現(xiàn)。Volatile8. 關鍵字 volatile有什么含意?并給出三個不同的例子。一個定義為 volatile 的變量是說這變量可能會被意想不到地改變，這樣，編譯器就不會去假設這個變量的值了。精確地說就是，優(yōu)化器在用到這個變量時必須每次都小心地重新讀取這個變量的值，而不是使用保存在寄存器里的備份。下面是 volatile變量的幾個例子：18?; 并行設備的硬件寄存器（如：狀態(tài)寄存器）?; 一個中斷服務子程序中會訪問到的非自動變量(Non-automatic variables)?; 多線程應用中被幾個任務共享的變量回答不出這個問題的人是不會被雇傭的。我認為這是區(qū)分 C程序員和嵌入式系統(tǒng)程序員的最基本的問題。搞嵌入式的家伙們經(jīng)常同硬件、中斷、RTOS 等等打交道，所有這些都要求用到volatile 變量。不懂得volatile 的內(nèi)容將會帶來災難。假設被面試者正確地回答了這是問題（嗯，懷疑是否會是這樣），我將稍微深究一下，看一下這家伙是不是直正懂得 volatile完全的重要性。?; 一個參數(shù)既可以是const 還可以是volatile 嗎？解釋為什么。?; 一個指針可以是volatile 嗎？解釋為什么。?; 下面的函數(shù)有什么錯誤：int square(volatile int *ptr){return *ptr * *ptr;}下面是答案：?; 是的。一個例子是只讀的狀態(tài)寄存器。它是volatile 因為它可能被意想不到地改變。它是const 因為程序不應該試圖去修改它。?; 是的。盡管這并不很常見。一個例子是當一個中服務子程序修該一個指向一個buffer 的指針時。?; 這段代碼有點變態(tài)。這段代碼的目的是用來返指針*ptr指向值的平方，但是，由于*ptr指向一個 volatile型參數(shù)，編譯器將產(chǎn)生類似下面的代碼：int square(volatile int *ptr){int a,b;a = *ptr;b = *ptr;return a * b;}由于*ptr的值可能被意想不到地該變，因此 a和 b可能是不同的。結(jié)果，這段代碼可能返不是你所期望的平方值！正確的代碼如下：long square(volatile int *ptr){int a;a = *ptr;return a * a;}位操作（ Bit manipulation）9. 嵌入式系統(tǒng)總是要用戶對變量或寄存器進行位操作。給定一個整型變量a，寫兩段代碼，第一個設置a 的bit 3，第二個清除a 的bit 3。在以上兩個操作中，要保持其它位不變。19對這個問題有三種基本的反應?; 不知道如何下手。該被面者從沒做過任何嵌入式系統(tǒng)的工作。?; 用bit fields。Bit fields 是被扔到C 語言死角的東西，它保證你的代碼在不同編譯器之間是不可移植的，同時也保證了的你的代碼是不可重用的。我最近不幸看到 Infineon 為其較復雜的通信芯片寫的驅(qū)動程序，它用到了 bit fields因此完全對我無用，因為我的編譯器用其它的方式來實現(xiàn) bit fields 的。從道德講：永遠不要讓一個非嵌入式的家伙粘實際硬件的邊。?; 用#defines 和bit masks 操作。這是一個有極高可移植性的方法，是應該被用到的方法。最佳的解決方案如下：#define BIT3 (0x1 << 3)static int a;void set_bit3(void) {a |= BIT3;}void clear_bit3(void) {a &= ~BIT3;}一些人喜歡為設置和清除值而定義一個掩碼同時定義一些說明常數(shù)，這也是可以接受的。我希望看到幾個要點：說明常數(shù)、|=和&=~操作。訪問固定的內(nèi)存位置（ accessing fixed memory locations）10. 嵌入式系統(tǒng)經(jīng)常具有要求程序員去訪問某特定的內(nèi)存位置的特點。在某工程中，要求設置一絕對地址為0x67a9 的整型變量的值為0xaa66。編譯器是一個純粹的 ANSI編譯器。寫代碼去完成這一任務。這一問題測試你是否知道為了訪問一絕對地址把一個整型數(shù)強制轉(zhuǎn)換（ typecast）為一指針是合法的。這一問題的實現(xiàn)方式隨著個人風格不同而不同。典型的類似代碼如下：int *ptr;ptr = (int *)0x67a9;*ptr = 0xaa55;A more obscure approach is:一個較晦澀的方法是：*(int * const)(0x67a9) = 0xaa55;即使你的品味更接近第二種方案，但我建議你在面試時使用第一種方案。中斷（ Interrupts）11. 中斷是嵌入式系統(tǒng)中重要的組成部分，這導致了很多編譯開發(fā)商提供一種擴展―讓標準C 支持中斷。具代表事實是，產(chǎn)生了一個新的關鍵字__interrupt。下面的代碼就使用了__interrupt關鍵字去定義了一個中斷服務子程序(ISR)，請評論一下這段代碼的。__interrupt double compute_area (double radius){20double area = PI * radius * radius;printf("/nArea = %f", area);return area;}這個函數(shù)有太多的錯誤了，以至讓人不知從何說起了：?; ISR 不能返回一個值。如果你不懂這個，那么你不會被雇用的。?; ISR 不能傳遞參數(shù)。如果你沒有看到這一點，你被雇用的機會等同第一項。?; 在許多的處理器/編譯器中，浮點一般都是不可重入的。有些處理器/編譯器需要讓額處的寄存器入棧，有些處理器/編譯器就是不允許在ISR 中做浮點運算。此外， ISR應該是短而有效率的，在 ISR中做浮點運算是不明智的。?; 與第三點一脈相承，printf()經(jīng)常有重入和性能上的問題。如果你丟掉了第三和第四點，我不會太為難你的。不用說，如果你能得到后兩點，那么你的被雇用前景越來越光明了。*****代碼例子（ Code examples）12 . 下面的代碼輸出是什么，為什么？void foo(void){unsigned int a = 6;int b = -20;(a+b > 6) ? puts("> 6") : puts("<= 6");}這個問題測試你是否懂得 C語言中的整數(shù)自動轉(zhuǎn)換原則，我發(fā)現(xiàn)有些開發(fā)者懂得極少這些東西。不管如何，這無符號整型問題的答案是輸出是">6"。原因是當表達式中存在有符號類型和無符號類型時所有的操作數(shù)都自動轉(zhuǎn)換為無符號類型。因此-20變成了一個非常大的正整數(shù)，所以該表達式計算出的結(jié)果大于 6。這一點對于應當頻繁用到無符號數(shù)據(jù)類型的嵌入式系統(tǒng)來說是豐常重要的。如果你答錯了這個問題，你也就到了得不到這份工作的邊緣。13. 評價下面的代碼片斷：unsigned int zero = 0;unsigned int compzero = 0xFFFF;/*1's complement of zero */對于一個 int型不是 16位的處理器為說，上面的代碼是不正確的。應編寫如下：unsigned int compzero = ~0;這一問題真正能揭露出應試者是否懂得處理器字長的重要性。在我的經(jīng)驗里，好的嵌入式程序員非常準確地明白硬件的細節(jié)和它的局限，然而PC 機程序往往把硬件作為一個無法避免的煩惱。到了這個階段，應試者或者完全垂頭喪氣了或者信心滿滿志在必得。如果顯然應試者不是很好，那么這個測試就在這里結(jié)束了。但如果顯然應試者做得不錯，那么我就扔出下面的追加問題，這些問題是比較難的，我想僅僅非常優(yōu)秀的應試者能做得不錯。提出這些問題，我希望更多看到應試者應付問題的方法，而不是答案。不管如何，你就當是這個娛樂吧...21動態(tài)內(nèi)存分配（ Dynamic memory allocation）14. 盡管不像非嵌入式計算機那么常見，嵌入式系統(tǒng)還是有從堆（heap）中動態(tài)分配內(nèi)存的過程的。那么嵌入式系統(tǒng)中，動態(tài)分配內(nèi)存可能發(fā)生的問題是什么？這里，我期望應試者能提到內(nèi)存碎片，碎片收集的問題，變量的持行時間等等。這個主題已經(jīng)在 ESP雜志中被廣泛地討論過了（主要是 P.J.Plauger, 他的解釋遠遠超過我這里能提到的任何解釋），所有回過頭看一下這些雜志吧！讓應試者進入一種虛假的安全感覺后，我拿出這么一個小節(jié)目：下面的代碼片段的輸出是什么，為什么？char *ptr;if ((ptr = (char *)malloc(0)) ==NULL)elseputs("Got a null pointer");puts("Got a valid pointer");這是一個有趣的問題。最近在我的一個同事不經(jīng)意把 0值傳給了函數(shù) malloc，得到了一個合法的指針之后，我才想到這個問題。這就是上面的代碼，該代碼的輸出是"Got a valid pointer"。我用這個來開始討論這樣的一問題，看看被面試者是否想到庫例程這樣做是正確。得到正確的答案固然重要，但解決問題的方法和你做決定的基本原理更重要些。Typedef:15 Typedef 在 C語言中頻繁用以聲明一個已經(jīng)存在的數(shù)據(jù)類型的同義字。也可以用預處理器做類似的事。例如，思考一下下面的例子：#define dPS struct s *typedef struct s * tPS;以上兩種情況的意圖都是要定義 dPS和 tPS作為一個指向結(jié)構 s指針。哪種方法更好呢？（如果有的話）為什么？這是一個非常微妙的問題，任何人答對這個問題（正當?shù)脑颍┦菓敱还驳摹４鸢甘牵?typedef更好。思考下面的例子：dPS p1,p2;tPS p3,p4;第一個擴展為struct s * p1, p2;.上面的代碼定義 p1為一個指向結(jié)構的指， p2為一個實際的結(jié)構，這也許不是你想要的。第二個例子正確地定義了 p3和 p4兩個指針。晦澀的語法16 . C 語言同意一些令人震驚的結(jié)構,下面的結(jié)構是合法的嗎，如果是它做些什么？int a = 5, b = 7, c;c = a+++b;22這個問題將做為這個測驗的一個愉快的結(jié)尾。不管你相不相信，上面的例子是完全合乎語法的。問題是編譯器如何處理它？水平不高的編譯作者實際上會爭論這個問題，根據(jù)最處理原則，編譯器應當能處理盡可能所有合法的用法。因此，上面的代碼被處理成：c = a++ + b;因此,這段代碼持行后 a = 6, b = 7, c = 12。如果你知道答案，或猜出正確答案，做得好。如果你不知道答案，我也不把這個當作問題。我發(fā)現(xiàn)這個問題的最大好處是這是一個關于代碼編寫風格，代碼的可讀性，代碼的可修改性的好的話題。好了，伙計們，你現(xiàn)在已經(jīng)做完所有的測試了。這就是我出的 C語言測試題，我懷著愉快的心情寫完它，希望你以同樣的心情讀完它。如果是認為這是一個好的測試，那么盡量都用到你的找工作的過程中去吧。天知道也許過個一兩年，我就不做現(xiàn)在的工作，也需要找一個。Nigel Jones 是一個顧問，現(xiàn)在住在Maryland，當他不在水下時，你能在多個范圍的嵌入項目中找到他。他很高興能收到讀者的來信，他的email 地址是: NAJones@compuserve.com。References?; Jones, Nigel, "In Praise of the #error directive," Embedded Systems Programming, September 1999, p. 114.?; Jones, Nigel, " Efficient C Code for Eight-bit MCUs ," Embedded Systems Programming, November 1998, p. 66C 語言嵌入式系統(tǒng)編程修煉C 語言嵌入式系統(tǒng)編程修煉之一:背景篇作者:宋寶華更新日期:2005-08-30來源:yesky.com不同于一般形式的軟件編程，嵌入式系統(tǒng)編程建立在特定的硬件平臺上，勢必要求其編程語言具備較強的硬件直接操作能力。無疑，匯編語言具備這樣的特質(zhì)。但是，歸因于匯編語言開發(fā)過程的復雜性，它并不是嵌入式系統(tǒng)開發(fā)的一般選擇。而與之相比，C 語言--一種"高級的低級"語言，則成為嵌入式系統(tǒng)開發(fā)的最佳選擇。筆者在嵌入式系統(tǒng)項目的開發(fā)過程中，一次又一次感受到 C 語言的精妙，沉醉于 C 語言給嵌入式開發(fā)帶來的便利。圖 1 給出了本文的討論所基于的硬件平臺，實際上，這也是大多數(shù)嵌入式系統(tǒng)的硬件平臺。它包括兩部分：（1）以通用處理器為中心的協(xié)議處理模塊，用于網(wǎng)絡控制協(xié)議的處理；（2）以數(shù)字信號處理器（DSP）為中心的信號處理模塊，用于調(diào)制、解調(diào)和數(shù)/模信號轉(zhuǎn)換。本文的討論主要圍繞以通用處理器為中心的協(xié)議處理模塊進行，因為它更多地牽涉到具體的 C 語言編程技巧。而 DSP編程則重點關注具體的數(shù)字信號處理算法，主要涉及通信領域的知識，不是本文的討論重點。23著眼于討論普遍的嵌入式系統(tǒng) C 編程技巧，系統(tǒng)的協(xié)議處理模塊沒有選擇特別的 CPU，而是選擇了眾所周知的 CPU 芯片--80186，每一位學習過《微機原理》的讀者都應該對此芯片有一個基本的認識，且對其指令集比較熟悉。80186 的字長是 16 位，可以尋址到的內(nèi)存空間為 1MB，只有實地址模式。C 語言編譯生成的指針為 32 位（雙字），高 16 位為段地址，低16 位為段內(nèi)偏移，一段最多 64KB。圖 1 系統(tǒng)硬件架構協(xié)議處理模塊中的 Flash 和 RAM 幾乎是每個嵌入式系統(tǒng)的必備設備，前者用于存儲程序，后者則是程序運行時指令及數(shù)據(jù)的存放位置。系統(tǒng)所選擇的 FLASH 和 RAM 的位寬都為 16 位，與 CPU 一致。實時鐘芯片可以為系統(tǒng)定時，給出當前的年、月、日及具體時間（小時、分、秒及毫秒），可以設定其經(jīng)過一段時間即向 CPU 提出中斷或設定報警時間到來時向 CPU 提出中斷（類似鬧鐘功能）。NVRAM（非易失去性 RAM）具有掉電不丟失數(shù)據(jù)的特性，可以用于保存系統(tǒng)的設置信息，譬如網(wǎng)絡協(xié)議參數(shù)等。在系統(tǒng)掉電或重新啟動后，仍然可以讀取先前的設置信息。其位寬為 8 位，比 CPU 字長小。文章特意選擇一個與 CPU 字長不一致的存儲芯片，為后文中一節(jié)的討論創(chuàng)造條件。UART 則完成 CPU 并行數(shù)據(jù)傳輸與 RS-232 串行數(shù)據(jù)傳輸?shù)霓D(zhuǎn)換，它可以在接收到[1~MAX_BUFFER]字節(jié)后向 CPU 提出中斷，MAX_BUFFER 為 UART 芯片存儲接收到字節(jié)的最大緩沖區(qū)。鍵盤控制器和顯示控制器則完成系統(tǒng)人機界面的控制。以上提供的是一個較完備的嵌入式系統(tǒng)硬件架構，實際的系統(tǒng)可能包含更少的外設。之所以選擇一個完備的系統(tǒng)，是為了后文更全面的討論嵌入式系統(tǒng) C 語言編程技巧的方方面面，所有設備都會成為后文的分析目標。嵌入式系統(tǒng)需要良好的軟件開發(fā)環(huán)境的支持，由于嵌入式系統(tǒng)的目標機資源受限，不可能在其上建立龐大、復雜的開發(fā)環(huán)境，因而其開發(fā)環(huán)境和目標運行環(huán)境相互分離。因此，嵌入式應用軟件的開發(fā)方式一般是，在宿主機(Host)上建立開發(fā)環(huán)境，進行應用程序編碼和交叉編譯，然后宿主機同目標機(Target)建立連接，將應用程序下載到目標機上進行交叉調(diào)試，經(jīng)過調(diào)試和優(yōu)化，最后將應用程序固化到目標機中實際運行。CAD-UL 是適用于 x86 處理器的嵌入式應用軟件開發(fā)環(huán)境，它運行在 Windows 操作系統(tǒng)之上，可生成 x86 處理器的目標24代碼并通過 PC 機的 COM 口（RS-232 串口）或以太網(wǎng)口下載到目標機上運行，如圖 2。其駐留于目標機 FLASH 存儲器中的monitor 程序可以監(jiān)控宿主機 Windows 調(diào)試平臺上的用戶調(diào)試指令，獲取 CPU 寄存器的值及目標機存儲空間、I/O 空間的內(nèi)容。圖 2 交叉開發(fā)環(huán)境后續(xù)章節(jié)將從軟件架構、內(nèi)存操作、屏幕操作、鍵盤操作、性能優(yōu)化等多方面闡述 C 語言嵌入式系統(tǒng)的編程技巧。軟件架構是一個宏觀概念，與具體硬件的聯(lián)系不大；內(nèi)存操作主要涉及系統(tǒng)中的 FLASH、 RAM 和 NVRAM 芯片；屏幕操作則涉及顯示控制器和實時鐘；鍵盤操作主要涉及鍵盤控制器；性能優(yōu)化則給出一些具體的減小程序時間、空間消耗的技巧。在我們的修煉旅途中將經(jīng)過 25 個關口，這些關口主分為兩類，一類是技巧型，有很強的適用性；一類則是常識型，在理論上有些意義。C 語言嵌入式系統(tǒng)編程修煉之二:軟件架構篇作者:宋寶華更新日期:2005-07-22模塊劃分模塊劃分的"劃"是規(guī)劃的意思，意指怎樣合理的將一個很大的軟件劃分為一系列功能獨立的部分合作完成系統(tǒng)的需求。C 語言作為一種結(jié)構化的程序設計語言，在模塊的劃分上主要依據(jù)功能（依功能進行劃分在面向?qū)ο笤O計中成為一個錯誤，牛頓定律遇到了>相對論），C 語言模塊化程序設計需理解如下概念：（1）模塊即是一個.c 文件和一個.h 文件的結(jié)合，頭文件(.h)中是對于該模塊接口的聲明；（2）某模塊提供給其它模塊調(diào)用的外部函數(shù)及數(shù)據(jù)需在.h 中文件中冠以 extern 關鍵字聲明；（3）模塊內(nèi)的函數(shù)和全局變量需在.c 文件開頭冠以 static 關鍵字聲明；（4）永遠不要在.h 文件中定義變量！定義變量和聲明變量的區(qū)別在于定義會產(chǎn)生內(nèi)存分配的操作，是匯編階段的概念；而聲明則只是告訴包含該聲明的模塊在連接階段從其它模塊尋找外部函數(shù)和變量。如：/*module1.h*/int a = 5; /* 在模塊 1 的.h 文件中定義 int a *//*module1 .c*/#include "module1.h" /* 在模塊 1 中包含模塊 1 的.h 文件 */25/*module2 .c*/#include "module1.h" /* 在模塊 2 中包含模塊 1 的.h 文件 *//*module3 .c*/#include "module1.h" /* 在模塊 3 中包含模塊 1 的.h 文件 */以上程序的結(jié)果是在模塊 1、2、3 中都定義了整型變量 a，a 在不同的模塊中對應不同的地址單元，這個世界上從來不需要這樣的程序。正確的做法是：/*module1.h*/extern int a; /* 在模塊 1 的.h 文件中聲明 int a *//*module1 .c*/#include "module1.h" /* 在模塊 1 中包含模塊 1 的.h 文件 */int a = 5; /* 在模塊 1 的.c 文件中定義 int a *//*module2 .c*/#include "module1.h" /* 在模塊 2 中包含模塊 1 的.h 文件 *//*module3 .c*/#include "module1.h" /* 在模塊 3 中包含模塊 1 的.h 文件 */這樣如果模塊 1、2、3 操作 a 的話，對應的是同一片內(nèi)存單元。一個嵌入式系統(tǒng)通常包括兩類模塊：（1）硬件驅(qū)動模塊，一種特定硬件對應一個模塊；（2）軟件功能模塊，其模塊的劃分應滿足低偶合、高內(nèi)聚的要求。多任務還是單任務所謂"單任務系統(tǒng)"是指該系統(tǒng)不能支持多任務并發(fā)操作，宏觀串行地執(zhí)行一個任務。而多任務系統(tǒng)則可以宏觀并行（微觀上可能串行）地"同時"執(zhí)行多個任務。多任務的并發(fā)執(zhí)行通常依賴于一個多任務操作系統(tǒng) （OS），多任務 OS 的核心是系統(tǒng)調(diào)度器，它使用任務控制塊（TCB）來管理任務調(diào)度功能。TCB 包括任務的當前狀態(tài)、優(yōu)先級、要等待的事件或資源、任務程序碼的起始地址、初始堆棧指針等信息。調(diào)度器在任務被激活時，要用到這些信息。此外，TCB 還被用來存放任務的"上下文"（context)。任務的上下文就是當一個執(zhí)行中的任務被停止時，所要保存的所有信息。通常，上下文就是計算機當前的狀態(tài)，也即各個寄存器的內(nèi)容。當發(fā)生任務切換時，當前運行的任務的上下文被存入 TCB，并將要被執(zhí)行的任務的上下文從它的 TCB 中取出，放入各個寄存器中。嵌入式多任務 OS 的典型例子有 Vxworks、ucLinux 等。嵌入式 OS 并非遙不可及的神壇之物，我們可以用不到 100026行代碼實現(xiàn)一個針對 80186 處理器的功能最簡單的 OS 內(nèi)核，作者正準備進行此項工作，希望能將心得貢獻給大家。究竟選擇多任務還是單任務方式，依賴于軟件的體系是否龐大。例如，絕大多數(shù)手機程序都是多任務的，但也有一些小靈通的協(xié)議棧是單任務的，沒有操作系統(tǒng)，它們的主程序輪流調(diào)用各個軟件模塊的處理程序，模擬多任務環(huán)境。單任務程序典型架構（1）從 CPU 復位時的指定地址開始執(zhí)行；（2）跳轉(zhuǎn)至匯編代碼 startup 處執(zhí)行；（3）跳轉(zhuǎn)至用戶主程序 main 執(zhí)行，在 main 中完成：a.初試化各硬件設備；b.初始化各軟件模塊；c.進入死循環(huán)（無限循環(huán)），調(diào)用各模塊的處理函數(shù)用戶主程序和各模塊的處理函數(shù)都以 C 語言完成。用戶主程序最后都進入了一個死循環(huán)，其首選方案是：while(1){}有的程序員這樣寫：for(;;){}這個語法沒有確切表達代碼的含義，我們從 for(;;)看不出什么，只有弄明白 for(;;)在 C 語言中意味著無條件循環(huán)才明白其意。下面是幾個"著名"的死循環(huán)：（1）操作系統(tǒng)是死循環(huán)；（2）WIN32 程序是死循環(huán)；（3）嵌入式系統(tǒng)軟件是死循環(huán)；（4）多線程程序的線程處理函數(shù)是死循環(huán)。你可能會辯駁，大聲說："凡事都不是絕對的，2、3、4 都可以不是死循環(huán)"。Yes，you are right，但是你得不到鮮27花和掌聲。實際上，這是一個沒有太大意義的牛角尖，因為這個世界從來不需要一個處理完幾個消息就喊著要 OS 殺死它的WIN32 程序，不需要一個剛開始 RUN 就自行了斷的嵌入式系統(tǒng)，不需要莫名其妙啟動一個做一點事就干掉自己的線程。有時候，過于嚴謹制造的不是便利而是麻煩。君不見，五層的 TCP/IP 協(xié)議棧超越嚴謹?shù)?ISO/OSI 七層協(xié)議棧大行其道成為事實上的標準？經(jīng)常有網(wǎng)友討論：printf("%d,%d",++i,i++); /* 輸出是什么？*/c = a+++b; /* c=? */等類似問題。面對這些問題，我們只能發(fā)出由衷的感慨：世界上還有很多有意義的事情等著我們?nèi)ハ瘮z入的食物。實際上，嵌入式系統(tǒng)要運行到世界末日。中斷服務程序中斷是嵌入式系統(tǒng)中重要的組成部分，但是在標準 C 中不包含中斷。許多編譯開發(fā)商在標準 C 上增加了對中斷的支持，提供新的關鍵字用于標示中斷服務程序 (ISR)，類似于__interrupt、#program interrupt 等。當一個函數(shù)被定義為 ISR的時候，編譯器會自動為該函數(shù)增加中斷服務程序所需要的中斷現(xiàn)場入棧和出棧代碼。中斷服務程序需要滿足如下要求：(1)不能返回值；(2)不能向 ISR 傳遞參數(shù)；(3) ISR 應該盡可能的短小精悍；(4) printf(char * lpFormatString,…)函數(shù)會帶來重入和性能問題，不能在 ISR 中采用。在某項目的開發(fā)中，我們設計了一個隊列，在中斷服務程序中，只是將中斷類型添加入該隊列中，在主程序的死循環(huán)中不斷掃描中斷隊列是否有中斷，有則取出隊列中的第一個中斷類型，進行相應處理。/* 存放中斷的隊列 */typedef struct tagIntQueue{int intType; /* 中斷類型 */struct tagIntQueue *next;}IntQueue;IntQueue lpIntQueueHead;__interrupt ISRexample (){28int intType;intType = GetSystemType();QueueAddTail(lpIntQueueHead, intType)；/* 在隊列尾加入新的中斷 */}在主程序循環(huán)中判斷是否有中斷：While(1){If( !IsIntQueueEmpty() ){intType = GetFirstInt();switch(intType) /* 是不是很象 WIN32 程序的消息解析函數(shù)? */{/* 對，我們的中斷類型解析很類似于消息驅(qū)動 */case xxx: /* 我們稱其為"中斷驅(qū)動"吧？ */…break;case xxx:…break;…}}}按上述方法設計的中斷服務程序很小，實際的工作都交由主程序執(zhí)行了。硬件驅(qū)動模塊一個硬件驅(qū)動模塊通常應包括如下函數(shù)：（1）中斷服務程序 ISR（2）硬件初始化a.修改寄存器，設置硬件參數(shù)（如 UART 應設置其波特率，AD/DA 設備應設置其采樣速率等）；b.將中斷服務程序入口地址寫入中斷向量表：/* 設置中斷向量表 */m_myPtr = make_far_pointer(0l); /* 返回 void far 型指針 void far * */m_myPtr += ITYPE_UART; /* ITYPE_UART： uart 中斷服務程序 *//* 相對于中斷向量表首地址的偏移 */29*m_myPtr = &UART _Isr; /* UART _Isr：UART 的中斷服務程序 */（3）設置 CPU 針對該硬件的控制線a.如果控制線可作 PIO（可編程 I/O）和控制信號用，則設置 CPU 內(nèi)部對應寄存器使其作為控制信號；b.設置 CPU 內(nèi)部的針對該設備的中斷屏蔽位，設置中斷方式（電平觸發(fā)還是邊緣觸發(fā)）。（ 4）提供一系列針對該設備的操作接口函數(shù)。例如，對于 LCD，其驅(qū)動模塊應提供繪制像素、畫線、繪制矩陣、顯示字符點陣等函數(shù)；而對于實時鐘，其驅(qū)動模塊則需提供獲取時間、設置時間等函數(shù)。C 的面向?qū)ο蠡诿嫦驅(qū)ο蟮恼Z言里面，出現(xiàn)了類的概念。類是對特定數(shù)據(jù)的特定操作的集合體。類包含了兩個范疇：數(shù)據(jù)和操作。而 C 語言中的 struct 僅僅是數(shù)據(jù)的集合，我們可以利用函數(shù)指針將 struct 模擬為一個包含數(shù)據(jù)和操作的"類"。下面的 C程序模擬了一個最簡單的"類"：#ifndef C_Class#define C_Class struct#endifC_Class A{C_Class A *A_this; /* this 指針 */void (*Foo)(C_Class A *A_this); /* 行為：函數(shù)指針 */int a; /* 數(shù)據(jù) */int b;};我們可以利用 C 語言模擬出面向?qū)ο蟮娜齻€特性：封裝、繼承和多態(tài)，但是更多的時候，我們只是需要將數(shù)據(jù)與行為封裝以解決軟件結(jié)構混亂的問題。C 模擬面向?qū)ο笏枷氲哪康牟辉谟谀M行為本身，而在于解決某些情況下使用 C 語言編程時程序整體框架結(jié)構分散、數(shù)據(jù)和函數(shù)脫節(jié)的問題。我們在后續(xù)章節(jié)會看到這樣的例子。總結(jié)本篇介紹了嵌入式系統(tǒng)編程軟件架構方面的知識，主要包括模塊劃分、多任務還是單任務選取、單任務程序典型架構、中斷服務程序、硬件驅(qū)動模塊設計等，從宏觀上給出了一個嵌入式系統(tǒng)軟件所包含的主要元素。請記住：軟件結(jié)構是軟件的靈魂！結(jié)構混亂的程序面目可憎，調(diào)試、測試、維護、升級都極度困難。小力力力 2005-09-21 17:2930C 語言嵌入式系統(tǒng)編程修煉之三:內(nèi)存操作作者:宋寶華更新日期:2005-07-22數(shù)據(jù)指針在嵌入式系統(tǒng)的編程中，常常要求在特定的內(nèi)存單元讀寫內(nèi)容，匯編有對應的 MOV 指令，而除 C/C++以外的其它編程語言基本沒有直接訪問絕對地址的能力。在嵌入式系統(tǒng)的實際調(diào)試中，多借助 C 語言指針所具有的對絕對地址單元內(nèi)容的讀寫能力。以指針直接操作內(nèi)存多發(fā)生在如下幾種情況：(1) 某 I/O 芯片被定位在 CPU 的存儲空間而非 I/O 空間，而且寄存器對應于某特定地址；(2) 兩個 CPU 之間以雙端口 RAM 通信，CPU 需要在雙端口 RAM 的特定單元（稱為 mail box）書寫內(nèi)容以在對方 CPU 產(chǎn)生中斷；(3) 讀取在 ROM 或 FLASH 的特定單元所燒錄的漢字和英文字模。譬如：unsigned char *p = (unsigned char *)0xF000FF00;*p=11;以上程序的意義為在絕對地址 0xF0000+0xFF00(80186 使用 16 位段地址和 16 位偏移地址)寫入 11。在使用絕對地址指針時，要注意指針自增自減操作的結(jié)果取決于指針指向的數(shù)據(jù)類別。上例中 p++后的結(jié)果是 p=0xF000FF01，若 p 指向 int，即：int *p = (int *)0xF000FF00;p++(或++p)的結(jié)果等同于：p = p+sizeof(int)，而 p-(或-p)的結(jié)果是 p = p-sizeof(int)。同理，若執(zhí)行：long int *p = (long int *)0xF000FF00;則 p++(或++p)的結(jié)果等同于：p = p+sizeof(long int) ，而 p-(或-p)的結(jié)果是 p = p-sizeof(long int)。記住： CPU 以字節(jié)為單位編址，而 C 語言指針以指向的數(shù)據(jù)類型長度作自增和自減。理解這一點對于以指針直接操作內(nèi)存是相當重要的。函數(shù)指針首先要理解以下三個問題：31（1）C 語言中函數(shù)名直接對應于函數(shù)生成的指令代碼在內(nèi)存中的地址，因此函數(shù)名可以直接賦給指向函數(shù)的指針；（2）調(diào)用函數(shù)實際上等同于"調(diào)轉(zhuǎn)指令＋參數(shù)傳遞處理＋回歸位置入棧"，本質(zhì)上最核心的操作是將函數(shù)生成的目標代碼的首地址賦給 CPU 的 PC 寄存器；（3）因為函數(shù)調(diào)用的本質(zhì)是跳轉(zhuǎn)到某一個地址單元的 code 去執(zhí)行，所以可以"調(diào)用"一個根本就不存在的函數(shù)實體，暈？請往下看：請拿出你可以獲得的任何一本大學《微型計算機原理》教材，書中講到，186 CPU 啟動后跳轉(zhuǎn)至絕對地址 0xFFFF0（對應 C 語言指針是 0xF000FFF0，0xF000 為段地址，0xFFF0 為段內(nèi)偏移）執(zhí)行，請看下面的代碼：typedef void (*lpFunction) ( ); /* 定義一個無參數(shù)、無返回類型的函數(shù)指針類型*//* 定義一個函數(shù)指針，指向 CPU 啟動后所執(zhí)行第一條指令的位置*/lpFunction lpReset = (lpFunction)0xF000FFF0;lpReset(); /* 調(diào)用函數(shù) */在以上的程序中，我們根本沒有看到任何一個函數(shù)實體，但是我們卻執(zhí)行了這樣的函數(shù)調(diào)用：lpReset()，它實際上起到了"軟重啟"的作用，跳轉(zhuǎn)到 CPU 啟動后第一條要執(zhí)行的指令的位置。記住：函數(shù)無它，唯指令集合耳；你可以調(diào)用一個沒有函數(shù)體的函數(shù)，本質(zhì)上只是換一個地址開始執(zhí)行指令！數(shù)組 vs.動態(tài)申請在嵌入式系統(tǒng)中動態(tài)內(nèi)存申請存在比一般系統(tǒng)編程時更嚴格的要求，這是因為嵌入式系統(tǒng)的內(nèi)存空間往往是十分有限的，不經(jīng)意的內(nèi)存泄露會很快導致系統(tǒng)的崩潰。所以一定要保證你的 malloc 和 free 成對出現(xiàn)，如果你寫出這樣的一段程序：char * function(void){char *p;p = (char *)malloc(…);if(p==NULL)…;… /* 一系列針對 p 的操作 */return p;}在某處調(diào)用 function()，用完 function 中動態(tài)申請的內(nèi)存后將其 free，如下：32char *q = function();…free(q);上述代碼明顯是不合理的，因為違反了 malloc 和 free 成對出現(xiàn)的原則，即"誰申請，就由誰釋放"原則。不滿足這個原則，會導致代碼的耦合度增大，因為用戶在調(diào)用 function 函數(shù)時需要知道其內(nèi)部細節(jié)！正確的做法是在調(diào)用處申請內(nèi)存，并傳入 function 函數(shù)，如下：char *p=malloc(…);if(p==NULL)…;function(p);…free(p);p=NULL;而函數(shù) function 則接收參數(shù) p，如下：void function(char *p){… /* 一系列針對 p 的操作 */}基本上，動態(tài)申請內(nèi)存方式可以用較大的數(shù)組替換。對于編程新手，筆者推薦你盡量采用數(shù)組！嵌入式系統(tǒng)可以以博大的胸襟接收瑕疵，而無法"海納"錯誤。畢竟，以最笨的方式苦練神功的郭靖勝過機智聰明卻范政治錯誤走反革命道路的楊康。給出原則：（1）盡可能的選用數(shù)組，數(shù)組不能越界訪問（真理越過一步就是謬誤，數(shù)組越過界限就光榮地成全了一個混亂的嵌入式系統(tǒng)）；（2）如果使用動態(tài)申請，則申請后一定要判斷是否申請成功了，并且 malloc 和 free 應成對出現(xiàn)！關鍵字 constconst 意味著"只讀"。區(qū)別如下代碼的功能非常重要，也是老生長嘆，如果你還不知道它們的區(qū)別，而且已經(jīng)在程序界摸爬滾打多年，那只能說這是一個悲哀：const int a;int const a;const int *a;int * const a;33int const * a const;（1）關鍵字 const 的作用是為給讀你代碼的人傳達非常有用的信息。例如，在函數(shù)的形參前添加 const 關鍵字意味著這個參數(shù)在函數(shù)體內(nèi)不會被修改，屬于"輸入?yún)?shù)"。在有多個形參的時候，函數(shù)的調(diào)用者可以憑借參數(shù)前是否有 const 關鍵字，清晰的辨別哪些是輸入?yún)?shù)，哪些是可能的輸出參數(shù)。（2）合理地使用關鍵字 const 可以使編譯器很自然地保護那些不希望被改變的參數(shù)，防止其被無意的代碼修改，這樣可以減少 bug 的出現(xiàn)。const 在 C++語言中則包含了更豐富的含義，而在 C 語言中僅意味著："只能讀的普通變量"，可以稱其為"不能改變的變量"（這個說法似乎很拗口，但卻最準確的表達了 C 語言中 const 的本質(zhì)），在編譯階段需要的常數(shù)仍然只能以#define宏定義！故在 C 語言中如下程序是非法的：const int SIZE = 10;char a[SIZE]; /* 非法：編譯階段不能用到變量 */關鍵字 volatileC 語言編譯器會對用戶書寫的代碼進行優(yōu)化，譬如如下代碼：int a,b,c;a = inWord(0x100); /*讀取 I/O 空間 0x100 端口的內(nèi)容存入 a 變量*/b = a;a = inWord (0x100); /*再次讀取 I/O 空間 0x100 端口的內(nèi)容存入 a 變量*/c = a;很可能被編譯器優(yōu)化為：int a,b,c;a = inWord(0x100); /*讀取 I/O 空間 0x100 端口的內(nèi)容存入 a 變量*/b = a;c = a;但是這樣的優(yōu)化結(jié)果可能導致錯誤，如果 I/O 空間 0x100 端口的內(nèi)容在執(zhí)行第一次讀操作后被其它程序?qū)懭胄?#20540;，則其實第 2 次讀操作讀出的內(nèi)容與第一次不同，b 和 c 的值應該不同。在變量 a 的定義前加上 volatile 關鍵字可以防止編譯器的類似優(yōu)化，正確的做法是：volatile int a；volatile 變量可能用于如下幾種情況：(1) 并行設備的硬件寄存器（如：狀態(tài)寄存器，例中的代碼屬于此類）；34(2) 一個中斷服務子程序中會訪問到的非自動變量(也就是全局變量)；(3) 多線程應用中被幾個任務共享的變量。CPU 字長與存儲器位寬不一致處理在背景篇中提到，本文特意選擇了一個與 CPU 字長不一致的存儲芯片，就是為了進行本節(jié)的討論，解決 CPU 字長與存儲器位寬不一致的情況。80186 的字長為 16，而 NVRAM 的位寬為 8，在這種情況下，我們需要為 NVRAM 提供讀寫字節(jié)、字的接口，如下：typedef unsigned char BYTE;typedef unsigned int WORD;/* 函數(shù)功能：讀 NVRAM 中字節(jié)* 參數(shù)：wOffset，讀取位置相對 NVRAM 基地址的偏移* 返回：讀取到的字節(jié)值*/extern BYTE ReadByteNVRAM(WORD wOffset){LPBYTE lpAddr = (BYTE*)(NVRAM + wOffset * 2); /* 為什么偏移要×2? */return *lpAddr;}/* 函數(shù)功能：讀 NVRAM 中字* 參數(shù)：wOffset，讀取位置相對 NVRAM 基地址的偏移* 返回：讀取到的字*/extern WORD ReadWordNVRAM(WORD wOffset){WORD wTmp = 0;LPBYTE lpAddr;/* 讀取高位字節(jié) */lpAddr = (BYTE*)(NVRAM + wOffset * 2); /* 為什么偏移要×2? */wTmp += (*lpAddr)*256;/* 讀取低位字節(jié) */lpAddr = (BYTE*)(NVRAM + (wOffset +1) * 2); /* 為什么偏移要×2? */wTmp += *lpAddr;return wTmp;}/* 函數(shù)功能：向 NVRAM 中寫一個字節(jié)*參數(shù)：wOffset，寫入位置相對 NVRAM 基地址的偏移* byData，欲寫入的字節(jié)*/35extern void WriteByteNVRAM(WORD wOffset, BYTE byData){…}/* 函數(shù)功能：向 NVRAM 中寫一個字 */*參數(shù)：wOffset，寫入位置相對 NVRAM 基地址的偏移* wData，欲寫入的字*/extern void WriteWordNVRAM(WORD wOffset, WORD wData){…}子貢問曰：Why 偏移要乘以 2?子曰：請看圖 1，16 位 80186 與 8 位 NVRAM 之間互連只能以地址線 A1 對其 A0,CPU 本身的 A0 與 NVRAM 不連接。因此，NVRAM 的地址只能是偶數(shù)地址，故每次以 0x10 為單位前進！圖 1 CPU 與 NVRAM 地址線連接子貢再問：So why 80186 的地址線 A0 不與 NVRAM 的 A0 連接？子曰：請看《IT 論語》之《微機原理篇》，那里面講述了關于計算機組成的圣人之道。總結(jié)本篇主要講述了嵌入式系統(tǒng) C 編程中內(nèi)存操作的相關技巧。掌握并深入理解關于數(shù)據(jù)指針、函數(shù)指針、動態(tài)申請內(nèi)存、const 及 volatile 關鍵字等的相關知識，是一個優(yōu)秀的 C 語言程序設計師的基本要求。當我們已經(jīng)牢固掌握了上述技巧后，我們就已經(jīng)學會了 C 語言的 99%，因為 C 語言最精華的內(nèi)涵皆在內(nèi)存操作中體現(xiàn)。我們之所以在嵌入式系統(tǒng)中使用 C 語言進行程序設計，99%是因為其強大的內(nèi)存操作能力！如果你愛編程，請你愛 C 語言；如果你愛 C 語言，請你愛指針；36如果你愛指針，請你愛指針的指針！C 語言嵌入式系統(tǒng)編程修煉之四:屏幕操作作者:宋寶華更新日期:2005-07-22漢字處理現(xiàn)在要解決的問題是，嵌入式系統(tǒng)中經(jīng)常要使用的并非是完整的漢字庫，往往只是需要提供數(shù)量有限的漢字供必要的顯示功能。例如，一個微波爐的 LCD 上沒有必要提供顯示"電子郵件"的功能；一個提供漢字顯示功能的空調(diào)的 LCD 上不需要顯示一條"短消息"，諸如此類。但是一部手機、小靈通則通常需要包括較完整的漢字庫。如果包括的漢字庫較完整，那么，由內(nèi)碼計算出漢字字模在庫中的偏移是十分簡單的：漢字庫是按照區(qū)位的順序排列的，前一個字節(jié)為該漢字的區(qū)號，后一個字節(jié)為該字的位號。每一個區(qū)記錄 94 個漢字，位號則為該字在該區(qū)中的位置。因此，漢字在漢字庫中的具體位置計算公式為：94*(區(qū)號-1)+位號-1。減 1 是因為數(shù)組是以 0 為開始而區(qū)號位號是以 1 為開始的。只需乘上一個漢字字模占用的字節(jié)數(shù)即可，即：(94*(區(qū)號-1)+位號-1)*一個漢字字模占用字節(jié)數(shù)，以 16*16 點陣字庫為例，計算公式則為：(94*(區(qū)號-1)+(位號-1))*32。漢字庫中從該位置起的 32 字節(jié)信息記錄了該字的字模信息。對于包含較完整漢字庫的系統(tǒng)而言，我們可以以上述規(guī)則計算字模的位置。但是如果僅僅是提供少量漢字呢？譬如幾十至幾百個？最好的做法是：定義宏：# define EX_FONT_CHAR(value)# define EX_FONT_UNICODE_VAL(value) (value),# define EX_FONT_ANSI_VAL(value) (value),定義結(jié)構體：typedef struct _wide_unicode_font16x16{WORD value; /* 內(nèi)碼 */BYTE data[32]; /* 字模點陣 */}Unicode;#define CHINESE_CHAR_NUM … /* 漢字數(shù)量 */字模的存儲用數(shù)組：Unicode chinese[CHINESE_CHAR_NUM] ={{EX_FONT_CHAR("業(yè)")EX_FONT_UNICODE_VAL(0x4e1a)37{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}}}要顯示特定漢字的時候，只需要從數(shù)組中查找內(nèi)碼與要求漢字內(nèi)碼相同的即可獲得字模。如果前面的漢字在數(shù)組中以內(nèi)碼大小順序排列，那么可以以二分查找法更高效的查找到漢字的字模。這是一種很有效的組織小漢字庫的方法，它可以保證程序有很好的結(jié)構。系統(tǒng)時間顯示從 NVRAM 中可以讀取系統(tǒng)的時間，系統(tǒng)一般借助 NVRAM 產(chǎn)生的秒中斷每秒讀取一次當前時間并在 LCD 上顯示。關于時間的顯示，有一個效率問題。因為時間有其特殊性，那就是 60 秒才有一次分鐘的變化，60 分鐘才有一次小時變化，如果我們每次都將讀取的時間在屏幕上完全重新刷新一次，則浪費了大量的系統(tǒng)時間。一個較好的辦法是我們在時間顯示函數(shù)中以靜態(tài)變量分別存儲小時、分鐘、秒，只有在其內(nèi)容發(fā)生變化的時候才更新其顯示。extern void DisplayTime(…){38static 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 具有了更加強大的威力，它使得某些數(shù)據(jù)和函數(shù)脫離"對象"而成為"類"的一部分，正是它的這一特點，成就了軟件的無數(shù)優(yōu)秀設計。動畫顯示動畫是無所謂有，無所謂無的，靜止的畫面走的路多了，也就成了動畫。隨著時間的變更，在屏幕上顯示不同的靜止畫面，即是動畫之本質(zhì)。所以，在一個嵌入式系統(tǒng)的 LCD 上欲顯示動畫，必須借助定時器。沒有硬件或軟件定時器的世界是無法想像的：（1）沒有定時器，一個操作系統(tǒng)將無法進行時間片的輪轉(zhuǎn)，于是無法進行多任務的調(diào)度，于是便不再成其為一個多任務操作系統(tǒng)；（2）沒有定時器，一個多媒體播放軟件將無法運作，因為它不知道何時應該切換到下一幀畫面；（3）沒有定時器，一個網(wǎng)絡協(xié)議將無法運轉(zhuǎn)，因為其無法獲知何時包傳輸超時并重傳之，無法在特定的時間完成特定的任務。因此，沒有定時器將意味著沒有操作系統(tǒng)、沒有網(wǎng)絡、沒有多媒體，這將是怎樣的黑暗？所以，合理并靈活地使用各種定時器，是對一個軟件人的最基本需求！在 80186 為主芯片的嵌入式系統(tǒng)中，我們需要借助硬件定時器的中斷來作為軟件定時器，在中斷發(fā)生后變更畫面的顯示內(nèi)容。在時間顯示"xx:xx"中讓冒號交替有無，每次秒中斷發(fā)生后，需調(diào)用 ShowDot：39void ShowDot(){static BOOL bShowDot = TRUE; /* 再一次領略 static 關鍵字的威力 */if(bShowDot){showChar(’:’,xPos,yPos);}else{showChar(’ ’,xPos,yPos);}bShowDot = ! bShowDot;}菜單操作無數(shù)人為之絞盡腦汁的問題終于出現(xiàn)了，在這一節(jié)里，我們將看到，在 C 語言中哪怕用到一丁點的面向?qū)ο笏枷耄浖Y(jié)構將會有何等的改觀！筆者曾經(jīng)是個笨蛋，被菜單搞暈了，給出這樣的一個系統(tǒng)：圖 1 菜單范例要求以鍵盤上的"← →"鍵切換菜單焦點，當用戶在焦點處于某菜單時，若敲擊鍵盤上的 OK、CANCEL 鍵則調(diào)用該焦點菜單對應之處理函數(shù)。我曾經(jīng)傻傻地這樣做著：/* 按下 OK 鍵 */void onOkKey(){/* 判斷在什么焦點菜單上按下 Ok 鍵，調(diào)用相應處理函數(shù) */Switch(currentFocus){case MENU1:menu1OnOk();break;case MENU2:menu2OnOk();break;…}}40/* 按下 Cancel 鍵 */void onCancelKey(){/* 判斷在什么焦點菜單上按下 Cancel 鍵，調(diào)用相應處理函數(shù) */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 鍵的處理函數(shù)指針 */void (*onCancelFun)(); /* 在該菜單上按下 cancel 鍵的處理函數(shù)指針 */}SysMenu, *LPSysMenu;當我定義菜單時，只需要這樣：static SysMenu menu[MENU_NUM] ={{"menu1", 0, 48, menu1OnOk, menu1OnCancel},{" menu2", 7, 48, menu2OnOk, menu2OnCancel},{" menu3", 7, 48, menu3OnOk, menu3OnCancel}41,{" menu4", 7, 48, menu4OnOk, menu4OnCancel}…};OK 鍵和 CANCEL 鍵的處理變成：/* 按下 OK 鍵 */void onOkKey(){menu[currentFocusMenu].onOkFun();}/* 按下 Cancel 鍵 */void onCancelKey(){menu[currentFocusMenu].onCancelFun();}程序被大大簡化了，也開始具有很好的可擴展性！我們僅僅利用了面向?qū)ο笾械姆庋b思想，就讓程序結(jié)構清晰，其結(jié)果是幾乎可以在無需修改程序的情況下在系統(tǒng)中添加更多的菜單，而系統(tǒng)的按鍵處理函數(shù)保持不變。面向?qū)ο螅嫔窳耍∧M MessageBox 函數(shù)MessageBox 函數(shù)，這個 Windows 編程中的超級猛料，不知道是多少入門者第一次用到的函數(shù)。還記得我們第一次在Windows 中利用 MessageBox 輸出 "Hello,World!"對話框時新奇的感覺嗎？無法統(tǒng)計，這個世界上究竟有多少程序員學習Windows 編程是從 MessageBox ("Hello,World!",…)開始的。在我本科的學校，廣泛流傳著一個詞匯，叫做"’Hello,World’級程序員"，意指入門級程序員，但似乎"’Hello,World’級"這個說法更搞笑而形象。圖 2 經(jīng)典的 Hello,World!圖 2 給出了兩種永恒經(jīng)典的 Hello,World 對話框，一種只具有"確定"，一種則包含"確定"、"取消"。是的，MessageBox的確有，而且也應該有兩類！這完全是由特定的應用需求決定的。嵌入式系統(tǒng)中沒有給我們提供 MessageBox，但是鑒于其功能強大，我們需要模擬之，一個模擬的 MessageBox 函數(shù)為：42/******************************************/* 函數(shù)名稱: MessageBox/* 功能說明: 彈出式對話框,顯示提醒用戶的信息/* 參數(shù)說明: 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); /* 顯示字符串 *//* 根據(jù)對話框類型決定是否顯示確定、取消 */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;}}43上述函數(shù)與我們平素在 VC++等中使用的 MessageBox 是何等的神似啊？實現(xiàn)這個函數(shù)，你會看到它在嵌入式系統(tǒng)中的妙用是無窮的。總結(jié)本篇是本系列文章中技巧性最深的一篇，它提供了嵌入式系統(tǒng)屏幕顯示方面一些很巧妙的處理方法，靈活使用它們，我們將不再被 LCD 上凌亂不堪的顯示內(nèi)容所困擾。屏幕乃嵌入式系統(tǒng)生存之重要輔助，面目可憎之顯示將另用戶逃之夭夭。屏幕編程若處理不好，將是軟件中最不系統(tǒng)、最混亂的部分，筆者曾深受其害。C 語言嵌入式系統(tǒng)編程修煉之五:鍵盤操作作者:宋寶華更新日期:2005-07-22處理功能鍵功能鍵的問題在于，用戶界面并非固定的，用戶功能鍵的選擇將使屏幕畫面處于不同的顯示狀態(tài)下。例如，主畫面如圖 1：圖 1 主畫面當用戶在設置 XX 上按下 Enter 鍵之后，畫面就切換到了設置 XX 的界面，如圖 2：圖 2 切換到設置 XX 畫面程序如何判斷用戶處于哪一畫面，并在該畫面的程序狀態(tài)下調(diào)用對應的功能鍵處理函數(shù)，而且保證良好的結(jié)構，是一個值得思考的問題。讓我們來看看 WIN32 編程中用到的"窗口"概念，當消息（message）被發(fā)送給不同窗口的時候，該窗口的消息處理函數(shù)44（是一個 callback 函數(shù)）最終被調(diào)用，而在該窗口的消息處理函數(shù)中，又根據(jù)消息的類型調(diào)用了該窗口中的對應處理函數(shù)。通過這種方式，WIN32 有效的組織了不同的窗口，并處理不同窗口情況下的消息。我們從中學習到的就是：（1）將不同的畫面類比為 WIN32 中不同的窗口，將窗口中的各種元素（菜單、按鈕等）包含在窗口之中；（2）給各個畫面提供一個功能鍵"消息"處理函數(shù)，該函數(shù)接收按鍵信息為參數(shù)；（3）在各畫面的功能鍵"消息"處理函數(shù)中，判斷按鍵類型和當前焦點元素，并調(diào)用對應元素的按鍵處理函數(shù)。/* 將窗口元素、消息處理函數(shù)封裝在窗口中 */struct windows{BYTE currentFocus;ELEMENT element[ELEMENT_NUM];void (*messageFun) (BYTE keyValue);…};/* 消息處理函數(shù) */void messageFunction(BYTE keyValue){BYTE i = 0;/* 獲得焦點元素 */while ( (element [i].ID!= currentFocus)&& (i < ELEMENT_NUM) ){i++;}/* "消息映射" */if(i < ELEMENT_NUM){switch(keyValue){case OK:element[i].OnOk();break;…}}}在窗口的消息處理函數(shù)中調(diào)用相應元素按鍵函數(shù)的過程類似于"消息映射"，這是我們從 WIN32 編程中學習到的。編程到了一個境界，很多東西都是相通的了。其它地方的思想可以拿過來為我所用，是為編程中的"拿來主義"。45在這個例子中，如果我們還想玩得更大一點，我們可以借鑒 MFC 中處理 MESSAGE_MAP 的方法，我們也可以學習 MFC 定義幾個精妙的宏來實現(xiàn)"消息映射"。處理數(shù)字鍵用戶輸入數(shù)字時是一位一位輸入的，每一位的輸入都對應著屏幕上的一個顯示位置（x 坐標，y 坐標）。此外，程序還需要記錄該位置輸入的值，所以有效組織用戶數(shù)字輸入的最佳方式是定義一個結(jié)構體，將坐標和數(shù)值捆綁在一起：/* 用戶數(shù)字輸入結(jié)構體 */typedef struct tagInputNum{BYTE byNum; /* 接收用戶輸入賦值 */BYTE xPos; /* 數(shù)字輸入在屏幕上的顯示位置 x 坐標 */BYTE yPos; /* 數(shù)字輸入在屏幕上的顯示位置 y 坐標 */}InputNum, *LPInputNum;那么接收用戶輸入就可以定義一個結(jié)構體數(shù)組，用數(shù)組中的各位組成一個完整的數(shù)字：InputNum inputElement[NUM_LENGTH]; /* 接收用戶數(shù)字輸入的數(shù)組 *//* 數(shù)字按鍵處理函數(shù) */extern void onNumKey(BYTE num){if(num==0|| num==1) /* 只接收二進制輸入 */{/* 在屏幕上顯示用戶輸入 */DrawText(inputElement[currentElementInputPlace].xPos,inputElement[currentElementInputPlace].yPos, "%1d", num);/* 將輸入賦值給數(shù)組元素 */inputElement[currentElementInputPlace].byNum = num;/* 焦點及光標右移 */moveToRight();}}將數(shù)字每一位輸入的坐標和輸入值捆綁后，在數(shù)字鍵處理函數(shù)中就可以較有結(jié)構的組織程序，使程序顯得很緊湊。整理用戶輸入繼續(xù)第 2 節(jié)的例子，在第 2 節(jié)的 onNumKey 函數(shù)中，只是獲取了數(shù)字的每一位，因而我們需要將其轉(zhuǎn)化為有效數(shù)據(jù)，譬如要轉(zhuǎn)化為有效的 XXX 數(shù)據(jù)，其方法是：/* 從 2 進制數(shù)據(jù)位轉(zhuǎn)化為有效數(shù)據(jù)：XXX */void convertToXXX(){46BYTE i;XXX = 0;for (i = 0; i < NUM_LENGTH; i++){XXX += inputElement[i].byNum*power(2, NUM_LENGTH - i - 1);}}反之，我們也可能需要在屏幕上顯示那些有效的數(shù)據(jù)位，因為我們也需要能夠反向轉(zhuǎn)化：/* 從有效數(shù)據(jù)轉(zhuǎn)化為 2 進制數(shù)據(jù)位：XXX */void convertFromXXX(){BYTE i;XXX = 0;for (i = 0; i < NUM_LENGTH; i++){inputElement[i].byNum = XXX / power(2, NUM_LENGTH - i - 1) % 2;}}當然在上面的例子中，因為數(shù)據(jù)是 2 進制的，用 power 函數(shù)不是很好的選擇，直接用"<< >>"移位操作效率更高，我們僅是為了說明問題的方便。試想，如果用戶輸入是十進制的，power 函數(shù)或許是唯一的選擇了。總結(jié)本篇給出了鍵盤操作所涉及的各個方面：功能鍵處理、數(shù)字鍵處理及用戶輸入整理，基本上提供了一個全套的按鍵處理方案。對于功能鍵處理方法，將 LCD 屏幕與 Windows 窗口進行類比，提出了較新穎地解決屏幕、鍵盤繁雜交互問題的方案。計算機學的許多知識都具有相通性，因而，不斷追趕時髦技術而忽略基本功的做法是徒勞無意的。我們最多需要"精通"三種語言（精通，一個在如今的求職簡歷里泛濫成災的詞語），最佳拍檔是匯編、C、C++（或 java），很顯然，如果你"精通"了這三種語言，其它語言你應該是可以很快"熟悉"的，否則你就沒有"精通"它們.C 語言嵌入式系統(tǒng)編程修煉之六:性能優(yōu)化作者:宋寶華更新日期:2005-07-22使用宏定義在 C 語言中，宏是產(chǎn)生內(nèi)嵌代碼的唯一方法。對于嵌入式系統(tǒng)而言，為了能達到性能要求，宏是一種很好的代替函數(shù)的方法。47寫一個"標準"宏 MIN ，這個宏輸入兩個參數(shù)并返回較小的一個：錯誤做法：#define MIN(A,B) ( A <= B ? A : B )正確做法：#define MIN(A,B) （（A）<= (B) ? (A) : (B) )對于宏，我們需要知道三點：(1)宏定義"像"函數(shù)；(2)宏定義不是函數(shù)，因而需要括上所有"參數(shù)"；(3)宏定義可能產(chǎn)生副作用。下面的代碼：least = MIN(*p++, b);將被替換為：( (*p++) <= (b) ?(*p++):(b) )發(fā)生的事情無法預料。因而不要給宏定義傳入有副作用的"參數(shù)"。使用寄存器變量當對一個變量頻繁被讀寫時，需要反復訪問內(nèi)存，從而花費大量的存取時間。為此，C 語言提供了一種變量，即寄存器變量。這種變量存放在 CPU 的寄存器中，使用時，不需要訪問內(nèi)存，而直接從寄存器中讀寫，從而提高效率。寄存器變量的說明符是 register。對于循環(huán)次數(shù)較多的循環(huán)控制變量及循環(huán)體內(nèi)反復使用的變量均可定義為寄存器變量，而循環(huán)計數(shù)是應用寄存器變量的最好候選者。(1) 只有局部自動變量和形參才可以定義為寄存器變量。因為寄存器變量屬于動態(tài)存儲方式，凡需要采用靜態(tài)存儲方式的量都不能定義為寄存器變量，包括：模塊間全局變量、模塊內(nèi)全局變量、局部 static 變量；(2) register 是一個"建議"型關鍵字，意指程序建議該變量放在寄存器中，但最終該變量可能因為條件不滿足并未成為寄存器變量，而是被放在了存儲器中，但編譯器中并不報錯（在 C++語言中有另一個"建議"型關鍵字：inline）。48下面是一個采用寄存器變量的例子：/* 求 1+2+3+….+n 的值 */WORD Addition(BYTE n){register i,s=0;for(i=1;i<=n;i++){s=s+i;}return s;}本程序循環(huán) n 次，i 和 s 都被頻繁使用，因此可定義為寄存器變量。內(nèi)嵌匯編程序中對時間要求苛刻的部分可以用內(nèi)嵌匯編來重寫，以帶來速度上的顯著提高。但是，開發(fā)和測試匯編代碼是一件辛苦的工作，它將花費更長的時間，因而要慎重選擇要用匯編的部分。在程序中，存在一個 80-20 原則，即 20%的程序消耗了 80%的運行時間，因而我們要改進效率，最主要是考慮改進那20%的代碼。嵌入式 C 程序中主要使用在線匯編，即在 C 程序中直接插入_asm{ }內(nèi)嵌匯編語句：/* 把兩個輸入?yún)?shù)的值相加，結(jié)果存放到另外一個全局變量中 */int result;void Add(long a, long *b){_asm{MOV AX, aMOV BX, bADD AX, [BX]MOV result, AX}}利用硬件特性首先要明白 CPU 對各種存儲器的訪問速度，基本上是：CPU 內(nèi)部 RAM > 外部同步 RAM > 外部異步 RAM > FLASH/ROM49對于程序代碼，已經(jīng)被燒錄在 FLASH 或 ROM 中，我們可以讓 CPU 直接從其中讀取代碼執(zhí)行，但通常這不是一個好辦法，我們最好在系統(tǒng)啟動后將 FLASH 或 ROM 中的目標代碼拷貝入 RAM 中后再執(zhí)行以提高取指令速度；對于 UART 等設備，其內(nèi)部有一定容量的接收 BUFFER，我們應盡量在 BUFFER 被占滿后再向 CPU 提出中斷。例如計算機終端在向目標機通過 RS-232 傳遞數(shù)據(jù)時，不宜設置 UART 只接收到一個 BYTE 就向 CPU 提中斷，從而無謂浪費中斷處理時間；如果對某設備能采取 DMA 方式讀取，就采用 DMA 讀取，DMA 讀取方式在讀取目標中包含的存儲信息較大時效率較高，其數(shù)據(jù)傳輸?shù)幕締挝皇菈K，而所傳輸?shù)臄?shù)據(jù)是從設備直接送入內(nèi)存的（或者相反）。DMA 方式較之中斷驅(qū)動方式，減少了CPU 對外設的干預，進一步提高了 CPU 與外設的并行操作程度。活用位操作使用 C 語言的位操作可以減少除法和取模的運算。在計算機程序中數(shù)據(jù)的位是可以操作的最小數(shù)據(jù)單位，理論上可以用"位運算"來完成所有的運算和操作，因而，靈活的位操作可以有效地提高程序運行的效率。舉例如下：/* 方法 1 */int i,j;i = 879 / 16;j = 562 % 32;/* 方法 2 */int i,j;i = 879 >> 4;j = 562 - (562 >> 5 << 5);對于以 2 的指數(shù)次方為"*"、"/"或"%"因子的數(shù)學運算，轉(zhuǎn)化為移位運算"<< >>"通常可以提高算法效率。因為乘除運算指令周期通常比移位運算大。C 語言位運算除了可以提高運算效率外，在嵌入式系統(tǒng)的編程中，它的另一個最典型的應用，而且十分廣泛地正在被使用著的是位間的與（&）、或（|）、非（~）操作，這跟嵌入式系統(tǒng)的編程特點有很大關系。我們通常要對硬件寄存器進行位設置，譬如，我們通過將 AM186ER 型 80186 處理器的中斷屏蔽控制寄存器的第低 6 位設置為 0（開中斷 2），最通用的做法是：#define INT_I2_MASK 0x0040wTemp = inword(INT_MASK);outword(INT_MASK, wTemp &~INT_I2_MASK);而將該位設置為 1 的做法是：#define INT_I2_MASK 0x0040wTemp = inword(INT_MASK);outword(INT_MASK, wTemp | INT_I2_MASK);判斷該位是否為 1 的做法是：50#define INT_I2_MASK 0x0040wTemp = inword(INT_MASK);if(wTemp & INT_I2_MASK){… /* 該位為 1 */}上述方法在嵌入式系統(tǒng)的編程中是非常常見的，我們需要牢固掌握。總結(jié)在性能優(yōu)化方面永遠注意 80-20 準備，不要優(yōu)化程序中開銷不大的那 80%，這是勞而無功的。宏定義是 C 語言中實現(xiàn)類似函數(shù)功能而又不具函數(shù)調(diào)用和返回開銷的較好方法，但宏在本質(zhì)上不是函數(shù)，因而要防止宏展開后出現(xiàn)不可預料的結(jié)果，對宏的定義和使用要慎而處之。很遺憾，標準 C 至今沒有包括 C++中 inline 函數(shù)的功能，inline 函數(shù)兼具無調(diào)用開銷和安全的優(yōu)點。使用寄存器變量、內(nèi)嵌匯編和活用位操作也是提高程序效率的有效方法。除了編程上的技巧外，為提高系統(tǒng)的運行效率，我們通常也需要最大可能地利用各種硬件設備自身的特點來減小其運轉(zhuǎn)開銷，例如減小中斷次數(shù)、利用 DMA 傳輸方式等。C/C++語言 void 及 void 指針深層探索1.概述許多初學者對 C/C++語言中的 void 及 void 指針類型不甚理解，因此在使用上出現(xiàn)了一些錯誤。本文將對 void 關鍵字的深刻含義進行解說，并詳述 void 及 void 指針類型的使用方法與技巧。2.void 的含義void 的字面意思是“無類型”，void *則為“無類型指針”，void *可以指向任何類型的數(shù)據(jù)。void 幾乎只有“注釋”和限制程序的作用，因為從來沒有人會定義一個 void 變量，讓我們試著來定義：void a;這行語句編譯時會出錯，提示“illegal use of type ‘void‘”。不過，即使 void a 的編譯不會出錯，它也沒有任何實際意義。void 真正發(fā)揮的作用在于：（1）對函數(shù)返回的限定；（2）對函數(shù)參數(shù)的限定。我們將在第三節(jié)對以上二點進行具體說明。眾所周知，如果指針 p1 和 p2 的類型相同，那么我們可以直接在 p1 和 p2 間互相賦值；如果 p1 和 p2 指向不同的數(shù)據(jù)類型，則必須使用強制類型轉(zhuǎn)換運算符把賦值運算符右邊的指針類型轉(zhuǎn)換為左邊指針的類型。例如：float *p1;int *p2;p1 = p2;51其中 p1 = p2 語句會編譯出錯，提示“‘=‘ : cannot convert from ‘int *‘ to ‘float *‘”，必須改為：p1 = (float *)p2;而 void *則不同，任何類型的指針都可以直接賦值給它，無需進行強制類型轉(zhuǎn)換：void *p1;int *p2;p1 = p2;但這并不意味著，void *也可以無需強制類型轉(zhuǎn)換地賦給其它類型的指針。因為“無類型”可以包容“有類型”，而“有類型”則不能包容“無類型”。道理很簡單，我們可以說“男人和女人都是人”，但不能說“人是男人”或者“人是女人”。下面的語句編譯出錯：void *p1;int *p2;p2 = p1;提示“‘=‘ : cannot convert from ‘void *‘ to ‘int *‘”。3.void 的使用下面給出 void 關鍵字的使用規(guī)則：規(guī)則一如果函數(shù)沒有返回值，那么應聲明為 void 類型在 C 語言中，凡不加返回值類型限定的函數(shù)，就會被編譯器作為返回整型值處理。但是許多程序員卻誤以為其為 void 類型。例如：add ( int a, int b ){return a + b;}int main(int argc, char* argv[]){printf ( "2 + 3 = %d", add ( 2, 3) );}程序運行的結(jié)果為輸出：2 + 3 = 5這說明不加返回值說明的函數(shù)的確為 int 函數(shù)。林銳博士《高質(zhì)量 C/C++編程》中提到：“C++語言有很嚴格的類型安全檢查，不允許上述情況（指函數(shù)不加類型聲明）發(fā)生”。可是編譯器并不一定這么認定，譬如在 Visual C++6.0 中上述 add 函數(shù)的編譯無錯也無警告且運行正確，所以不能寄希望于編譯器會做嚴格的類型檢查。因此，為了避免混亂，我們在編寫 C/C++程序時，對于任何函數(shù)都必須一個不漏地指定其類型。如果函數(shù)沒有返回值，一定要聲明為 void 類型。這既是程序良好可讀性的需要，也是編程規(guī)范性的要求。另外，加上 void 類型聲明后，也可以發(fā)揮代碼的“自注釋”作用。代碼的“自注釋”即代碼能自己注釋自己。規(guī)則二如果函數(shù)無參數(shù)，那么應聲明其參數(shù)為 void52在 C++語言中聲明一個這樣的函數(shù)：int function(void){return 1;}則進行下面的調(diào)用是不合法的：function(2);因為在 C++中，函數(shù)參數(shù)為 void 的意思是這個函數(shù)不接受任何參數(shù)。我們在 Turbo C 2.0 中編譯：#include "stdio.h"fun(){return 1;}main(){printf("%d",fun(2));getchar();}編譯正確且輸出 1，這說明，在 C 語言中，可以給無參數(shù)的函數(shù)傳送任意類型的參數(shù)，但是在 C++編譯器中編譯同樣的代碼則會出錯。在 C++中，不能向無參數(shù)的函數(shù)傳送任何參數(shù)，出錯提示“‘fun‘ : function does not take 1 parameters”。所以，無論在 C 還是 C++中，若函數(shù)不接受任何參數(shù)，一定要指明參數(shù)為 void。規(guī)則三小心使用 void 指針類型按照 ANSI(American National Standards Institute)標準，不能對 void 指針進行算法操作，即下列操作都是不合法的：void * pvoid;pvoid++; //ANSI：錯誤pvoid += 1; //ANSI：錯誤//ANSI 標準之所以這樣認定，是因為它堅持：進行算法操作的指針必須是確定知道其指向數(shù)據(jù)類型大小的。//例如：int *pint;pint++; //ANSI：正確pint++的結(jié)果是使其增大 sizeof(int)。但是大名鼎鼎的 GNU(GNU‘s Not Unix 的縮寫)則不這么認定，它指定 void *的算法操作與 char *一致。因此下列語句在 GNU 編譯器中皆正確：53pvoid++; //GNU：正確pvoid += 1; //GNU：正確pvoid++的執(zhí)行結(jié)果是其增大了 1。在實際的程序設計中，為迎合 ANSI 標準，并提高程序的可移植性，我們可以這樣編寫實現(xiàn)同樣功能的代碼：void * pvoid;(char *)pvoid++; //ANSI：正確；GNU：正確(char *)pvoid += 1; //ANSI：錯誤；GNU：正確GNU 和 ANSI 還有一些區(qū)別，總體而言，GNU 較 ANSI 更“開放”，提供了對更多語法的支持。但是我們在真實設計時，還是應該盡可能地迎合 ANSI 標準。規(guī)則四如果函數(shù)的參數(shù)可以是任意類型指針，那么應聲明其參數(shù)為 void *典型的如內(nèi)存操作函數(shù) memcpy 和 memset 的函數(shù)原型分別為：void * memcpy(void *dest, const void *src, size_t len);void * memset ( void * buffer, int c, size_t num );這樣，任何類型的指針都可以傳入 memcpy 和 memset 中，這也真實地體現(xiàn)了內(nèi)存操作函數(shù)的意義，因為它操作的對象僅僅是一片內(nèi)存，而不論這片內(nèi)存是什么類型。如果 memcpy 和 memset 的參數(shù)類型不是 void *，而是 char *，那才叫真的奇怪了！這樣的 memcpy 和memset 明顯不是一個“純粹的，脫離低級趣味的”函數(shù)！下面的代碼執(zhí)行正確：//示例：memset 接受任意類型指針int intarray[100];memset ( intarray, 0, 100*sizeof(int) ); //將 intarray 清 0//示例：memcpy 接受任意類型指針int intarray1[100], intarray2[100];memcpy ( intarray1, intarray2, 100*sizeof(int) ); //將 intarray2 拷貝給 intarray1有趣的是，memcpy 和 memset 函數(shù)返回的也是 void *類型，標準庫函數(shù)的編寫者是多么地富有學問啊！規(guī)則五 void 不能代表一個真實的變量下面代碼都企圖讓 void 代表一個真實的變量，因此都是錯誤的代碼：void a; //錯誤function(void a); //錯誤void 體現(xiàn)了一種抽象，這個世界上的變量都是“有類型”的，譬如一個人不是男人就是女人（還有人妖？）。void 的出現(xiàn)只是為了一種抽象的需要，如果你正確地理解了面向?qū)ο笾小俺橄蠡悺钡母拍睿埠苋菀桌斫?void 數(shù)據(jù)類型。正如不能給抽象基類定義一個實例，我們也不能定義一個 void（讓我們類比的稱 void 為“抽象數(shù)據(jù)類型”）變量。4.總結(jié)小小的 void 蘊藏著很豐富的設計哲學，作為一名程序設計人員，對問題進行深一個層次的思考必然使我們受益匪淺。54C/C++語言可變參數(shù)表深層探索作者：宋寶華 e-mail:21cnbao@21cn.com1.引言C/C++語言有一個不同于其它語言的特性，即其支持可變參數(shù)，典型的函數(shù)如 printf、scanf 等可以接受數(shù)量不定的參數(shù)。如：printf ( "I love you" );printf ( "%d", a );printf ( "%d,%d", a, b );第一、二、三個 printf 分別接受 1、2、3 個參數(shù)，讓我們看看 printf 函數(shù)的原型：int printf ( const char *format, ... );從函數(shù)原型可以看出，其除了接收一個固定的參數(shù) format 以外，后面的參數(shù)用 “…”表示。在 C/C++語言中，“…”表示可以接受不定數(shù)量的參數(shù)，理論上來講，可以是 0 或 0 以上的 n 個參數(shù)。本文將對 C/C++可變參數(shù)表的使用方法及 C/C++支持可變參數(shù)表的深層機理進行探索。2.可變參數(shù)表的用法2.1 相關宏標準 C/C++包含頭文件 stdarg.h，該頭文件中定義了如下三個宏：void va_start ( va_list arg_ptr, prev_param ); /* ANSI version */type va_arg ( va_list arg_ptr, type );void va_end ( va_list arg_ptr );在這些宏中，va 就是 variable argument(可變參數(shù))的意思；arg_ptr 是指向可變參數(shù)表的指針；prev_param 則指可變參數(shù)表的前一個固定參數(shù)；type 為可變參數(shù)的類型。va_list 也是一個宏，其定義為 typedef char * va_list，實質(zhì)上是一 char 型指針。char 型指針的特點是++、--操作對其作用的結(jié)果是增 1 和減 1（因為 sizeof(char)為 1），與之不同的是 int 等其它類型指針的++、--操作對其作用的結(jié)果是增 sizeof(type)或減 sizeof(type)，而且 sizeof(type)大于 1。通過 va_start 宏我們可以取得可變參數(shù)表的首指針，這個宏的定義為：#define va_start ( ap, v ) ( ap = (va_list)&v + _INTSIZEOF(v) )顯而易見，其含義為將最后那個固定參數(shù)的地址加上可變參數(shù)對其的偏移后賦值給 ap，這樣 ap 就是可變參數(shù)表的首地址。其中的_INTSIZEOF 宏定義為：#define _INTSIZEOF(n) ((sizeof ( n ) + sizeof ( int ) – 1 ) & ~( sizeof( int ) – 1 ) )va_arg 宏的意思則指取出當前 arg_ptr 所指的可變參數(shù)并將 ap 指針指向下一可變參數(shù)，其原型為：#define va_arg(list, mode) ((mode *)(list =/(char *) ((((int)list + (__builtin_alignof(mode)<=4?3:7)) &/(__builtin_alignof(mode)<=4?-4:-8))+sizeof(mode))))[-1]對這個宏的具體含義我們將在第 3 節(jié)深入討論。而 va_end 宏被用來結(jié)束可變參數(shù)的獲取，其定義為：#define va_end ( list )可以看出，va_end ( list )實際上被定義為空，沒有任何真實對應的代碼，用于代碼對稱，與 va_start對應；另外，它還可能發(fā)揮代碼的“自注釋”作用。所謂代碼的“自注釋”，指的是代碼能自己注釋自己。下面我們以具體的例子來說明以上三個宏的使用方法。552.2 一個簡單的例子#include <stdarg.h>/* 函數(shù)名：max* 功能：返回 n 個整數(shù)中的最大值* 參數(shù)：num：整數(shù)的個數(shù) ...：num 個輸入的整數(shù)* 返回值：求得的最大整數(shù)*/int max ( int num, ... ){int m = -0x7FFFFFFF; /* 32 系統(tǒng)中最小的整數(shù) */va_list ap;va_start ( ap, num );for ( int i= 0; i< num; i++ ){int t = va_arg (ap, int);if ( t > m ){m = t;}}va_end (ap);return m;}/* 主函數(shù)調(diào)用 max */int main ( int argc, char* argv[] ){int n = max ( 5, 5, 6 ,3 ,8 ,5); /* 求 5 個整數(shù)中的最大值 */cout << n;return 0;}函數(shù) max 中首先定義了可變參數(shù)表指針 ap，而后通過 va_start ( ap, num )取得了參數(shù)表首地址（賦給了 ap），其后的 for 循環(huán)則用來遍歷可變參數(shù)表。這種遍歷方式與我們在數(shù)據(jù)結(jié)構教材中經(jīng)常看到的遍歷方式是類似的。函數(shù) max 看起來簡潔明了，但是實際上 printf 的實現(xiàn)卻遠比這復雜。max 函數(shù)之所以看起來簡單，是因為：(1) max 函數(shù)可變參數(shù)表的長度是已知的，通過 num 參數(shù)傳入；(2) max 函數(shù)可變參數(shù)表中參數(shù)的類型是已知的，都為 int 型。而 printf 函數(shù)則沒有這么幸運。首先，printf 函數(shù)可變參數(shù)的個數(shù)不能輕易的得到，而可變參數(shù)的類型也不是固定的，需由格式字符串進行識別（由%f、%d、%s 等確定），因此則涉及到可變參數(shù)表的更復雜應用。下面我們以實例來分析可變參數(shù)表的高級應用。2.3 高級應用下面這個程序是我們?yōu)槟城度胧较到y(tǒng)（該系統(tǒng)中 CPU 的字長為 16 位）編寫的在屏幕上顯示格式字符串56的函數(shù) DrawText，它的用法類似于 int printf ( const char *format, ... )函數(shù)，但其輸出的目標為嵌入式系統(tǒng)的液晶顯示屏幕（LED）。///////////////////////////////////////////////////////////////////////////////// 函數(shù)名稱: DrawText// 功能說明: 在顯示屏上繪制文字// 參數(shù)說明: xPos ---橫坐標的位置 [0 .. 30]// yPos ---縱坐標的位置 [0 .. 64]// ... 可以同數(shù)字一起顯示，需設置標志(%d、%l、%x、%s)///////////////////////////////////////////////////////////////////////////////extern void DrawText ( BYTE xPos, BYTE yPos, LPBYTE lpStr, ... ){BYTE lpData[100]; //緩沖區(qū)BYTE byIndex;BYTE byLen;DWORD dwTemp;WORD wTemp;int i;va_list lpParam;memset( lpData, 0, 100);byLen = strlen( lpStr );byIndex = 0;va_start ( lpParam, lpStr );for ( i = 0; i < byLen; i++ ){if( lpStr[i] != '%' ) //不是格式符開始{lpData[byIndex++] = lpStr[i];}else{switch (lpStr[i+1]){//整型case 'd':case 'D':wTemp = va_arg ( lpParam, int );byIndex += IntToStr( lpData+byIndex, (DWORD)wTemp );i++;break;//長整型case 'l':case 'L':57dwTemp = va_arg ( lpParam, long );byIndex += IntToStr ( lpData+byIndex, (DWORD)dwTemp );i++;break;//16 進制（長整型）case 'x':case 'X':dwTemp = va_arg ( lpParam, long );byIndex += HexToStr ( lpData+byIndex, (DWORD)dwTemp );i++;break;default:lpData[byIndex++] = lpStr[i];break;}}}va_end ( lpParam );lpData[byIndex] = '/0';DisplayString ( xPos, yPos, lpData, TRUE); //在屏幕上顯示字符串 lpData}在這個函數(shù)中，需通過對傳入的格式字符串（首地址為 lpStr）進行識別來獲知可變參數(shù)個數(shù)及各個可變參數(shù)的類型，具體實現(xiàn)體現(xiàn)在 for 循環(huán)中。譬如，在識別為%d 后，做的是 va_arg ( lpParam, int )，而獲知為%l 和%x 后則進行的是 va_arg ( lpParam, long )。格式字符串識別完成后，可變參數(shù)也就處理完了。在項目的最初，我們一直苦于不能找到一個好的辦法來混合輸出字符串和數(shù)字，我們采用了分別顯示數(shù)字和字符串的方法，并分別指定坐標，程序條理被破壞。而且，在混合顯示的時候，要給各類數(shù)據(jù)分別人工計算坐標，我們感覺頭疼不已。以前的函數(shù)為：//顯示字符串showString ( BYTE xPos, BYTE yPos, LPBYTE lpStr )//顯示數(shù)字showNum ( BYTE xPos, BYTE yPos, int num )//以 16 進制方式顯示數(shù)字showHexNum ( BYTE xPos, BYTE yPos, int num )最終，我們用 DrawText ( BYTE xPos, BYTE yPos, LPBYTE lpStr, ... )函數(shù)代替了原先所有的輸出函數(shù)，程序得到了簡化。就這樣，兄弟們用得爽翻了。3.運行機制探索通過第 2 節(jié)我們學會了可變參數(shù)表的使用方法，相信喜歡拋根問底的讀者還不甘心，必然想知道如下問題：（1）為什么按照第 2 節(jié)的做法就可以獲得可變參數(shù)并對其進行操作？（2）C/C++在底層究竟是依靠什么來對這一語法進行支持的，為什么其它語言就不能提供可變參數(shù)表呢？我們帶著這些疑問來一步步進行摸索。583.1 調(diào)用機制反匯編反匯編是研究語法深層特性的終極良策，先來看看 2.2 節(jié)例子中主函數(shù)進行 max ( 5, 5, 6 ,3 ,8 ,5)調(diào)用時的反匯編：1. 004010C8 push 52. 004010CA push 83. 004010CC push 34. 004010CE push 65. 004010D0 push 56. 004010D2 push 57. 004010D4 call @ILT+5(max) (0040100a)從上述反匯編代碼中我們可以看出，C/C++函數(shù)調(diào)用的過程中：第一步：將參數(shù)從右向左入棧（第 1～6 行）；第二步：調(diào)用 call 指令進行跳轉(zhuǎn)（第 7 行）。這兩步包含了深刻的含義，它說明 C/C++默認的調(diào)用方式為由調(diào)用者管理參數(shù)入棧的操作，且入棧的順序為從右至左，這種調(diào)用方式稱為_cdecl 調(diào)用。x86 系統(tǒng)的入棧方向為從高地址到低地址，故第 1 至 n個參數(shù)被放在了地址遞增的堆棧內(nèi)。在被調(diào)用函數(shù)內(nèi)部，讀取這些堆棧的內(nèi)容就可獲得各個參數(shù)的值，讓我們反匯編到 max 函數(shù)的內(nèi)部：int max ( int num, ...){1. 00401020 push ebp2. 00401021 mov ebp,esp3. 00401023 sub esp,50h4. 00401026 push ebx5. 00401027 push esi6. 00401028 push edi7. 00401029 lea edi,[ebp-50h]8. 0040102C mov ecx,14h9. 00401031 mov eax,0CCCCCCCCh10. 00401036 rep stos dword ptr [edi]va_list ap;int m = -0x7FFFFFFF; /* 32 系統(tǒng)中最小的整數(shù) */11. 00401038 mov dword ptr [ebp-8],80000001hva_start ( ap, num );12. 0040103F lea eax,[ebp+0Ch]13. 00401042 mov dword ptr [ebp-4],eaxfor ( int i= 0; i< num; i++ )14. 00401045 mov dword ptr [ebp-0Ch],015. 0040104C jmp max+37h (00401057)16. 0040104E mov ecx,dword ptr [ebp-0Ch]17. 00401051 add ecx,118. 00401054 mov dword ptr [ebp-0Ch],ecx19. 00401057 mov edx,dword ptr [ebp-0Ch]20. 0040105A cmp edx,dword ptr [ebp+8]21. 0040105D jge max+61h (00401081)59{int t= va_arg (ap, int);22. 0040105F mov eax,dword ptr [ebp-4]23. 00401062 add eax,424. 00401065 mov dword ptr [ebp-4],eax25. 00401068 mov ecx,dword ptr [ebp-4]26. 0040106B mov edx,dword ptr [ecx-4]27. 0040106E mov dword ptr [t],edxif ( t > m )28. 00401071 mov eax,dword ptr [t]29. 00401074 cmp eax,dword ptr [ebp-8]30. 00401077 jle max+5Fh (0040107f)m = t;31. 00401079 mov ecx,dword ptr [t]32. 0040107C mov dword ptr [ebp-8],ecx}33. 0040107F jmp max+2Eh (0040104e)va_end (ap);34. 00401081 mov dword ptr [ebp-4],0return m;35. 00401088 mov eax,dword ptr [ebp-8]}36. 0040108B pop edi37. 0040108C pop esi38. 0040108D pop ebx39. 0040108E mov esp,ebp40. 00401090 pop ebp41. 00401091 ret分析上述反匯編代碼，對于一個真正的程序員而言，將是一種很大的享受；而對于初學者，也將使其受益良多。所以請一定要賴著頭皮認真研究，千萬不要被嚇倒！行 1～10 進行執(zhí)行函數(shù)內(nèi)代碼的準備工作，保存現(xiàn)場。第 2 行對堆棧進行移動；第 3 行則意味著 max函數(shù)為其內(nèi)部局部變量準備的堆棧空間為 50h 字節(jié)；第 11 行表示把變量 n 的內(nèi)存空間安排在了函數(shù)內(nèi)部局部棧底減 8 的位置（占用 4 個字節(jié)）。第 12～13 行非常關鍵，對應著 va_start ( ap, num )，這兩行將第一個可變參數(shù)的地址賦值給了指針ap。另外，從第 12 行可以看出 num 的地址為 ebp+0Ch；從第 13 行可以看出 ap 被分配在函數(shù)內(nèi)部局部棧底減 4 的位置上（占用 4 個字節(jié)）。第 22～27 行最為關鍵，對應著 va_arg (ap, int)。其中，22~24 行的作用為將 ap 指向下一可變參數(shù)（可變參數(shù)的地址間隔為 4 個字節(jié)，從 add eax,4 可以看出）；25~27 行則取當前可變參數(shù)的值賦給變量 t。這段反匯編很奇怪，它先移動可變參數(shù)指針，再在賦值指令里面回過頭來取先前的參數(shù)值賦給t（從 mov edx,dword ptr [ecx-4]語句可以看出）。Visual C++同學玩得有意思，不知道碰見同樣的情況 Visual Basic 等其它同學怎么玩？第 36～41 行恢復現(xiàn)場和堆棧地址，執(zhí)行函數(shù)返回操作。痛苦的反匯編之旅差不多結(jié)束了，看了這段反匯編我們總算弄明白了可變參數(shù)的存放位置以及它們被讀取的方式，頓覺全省輕松！603.2 特殊的調(diào)用約定除此之外，我們需要了解 C/C++函數(shù)調(diào)用對參數(shù)占用空間的一些特殊約定，因為在_cdecl 調(diào)用協(xié)議中，有些變量類型是按照其它變量的尺寸入棧的。例如，字符型變量將被自動擴展為一個字的空間，因為入棧操作針對的是一個字。參數(shù) n 實際占用的空間為( ( sizeof(n) + sizeof(int) – 1 ) & ~( sizeof(int) – 1 ) )，這就是第 2.1 節(jié)_INTSIZEOF(v)宏的來歷！既然如此，2.1 節(jié)給出的 va_arg ( list, mode )宏為什么玩這么大的飛機就很清楚了。這個問題就留個讀者您來分析。C/C++數(shù)組名與指針區(qū)別深層探索作者：宋寶華 e-mail:21cnbao@21cn.com1. 引言指針是 C/C++語言的特色，而數(shù)組名與指針有太多的相似，甚至很多時候，數(shù)組名可以作為指針使用。于是乎，很多程序設計者就被搞糊涂了。而許多的大學老師，他們在 C語言的教學過程中也錯誤得給學生講解：“數(shù)組名就是指針”。很幸運，我的大學老師就是其中之一。時至今日，我日復一日地進行著 C/C++項目的開發(fā)，而身邊還一直充滿這樣的程序員，他們保留著“數(shù)組名就是指針”的誤解。想必這種誤解的根源在于國內(nèi)某著名的 C 程序設計教程。如果這篇文章能夠糾正許多中國程序員對數(shù)組名和指針的誤解，筆者就不甚欣慰了。借此文，筆者站在無數(shù)對知識如饑似渴的中國程序員之中，深深寄希望于國內(nèi)的計算機圖書編寫者們，能以“深入探索”的思維方式和精益求精的認真態(tài)度來對待圖書編寫工作，但愿市面上多一些融入作者思考結(jié)晶的心血之作！2. 魔幻數(shù)組名請看程序（本文程序在 WIN32 平臺下編譯）：1. #include <iostream.h>2. int main(int argc, char* argv[])3. {4. char str[10];5. char *pStr = str;6. cout << sizeof(str) << endl;7. cout << sizeof(pStr) << endl;8. return 0;9. }2.1 數(shù)組名不是指針我們先來推翻“數(shù)組名就是指針”的說法，用反證法。證明數(shù)組名不是指針假設：數(shù)組名是指針；則：pStr 和 str 都是指針；因為：在 WIN32 平臺下，指針長度為 4；所以：第 6 行和第 7 行的輸出都應該為 4；實際情況是：第 6 行輸出 10，第 7 行輸出 4；所以：假設不成立，數(shù)組名不是指針2.2 數(shù)組名神似指針上面我們已經(jīng)證明了數(shù)組名的確不是指針，但是我們再看看程序的第 5 行。該行程序?qū)?shù)組名直接賦值給指針，這顯61得數(shù)組名又的確是個指針！我們還可以發(fā)現(xiàn)數(shù)組名顯得像指針的例子：1. #include <string.h>2. #include <iostream.h>3. int main(int argc, char* argv[])4. {5. char str1[10] = "I Love U";6. char str2[10];7. strcpy(str2,str1);8. cout << "string array 1: " << str1 << endl;9. cout << "string array 2: " << str2 << endl;10. return 0;11. }標準 C 庫函數(shù) strcpy 的函數(shù)原形中能接納的兩個參數(shù)都為 char 型指針，而我們在調(diào)用中傳給它的卻是兩個數(shù)組名！函數(shù)輸出：string array 1: I Love Ustring array 2: I Love U數(shù)組名再一次顯得像指針！既然數(shù)組名不是指針，而為什么到處都把數(shù)組名當指針用？于是乎，許多程序員得出這樣的結(jié)論：數(shù)組名（主）是（謂）不是指針的指針（賓）。整個一魔鬼。3. 數(shù)組名大揭密那么，是揭露數(shù)組名本質(zhì)的時候了，先給出三個結(jié)論：(1)數(shù)組名的內(nèi)涵在于其指代實體是一種數(shù)據(jù)結(jié)構，這種數(shù)據(jù)結(jié)構就是數(shù)組；(2)數(shù)組名的外延在于其可以轉(zhuǎn)換為指向其指代實體的指針，而且是一個指針常量；(3)指向數(shù)組的指針則是另外一種變量類型（在 WIN32 平臺下，長度為 4），僅僅意味著數(shù)組的存放地址！3.1 數(shù)組名指代一種數(shù)據(jù)結(jié)構：數(shù)組現(xiàn)在可以解釋為什么第 1 個程序第 6 行的輸出為 10 的問題，根據(jù)結(jié)論 1，數(shù)組名 str 的內(nèi)涵為一種數(shù)據(jù)結(jié)構，即一個長度為 10 的 char 型數(shù)組，所以 sizeof(str)的結(jié)果為這個數(shù)據(jù)結(jié)構占據(jù)的內(nèi)存大小：10 字節(jié)。再看：1. int intArray[10];2. cout << sizeof(intArray) ;第 2 行的輸出結(jié)果為 40（整型數(shù)組占據(jù)的內(nèi)存空間大小）。如果 C/C++程序可以這樣寫：1. int[10] intArray;2. cout << sizeof(intArray) ;我們就都明白了，intArray 定義為 int[10]這種數(shù)據(jù)結(jié)構的一個實例，可惜啊， C/C++目前并不支持這種定義方式。3.2 數(shù)組名可作為指針常量根據(jù)結(jié)論 2，數(shù)組名可以轉(zhuǎn)換為指向其指代實體的指針，所以程序 1 中的第 5 行數(shù)組名直接賦值給指針，程序 2 第 7行直接將數(shù)組名作為指針形參都可成立。下面的程序成立嗎？1. int intArray[10];2. intArray++;讀者可以編譯之，發(fā)現(xiàn)編譯出錯。原因在于，雖然數(shù)組名可以轉(zhuǎn)換為指向其指代實體的指針，但是它只能被看作一個62指針常量，不能被修改。而指針，不管是指向結(jié)構體、數(shù)組還是基本數(shù)據(jù)類型的指針，都不包含原始數(shù)據(jù)結(jié)構的內(nèi)涵，在 WIN32 平臺下， sizeof操作的結(jié)果都是 4。順便糾正一下許多程序員的另一個誤解。許多程序員以為 sizeof 是一個函數(shù)，而實際上，它是一個操作符，不過其使用方式看起來的確太像一個函數(shù)了。語句 sizeof(int)就可以說明 sizeof 的確不是一個函數(shù)，因為函數(shù)接納形參（一個變量），世界上沒有一個 C/C++函數(shù)接納一個數(shù)據(jù)類型（如 int）為“形參”。3.3 數(shù)據(jù)名可能失去其數(shù)據(jù)結(jié)構內(nèi)涵到這里似乎數(shù)組名魔幻問題已經(jīng)宣告圓滿解決，但是平靜的湖面上卻再次掀起波浪。請看下面一段程序：1. #include <iostream.h>2. void arrayTest(char str[])3. {4. cout << sizeof(str) << endl;5. }6. int main(int argc, char* argv[])7. {8. char str1[10] = "I Love U";9. arrayTest(str1);10. return 0;11. }程序的輸出結(jié)果為 4。不可能吧？4，一個可怕的數(shù)字，前面已經(jīng)提到其為指針的長度!結(jié)論 1 指出，數(shù)據(jù)名內(nèi)涵為數(shù)組這種數(shù)據(jù)結(jié)構，在 arrayTest 函數(shù)體內(nèi)，str 是數(shù)組名，那為什么 sizeof 的結(jié)果卻是指針的長度？這是因為：(1)數(shù)組名作為函數(shù)形參時，在函數(shù)體內(nèi)，其失去了本身的內(nèi)涵，僅僅只是一個指針；(2)很遺憾，在失去其內(nèi)涵的同時，它還失去了其常量特性，可以作自增、自減等操作，可以被修改。所以，數(shù)據(jù)名作為函數(shù)形參時，其全面淪落為一個普通指針！它的貴族身份被剝奪，成了一個地地道道的只擁有 4個字節(jié)的平民。以上就是結(jié)論 4。4. 結(jié)論本文以打破沙鍋問到底的探索精神用數(shù)段程序?qū)嵗撟C了數(shù)據(jù)名和指針的區(qū)別。最后，筆者再次表達深深的希望，愿我和我的同道中人能夠真正以謹慎的研究態(tài)度來認真思考開發(fā)中的問題，這樣才能在我們中間產(chǎn)生大師級的程序員，頂級的開發(fā)書籍。每次拿著美國鬼子的開發(fā)書籍，我們不免發(fā)出這樣的感慨：我們落后太遠了。C/C++程序員應聘常見面試題深入剖析(1)作者：宋寶華 e-mail:21cnbao@21cn.com出處：軟件報1.引言本文的寫作目的并不在于提供 C/C++程序員求職面試指導，而旨在從技術上分析面試題的內(nèi)涵。文中的大多數(shù)面試題來自各大論壇，部分試題解答也參考了網(wǎng)友的意見。許多面試題看似簡單，卻需要深厚的基本功才能給出完美的解答。企業(yè)要求面試者寫一個最簡單的strcpy 函數(shù)都可看出面試者在技術上究竟達到了怎樣的程度，我們能真正寫好一個 strcpy 函數(shù)嗎？我們都覺得自己能，可是我們寫出的 strcpy 很可能只能拿到 10 分中的 2 分。讀者可從本文看到 strcpy63函數(shù)從 2 分到 10 分解答的例子，看看自己屬于什么樣的層次。此外，還有一些面試題考查面試者敏捷的思維能力。分析這些面試題，本身包含很強的趣味性；而作為一名研發(fā)人員，通過對這些面試題的深入剖析則可進一步增強自身的內(nèi)功。2.找錯題試題１：void test1(){char string[10];char* str1 = "0123456789";strcpy( string, str1 );}試題 2：void test2(){char string[10], str1[10];int i;for(i=0; i<10; i++){str1[i] = 'a';}strcpy( string, str1 );}試題 3：void test3(char* str1){char string[10];if( strlen( str1 ) <= 10 ){strcpy( string, str1 );}}解答：試題 1 字符串 str1 需要 11 個字節(jié)才能存放下（包括末尾的’/0’），而 string 只有 10 個字節(jié)的空間，strcpy 會導致數(shù)組越界；對試題2，如果面試者指出字符數(shù)組str1不能在數(shù)組內(nèi)結(jié)束可以給3分；如果面試者指出strcpy(string,str1)調(diào)用使得從 str1 內(nèi)存起復制到 string 內(nèi)存起所復制的字節(jié)數(shù)具有不確定性可以給 7 分，在此基礎上指出庫函數(shù) strcpy 工作方式的給 10 分；對試題 3，if(strlen(str1) <= 10)應改為 if(strlen(str1) < 10)，因為 strlen 的結(jié)果未統(tǒng)計’/0’所占用的 1 個字節(jié)。剖析：考查對基本功的掌握：（1）字符串以’/0’結(jié)尾；64（２）對數(shù)組越界把握的敏感度；（３）庫函數(shù) strcpy 的工作方式，如果編寫一個標準 strcpy 函數(shù)的總分值為 10，下面給出幾個不同得分的答案：2 分void strcpy( char *strDest, char *strSrc ){while( (*strDest++ = * strSrc++) != ‘/0’ );}4 分void strcpy( char *strDest, const char *strSrc )//將源字符串加 const，表明其為輸入?yún)?shù)，加 2 分{while( (*strDest++ = * strSrc++) != ‘/0’ );}7 分void strcpy(char *strDest, const char *strSrc){//對源地址和目的地址加非 0 斷言，加 3 分assert( (strDest != NULL) && (strSrc != NULL) );while( (*strDest++ = * strSrc++) != ‘/0’ );}10 分//為了實現(xiàn)鏈式操作，將目的地址返回，加 3 分！char * strcpy( char *strDest, const char *strSrc ){assert( (strDest != NULL) && (strSrc != NULL) );char *address = strDest;while( (*strDest++ = * strSrc++) != ‘/0’ );return address;}從 2 分到 10 分的幾個答案我們可以清楚的看到，小小的 strcpy 竟然暗藏著這么多玄機，真不是蓋的！需要多么扎實的基本功才能寫一個完美的 strcpy 啊！（４）對 strlen 的掌握，它沒有包括字符串末尾的'/0'。讀者看了不同分值的 strcpy 版本，應該也可以寫出一個 10 分的 strlen 函數(shù)了，完美的版本為：int strlen( const char *str ) //輸入?yún)?shù) const{assert( strt != NULL ); //斷言字符串地址非 0int len;while( (*str++) != '/0' ){len++;}return len;}65試題 4：void GetMemory( char *p ){p = (char *) malloc( 100 );}void Test( void ){char *str = NULL;GetMemory( str );strcpy( str, "hello world" );printf( str );}試題 5：char *GetMemory( void ){char p[] = "hello world";return p;}void Test( void ){char *str = NULL;str = GetMemory();printf( str );}試題 6：void GetMemory( char **p, int num ){*p = (char *) malloc( num );}void Test( void ){char *str = NULL;GetMemory( &str, 100 );strcpy( str, "hello" );printf( str );}試題 7：void Test( void ){char *str = (char *) malloc( 100 );strcpy( str, "hello" );free( str );... //省略的其它語句}66解答：試題 4 傳入中 GetMemory( char *p )函數(shù)的形參為字符串指針，在函數(shù)內(nèi)部修改形參并不能真正的改變傳入形參的值，執(zhí)行完char *str = NULL;GetMemory( str );后的 str 仍然為 NULL；試題 5 中char p[] = "hello world";return p;的 p[]數(shù)組為函數(shù)內(nèi)的局部自動變量，在函數(shù)返回后，內(nèi)存已經(jīng)被釋放。這是許多程序員常犯的錯誤，其根源在于不理解變量的生存期。試題 6 的 GetMemory 避免了試題 4 的問題，傳入 GetMemory 的參數(shù)為字符串指針的指針，但是在GetMemory 中執(zhí)行申請內(nèi)存及賦值語句*p = (char *) malloc( num );后未判斷內(nèi)存是否申請成功，應加上：if ( *p == NULL ){...//進行申請內(nèi)存失敗處理}試題 7 存在與試題 6 同樣的問題，在執(zhí)行char *str = (char *) malloc(100);后未進行內(nèi)存是否申請成功的判斷；另外，在 free(str)后未置 str 為空，導致可能變成一個“野”指針，應加上：str = NULL;試題 6 的 Test 函數(shù)中也未對 malloc 的內(nèi)存進行釋放。剖析：試題 4～7 考查面試者對內(nèi)存操作的理解程度，基本功扎實的面試者一般都能正確的回答其中 50~60 的錯誤。但是要完全解答正確，卻也絕非易事。對內(nèi)存操作的考查主要集中在：（1）指針的理解；（2）變量的生存期及作用范圍；（3）良好的動態(tài)內(nèi)存申請和釋放習慣。在看看下面的一段程序有什么錯誤：swap( int* p1,int* p2 ){int *p;*p = *p1;*p1 = *p2;*p2 = *p;}在 swap 函數(shù)中，p 是一個“野”指針，有可能指向系統(tǒng)區(qū)，導致程序運行的崩潰。在 VC++中 DEBUG 運行時提示錯誤“Access Violation”。該程序應該改為：swap( int* p1,int* p2 ){67int p;p = *p1;*p1 = *p2;*p2 = p;}C/C++程序員應聘常見面試題深入剖析(2)作者：宋寶華 e-mail:21cnbao@21cn.com出處：軟件報3.內(nèi)功題試題 1：分別給出 BOOL，int，float，指針變量與“零值”比較的 if 語句（假設變量名為 var）解答：BOOL 型變量：if(!var)int 型變量： if(var==0)float 型變量：const float EPSINON = 0.00001;if ((x >= - EPSINON) && (x <= EPSINON)指針變量： if(var==NULL)剖析：考查對 0 值判斷的“內(nèi)功”，BOOL 型變量的 0 判斷完全可以寫成 if(var==0)，而 int 型變量也可以寫成 if(!var)，指針變量的判斷也可以寫成 if(!var)，上述寫法雖然程序都能正確運行，但是未能清晰地表達程序的意思。一般的，如果想讓 if 判斷一個變量的“真”、“假”，應直接使用 if(var)、if(!var)，表明其為“邏輯”判斷；如果用 if 判斷一個數(shù)值型變量(short、int、long 等)，應該用 if(var==0)，表明是與 0進行“數(shù)值”上的比較；而判斷指針則適宜用 if(var==NULL)，這是一種很好的編程習慣。浮點型變量并不精確，所以不可將 float 變量用“==”或“！=”與數(shù)字比較，應該設法轉(zhuǎn)化成“>=”或“<=”形式。如果寫成 if (x == 0.0)，則判為錯，得 0 分。試題 2：以下為 Windows NT 下的 32 位 C++程序，請計算 sizeof 的值void Func ( char str[100] ){sizeof( str ) = ?}void *p = malloc( 100 );sizeof ( p ) = ?解答：sizeof( str ) = 4sizeof ( p ) = 4剖析：Func ( char str[100] )函數(shù)中數(shù)組名作為函數(shù)形參時，在函數(shù)體內(nèi)，數(shù)組名失去了本身的內(nèi)涵，僅僅只是一個指針；在失去其內(nèi)涵的同時，它還失去了其常量特性，可以作自增、自減等操作，可以被修改。數(shù)組名的本質(zhì)如下：68（1）數(shù)組名指代一種數(shù)據(jù)結(jié)構，這種數(shù)據(jù)結(jié)構就是數(shù)組；例如：char str[10];cout << sizeof(str) << endl;輸出結(jié)果為 10，str 指代數(shù)據(jù)結(jié)構 char[10]。（2）數(shù)組名可以轉(zhuǎn)換為指向其指代實體的指針，而且是一個指針常量，不能作自增、自減等操作，不能被修改；char str[10];str++; //編譯出錯，提示 str 不是左值（3）數(shù)組名作為函數(shù)形參時，淪為普通指針。Windows NT 32 位平臺下，指針的長度（占用內(nèi)存的大小）為 4 字節(jié)，故 sizeof( str ) 、sizeof ( p ) 都為 4。試題 3：寫一個“標準”宏 MIN，這個宏輸入兩個參數(shù)并返回較小的一個。另外，當你寫下面的代碼時會發(fā)生什么事？least = MIN(*p++, b);解答：#define MIN(A,B) ((A) <= (B) ? (A) : (B))MIN(*p++, b)會產(chǎn)生宏的副作用剖析：這個面試題主要考查面試者對宏定義的使用，宏定義可以實現(xiàn)類似于函數(shù)的功能，但是它終歸不是函數(shù)，而宏定義中括弧中的“參數(shù)”也不是真的參數(shù)，在宏展開的時候?qū)Α皡?shù)”進行的是一對一的替換。程序員對宏定義的使用要非常小心，特別要注意兩個問題：（1）謹慎地將宏定義中的“參數(shù)”和整個宏用用括弧括起來。所以，嚴格地講，下述解答：#define MIN(A,B) (A) <= (B) ? (A) : (B)#define MIN(A,B) (A <= B ? A : B )都應判 0 分；（2）防止宏的副作用。宏定義#define MIN(A,B) ((A) <= (B) ? (A) : (B))對 MIN(*p++, b)的作用結(jié)果是：((*p++) <= (b) ? (*p++) : (b))這個表達式會產(chǎn)生副作用，指針 p 會作兩次++自增操作。除此之外，另一個應該判 0 分的解答是：#define MIN(A,B) ((A) <= (B) ? (A) : (B));這個解答在宏定義的后面加“;”，顯示編寫者對宏的概念模糊不清，只能被無情地判 0 分并被面試官淘汰。試題 4：為什么標準頭文件都有類似以下的結(jié)構？#ifndef __INCvxWorksh#define __INCvxWorksh#ifdef __cplusplusextern "C" {#endif/*...*/#ifdef __cplusplus}69#endif#endif /* __INCvxWorksh */解答：頭文件中的編譯宏#ifndef __INCvxWorksh#define __INCvxWorksh#endif的作用是防止被重復引用。作為一種面向?qū)ο蟮恼Z言，C++支持函數(shù)重載，而過程式語言 C 則不支持。函數(shù)被 C++編譯后在 symbol庫中的名字與 C 語言的不同。例如，假設某個函數(shù)的原型為：void foo(int x, int y);該函數(shù)被 C 編譯器編譯后在 symbol 庫中的名字為_foo，而 C++編譯器則會產(chǎn)生像_foo_int_int 之類的名字。_foo_int_int 這樣的名字包含了函數(shù)名和函數(shù)參數(shù)數(shù)量及類型信息，C++就是考這種機制來實現(xiàn)函數(shù)重載的。為了實現(xiàn) C 和 C++的混合編程，C++提供了 C 連接交換指定符號 extern "C"來解決名字匹配問題，函數(shù)聲明前加上 extern "C"后，則編譯器就會按照 C 語言的方式將該函數(shù)編譯為_foo，這樣 C 語言中就可以調(diào)用 C++的函數(shù)了。試題 5：編寫一個函數(shù)，作用是把一個 char 組成的字符串循環(huán)右移 n 個。比如原來是“abcdefghi”如果 n=2，移位后應該是“hiabcdefgh”函數(shù)頭是這樣的：//pStr 是指向以'/0'結(jié)尾的字符串的指針//steps 是要求移動的 nvoid LoopMove ( char * pStr, int steps ){//請?zhí)畛?..}解答：正確解答 1：void LoopMove ( char *pStr, int steps ){int n = strlen( pStr ) - steps;char tmp[MAX_LEN];strcpy ( tmp, pStr + n );strcpy ( tmp + steps, pStr);*( tmp + strlen ( pStr ) ) = '/0';strcpy( pStr, tmp );}正確解答 2：void LoopMove ( char *pStr, int steps ){int n = strlen( pStr ) - steps;char tmp[MAX_LEN];memcpy( tmp, pStr + n, steps );memcpy(pStr + steps, pStr, n );70memcpy(pStr, tmp, steps );}剖析：這個試題主要考查面試者對標準庫函數(shù)的熟練程度，在需要的時候引用庫函數(shù)可以很大程度上簡化程序編寫的工作量。最頻繁被使用的庫函數(shù)包括：（1）strcpy（2）memcpy（3）memset試題 6：已知 WAV 文件格式如下表，打開一個 WAV 文件，以適當?shù)臄?shù)據(jù)結(jié)構組織 WAV 文件頭并解析 WAV格式的各項信息。WAVE 文件格式說明表

偏移地址	字節(jié)數(shù)	數(shù)據(jù)類型	內(nèi) 容
00H	4	Char	"RIFF"標志	文件頭
04H	4	int32	文件長度
08H	4	Char	"WAVE"標志
0CH	4	Char	"fmt"標志
10H	4	過渡字節(jié)（不定）
14H	2	int16	格式類別
16H	2	int16	通道數(shù)
18H	2	int16	采樣率（每秒樣本數(shù)），表示每個通道的播放速度
1CH	4	int32	波形音頻數(shù)據(jù)傳送速率
20H	2	int16	數(shù)據(jù)塊的調(diào)整數(shù)（按字節(jié)算的）
22H	2	每樣本的數(shù)據(jù)位數(shù)
24H	4	Char	數(shù)據(jù)標記符＂data＂
28H	4	int32	語音數(shù)據(jù)的長度

解答：將 WAV 文件格式定義為結(jié)構體 WAVEFORMAT：typedef struct tagWaveFormat{char cRiffFlag[4];UIN32 nFileLen;char cWaveFlag[4];char cFmtFlag[4];char cTransition[4];UIN16 nFormatTag ;UIN16 nChannels;UIN16 nSamplesPerSec;UIN32 nAvgBytesperSec;UIN16 nBlockAlign;UIN16 nBitNumPerSample;char cDataFlag[4];71UIN16 nAudioLength;} WAVEFORMAT;假設 WAV 文件內(nèi)容讀出后存放在指針 buffer 開始的內(nèi)存單元內(nèi)，則分析文件格式的代碼很簡單，為：WAVEFORMAT waveFormat;memcpy( &waveFormat, buffer,sizeof( WAVEFORMAT ) );直接通過訪問 waveFormat 的成員，就可以獲得特定 WAV 文件的各項格式信息。剖析：試題 6 考查面試者組織數(shù)據(jù)結(jié)構的能力，有經(jīng)驗的程序設計者將屬于一個整體的數(shù)據(jù)成員組織為一個結(jié)構體，利用指針類型轉(zhuǎn)換，可以將 memcpy、memset 等函數(shù)直接用于結(jié)構體地址，進行結(jié)構體的整體操作。透過這個題可以看出面試者的程序設計經(jīng)驗是否豐富。試題 7：編寫類 String 的構造函數(shù)、析構函數(shù)和賦值函數(shù)，已知類 String 的原型為：class String{public:String(const char *str = NULL); // 普通構造函數(shù)String(const String &other); // 拷貝構造函數(shù)~ String(void); // 析構函數(shù)String & Operate =(const String &other); // 賦值函數(shù)private:char *m_data; // 用于保存字符串};解答：//普通構造函數(shù)String::String(const char *str){if(str==NULL){m_data = new char[1]; // 得分點：對空字符串自動申請存放結(jié)束標志'/0'的空//加分點：對 m_data 加 NULL 判斷*m_data = '/0';}else{int length = strlen(str);m_data = new char[length+1]; // 若能加 NULL 判斷則更好strcpy(m_data, str);}}// String 的析構函數(shù)String::~String(void){delete [] m_data; // 或 delete m_data;}72//拷貝構造函數(shù)String::String(const String &other) // 得分點：輸入?yún)?shù)為 const 型{int length = strlen(other.m_data);m_data = new char[length+1]; //加分點：對 m_data 加 NULL 判斷strcpy(m_data, other.m_data);}//賦值函數(shù)String & String::operate =(const String &other) // 得分點：輸入?yún)?shù)為 const 型{if(this == &other) //得分點：檢查自賦值return *this;delete [] m_data; //得分點：釋放原有的內(nèi)存資源int length = strlen( other.m_data );m_data = new char[length+1]; //加分點：對 m_data 加 NULL 判斷strcpy( m_data, other.m_data );return *this; //得分點：返回本對象的引用}剖析：能夠準確無誤地編寫出 String 類的構造函數(shù)、拷貝構造函數(shù)、賦值函數(shù)和析構函數(shù)的面試者至少已經(jīng)具備了 C++基本功的 60%以上！在這個類中包括了指針類成員變量 m_data，當類中包括指針類成員變量時，一定要重載其拷貝構造函數(shù)、賦值函數(shù)和析構函數(shù)，這既是對 C++程序員的基本要求，也是《Effective C++》中特別強調(diào)的條款。仔細學習這個類，特別注意加注釋的得分點和加分點的意義，這樣就具備了 60%以上的 C++基本功！試題 8：請說出 static 和 const 關鍵字盡可能多的作用解答：static 關鍵字至少有下列 n 個作用：（1）函數(shù)體內(nèi) static 變量的作用范圍為該函數(shù)體，不同于 auto 變量，該變量的內(nèi)存只被分配一次，因此其值在下次調(diào)用時仍維持上次的值；（2）在模塊內(nèi)的 static 全局變量可以被模塊內(nèi)所用函數(shù)訪問，但不能被模塊外其它函數(shù)訪問；（3）在模塊內(nèi)的 static 函數(shù)只可被這一模塊內(nèi)的其它函數(shù)調(diào)用，這個函數(shù)的使用范圍被限制在聲明它的模塊內(nèi)；（4）在類中的 static 成員變量屬于整個類所擁有，對類的所有對象只有一份拷貝；（5）在類中的 static 成員函數(shù)屬于整個類所擁有，這個函數(shù)不接收 this 指針，因而只能訪問類的static 成員變量。const 關鍵字至少有下列 n 個作用：（1）欲阻止一個變量被改變，可以使用 const 關鍵字。在定義該 const 變量時，通常需要對它進行初始化，因為以后就沒有機會再去改變它了；（2）對指針來說，可以指定指針本身為 const，也可以指定指針所指的數(shù)據(jù)為 const，或二者同時指定為 const；（3）在一個函數(shù)聲明中，const 可以修飾形參，表明它是一個輸入?yún)?shù)，在函數(shù)內(nèi)部不能改變其值；（4）對于類的成員函數(shù)，若指定其為 const 類型，則表明其是一個常函數(shù)，不能修改類的成員變量；（5）對于類的成員函數(shù)，有時候必須指定其返回值為 const 類型，以使得其返回值不為“左值”。例73如：const classA operator*(const classA& a1,const classA& a2);operator*的返回結(jié)果必須是一個 const 對象。如果不是，這樣的變態(tài)代碼也不會編譯出錯：classA a, b, c;(a * b) = c; // 對 a*b 的結(jié)果賦值操作(a * b) = c 顯然不符合編程者的初衷，也沒有任何意義。剖析：驚訝嗎？小小的 static 和 const 居然有這么多功能，我們能回答幾個？如果只能回答 1~2 個，那還真得閉關再好好修煉修煉。這個題可以考查面試者對程序設計知識的掌握程度是初級、中級還是比較深入，沒有一定的知識廣度和深度，不可能對這個問題給出全面的解答。大多數(shù)人只能回答出 static 和 const 關鍵字的部分功能。4.技巧題試題 1：請寫一個 C 函數(shù)，若處理器是 Big_endian 的，則返回 0；若是 Little_endian 的，則返回 1解答：int checkCPU(){{union w{int a;char b;} c;c.a = 1;return (c.b == 1);}}剖析：嵌入式系統(tǒng)開發(fā)者應該對 Little-endian 和 Big-endian 模式非常了解。采用 Little-endian 模式的 CPU對操作數(shù)的存放方式是從低字節(jié)到高字節(jié)，而 Big-endian 模式對操作數(shù)的存放方式是從高字節(jié)到低字節(jié)。例如，16bit 寬的數(shù) 0x1234 在 Little-endian 模式 CPU 內(nèi)存中的存放方式（假設從地址 0x4000開始存放）為：

內(nèi) 存地址	0x4000	0x4001
存放內(nèi)容	0x34	0x12

而在 Big-endian 模式 CPU 內(nèi)存中的存放方式則為：

內(nèi) 存地址	0x4000	0x4001
存放內(nèi)容	0x12	0x34

32bit 寬的數(shù) 0x12345678 在 Little-endian 模式 CPU 內(nèi)存中的存放方式（假設從地址 0x4000 開始存放）為：

內(nèi) 存地

0x4000

0x4001

0x4002

0x4003

址
存放內(nèi)容	0x78	0x56	0x34	0x12

而在 Big-endian 模式 CPU 內(nèi)存中的存放方式則為：

內(nèi) 存地址	0x4000	0x4001	0x4002	0x4003
存放內(nèi)容	0x12	0x34	0x56	0x78

聯(lián)合體 union 的存放順序是所有成員都從低地址開始存放，面試者的解答利用該特性，輕松地獲得了CPU 對內(nèi)存采用 Little-endian 還是 Big-endian 模式讀寫。如果誰能當場給出這個解答，那簡直就是一個天才的程序員。試題 2：寫一個函數(shù)返回 1+2+3+…+n 的值（假定結(jié)果不會超過長整型變量的范圍）解答：int Sum( int n ){return ( (long)1 + n) * n / 2; //或 return (1l + n) * n / 2;}剖析：對于這個題，只能說，也許最簡單的答案就是最好的答案。下面的解答，或者基于下面的解答思路去優(yōu)化，不管怎么“折騰”，其效率也不可能與直接 return ( 1 l + n ) * n / 2 相比！int Sum( int n ){long sum = 0;for( int i=1; i<=n; i++ ){sum += i;}return sum;}所以程序員們需要敏感地將數(shù)學等知識用在程序設計中。一道著名外企面試題的抽絲剝繭宋寶華 21cnbao@21cn.com軟件報問題：對于一個字節(jié)（ 8bit）的數(shù)據(jù)，求其中“1”的個數(shù)，要求算法的執(zhí)行效率盡可能地高。分析：作為一道著名外企的面試題，看似簡單，實則可以看出一個程序員的基本功底的扎實程度。你或許已經(jīng)想到很多方法，譬如除、余操作，位操作等，但都不是最快的。本文一步步分析，直到最后給出一個最快的方法，相信你看到本文最后的那個最快的方法時會有驚詫的感覺。解答：首先，很自然的，你想到除法和求余運算，并給出了如下的答案：方法 1：使用除、余操作75#include#define BYTE unsigned charint main(int argc, char *argv[]){int i, num = 0;BYTE a;/* 接收用戶輸入 */printf("/nPlease Input a BYTE(0~255):");scanf("%d", &a);/* 計算 1的個數(shù) */for (i = 0; i < 8; i++){if (a % 2 == 1){num++;}a = a / 2;}printf("/nthe num of 1 in the BYTE is %d", num);return 0;}很遺憾，眾所周知，除法操作的運算速率實在是很低的，這個答案只能意味著面試者被淘汰！好，精明的面試者想到了以位操作代替除法和求余操作，并給出如下答案：方法 2：使用位操作#include#define BYTE unsigned charint main(int argc, char *argv[]){int i, num = 0;BYTE a;/* 接收用戶輸入 */printf("/nPlease Input a BYTE(0~255):");scanf("%d", &a);/* 計算 1的個數(shù) */for (i = 0; i < 8; i++){num += (a >> i) &0x01;}/*或者這樣計算 1的個數(shù)： *//* for(i=0;i<8;i++){if((a>>i)&0x01)num++;}76*/printf("/nthe num of 1 in the BYTE is %d", num);return 0;}方法二中 num += (a >> i) &0x01;操作的執(zhí)行效率明顯高于方法一中的if (a % 2 == 1){num++;}a = a / 2;到這個時候，面試者有被錄用的可能性了，但是，難道最快的就是這個方法了嗎？沒有更快的了嗎？方法二真的高山仰止了嗎？能不能不用做除法、位操作就直接得出答案的呢？于是你想到把 0~255 的情況都羅列出來，并使用分支操作，給出如下答案：方法 3：使用分支操作#include#define BYTE unsigned charint main(int argc, char *argv[]){int i, num = 0;BYTE a;/* 接收用戶輸入 */printf("/nPlease Input a BYTE(0~255):");scanf("%d", &a);/* 計算 1的個數(shù) */switch (a){case 0x0:num = 0;break;case 0x1:case 0x2:case 0x4:case 0x8:case 0x10:case 0x20:case 0x40:case 0x80:num = 1;break;case 0x3:case 0x6:case 0xc:case 0x18:77case 0x30:case 0x60:case 0xc0:num = 2;break;//...}printf("/nthe num of 1 in the BYTE is %d", num);return 0;}方法三看似很直接，實際執(zhí)行效率可能還會小于方法二，因為分支語句的執(zhí)行情況要看具體字節(jié)的值，如果a=0，那自然在第 1 個case 就得出了答案，但是如果a=255，則要在最后一個case 才得出答案，即在進行了255次比較操作之后！看來方法三不可取！但是方法三提供了一個思路，就是羅列并直接給出值，離最后的方法四只有一步之遙。眼看著就要被這家著名外企錄用，此時此刻，絕不對放棄尋找更快的方法。終于，靈感一現(xiàn)，得到方法四，一個令你心潮澎湃的答案，快地令人咋舌，算法中不需要進行任何的運算。你有足夠的信心了，把下面的答案遞給面試官：方法 4：直接得到結(jié)果#include#define BYTE unsigned char/* 定義查找表 */BYTE numTable[256] ={0, 1, 1, 2, 1, 2, 2, 3, 1, 2, 2, 3, 2, 3, 3, 4, 1, 2, 2, 3, 2, 3, 3, 4, 2, 3,3, 4, 3, 4, 4, 5, 1, 2, 2, 3, 2, 3, 3, 4, 2, 3, 3, 4, 3, 4, 4, 5, 2, 3, 3,4, 3, 4, 4, 5, 3, 4, 4, 5, 4, 5, 5, 6, 1, 2, 2, 3, 2, 3, 3, 4, 2, 3, 3, 4,3, 4, 4, 5, 2, 3, 3, 4, 3, 4, 4, 5, 3, 4, 4, 5, 4, 5, 5, 6, 2, 3, 3, 4, 3,4, 4, 5, 3, 4, 4, 5, 4, 5, 5, 6, 3, 4, 4, 5, 4, 5, 5, 6, 4, 5, 5, 6, 5, 6,6, 7, 1, 2, 2, 3, 2, 3, 3, 4, 2, 3, 3, 4, 3, 4, 4, 5, 2, 3, 3, 4, 3, 4, 4,5, 3, 4, 4, 5, 4, 5, 5, 6, 2, 3, 3, 4, 3, 4, 4, 5, 3, 4, 4, 5, 4, 5, 5, 6,3, 4, 4, 5, 4, 5, 5, 6, 4, 5, 5, 6, 5, 6, 6, 7, 2, 3, 3, 4, 3, 4, 4, 5, 3,4, 4, 5, 4, 5, 5, 6, 3, 4, 4, 5, 4, 5, 5, 6, 4, 5, 5, 6, 5, 6, 6, 7, 3, 4,4, 5, 4, 5, 5, 6, 4, 5, 5, 6, 5, 6, 6, 7, 4, 5, 5, 6, 5, 6, 6, 7, 5, 6, 6,7, 6, 7, 7, 8};int main(int argc, char *argv[]){int i, num = 0;BYTE a = 0;/* 接收用戶輸入 */printf("/nPlease Input a BYTE(0~255):");scanf("%d", &a);/* 計算 1的個數(shù) *//* 用 BYTE直接作為數(shù)組的下標取出 1的個數(shù)，妙哉！ */78printf("/nthe num of 1 in the BYTE is %d", checknum[a]);return 0;}這是個典型的空間換時間算法，把0~255中1的個數(shù)直接存儲在數(shù)組中，字節(jié)a作為數(shù)組的下標，checknum[a]直接就是 a中“1”的個數(shù)！算法的復雜度如下：時間復雜度： O(1)空間復雜度： O(2n)恭喜你，你已經(jīng)被這家著名的外企錄用！老總向你伸出手，說：“Welcome to our company”。C/C++結(jié)構體的一個高級特性――指定成員的位數(shù)宋寶華 21cnbao@21cn.comsweek在大多數(shù)情況下，我們一般這樣定義結(jié)構體：struct student{unsigned int sex;unsigned int age;};對于一般的應用，這已經(jīng)能很充分地實現(xiàn)數(shù)據(jù)了的“封裝”。但是，在實際工程中，往往碰到這樣的情況：那就是要用一個基本類型變量中的不同的位表示不同的含義。譬如一個 cpu 內(nèi)部的標志寄存器，假設為16 bit，而每個bit 都可以表達不同的含義，有的表示結(jié)果是否為0，有的表示是否越界等等。這個時候我們用什么數(shù)據(jù)結(jié)構來表達這個寄存器呢？答案還是結(jié)構體！為達到此目的，我們要用到結(jié)構體的高級特性，那就是在基本成員變量的后面添加：: 數(shù)據(jù)位數(shù)組成新的結(jié)構體：struct xxx{成員 1類型成員 1 :成員 1位數(shù);成員 2類型成員 2 :成員 2位數(shù);成員 3類型成員 3 :成員 3位數(shù);};基本的成員變量就會被拆分！這個語法在初級編程中很少用到，但是在高級程序設計中不斷地被用到！例如：struct student{unsigned int sex : 1;unsigned int age : 15;};上述結(jié)構體中的兩個成員 sex和 age加起來只占用了一個 unsigned int的空間（假設 unsigned int為 16位）。基本成員變量被拆分后，訪問的方法仍然和訪問沒有拆分的情況是一樣的，例如：79struct student sweek;sweek.sex = MALE;sweek.age = 20;雖然拆分基本成員變量在語法上是得到支持的，但是并不等于我們想怎么分就怎么分，例如下面的拆分顯然是不合理的：struct student{unsigned int sex : 1;unsigned int age : 12;};這是因為 1+12 = 13，不能再組合成一個基本成員，不能組合成char、int 或任何類型，這顯然是不能“自圓其說”的。在拆分基本成員變量的情況下，我們要特別注意數(shù)據(jù)的存放順序，這還與 CPU 是Big endian 還是Little endian來決定。 Little endian和 Big endian是 CPU存放數(shù)據(jù)的兩種不同順序。對于整型、長整型等數(shù)據(jù)類型，Bigendian 認為第一個字節(jié)是最高位字節(jié)（按照從低地址到高地址的順序存放數(shù)據(jù)的高位字節(jié)到低位字節(jié)）；而Little endian 則相反，它認為第一個字節(jié)是最低位字節(jié)（按照從低地址到高地址的順序存放數(shù)據(jù)的低位字節(jié)到高位字節(jié)）。我們定義 IP 包頭結(jié)構體為：struct iphdr {#if defined(__LITTLE_ENDIAN_BITFIELD)__u8 ihl:4,version:4;#elif defined (__BIG_ENDIAN_BITFIELD)__u8 version:4,ihl:4;#else#error "Please fix <asm/byteorder.h>"#endif__u8 tos;__u16 tot_len;__u16 id;__u16 frag_off;__u8 ttl;__u8 protocol;__u16 check;__u32 saddr;__u32 daddr;/*The options start here. */};在 Little endian模式下， iphdr中定義：__u8 ihl:4,version:4;其存放方式為：第 1 字節(jié)低4 位ihl80第 1字節(jié)高 4位 version（ IP的版本號）若在 Big endian 模式下還這樣定義，則存放方式為：第 1 字節(jié)低4 位version （IP 的版本號）第 1 字節(jié)高4 位ihl這與實際的 IP協(xié)議是不匹配的，所以在 Linux內(nèi)核源代碼中， IP包頭結(jié)構體的定義利用了宏：#if defined(__LITTLE_ENDIAN_BITFIELD)…#elif defined (__BIG_ENDIAN_BITFIELD)…#endif來區(qū)分兩種不同的情況。由此我們總結(jié)全文的主要觀點：（ 1）C/C++語言的結(jié)構體支持對其中的基本成員變量按位拆分；（ 2）拆分的位數(shù)應該是合乎邏輯的，應仍然可以組合為基本成員變量；要特別注意拆分后的數(shù)據(jù)的存放順序，這一點要結(jié)合具體的CPU 的結(jié)構。C/C++中的近指令、遠指針和巨指針宋寶華 email:21cnbao@21cn.com sweek在我們的 C/C++學習生涯中、在我們大腦的印象里，通常只有指針的概念，很少聽說指針還有遠、近、巨之分的，從沒聽說過什么近指針、遠指針和巨指針。可以，某年某月的某一天，你突然看到這樣的語句：char near *p; /*定義一個字符型“近”指針*/char far *p; /*定義一個字符型“遠”指針*/char huge *p; /*定義一個字符型“巨”指針*/實在不知道語句中的“near”、“far”、“huge”是從哪里冒出來的，是個什么概念！本文試圖對此進行解答，解除許多人的困惑。這一點首先要從 8086 處理器體系結(jié)構和匯編淵源講起。大家知道，8086 是一個16 位處理器，它設定了四個段寄存器，專門用來保存段地址： CS（Code Segment）：代碼段寄存器；DS（Data Segment）：數(shù)據(jù)段寄存器； SS（Stack Segment）：堆棧段寄存器；ES（Extra Segment）：附加段寄存器。8086 采用段式訪問，訪問本段（ 64K 范圍內(nèi)）的數(shù)據(jù)或指令時，不需要變更段地址（意味著段地址寄存器不需修改），而訪問本段范圍以外的數(shù)據(jù)或指令時，則需要變更段地址（意味著段地址寄存器需要修改）。因此，在 16 位處理器環(huán)境下，如果訪問本段內(nèi)地址的值，用一個16 位的指針（表示段內(nèi)偏移）就可以訪問到；而要訪問本段以外地址的值，則需要用 16 位的段內(nèi)偏移+16位的段地址，總共 32位的指針。這樣，我們就知道了遠、近指針的區(qū)別：? 近指針是只能訪問本段、只包含本段偏移的、位寬為16 位的指針；? 遠指針是能訪問非本段、包含段偏移和段地址的、位寬為32 位的指針。近指針只能對64k 字節(jié)數(shù)據(jù)段內(nèi)的地址進行存取，如：char near *p;p=(char near *)0xffff;遠指針是 32 位指針，它表示段地址：偏移地址，遠指針可以進行跨段尋址，可以訪問整個內(nèi)存的地址。如定81義遠程指針 p指向 0x1000段的 0x2號地址，即 1000:0002，則可寫作：char far *p;p=(char far *)0x10000002;除了遠指針和近指針外，還有一個巨指針的概念。和遠指針一樣，巨指針也是 32 位的指針，指針也表示為16 位段：16 位偏移，也可以尋址任何地址。它和遠指針的區(qū)別在于進行了規(guī)格化處理。遠指針沒有規(guī)格化，可能存在兩個遠指針實際指向同一個物理地址，但是它們的段地址和偏移地址不一樣，如 23B0:0004 和23A1:00F4 都指向同一個物理地址23604！巨指針通過特定的例程保證：每次操作完成后其偏移量均小于 10h，即只有最低4 位有數(shù)值，其余數(shù)值都被進位到段地址上去了，這樣就可以避免 Far 指針在64K 邊界時出乎意料的回繞的行為。當然，一次操作必須小于64K。下面的函數(shù)可以將遠指針轉(zhuǎn)換為巨指針：void normalize(void far ** p){*p=(void far *)(((long)*p&0xffff000f)+(((long)*p&0x0000fff00<<12));}從上面的函數(shù)中我們再一次看到了指針之指針的使用，這個函數(shù)要修改指針的值，因此必須傳給它的指針的指針作為參數(shù)。講到這里，筆者要強調(diào)的是：近指針、遠指針、巨指針是段尋址的16bit 處理器的產(chǎn)物（如果處理器是16 位的，但是不采用段尋址的話，也不存在近指針、遠指針、巨指針的概念），當前普通 PC 所使用的32bit 處理器（ 80386 以上）一般運行在保護模式下的，指針都是32 位的，可平滑地址，已經(jīng)不分遠、近指針了。但是在嵌入式系統(tǒng)領域下， 8086 的處理器仍然有比較廣泛的市場，如AMD 公司的AM186ED、AM186ER 等處理器，開發(fā)這些系統(tǒng)的程序時，我們還是有必要弄清楚指針的尋址范圍。如果讀者還想更透徹地理解本文講解的內(nèi)容，不妨再溫習一下微機原理、 8086 匯編，并參考C/C++高級編程書籍的相關內(nèi)容。從兩道經(jīng)典試題談 C/C++中聯(lián)合體（union）的使用宋寶華 21cnbaosweek@21cn.com試題一：編寫一段程序判斷系統(tǒng)中的 CPU是 Little endian還是 Big endian模式？分析：作為一個計算機相關專業(yè)的人，我們應該在計算機組成中都學習過什么叫 Little endian 和 Big endian。Littleendian 和 Big endian是 CPU存放數(shù)據(jù)的兩種不同順序。對于整型、長整型等數(shù)據(jù)類型，Big endian 認為第一個字節(jié)是最高位字節(jié)（按照從低地址到高地址的順序存放數(shù)據(jù)的高位字節(jié)到低位字節(jié)）；而 Little endian則相反，它認為第一個字節(jié)是最低位字節(jié)（按照從低地址到高地址的順序存放數(shù)據(jù)的低位字節(jié)到高位字節(jié)）。例如，假設從內(nèi)存地址 0x0000 開始有以下數(shù)據(jù)：

0x0000	0x0001	0x0002	0x0003
0x12	0x34	0xab	0xcd

如果我們?nèi)プx取一個地址為 0x0000的四個字節(jié)變量，若字節(jié)序為 big-endian，則讀出結(jié)果為0x1234abcd；若字節(jié)序位 little-endian，則讀出結(jié)果為0xcdab3412。如果我們將0x1234abcd 寫入到以0x0000 開始的內(nèi)存中，則 Little endian 和Big endian 模式的存放結(jié)果如下：

地址

0x0000

0x0001

0x0002

0x0003

big-endian	0x12	0x34	0xab	0xcd
little-endian	0xcd	0xab	0x34	0x12

一般來說， x86系列 CPU都是 little-endian的字節(jié)序， PowerPC通常是 Big endian，還有的CPU 能通過跳線來設置 CPU 工作于Little endian 還是Big endian 模式。解答：顯然，解答這個問題的方法只能是將一個字節(jié)（ CHAR/BYTE 類型）的數(shù)據(jù)和一個整型數(shù)據(jù)存放于同樣的內(nèi)存開始地址，通過讀取整型數(shù)據(jù)，分析 CHAR/BYTE 數(shù)據(jù)在整型數(shù)據(jù)的高位還是低位來判斷CPU 工作于Littleendian 還是 Big endian模式。得出如下的答案：typedef unsigned char BYTE;int main(int argc, char* argv[]){unsigned int num,*p;p = #num = 0;*(BYTE *)p = 0xff;if(num == 0xff){printf("The endian of cpu is little/n");}else //num == 0xff000000{printf("The endian of cpu is big/n");}return 0;}除了上述方法(通過指針類型強制轉(zhuǎn)換并對整型數(shù)據(jù)首字節(jié)賦值，判斷該賦值賦給了高位還是低位)外，還有沒有更好的辦法呢？我們知道， union 的成員本身就被存放在相同的內(nèi)存空間（共享內(nèi)存，正是union 發(fā)揮作用、做貢獻的去處），因此，我們可以將一個 CHAR/BYTE 數(shù)據(jù)和一個整型數(shù)據(jù)同時作為一個union 的成員，得出如下答案：int checkCPU(){{union w{int a;char b;} c;c.a = 1;return (c.b == 1);}}實現(xiàn)同樣的功能，我們來看看 Linux操作系統(tǒng)中相關的源代碼是怎么做的：static union { char c[4]; unsigned long l; } endian_test = { { 'l', '?', '?', 'b' } };83#define ENDIANNESS ((char)endian_test.l)Linux 的內(nèi)核作者們僅僅用一個union 變量和一個簡單的宏定義就實現(xiàn)了一大段代碼同樣的功能！由以上一段代碼我們可以深刻領會到 Linux 源代碼的精妙之處！(如果ENDIANNESS=’l’表示系統(tǒng)為little endian,為’b’表示big endian)試題二：假設網(wǎng)絡節(jié)點 A和網(wǎng)絡節(jié)點 B中的通信協(xié)議涉及四類報文，報文格式為“報文類型字段+報文內(nèi)容的結(jié)構體”，四個報文內(nèi)容的結(jié)構體類型分別為STRUCTTYPE1~ STRUCTTYPE4，請編寫程序以最簡單的方式組織一個統(tǒng)一的報文數(shù)據(jù)結(jié)構。分析：報文的格式為“報文類型+報文內(nèi)容的結(jié)構體”，在真實的通信中，每次只能發(fā)四類報文中的一種，我們可以將四類報文的結(jié)構體組織為一個 union（共享一段內(nèi)存，但每次有效的只是一種），然后和報文類型字段統(tǒng)一組織成一個報文數(shù)據(jù)結(jié)構。解答：根據(jù)上述分析，我們很自然地得出如下答案：typedef unsigned char BYTE;//報文內(nèi)容聯(lián)合體typedef union tagPacketContent{STRUCTTYPE1 pkt1;STRUCTTYPE2 pkt2;STRUCTTYPE3 pkt1;STRUCTTYPE4 pkt2;}PacketContent;//統(tǒng)一的報文數(shù)據(jù)結(jié)構typedef struct tagPacket{BYTE pktType;PacketContent pktContent;}Packet;總結(jié)在 C/C++程序的編寫中，當多個基本數(shù)據(jù)類型或復合數(shù)據(jù)結(jié)構要占用同一片內(nèi)存時，我們要使用聯(lián)合體（試題一是這樣的例證）；當多種類型，多個對象，多個事物只取其一時（我們姑且通俗地稱其為“n 選 1”），我們也可以使用聯(lián)合體來發(fā)揮其長處（試題二是這樣的例證）。基于 ARM 的嵌入式 Linux 移植真實體驗基于 ARM 的嵌入式 Linux 移植真實體驗（1） ――基本概念宋寶華 21cnbao@21cn.com出處：dev.yesky.com841.引言ARM 是 Advanced RISC Machines（高級精簡指令系統(tǒng)處理器）的縮寫，是 ARM 公司提供的一種微處理器知識產(chǎn)權（IP）核。ARM 的應用已遍及工業(yè)控制、消費類電子產(chǎn)品、通信系統(tǒng)、網(wǎng)絡系統(tǒng)、無線系統(tǒng)等各類產(chǎn)品市場。基于 ARM 技術的微處理器應用約占據(jù)了 32 位 RISC 微處理器 75％以上的市場份額。揭開你的手機、MP3、PDA，嘿嘿，里面多半藏著一個基于 ARM 的微處理器！ARM 內(nèi)核的數(shù)個系列（ARM7、ARM9、ARM9E、ARM10E、SecurCore、Xscale、StrongARM），各自滿足不同應用領域的需求，無孔不入的滲入嵌入式系統(tǒng)各個角落的應用。這是一個 ARM 的時代！下面的圖片顯示了 ARM 的隨處可見：有人的地方就有江湖（《武林外傳》），有嵌入式系統(tǒng)的地方就有 ARM。構建一個復雜的嵌入式系統(tǒng)，僅有硬件是不夠的，我們還需要進行操作系統(tǒng)的移植。我們通常在 ARM平臺上構建 Windows CE、Linux、Palm OS 等操作系統(tǒng)，其中 Linux 具有開放源代碼的優(yōu)點。下圖顯示了基于 ARM 嵌入式系統(tǒng)中軟件與硬件的關系：日前，筆者作為某嵌入式 ARM（硬件）/Linux（軟件）系統(tǒng)的項目負責人，帶領項目組成員進行了下述85工作：(1)基于 ARM920T 內(nèi)核 S3C2410A CPU 的電路板設計；(2)ARM 處理下底層軟件平臺搭建：a.Bootloader 的移植；b.嵌入式 Linux 操作系統(tǒng)內(nèi)核的移植；c.嵌入式 Linux 操作系統(tǒng)根文件系統(tǒng)的創(chuàng)建；d.電路板上外設 Linux 驅(qū)動程序的編寫。本文將真實地再現(xiàn)本項目開發(fā)過程中作者的心得，以便與廣大讀者共勉。第一章將簡單地介紹本 ARM開發(fā)板的硬件設計，第二章分析 Bootloader 的移植方法，第三章敘述嵌入式 Linux 的移植及文件系統(tǒng)的構建方法，第四章講解外設的驅(qū)動程序設計，第五章給出一個已構建好的軟硬件平臺上應用開發(fā)的實例。如果您有良好的嵌入式系統(tǒng)開發(fā)基礎，您將非常容易領會本文講解地內(nèi)容。即便是您從來沒有嵌入式系統(tǒng)的開發(fā)經(jīng)歷，本文也力求讓您讀起來不覺得生澀。您可以通過如下 email 與作者聯(lián)系：21cnbao@21cn.com。2.ARM 體系結(jié)構作為一種 RISC 體系結(jié)構的微處理器，ARM 微處理器具有 RISC 體系結(jié)構的典型特征。還具有如下增強特點：(l)在每條數(shù)據(jù)處理指令當中，都控制算術邏輯單元(ALU)和移位器，以使 ALU 和移位器獲得最大的利用率；(2)自動遞增和自動遞減的尋址模式，以優(yōu)化程序中的循環(huán)；(3)同時 Load 和 Store 多條指令，以增加數(shù)據(jù)吞吐量；(4)所有指令都條件執(zhí)行，以增大執(zhí)行吞吐量。ARM 體系結(jié)構的字長為 32 位，它們都支持 Byte(8 位)、Halfword(16 位)和 Word(32 位)3 種數(shù)據(jù)類型。ARM 處理器支持 7 種處理器模式，如下表：大部分應用程序都在 User 模式下運行。當處理器處于 User 模式下時，執(zhí)行的程序無法訪問一些被保護的系統(tǒng)資源，也不能改變模式，否則就會導致一次異常。對系統(tǒng)資源的使用由操作系統(tǒng)來控制。User 模式之外的其它幾種模式也稱為特權模式，它們可以完全訪問系統(tǒng)資源，可以自由地改變模式。其中的 FIQ、IRQ、supervisor、Abort 和 undefined 5 種模式也被稱為異常模式。在處理特定的異常時，系統(tǒng)進入這幾種模式。這 5 種異常模式都有各自的額外的寄存器，用于避免在發(fā)生異常的時候與用戶模式下的程序發(fā)生沖突。還有一種模式是 system 模式，任何異常都不會導致進入這一模式，而且它使用的寄存器和 User 模式下基本相同。它是一種特權模式，用于有訪問系統(tǒng)資源請求而又需要避免使用額外的寄存器的操作系統(tǒng)任務。程序員可見的 ARM 寄存器共有 37 個：31 個通用寄存器以及 6 個針對 ARM 處理器的不同工作模式所設立的專用狀態(tài)寄存器，如下圖：86ARM9 采用 5 級流水線操作：指令預取、譯碼、執(zhí)行、數(shù)據(jù)緩沖、寫回。ARM9 設置了 16 個字的數(shù)據(jù)緩沖和 4 個字的地址緩沖。這 5 級流水已被很多的 RISC 處理器所采用，被看作 RISC 結(jié)構的“經(jīng)典”。3.硬件設計3.1 S3C2410A 微控制器電路板上的 ARM 微控制器 S3C2410A 采用了 ARM920T 核，它由 ARM9TDMI、存儲管理單元 MMU 和高速緩存三部分組成。其中， MMU 可以管理虛擬內(nèi)存，高速緩存由獨立的 16KB 地址和 16KB 數(shù)據(jù)高速 Cache 組成。ARM920T 有兩個內(nèi)部協(xié)處理器：CP14 和 CP15。CP14 用于調(diào)試控制，CP15 用于存儲系統(tǒng)控制以及測試控制。S3C2410A 集成了大量的內(nèi)部電路和外圍接口：? LCD 控制器(支持 STN 和 TFT 帶有觸摸屏的液晶顯示屏)? SDRAM 控制器? 3 個通道的 UART? 4 個通道的 DMA? 4 個具有 PWM 功能的計時器和一個內(nèi)部時鐘? 8 通道的 10 位 ADC? 觸摸屏接口? I2C 總線接口? 12S 總線接口? 兩個 USB 主機接口? 一個 USB 設備接口? 兩個 SPI 接口? SD 接口? MMC 卡接口S3C2410A 集成了一個具有日歷功能的 RTC 和具有 PLL(MPLL 和 UPLL)的芯片時鐘發(fā)生器。MPLL 產(chǎn)生主時鐘，能夠使處理器工作頻率最高達到 203MHz。這個工作頻率能夠使處理器輕松運行 WinCE、Linux 等操作系統(tǒng)以及進行較為復雜的信息處理。UPLL 則產(chǎn)生實現(xiàn) USB 模塊的時鐘。下圖顯示了 S3C2410A 的集成資源和外圍接口：87我們需要對上圖中的 AHB 總線和 APB 總線的概念進行一番解釋。ARM 核開發(fā)的目的，是使其作為復雜片上系統(tǒng)的一個處理單元來應用的，所以還必須提供一個 ARM 與其它片上宏單元通信的接口。為了減少不必要的設計資源的浪費，ARM 公司定義了 AMBA(Advanced Microcontroller Bus Architecture)總線規(guī)范，它是一組針對基于 ARM 核的、片上系統(tǒng)之間通信而設計的、標準的、開放協(xié)議。在 AMBA 總線規(guī)范中，定義了 3 種總線：(l)AHB—Advanced High Performace Bus，用于高性能系統(tǒng)模塊的連接，支持突發(fā)模式數(shù)據(jù)傳輸和事務分割；(2)ASB—Advanced System Bus，也用于高性能系統(tǒng)模塊的連接，支持突發(fā)模式數(shù)據(jù)傳輸，這是較老的系統(tǒng)總線格式，后來由 AHB 總線替代；(3)APB—Advanced PeriPheral Bus，用于較低性能外設的簡單連接，一般是接在 AHB 或 ASB 系統(tǒng)總線上的第二級總線。典型的 AMBA 總線系統(tǒng)如下圖：S3C2410A 將系統(tǒng)的存儲空間分成 8 個 bank，每個 bank 的大小是 128M 字節(jié)，共 1G 字節(jié)。Bank0 到 bank5的開始地址是固定的，用于 ROM 或 SRAM。bank6 和 bank7 可用于 ROM、SRAM 或 SDRAM。所有內(nèi)存塊的訪問周期都可編程，外部 Wait 也能擴展訪問周期。下圖給出了 S3C2410A 的內(nèi)存組織：88下圖給出了 S3C2410A 的數(shù)據(jù)總線、地址總線和片選電路：SDRAM 控制信號、集成 USB 接口電路：89內(nèi)核與存儲單元供電電路（S3C2410A 對于片內(nèi)的各個部件采用了獨立的電源供給，內(nèi)核采用 1.8V 供電，存儲單元采用 3.3V 獨立供電）：JTAG 標準通過邊界掃描技術提供了對電路板上每一元件的功能、互聯(lián)及相互間影響進行測試的方法，極大地方便了系統(tǒng)電路的調(diào)試。測試接入端口 TAP 的管腳定義如下：? TCK：專用的邏輯測試時鐘，時鐘上升沿按串行方式對測試指令、數(shù)據(jù)及控制信號進行移位操作，下降沿用于對輸出信號移位操作；? TMS：測試模式選擇，在 TCK 上升沿有效的邏輯測試控制信號；? TDI：測試數(shù)據(jù)輸入，用于接收測試數(shù)據(jù)與測試指令；? TDO：測試數(shù)據(jù)輸出，用于測試數(shù)據(jù)的輸出。S3C2410A 調(diào)試用 JTAG 接口電路：903.2 SDRAM 存儲器SDRAM 被用來存放操作系統(tǒng)（從 FLASH 解壓縮拷入）以及存放各類動態(tài)數(shù)據(jù)，采用 SAMSUNG 公司的K4S561632，它是 4Mxl6bitx4bank 的同步 DRAM，容量為 32MB。用 2 片 K4S561632 實現(xiàn)位擴展，使數(shù)據(jù)總線寬度達到 32bit，總?cè)萘窟_到 64MB，將其地址空間映射在 S3C2410A 的 bank6。SDRAM 所有的輸入和輸出都與系統(tǒng)時鐘 CL K 上升沿同步，由輸入信號 RA S、CA S、WE 組合產(chǎn)生 SDRAM控制命令，其基本的控制命令如下：SDRAM 在具體操作之前首先必須通過 MRS 命令設置模式寄存器，以便確定 SDRAM 的列地址延遲、突發(fā)類型、突發(fā)長度等工作模式；再通過 ACT 命令激活對應地址的組，同時輸入行地址；然后通過 RD 或WR 命令輸入列地址，將相應數(shù)據(jù)讀出或?qū)懭雽牡刂罚徊僮魍瓿珊笥?PCH 命令或 BT 命令中止讀或?qū)懖僮鳌Ｔ跊]有操作的時候，每隔一段時間必須用 ARF 命令刷新數(shù)據(jù)，防止數(shù)據(jù)丟失。下圖給出了 SDRAM 的連接電路：913.3 FLASH 存儲器NOR 和 NAND 是現(xiàn)在市場上兩種主要的非易失閃存技術。NOR 的特點是芯片內(nèi)執(zhí)行(XIP，Execute In Place)，即應用程序可直接在 Flash 閃存內(nèi)運行，不必把代碼讀到系統(tǒng) RAM 中。NOR 的傳輸效率很高，在 1~4MB 的小容量時具有很高的成本效益，但是很低的寫入和擦除速度大大影響了它的性能。NAND 結(jié)構能提供極高的單元密度，可以達到高存儲密度，并且寫入和擦除的速度也很快。應用 NAND的困難在于 Flash 的管理和需要特殊的系統(tǒng)接口，S3C2410A 內(nèi)嵌了 NAND FLASH 控制器。S3C2410A 支持從 GCS0 上的 NOR FLASH 啟動（16 位或 32 位）或從 NAND FLASH 啟動，需要通過 OM0 和OM1 上電時的上下拉來設置：在系統(tǒng)中分別采用了一片 NOR FLASH(28F640)和 NAND FLASH(K9S1208)，電路如下圖：923.4 串口S3C2410 內(nèi)部集成了 UART 控制器，實現(xiàn)了并串轉(zhuǎn)換。外部還需提供 CMOS/TTL 電平與 RS232 之間的轉(zhuǎn)換：3.5 以太網(wǎng)以太網(wǎng)控制芯片采用 CIRRUS LOGIC 公司生產(chǎn)的 CS8900A，其突出特點是使用靈活，其物理層接口、數(shù)據(jù)傳輸模式和工作模式等都能根據(jù)需要而動態(tài)調(diào)整，通過內(nèi)部寄存器的設置來適應不同的應用環(huán)境。它符合 IEEE803.3 以太網(wǎng)標準，帶有傳送、接收低通濾波的 10Base-T 連接端口，支持 10Base2， 10Base5和 10Base-F 的 AUI 接口，并能自動生成報頭，自動進行 CRC 檢驗，在沖突后自動重發(fā)。CS8900A 支持的傳輸模式有 I/O 和 Memory 模式。當 CS8900A 有硬件復位或軟件復位時,它將默認成為 8位工作模式。因此，要使 CS8900A 工作于 16 位模式，系統(tǒng)必須在訪問之前提供給總線高位使能管腳(/SBHE)一個由高到低、再由低到高變化的電平。933.6 USB 接口USB 系統(tǒng)由 USB 主機（USB Host）、USB 集線器（USB Hub）和 USB 設備（USB Device）組成。USB 和主機系統(tǒng)的接口稱作主機控制器（Host Controller），它是由硬件和軟件結(jié)合實現(xiàn)的。根集線器是綜合于主機系統(tǒng)內(nèi)部的，用以提供 USB 的連接點。USB 的設備包括集線器（Hub）和功能器件（Function）。S3C2410A 集成了 USB host 和 USB device，外部連接電路如下圖：3.7 電源LDO(Low Dropout)屬于 DC/DC 變換器中的降壓變換器，它具有低成本、低噪聲、低功耗等突出優(yōu)點，另外它所需要的外圍器件也很少，通常只有 1~2 個旁路電容。在電路板上我們分別用兩個 LDO 來實現(xiàn) 5V 向 3.3V（存儲接口電平）和 1.8V（ARM 內(nèi)核電平）的轉(zhuǎn)換。94up 監(jiān)控電路采用 MAX708 芯片，提供上電、掉電以及降壓情況下的復位輸出及低電平有效的人工復位輸出：3.8 其它SN74LVTH62245A 提供總線驅(qū)動和緩沖能力：S3C2410A 集成 LCD 液晶顯示器控制電路，外部引出接口：95觸摸屏有電阻式、電容式等，其本質(zhì)是一種將手指在屏幕上的觸點位置轉(zhuǎn)化為電信號的傳感器。手指觸到屏幕，引起觸點位置電阻或電容的變化，再通過檢測這一電性變化，從而獲得手指的坐標位置。通過 S3C2410A 集成的 AD 功能，完成電信號向屏幕坐標的轉(zhuǎn)化，觸摸屏接口如下：鍵盤則直接利用 CPU 的可編程 I/O 口，若連接 mxn 鍵盤，則需要 m+n 個可編程 I/O 口，由軟件實現(xiàn)鍵盤掃描，識別按鍵：3.9 整體架構下圖呈現(xiàn)了 ARM 處理器及外圍電路的整體設計框架：964.小結(jié)本章講解了基于 S3C2410A ARM 處理器電路板硬件設計的基本組成，為后續(xù)各章提供了總體性的準備工作。基于 ARM 的嵌入式 Linux 移植真實體驗（2）――BootLoader宋寶華 21cnbao@21cn.com 出處:dev.yesky.comBootLoader 指系統(tǒng)啟動后，在操作系統(tǒng)內(nèi)核運行之前運行的一段小程序。通過 BootLoader，我們可以初始化硬件設備、建立內(nèi)存空間的映射圖，從而將系統(tǒng)的軟硬件環(huán)境帶到一個合適的狀態(tài)，以便為最終調(diào)用操作系統(tǒng)內(nèi)核準備好正確的環(huán)境。通常，BootLoader 是嚴重地依賴于硬件而實現(xiàn)的，特別是在嵌入式世界。因此，在嵌入式世界里建立一個通用的 BootLoader 幾乎是不可能的。盡管如此，我們?nèi)匀豢梢詫?BootLoader 歸納出一些通用的概念來，以指導用戶特定的 BootLoader 設計與實現(xiàn)。BootLoader 的實現(xiàn)依賴于 CPU 的體系結(jié)構，因此大多數(shù) BootLoader 都分為 stage1 和 stage2 兩大部分。依賴于CPU 體系結(jié)構的代碼，比如設備初始化代碼等，通常都放在 stage1 中，而且通常都用匯編語言來實現(xiàn)，以達到短小精悍的目的。而 stage2 則通常用 C 語言來實現(xiàn)，這樣可以實現(xiàn)更復雜的功能，而且代碼會具有更好的可讀性和可移植性。BootLoader 的 stage1 通常包括以下步驟：? 硬件設備初始化；? 為加載 Boot Loader 的 stage2 準備 RAM 空間；? 拷貝 Boot Loader 的 stage2 到 RAM 空間中；? 設置好堆棧；97? 跳轉(zhuǎn)到 stage2 的 C 入口點。Boot Loader 的 stage2 通常包括以下步驟：? 初始化本階段要使用到的硬件設備；? 檢測系統(tǒng)內(nèi)存映射(memory map)；? 將 kernel 映像和根文件系統(tǒng)映像從 flash 上讀到 RAM 空間中；? 為內(nèi)核設置啟動參數(shù)；? 調(diào)用內(nèi)核。本系統(tǒng)中的 BootLoader 參照韓國 mizi 公司的 vivi 進行修改。1.開發(fā)環(huán)境我們購買了武漢創(chuàng)維特信息技術有限公司開發(fā)的具有自主知識產(chǎn)權的應用于嵌入式軟件開發(fā)的集成軟、硬件開發(fā)平臺ADT（ARM Development Tools）它為基于 ARM 核的嵌入式應用提供了一整套完備的開發(fā)方案，包括程序編輯、工程管理和設置、程序編譯、程序調(diào)試等。ADT 嵌入式開發(fā)環(huán)境由 ADT Emulator for ARM 和 ADT IDE for ARM 組成。 ADT Emulator for ARM 通過 JTAG 實現(xiàn)主機和目標機之間的調(diào)試支持功能。它無需目標存儲器，不占用目標系統(tǒng)的任何端口資源。目標程序直接在目標板上運行，通過 ARM 芯片的 JTAG 邊界掃描口進行調(diào)試，屬于完全非插入式調(diào)試，其仿真效果接近真實系統(tǒng)。ADT IDE for ARM 為用戶提供高效明晰的圖形化嵌入式應用軟件開發(fā)環(huán)境，包括一整套完備的面向嵌入式系統(tǒng)的開發(fā)和調(diào)試工具：源碼編輯器、工程管理器、工程編譯器（編譯器、匯編器和連接器）、集成調(diào)試環(huán)境、ADT Emulator forARM 調(diào)試接口等。其界面同 Microsoft Visual Studio 環(huán)境相似，用戶可以在 ADT IDE for ARM 集成開發(fā)環(huán)境中創(chuàng)建工程、打開工程，建立、打開和編輯文件，編譯、連接、設置、運行、調(diào)試嵌入式應用程序。ADT 嵌入式軟件開發(fā)環(huán)境采用主機－目標機交叉開發(fā)模型。ADT IDE for ARM 運行于主機端，而 ADT Emulator for ARM實現(xiàn) ADT IDE for ARM 與目標機之間的連接。開發(fā)時，首先由 ADT IDE for ARM 編譯連接生成目標代碼，然后建立與 ADT Emulator for ARM 之間的調(diào)試通道，調(diào)試通道建立成功后，就可以在 ADT IDE for ARM 中通過 ADT Emulatorfor ARM 控制目標板實現(xiàn)目標程序的調(diào)試，包括將目標代碼下載到目標機中，控制程序運行，調(diào)試信息觀察等等。2.ARM 匯編ARM 本身屬于 RISC 指令系統(tǒng)，指令條數(shù)就很少，而其編程又以 C 等高級語言為主，我們僅需要在 Bootloader 的第一階段用到少量匯編指令：（1）+-運算ADD r0, r1, r298―― r0 := r1 + r2SUB r0, r1, r2―― r0 := r1 - r2其中的第二個操作數(shù)可以是一個立即數(shù)：ADD r3, r3, #1―― r3 := r3 + 1第二個操作數(shù)還可以是位移操作后的結(jié)果：ADD r3, r2, r1, LSL #3―― r3 := r2 + 8.r1（2）位運算AND r0, r1, r2―― r0 := r1 and r2ORR r0, r1, r2―― r0 := r1 or r2EOR r0, r1, r2―― r0 := r1 xor r2BIC r0, r1, r2―― r0 := r1 and not r2（3）寄存器搬移MOV r0, r2―― r0 := r2MVN r0, r2―― r0 := not r2（4）比較CMP r1, r2―― set cc on r1 - r2CMN r1, r2―― set cc on r1 + r2TST r1, r2―― set cc on r1 and r2TEQ r1, r2―― set cc on r1 or r2這些指令影響 CPSR 寄存器中的 (N, Z, C, V) 位（5）內(nèi)存操作LDR r0, [r1]―― r0 := mem [r1]STR r0, [r1]― mem [r1] := r0LDR r0, [r1, #4]―― r0 := mem [r1+4]LDR r0, [r1, #4] !―― r0 := mem [r1+4] r1 := r1 + 4LDR r0, [r1], #4―― r0 := mem [r1] r1 := r1 +499LDRB r0 , [r1]―― r0 := mem8 [r1]LDMIA r1, {r0, r2, r5}―― r0 := mem [r1] r2 := mem [r1+4] r5 := mem [r1+8]{..} 可以包括 r0~r15 中的所有寄存器，若包括 r15 (PC)將導致程序的跳轉(zhuǎn)。（6）控制流例 1:MOV r0, #0 ; initialize counterLOOP:ADD r0, r0, #1 ; increment counterCMP r0, #10 ; compare with limitBNE LOOP ; repeat if not equal例 2:CMP r0, #5ADDNE r1, r1, r0SUBNE r1, r1, r2――if (r0 != 5) {r1 := r1 + r0 - r2}3.BootLoader 第一階段3.1 硬件設備初始化基本的硬件初始化工作包括：? 屏蔽所有的中斷；? 設置 CPU 的速度和時鐘頻率；? RAM 初始化；? 初始化 LEDARM 的中斷向量表設置在 0 地址開始的 8 個字空間中，如下表：每當其中的某個異常發(fā)生后即將 PC 值置到相應的中斷向量處，每個中斷向量處放置一個跳轉(zhuǎn)指令到相應的中斷服務程序去進行處理，中斷向量表的程序如下：@ 0x00: Resetb Reset@ 0x04: Undefined instruction exceptionUndefEntryPoint:b HandleUndef@ 0x08: Software interrupt exceptionSWIEntryPoint:b HandleSWI@ 0x0c: Prefetch Abort (Instruction Fetch Memory Abort)PrefetchAbortEnteryPoint:b HandlePrefetchAbort@ 0x10: Data Access Memory AbortDataAbortEntryPoint:b HandleDataAbort100@ 0x14: Not usedNotUsedEntryPoint:b HandleNotUsed@ 0x18: IRQ(Interrupt Request) exceptionIRQEntryPoint:b HandleIRQ@ 0x1c: FIQ(Fast Interrupt Request) exceptionFIQEntryPoint:b HandleFIQ復位時關閉看門狗定時器、屏蔽所有中斷：Reset:@ disable watch dog timermov r1, #0x53000000mov r2, #0x0str r2, [r1]@ disable all interruptsmov r1, #INT_CTL_BASEmov r2, #0xffffffffstr r2, [r1, #oINTMSK]ldr r2, =0x7ffstr r2, [r1, #oINTSUBMSK]設置系統(tǒng)時鐘：@init clk@ 1:2:4mov r1, #CLK_CTL_BASEmov r2, #0x3str r2, [r1, #oCLKDIVN]mrc p15, 0, r1, c1, c0, 0 @ read ctrl registerorr r1, r1, #0xc0000000 @ Asynchronousmcr p15, 0, r1, c1, c0, 0 @ write ctrl register@ now, CPU clock is 200 Mhzmov r1, #CLK_CTL_BASEldr r2, mpll_200mhzstr r2, [r1, #oMPLLCON]點亮所有的用戶 LED：@ All LED onmov r1, #GPIO_CTL_BASEadd r1, r1, #oGPIO_Fldr r2,=0x55aastr r2, [r1, #oGPIO_CON]mov r2, #0xffstr r2, [r1, #oGPIO_UP]mov r2, #0x00str r2, [r1, #oGPIO_DAT]101設置（初始化）內(nèi)存映射：ENTRY(memsetup)@ initialise the static memory@ set memory control registersmov r1, #MEM_CTL_BASEadrl r2, mem_cfg_valadd r3, r1, #521: ldr r4, [r2], #4str r4, [r1], #4cmp r1, r3bne 1bmov pc, lr設置（初始化）UART：@ set GPIO for UARTmov r1, #GPIO_CTL_BASEadd r1, r1, #oGPIO_Hldr r2, gpio_con_uartstr r2, [r1, #oGPIO_CON]ldr r2, gpio_up_uartstr r2, [r1, #oGPIO_UP]bl InitUART@ Initialize UART@@ r0 = number of UART portInitUART:ldr r1, SerBasemov r2, #0x0str r2, [r1, #oUFCON]str r2, [r1, #oUMCON]mov r2, #0x3str r2, [r1, #oULCON]ldr r2, =0x245str r2, [r1, #oUCON]#define UART_BRD ((50000000 / (UART_BAUD_RATE * 16)) - 1)mov r2, #UART_BRstr r2, [r1, #oUBRDIV]mov r3, #100mov r2, #0x01: sub r3, r3, #0x1tst r2, r3bne 1b#if 0mov r2, #'U'str r2, [r1, #oUTXHL]1021: ldr r3, [r1, #oUTRSTAT]and r3, r3, #UTRSTAT_TX_EMPTYtst r3, #UTRSTAT_TX_EMPTYbne 1bmov r2, #'0'str r2, [r1, #oUTXHL]1: ldr r3, [r1, #oUTRSTAT]and r3, r3, #UTRSTAT_TX_EMPTYtst r3, #UTRSTAT_TX_EMPTYbne 1b#endifmov pc, lr此外，vivi 還提供了幾個匯編情況下通過串口打印字符的函數(shù) PrintChar、PrintWord 和 PrintHexWord：@ PrintChar : prints the character in R0@ r0 contains the character@ r1 contains base of serial port@ writes ro with XXX, modifies r0,r1,r2@ TODO : write ro with XXX reg to error handlingPrintChar:TXBusy:ldr r2, [r1, #oUTRSTAT]and r2, r2, #UTRSTAT_TX_EMPTYtst r2, #UTRSTAT_TX_EMPTYbeq TXBusystr r0, [r1, #oUTXHL]mov pc, lr@ PrintWord : prints the 4 characters in R0@ r0 contains the binary word@ r1 contains the base of the serial port@ writes ro with XXX, modifies r0,r1,r2@ TODO : write ro with XXX reg to error handlingPrintWord:mov r3, r0mov r4, lrbl PrintCharmov r0, r3, LSR #8 /* shift word right 8 bits */bl PrintCharmov r0, r3, LSR #16 /* shift word right 16 bits */bl PrintCharmov r0, r3, LSR #24 /* shift word right 24 bits */bl PrintCharmov r0, #'/r'bl PrintChar103mov r0, #'/n'bl PrintCharmov pc, r4@ PrintHexWord : prints the 4 bytes in R0 as 8 hex ascii characters@ followed by a newline@ r0 contains the binary word@ r1 contains the base of the serial port@ writes ro with XXX, modifies r0,r1,r2@ TODO : write ro with XXX reg to error handlingPrintHexWord:mov r4, lrmov r3, r0mov r0, r3, LSR #28bl PrintHexNibblemov r0, r3, LSR #24bl PrintHexNibblemov r0, r3, LSR #20bl PrintHexNibblemov r0, r3, LSR #16bl PrintHexNibblemov r0, r3, LSR #12bl PrintHexNibblemov r0, r3, LSR #8bl PrintHexNibblemov r0, r3, LSR #4bl PrintHexNibblemov r0, r3bl PrintHexNibblemov r0, #'/r'bl PrintCharmov r0, #'/n'bl PrintCharmov pc, r43.2Bootloader 拷貝配置為從 NAND FLASH 啟動，需要將 NAND FLASH 中的 vivi 代碼 copy 到 RAM 中：#ifdef CONFIG_S3C2410_NAND_BOOTbl copy_myself@ jump to ramldr r1, =on_the_ramadd pc, r1, #0nopnop1: b 1b @ infinite loop#ifdef CONFIG_S3C2410_NAND_BOOT104@@ copy_myself: copy vivi to ram@copy_myself:mov r10, lr@ reset NANDmov r1, #NAND_CTL_BASEldr r2, =0xf830 @ initial valuestr r2, [r1, #oNFCONF]ldr r2, [r1, #oNFCONF]bic r2, r2, #0x800 @ enable chipstr r2, [r1, #oNFCONF]mov r2, #0xff @ RESET commandstrb r2, [r1, #oNFCMD]mov r3, #0 @ wait1: add r3, r3, #0x1cmp r3, #0xablt 1b2: ldr r2, [r1, #oNFSTAT] @ wait readytst r2, #0x1beq 2bldr r2, [r1, #oNFCONF]orr r2, r2, #0x800 @ disable chipstr r2, [r1, #oNFCONF]@ get read to call C functions (for nand_read())ldr sp, DW_STACK_START @ setup stack pointermov fp, #0 @ no previous frame, so fp=0@ copy vivi to RAMldr r0, =VIVI_RAM_BASEmov r1, #0x0mov r2, #0x20000bl nand_read_lltst r0, #0x0beq ok_nand_read#ifdef CONFIG_DEBUG_LLbad_nand_read:ldr r0, STR_FAILldr r1, SerBasebl PrintWord1: b 1b @ infinite loop#endifok_nand_read:#ifdef CONFIG_DEBUG_LLldr r0, STR_OK105ldr r1, SerBasebl PrintWord#endif@ verifymov r0, #0ldr r1, =0x33f00000mov r2, #0x400 @ 4 bytes * 1024 = 4K-bytesgo_next:ldr r3, [r0], #4ldr r4, [r1], #4teq r3, r4bne notmatchsubs r2, r2, #4beq done_nand_readbne go_nextnotmatch:#ifdef CONFIG_DEBUG_LLsub r0, r0, #4ldr r1, SerBasebl PrintHexWordldr r0, STR_FAILldr r1, SerBasebl PrintWord#endif1: b 1bdone_nand_read:#ifdef CONFIG_DEBUG_LLldr r0, STR_OKldr r1, SerBasebl PrintWord#endifmov pc, r10@ clear memory@ r0: start address@ r1: lengthmem_clear:mov r2, #0mov r3, r2mov r4, r2mov r5, r2mov r6, r2mov r7, r2mov r8, r2mov r9, r2106clear_loop:stmia r0!, {r2-r9}subs r1, r1, #(8 * 4)bne clear_loopmov pc, lr#endif @ CONFIG_S3C2410_NAND_BOOT3.3 進入 C 代碼首先要設置堆棧指針 sp，堆棧指針的設置是為了執(zhí)行 C 語言代碼作好準備。設置好堆棧后，調(diào)用 C 語言的 main 函數(shù)：@ get read to call C functionsldr sp, DW_STACK_START @ setup stack pointermov fp, #0 @ no previous frame, so fp=0mov a2, #0 @ set argv to NULLbl main @ call mainmov pc, #FLASH_BASE @ otherwise, reboot4. BootLoader 第二階段vivi Bootloader 的第二階段又分成了八個小階段，在 main 函數(shù)中分別調(diào)用這幾個小階段的相關函數(shù)：int main(int argc, char *argv[]){int ret;/** Step 1:*/putstr("/r/n");putstr(vivi_banner);reset_handler();/** Step 2:*/ret = board_init();if (ret) {putstr("Failed a board_init() procedure/r/n");error();}/** Step 3:*/mem_map_init();mmu_init();putstr("Succeed memory mapping./r/n");/** Now, vivi is running on the ram. MMU is enabled.*//** Step 4:107*//* initialize the heap area*/ret = heap_init();if (ret) {putstr("Failed initailizing heap region/r/n");error();}/* Step 5:*/ret = mtd_dev_init();/* Step 6:*/init_priv_data();/* Step 7:*/misc();init_builtin_cmds();/* Step 8:*/boot_or_vivi();return 0;}STEP1 的 putstr(vivi_banner)語句在串口輸出一段字符說明 vivi 的版本、作者等信息，vivi_banner 定義為：const char *vivi_banner ="VIVI version " VIVI_RELEASE " (" VIVI_COMPILE_BY "@"VIVI_COMPILE_HOST ") (" VIVI_COMPILER ") " UTS_VERSION "/r/n";reset_handler 進行相應的復位處理：voidreset_handler(void){int pressed;pressed = is_pressed_pw_btn();if (pressed == PWBT_PRESS_LEVEL) {DPRINTK("HARD RESET/r/n");hard_reset_handle();} else {DPRINTK("SOFT RESET/r/n");soft_reset_handle();}}hard_reset_handle 會 clear 內(nèi)存，而軟件復位處理則什么都不做：static voidhard_reset_handle(void){108clear_mem((unsigned long)USER_RAM_BASE, (unsigned long)USER_RAM_SIZE);}STEP2 進行板初始化，設置時間和可編程 I/O 口：int board_init(void){init_time();set_gpios();return 0;}STEP3 進行內(nèi)存映射及 MMU 初始化：void mem_map_init(void){#ifdef CONFIG_S3C2410_NAND_BOOTmem_map_nand_boot();#elsemem_map_nor();#endifcache_clean_invalidate();tlb_invalidate();}S3C2410A 的 MMU 初始化只需要調(diào)用通用的 arm920 MMU 初始化函數(shù)：static inline void arm920_setup(void){unsigned long ttb = MMU_TABLE_BASE;__asm__(/* Invalidate caches */"mov r0, #0/n""mcr p15, 0, r0, c7, c7, 0/n" /* invalidate I,D caches on v4 */"mcr p15, 0, r0, c7, c10, 4/n" /* drain write buffer on v4 */"mcr p15, 0, r0, c8, c7, 0/n" /* invalidate I,D TLBs on v4 *//* Load page table pointer */"mov r4, %0/n""mcr p15, 0, r4, c2, c0, 0/n" /* load page table pointer *//* Write domain id (cp15_r3) */"mvn r0, #0/n" /* Domains 0, 1 = client */"mcr p15, 0, r0, c3, c0, 0/n" /* load domain access register *//* Set control register v4 */"mrc p15, 0, r0, c1, c0, 0/n" /* get control register v4 *//* Clear out 'unwanted' bits (then put them in if we need them) *//* .RVI ..RS B... .CAM */"bic r0, r0, #0x3000/n" /* ..11 .... .... .... */"bic r0, r0, #0x0300/n" /* .... ..11 .... .... */"bic r0, r0, #0x0087/n" /* .... .... 1... .111 *//* Turn on what we want */109/* Fault checking enabled */"orr r0, r0, #0x0002/n" /* .... .... .... ..1. */#ifdef CONFIG_CPU_D_CACHE_ON"orr r0, r0, #0x0004/n" /* .... .... .... .1.. */#endif#ifdef CONFIG_CPU_I_CACHE_ON"orr r0, r0, #0x1000/n" /* ...1 .... .... .... */#endif/* MMU enabled */"orr r0, r0, #0x0001/n" /* .... .... .... ...1 */"mcr p15, 0, r0, c1, c0, 0/n" /* write control register */: /* no outputs */: "r" (ttb) );}STEP4 設置堆棧；STEP5 進行 mtd 設備的初始化，記錄 MTD 分區(qū)信息；STEP6 設置私有數(shù)據(jù)；STEP7 初始化內(nèi)建命令。STEP8 啟動一個 SHELL，等待用戶輸出命令并進行相應處理。在 SHELL 退出的情況下，啟動操作系統(tǒng)：#define DEFAULT_BOOT_DELAY 0x30000000void boot_or_vivi(void){char c;int ret;ulong boot_delay;boot_delay = get_param_value("boot_delay", &ret);if (ret) boot_delay = DEFAULT_BOOT_DELAY;/* If a value of boot_delay is zero,* unconditionally call vivi shell */if (boot_delay == 0) vivi_shell();/** wait for a keystroke (or a button press if you want.)*/printk("Press Return to start the LINUX now, any other key for vivi/n");c = awaitkey(boot_delay, NULL);if (((c != '/r') && (c != '/n') && (c != '/0'))) {printk("type /"help/" for help./n");vivi_shell();}run_autoboot();return;}SHELL 中讀取用戶從串口輸出的命令字符串，執(zhí)行該命令：voidvivi_shell(void)110{#ifdef CONFIG_SERIAL_TERMserial_term();#else#error there is no terminal.#endif}void serial_term(void){char cmd_buf[MAX_CMDBUF_SIZE]；for (;;) {printk("%s> ", prompt);getcmd(cmd_buf, MAX_CMDBUF_SIZE);/* execute a user command */if (cmd_buf[0])exec_string(cmd_buf);}}5.電路板調(diào)試在電路板的調(diào)試過程中，我們首先要在 ADT 新建的工程中添加第一階段的匯編代碼 head.S 文件，修改 Link 腳本，將代碼和數(shù)據(jù)映射到 S3C2410A 自帶的 0x40000000 開始的 4KB 內(nèi)存空間內(nèi)：SECTIONS{. = 0x40000000;.text : { *(.text) }Image_RO_Limit = .;Image_RW_Base = .;.data : { *(.data) }.rodata : { *(.rodata) }Image_ZI_Base = .;.bss : { *(.bss) }Image_ZI_Limit = .;__bss_start__ = .;__bss_end__ = .;__EH_FRAME_BEGIN__ = .;__EH_FRAME_END__ = .;PROVIDE (__stack = .);end = .;_end = .;.debug_info 0 : { *(.debug_info) }.debug_line 0 : { *(.debug_line) }.debug_abbrev 0 : { *(.debug_abbrev)}.debug_frame 0 : { *(.debug_frame) }111}借助萬用表、示波器等儀器儀表，調(diào)通 SDRAM，并將 vivi 中自帶的串口、NAND FLASH 驅(qū)動添加到工程中，調(diào)試通過板上的串口和 FLASH。如果板電路的原理與三星公司 DEMO 板有差距，則 vivi 中硬件的操作要進行相應的修改。全部調(diào)試通過后，修改 vivi 源代碼，重新編譯 vivi，將其燒錄入 NAND FLASH 就可以在復位后啟動這個 Bootloader 了。調(diào)試板上的新增硬件時，宜在 ADT 中添加相應的代碼，在不加載操作系統(tǒng)的情況下，單純地操作這些硬件。如果電路板設計有誤，要進行飛線和割線等處理。6.小結(jié)本章講解了 ARM 匯編、Bootloader 的功能，Bootloader 的調(diào)試環(huán)境及 ARM 電路板的調(diào)試方法。基于 ARM 的嵌入式 Linux 移植真實體驗（ 3）――操作系統(tǒng)宋寶華 21cnbao@21cn.com出處:dev.yesky.com在筆者撰寫的《 C語言嵌入式系統(tǒng)編程修煉之道》一文中，主要陳訴的軟件架構是單任務無操作系統(tǒng)平臺的，而本文的側(cè)重點則在于講述操作系統(tǒng)嵌入的軟件架構，二者的區(qū)別如下圖：嵌入式操作系統(tǒng)并不總是必須的，因為程序完全可以在裸板上運行。盡管如此，但對于復雜的系統(tǒng)，為使其具有任務管理、定時器管理、存儲器管理、資源管理、事件管理、系統(tǒng)管理、消息管理、隊列管理和中斷處理的能力，提供多任務處理，更好的分配系統(tǒng)資源的功能，很有必要針對特定的硬件平臺和實際應用移植操作系統(tǒng)。鑒于 Linux 的源代碼開放性，它成為嵌入式操作系統(tǒng)領域的很好選擇。國內(nèi)外許多知名大學、公司、研究機構都加入了嵌入式 Linux 的研究行列，推出了一些著名的版本：? RT-Linux 提供了一個精巧的實時內(nèi)核，把標準的Linux 核心作為實時核心的一個進程同用戶的實時進程一起調(diào)度。 RT-Linux 已成功地應用于航天飛機的空間數(shù)據(jù)采集、科學儀器測控和電影特技圖像處理等廣泛的應用領域。如 NASA(美國國家宇航局)將裝有RT-Linux 的設備放在飛機上，以測量Georage 咫風的風速；? uCLinux（Micro-Control-Linux，u 表示Micro，C 表示Control）去掉了MMU（內(nèi)存管理）功能，應用于沒有虛擬內(nèi)存管理的微處理器/微控制器，它已經(jīng)被成功地移植到了很多平臺上。本章涉及的 mizi-linux 由韓國mizi 公司根據(jù)Linux 2.4 內(nèi)核移植而來，支持S3C2410A 處理器。1.Linux內(nèi)核要點和其他操作系統(tǒng)一樣， Linux包含進程調(diào)度與進程間通信(IPC)、內(nèi)存管理(MMU)、虛擬文件系統(tǒng)(VFS)、網(wǎng)絡接口等，下圖給出了 Linux 的組成及其關系：112Linux 內(nèi)核源代碼包括多個目錄：（ 1）arch：包括硬件特定的內(nèi)核代碼，如arm、mips、i386 等；（ 2）drivers：包含硬件驅(qū)動代碼，如char、cdrom、scsi、mtd 等；（ 3）include：通用頭文件及針對不同平臺特定的頭文件，如asm-i386、asm-arm 等；（ 4）init：內(nèi)核初始化代碼；（ 5）ipc：進程間通信代碼；（ 6）kernel：內(nèi)核核心代碼；（ 7）mm：內(nèi)存管理代碼；（ 8）net：與網(wǎng)絡協(xié)議棧相關的代碼，如ipv4、ipv6、ethernet 等；（ 9）fs：文件系統(tǒng)相關代碼，如nfs、vfat 等；（ 10）lib：庫文件，與平臺無關的strlen、strcpy 等，如在string.c 中包含：char * strcpy(char * dest,const char *src){char *tmp = dest;while ((*dest++ = *src++) != '/0')/* nothing */;return tmp;}（ 11）Documentation：文檔。在 Linux 內(nèi)核的實現(xiàn)中，有一些數(shù)據(jù)結(jié)構使用非常頻繁，對研讀內(nèi)核的人來說至為關鍵，它們是：1.task_structLinux 內(nèi)核利用task_struct 數(shù)據(jù)結(jié)構代表一個進程，用task_struct 指針形成一個task 數(shù)組。當建立新進程的時候， Linux 為新的進程分配一個task_struct 結(jié)構，然后將指針保存在task 數(shù)組中。調(diào)度程序維護current 指針，它指向當前正在運行的進程。2.mm_struct每個進程的虛擬內(nèi)存由 mm_struct結(jié)構代表。該結(jié)構中包含了一組指向 vm-area_struct結(jié)構的指針，vm-area_struct 結(jié)構描述了虛擬內(nèi)存的一個區(qū)域。3.inodeLinux 虛擬文件系統(tǒng)中的文件、目錄等均由對應的索引節(jié)點(inode)代表。2.Linux移植項目mizi-linux 已經(jīng)根據(jù)Linux 2.4 內(nèi)核針對S3C2410A 這一芯片進行了有針對性的移植工作，包括：（ 1）修改根目錄下的Makefile 文件113a.指定目標平臺為ARM：#ARCH := $(shell uname -m | sed -e s/i.86/i386/ -e s/sun4u/sparc64/ -e s/arm.*/arm/ -es/sa110/arm/)ARCH := armb.指定交叉編譯器：CROSS_COMPILE = arm-linux-（ 2）修改arch 目錄中的文件根據(jù)本章第一節(jié)可知， Linux 的arch 目錄存放硬件相關的內(nèi)核代碼，因此，在Linux 內(nèi)核中增加對S3C2410的支持，最主要就是要修改 arch目錄中的文件。a.在arch/arm/Makefile 文件中加入：ifeq ($(CONFIG_ARCH_S3C2410),y)TEXTADDR = 0xC0008000MACHINE = s3c2410Endifb.在 arch/arm/config.in文件中加入：if [ "$CONFIG_ARCH_S3C2410" = "y" ]; thencomment 'S3C2410 Implementation'dep_bool ' SMDK (MERI TECH BOARD)' CONFIG_S3C2410_SMDK $CONFIG_ARCH_S3C2410dep_bool ' change AIJI' CONFIG_SMDK_AIJIdep_tristate 'S3C2410 USB function support' CONFIG_S3C2410_USB $CONFIG_ARCH_S3C2100dep_tristate ' Support for S3C2410 USB character device emulation'CONFIG_S3C2410_USB_CHAR $CONFIG_S3C2410_USBfi # /* CONFIG_ARCH_S3C2410 */arch/arm/config.in 文件還有幾處針對S3C2410 的修改。c.在arch/arm/boot/Makefile 文件中加入：ifeq ($(CONFIG_ARCH_S3C2410),y)ZTEXTADDR = 0x30008000ZRELADDR = 0x30008000endifd.在 linux/arch/arm/boot/compressed/Makefile文件中加入：ifeq ($(CONFIG_ARCH_S3C2410),y)OBJS += head-s3c2410.oendif加入的結(jié)果是 head-s3c2410.S文件被編譯為 head-s3c2410.o。e.加入arch/arm/boot/compressed/ head-s3c2410.S 文件#include <linux/config.h>#include <linux/linkage.h>#include <asm/mach-types.h>.section ".start", #alloc, #execinstr__S3C2410_start:@ Preserve r8/r7 i.e. kernel entry values114@ What is it?@ Nandy@ Data cache, Intstruction cache, MMU might be active.@ Be sure to flush kernel binary out of the cache,@ whatever state it is, before it is turned off.@ This is done by fetching through currently executed@ memory to be sure we hit the same cachebic r2, pc, #0x1fadd r3, r2, #0x4000 @ 16 kb is quite enough...1: ldr r0, [r2], #32teq r2, r3bne 1bmcr p15, 0, r0, c7, c10, 4 @ drain WBmcr p15, 0, r0, c7, c7, 0 @ flush I & D caches#if 0@ disabling MMU and cachesmrc p15, 0, r0, c1, c0, 0 @ read control registerbic r0, r0, #0x05 @ disable D cache and MMUbic r0, r0, #1000 @ disable I cachemcr p15, 0, r0, c1, c0, 0#endif/** Pause for a short time so that we give enough time* for the host to start a terminal up.*/mov r0, #0x002000001: subs r0, r0, #1bne 1b該文件中的匯編代碼完成 S3C2410特定硬件相關的初始化。f.在arch/arm/def-configs 目錄中增加配置文件g.在arch/arm/kernel/Makefile 中增加對S3C2410 的支持no-irq-arch := $(CONFIG_ARCH_INTEGRATOR) $(CONFIG_ARCH_CLPS711X) /$(CONFIG_FOOTBRIDGE) $(CONFIG_ARCH_EBSA110) /$(CONFIG_ARCH_SA1100) $(CONFIG_ARCH_CAMELOT) /$(CONFIG_ARCH_S3C2400) $(CONFIG_ARCH_S3C2410) /$(CONFIG_ARCH_MX1ADS) $(CONFIG_ARCH_PXA)obj-$(CONFIG_MIZI) += event.oobj-$(CONFIG_APM) += apm2.oh.修改 arch/arm/kernel/debug-armv.S文件，在適當?shù)奈恢迷黾尤缦玛P于 S3C2410的代碼：#elif defined(CONFIG_ARCH_S3C2410)115.macro addruart,rxmrc p15, 0, /rx, c1, c0tst /rx, #1 @ MMU enabled ?moveq /rx, #0x50000000 @ physical base addressmovne /rx, #0xf0000000 @ virtual address.endm.macro senduart,rd,rxstr /rd, [/rx, #0x20] @ UTXH.endm.macro waituart,rd,rx.endm.macro busyuart,rd,rx1001: ldr /rd, [/rx, #0x10] @ read UTRSTATtst /rd, #1 << 2 @ TX_EMPTY ?beq 1001b.endmi.修改 arch/arm/kernel/setup.c文件此文件中的 setup_arch 非常關鍵，用來完成與體系結(jié)構相關的初始化：void __init setup_arch(char **cmdline_p){struct tag *tags = NULL;struct machine_desc *mdesc;char *from = default_command_line;ROOT_DEV = MKDEV(0, 255);setup_processor();mdesc = setup_machine(machine_arch_type);machine_name = mdesc->name;if (mdesc->soft_reboot)reboot_setup("s");if (mdesc->param_offset)tags = phys_to_virt(mdesc->param_offset);/** Do the machine-specific fixups before we parse the* parameters or tags.*/116if (mdesc->fixup)mdesc->fixup(mdesc, (struct param_struct *)tags,&from, &meminfo);/** If we have the old style parameters, convert them to* a tag list before.*/if (tags && tags->hdr.tag != ATAG_CORE)convert_to_tag_list((struct param_struct *)tags,meminfo.nr_banks == 0);if (tags && tags->hdr.tag == ATAG_CORE)parse_tags(tags);if (meminfo.nr_banks == 0) {meminfo.nr_banks = 1;meminfo.bank[0].start = PHYS_OFFSET;meminfo.bank[0].size = MEM_SIZE;}init_mm.start_code = (unsigned long) &_text;init_mm.end_code = (unsigned long) &_etext;init_mm.end_data = (unsigned long) &_edata;init_mm.brk = (unsigned long) &_end;memcpy(saved_command_line, from, COMMAND_LINE_SIZE);saved_command_line[COMMAND_LINE_SIZE-1] = '/0';parse_cmdline(&meminfo, cmdline_p, from);bootmem_init(&meminfo);paging_init(&meminfo, mdesc);request_standard_resources(&meminfo, mdesc);/** Set up various architecture-specific pointers*/init_arch_irq = mdesc->init_irq;#ifdef CONFIG_VT#if defined(CONFIG_VGA_CONSOLE)conswitchp = &vga_con;#elif defined(CONFIG_DUMMY_CONSOLE)conswitchp = &dummy_con;#endif117#endif}j.修改 arch/arm/mm/mm-armv.c文件（ arch/arm/mm/目錄中的文件完成與ARM 相關的MMU 處理）修改init_maps->bufferable = 0;為init_maps->bufferable = 1;要輕而易舉地進行上述馬拉松式的內(nèi)核移植工作并非一件輕松的事情，需要對Linux 內(nèi)核有很好的掌握，同時掌握硬件特定的知識和相關的匯編。幸而 mizi 公司的開發(fā)者們已經(jīng)合力為我們完成了上述工作，這使得小弟們在將 mizi-linux 移植到自身開發(fā)的電路板的過程中只需要關心如下幾點：（ 1）內(nèi)核初始化：Linux 內(nèi)核的入口點是start_kernel()函數(shù)。它初始化內(nèi)核的其他部分，包括捕獲，IRQ通道，調(diào)度，設備驅(qū)動，標定延遲循環(huán)，最重要的是能夠 fork“init”進程，以啟動整個多任務環(huán)境。我們可以在 init 中加上一些特定的內(nèi)容。(2)設備驅(qū)動：設備驅(qū)動占據(jù)了Linux 內(nèi)核很大部分。同其他操作系統(tǒng)一樣，設備驅(qū)動為它們所控制的硬件設備和操作系統(tǒng)提供接口。本文第四章將單獨講解驅(qū)動程序的編寫方法。(3)文件系統(tǒng)：Linux 最重要的特性之一就是對多種文件系統(tǒng)的支持。這種特性使得Linux 很容易地同其他操作系統(tǒng)共存。文件系統(tǒng)的概念使得用戶能夠查看存儲設備上的文件和路徑而無須考慮實際物理設備的文件系統(tǒng)類型。 Linux 透明的支持許多不同的文件系統(tǒng)，將各種安裝的文件和文件系統(tǒng)以一個完整的虛擬文件系統(tǒng)的形式呈現(xiàn)給用戶。我們可以在 K9S1208 NAND FLASH 上移植cramfs、jfss2、yaffs 等FLASH 文件系統(tǒng)。3. init進程在 init函數(shù)中“加料”，可以使得Linux 啟動的時候做點什么，例如廣州友善之臂公司的demo 板在其中加入了公司信息：static int init(void * unused){lock_kernel();do_basic_setup();prepare_namespace();/** Ok, we have completed the initial bootup, and* we're essentially up and running. Get rid of the* initmem segments and start the user-mode stuff..*/free_initmem();unlock_kernel();if (open("/dev/console", O_RDWR, 0) < 0)printk("Warning: unable to open an initial console./n");(void) dup(0);118(void) dup(0);/** We try each of these until one succeeds.** The Bourne shell can be used instead of init if we are* trying to recover a really broken machine.*/printk("========================================/n");printk("= Friendly-ARM Tech. Ltd. =/n");printk("= http://www.arm9.net =/n");printk("= http://www.arm9.com.cn =/n");printk("========================================/n");if (execute_command)execve(execute_command,argv_init,envp_init);execve("/sbin/init",argv_init,envp_init);execve("/etc/init",argv_init,envp_init);execve("/bin/init",argv_init,envp_init);execve("/bin/sh",argv_init,envp_init);panic("No init found. Try passing init= option to kernel.");}這樣在 Linux的啟動過程中，會額外地輸出：========================================= Friendly-ARM Tech. Ltd. == http://www.arm9.net == http://www.arm9.com.cn =========================================4.文件系統(tǒng)移植文件系統(tǒng)是基于被劃分的存儲設備上的邏輯上單位上的一種定義文件的命名、存儲、組織及取出的方法。如果一個 Linux 沒有根文件系統(tǒng)，它是不能被正確的啟動的。因此，我們需要為Linux 創(chuàng)建根文件系統(tǒng)，我們將其創(chuàng)建在 K9S1208 NAND FLASH 上。Linux 的根文件系統(tǒng)可能包括如下目錄（或更多的目錄）：（ 1）/bin (binary)：包含著所有的標準命令和應用程序；（ 2）/dev (device)：包含外設的文件接口，在Linux 下，文件和設備采用同種地方法訪問的，系統(tǒng)上的每個設備都在/dev 里有一個對應的設備文件；（ 3）/etc (etcetera)：這個目錄包含著系統(tǒng)設置文件和其他的系統(tǒng)文件，例如/etc/fstab(file system table)記錄了啟動時要 mount的 filesystem；（ 4）/home：存放用戶主目錄；（ 5）/lib(library)：存放系統(tǒng)最基本的庫文件；（ 6）/mnt：用戶臨時掛載文件系統(tǒng)的地方；（ 7）/proc：linux 提供的一個虛擬系統(tǒng)，系統(tǒng)啟動時在內(nèi)存中產(chǎn)生，用戶可以直接通過訪問這些文件來獲得119系統(tǒng)信息；（ 8）/root：超級用戶主目錄；（ 9）/sbin：這個目錄存放著系統(tǒng)管理程序，如fsck、mount 等；（ 10）/tmp(temporary)：存放不同的程序執(zhí)行時產(chǎn)生的臨時文件；（ 11）/usr(user)：存放用戶應用程序和文件。采用 BusyBox 是縮小根文件系統(tǒng)的好辦法，因為其中提供了系統(tǒng)的許多基本指令但是其體積很小。眾所周知，瑞士軍刀以其小巧輕便、功能眾多而聞名世界，成為各國軍人的必備工具，并廣泛應用于民間，而 BusyBox也被稱為嵌入式 Linux領域的“瑞士軍刀”。此地址可以下載 BusyBox：http://www.busybox.net，當前最新版本為1.1.3。編譯好busybox 后，將其放入/bin 目錄，若要使用其中的命令，只需要建立link，如：ln -s ./busybox lsln -s ./busybox mkdir4.1 cramfs在根文件系統(tǒng)中，為保護系統(tǒng)的基本設置不被更改，可以采用cramfs 格式，它是一種只讀的閃存文件系統(tǒng)。制作cramfs 文件系統(tǒng)的方法為：建立一個目錄，將需要放到文件系統(tǒng)的文件copy到這個目錄，運行“mkcramfs目錄名 image名”就可以生成一個cramfs 文件系統(tǒng)的image 文件。例如如果目錄名為rootfs，則正確的命令為：mkcramfs rootfs rootfs.ramfs我們使用下面的命令可以 mount生成的 rootfs.ramfs文件，并查看其中的內(nèi)容：mount -o loop -t cramfs rootfs.ramfs /mount/point此地址可以下載 mkcramfs工具： http://sourceforge.net/projects/cramfs/。4.2 jfss2對于 cramfs閃存文件系統(tǒng)，如果沒有 ramfs的支持則只能讀，而采用 jfss2（The Journalling Flash FileSystem version 2）文件系統(tǒng)則可以直接在閃存中讀、寫數(shù)據(jù)。jfss2 是一個日志結(jié)構(log-structured)的文件系統(tǒng)，包含數(shù)據(jù)和原數(shù)據(jù)(meta-data)的節(jié)點在閃存上順序地存儲。jfss2 記錄了每個擦寫塊的擦寫次數(shù)，當閃存上各個擦寫塊的擦寫次數(shù)的差距超過某個預定的閥值，開始進行磨損平衡的調(diào)整。調(diào)整的策略是，在垃圾回收時將擦寫次數(shù)小的擦寫塊上的數(shù)據(jù)遷移到擦寫次數(shù)大的擦寫塊上以達到磨損平衡的目的。與 mkcramfs 類似，同樣有一個mkfs.jffs2 工具可以將一個目錄制作為jffs2 文件系統(tǒng)。假設把/bin目錄制作為 jffs2 文件系統(tǒng)，需要運行的命令為：mkfs.jffs2 -d /bin -o jffs2.img4.3 yaffsyaffs 是一種專門為嵌入式系統(tǒng)中常用的閃存設備設計的一種可讀寫的文件系統(tǒng)，它比jffs2 文件系統(tǒng)具有更快的啟動速度，對閃存使用壽命有更好的保護機制。為使 Linux 支持yaffs 文件系統(tǒng)，我們需要將其對應的驅(qū)動加入到內(nèi)核中 fs/yaffs/，并修改內(nèi)核配置文件。使用我們使用mkyaffs 工具可以將NAND FLASH 中的分區(qū)格式化為 yaffs 格式（如/bin/mkyaffs /dev/mtdblock/0命令可以將第 1個 MTD塊設備分區(qū)格式化為yaffs），而使用mkyaffsimage（類似于mkcramfs、mkfs.jffs2）則可以將某目錄生成為yaffs 文件系統(tǒng)鏡像。嵌入式 Linux 還可以使用NFS（網(wǎng)絡文件系統(tǒng)）通過以太網(wǎng)掛接根文件系統(tǒng)，這是一種經(jīng)常用來作為調(diào)試使用的文件系統(tǒng)啟動方式。通過網(wǎng)絡掛接的根文件系統(tǒng)，可以在主機上生成 ARM 交叉編譯版本的目標文件或二進制可執(zhí)行文件，然后就可以直接裝載或執(zhí)行它，而不用頻繁地寫入 flash。采用不同的文件系統(tǒng)啟動時，要注意通過第二章介紹的 BootLoader 修改啟動參數(shù)，如廣州友善之臂的demo提供如下三種啟動方式：（ 1）從cramfs 掛接根文件系統(tǒng)：root=/dev/bon/2()；（ 2）從移植的yaffs 掛接根文件系統(tǒng)：root=/dev/mtdblock/0；120（ 3）從以太網(wǎng)掛接根文件系統(tǒng)：root=/dev/nfs。5.小結(jié)本章介紹了嵌入式 Linux的背景、移植項目、 init進程修改和文件系統(tǒng)移植，通過這些步驟，我們可以在嵌入式系統(tǒng)上啟動一個基本的 Linux。基于 ARM 的嵌入式 Linux 移植真實體驗（4）――設備驅(qū)動宋寶華 21cnbao@21cn.com出處:dev.yesky.com設備驅(qū)動程序是操作系統(tǒng)內(nèi)核和機器硬件之間的接口，它為應用程序屏蔽硬件的細節(jié)，一般來說，Linux 的設備驅(qū)動程序需要完成如下功能：? 設備初始化、釋放；? 提供各類設備服務；? 負責內(nèi)核和設備之間的數(shù)據(jù)交換；? 檢測和處理設備工作過程中出現(xiàn)的錯誤。Linux 下的設備驅(qū)動程序被組織為一組完成不同任務的函數(shù)的集合，通過這些函數(shù)使得Linux 的設備操作猶如文件一般。在應用程序看來，硬件設備只是一個設備文件，應用程序可以象操作普通文件一樣對硬件設備進行操作，如 open ()、close ()、read ()、write () 等。Linux 主要將設備分為二類：字符設備和塊設備。字符設備是指設備發(fā)送和接收數(shù)據(jù)以字符的形式進行；而塊設備則以整個數(shù)據(jù)緩沖區(qū)的形式進行。在對字符設備發(fā)出讀/寫請求時，實際的硬件I/O 一般就緊接著發(fā)生了；而塊設備則不然，它利用一塊系統(tǒng)內(nèi)存作緩沖區(qū)，當用戶進程對設備請求能滿足用戶的要求，就返回請求的數(shù)據(jù)，如果不能，就調(diào)用請求函數(shù)來進行實際的 I/O 操作。塊設備主要針對磁盤等慢速設備。1.內(nèi)存分配由于Linux驅(qū)動程序在內(nèi)核中運行，因此在設備驅(qū)動程序需要申請/釋放內(nèi)存時，不能使用用戶級的malloc/free函數(shù)，而需由內(nèi)核級的函數(shù) kmalloc/kfree ()來實現(xiàn)， kmalloc()函數(shù)的原型為：void kmalloc (size_t size ,int priority);參數(shù) size為申請分配內(nèi)存的字節(jié)數(shù)， kmalloc最多只能開辟 128k的內(nèi)存；參數(shù) priority說明若 kmalloc()不能馬上分配內(nèi)存時用戶進程要采用的動作： GFP_KERNEL 表示等待，即等kmalloc()函數(shù)將一些內(nèi)存安排到交換區(qū)來滿足你的內(nèi)存需要， GFP_ATOMIC 表示不等待，如不能立即分配到內(nèi)存則返回0 值；函數(shù)的返回值指向已分配內(nèi)存的起始地址，出錯時，返回 0。kmalloc ()分配的內(nèi)存需用kfree()函數(shù)來釋放，kfree ()被定義為：# define kfree (n) kfree_s( (n) ,0)其中 kfree_s ()函數(shù)原型為：void kfree_s (void * ptr ,int size);參數(shù) ptr為 kmalloc()返回的已分配內(nèi)存的指針，size 是要釋放內(nèi)存的字節(jié)數(shù)，若為0 時，由內(nèi)核自動確定內(nèi)存的大小。2.中斷許多設備涉及到中斷操作，因此，在這樣的設備的驅(qū)動程序中需要對硬件產(chǎn)生的中斷請求提供中斷服務程序。與注冊基本入口點一樣，驅(qū)動程序也要請求內(nèi)核將特定的中斷請求和中斷服務程序聯(lián)系在一起。在 Linux中，用 request_irq()函數(shù)來實現(xiàn)請求：121int request_irq (unsigned int irq ,void( * handler) int ,unsigned long type ,char * name);參數(shù) irq為要中斷請求號，參數(shù) handler為指向中斷服務程序的指針，參數(shù) type用來確定是正常中斷還是快速中斷（正常中斷指中斷服務子程序返回后，內(nèi)核可以執(zhí)行調(diào)度程序來確定將運行哪一個進程；而快速中斷是指中斷服務子程序返回后，立即執(zhí)行被中斷程序，正常中斷 type 取值為0 ，快速中斷type 取值為SA_INTERRUPT），參數(shù)name 是設備驅(qū)動程序的名稱。3.字符設備驅(qū)動我們必須為字符設備提供一個初始化函數(shù) ，該函數(shù) 用來完成對所控設備的初始化工作，并調(diào) 用register_chrdev() 函數(shù)注冊字符設備。假設有一字符設備“exampledev”，則其init 函數(shù)為：void exampledev_init(void){if (register_chrdev(MAJOR_NUM, " exampledev ", &exampledev_fops))TRACE_TXT("Device exampledev driver registered error");elseTRACE_TXT("Device exampledev driver registered successfully");…//設備初始化}其中， register_chrdev函數(shù) 中的參數(shù) MAJOR_NUM為主設備號 ,“exampledev”為設備名，exampledev_fops 為包含基本函數(shù)入口點的結(jié)構體，類型為file_operations。當執(zhí)行exampledev_init 時，它將調(diào)用內(nèi)核函數(shù) register_chrdev，把驅(qū)動程序的基本入口點指針存放在內(nèi)核的字符設備地址表中，在用戶進程對該設備執(zhí)行系統(tǒng)調(diào)用時提供入口地址。隨著內(nèi)核功能的加強， file_operations 結(jié)構體也變得更加龐大。但是大多數(shù)的驅(qū)動程序只是利用了其中的一部分，對于驅(qū)動程序中無需提供的功能，只需要把相應位置的值設為 NULL。對于字符設備來說，要提供的主要入口有： open ()、release ()、read ()、write ()、ioctl ()等。open()函數(shù) 對設備特殊文件進行open()系統(tǒng)調(diào)用時，將調(diào)用驅(qū)動程序的open () 函數(shù)：int (*open)(struct inode * inode,struct file *filp);其中參數(shù) inode為設備特殊文件的 inode (索引結(jié)點)結(jié)構的指針，參數(shù) filp是指向這一設備的文件結(jié)構的指針。 open()的主要任務是確定硬件處在就緒狀態(tài)、驗證次設備號的合法性(次設備號可以用MINOR(inode->i_rdev) 取得)、控制使用設備的進程數(shù)、根據(jù)執(zhí)行情況返回狀態(tài)碼(0表示成功，負數(shù)表示存在錯誤)等；release()函數(shù) 當最后一個打開設備的用戶進程執(zhí)行close ()系統(tǒng)調(diào)用時，內(nèi)核將調(diào)用驅(qū)動程序的release ()函數(shù)：void (*release) (struct inode * inode,struct file *filp) ;release 函數(shù)的主要任務是清理未結(jié)束的輸入/輸出操作、釋放資源、用戶自定義排他標志的復位等。read()函數(shù) 當對設備特殊文件進行read() 系統(tǒng)調(diào)用時，將調(diào)用驅(qū)動程序read() 函數(shù)：ssize_t (*read) (struct file * filp, char * buf, size_t count, loff_t * offp);參數(shù) buf是指向用戶空間緩沖區(qū)的指針，由用戶進程給出， count 為用戶進程要求讀取的字節(jié)數(shù)，也由用戶給出。read() 函數(shù)的功能就是從硬設備或內(nèi)核內(nèi)存中讀取或復制count 個字節(jié)到buf 指定的緩沖區(qū)中。在復制數(shù)據(jù)時要注意，驅(qū)動程序運行在內(nèi)核中，而 buf 指定的緩沖區(qū)在用戶內(nèi)存區(qū)中，是不能直接在內(nèi)核中訪問使用的，因此，必須使用特殊的復制函數(shù)來完成復制工作，這些函數(shù)在 include/asm/uaccess.h中被聲明：unsigned long copy_to_user (void * to, void * from, unsigned long len);此外， put_user()函數(shù)用于內(nèi)核空間和用戶空間的單值交互（如char、int、long）。write( )函數(shù) 當設備特殊文件進行 write ()系統(tǒng)調(diào)用時，將調(diào)用驅(qū)動程序的 write ()函數(shù)：ssize_t (*write) (struct file *, const char *, size_t, loff_t *);122write ()的功能是將參數(shù)buf 指定的緩沖區(qū)中的count 個字節(jié)內(nèi)容復制到硬件或內(nèi)核內(nèi)存中，和read() 一樣，復制工作也需要由特殊函數(shù)來完成：unsigned long copy_from_user(void *to, const void *from, unsigned long n);此外， get_user()函數(shù)用于內(nèi)核空間和用戶空間的單值交互（如char、int、long）。ioctl()函數(shù) 該函數(shù)是特殊的控制函數(shù)，可以通過它向設備傳遞控制信息或從設備取得狀態(tài)信息，函數(shù)原型為：int (*ioctl) (struct inode * inode,struct file * filp,unsigned int cmd,unsigned long arg);參數(shù) cmd為設備驅(qū)動程序要執(zhí)行的命令的代碼，由用戶自定義，參數(shù)arg 為相應的命令提供參數(shù)，類型可以是整型、指針等。同樣，在驅(qū)動程序中，這些函數(shù)的定義也必須符合命名規(guī)則，按照本文約定，設備“exampledev”的驅(qū)動程序的這些函數(shù) 應分別命名為 exampledev_open 、exampledev_ release 、exampledev_read 、exampledev_write 、exampledev_ioctl ，因此設備“exampledev” 的基本入口點結(jié) 構變量exampledev_fops 賦值如下（對較早版本的內(nèi)核）：struct file_operations exampledev_fops {NULL ,exampledev_read ,exampledev_write ,NULL ,NULL ,exampledev_ioctl ,NULL ,exampledev_open ,exampledev_release ,NULL ,NULL ,NULL ,NULL} ;就目前而言，由于 file_operations結(jié)構體已經(jīng)很龐大，我們更適合用 GNU擴展的 C語法來初始化exampledev_fops：struct file_operations exampledev_fops = {read: exampledev _read,write: exampledev _write,ioctl: exampledev_ioctl ,open: exampledev_open ,release : exampledev_release ,};看看第一章電路板硬件原理圖，板上包含四個用戶可編程的發(fā)光二極管（LED），這些LED 連接在ARM 處理器的可編程 I/O 口（GPIO）上，現(xiàn)在來編寫這些LED 的驅(qū)動：#include <linux/config.h>#include <linux/kernel.h>#include <linux/init.h>#include <linux/miscdevice.h>#include <linux/sched.h>123#include <linux/delay.h>#include <asm/hardware.h>#define DEVICE_NAME "leds" /*定義led 設備的名字*/#define LED_MAJOR 231 /*定義led 設備的主設備號*/static unsigned long led_table[] ={/*I/O 方式 led設備對應的硬件資源*/GPIO_B10, GPIO_B8, GPIO_B5, GPIO_B6,};/*使用 ioctl控制 led*/static int leds_ioctl(struct inode *inode, struct file *file, unsigned int cmd,unsigned long arg){switch (cmd){case 0:case 1:if (arg > 4){return -EINVAL;}write_gpio_bit(led_table[arg], !cmd);default:return -EINVAL;}}static struct file_operations leds_fops ={owner: THIS_MODULE, ioctl: leds_ioctl,};static devfs_handle_t devfs_handle;static int __init leds_init(void){int ret;int i;/*在內(nèi)核中注冊設備*/ret = register_chrdev(LED_MAJOR, DEVICE_NAME, &leds_fops);if (ret < 0){printk(DEVICE_NAME " can't register major number/n");return ret;}devfs_handle = devfs_register(NULL, DEVICE_NAME, DEVFS_FL_DEFAULT, LED_MAJOR,1240, S_IFCHR | S_IRUSR | S_IWUSR, &leds_fops, NULL);/*使用宏進行端口初始化， set_gpio_ctrl和 write_gpio_bit均為宏定義*/for (i = 0; i < 8; i++){set_gpio_ctrl(led_table[i] | GPIO_PULLUP_EN | GPIO_MODE_OUT);write_gpio_bit(led_table[i], 1);}printk(DEVICE_NAME " initialized/n");return 0;}static void __exit leds_exit(void){devfs_unregister(devfs_handle);unregister_chrdev(LED_MAJOR, DEVICE_NAME);}module_init(leds_init);module_exit(leds_exit);使用命令方式編譯 led驅(qū)動模塊：#arm-linux-gcc -D__KERNEL__ -I/arm/kernel/include-DKBUILD_BASENAME=leds -DMODULE -c -o leds.o leds.c以上命令將生成 leds.o文件，把該文件復制到板子的/lib目錄下，使用以下命令就可以安裝 leds驅(qū)動模塊：#insmod /lib/ leds.o刪除該模塊的命令是：#rmmod leds4.塊設備驅(qū)動塊設備驅(qū)動程序的編寫是一個浩繁的工程，其難度遠超過字符設備，上千行的代碼往往只能搞定一個簡單的塊設備，而數(shù)十行代碼就可能搞定一個字符設備。因此，非得有相當?shù)幕竟Σ拍芡瓿纱隧椆ぷ鳌Ｏ旅嫦冉o出一個實例，即 mtdblock 塊設備的驅(qū)動。我們通過分析此實例中的代碼來說明塊設備驅(qū)動程序的寫法（由于篇幅的關系，大量的代碼被省略，只保留了必要的主干）：#include <linux/config.h>#include <linux/devfs_fs_kernel.h>static void mtd_notify_add(struct mtd_info* mtd);static void mtd_notify_remove(struct mtd_info* mtd);static struct mtd_notifier notifier = {mtd_notify_add,mtd_notify_remove,NULL};static devfs_handle_t devfs_dir_handle = NULL;static devfs_handle_t devfs_rw_handle[MAX_MTD_DEVICES];125static struct mtdblk_dev {struct mtd_info *mtd; /* Locked */int count;struct semaphore cache_sem;unsigned char *cache_data;unsigned long cache_offset;unsigned int cache_size;enum { STATE_EMPTY, STATE_CLEAN, STATE_DIRTY } cache_state;} *mtdblks[MAX_MTD_DEVICES];static spinlock_t mtdblks_lock;/* this lock is used just in kernels >= 2.5.x */static spinlock_t mtdblock_lock;static int mtd_sizes[MAX_MTD_DEVICES];static int mtd_blksizes[MAX_MTD_DEVICES];static void erase_callback(struct erase_info *done){wait_queue_head_t *wait_q = (wait_queue_head_t *)done->priv;wake_up(wait_q);}static int erase_write (struct mtd_info *mtd, unsigned long pos,int len, const char *buf){struct erase_info erase;DECLARE_WAITQUEUE(wait, current);wait_queue_head_t wait_q;size_t retlen;int ret;/** First, let's erase the flash block.*/init_waitqueue_head(&wait_q);erase.mtd = mtd;erase.callback = erase_callback;erase.addr = pos;erase.len = len;erase.priv = (u_long)&wait_q;set_current_state(TASK_INTERRUPTIBLE);126add_wait_queue(&wait_q, &wait);ret = MTD_ERASE(mtd, &erase);if (ret) {set_current_state(TASK_RUNNING);remove_wait_queue(&wait_q, &wait);printk (KERN_WARNING "mtdblock: erase of region [0x%lx, 0x%x] ""on /"%s/" failed/n",pos, len, mtd->name);return ret;}schedule(); /* Wait for erase to finish. */remove_wait_queue(&wait_q, &wait);/** Next, writhe data to flash.*/ret = MTD_WRITE (mtd, pos, len, &retlen, buf);if (ret)return ret;if (retlen != len)return -EIO;return 0;}static int write_cached_data (struct mtdblk_dev *mtdblk){struct mtd_info *mtd = mtdblk->mtd;int ret;if (mtdblk->cache_state != STATE_DIRTY)return 0;DEBUG(MTD_DEBUG_LEVEL2, "mtdblock: writing cached data for /"%s/" ""at 0x%lx, size 0x%x/n", mtd->name,mtdblk->cache_offset, mtdblk->cache_size);ret = erase_write (mtd, mtdblk->cache_offset,mtdblk->cache_size, mtdblk->cache_data);if (ret)return ret;127mtdblk->cache_state = STATE_EMPTY;return 0;}static int do_cached_write (struct mtdblk_dev *mtdblk, unsigned long pos,int len, const char *buf){…}static int do_cached_read (struct mtdblk_dev *mtdblk, unsigned long pos,int len, char *buf){…}static int mtdblock_open(struct inode *inode, struct file *file){…}static release_t mtdblock_release(struct inode *inode, struct file *file){int dev;struct mtdblk_dev *mtdblk;DEBUG(MTD_DEBUG_LEVEL1, "mtdblock_release/n");if (inode == NULL)release_return(-ENODEV);dev = minor(inode->i_rdev);mtdblk = mtdblks[dev];down(&mtdblk->cache_sem);write_cached_data(mtdblk);up(&mtdblk->cache_sem);spin_lock(&mtdblks_lock);if (!--mtdblk->count) {/* It was the last usage. Free the device */mtdblks[dev] = NULL;spin_unlock(&mtdblks_lock);if (mtdblk->mtd->sync)128mtdblk->mtd->sync(mtdblk->mtd);put_mtd_device(mtdblk->mtd);vfree(mtdblk->cache_data);kfree(mtdblk);} else {spin_unlock(&mtdblks_lock);}DEBUG(MTD_DEBUG_LEVEL1, "ok/n");BLK_DEC_USE_COUNT;release_return(0);}/** This is a special request_fn because it is executed in a process context* to be able to sleep independently of the caller. The* io_request_lock (for <2.5) or queue_lock (for >=2.5) is held upon entry* and exit. The head of our request queue is considered active so there is* no need to dequeue requests before we are done.*/static void handle_mtdblock_request(void){struct request *req;struct mtdblk_dev *mtdblk;unsigned int res;for (;;) {INIT_REQUEST;req = CURRENT;spin_unlock_irq(QUEUE_LOCK(QUEUE));mtdblk = mtdblks[minor(req->rq_dev)];res = 0;if (minor(req->rq_dev) >= MAX_MTD_DEVICES)panic("%s : minor out of bound", __FUNCTION__);if (!IS_REQ_CMD(req))goto end_req;if ((req->sector + req->current_nr_sectors) > (mtdblk->mtd->size >> 9))goto end_req;129// Handle the requestswitch (rq_data_dir(req)){int err;case READ:down(&mtdblk->cache_sem);err = do_cached_read (mtdblk, req->sector << 9,req->current_nr_sectors << 9,req->buffer);up(&mtdblk->cache_sem);if (!err)res = 1;break;case WRITE:// Read only deviceif ( !(mtdblk->mtd->flags & MTD_WRITEABLE) )break;// Do the writedown(&mtdblk->cache_sem);err = do_cached_write (mtdblk, req->sector << 9,req->current_nr_sectors << 9,req->buffer);up(&mtdblk->cache_sem);if (!err)res = 1;break;}end_req:spin_lock_irq(QUEUE_LOCK(QUEUE));end_request(res);}}static volatile int leaving = 0;static DECLARE_MUTEX_LOCKED(thread_sem);static DECLARE_WAIT_QUEUE_HEAD(thr_wq);int mtdblock_thread(void *dummy){…130}#define RQFUNC_ARG request_queue_t *qstatic void mtdblock_request(RQFUNC_ARG){/* Don't do anything, except wake the thread if necessary */wake_up(&thr_wq);}static int mtdblock_ioctl(struct inode * inode, struct file * file,unsigned int cmd, unsigned long arg){struct mtdblk_dev *mtdblk;mtdblk = mtdblks[minor(inode->i_rdev)];switch (cmd) {case BLKGETSIZE: /* Return device size */return put_user((mtdblk->mtd->size >> 9), (unsigned long *) arg);case BLKFLSBUF:if(!capable(CAP_SYS_ADMIN))return -EACCES;fsync_dev(inode->i_rdev);invalidate_buffers(inode->i_rdev);down(&mtdblk->cache_sem);write_cached_data(mtdblk);up(&mtdblk->cache_sem);if (mtdblk->mtd->sync)mtdblk->mtd->sync(mtdblk->mtd);return 0;default:return -EINVAL;}}static struct block_device_operations mtd_fops ={owner: THIS_MODULE,open: mtdblock_open,131release: mtdblock_release,ioctl: mtdblock_ioctl};static void mtd_notify_add(struct mtd_info* mtd){…}static void mtd_notify_remove(struct mtd_info* mtd){if (!mtd || mtd->type == MTD_ABSENT)return;devfs_unregister(devfs_rw_handle[mtd->index]);}int __init init_mtdblock(void){int i;spin_lock_init(&mtdblks_lock);/* this lock is used just in kernels >= 2.5.x */spin_lock_init(&mtdblock_lock);#ifdef CONFIG_DEVFS_FSif (devfs_register_blkdev(MTD_BLOCK_MAJOR, DEVICE_NAME, &mtd_fops)){printk(KERN_NOTICE "Can't allocate major number %d for Memory TechnologyDevices./n",MTD_BLOCK_MAJOR);return -EAGAIN;}devfs_dir_handle = devfs_mk_dir(NULL, DEVICE_NAME, NULL);register_mtd_user(?ifier);#elseif (register_blkdev(MAJOR_NR,DEVICE_NAME,&mtd_fops)) {printk(KERN_NOTICE "Can't allocate major number %d for Memory TechnologyDevices./n",MTD_BLOCK_MAJOR);return -EAGAIN;}#endif132/* We fill it in at open() time. */for (i=0; i< MAX_MTD_DEVICES; i++) {mtd_sizes[i] = 0;mtd_blksizes[i] = BLOCK_SIZE;}init_waitqueue_head(&thr_wq);/* Allow the block size to default to BLOCK_SIZE. */blksize_size[MAJOR_NR] = mtd_blksizes;blk_size[MAJOR_NR] = mtd_sizes;BLK_INIT_QUEUE(BLK_DEFAULT_QUEUE(MAJOR_NR), &mtdblock_request,&mtdblock_lock);kernel_thread (mtdblock_thread, NULL, CLONE_FS|CLONE_FILES|CLONE_SIGHAND);return 0;}static void __exit cleanup_mtdblock(void){leaving = 1;wake_up(&thr_wq);down(&thread_sem);#ifdef CONFIG_DEVFS_FSunregister_mtd_user(?ifier);devfs_unregister(devfs_dir_handle);devfs_unregister_blkdev(MTD_BLOCK_MAJOR, DEVICE_NAME);#elseunregister_blkdev(MAJOR_NR,DEVICE_NAME);#endifblk_cleanup_queue(BLK_DEFAULT_QUEUE(MAJOR_NR));blksize_size[MAJOR_NR] = NULL;blk_size[MAJOR_NR] = NULL;}module_init(init_mtdblock);module_exit(cleanup_mtdblock);從上述源代碼中我們發(fā)現(xiàn)，塊設備也以與字符設備 register_chrdev、unregister_ chrdev 函數(shù)類似的方法進行設備的注冊與釋放：int register_blkdev(unsigned int major, const char *name, struct block_device_operations*bdops);int unregister_blkdev(unsigned int major, const char *name);但是， register_chrdev使用一個向 file_operations結(jié) 構的指針，而 register_blkdev則使用block_device_operations 結(jié)構的指針，其中定義的open、release 和ioctl 方法和字符設備的對應方法相133同，但未定義 read或者 write操作。這是因為，所有涉及到塊設備的 I/O通常由系統(tǒng)進行緩沖處理。塊驅(qū)動程序最終必須提供完成實際塊 I/O 操作的機制，在Linux 當中，用于這些I/O 操作的方法稱為“request（請求）”。在塊設備的注冊過程中，需要初始化request 隊列，這一動作通過blk_init_queue 來完成， blk_init_queue 函數(shù)建立隊列，并將該驅(qū)動程序的request 函數(shù)關聯(lián)到隊列。在模塊的清除階段，應調(diào)用 blk_cleanup_queue 函數(shù)。本例中相關的代碼為：BLK_INIT_QUEUE(BLK_DEFAULT_QUEUE(MAJOR_NR), &mtdblock_request, &mtdblock_lock);blk_cleanup_queue(BLK_DEFAULT_QUEUE(MAJOR_NR));每個設備有一個默認使用的請求隊列，必要時，可使用 BLK_DEFAULT_QUEUE(major) 宏得到該默認隊列。這個宏在 blk_dev_struct 結(jié)構形成的全局數(shù)組（該數(shù)組名為blk_dev）中搜索得到對應的默認隊列。blk_dev 數(shù)組由內(nèi)核維護，并可通過主設備號索引。blk_dev_struct 接口定義如下：struct blk_dev_struct {/** queue_proc has to be atomic*/request_queue_t request_queue;queue_proc *queue;void *data;};request_queue 成員包含了初始化之后的 I/O 請求隊列，data 成員可由驅(qū)動程序使用，以便保存一些私有數(shù)據(jù)。request_queue 定義為：struct request_queue{/** the queue request freelist, one for reads and one for writes*/struct request_list rq[2];/** Together with queue_head for cacheline sharing*/struct list_head queue_head;elevator_t elevator;request_fn_proc * request_fn;merge_request_fn * back_merge_fn;merge_request_fn * front_merge_fn;merge_requests_fn * merge_requests_fn;make_request_fn * make_request_fn;plug_device_fn * plug_device_fn;/** The queue owner gets to use this for whatever they like.* ll_rw_blk doesn't touch it.134*/void * queuedata;/** This is used to remove the plug when tq_disk runs.*/struct tq_struct plug_tq;/** Boolean that indicates whether this queue is plugged or not.*/char plugged;/** Boolean that indicates whether current_request is active or* not.*/char head_active;/** Is meant to protect the queue in the future instead of* io_request_lock*/spinlock_t queue_lock;/** Tasks wait here for free request*/wait_queue_head_t wait_for_request;};下圖表征了 blk_dev、blk_dev_struct 和request_queue 的關系：下圖則表征了塊設備的注冊和釋放過程：1355.小結(jié)本章講述了 Linux設備驅(qū)動程序的入口函數(shù)及驅(qū)動程序中的內(nèi)存申請、中斷等，并分別以實例講述了字符設備及塊設備的驅(qū)動開發(fā)方法。Trackback: http://tb.donews.net/TrackBack.aspx?PostId=1000099[點擊此處收藏本文]發(fā)表于 2006年 08月 14日 8:07 PM基于 ARM 的嵌入式 Linux 移植真實體驗（5）――應用實例宋寶華 21cnbao@21cn.com出處:dev.yesky.com應用實例的編寫實際上已經(jīng)不屬于 Linux操作系統(tǒng)移植的范疇，但是為了保證本系列文章的完整性，這里提供一系列針對嵌入式 Linux 開發(fā)應用程序的實例。編寫 Linux 應用程序要用到如下工具：（ 1）編譯器：GCCGCC 是 Linux平臺下最重要的開發(fā)工具，它是 GNU的 C和 C++編譯器，其基本用法為：gcc [options]136[filenames]。我們應該使用 arm-linux-gcc。（ 2）調(diào)試器：GDBgdb 是一個用來調(diào)試 C和 C++程序的強力調(diào)試器，我們能通過它進行一系列調(diào)試工作，包括設置斷點、觀查變量、單步等。我們應該使用 arm-linux-gdb。（ 3）MakeGNU Make 的主要工作是讀進一個文本文件，稱為makefile。這個文件記錄了哪些文件由哪些文件產(chǎn)生，用什么命令來產(chǎn)生。 Make 依靠此makefile 中的信息檢查磁盤上的文件，如果目的文件的創(chuàng)建或修改時間比它的一個依靠文件舊的話， make 就執(zhí)行相應的命令，以便更新目的文件。Makefile 中的編譯規(guī)則要相應地使用arm-linux-版本。（ 4）代碼編輯可以使用傳統(tǒng)的 vi 編輯器，但最好采用emacs 軟件，它具備語法高亮、版本控制等附帶功能。在宿主機上用上述工具完成應用程序的開發(fā)后，可以通過如下途徑將程序下載到目標板上運行：（ 1）通過串口通信協(xié)議rz 將程序下載到目標板的文件系統(tǒng)中（感謝Linux 提供了rz 這樣的一個命令）；（ 2）通過ftp 通信協(xié)議從宿主機上的ftp 目錄里將程序下載到目標板的文件系統(tǒng)中；（ 3）將程序拷入U 盤，在目標機上mount U 盤，運行U 盤中的程序；（ 4）如果目標機Linux 使用NFS 文件系統(tǒng)，則可以直接將程序拷入到宿主機相應的目錄內(nèi)，在目標機Linux中可以直接使用。1. 文件編程Linux 的文件操作API 涉及到創(chuàng)建、打開、讀寫和關閉文件。創(chuàng)建int creat(const char *filename, mode_t mode);參數(shù) mode指定新建文件的存取權限，它同 umask一起決定文件的最終權限（ mode&umask），其中umask代表了文件在創(chuàng)建時需要去掉的一些存取權限。 umask 可通過系統(tǒng)調(diào)用umask()來改變：int umask(int newmask);該調(diào)用將 umask設置為 newmask，然后返回舊的umask，它只影響讀、寫和執(zhí)行權限。打開int open(const char *pathname, int flags);int open(const char *pathname, int flags, mode_t mode);讀寫在文件打開以后，我們才可對文件進行讀寫了， Linux 中提供文件讀寫的系統(tǒng)調(diào)用是read、write 函數(shù)：int read(int fd, const void *buf, size_t length);int write(int fd, const void *buf, size_t length);其中參數(shù) buf為指向緩沖區(qū)的指針， length為緩沖區(qū)的大小（以字節(jié)為單位）。函數(shù) read()實現(xiàn)從文件描述符 fd 所指定的文件中讀取length 個字節(jié)到buf 所指向的緩沖區(qū)中，返回值為實際讀取的字節(jié)數(shù)。函數(shù)write實現(xiàn)將把 length個字節(jié)從 buf指向的緩沖區(qū)中寫到文件描述符 fd所指向的文件中，返回值為實際寫入的字節(jié)數(shù)。以 O_CREAT 為標志的open 實際上實現(xiàn)了文件創(chuàng)建的功能，因此，下面的函數(shù)等同creat()函數(shù)：int open(pathname, O_CREAT | O_WRONLY | O_TRUNC, mode);定位對于隨機文件，我們可以隨機的指定位置讀寫，使用如下函數(shù)進行定位：int lseek(int fd, offset_t offset, int whence);137lseek()將文件讀寫指針相對whence 移動offset 個字節(jié)。操作成功時，返回文件指針相對于文件頭的位置。參數(shù) whence 可使用下述值：SEEK_SET：相對文件開頭SEEK_CUR：相對文件讀寫指針的當前位置SEEK_END：相對文件末尾offset 可取負值，例如下述調(diào)用可將文件指針相對當前位置向前移動5 個字節(jié)：lseek(fd, -5, SEEK_CUR);由于 lseek函數(shù)的返回值為文件指針相對于文件頭的位置，因此下列調(diào)用的返回值就是文件的長度：lseek(fd, 0, SEEK_END);關閉只要調(diào)用 close 就可以了，其中fd 是我們要關閉的文件描述符：int close(int fd);下面我們來編寫一個應用程序，在當前目錄下創(chuàng)建用戶可讀寫文件“example.txt”，在其中寫入“Hello World”，關閉文件，再次打開它，讀取其中的內(nèi)容并輸出在屏幕上：#include <sys/types.h>#include <sys/stat.h>#include <fcntl.h>#include <stdio.h>#define LENGTH 100main(){int fd, len;char str[LENGTH];fd = open("hello.txt", O_CREAT | O_RDWR, S_IRUSR | S_IWUSR); /* 創(chuàng)建并打開文件*/if (fd){write(fd, "Hello, Software Weekly", strlen("Hello, software weekly")); /* 寫入 Hello, softwareweekly 字符串 */close(fd);}fd = open("hello.txt", O_RDWR);len = read(fd, str, LENGTH); /* 讀取文件內(nèi)容*/str[len] = '/0';printf("%s/n", str);close(fd);}2. 進程控制/通信編程進程控制中主要涉及到進程的創(chuàng)建、睡眠和退出等，在 Linux 中主要提供了fork、exec、clone 的進程創(chuàng)建方法， sleep 的進程睡眠和exit 的進程退出調(diào)用，另外Linux 還提供了父進程等待子進程結(jié)束的系統(tǒng)調(diào)用wait。fork對于沒有接觸過 Unix/Linux操作系統(tǒng)的人來說， fork是最難理解的概念之一，因為它執(zhí)行一次卻返回兩個值，138以前“聞所未聞”。先看下面的程序：int main(){int i;if (fork() == 0){for (i = 1; i < 3; i++)printf("This is child process/n");}else{for (i = 1; i < 3; i++)printf("This is parent process/n");}}執(zhí)行結(jié)果為：This is child processThis is child processThis is parent processThis is parent processfork 在英文中是“分叉”的意思，一個進程在運行中，如果使用了fork，就產(chǎn)生了另一個進程，于是進程就“分叉”了。當前進程為父進程，通過fork()會產(chǎn)生一個子進程。對于父進程，fork 函數(shù)返回子程序的進程號而對于子程序， fork 函數(shù)則返回零，這就是一個函數(shù)返回兩次的本質(zhì)。exec在 Linux中可使用 exec函數(shù)族，包含多個函數(shù)（ execl、execlp、execle、execv、execve 和execvp），被用于啟動一個指定路徑和文件名的進程。 exec 函數(shù)族的特點體現(xiàn)在：某進程一旦調(diào)用了exec 類函數(shù)，正在執(zhí)行的程序就被干掉了，系統(tǒng)把代碼段替換成新的程序（由 exec 類函數(shù)執(zhí)行）的代碼，并且原有的數(shù)據(jù)段和堆棧段也被廢棄，新的數(shù)據(jù)段與堆棧段被分配，但是進程號卻被保留。也就是說， exec 執(zhí)行的結(jié)果為：系統(tǒng)認為正在執(zhí)行的還是原先的進程，但是進程對應的程序被替換了。fork 函數(shù)可以創(chuàng)建一個子進程而當前進程不死，如果我們在fork 的子進程中調(diào)用exec 函數(shù)族就可以實現(xiàn)既讓父進程的代碼執(zhí)行又啟動一個新的指定進程，這很好。 fork 和exec 的搭配巧妙地解決了程序啟動另一程序的執(zhí)行但自己仍繼續(xù)運行的問題，請看下面的例子：char command[MAX_CMD_LEN];void main(){int rtn; /* 子進程的返回數(shù)值 */while (1){/* 從終端讀取要執(zhí)行的命令 */printf(">");fgets(command, MAX_CMD_LEN, stdin);command[strlen(command) - 1] = 0;if (fork() == 0){139/* 子進程執(zhí)行此命令*/execlp(command, command);/* 如果 exec函數(shù)返回，表明沒有正常執(zhí)行命令，打印錯誤信息*/perror(command);exit(errorno);}else{/* 父進程，等待子進程結(jié)束，并打印子進程的返回值 */wait(&rtn);printf(" child process return %d/n", rtn);}}}這個函數(shù)實現(xiàn)了一個 shell的功能，它讀取用戶輸入的進程名和參數(shù)，并啟動對應的進程。cloneclone 是Linux2.0 以后才具備的新功能，它較fork 更強（可認為fork 是clone 要實現(xiàn)的一部分），可以使得創(chuàng)建的子進程共享父進程的資源，并且要使用此函數(shù)必須在編譯內(nèi)核時設置 clone_actually_works_ok選項。clone 函數(shù)的原型為：int clone(int (*fn)(void *), void *child_stack, int flags, void *arg);此函數(shù)返回創(chuàng)建進程的 PID，函數(shù)中的flags 標志用于設置創(chuàng)建子進程時的相關選項。來看下面的例子：int variable, fd;int do_something() {variable = 42;close(fd);_exit(0);}int main(int argc, char *argv[]) {void **child_stack;char tempch;variable = 9;fd = open("test.file", O_RDONLY);child_stack = (void **) malloc(16384);printf("The variable was %d/n", variable);clone(do_something, child_stack, CLONE_VM|CLONE_FILES, NULL);sleep(1); /* 延時以便子進程完成關閉文件操作、修改變量*/printf("The variable is now %d/n", variable);140if (read(fd, &tempch, 1) < 1) {perror("File Read Error");exit(1);}printf("We could read from the file/n");return 0;}運行輸出：The variable is now 42File Read Error程序的輸出結(jié)果告訴我們，子進程將文件關閉并將變量修改（調(diào)用clone 時用到的CLONE_VM、CLONE_FILES標志將使得變量和文件描述符表被共享），父進程隨即就感覺到了，這就是clone 的特點。sleep函數(shù)調(diào)用 sleep可以用來使進程掛起指定的秒數(shù)，該函數(shù)的原型為：unsigned int sleep(unsigned int seconds);該函數(shù)調(diào)用使得進程掛起一個指定的時間，如果指定掛起的時間到了，該調(diào)用返回0；如果該函數(shù)調(diào)用被信號所打斷，則返回剩余掛起的時間數(shù)（指定的時間減去已經(jīng)掛起的時間）。exit系統(tǒng)調(diào)用 exit的功能是終止本進程，其函數(shù)原型為：void _exit(int status);_exit 會立即終止發(fā)出調(diào)用的進程，所有屬于該進程的文件描述符都關閉。參數(shù)status 作為退出的狀態(tài)值返回父進程，在父進程中通過系統(tǒng)調(diào)用 wait 可獲得此值。waitwait 系統(tǒng)調(diào)用包括：pid_t wait(int *status);pid_t waitpid(pid_t pid, int *status, int options);wait 的作用為發(fā)出調(diào)用的進程只要有子進程，就睡眠到它們中的一個終止為止；waitpid 等待由參數(shù)pid 指定的子進程退出。Linux 的進程間通信（IPC，InterProcess Communication）通信方法有管道、消息隊列、共享內(nèi)存、信號量、套接口等。套接字通信并不為 Linux 所專有，在所有提供了TCP/IP 協(xié)議棧的操作系統(tǒng)中幾乎都提供了socket，而所有這樣操作系統(tǒng)，對套接字的編程方法幾乎是完全一樣的。管道分為有名管道和無名管道，無名管道只能用于親屬進程之間的通信，而有名管道則可用于無親屬關系的進程之間；消息隊列用于運行于同一臺機器上的進程間通信，與管道相似；共享內(nèi)存通常由一個進程創(chuàng)建，其余進程對這塊內(nèi)存區(qū)進行讀寫；信號量是一個計數(shù)器，它用來記錄對某個資源（如共享內(nèi)存）的存取狀況。下面是一個使用信號量的例子，該程序創(chuàng)建一個特定的 IPC 結(jié)構的關鍵字和一個信號量，建立此信號量的索引，修改索引指向的信號量的值，最后清除信號量：#include <stdio.h>#include <sys/types.h>#include <sys/sem.h>#include <sys/ipc.h>void main(){key_t unique_key; /* 定義一個 IPC 關鍵字*/int id;141struct sembuf lock_it;union semun options;int i;unique_key = ftok(".", 'a'); /* 生成關鍵字，字符'a'是一個隨機種子*//* 創(chuàng)建一個新的信號量集合*/id = semget(unique_key, 1, IPC_CREAT | IPC_EXCL | 0666);printf("semaphore id=%d/n", id);options.val = 1; /*設置變量值*/semctl(id, 0, SETVAL, options); /*設置索引0 的信號量*//*打印出信號量的值*/i = semctl(id, 0, GETVAL, 0);printf("value of semaphore at index 0 is %d/n", i);/*下面重新設置信號量*/lock_it.sem_num = 0; /*設置哪個信號量*/lock_it.sem_op = - 1; /*定義操作*/lock_it.sem_flg = IPC_NOWAIT; /*操作方式*/if (semop(id, &lock_it, 1) == - 1){printf("can not lock semaphore./n");exit(1);}i = semctl(id, 0, GETVAL, 0);printf("value of semaphore at index 0 is %d/n", i);/*清除信號量*/semctl(id, 0, IPC_RMID, 0);}3. 線程控制/通信編程Linux 本身只有進程的概念，而其所謂的“線程”本質(zhì)上在內(nèi)核里仍然是進程。大家知道，進程是資源分配的單位，同一進程中的多個線程共享該進程的資源（如作為共享內(nèi)存的全局變量）。 Linux 中所謂的“線程”只是在被創(chuàng)建的時候“克隆”(clone)了父進程的資源，因此，clone 出來的進程表現(xiàn)為“線程”。Linux 中最流行的線程機制為 LinuxThreads，它實現(xiàn)了一種Posix 1003.1c “pthread”標準接口。線程之間的通信涉及同步和互斥，互斥體的用法為：pthread_mutex_t mutex;pthread_mutex_init(&mutex, NULL); //按缺省的屬性初始化互斥體變量mutexpthread_mutex_lock(&mutex); // 給互斥體變量加鎖… //臨界資源phtread_mutex_unlock(&mutex); // 給互斥體變量解鎖同步就是線程等待某個事件的發(fā)生。只有當?shù)却氖录l(fā)生線程才繼續(xù)執(zhí)行，否則線程掛起并放棄處理器。當142多個線程協(xié)作時，相互作用的任務必須在一定的條件下同步。Linux 下的C 語言編程有多種線程同步機制，最典型的是條件變量(condition variable)。而在頭文件semaphore.h 中定義的信號量則完成了互斥體和條件變量的封裝，按照多線程程序設計中訪問控制機制，控制對資源的同步訪問，提供程序設計人員更方便的調(diào)用接口。下面的生產(chǎn)者/消費者問題說明了Linux 線程的控制和通信：#include <stdio.h>#include <pthread.h>#define BUFFER_SIZE 16struct prodcons{int buffer[BUFFER_SIZE];pthread_mutex_t lock;int readpos, writepos;pthread_cond_t notempty;pthread_cond_t notfull;};/* 初始化緩沖區(qū)結(jié)構 */void init(struct prodcons *b){pthread_mutex_init(&b->lock, NULL);pthread_cond_init(&b->notempty, NULL);pthread_cond_init(&b->notfull, NULL);b->readpos = 0;b->writepos = 0;}/* 將產(chǎn)品放入緩沖區(qū),這里是存入一個整數(shù)*/void put(struct prodcons *b, int data){pthread_mutex_lock(&b->lock);/* 等待緩沖區(qū)未滿*/if ((b->writepos + 1) % BUFFER_SIZE == b->readpos){pthread_cond_wait(&b->notfull, &b->lock);}/* 寫數(shù)據(jù),并移動指針*/b->buffer[b->writepos] = data;b->writepos++;if (b->writepos > = BUFFER_SIZE)b->writepos = 0;/* 設置緩沖區(qū)非空的條件變量*/pthread_cond_signal(&b->notempty);pthread_mutex_unlock(&b->lock);}/* 從緩沖區(qū)中取出整數(shù)*/143int get(struct prodcons *b){int data;pthread_mutex_lock(&b->lock);/* 等待緩沖區(qū)非空*/if (b->writepos == b->readpos){pthread_cond_wait(&b->notempty, &b->lock);}/* 讀數(shù)據(jù),移動讀指針*/data = b->buffer[b->readpos];b->readpos++;if (b->readpos > = BUFFER_SIZE)b->readpos = 0;/* 設置緩沖區(qū)未滿的條件變量*/pthread_cond_signal(&b->notfull);pthread_mutex_unlock(&b->lock);return data;}/* 測試:生產(chǎn)者線程將1 到10000 的整數(shù)送入緩沖區(qū),消費者線程從緩沖區(qū)中獲取整數(shù),兩者都打印信息*/#define OVER ( - 1)struct prodcons buffer;void *producer(void *data){int n;for (n = 0; n < 10000; n++){printf("%d --->/n", n);put(&buffer, n);} put(&buffer, OVER);return NULL;}void *consumer(void *data){int d;while (1){d = get(&buffer);if (d == OVER)break;printf("--->%d /n", d);144}return NULL;}int main(void){pthread_t th_a, th_b;void *retval;init(&buffer);/* 創(chuàng)建生產(chǎn)者和消費者線程*/pthread_create(&th_a, NULL, producer, 0);pthread_create(&th_b, NULL, consumer, 0);/* 等待兩個線程結(jié)束*/pthread_join(th_a, &retval);pthread_join(th_b, &retval);return 0;}4.小結(jié)本章主要給出了 Linux平臺下文件、進程控制與通信、線程控制與通信的編程實例。至此，一個完整的，涉及硬件原理、 Bootloader、操作系統(tǒng)及文件系統(tǒng)移植、驅(qū)動程序開發(fā)及應用程序編寫的嵌入式Linux 系列講解就全部結(jié)束了。深入淺出 Linux 設備驅(qū)動編程宋寶華 21cnbao@21cn.comyesky1.Linux 內(nèi)核模塊Linux 設備驅(qū)動屬于內(nèi)核的一部分，Linux 內(nèi)核的一個模塊可以以兩種方式被編譯和加載：（ 1）直接編譯進Linux 內(nèi)核，隨同Linux 啟動時加載；（ 2）編譯成一個可加載和刪除的模塊，使用insmod 加載（modprobe 和insmod 命令類似，但依賴于相關的配置文件）， rmmod 刪除。這種方式控制了內(nèi)核的大小，而模塊一旦被插入內(nèi)核，它就和內(nèi)核其他部分一樣。下面我們給出一個內(nèi)核模塊的例子：#include <linux/module.h> //所有模塊都需要的頭文件#include <linux/init.h> // init&exit 相關宏MODULE_LICENSE("GPL");static int __init hello_init (void)145{printk("Hello module init/n");return 0;}static void __exit hello_exit (void){printk("Hello module exit/n");}module_init(hello_init);module_exit(hello_exit);分析上述程序，發(fā)現(xiàn)一個 Linux內(nèi)核模塊需包含模塊初始化和模塊卸載函數(shù)，前者在 insmod 的時候運行，后者在 rmmod 的時候運行。初始化與卸載函數(shù)必須在宏module_init 和module_exit 使用前定義，否則會出現(xiàn)編譯錯誤。程序中的 MODULE_LICENSE("GPL")用于聲明模塊的許可證。如果要把上述程序編譯為一個運行時加載和刪除的模塊，則編譯命令為：gcc –D__KERNEL__ -DMODULE –DLINUX –I /usr/local/src/linux2.4/include -c –o hello.o hello.c由此可見， Linux內(nèi)核模塊的編譯需要給 gcc指示–D__KERNEL__ -DMODULE –DLINUX參數(shù)。 -I選項跟著 Linux 內(nèi)核源代碼中Include 目錄的路徑。下列命令將可加載 hello 模塊：insmod ./hello.o下列命令完成相反過程：rmmod hello如果要將其直接編譯入 Linux內(nèi)核，則需要將源代碼文件拷貝入 Linux內(nèi)核源代碼的相應路徑里，并修改Makefile。我們有必要補充一下 Linux 內(nèi)核編程的一些基本知識：內(nèi)存在 Linux 內(nèi)核模式下，我們不能使用用戶態(tài)的malloc()和free()函數(shù)申請和釋放內(nèi)存。進行內(nèi)核編程時，最常用的內(nèi)存申請和釋放函數(shù)為在 include/linux/kernel.h 文件中聲明的kmalloc()和kfree()，其原型為：void *kmalloc(unsigned int len, int priority);void kfree(void *__ptr);kmalloc 的 priority參數(shù)通常設置為 GFP_KERNEL，如果在中斷服務程序里申請內(nèi)存則要用GFP_ATOMIC參數(shù)，因為使用 GFP_KERNEL參數(shù)可能會引起睡眠，不能用于非進程上下文中（在中斷中是不允許睡眠的）。由于內(nèi)核態(tài)和用戶態(tài)使用不同的內(nèi)存定義，所以二者之間不能直接訪問對方的內(nèi)存。而應該使用 Linux 中的用戶和內(nèi)核態(tài)內(nèi)存交互函數(shù)（這些函數(shù)在 include/asm/uaccess.h 中被聲明）：unsigned long copy_from_user(void *to, const void *from, unsigned long n);unsigned long copy_to_user (void * to, void * from, unsigned long len);copy_from_user、 copy_to_user函數(shù)返回不能被復制的字節(jié)數(shù)，因此，如果完全復制成功，返回值為0。include/asm/uaccess.h 中定義的put_user 和get_user 用于內(nèi)核空間和用戶空間的單值交互（如char、int、long）。這里給出的僅僅是關于內(nèi)核中內(nèi)存管理的皮毛，關于 Linux 內(nèi)存管理的更多細節(jié)知識，我們會在本文第9 節(jié) 《內(nèi)存與 I/O 操作》進行更加深入地介紹。輸出146在內(nèi)核編程中，我們不能使用用戶態(tài) C庫函數(shù)中的 printf()函數(shù)輸出信息，而只能使用printk()。但是，內(nèi)核中 printk()函數(shù)的設計目的并不是為了和用戶交流，它實際上是內(nèi)核的一種日志機制，用來記錄下日志信息或者給出警告提示。每個 printk 都會有個優(yōu)先級，內(nèi)核一共有8 個優(yōu)先級，它們都有對應的宏定義。如果未指定優(yōu)先級，內(nèi)核會選擇默認的優(yōu)先級 DEFAULT_MESSAGE_LOGLEVEL。如果優(yōu)先級數(shù)字比int console_loglevel 變量小的話，消息就會打印到控制臺上。如果 syslogd 和klogd 守護進程在運行的話，則不管是否向控制臺輸出，消息都會被追加進/var/log/messages 文件。klogd 只處理內(nèi)核消息，syslogd 處理其他系統(tǒng)消息，比如應用程序。模塊參數(shù)2.4 內(nèi)核下，include/linux/module.h中定義的宏 MODULE_PARM(var,type)用于向模塊傳遞命令行參數(shù)。var 為接受參數(shù)值的變量名，type 為采取如下格式的字符串[min[-max]]{b,h,i,l,s}。min 及max 用于表示當參數(shù)為數(shù)組類型時，允許輸入的數(shù)組元素的個數(shù)范圍； b：byte；h：short；i：int；l：long；s：string。在裝載內(nèi)核模塊時，用戶可以向模塊傳遞一些參數(shù)：insmod modname var=value如果用戶未指定參數(shù)， var將使用模塊內(nèi)定義的缺省值。2.字符設備驅(qū)動程序Linux 下的設備驅(qū)動程序被組織為一組完成不同任務的函數(shù)的集合，通過這些函數(shù)使得Windows 的設備操作猶如文件一般。在應用程序看來，硬件設備只是一個設備文件，應用程序可以象操作普通文件一樣對硬件設備進行操作，如 open ()、close ()、read ()、write () 等。Linux 主要將設備分為二類：字符設備和塊設備。字符設備是指設備發(fā)送和接收數(shù)據(jù)以字符的形式進行；而塊設備則以整個數(shù)據(jù)緩沖區(qū)的形式進行。字符設備的驅(qū)動相對比較簡單。下面我們來假設一個非常簡單的虛擬字符設備：這個設備中只有一個 4 個字節(jié)的全局變量int global_var，而這個設備的名字叫做“gobalvar”。對“gobalvar”設備的讀寫等操作即是對其中全局變量global_var 的操作。驅(qū)動程序是內(nèi)核的一部分，因此我們需要給其添加模塊初始化函數(shù)，該函數(shù)用來完成對所控設備的初始化工作，并調(diào)用 register_chrdev() 函數(shù)注冊字符設備：static int __init gobalvar_init(void){if (register_chrdev(MAJOR_NUM, " gobalvar ", &gobalvar_fops)){//…注冊失敗}else{//…注冊成功}}其中， register_chrdev函數(shù)中的參數(shù) MAJOR_NUM為主設備號,“gobalvar”為設備名，gobalvar_fops 為包含基本函數(shù)入口點的結(jié)構體，類型為 file_operations。當gobalvar 模塊被加載時，gobalvar_init 被執(zhí)行，它將調(diào)用內(nèi)核函數(shù) register_chrdev，把驅(qū)動程序的基本入口點指針存放在內(nèi)核的字符設備地址表中，在用戶進程對該設備執(zhí)行系統(tǒng)調(diào)用時提供入口地址。與模塊初始化函數(shù)對應的就是模塊卸載函數(shù)，需要調(diào)用 register_chrdev()的“反函數(shù)” unregister_chrdev()：static void __exit gobalvar_exit(void)147{if (unregister_chrdev(MAJOR_NUM, " gobalvar ")){//…卸載失敗}else{//…卸載成功}}隨著內(nèi)核不斷增加新的功能， file_operations結(jié)構體已逐漸變得越來越大，但是大多數(shù)的驅(qū)動程序只是利用了其中的一部分。對于字符設備來說，要提供的主要入口有： open ()、release ()、read ()、write ()、ioctl ()、llseek()、poll()等。open()函數(shù) 對設備特殊文件進行open()系統(tǒng)調(diào)用時，將調(diào)用驅(qū)動程序的open () 函數(shù)：int (*open)(struct inode * ,struct file *);其中參數(shù) inode為設備特殊文件的 inode (索引結(jié)點)結(jié)構的指針，參數(shù) file是指向這一設備的文件結(jié)構的指針。 open()的主要任務是確定硬件處在就緒狀態(tài)、驗證次設備號的合法性(次設備號可以用MINOR(inode-> i- rdev) 取得)、控制使用設備的進程數(shù)、根據(jù)執(zhí)行情況返回狀態(tài)碼(0表示成功，負數(shù)表示存在錯誤)等；release()函數(shù) 當最后一個打開設備的用戶進程執(zhí)行close ()系統(tǒng)調(diào)用時，內(nèi)核將調(diào)用驅(qū)動程序的release ()函數(shù)：void (*release) (struct inode * ,struct file *) ;release 函數(shù)的主要任務是清理未結(jié)束的輸入/輸出操作、釋放資源、用戶自定義排他標志的復位等。read()函數(shù) 當對設備特殊文件進行read() 系統(tǒng)調(diào)用時，將調(diào)用驅(qū)動程序read() 函數(shù)：ssize_t (*read) (struct file *, char *, size_t, loff_t *);用來從設備中讀取數(shù)據(jù)。當該函數(shù)指針被賦為 NULL 值時，將導致read 系統(tǒng)調(diào)用出錯并返回-EINVAL（ “Invalid argument，非法參數(shù)”）。函數(shù)返回非負值表示成功讀取的字節(jié)數(shù)（返回值為“signed size”數(shù)據(jù)類型，通常就是目標平臺上的固有整數(shù)類型）。globalvar_read 函數(shù)中內(nèi)核空間與用戶空間的內(nèi)存交互需要借助第2 節(jié)所介紹的函數(shù)：static ssize_t globalvar_read(struct file *filp, char *buf, size_t len, loff_t *off){…copy_to_user(buf, &global_var, sizeof(int));…}write( )函數(shù) 當設備特殊文件進行 write ()系統(tǒng)調(diào)用時，將調(diào)用驅(qū)動程序的 write ()函數(shù)：ssize_t (*write) (struct file *, const char *, size_t, loff_t *);向設備發(fā)送數(shù)據(jù)。如果沒有這個函數(shù)， write系統(tǒng)調(diào)用會向調(diào)用程序返回一個-EINVAL。如果返回值非負，則表示成功寫入的字節(jié)數(shù)。globalvar_write 函數(shù)中內(nèi)核空間與用戶空間的內(nèi)存交互需要借助第2 節(jié)所介紹的函數(shù)：static ssize_t globalvar_write(struct file *filp, const char *buf, size_t len, loff_t*off){…copy_from_user(&global_var, buf, sizeof(int));148…}ioctl()函數(shù) 該函數(shù)是特殊的控制函數(shù)，可以通過它向設備傳遞控制信息或從設備取得狀態(tài)信息，函數(shù)原型為：int (*ioctl) (struct inode * ,struct file * ,unsigned int ,unsigned long);unsigned int 參數(shù)為設備驅(qū)動程序要執(zhí)行的命令的代碼，由用戶自定義，unsigned long 參數(shù)為相應的命令提供參數(shù)，類型可以是整型、指針等。如果設備不提供 ioctl 入口點，則對于任何內(nèi)核未預先定義的請求，ioctl 系統(tǒng)調(diào)用將返回錯誤（ -ENOTTY，“No such ioctl fordevice，該設備無此ioctl 命令”）。如果該設備方法返回一個非負值，那么該值會被返回給調(diào)用程序以表示調(diào)用成功。llseek()函數(shù)該函數(shù)用來修改文件的當前讀寫位置，并將新位置作為（正的）返回值返回，原型為：loff_t (*llseek) (struct file *, loff_t, int);poll()函數(shù)poll 方法是poll 和select 這兩個系統(tǒng)調(diào)用的后端實現(xiàn)，用來查詢設備是否可讀或可寫，或是否處于某種特殊狀態(tài)，原型為：unsigned int (*poll) (struct file *, struct poll_table_struct *);我們將在“設備的阻塞與非阻塞操作”一節(jié)對該函數(shù)進行更深入的介紹。設備 “gobalvar” 的驅(qū) 動程序的這些函數(shù) 應分別命名為gobalvar_open 、gobalvar_ release 、gobalvar_read 、gobalvar_write 、gobalvar_ioctl ，因此設備“gobalvar” 的基本入口點結(jié) 構變量gobalvar_fops 賦值如下：struct file_operations gobalvar_fops = {read: gobalvar_read,write: gobalvar_write,};上述代碼中對 gobalvar_fops的初始化方法并不是標準 C所支持的，屬于 GNU擴展語法。完整的 globalvar.c 文件源代碼如下：#include <linux/module.h>#include <linux/init.h>#include <linux/fs.h>#include <asm/uaccess.h>MODULE_LICENSE("GPL");#define MAJOR_NUM 254 //主設備號static ssize_t globalvar_read(struct file *, char *, size_t, loff_t*);static ssize_t globalvar_write(struct file *, const char *, size_t, loff_t*);//初始化字符設備驅(qū)動的 file_operations結(jié)構體struct file_operations globalvar_fops ={read: globalvar_read, write: globalvar_write,};static int global_var = 0; //“globalvar”設備的全局變量static int __init globalvar_init(void)149{int ret;//注冊設備驅(qū)動ret = register_chrdev(MAJOR_NUM, "globalvar", &globalvar_fops);if (ret){printk("globalvar register failure");}else{printk("globalvar register success");}return ret;}static void __exit globalvar_exit(void){int ret;//注銷設備驅(qū)動ret = unregister_chrdev(MAJOR_NUM, "globalvar");if (ret){printk("globalvar unregister failure");}else{printk("globalvar unregister success");}}static ssize_t globalvar_read(struct file *filp, char *buf, size_t len, loff_t *off){//將 global_var從內(nèi)核空間復制到用戶空間if (copy_to_user(buf, &global_var, sizeof(int))){return - EFAULT;}return sizeof(int);}static ssize_t globalvar_write(struct file *filp, const char *buf, size_t len, loff_t*off)150{//將用戶空間的數(shù)據(jù)復制到內(nèi)核空間的 global_varif (copy_from_user(&global_var, buf, sizeof(int))){return - EFAULT;}return sizeof(int);}module_init(globalvar_init);module_exit(globalvar_exit);運行gcc –D__KERNEL__ -DMODULE –DLINUX –I /usr/local/src/linux2.4/include -c –o globalvar.oglobalvar.c編譯代碼，運行inmod globalvar.o加載 globalvar模塊，再運行cat /proc/devices發(fā)現(xiàn)其中多出了“254 globalvar”一行，如下圖：接著我們可以運行：mknod /dev/globalvar c 254 0創(chuàng)建設備節(jié)點，用戶進程通過/dev/globalvar這個路徑就可以訪問到這個全局變量虛擬設備了。我們寫一個用戶態(tài)的程序 globalvartest.c 來驗證上述設備：#include <sys/types.h>#include <sys/stat.h>#include <stdio.h>#include <fcntl.h>main(){int fd, num;//打開“/dev/globalvar”fd = open("/dev/globalvar", O_RDWR, S_IRUSR | S_IWUSR);if (fd != -1 ){//初次讀 globalvarread(fd, &num, sizeof(int));printf("The globalvar is %d/n", num);//寫 globalvarprintf("Please input the num written to globalvar/n");scanf("%d", &num);write(fd, &num, sizeof(int));//再次讀 globalvar151read(fd, &num, sizeof(int));printf("The globalvar is %d/n", num);//關閉“/dev/globalvar”close(fd);}else{printf("Device open failure/n");}}編譯上述文件：gcc –o globalvartest.o globalvartest.c運行./globalvartest.o可以發(fā)現(xiàn)“globalvar”設備可以正確的讀寫。3.設備驅(qū)動中的并發(fā)控制在驅(qū)動程序中，當多個線程同時訪問相同的資源時（驅(qū)動程序中的全局變量是一種典型的共享資源），可能會引發(fā)“競態(tài)”，因此我們必須對共享資源進行并發(fā)控制。Linux 內(nèi)核中解決并發(fā)控制的最常用方法是自旋鎖與信號量（絕大多數(shù)時候作為互斥鎖使用）。自旋鎖與信號量“類似而不類”，類似說的是它們功能上的相似性，“不類”指代它們在本質(zhì)和實現(xiàn)機理上完全不一樣，不屬于一類。自旋鎖不會引起調(diào)用者睡眠，如果自旋鎖已經(jīng)被別的執(zhí)行單元保持，調(diào)用者就一直循環(huán)查看是否該自旋鎖的保持者已經(jīng)釋放了鎖， “自旋”就是“在原地打轉(zhuǎn)”。而信號量則引起調(diào)用者睡眠，它把進程從運行隊列上拖出去，除非獲得鎖。這就是它們的“不類”。但是，無論是信號量，還是自旋鎖，在任何時刻，最多只能有一個保持者，即在任何時刻最多只能有一個執(zhí)行單元獲得鎖。這就是它們的“類似”。鑒于自旋鎖與信號量的上述特點，一般而言，自旋鎖適合于保持時間非常短的情況，它可以在任何上下文使用；信號量適合于保持時間較長的情況，會只能在進程上下文使用。如果被保護的共享資源只在進程上下文訪問，則可以以信號量來保護該共享資源，如果對共享資源的訪問時間非常短，自旋鎖也是好的選擇。但是，如果被保護的共享資源需要在中斷上下文訪問（包括底半部即中斷處理句柄和頂半部即軟中斷），就必須使用自旋鎖。與信號量相關的 API 主要有：定義信號量struct semaphore sem;初始化信號量void sema_init (struct semaphore *sem, int val);該函數(shù)初始化信號量，并設置信號量 sem的值為 valvoid init_MUTEX (struct semaphore *sem);該函數(shù)用于初始化一個互斥鎖，即它把信號量 sem 的值設置為1，等同于sema_init (struct semaphore*sem, 1)；void init_MUTEX_LOCKED (struct semaphore *sem);152該函數(shù)也用于初始化一個互斥鎖，但它把信號量 sem 的值設置為0，等同于sema_init (struct semaphore*sem, 0)；獲得信號量void down(struct semaphore * sem);該函數(shù)用于獲得信號量 sem，它會導致睡眠，因此不能在中斷上下文使用；int down_interruptible(struct semaphore * sem);該函數(shù)功能與 down類似，不同之處為， down不能被信號打斷，但 down_interruptible能被信號打斷；int down_trylock(struct semaphore * sem);該函數(shù)嘗試獲得信號量 sem，如果能夠立刻獲得，它就獲得該信號量并返回0，否則，返回非0 值。它不會導致調(diào)用者睡眠，可以在中斷上下文使用。釋放信號量void up(struct semaphore * sem);該函數(shù)釋放信號量 sem，喚醒等待者。與自旋鎖相關的 API 主要有：定義自旋鎖spinlock_t spin;初始化自旋鎖spin_lock_init(lock)該宏用于動態(tài)初始化自旋鎖 lock獲得自旋鎖spin_lock(lock)該宏用于獲得自旋鎖 lock，如果能夠立即獲得鎖，它就馬上返回，否則，它將自旋在那里，直到該自旋鎖的保持者釋放；spin_trylock(lock)該宏嘗試獲得自旋鎖 lock，如果能立即獲得鎖，它獲得鎖并返回真，否則立即返回假，實際上不再“在原地打轉(zhuǎn)”；釋放自旋鎖spin_unlock(lock)該宏釋放自旋鎖 lock，它與spin_trylock 或spin_lock 配對使用；除此之外，還有一組自旋鎖使用于中斷情況下的 API。下面進入對并發(fā)控制的實戰(zhàn)。首先，在 globalvar 的驅(qū)動程序中，我們可以通過信號量來控制對int global_var的并發(fā)訪問，下面給出源代碼：#include <linux/module.h>#include <linux/init.h>#include <linux/fs.h>#include <asm/uaccess.h>#include <asm/semaphore.h>MODULE_LICENSE("GPL");#define MAJOR_NUM 254static ssize_t globalvar_read(struct file *, char *, size_t, loff_t*);static ssize_t globalvar_write(struct file *, const char *, size_t, loff_t*);153struct file_operations globalvar_fops ={read: globalvar_read, write: globalvar_write,};static int global_var = 0;static struct semaphore sem;static int __init globalvar_init(void){int ret;ret = register_chrdev(MAJOR_NUM, "globalvar", &globalvar_fops);if (ret){printk("globalvar register failure");}else{printk("globalvar register success");init_MUTEX(&sem);}return ret;}static void __exit globalvar_exit(void){int ret;ret = unregister_chrdev(MAJOR_NUM, "globalvar");if (ret){printk("globalvar unregister failure");}else{printk("globalvar unregister success");}}static ssize_t globalvar_read(struct file *filp, char *buf, size_t len, loff_t *off){//獲得信號量if (down_interruptible(&sem)){return - ERESTARTSYS;}154//將global_var 從內(nèi)核空間復制到用戶空間if (copy_to_user(buf, &global_var, sizeof(int))){up(&sem);return - EFAULT;}//釋放信號量up(&sem);return sizeof(int);}ssize_t globalvar_write(struct file *filp, const char *buf, size_t len, loff_t*off){//獲得信號量if (down_interruptible(&sem)){return - ERESTARTSYS;}//將用戶空間的數(shù)據(jù)復制到內(nèi)核空間的 global_varif (copy_from_user(&global_var, buf, sizeof(int))){up(&sem);return - EFAULT;}//釋放信號量up(&sem);return sizeof(int);}module_init(globalvar_init);module_exit(globalvar_exit);接下來，我們給 globalvar的驅(qū)動程序增加 open()和release()函數(shù)，并在其中借助自旋鎖來保護對全局變量int globalvar_count （記錄打開設備的進程數(shù) ）的訪問來實現(xiàn) 設備只能被一個進程打開（必須確保globalvar_count 最多只能為1）：#include <linux/module.h>#include <linux/init.h>155#include <linux/fs.h>#include <asm/uaccess.h>#include <asm/semaphore.h>MODULE_LICENSE("GPL");#define MAJOR_NUM 254static ssize_t globalvar_read(struct file *, char *, size_t, loff_t*);static ssize_t globalvar_write(struct file *, const char *, size_t, loff_t*);static int globalvar_open(struct inode *inode, struct file *filp);static int globalvar_release(struct inode *inode, struct file *filp);struct file_operations globalvar_fops ={read: globalvar_read, write: globalvar_write, open: globalvar_open, release:globalvar_release,};static int global_var = 0;static int globalvar_count = 0;static struct semaphore sem;static spinlock_t spin = SPIN_LOCK_UNLOCKED;static int __init globalvar_init(void){int ret;ret = register_chrdev(MAJOR_NUM, "globalvar", &globalvar_fops);if (ret){printk("globalvar register failure");}else{printk("globalvar register success");init_MUTEX(&sem);}return ret;}static void __exit globalvar_exit(void){int ret;156ret = unregister_chrdev(MAJOR_NUM, "globalvar");if (ret){printk("globalvar unregister failure");}else{printk("globalvar unregister success");}}static int globalvar_open(struct inode *inode, struct file *filp){//獲得自選鎖spin_lock(&spin);//臨界資源訪問if (globalvar_count){spin_unlock(&spin);return - EBUSY;}globalvar_count++;//釋放自選鎖spin_unlock(&spin);return 0;}static int globalvar_release(struct inode *inode, struct file *filp){globalvar_count--;return 0;}static ssize_t globalvar_read(struct file *filp, char *buf, size_t len, loff_t*off){if (down_interruptible(&sem)){return - ERESTARTSYS;}157if (copy_to_user(buf, &global_var, sizeof(int))){up(&sem);return - EFAULT;}up(&sem);return sizeof(int);}static ssize_t globalvar_write(struct file *filp, const char *buf, size_t len,loff_t *off){if (down_interruptible(&sem)){return - ERESTARTSYS;}if (copy_from_user(&global_var, buf, sizeof(int))){up(&sem);return - EFAULT;}up(&sem);return sizeof(int);}module_init(globalvar_init);module_exit(globalvar_exit);為了上述驅(qū) 動程序的效果，我們啟動兩個進程分別打開/dev/globalvar 。在兩個終端中調(diào)用./globalvartest.o 測試程序，當一個進程打開/dev/globalvar后，另外一個進程將打開失敗，輸出“deviceopen failure”，如下圖：4.設備的阻塞與非阻塞操作阻塞操作是指，在執(zhí)行設備操作時，若不能獲得資源，則進程掛起直到滿足可操作的條件再進行操作。非阻塞操作的進程在不能進行設備操作時，并不掛起。被掛起的進程進入 sleep 狀態(tài)，被從調(diào)度器的運行隊列移走，直到等待的條件被滿足。在 Linux 驅(qū)動程序中，我們可以使用等待隊列（wait queue）來實現(xiàn)阻塞操作。wait queue 很早就作為一個基本的功能單位出現(xiàn)在 Linux 內(nèi)核里了，它以隊列為基礎數(shù)據(jù)結(jié)構，與進程調(diào)度機制緊密結(jié)合，能夠用于實現(xiàn)核心的異步事件通知機制。等待隊列可以用來同步對系統(tǒng)資源的訪問，上節(jié)中所講述 Linux 信號量在內(nèi)核中也是由等待隊列來實現(xiàn)的。158下面我們重新定義設備“globalvar”，它可以被多個進程打開，但是每次只有當一個進程寫入了一個數(shù)據(jù)之后本進程或其它進程才可以讀取該數(shù)據(jù)，否則一直阻塞。#include <linux/module.h>#include <linux/init.h>#include <linux/fs.h>#include <asm/uaccess.h>#include <linux/wait.h>#include <asm/semaphore.h>MODULE_LICENSE("GPL");#define MAJOR_NUM 254static ssize_t globalvar_read(struct file *, char *, size_t, loff_t*);static ssize_t globalvar_write(struct file *, const char *, size_t, loff_t*);struct file_operations globalvar_fops ={read: globalvar_read, write: globalvar_write,};static int global_var = 0;static struct semaphore sem;static wait_queue_head_t outq;static int flag = 0;static int __init globalvar_init(void){int ret;ret = register_chrdev(MAJOR_NUM, "globalvar", &globalvar_fops);if (ret){printk("globalvar register failure");}else{printk("globalvar register success");init_MUTEX(&sem);init_waitqueue_head(&outq);}return ret;}static void __exit globalvar_exit(void)159{int ret;ret = unregister_chrdev(MAJOR_NUM, "globalvar");if (ret){printk("globalvar unregister failure");}else{printk("globalvar unregister success");}}static ssize_t globalvar_read(struct file *filp, char *buf, size_t len, loff_t*off){//等待數(shù)據(jù)可獲得if (wait_event_interruptible(outq, flag != 0)){return - ERESTARTSYS;}if (down_interruptible(&sem)){return - ERESTARTSYS;}flag = 0;if (copy_to_user(buf, &global_var, sizeof(int))){up(&sem);return - EFAULT;}up(&sem);return sizeof(int);}static ssize_t globalvar_write(struct file *filp, const char *buf, size_t len,loff_t *off){if (down_interruptible(&sem))160{return - ERESTARTSYS;}if (copy_from_user(&global_var, buf, sizeof(int))){up(&sem);return - EFAULT;}up(&sem);flag = 1;//通知數(shù)據(jù)可獲得wake_up_interruptible(&outq);return sizeof(int);}module_init(globalvar_init);module_exit(globalvar_exit);編寫兩個用戶態(tài)的程序來測試，第一個用于阻塞地讀/dev/globalvar，另一個用于寫/dev/globalvar。只有當后一個對/dev/globalvar 進行了輸入之后，前者的read 才能返回。讀的程序為：#include <sys/types.h>#include <sys/stat.h>#include <stdio.h>#include <fcntl.h>main(){int fd, num;fd = open("/dev/globalvar", O_RDWR, S_IRUSR | S_IWUSR);if (fd != - 1){while (1){read(fd, &num, sizeof(int)); //程序?qū)⒆枞诖苏Z句，除非有針對globalvar 的輸入printf("The globalvar is %d/n", num);//如果輸入是 0，則退出if (num == 0){close(fd);break;}}161}else{printf("device open failure/n");}}寫的程序為：#include <sys/types.h>#include <sys/stat.h>#include <stdio.h>#include <fcntl.h>main(){int fd, num;fd = open("/dev/globalvar", O_RDWR, S_IRUSR | S_IWUSR);if (fd != - 1){while (1){printf("Please input the globalvar:/n");scanf("%d", &num);write(fd, &num, sizeof(int));//如果輸入 0，退出if (num == 0){close(fd);break;}}}else{printf("device open failure/n");}}打開兩個終端，分別運行上述兩個應用程序，發(fā)現(xiàn)當在第二個終端中沒有輸入數(shù)據(jù)時，第一個終端沒有輸出（阻塞），每當我們在第二個終端中給 globalvar 輸入一個值，第一個終端就會輸出這個值，如下圖：關于上述例程，我們補充說一點，如果將驅(qū)動程序中的 read 函數(shù)改為：static ssize_t globalvar_read(struct file *filp, char *buf, size_t len, loff_t*off){//獲取信號量：可能阻塞162if (down_interruptible(&sem)){return - ERESTARTSYS;}//等待數(shù)據(jù)可獲得：可能阻塞if (wait_event_interruptible(outq, flag != 0)){return - ERESTARTSYS;}flag = 0;//臨界資源訪問if (copy_to_user(buf, &global_var, sizeof(int))){up(&sem);return - EFAULT;}//釋放信號量up(&sem);return sizeof(int);}即交換 wait_event_interruptible(outq, flag != 0)和down_interruptible(&sem)的順序，這個驅(qū)動程序?qū)⒆兊貌豢蛇\行。實際上，當兩個可能要阻塞的事件同時出現(xiàn)時，即兩個 wait_event 或 down擺在一起的時候，將變得非常危險，死鎖的可能性很大，這個時候我們要特別留意它們的出現(xiàn)順序。當然，我們應該盡可能地避免這種情況的發(fā)生！+還有一個與設備阻塞與非阻塞訪問息息相關的論題，即select 和poll，select 和poll 的本質(zhì)一樣，前者在BSD Unix 中引入，后者在System V 中引入。poll 和select 用于查詢設備的狀態(tài)，以便用戶程序獲知是否能對設備進行非阻塞的訪問，它們都需要設備驅(qū)動程序中的 poll 函數(shù)支持。驅(qū)動程序中 poll 函數(shù)中最主要用到的一個API 是poll_wait，其原型如下：void poll_wait(struct file *filp, wait_queue_heat_t *queue, poll_table * wait);poll_wait 函數(shù)所做的工作是把當前進程添加到wait 參數(shù)指定的等待列表（poll_table）中。下面我們給globalvar 的驅(qū)動添加一個poll 函數(shù)：static unsigned int globalvar_poll(struct file *filp, poll_table *wait){unsigned int mask = 0;poll_wait(filp, &outq, wait);//數(shù)據(jù)是否可獲得？if (flag != 0){163mask |= POLLIN | POLLRDNORM; //標示數(shù)據(jù)可獲得}return mask;}需要說明的是， poll_wait函數(shù)并不阻塞，程序中 poll_wait(filp, &outq, wait)這句話的意思并不是說一直等待 outq 信號量可獲得，真正的阻塞動作是上層的select/poll 函數(shù)中完成的。select/poll 會在一個循環(huán)中對每個需要監(jiān)聽的設備調(diào)用它們自己的 poll 支持函數(shù)以使得當前進程被加入各個設備的等待列表。若當前沒有任何被監(jiān)聽的設備就緒，則內(nèi)核進行調(diào)度（調(diào)用 schedule）讓出cpu 進入阻塞狀態(tài)，schedule 返回時將再次循環(huán)檢測是否有操作可以進行，如此反復；否則，若有任意一個設備就緒， select/poll 都立即返回。我們編寫一個用戶態(tài)應用程序來測試改寫后的驅(qū)動。程序中要用到 BSD Unix 中引入的select 函數(shù)，其原型為：int select(int numfds, fd_set *readfds, fd_set *writefds, fd_set *exceptfds, struct timeval*timeout);其中 readfds、writefds、exceptfds 分別是被select()監(jiān)視的讀、寫和異常處理的文件描述符集合，numfds的值是需要檢查的號碼最高的文件描述符加 1。timeout 參數(shù)是一個指向struct timeval 類型的指針，它可以使 select()在等待timeout 時間后若沒有文件描述符準備好則返回。struct timeval 數(shù)據(jù)結(jié)構為：struct timeval{int tv_sec; /* seconds */int tv_usec; /* microseconds */};除此之外，我們還將使用下列 API：FD_ZERO(fd_set *set)――清除一個文件描述符集；FD_SET(int fd,fd_set *set)――將一個文件描述符加入文件描述符集中；FD_CLR(int fd,fd_set *set)――將一個文件描述符從文件描述符集中清除；FD_ISSET(int fd,fd_set *set)――判斷文件描述符是否被置位。下面的用戶態(tài)測試程序等待/dev/globalvar 可讀，但是設置了5 秒的等待超時，若超過5 秒仍然沒有數(shù)據(jù)可讀，則輸出“No data within 5 seconds”：#include <sys/types.h>#include <sys/stat.h>#include <stdio.h>#include <fcntl.h>#include <sys/time.h>#include <sys/types.h>#include <unistd.h>main(){int fd, num;fd_set rfds;struct timeval tv;fd = open("/dev/globalvar", O_RDWR, S_IRUSR | S_IWUSR);if (fd != - 1)164{while (1){//查看 globalvar是否有輸入FD_ZERO(&rfds);FD_SET(fd, &rfds);//設置超時時間為 5stv.tv_sec = 5;tv.tv_usec = 0;select(fd + 1, &rfds, NULL, NULL, &tv);//數(shù)據(jù)是否可獲得？if (FD_ISSET(fd, &rfds)){read(fd, &num, sizeof(int));printf("The globalvar is %d/n", num);//輸入為 0，退出if (num == 0){close(fd);break;}}elseprintf("No data within 5 seconds./n");}}else{printf("device open failure/n");}}開兩個終端，分別運行程序：一個對 globalvar進行寫，一個用上述程序?qū)?globalvar進行讀。當我們在寫終端給 globalvar 輸入一個值后，讀終端立即就能輸出該值，當我們連續(xù)5 秒沒有輸入時，“No data within 5seconds”在讀終端被輸出.

上一篇：XMLTag詳解

下一篇：Effective Modern C++ 條款9補完理解模板類型推斷