跟大家分享一个EPCS16的C语言驱动程序.其它EPCS4,EPCS64,EPCS128都大同小异.

jianhong_wu

★坚鸿-深圳：
今天为了实现FPGA的在线升级程序，刚刚终于搞出来了。要实现这个功能，我采用的方案就要编写SPI通讯的EPCS16芯片的驱动程序，这个芯片是一个FLASH芯片，专门用来装FPGA程序。FPGA每次上电时就自动从这个外围的FLASH芯片中快速读取并加载程序到FPGA内部。现在我决定把这个EPCS16的C语言驱动程序分享给大家。其它EPCS4，EPCS64，EPCS128都大同小异。

Epcs16.h头文件：

1. #ifndef _EPCS16_
   
2. #define _EPCS16_
   
3. 
   
4. 
   
5. #define EPCS16_SPI_CS_ON()       GPIO_SetBits(GPIOF , GPIO_Pin_0)
   
6. #define EPCS16_SPI_CS_OFF()      GPIO_ResetBits(GPIOF , GPIO_Pin_0)
   
7. 
   
8. #define EPCS16_SPI_SCK_ON()      GPIO_SetBits(GPIOF , GPIO_Pin_1)
   
9. #define EPCS16_SPI_SCK_OFF()     GPIO_ResetBits(GPIOF , GPIO_Pin_1)
   
10. 
    
11. #define EPCS16_SPI_SI_ON()       GPIO_SetBits(GPIOF , GPIO_Pin_2)
    
12. #define EPCS16_SPI_SI_OFF()      GPIO_ResetBits(GPIOF , GPIO_Pin_2)
    
13. 
    
14. #define EPCS16_SPI_READ_SO()     GPIO_ReadInputDataBit(GPIOF,GPIO_Pin_3)
    
15. 
    
16. void Epcs16Initial(void);
    
17. void Epcs16SendByte(u8 u8SendData);
    
18. u8   Epcs16GetByte(void);
    
19. void Epcs16WriteDisable(void);
    
20. void Epcs16WriteEnable(void);
    
21. void Epcs16CheckBusy(u16 u16TimeOut);   //注意，这里用到定时中断的延时，每1ms定时中断一次的累计时间。
    
22. void Epcs16WriteStatus(u8 u8Epcs16Data);
    
23. void Epcs16WriteByte(u32 u32Epcs16Addr,u8 u8Epcs16Data);
    
24. u8   Epcs16ReadByte(u32 u32Epcs16Addr);
    
25. void Epcs16EraseSector(u32 u32Epcs16Addr);
    
26. void Epcs16EraseBulk(void);
    
27. 
    
28. 
    
29. 
    
30. 
    
31. 
    
32. 
    
33. #endif
    
34. 
    
35. 
    

复制代码

Epcs16.c源文件：

1. #include "stm32f4xx.h"
   
2. #include  "Epcs16.h"
   
3. #include "delay.h"
   
4. 
   
5. 
   
6. 
   
7. void Epcs16Initial(void)
   
8. {
   
9.           GPIO_InitTypeDef  GPIO_InitStructure;
   
10.           RCC_AHB1PeriphClockCmd( RCC_AHB1Periph_GPIOF, ENABLE);                                                  
    
11.        
    
12.           GPIO_InitStructure.GPIO_Pin = GPIO_Pin_0 | GPIO_Pin_1 | GPIO_Pin_2 ;
    
13.           GPIO_InitStructure.GPIO_Mode = GPIO_Mode_OUT;
    
14.           GPIO_InitStructure.GPIO_Speed = GPIO_Speed_100MHz;
    
15.           GPIO_Init(GPIOF, &GPIO_InitStructure);
    
16.        
    
17.           GPIO_InitStructure.GPIO_Pin = GPIO_Pin_3;
    
18.           GPIO_InitStructure.GPIO_Speed = GPIO_Speed_100MHz;
    
19.           GPIO_InitStructure.GPIO_Mode = GPIO_Mode_IN;
    
20.           GPIO_InitStructure.GPIO_PuPd  = GPIO_PuPd_UP;
    
21.           GPIO_Init(GPIOF, &GPIO_InitStructure);       
    
22.        
    
23. 
    
24.        
    
25.     EPCS16_SPI_CS_ON();
    
26. 
    
27. }
    
28. 
    
29. 
    
30. void Epcs16SendByte(u8 u8SendData)
    
31. {
    
32.         u8 i=0;
    
33. 
    
34.         for(i=0;i<8;i++)                  //8位数据串行输出
    
35.         {
    
36. 
    
37.     EPCS16_SPI_SCK_OFF();
    
38.                 if(u8SendData&0x80)
    
39.                 {
    
40.         EPCS16_SPI_SI_ON();
    
41.                 }
    
42.                 else
    
43.                 {
    
44.         EPCS16_SPI_SI_OFF();
    
45.                 }
    
46.     u8Delay(1);
    
47.                 u8SendData=u8SendData<<1;       
    
48.     EPCS16_SPI_SCK_ON();
    
49.     u8Delay(1);
    
50.         }
    
51. }
    
52. 
    
53. u8 Epcs16GetByte(void)
    
54. {
    
55.         u8 u8GetData;
    
56.         u8 i;
    
57.        
    
58.         for(i=0;i<8;i++)
    
59.         {
    
60. 
    
61.     EPCS16_SPI_SCK_OFF();
    
62.     u8Delay(1);
    
63.                 u8GetData=u8GetData<<1;
    
64.     EPCS16_SPI_SCK_ON();
    
65.     u8Delay(1);
    
66.                 if(0!=EPCS16_SPI_READ_SO())                 //如果存储器输出高电平
    
67.                 {
    
68.                    u8GetData=u8GetData|0x01;
    
69.                 }
    
70. 
    
71.         }
    
72.         return u8GetData;                         
    
73. }
    
74. 
    
75. 
    
76. void Epcs16WriteDisable(void)
    
77. {
    
78.                 EPCS16_SPI_CS_OFF();
    
79.                 Epcs16SendByte(0x04);                 // 设置禁止写使能锁存
    
80.                 EPCS16_SPI_CS_ON();
    
81. 
    
82. }
    
83. 
    
84. void Epcs16WriteEnable(void)
    
85. {
    
86.                 EPCS16_SPI_CS_OFF();
    
87.                 Epcs16SendByte(0x06);                 // 设置写使能锁存
    
88.                 EPCS16_SPI_CS_ON();
    
89. }
    
90. 
    
91. void Epcs16CheckBusy(u16 u16TimeOut) //注意，这里用到定时中断的延时，每1ms定时中断一次的累计时间。
    
92. {
    
93. 
    
94.         u8 u8ReadStatusData;
    
95.        
    
96.         Gu8DelayTimerFlag=0;  //注意，这里用到定时中断的延时，每1ms定时中断一次的累计时间。
    
97.   Gu16DelayTimerCnt=u16TimeOut; //注意，这里用到定时中断的延时，每1ms定时中断一次的累计时间。
    
98.         Gu8DelayTimerFlag=1; //注意，这里用到定时中断的延时，每1ms定时中断一次的累计时间。
    
99.        
    
100.         while(1)
     
101.         {
     
102.                 if(0==Gu16DelayTimerCnt)  //注意，这里用到定时中断的延时，每1ms定时中断一次的累计时间。
     
103.                 {
     
104.                    break;
     
105.                 }
     
106.                
     
107.                 EPCS16_SPI_CS_OFF();
     
108.                 Epcs16SendByte(0x05);    //获取存储器的状态
     
109.                 u8ReadStatusData=Epcs16GetByte();
     
110.           EPCS16_SPI_CS_ON();
     
111. 
     
112.                
     
113.                 if(0==(u8ReadStatusData&0x01))         //如果读出的最低位为1则表示存储器还在存储，此时单片机等待，知道存储完毕
     
114.                 {
     
115.                         break;
     
116.                 }
     
117. 
     
118.         }
     
119.        
     
120.         EPCS16_SPI_CS_ON();
     
121. }
     
122. 
     
123. void Epcs16WriteStatus(u8 u8Epcs16Data)
     
124. {
     
125. 
     
126.        
     
127.   Epcs16WriteEnable();
     
128.        
     
129.         EPCS16_SPI_CS_OFF();
     
130.         Epcs16SendByte(0x01);                 // 设置写状态指令
     
131.         Epcs16SendByte(u8Epcs16Data);                 // 设置写状态数据
     
132.         EPCS16_SPI_CS_ON();
     
133.   Epcs16CheckBusy(15);
     
134. 
     
135. }
     
136. 
     
137. 
     
138. 
     
139. void Epcs16WriteByte(u32 u32Epcs16Addr,u8 u8Epcs16Data)
     
140. {
     
141. 
     
142.         u8 u8Addr=0;
     
143.        
     
144.   Epcs16WriteEnable();
     
145.        
     
146.         EPCS16_SPI_CS_OFF();
     
147.         Epcs16SendByte(0x02);                //发送写数据指令
     
148. 
     
149.         u8Addr=u32Epcs16Addr>>16;
     
150.         Epcs16SendByte(u8Addr);                        //写入存储数据的地址
     
151.         u8Addr=u32Epcs16Addr>>8;
     
152.         Epcs16SendByte(u8Addr);                        //写入存储数据的地址
     
153.         u8Addr=u32Epcs16Addr;
     
154.         Epcs16SendByte(u8Addr);                        //写入存储数据的地址
     
155.        
     
156.         Epcs16SendByte(u8Epcs16Data);                        //写入待存储的数据
     
157.        
     
158.         EPCS16_SPI_CS_ON();
     
159.   Epcs16CheckBusy(5);
     
160. }
     
161. 
     
162. 
     
163. u8 Epcs16ReadByte(u32 u32Epcs16Addr)
     
164. {
     
165.         u8 u8ReadData=0;
     
166.         u8 u8Addr;
     
167.        
     
168.         EPCS16_SPI_CS_OFF();
     
169.         Epcs16SendByte(0x03);                //首先向存储器发送读数据指令
     
170. 
     
171.         u8Addr=u32Epcs16Addr>>16;
     
172.         Epcs16SendByte(u8Addr);                        //写入存储数据的地址
     
173.         u8Addr=u32Epcs16Addr>>8;
     
174.         Epcs16SendByte(u8Addr);                        //写入存储数据的地址
     
175.         u8Addr=u32Epcs16Addr;
     
176.         Epcs16SendByte(u8Addr);                        //写入存储数据的地址
     
177.        
     
178.         u8ReadData=Epcs16GetByte();                   //读出数据
     
179.        
     
180.         EPCS16_SPI_CS_ON();
     
181. 
     
182.         return u8ReadData;
     
183. }
     
184. 
     
185. void Epcs16EraseSector(u32 u32Epcs16Addr)
     
186. {
     
187. 
     
188.         u8 u8Addr;
     
189. 
     
190.   Epcs16WriteStatus(0x02);
     
191.        
     
192.   Epcs16WriteEnable();
     
193.        
     
194.         EPCS16_SPI_CS_OFF();
     
195. 
     
196.        
     
197.         Epcs16SendByte(0xD8);                //首先向存储器发送擦除扇区指令
     
198. 
     
199.         u8Addr=u32Epcs16Addr>>16;
     
200.         Epcs16SendByte(u8Addr);                        //写入存储数据的地址
     
201.         u8Addr=u32Epcs16Addr>>8;
     
202.         Epcs16SendByte(u8Addr);                        //写入存储数据的地址
     
203.         u8Addr=u32Epcs16Addr;
     
204.         Epcs16SendByte(u8Addr);                        //写入存储数据的地址
     
205.        
     
206.         EPCS16_SPI_CS_ON();
     
207.   Epcs16CheckBusy(3000);
     
208.        
     
209. 
     
210. }
     
211. 
     
212. 
     
213. void Epcs16EraseBulk(void)
     
214. {
     
215. 
     
216.   Epcs16WriteStatus(0x02);
     
217. 
     
218.   Epcs16WriteEnable();
     
219.        
     
220.         EPCS16_SPI_CS_OFF();
     
221. 
     
222.        
     
223.         Epcs16SendByte(0xC7);                //首先向存储器发送擦除整片指令
     
224. 
     
225. 
     
226.         EPCS16_SPI_CS_ON();
     
227.   Epcs16CheckBusy(40000);
     
228.        
     
229. 
     
230. }
     
231. 
     
232. 
     
233. 
     
234. 
     
235. 
     

复制代码