对S3C2440裸板程序设计（无操作系统）的抽象

在嵌入式领域中，几乎所有的设备控制和各种协议控制都在同一个嵌入式CPU当中，非常有利于对CPU Core和设备进行抽象。如果能对CPU Core和设备的各种控制进行抽象，人们在移植OS或者开发驱动程序时就没有必要对CPU进行非常深入的了解，不必要了解某个寄存器的某个位是控制什么的，也没有必要了解怎样初始化某个控制寄存器等等。

在利用控制器编写裸板应用程序时，编程人员只需要了解该控制器的初始化顺序以及初始化的内容而不需要了解初始化的具体细节就能完成应用程序。显然可以大大的提高工作效率，并且对于硬件的具体细节设置是在应用程序中最容易出错的地方，而利用控制器则可以大大的减少出错的可能性。

ARM是功能更加强大的单片机，在学习裸机程序设计的过程中，发现ARM比一般的单片机集成了更多的外设(一般的单片机只集成了串口，还有四组IO端口)，包含更多的GPIO，有更多的寄存器，通过寄存器的设置和启用来控制相关引脚，从而控制相关设备。S3C2440内部集成了硬件控制器，各种驱动协议用硬件控制器产生，我们只需配置对应硬件控制器的寄存器即可产生相应的驱动时序。 高端ARM学习以软件编程为主（即理解为主），其资源丰富，很少需要需要扩展外设，学习重点在于如何配置寄存器以及如何编写应用程序。

下面以S3C2440的I2C控制器为例来讲解。下面的程序是基于中断模式，I2C协议的讲解可以查看我以前的博客。I2C协议中规定：接收器接收到一个字节（地址或数据）后，要发送一个ACK，发送器接收到ACK后可以接着发送数据或结束数据传输。接收器（这里我们是S3C2440的I2C控制器）收到ACK后会产生一个中断，在中断处理程序中可以继续发送程序或者结束传输。理解了I2C协议的基本原理，编写程序就水到渠成。

1. //===================================================================   
2. //       SMDK2440 IIC configuration   
3. //  GPE15=IICSDA, GPE14=IICSCL   
4. //  "Interrupt mode" for IIC block   
5. //===================================================================    
6.   
7. //******************[ Test_Iic ]**************************************   
8. void Test_Iic(void)  
9. {  
10.     unsigned int i,j,save_E,save_PE;  
11.     static U8 data[256];  
12.   
13.     Uart_Printf("\nIIC Test(Interrupt) using AT24C08\n");  
14.   
15.     save_E   = rGPECON;                 //保存以前的值   
16.     rGPECON |= 0xa00000;                //GPE15:IICSDA , GPE14:IICSCL    
17.   
18.     pISR_IIC = (unsigned)IicInt;        //设置中断处理函数   
19.     rINTMSK &= ~(BIT_IIC);              //打开IIC中断   
20.   
21.       //Enable ACK, Prescaler IICCLK=PCLK/16, Enable interrupt, Transmit clock value Tx clock=IICCLK/16   
22.       // If PCLK 50.7MHz, IICCLK = 3.17MHz, Tx Clock = 0.198MHz   
23.     rIICCON = (1<<7) | (0<<6) | (1<<5) | (0xf);//第四位为1，SCL线被拉低，传输被中断   
24.   
25.     rIICADD  = 0x10;                    //2440 slave address = [7:1]   
26.     rIICSTAT = 0x10;                    //IIC bus data output enable(Rx/Tx)使能接收/发送功能   
27.     rIICLC = (1<<2)|(1);               // Filter enable, 15 clocks SDA output delay       added by junon   
28.       
29.     Uart_Printf("Write test data into AT24C08\n");  
30.   
31.     for(i=0;i<256;i++)  
32.         Wr24C080(0xa0,(U8)i,i);  
33.              
34.     for(i=0;i<256;i++)  
35.         data[i] = 0;  
36.   
37.     Uart_Printf("Read test data from AT24C08\n");  
38.       
39.     for(i=0;i<256;i++)  
40.         Rd24C080(0xa0,(U8)i,&(data[i]));   
41.   
42.         //Line changed 0 ~ f   
43.     for(i=0;i<16;i++)  
44.     {  
45.         for(j=0;j<16;j++)  
46.             Uart_Printf("%2x ",data[i*16+j]);  
47.         Uart_Printf("\n");  
48.     }  
49.     rINTMSK |= BIT_IIC;      
50.     rGPECON = save_E;  
51. }  
52.   
53.   
54. //*************************[ Wr24C080 ]****************************   
55. void Wr24C080(U32 slvAddr,U32 addr,U8 data)  
56. {  
57.     _iicMode      = WRDATA;  
58.     _iicPt        = 0;  
59.     _iicData[0]   = (U8)addr;  
60.     _iicData[1]   = data;  
61.     _iicDataCount = 2;  
62.       
63.     rIICDS   = slvAddr;                 //0xa0   
64.     rIICSTAT = 0xf0;                    //MasTx,Start主机发送器 发出S信号   
65.       //Clearing the pending bit isn't needed because the pending bit has been cleared.   
66.       
67.     while(_iicDataCount!=-1);//等待数据数据发送完毕www.linuxidc.com   
68.   
69.   
70.   
71.   
72. //开始一次新的传输，不过只发送设备地址，等待应答，以证明上次传输完成。而下次Wr24C080的时候会重新开始，这次的传输并没有写入数据   
73.     _iicMode = POLLACK;  
74.   
75.     while(1)  
76.     {  
77.         rIICDS     = slvAddr;  
78.         _iicStatus = 0x100;  
79.         rIICSTAT   = 0xf0;              //MasTx,Start   
80.         rIICCON    = 0xaf;              //Resumes IIC operation.    
81.              
82.         while(_iicStatus==0x100)    ;//等待数据数据发送完毕，状态寄存器改变了就可以了   
83.              
84.         if(!(_iicStatus&0x1))     //接收到的最后一位为0 (接收到ACK信号)   
85.             break;           //When ACK is received  判断最后一位的状态   
86.     }  
87.     rIICSTAT = 0xd0;                    //Stop MasTx condition    
88.     rIICCON  = 0xaf;                    //Resumes IIC operation.    
89.     Delay(1);                           //Wait until stop condtion is in effect.   
90.        //Write is completed.   
91. }  
92.           
93. //**********************[ Rd24C080 ] ***********************************   
94. void Rd24C080(U32 slvAddr,U32 addr,U8 *data)  
95. {  
96.     _iicMode      = SETRDADDR;  
97.     _iicPt        = 0;  
98.     _iicData[0]   = (U8)addr;  
99.     _iicDataCount = 1;  
100.   
101.     rIICDS   = slvAddr;  
102.     rIICSTAT = 0xf0;                    //MasTx,Start     
103.       //Clearing the pending bit isn't needed because the pending bit has been cleared.   
104.     while(_iicDataCount!=-1);  
105.   
106.     _iicMode      = RDDATA;  
107.     _iicPt        = 0;  
108.     _iicDataCount = 1;  
109.       
110.     rIICDS        = slvAddr;  
111.     rIICSTAT      = 0xb0;               //MasRx,Start   
112.     rIICCON       = 0xaf;               //Resumes IIC operation.      
113.     while(_iicDataCount!=-1);  
114.   
115.     *data = _iicData[1];  
116. }  
117.   
118.   
119. //-------------------------------------------------------------------------   
120. void __irq IicInt(void)  
121. {  
122.     U32 iicSt,i;  
123.       
124.     rSRCPND = BIT_IIC;          //Clear pending bit   
125.     rINTPND = BIT_IIC;  
126.     iicSt   = rIICSTAT;   
127.       
128.     if(iicSt & 0x8){}           //When bus arbitration is failed.   
129.     if(iicSt & 0x4){}           //When a slave address is matched with IICADD   
130.     if(iicSt & 0x2){}           //When a slave address is 0000000b   
131.     if(iicSt & 0x1){}           //When ACK isn't received   
132.   
133.     switch(_iicMode)  
134.     {  
135.        case POLLACK:  
136.            _iicStatus = iicSt;  
137.            break;  
138.   
139.        case RDDATA:  
140.            if((_iicDataCount--)==0)  
141.            {  
142.                _iicData[_iicPt++] = rIICDS;  
143.               
144.                rIICSTAT = 0x90;                 //Stop MasRx condition    
145.                rIICCON  = 0xaf;                 //Resumes IIC operation.   
146.                Delay(1);                        //Wait until stop condtion is in effect.   
147.                                                 //Too long time...    
148.                                                 //The pending bit will not be set after issuing stop condition.   
149.                break;      
150.            }        
151.            _iicData[_iicPt++] = rIICDS;         //The last data has to be read with no ack.   
152.   
153.            if((_iicDataCount)==0)  
154.                rIICCON = 0x2f;                  //Resumes IIC operation with NOACK.     
155.            else   
156.                rIICCON = 0xaf;                  //Resumes IIC operation with ACK   
157.                break;  
158.   
159.         case WRDATA:  
160.             if((_iicDataCount--)==0)  
161.             {  
162.                 rIICSTAT = 0xd0;                //Stop MasTx condition    
163.                 rIICCON  = 0xaf;                //Resumes IIC operation.   
164.                 Delay(1);                       //Wait until stop condtion is in effect.   
165.                        //The pending bit will not be set after issuing stop condition.   
166.                 break;      
167.             }  
168.             rIICDS = _iicData[_iicPt++];        //_iicData[0] has dummy.   
169.             for(i=0;i<10;i++);                  //for setup time until rising edge of IICSCL   
170.                 
171.             rIICCON = 0xaf;                     //resumes IIC operation.   
172.             break;  
173.   
174.         case SETRDADDR:  
175. //          Uart_Printf("[ S%d ]",_iicDataCount);   
176.             if((_iicDataCount--)==0)  
177.                 break;                          //IIC operation is stopped because of IICCON[4]       
178.             rIICDS = _iicData[_iicPt++];  
179.             for(i=0;i<10;i++);                  //For setup time until rising edge of IICSCL   
180.             rIICCON = 0xaf;                     //Resumes IIC operation.   
181.             break;  
182.   
183.         default:  
184.             break;        
185.     }  
186. }