国产免费AV|泡泡玛特欧洲总部将设在伦敦|中文天堂网www新版资源在线|一本久道综合在线中文|国精产品一二三产区的使用方法|香蕉鱼在线观看|www.27eee

<b id="auyfc"><address id="auyfc"><source id="auyfc"></source></address></b>

<tr id="auyfc"><output id="auyfc"><pre id="auyfc"></pre></output></tr>

<b id="auyfc"><output id="auyfc"><pre id="auyfc"></pre></output></b>

<div id="auyfc"><acronym id="auyfc"></acronym></div>

ELEOK

標題: stm32f407硬件spi讀寫sst25vf閃存flash代碼 [打印本頁]

---

作者: coolice    時間: 2021-8-13 23:49
標題: stm32f407硬件spi讀寫sst25vf閃存flash代碼

1. #ifndef __SPI_FLASH_H
   
2. #define __SPI_FLASH_H
   
3. 
   
4. /* Includes ------------------------------------------------------------------*/
   
5. #include "stm324xg_eval.h"
   
6. 
   
7. 
   
8. /* Private typedef -----------------------------------------------------------*/
   
9. #define SPI_FLASH_PageSize    0x100
   
10. 
    
11. /* Private define ------------------------------------------------------------*/
    
12. #define WRITE      0x02  /* Write to Memory instruction */
    
13. #define WRSR       0x01  /* Write Status Register instruction */
    
14. #define WREN       0x06  /* Write enable instruction */
    
15. #define WRDI       0x04  /* Write disable instruction */
    
16. 
    
17. #define READ       0x03  /* Read from Memory instruction */
    
18. #define RDSR       0x05  /* Read Status Register instruction  */
    
19. #define RDID       0x9F  /* Read identification */
    
20. #define SE         0xD8  /* Sector Erase instruction */
    
21. #define BE         0xC7  /* Bulk Erase instruction */
    
22. #define CE         0x60  /* Chip Erase instruction */
    
23. #define EWSR       0x50  /* Enable Write Status Register instruction */
    
24. 
    
25. #define WIP_Flag   0x01  /* Write In Progress (WIP) flag */
    
26. 
    
27. #define Dummy_Byte 0xA5
    
28. 
    
29. #define countof(a) (sizeof(a) / sizeof(*(a)))
    
30. /*for M25P64 SERIAL FLASH---------------------------------------------------*/
    
31. #define  FLASH_WriteAddress     0x700000
    
32. #define  FLASH_ReadAddress      FLASH_WriteAddress
    
33. #define  FLASH_SectorToErase    FLASH_WriteAddress
    
34. #define  M25P64_FLASH_ID        0x202017
    
35. #define  BufferSize (countof(Tx_Buffer)-1)
    
36. 
    
37. #define FLASH_SPI                       SPI1
    
38. #define FLASH_SPI_CLK                   RCC_APB2Periph_SPI1
    
39. 
    
40. #define FLASH_SPI_SCK_PIN               GPIO_Pin_5                  /* PA.05 */
    
41. #define FLASH_SPI_SCK_GPIO_PORT         GPIOA                       /* GPIOA */
    
42. #define FLASH_SPI_SCK_GPIO_CLK          RCC_AHB1Periph_GPIOA
    
43. #define FLASH_SPI_SCK_SOURCE            GPIO_PinSource5
    
44. #define FLASH_SPI_SCK_AF                GPIO_AF_SPI1
    
45. 
    
46. #define FLASH_SPI_MISO_PIN              GPIO_Pin_6                  
    
47. #define FLASH_SPI_MISO_GPIO_PORT        GPIOA                     
    
48. #define FLASH_SPI_MISO_GPIO_CLK         RCC_AHB1Periph_GPIOA
    
49. #define FLASH_SPI_MISO_SOURCE           GPIO_PinSource6
    
50. #define FLASH_SPI_MISO_AF               GPIO_AF_SPI1
    
51. 
    
52. #define FLASH_SPI_MOSI_PIN              GPIO_Pin_5                  /* PB.5 */
    
53. #define FLASH_SPI_MOSI_GPIO_PORT        GPIOB                       /* GPIOB */
    
54. #define FLASH_SPI_MOSI_GPIO_CLK         RCC_AHB1Periph_GPIOB
    
55. #define FLASH_SPI_MOSI_SOURCE           GPIO_PinSource5
    
56. #define FLASH_SPI_MOSI_AF               GPIO_AF_SPI1
    
57. 
    
58. #define FLASH_SPI_CS_PIN                GPIO_Pin_7/* PB.00 */
    
59. #define FLASH_SPI_CS_GPIO_PORT          GPIOE                       /* GPIOB */
    
60. #define FLASH_SPI_CS_GPIO_CLK           RCC_AHB1Periph_GPIOE
    
61. 
    
62. #define FLASH_SPI_157_PIN                GPIO_Pin_1                  /* PB.01 */
    
63. #define FLASH_SPI_157_GPIO_PORT          GPIOB                       /* GPIOB */
    
64. #define FLASH_SPI_157_GPIO_CLK           RCC_AHB1Periph_GPIOB
    
65. 
    
66. /* Exported macro ------------------------------------------------------------*/
    
67. /* Select SPI FLASH: Chip Select pin low  */
    
68. #define SPI_FLASH_CS_LOW()       GPIO_ResetBits(FLASH_SPI_CS_GPIO_PORT, FLASH_SPI_CS_PIN)
    
69. /* Deselect SPI FLASH: Chip Select pin high */
    
70. #define SPI_FLASH_CS_HIGH()      GPIO_SetBits(FLASH_SPI_CS_GPIO_PORT, FLASH_SPI_CS_PIN)
    
71. 
    
72. #define SPI_FLASH_157_EN()    GPIO_ResetBits(FLASH_SPI_157_GPIO_PORT, FLASH_SPI_157_PIN) //高選通
    
73. #define SPI_FLASH_157_DIS()     GPIO_SetBits(FLASH_SPI_157_GPIO_PORT, FLASH_SPI_157_PIN)
    
74. 
    
75. /* Exported functions ------------------------------------------------------- */
    
76. /*----- High layer function -----*/
    
77. 
    
78. #define TIME_PAGE_PROGRAME                        3//5MS
    
79. #define TIME_BULK_ERASE                                200//100000//160S
    
80. extern uint64_t        flash_wait;
    
81. 
    
82. void SPI_FLASH_Init(void);
    
83. //void SPI_FLASH_SectorErase(u32 SectorAddr);
    
84. //void SPI_FLASH_BulkErase(void);
    
85. //void SPI_FLASH_PageWrite(u8* pBuffer, u32 WriteAddr, u16 NumByteToWrite);
    
86. //void SPI_FLASH_BufferWrite(u8* pBuffer, u32 WriteAddr, u16 NumByteToWrite);
    
87. //void SPI_FLASH_BufferRead(u8* pBuffer, u32 ReadAddr, u16 NumByteToRead);
    
88. //u32 SPI_FLASH_ReadID(void);
    
89. //void SPI_FLASH_StartReadSequence(u32 ReadAddr);
    
90. 
    
91. /*----- Low layer function -----*/
    
92. //u8 SPI_FLASH_ReadByte(void);
    
93. u8 SPI_FLASH_SendByte(u8 byte);
    
94. //u16 SPI_FLASH_SendHalfWord(u16 HalfWord);
    
95. void SPI_FLASH_WriteEnable();
    
96. void SPI_FLASH_WriteDisable();
    
97. void SPI_FLASH_WaitForWriteEnd();
    
98. void SPI_FLASH_Wait(uint64_t time);
    
99. 
    
100. //void SPI_FLASH_ByteWrite(u32 WriteAddr);
     
101. //u8 SPI_FLASH_ByteRead(u32 ReadAddr);
     
102. u32 SPI_FLASH_Read_ID();
     
103. u32 SPI_FLASH_ReadID();
     
104. void SPI_FLASH_ChipErase();
     
105. //void SPI_FLASH_4KByteErase(u32 SectorAddr);
     
106. void SPI_FLASH_PageWrite(unsigned int Addr, unsigned char *buf, unsigned int num);
     
107. 
     
108. 
     
109. void SPI_FLASH_PageWriteEnd(unsigned int Addr, unsigned char *buf, unsigned int num);
     
110. void SPI_FLASH_PageRead(unsigned int Addr,unsigned char *buf);
     
111. void SPI_FLASH_Writebyte(unsigned int Addr, unsigned char *buf);
     
112. void SPI_FLASH_Readnbyte(unsigned int Addr,unsigned char *buf,u16 num);
     
113. void SPI_FLASH_Writenbyte(unsigned int Addr, unsigned char *buf,u16 num);
     
114. #endif /* __SPI_FLASH_H */

復制代碼

1. /************************************************************
   
2.   Description:    FPGA和FLI32626的Flash操作      
   
3.   Version:        Flash使用ssT25VF032B
   
4.   Function List:  適用于stm32f4  自帶硬件spi
   
5.     1. -------
   
6.   History:         
   
7.       <author>          <time>     <version >   <desc>
   
8.       lide           2012.5.22      1.0      創(chuàng)建模塊  
   
9. ***********************************************************/
   
10. 
    
11. /* Includes ------------------------------------------------------------------*/
    
12. #include "spi_flash.h"
    
13. #include "stm32_delay.h"
    
14. 
    
15. //#define SPI1DMA_RX 0
    
16. uint64_t        flash_wait = 0;
    
17. extern unsigned char time_is_up;
    
18. /*******************************************************************************
    
19. * Function Name  : SPI_FLASH_Init
    
20. * Description    : Initializes the peripherals used by the SPI FLASH driver.
    
21. * Input          : None
    
22. * Output         : None
    
23. * Return         : None
    
24. *******************************************************************************/
    
25. void delay_nus(unsigned short n)
    
26. {
    
27.     unsigned char i;
    
28.    
    
29.     while(n--)
    
30.     {
    
31.         for(i=0;i<26;i++);              //i=26 剛好1us
    
32.     }
    
33. }
    
34. 
    
35. void SPI_FLASH_Init(void)
    
36. {
    
37.     GPIO_InitTypeDef GPIO_InitStructure;
    
38.     SPI_InitTypeDef  SPI_InitStructure;
    
39.     NVIC_InitTypeDef   NVIC_InitStructure;
    
40. 
    
41.     /* Enable the SPI periph */
    
42.     RCC_APB2PeriphClockCmd(FLASH_SPI_CLK, ENABLE);
    
43. 
    
44.     /* Enable SCK, MOSI and MISO GPIO clocks */
    
45.     RCC_AHB1PeriphClockCmd(FLASH_SPI_SCK_GPIO_CLK | FLASH_SPI_MOSI_GPIO_CLK | FLASH_SPI_MISO_GPIO_CLK, ENABLE);//FLASH_SPI_MISO_GPIO_CLK
    
46. 
    
47.     /* Enable CS  GPIO clock */
    
48.     RCC_AHB1PeriphClockCmd(FLASH_SPI_CS_GPIO_CLK, ENABLE);
    
49.    
    
50.     /* Enable 157  GPIO clock */
    
51.     RCC_AHB1PeriphClockCmd(FLASH_SPI_157_GPIO_CLK, ENABLE);
    
52.    
    
53. 
    
54.     GPIO_PinAFConfig(FLASH_SPI_SCK_GPIO_PORT, FLASH_SPI_SCK_SOURCE, FLASH_SPI_SCK_AF);
    
55.     GPIO_PinAFConfig(FLASH_SPI_MISO_GPIO_PORT, FLASH_SPI_MISO_SOURCE, FLASH_SPI_MISO_AF);
    
56.     GPIO_PinAFConfig(FLASH_SPI_MOSI_GPIO_PORT, FLASH_SPI_MOSI_SOURCE, FLASH_SPI_MOSI_AF);
    
57. 
    
58.     GPIO_InitStructure.GPIO_Mode = GPIO_Mode_AF;
    
59.     GPIO_InitStructure.GPIO_OType = GPIO_OType_PP;
    
60.     GPIO_InitStructure.GPIO_PuPd  = GPIO_PuPd_DOWN;
    
61.     GPIO_InitStructure.GPIO_Speed = GPIO_Speed_50MHz;
    
62. 
    
63.     /* SPI SCK pin configuration */
    
64.     GPIO_InitStructure.GPIO_Pin = FLASH_SPI_SCK_PIN;
    
65.     GPIO_Init(FLASH_SPI_SCK_GPIO_PORT, &GPIO_InitStructure);
    
66. 
    
67.     /* SPI  MOSI pin configuration */
    
68.     GPIO_InitStructure.GPIO_Pin =  FLASH_SPI_MOSI_PIN;
    
69.     GPIO_Init(FLASH_SPI_MOSI_GPIO_PORT, &GPIO_InitStructure);
    
70. 
    
71.     /* SPI MISO pin configuration */
    
72.     GPIO_InitStructure.GPIO_Pin = FLASH_SPI_MISO_PIN;
    
73.     GPIO_Init(FLASH_SPI_MISO_GPIO_PORT, &GPIO_InitStructure);
    
74. 
    
75. 
    
76.     /* Configure GPIO PIN for Lis Chip select */
    
77.     GPIO_InitStructure.GPIO_Pin = FLASH_SPI_CS_PIN;
    
78.     GPIO_InitStructure.GPIO_Mode = GPIO_Mode_OUT;
    
79.     GPIO_InitStructure.GPIO_OType = GPIO_OType_PP;
    
80.     GPIO_InitStructure.GPIO_Speed = GPIO_Speed_50MHz;
    
81.     GPIO_Init(FLASH_SPI_CS_GPIO_PORT, &GPIO_InitStructure);
    
82.    
    
83.     SPI_FLASH_CS_HIGH();
    
84. 
    
85.   /* Configure GPIO PIN for 157 */
    
86.     GPIO_InitStructure.GPIO_Pin = FLASH_SPI_157_PIN;
    
87.     GPIO_InitStructure.GPIO_Mode = GPIO_Mode_OUT;
    
88.     GPIO_InitStructure.GPIO_OType = GPIO_OType_PP;
    
89.     GPIO_InitStructure.GPIO_Speed = GPIO_Speed_50MHz;
    
90.     GPIO_Init(FLASH_SPI_157_GPIO_PORT, &GPIO_InitStructure);
    
91. 
    
92.     /* SPI1 configuration */
    
93.     SPI_InitStructure.SPI_Direction = SPI_Direction_2Lines_FullDuplex;
    
94.     SPI_InitStructure.SPI_Mode = SPI_Mode_Master;
    
95.     SPI_InitStructure.SPI_DataSize = SPI_DataSize_8b;
    
96.     SPI_InitStructure.SPI_CPOL = SPI_CPOL_High;
    
97.     SPI_InitStructure.SPI_CPHA = SPI_CPHA_2Edge;
    
98.     SPI_InitStructure.SPI_NSS = SPI_NSS_Soft;
    
99.     SPI_InitStructure.SPI_BaudRatePrescaler = SPI_BaudRatePrescaler_4;
    
100.     SPI_InitStructure.SPI_FirstBit = SPI_FirstBit_MSB;
     
101.     SPI_InitStructure.SPI_CRCPolynomial = 7;
     
102.     SPI_Init(FLASH_SPI, &SPI_InitStructure);
     
103. 
     
104.     /* Enable SPI1  */
     
105.     SPI_Cmd(FLASH_SPI, ENABLE);
     
106.     SPI_FLASH_157_DIS();
     
107.    
     
108.     //SPI_DMAInit();
     
109.     /* I2S DMA IRQ Channel configuration */
     
110.    /* NVIC_InitStructure.NVIC_IRQChannel = SPI1_DMA_RX_IRQn;
     
111.     NVIC_InitStructure.NVIC_IRQChannelPreemptionPriority = 0;
     
112.     NVIC_InitStructure.NVIC_IRQChannelSubPriority = 0;
     
113.     NVIC_InitStructure.NVIC_IRQChannelCmd = ENABLE;
     
114.     NVIC_Init(&NVIC_InitStructure);
     
115.    
     
116.     NVIC_InitStructure.NVIC_IRQChannel = SPI1_DMA_TX_IRQn;
     
117.     NVIC_Init(&NVIC_InitStructure);
     
118.     Delay_Init(168);*/
     
119. 
     
120. }
     
121. 
     
122. /*******************************************************************************
     
123. * Function Name  : SPI_FLASH_SectorErase
     
124. * Description    : Erases the specified FLASH sector.
     
125. * Input          : SectorAddr: address of the sector to erase.
     
126. * Output         : None
     
127. * Return         : None
     
128. *******************************************************************************/
     
129. //void SPI_FLASH_SectorErase(u32 SectorAddr)
     
130. //{
     
131. //  /* Send write enable instruction */
     
132. //  SPI_FLASH_WriteEnable();
     
133. //
     
134. //  /* Sector Erase */
     
135. //  /* Select the FLASH: Chip Select low */
     
136. //  SPI_FLASH_CS_LOW();
     
137. //  /* Send Sector Erase instruction */
     
138. //  SPI_FLASH_SendByte(SE);
     
139. //  /* Send SectorAddr high nibble address byte */
     
140. //  SPI_FLASH_SendByte((SectorAddr & 0xFF0000) >> 16);
     
141. //  /* Send SectorAddr medium nibble address byte */
     
142. //  SPI_FLASH_SendByte((SectorAddr & 0xFF00) >> 8);
     
143. //  /* Send SectorAddr low nibble address byte */
     
144. //  SPI_FLASH_SendByte(SectorAddr & 0xFF);
     
145. //  /* Deselect the FLASH: Chip Select high */
     
146. //  SPI_FLASH_CS_HIGH();
     
147. //
     
148. //  /* Wait the end of Flash writing */
     
149. //  SPI_FLASH_WaitForWriteEnd();
     
150. //}
     
151. 
     
152. /*******************************************************************************
     
153. * Function Name  : SPI_FLASH_BulkErase
     
154. * Description    : Erases the entire FLASH.
     
155. * Input          : None
     
156. * Output         : None
     
157. * Return         : None
     
158. *******************************************************************************/
     
159. //void SPI_FLASH_BulkErase(void)
     
160. //{
     
161. //  /* Send write enable instruction */
     
162. //  SPI_FLASH_WriteEnable();
     
163. //
     
164. //  /* Bulk Erase */
     
165. //  /* Select the FLASH: Chip Select low */
     
166. //  SPI_FLASH_CS_LOW();
     
167. //  /* Send Bulk Erase instruction  */
     
168. //  SPI_FLASH_SendByte(0xc7);
     
169. //  /* Deselect the FLASH: Chip Select high */
     
170. //  SPI_FLASH_CS_HIGH();
     
171. //
     
172. //  /* Wait the end of Flash writing */
     
173. //  //SPI_FLASH_WaitForWriteEnd();
     
174. //  SPI_FLASH_Wait(TIME_BULK_ERASE);
     
175. //}
     
176. 
     
177. //void SPI_FLASH_4KByteErase(u32 SectorAddr)
     
178. //{
     
179. //  /* Send write enable instruction */
     
180. //  SPI_FLASH_WriteEnable();
     
181. //
     
182. //  /* Bulk Erase */
     
183. //  /* Select the FLASH: Chip Select low */
     
184. //  SPI_FLASH_CS_LOW();
     
185. //  /* Send Bulk Erase instruction  */
     
186. //  SPI_FLASH_SendByte(0x20);
     
187. //  /* Send SectorAddr high nibble address byte */
     
188. //  SPI_FLASH_SendByte((SectorAddr & 0xFF0000) >> 16);
     
189. //  /* Send SectorAddr medium nibble address byte */
     
190. //  SPI_FLASH_SendByte((SectorAddr & 0xFF00) >> 8);
     
191. //  /* Send SectorAddr low nibble address byte */
     
192. //  SPI_FLASH_SendByte(SectorAddr & 0xFF);
     
193. //  /* Deselect the FLASH: Chip Select high */
     
194. //
     
195. //  SPI_FLASH_CS_HIGH();
     
196. //
     
197. //  /* Wait the end of Flash writing */
     
198. //  //SPI_FLASH_WaitForWriteEnd();
     
199. //  SPI_FLASH_Wait(30);
     
200. //}
     
201. 
     
202. void SPI_FLASH_WriteSR(unsigned char data)
     
203. {
     
204.     SPI_FLASH_CS_LOW();
     
205.     SPI_FLASH_SendByte(EWSR);
     
206.     SPI_FLASH_CS_HIGH();
     
207.    
     
208.     SPI_FLASH_CS_LOW();
     
209.     SPI_FLASH_SendByte(WRSR);
     
210.     SPI_FLASH_SendByte(data);
     
211.     SPI_FLASH_CS_HIGH();
     
212. }
     
213. 
     
214. void SPI_FLASH_ChipErase()
     
215. {
     
216.     SPI_FLASH_WriteSR(0x00);  //寫狀態(tài)寄存器為整片都非保護模式
     
217.         SPI_FLASH_WriteEnable();
     
218. 
     
219.         SPI_FLASH_CS_LOW();
     
220.     SPI_FLASH_SendByte(CE);
     
221.     SPI_FLASH_CS_HIGH();
     
222. 
     
223.         SPI_FLASH_WriteDisable();
     
224.         //Delay_ms(40);   
     
225.         TIM_Delay_10ms(40);
     
226.         while(time_is_up == 0);
     
227.         time_is_up = 0;
     
228. 
     
229.         //SPI_FLASH_Wait(50);/* 延時至少35ms */
     
230. }
     
231. 
     
232. 
     
233. //void SPI_FLASH_ByteWrite(u32 WriteAddr)
     
234. //{
     
235. //  /* Enable the write access to the FLASH */
     
236. //  SPI_FLASH_WriteEnable();
     
237. //
     
238. //  /* Select the FLASH: Chip Select low */
     
239. //  SPI_FLASH_CS_LOW();
     
240. //  /* Send "Write to Memory " instruction */
     
241. //  SPI_FLASH_SendByte(WRITE);
     
242. //  /* Send WriteAddr high nibble address byte to write to */
     
243. //  SPI_FLASH_SendByte((WriteAddr & 0xFF0000) >> 16);
     
244. //  /* Send WriteAddr medium nibble address byte to write to */
     
245. //  SPI_FLASH_SendByte((WriteAddr & 0xFF00) >> 8);
     
246. //  /* Send WriteAddr low nibble address byte to write to */
     
247. //  SPI_FLASH_SendByte(WriteAddr & 0xFF);
     
248. //
     
249. //    /* Send the current byte */
     
250. //    SPI_FLASH_SendByte(0x22);
     
251. //
     
252. //  /* Deselect the FLASH: Chip Select high */
     
253. //  SPI_FLASH_CS_HIGH();
     
254. //
     
255. //  /* Wait the end of Flash writing */
     
256. ////  SPI_FLASH_WaitForWriteEnd();
     
257. ////SPI_FLASH_Wait(TIME_PAGE_PROGRAME);
     
258. //  SPI_FLASH_Wait(100);
     
259. //}
     
260. extern DMA_InitTypeDef    SPIDMA_InitStructure;
     
261. void SPI_DMAInit1(unsigned char *buf, unsigned short size, unsigned char type)
     
262. {
     
263.   unsigned char temp[256]={2,2,2,2,2,2,2,2,2,2,2,2};
     
264.       /* Enable the DMA clock */
     
265.   RCC_AHB1PeriphClockCmd(SPI1_DMA_CLK, ENABLE);
     
266.   
     
267.   /* Clear any pending flag on Rx Stream  */
     
268.   DMA_ClearFlag(SPI1_DMA_STREAM_TX, SPI1_TX_DMA_FLAG_FEIF | SPI1_TX_DMA_FLAG_DMEIF | SPI1_TX_DMA_FLAG_TEIF | \
     
269.                                        SPI1_TX_DMA_FLAG_HTIF | SPI1_TX_DMA_FLAG_TCIF);
     
270.   /* Disable the EE I2C Tx DMA stream */
     
271.   DMA_Cmd(SPI1_DMA_STREAM_TX, DISABLE);
     
272.   /* Configure the DMA stream for the EE I2C peripheral TX direction */
     
273.   DMA_DeInit(SPI1_DMA_STREAM_TX);
     
274.   SPIDMA_InitStructure.DMA_Channel = SPI1_DMA_CHANNEL;
     
275.   SPIDMA_InitStructure.DMA_PeripheralBaseAddr = (uint32_t)SPI1_DR_Address;
     
276.   if(type == 1) //RX
     
277.       SPIDMA_InitStructure.DMA_Memory0BaseAddr = (uint32_t)temp;    /* This parameter will be configured durig communication */
     
278.   else if(type == 2) //TX
     
279.       SPIDMA_InitStructure.DMA_Memory0BaseAddr = (uint32_t)buf;    /* This parameter will be configured durig communication */
     
280.   SPIDMA_InitStructure.DMA_DIR = DMA_DIR_MemoryToPeripheral; /* This parameter will be configured durig communication */
     
281.   SPIDMA_InitStructure.DMA_BufferSize = size;              /* This parameter will be configured durig communication */
     
282.   SPIDMA_InitStructure.DMA_PeripheralInc = DMA_PeripheralInc_Disable;
     
283.   SPIDMA_InitStructure.DMA_MemoryInc = DMA_MemoryInc_Enable;
     
284.   SPIDMA_InitStructure.DMA_PeripheralDataSize = DMA_PeripheralDataSize_Byte;
     
285.   SPIDMA_InitStructure.DMA_MemoryDataSize = DMA_MemoryDataSize_Byte;
     
286.   SPIDMA_InitStructure.DMA_Mode = DMA_Mode_Normal;
     
287.   SPIDMA_InitStructure.DMA_Priority = DMA_Priority_VeryHigh;
     
288.   SPIDMA_InitStructure.DMA_FIFOMode = DMA_FIFOMode_Enable;
     
289.   SPIDMA_InitStructure.DMA_FIFOThreshold = DMA_FIFOThreshold_1QuarterFull;
     
290.   SPIDMA_InitStructure.DMA_MemoryBurst = DMA_MemoryBurst_Single;
     
291.   SPIDMA_InitStructure.DMA_PeripheralBurst = DMA_PeripheralBurst_Single;
     
292.   DMA_Init(SPI1_DMA_STREAM_TX, &SPIDMA_InitStructure);
     
293.   
     
294.   /* Clear any pending flag on Rx Stream */
     
295.   DMA_ClearFlag(SPI1_DMA_STREAM_RX, SPI1_RX_DMA_FLAG_FEIF | SPI1_RX_DMA_FLAG_DMEIF | SPI1_RX_DMA_FLAG_TEIF | \
     
296.                                        SPI1_RX_DMA_FLAG_HTIF | SPI1_RX_DMA_FLAG_TCIF);
     
297.   /* Disable the EE I2C DMA Rx stream */
     
298.   DMA_Cmd(SPI1_DMA_STREAM_RX, DISABLE);
     
299.   /* Configure the DMA stream for the EE I2C peripheral RX direction */
     
300.   DMA_DeInit(SPI1_DMA_STREAM_RX);
     
301.   if(type == 1) //RX
     
302.       SPIDMA_InitStructure.DMA_Memory0BaseAddr = (uint32_t)buf;    /* This parameter will be configured durig communication */
     
303.   else if(type == 2) //TX
     
304.       SPIDMA_InitStructure.DMA_Memory0BaseAddr = (uint32_t)temp;    /* This parameter will be configured durig communication */
     
305.   SPIDMA_InitStructure.DMA_BufferSize = size;
     
306.   SPIDMA_InitStructure.DMA_DIR = DMA_DIR_PeripheralToMemory;
     
307.   DMA_Init(SPI1_DMA_STREAM_RX, &SPIDMA_InitStructure);
     
308. 
     
309.   /* Enable the DMA Channels Interrupts */
     
310.   DMA_ITConfig(SPI1_DMA_STREAM_RX, DMA_IT_TC, ENABLE);  
     
311.   DMA_ITConfig(SPI1_DMA_STREAM_TX, DMA_IT_TC, ENABLE);  
     
312. }
     
313. /*------------------------------------------------------------------------------
     
314. 函數(shù)名稱 : SPI_FLASH_WaitForWriteEnd
     
315. 函數(shù)功能 : 等待FLASH操作完成
     
316. 入口參數(shù) :  無
     
317. 出口參數(shù) :  無
     
318. ------------------------------------------------------------------------------*/
     
319. 
     
320. void SPI_FLASH_PageWrite(unsigned int Addr, unsigned char *buf, unsigned int num)
     
321. {
     
322.     unsigned short i = 0, j = 0;
     
323.     SPI_FLASH_WriteEnable();
     
324. 
     
325.         /* 傳輸前兩個字節(jié)數(shù)據(jù) */
     
326.     SPI_FLASH_CS_LOW();
     
327. 
     
328.     SPI_FLASH_SendByte(0xAD);
     
329.     SPI_FLASH_SendByte(Addr>>16);
     
330.     SPI_FLASH_SendByte(Addr>>8);
     
331.     SPI_FLASH_SendByte(Addr);
     
332.     SPI_FLASH_SendByte(*buf++);
     
333.     SPI_FLASH_SendByte(*buf++);
     
334. 
     
335.     SPI_FLASH_CS_HIGH();
     
336.    
     
337.     delay_nus(20);                          /* 延時 */
     
338.         
     
339.    for(i=0; i<((num-2)/2); i++) //總共大小為256個字
     
340.     {
     
341.         SPI_FLASH_CS_LOW();
     
342. 
     
343.         SPI_FLASH_SendByte(0xAD);
     
344.         
     
345. #ifdef SPI1DMA_TX         
     
346.         SPI_DMAInit1(buf, 2, 2);
     
347.         
     
348.         SPI_I2S_DMACmd(SPI1, SPI_I2S_DMAReq_Tx, ENABLE);
     
349.         SPI_I2S_DMACmd(SPI1, SPI_I2S_DMAReq_Rx, ENABLE);
     
350.         DMA_Cmd(SPI1_DMA_STREAM_TX, ENABLE);
     
351.         DMA_Cmd(SPI1_DMA_STREAM_RX, ENABLE);
     
352.        // for(j=0; j<0xfff8; j++);
     
353. 
     
354.         while (!DMA_GetFlagStatus(SPI1_DMA_STREAM_TX, SPI1_RX_DMA_FLAG_TCIF))
     
355.         {
     
356.           if((j++) > 0xfff0)    break;
     
357.         }
     
358. 
     
359.         DMA_Cmd(SPI1_DMA_STREAM_TX, DISABLE);
     
360.         DMA_Cmd(SPI1_DMA_STREAM_RX, DISABLE);
     
361.         SPI_I2S_DMACmd(SPI1, SPI_I2S_DMAReq_Rx, DISABLE);
     
362.         SPI_I2S_DMACmd(SPI1, SPI_I2S_DMAReq_Tx, DISABLE);
     
363. 
     
364.         
     
365.         buf+=2;
     
366. #else
     
367.         SPI_FLASH_SendByte(*buf++);
     
368.    SPI_FLASH_SendByte(*buf++);
     
369. #endif
     
370.         SPI_FLASH_CS_HIGH();
     
371. 
     
372.         delay_nus(15);/* 延時 */
     
373.     }
     
374.     SPI_FLASH_WriteDisable();
     
375.     delay_nus(20);
     
376. }
     
377. 
     
378. /*------------------------------------------------------------------------------
     
379. 函數(shù)名稱 : SPI_FLASH_WaitForWriteEnd
     
380. 函數(shù)功能 : 等待FLASH操作完成
     
381. 入口參數(shù) :  無
     
382. 出口參數(shù) :  無
     
383. ------------------------------------------------------------------------------*/
     
384. void SPI_FLASH_WaitForWriteEnd2(void)
     
385. {
     
386.   u8 FLASH_Status = 0;
     
387. 
     
388.   /* Select the FLASH: Chip Select low */
     
389. 
     
390.    SPI_FLASH_CS_LOW();
     
391. 
     
392.   /* Send "Read Status Register" instruction */
     
393.   SPI_FLASH_SendByte(RDSR);
     
394. 
     
395.   /* Loop as long as the memory is busy with a write cycle */
     
396.   do
     
397.   {
     
398.     /* Send a dummy byte to generate the clock needed by the FLASH
     
399.     and put the value of the status register in FLASH_Status variable */
     
400.     FLASH_Status = SPI_FLASH_SendByte(Dummy_Byte);
     
401. 
     
402.   }
     
403.   while ((FLASH_Status & WIP_Flag) == RESET); /* Write in progress */
     
404. 
     
405.   /* Deselect the FLASH: Chip Select high */
     
406.   SPI_FLASH_CS_HIGH();
     
407. }
     
408. 
     
409. /*------------------------------------------------------------------------------
     
410. 函數(shù)名稱 : SPI_FLASH_Writebyte
     
411. 函數(shù)功能 : 寫一個字節(jié)數(shù)據(jù)
     
412. 入口參數(shù) :  address:地址  buffer:數(shù)據(jù)
     
413. 出口參數(shù) :  無
     
414. ------------------------------------------------------------------------------*/
     
415. 
     
416. void SPI_FLASH_Writebyte(unsigned int Addr, unsigned char *buf)
     
417. {
     
418.     unsigned short i = 0, j = 0;
     
419. 
     
420.     SPI_FLASH_WriteEnable();
     
421. 
     
422.     SPI_FLASH_CS_LOW();
     
423.         SPI_FLASH_SendByte(0x02);
     
424.         SPI_FLASH_SendByte((Addr)>>16);
     
425.     SPI_FLASH_SendByte((Addr)>>8);
     
426.         SPI_FLASH_SendByte((Addr));
     
427.         SPI_FLASH_SendByte(*buf);
     
428.     SPI_FLASH_CS_HIGH();
     
429.            SPI_FLASH_WaitForWriteEnd();
     
430.     SPI_FLASH_WriteDisable();
     
431.     delay_nus(20);
     
432. }
     
433. /*------------------------------------------------------------------------------
     
434. 函數(shù)名稱 : SPI_FLASH_Writenbyte
     
435. 函數(shù)功能 : 寫一個字節(jié)數(shù)據(jù)
     
436. 入口參數(shù) :  address:地址  buffer:數(shù)據(jù) num :數(shù)量
     
437. 出口參數(shù) :  無
     
438. 
     
439. ------------------------------------------------------------------------------*/
     
440. 
     
441. 
     
442. void SPI_FLASH_Writenbyte(unsigned int Addr, unsigned char *buf,u16 num)
     
443. {
     
444. u8 i;
     
445. for(i=0;i<num;i++)
     
446. {
     
447.    SPI_FLASH_Writebyte(Addr++,&buf[i]);
     
448. }
     
449. 
     
450. }
     
451. /*------------------------------------------------------------------------------
     
452. 函數(shù)名稱 : SPI_FLASH_Readnbyte
     
453. 函數(shù)功能 : 寫一個字節(jié)數(shù)據(jù)
     
454. 入口參數(shù) :  address:地址  buffer:數(shù)據(jù) num :數(shù)量
     
455. 出口參數(shù) :  無
     
456. 
     
457. ------------------------------------------------------------------------------*/
     
458. 
     
459. void SPI_FLASH_Readnbyte(unsigned int Addr,unsigned char *buf,u16 num)
     
460. {
     
461.     unsigned short i = 0;
     
462. 
     
463.     SPI_FLASH_CS_LOW();
     
464. 
     
465.     SPI_FLASH_SendByte(0x0b);
     
466.         SPI_FLASH_SendByte(Addr>>16);
     
467.         SPI_FLASH_SendByte(Addr>>8);
     
468.         SPI_FLASH_SendByte(Addr);
     
469.         //dummy
     
470.         SPI_FLASH_SendByte(Dummy_Byte);
     
471.     for(i=0;i<num;i++)
     
472.     {
     
473.                 buf[i]= SPI_FLASH_SendByte(Dummy_Byte);
     
474. 
     
475.         }
     
476. 
     
477.        
     
478.     SPI_FLASH_CS_HIGH();
     
479. }
     
480. 
     
481. void SPI_FLASH_PageWriteEnd(unsigned int Addr, unsigned char *buf, unsigned int num)
     
482. {
     
483.     unsigned short i = 0;
     
484.     SPI_FLASH_WriteEnable();
     
485. 
     
486.         /* 傳輸前兩個字節(jié)數(shù)據(jù) */
     
487.     SPI_FLASH_CS_LOW();
     
488. 
     
489.     SPI_FLASH_SendByte(0xAD);
     
490.         SPI_FLASH_SendByte(Addr>>16);
     
491.         SPI_FLASH_SendByte(Addr>>8);
     
492.         SPI_FLASH_SendByte(Addr);
     
493.         SPI_FLASH_SendByte(*buf++);
     
494.         SPI_FLASH_SendByte(*buf++);
     
495. 
     
496.     SPI_FLASH_CS_HIGH();
     
497. 
     
498.     delay_nus(20);                          /* 延時 */
     
499. 
     
500.         for(i=0; i<((num-2)/2); i++) //總共大小為256個字節(jié)
     
501.     {
     
502.         SPI_FLASH_CS_LOW();
     
503. 
     
504.                 SPI_FLASH_SendByte(0xAD);
     
505.                 SPI_FLASH_SendByte(*buf++);
     
506.             SPI_FLASH_SendByte(*buf++);
     
507. 
     
508.         SPI_FLASH_CS_HIGH();
     
509. 
     
510.                 delay_nus(15);/* 延時 */
     
511.         }
     
512. 
     
513.     if(num%2)
     
514.     {
     
515.         SPI_FLASH_CS_LOW();
     
516. 
     
517.                 SPI_FLASH_SendByte(0xAD);
     
518.                 SPI_FLASH_SendByte(*buf++);
     
519.             SPI_FLASH_SendByte(0xFF);
     
520. 
     
521.         SPI_FLASH_CS_HIGH();
     
522. 
     
523.                 delay_nus(15);
     
524.     }
     
525. 
     
526.         SPI_FLASH_WriteDisable();
     
527.         delay_nus(20);
     
528. }
     
529. 
     
530. 
     
531. void SPI_FLASH_PageRead(unsigned int Addr,unsigned char *buf)
     
532. {
     
533.     unsigned short i = 0;
     
534. 
     
535.     SPI_FLASH_CS_LOW();
     
536. 
     
537.     SPI_FLASH_SendByte(0x0B);
     
538.         SPI_FLASH_SendByte(Addr>>16);
     
539.         SPI_FLASH_SendByte(Addr>>8);
     
540.         SPI_FLASH_SendByte(Addr);
     
541.         SPI_FLASH_SendByte(0xFF);  //dummy
     
542. #ifdef SPI1DMA_RX     
     
543.         SPI_DMAInit1(buf, 256, 1);
     
544.         
     
545.         SPI_I2S_DMACmd(SPI1, SPI_I2S_DMAReq_Rx, ENABLE);
     
546.         SPI_I2S_DMACmd(SPI1, SPI_I2S_DMAReq_Tx, ENABLE);
     
547.         DMA_Cmd(SPI1_DMA_STREAM_RX, ENABLE);
     
548.         DMA_Cmd(SPI1_DMA_STREAM_TX, ENABLE);
     
549.         //for(i=0; i<0xfff8; i++);
     
550.         while (!DMA_GetFlagStatus(SPI1_DMA_STREAM_RX, SPI1_RX_DMA_FLAG_TCIF))
     
551.         {
     
552.           if((i++) > 0xfff0)    break;
     
553.         }  
     
554.         
     
555. 
     
556.         DMA_Cmd(SPI1_DMA_STREAM_RX, DISABLE);
     
557.         DMA_Cmd(SPI1_DMA_STREAM_TX, DISABLE);
     
558.         SPI_I2S_DMACmd(SPI1, SPI_I2S_DMAReq_Rx, DISABLE);
     
559.         SPI_I2S_DMACmd(SPI1, SPI_I2S_DMAReq_Tx, DISABLE);
     
560.         
     
561. #else
     
562.         for(i=0; i<256; i++) //總共大小為256個字節(jié)
     
563.         {
     
564.                 *buf++ = SPI_FLASH_SendByte(Dummy_Byte);
     
565.         }
     
566. #endif
     
567. 
     
568.     SPI_FLASH_CS_HIGH();
     
569. }
     
570. 
     
571. /*******************************************************************************
     
572. * Function Name  : SPI_FLASH_BufferWrite
     
573. * Description    : Writes block of data to the FLASH. In this function, the
     
574. *                  number of WRITE cycles are reduced, using Page WRITE sequence.
     
575. * Input          : - pBuffer : pointer to the buffer  containing the data to be
     
576. *                    written to the FLASH.
     
577. *                  - WriteAddr : FLASH's internal address to write to.
     
578. *                  - NumByteToWrite : number of bytes to write to the FLASH.
     
579. * Output         : None
     
580. * Return         : None
     
581. *******************************************************************************/
     
582. //void SPI_FLASH_BufferWrite(u8* pBuffer, u32 WriteAddr, u16 NumByteToWrite)
     
583. //{
     
584. //  u8 NumOfPage = 0, NumOfSingle = 0, Addr = 0, count = 0, temp = 0;
     
585. //
     
586. //  Addr = WriteAddr % SPI_FLASH_PageSize;
     
587. //  count = SPI_FLASH_PageSize - Addr;
     
588. //  NumOfPage =  NumByteToWrite / SPI_FLASH_PageSize;
     
589. //  NumOfSingle = NumByteToWrite % SPI_FLASH_PageSize;
     
590. //
     
591. //  if (Addr == 0) /* WriteAddr is SPI_FLASH_PageSize aligned  */
     
592. //  {
     
593. //    if (NumOfPage == 0) /* NumByteToWrite < SPI_FLASH_PageSize */
     
594. //    {
     
595. //      SPI_FLASH_PageWrite(pBuffer, WriteAddr, NumByteToWrite);
     
596. //    }
     
597. //    else /* NumByteToWrite > SPI_FLASH_PageSize */
     
598. //    {
     
599. //      while (NumOfPage--)
     
600. //      {
     
601. //        SPI_FLASH_PageWrite(pBuffer, WriteAddr, SPI_FLASH_PageSize);
     
602. //        WriteAddr +=  SPI_FLASH_PageSize;
     
603. //        pBuffer += SPI_FLASH_PageSize;
     
604. //      }
     
605. //
     
606. //      SPI_FLASH_PageWrite(pBuffer, WriteAddr, NumOfSingle);
     
607. //    }
     
608. //  }
     
609. //  else /* WriteAddr is not SPI_FLASH_PageSize aligned  */
     
610. //  {
     
611. //    if (NumOfPage == 0) /* NumByteToWrite < SPI_FLASH_PageSize */
     
612. //    {
     
613. //      if (NumOfSingle > count) /* (NumByteToWrite + WriteAddr) > SPI_FLASH_PageSize */
     
614. //      {
     
615. //        temp = NumOfSingle - count;
     
616. //
     
617. //        SPI_FLASH_PageWrite(pBuffer, WriteAddr, count);
     
618. //        WriteAddr +=  count;
     
619. //        pBuffer += count;
     
620. //
     
621. //        SPI_FLASH_PageWrite(pBuffer, WriteAddr, temp);
     
622. //      }
     
623. //      else
     
624. //      {
     
625. //        SPI_FLASH_PageWrite(pBuffer, WriteAddr, NumByteToWrite);
     
626. //      }
     
627. //    }
     
628. //    else /* NumByteToWrite > SPI_FLASH_PageSize */
     
629. //    {
     
630. //      NumByteToWrite -= count;
     
631. //      NumOfPage =  NumByteToWrite / SPI_FLASH_PageSize;
     
632. //      NumOfSingle = NumByteToWrite % SPI_FLASH_PageSize;
     
633. //
     
634. //      SPI_FLASH_PageWrite(pBuffer, WriteAddr, count);
     
635. //      WriteAddr +=  count;
     
636. //      pBuffer += count;
     
637. //
     
638. //      while (NumOfPage--)
     
639. //      {
     
640. //        SPI_FLASH_PageWrite(pBuffer, WriteAddr, SPI_FLASH_PageSize);
     
641. //        WriteAddr +=  SPI_FLASH_PageSize;
     
642. //        pBuffer += SPI_FLASH_PageSize;
     
643. //      }
     
644. //
     
645. //      if (NumOfSingle != 0)
     
646. //      {
     
647. //        SPI_FLASH_PageWrite(pBuffer, WriteAddr, NumOfSingle);
     
648. //      }
     
649. //    }
     
650. //  }
     
651. //}
     
652. //
     
653. /*******************************************************************************
     
654. * Function Name  : SPI_FLASH_BufferRead
     
655. * Description    : Reads a block of data from the FLASH.
     
656. * Input          : - pBuffer : pointer to the buffer that receives the data read
     
657. *                    from the FLASH.
     
658. *                  - ReadAddr : FLASH's internal address to read from.
     
659. *                  - NumByteToRead : number of bytes to read from the FLASH.
     
660. * Output         : None
     
661. * Return         : None
     
662. *******************************************************************************/
     
663. //void SPI_FLASH_BufferRead(u8* pBuffer, u32 ReadAddr, u16 NumByteToRead)
     
664. //{
     
665. //  /* Select the FLASH: Chip Select low */
     
666. //  SPI_FLASH_CS_LOW();
     
667. //
     
668. //  /* Send "Read from Memory " instruction */
     
669. //  SPI_FLASH_SendByte(READ);
     
670. //
     
671. //  /* Send ReadAddr high nibble address byte to read from */
     
672. //  SPI_FLASH_SendByte((ReadAddr & 0xFF0000) >> 16);
     
673. //  /* Send ReadAddr medium nibble address byte to read from */
     
674. //  SPI_FLASH_SendByte((ReadAddr& 0xFF00) >> 8);
     
675. //  /* Send ReadAddr low nibble address byte to read from */
     
676. //  SPI_FLASH_SendByte(ReadAddr & 0xFF);
     
677. //
     
678. //  while (NumByteToRead--) /* while there is data to be read */
     
679. //  {
     
680. //    /* Read a byte from the FLASH */
     
681. //    *pBuffer = SPI_FLASH_SendByte(Dummy_Byte);
     
682. //    /* Point to the next location where the byte read will be saved */
     
683. //    pBuffer++;
     
684. //  }
     
685. //
     
686. //  /* Deselect the FLASH: Chip Select high */
     
687. //  SPI_FLASH_CS_HIGH();
     
688. //}
     
689. 
     
690. //u8 SPI_FLASH_ByteRead(u32 ReadAddr)
     
691. //{
     
692. //    u8 temp = 0;
     
693. //
     
694. //  /* Select the FLASH: Chip Select low */
     
695. //  SPI_FLASH_CS_LOW();
     
696. //
     
697. //  /* Send "Read from Memory " instruction */
     
698. //  SPI_FLASH_SendByte(0x03);
     
699. //
     
700. //  /* Send ReadAddr high nibble address byte to read from */
     
701. //  SPI_FLASH_SendByte((ReadAddr & 0xFF0000) >> 16);
     
702. //  /* Send ReadAddr medium nibble address byte to read from */
     
703. //  SPI_FLASH_SendByte((ReadAddr & 0xFF00) >> 8);
     
704. //  /* Send ReadAddr low nibble address byte to read from */
     
705. //  SPI_FLASH_SendByte(ReadAddr & 0xFF);
     
706. //
     
707. //    /* Read a byte from the FLASH */
     
708. //    temp = SPI_FLASH_SendByte(Dummy_Byte);
     
709. //
     
710. //  /* Deselect the FLASH: Chip Select high */
     
711. //  SPI_FLASH_CS_HIGH();
     
712. //
     
713. //    return temp;
     
714. //}
     
715. 
     
716. 
     
717. 
     
718. /*******************************************************************************
     
719. * Function Name  : SPI_FLASH_ReadID
     
720. * Description    : Reads FLASH identification.
     
721. * Input          : None
     
722. * Output         : None
     
723. * Return         : FLASH identification
     
724. *******************************************************************************/
     
725. u32 SPI_FLASH_ReadID()
     
726. {
     
727.   u32 Temp = 0, Temp0 = 0, Temp1 = 0, Temp2 = 0;
     
728. 
     
729.   /* Select the FLASH: Chip Select low */
     
730.   SPI_FLASH_CS_LOW();
     
731. 
     
732.   /* Send "RDID " instruction */
     
733.   SPI_FLASH_SendByte(0x9F);
     
734. 
     
735.   /* Read a byte from the FLASH */
     
736.   Temp0 = SPI_FLASH_SendByte(Dummy_Byte);
     
737. 
     
738.   /* Read a byte from the FLASH */
     
739.   Temp1 = SPI_FLASH_SendByte(Dummy_Byte);
     
740. 
     
741.   /* Read a byte from the FLASH */
     
742.   Temp2 = SPI_FLASH_SendByte(Dummy_Byte);
     
743. 
     
744.   /* Deselect the FLASH: Chip Select high */
     
745.   SPI_FLASH_CS_HIGH();
     
746. 
     
747.   Temp = (Temp0 << 16) | (Temp1 << 8) | Temp2;
     
748. 
     
749.   return Temp;
     
750. }
     
751. 
     
752. 
     
753. /*******************************************************************************
     
754. * Function Name  : SPI_FLASH_StartReadSequence
     
755. * Description    : Initiates a read data byte (READ) sequence from the Flash.
     
756. *                  This is done by driving the /CS line low to select the device,
     
757. *                  then the READ instruction is transmitted followed by 3 bytes
     
758. *                  address. This function exit and keep the /CS line low, so the
     
759. *                  Flash still being selected. With this technique the whole
     
760. *                  content of the Flash is read with a single READ instruction.
     
761. * Input          : - ReadAddr : FLASH's internal address to read from.
     
762. * Output         : None
     
763. * Return         : None
     
764. *******************************************************************************/
     
765. //void SPI_FLASH_StartReadSequence(u32 ReadAddr)
     
766. //{
     
767. //  /* Select the FLASH: Chip Select low */
     
768. //  SPI_FLASH_CS_LOW();
     
769. //
     
770. //  /* Send "Read from Memory " instruction */
     
771. //  SPI_FLASH_SendByte(READ);
     
772. //
     
773. //  /* Send the 24-bit address of the address to read from -----------------------*/
     
774. //  /* Send ReadAddr high nibble address byte */
     
775. //  SPI_FLASH_SendByte((ReadAddr & 0xFF0000) >> 16);
     
776. //  /* Send ReadAddr medium nibble address byte */
     
777. //  SPI_FLASH_SendByte((ReadAddr& 0xFF00) >> 8);
     
778. //  /* Send ReadAddr low nibble address byte */
     
779. //  SPI_FLASH_SendByte(ReadAddr & 0xFF);
     
780. //}
     
781. 
     
782. /*******************************************************************************
     
783. * Function Name  : SPI_FLASH_ReadByte
     
784. * Description    : Reads a byte from the SPI Flash.
     
785. *                  This function must be used only if the Start_Read_Sequence
     
786. *                  function has been previously called.
     
787. * Input          : None
     
788. * Output         : None
     
789. * Return         : Byte Read from the SPI Flash.
     
790. *******************************************************************************/
     
791. u8 SPI_FLASH_ReadByte(void)
     
792. {
     
793.   return (SPI_FLASH_SendByte(Dummy_Byte));
     
794. }
     
795. 
     
796. /*******************************************************************************
     
797. * Function Name  : SPI_FLASH_SendByte
     
798. * Description    : Sends a byte through the SPI interface and return the byte
     
799. *                  received from the SPI bus.
     
800. * Input          : byte : byte to send.
     
801. * Output         : None
     
802. * Return         : The value of the received byte.
     
803. *******************************************************************************/
     
804. u8 SPI_FLASH_SendByte(u8 byte)
     
805. {
     
806.   /* Loop while DR register in not emplty */
     
807. //          while (SPI_I2S_GetFlagStatus(SPI1, SPI_I2S_FLAG_TXE) == RESET);
     
808. 
     
809.   /* Send byte through the SPI1 peripheral */
     
810.         SPI_I2S_SendData(SPI1, byte);
     
811.         //while (SPI_I2S_GetFlagStatus(SPI1, SPI_I2S_FLAG_TXE) == RESET);
     
812.   /* Wait to receive a byte */
     
813.         while (SPI_I2S_GetFlagStatus(SPI1, SPI_I2S_FLAG_RXNE) == RESET);
     
814. 
     
815.   /* Return the byte read from the SPI bus */
     
816.           return SPI_I2S_ReceiveData(SPI1);
     
817. //          return 0;
     
818. }
     
819. 
     
820. /*******************************************************************************
     
821. * Function Name  : SPI_FLASH_SendHalfWord
     
822. * Description    : Sends a Half Word through the SPI interface and return the
     
823. *                  Half Word received from the SPI bus.
     
824. * Input          : Half Word : Half Word to send.
     
825. * Output         : None
     
826. * Return         : The value of the received Half Word.
     
827. *******************************************************************************/
     
828. u16 SPI_FLASH_SendHalfWord(u16 HalfWord)
     
829. {
     
830.   /* Loop while DR register in not emplty */
     
831.   while (SPI_I2S_GetFlagStatus(SPI1, SPI_I2S_FLAG_TXE) == RESET);
     
832. 
     
833.   /* Send Half Word through the SPI1 peripheral */
     
834.   SPI_I2S_SendData(SPI1, HalfWord);
     
835. 
     
836.   /* Wait to receive a Half Word */
     
837.   while (SPI_I2S_GetFlagStatus(SPI1, SPI_I2S_FLAG_RXNE) == RESET);
     
838. 
     
839.   /* Return the Half Word read from the SPI bus */
     
840.   return SPI_I2S_ReceiveData(SPI1);
     
841. }
     
842. 
     
843. /*******************************************************************************
     
844. * Function Name  : SPI_FLASH_WriteEnable
     
845. * Description    : Enables the write access to the FLASH.
     
846. * Input          : None
     
847. * Output         : None
     
848. * Return         : None
     
849. *******************************************************************************/
     
850. void SPI_FLASH_WriteEnable()
     
851. {
     
852.   /* Select the FLASH: Chip Select low */
     
853.     SPI_FLASH_CS_LOW();
     
854. 
     
855.   /* Send "Write Enable" instruction */
     
856.   SPI_FLASH_SendByte(WREN);
     
857. 
     
858.   /* Deselect the FLASH: Chip Select high */
     
859.     SPI_FLASH_CS_HIGH();
     
860. }
     
861. 
     
862. void SPI_FLASH_WriteDisable()
     
863. {
     
864.   /* Select the FLASH: Chip Select low */
     
865.     SPI_FLASH_CS_LOW();
     
866. 
     
867.   /* Send "Write Enable" instruction */
     
868.   SPI_FLASH_SendByte(WRDI);
     
869. 
     
870.   /* Deselect the FLASH: Chip Select high */
     
871.     SPI_FLASH_CS_HIGH();
     
872. }
     
873. 
     
874. /*******************************************************************************
     
875. * Function Name  : SPI_FLASH_WaitForWriteEnd
     
876. * Description    : Polls the status of the Write In Progress (WIP) flag in the
     
877. *                  FLASH's status  register  and  loop  until write  opertaion
     
878. *                  has completed.
     
879. * Input          : None
     
880. * Output         : None
     
881. * Return         : None
     
882. *******************************************************************************/
     
883. void SPI_FLASH_WaitForWriteEnd()
     
884. {
     
885.   u8 FLASH_Status = 0;
     
886. 
     
887.   /* Select the FLASH: Chip Select low */
     
888.     SPI_FLASH_CS_LOW();
     
889. 
     
890.   /* Send "Read Status Register" instruction */
     
891.   SPI_FLASH_SendByte(RDSR);
     
892. 
     
893.   /* Loop as long as the memory is busy with a write cycle */
     
894.   do
     
895.   {
     
896.     /* Send a dummy byte to generate the clock needed by the FLASH
     
897.     and put the value of the status register in FLASH_Status variable */
     
898.     FLASH_Status = SPI_FLASH_SendByte(Dummy_Byte);
     
899. 
     
900.   }
     
901.   while ((FLASH_Status & WIP_Flag) == SET); /* Write in progress */
     
902. 
     
903.   /* Deselect the FLASH: Chip Select high */
     
904.     SPI_FLASH_CS_HIGH();
     
905. }
     
906. 
     
907. void SPI_FLASH_Wait(uint64_t time)
     
908. {
     
909.         flash_wait = time;
     
910.         while(flash_wait);
     
911. }
     
912. 
     
913. 
     
914. //void FlashRWTest(void)
     
915. //{
     
916. //                /* Get SPI Flash ID */
     
917. //        FLASH_ID = SPI_FLASH_ReadID();
     
918. //        /* Check the SPI Flash ID */
     
919. //        if (FLASH_ID == M25P64_FLASH_ID)
     
920. //        {
     
921. //                /* OK: Set GPIO_LED */
     
922. //                GPIOB->BSRR = 0x1000E000;
     
923. //        }
     
924. //        else
     
925. //        {
     
926. //                /* Error: Set GPIO_LED*/
     
927. //                GPIOB->BSRR = 0x2000D000;
     
928. //        }
     
929. //
     
930. //        SPI_FLASH_SectorErase(FLASH_SectorToErase);
     
931. //
     
932. //        /* Write Tx_Buffer data to SPI FLASH memory */
     
933. //        //SPI_FLASH_BufferWrite(TxBuffer, FLASH_WriteAddress, BufferSize);
     
934. //
     
935. //        /* Read data from SPI FLASH memory */
     
936. //        //SPI_FLASH_BufferRead(RxBuffer, FLASH_ReadAddress, BufferSize);
     
937. //}
     
938. 
     
939. /******************* (C) COPYRIGHT 2008 STMicroelectronics *****END OF FILE****/
     

復制代碼

---

歡迎光臨 ELEOK (http://m.afoofa.cn/)

Powered by Discuz! X5.0

感谢您访问我们的网站，您可能还对以下资源感兴趣：

国产免费AV|泡泡玛特欧洲总部将设在伦敦|中文天堂网www新版资源在线|一本久道综合在线中文|国精产品一二三产区的使用方法|香蕉鱼在线观看|www.27eee

<strong id="ij00o"></strong>

<rt id="ij00o"><b id="ij00o"></b></rt>

<thead id="ij00o"><acronym id="ij00o"><input id="ij00o"></input></acronym></thead>

<fieldset id="ij00o"></fieldset>