求助！！！FLAH扇区擦除不成功！旧版例程里的代码

Alvin_Huang

1. 无论是扇区擦除还是页擦除，都不成功，读ID正常。FLASH的0x00~0x46里的内容都不是0xFF，0x46之后的内容就是0xFF。请各位大大指点！！！

复制代码

1. /**********************************************************************************
   
2. * 文件名  ：spi_flash.c
   
3. * 描述    ：spi 底层应用函数库         
   
4. * 实验平台：野火STM32开发板
   
5. * 硬件连接 ----------------------------
   
6. *         | PA4-SPI1-NSS  : W25X16-CS  |
   
7. *         | PA5-SPI1-SCK  : W25X16-CLK |
   
8. *         | PA6-SPI1-MISO : W25X16-DO  |
   
9. *         | PA7-SPI1-MOSI : W25X16-DIO |
   
10. *          ----------------------------
    
11. * 库版本  ：ST3.5.0
    
12. * 作者    ：保留
    
13. * 论坛    ：http://www.amobbs.com/forum-1008-1.html
    
14. * 淘宝    ：http://firestm32.taobao.com
    
15. **********************************************************************************/
    
16. #include "spi_flash.h"
    
17. 
    
18. 
    
19. 
    
20. /* Private typedef -----------------------------------------------------------*/
    
21. //#define SPI_FLASH_PageSize      4096
    
22. #define SPI_FLASH_PageSize      256
    
23. #define SPI_FLASH_PerWritePageSize      256
    
24. 
    
25. /* Private define ------------------------------------------------------------*/
    
26. #define W25X_WriteEnable                      0x06
    
27. #define W25X_WriteDisable                      0x04
    
28. #define W25X_ReadStatusReg                    0x05
    
29. #define W25X_WriteStatusReg                    0x01
    
30. #define W25X_ReadData                                0x03
    
31. #define W25X_FastReadData                      0x0B
    
32. #define W25X_FastReadDual                      0x3B
    
33. #define W25X_PageProgram                      0x02
    
34. #define W25X_BlockErase                              0xD8
    
35. #define W25X_SectorErase                      0x20
    
36. #define W25X_ChipErase                              0xC7
    
37. #define W25X_PowerDown                              0xB9
    
38. #define W25X_ReleasePowerDown            0xAB
    
39. #define W25X_DeviceID                                0xAB
    
40. #define W25X_ManufactDeviceID           0x90
    
41. #define W25X_JedecDeviceID                    0x9F
    
42. 
    
43. #define WIP_Flag                  0x01  /* Write In Progress (WIP) flag */
    
44. 
    
45. #define Dummy_Byte                0xFF
    
46. 
    
47. /*******************************************************************************
    
48. * Function Name  : SPI_FLASH_Init
    
49. * Description    : Initializes the peripherals used by the SPI FLASH driver.
    
50. * Input          : None
    
51. * Output         : None
    
52. * Return         : None
    
53. *******************************************************************************/
    
54. void SPI_FLASH_Init(void)
    
55. {
    
56.   SPI_InitTypeDef  SPI_InitStructure;
    
57.   GPIO_InitTypeDef GPIO_InitStructure;
    
58.   
    
59.   /* Enable SPI1 and GPIO clocks */
    
60.   /*!< SPI_FLASH_SPI_CS_GPIO, SPI_FLASH_SPI_MOSI_GPIO,
    
61.        SPI_FLASH_SPI_MISO_GPIO, SPI_FLASH_SPI_DETECT_GPIO
    
62.        and SPI_FLASH_SPI_SCK_GPIO Periph clock enable */
    
63.   RCC_APB2PeriphClockCmd(RCC_APB2Periph_GPIOA | RCC_APB2Periph_GPIOD, ENABLE);
    
64. 
    
65.   /*!< SPI_FLASH_SPI Periph clock enable */
    
66.   RCC_APB2PeriphClockCmd(RCC_APB2Periph_SPI1, ENABLE);
    
67. 
    
68.   
    
69.   /*!< Configure SPI_FLASH_SPI pins: SCK */
    
70.   GPIO_InitStructure.GPIO_Pin = GPIO_Pin_5;
    
71.   GPIO_InitStructure.GPIO_Speed = GPIO_Speed_50MHz;
    
72.   GPIO_InitStructure.GPIO_Mode = GPIO_Mode_AF_PP;
    
73.   GPIO_Init(GPIOA, &GPIO_InitStructure);
    
74. 
    
75.   /*!< Configure SPI_FLASH_SPI pins: MISO */
    
76.   GPIO_InitStructure.GPIO_Pin = GPIO_Pin_6;
    
77.   GPIO_Init(GPIOA, &GPIO_InitStructure);
    
78. 
    
79.   /*!< Configure SPI_FLASH_SPI pins: MOSI */
    
80.   GPIO_InitStructure.GPIO_Pin = GPIO_Pin_7;
    
81.   GPIO_Init(GPIOA, &GPIO_InitStructure);
    
82. 
    
83.   /*!< Configure SPI_FLASH_SPI_CS_PIN pin: SPI_FLASH Card CS pin */
    
84.   GPIO_InitStructure.GPIO_Pin = GPIO_Pin_4;
    
85.   GPIO_InitStructure.GPIO_Mode = GPIO_Mode_Out_PP;
    
86.   GPIO_Init(GPIOA, &GPIO_InitStructure);
    
87. 
    
88.   /* Deselect the FLASH: Chip Select high */
    
89.   SPI_FLASH_CS_HIGH();
    
90. 
    
91.   /* SPI1 configuration */
    
92.   // W25X16: data input on the DIO pin is sampled on the rising edge of the CLK.
    
93.   // Data on the DO and DIO pins are clocked out on the falling edge of CLK.
    
94.   SPI_InitStructure.SPI_Direction = SPI_Direction_2Lines_FullDuplex;
    
95.   SPI_InitStructure.SPI_Mode = SPI_Mode_Master;
    
96.   SPI_InitStructure.SPI_DataSize = SPI_DataSize_8b;
    
97.   SPI_InitStructure.SPI_CPOL = SPI_CPOL_High;
    
98.   SPI_InitStructure.SPI_CPHA = SPI_CPHA_2Edge;
    
99.   SPI_InitStructure.SPI_NSS = SPI_NSS_Soft;
    
100.   SPI_InitStructure.SPI_BaudRatePrescaler = SPI_BaudRatePrescaler_2;
     
101.   SPI_InitStructure.SPI_FirstBit = SPI_FirstBit_MSB;
     
102.   SPI_InitStructure.SPI_CRCPolynomial = 7;
     
103.   SPI_Init(SPI1, &SPI_InitStructure);
     
104. 
     
105.   /* Enable SPI1  */
     
106.   SPI_Cmd(SPI1, ENABLE);
     
107. }
     
108. /*******************************************************************************
     
109. * Function Name  : SPI_FLASH_SectorErase
     
110. * Description    : Erases the specified FLASH sector.
     
111. * Input          : SectorAddr: address of the sector to erase.
     
112. * Output         : None
     
113. * Return         : None
     
114. *******************************************************************************/
     
115. void SPI_FLASH_SectorErase(u32 SectorAddr)
     
116. {
     
117.   /* Send write enable instruction */
     
118.   SPI_FLASH_WriteEnable();
     
119.   SPI_FLASH_WaitForWriteEnd();
     
120.   /* Sector Erase */
     
121.   /* Select the FLASH: Chip Select low */
     
122.   SPI_FLASH_CS_LOW();
     
123.   /* Send Sector Erase instruction */
     
124.   SPI_FLASH_SendByte(W25X_SectorErase);
     
125.   /* Send SectorAddr high nibble address byte */
     
126.   SPI_FLASH_SendByte((SectorAddr & 0xFF0000) >> 16);
     
127.   /* Send SectorAddr medium nibble address byte */
     
128.   SPI_FLASH_SendByte((SectorAddr & 0xFF00) >> 8);
     
129.   /* Send SectorAddr low nibble address byte */
     
130.   SPI_FLASH_SendByte(SectorAddr & 0xFF);
     
131.   /* Deselect the FLASH: Chip Select high */
     
132.   SPI_FLASH_CS_HIGH();
     
133.   /* Wait the end of Flash writing */
     
134.   SPI_FLASH_WaitForWriteEnd();
     
135. }
     
136. 
     
137. /*******************************************************************************
     
138. * Function Name  : SPI_FLASH_BulkErase
     
139. * Description    : Erases the entire FLASH.
     
140. * Input          : None
     
141. * Output         : None
     
142. * Return         : None
     
143. *******************************************************************************/
     
144. void SPI_FLASH_BulkErase(void)
     
145. {
     
146.   /* Send write enable instruction */
     
147.   SPI_FLASH_WriteEnable();
     
148. 
     
149.   /* Bulk Erase */
     
150.   /* Select the FLASH: Chip Select low */
     
151.   SPI_FLASH_CS_LOW();
     
152.   /* Send Bulk Erase instruction  */
     
153.   SPI_FLASH_SendByte(W25X_ChipErase);
     
154.   /* Deselect the FLASH: Chip Select high */
     
155.   SPI_FLASH_CS_HIGH();
     
156. 
     
157.   /* Wait the end of Flash writing */
     
158.   SPI_FLASH_WaitForWriteEnd();
     
159. }
     
160. 
     
161. /*******************************************************************************
     
162. * Function Name  : SPI_FLASH_PageWrite
     
163. * Description    : Writes more than one byte to the FLASH with a single WRITE
     
164. *                  cycle(Page WRITE sequence). The number of byte can't exceed
     
165. *                  the FLASH page size.
     
166. * Input          : - pBuffer : pointer to the buffer  containing the data to be
     
167. *                    written to the FLASH.
     
168. *                  - WriteAddr : FLASH's internal address to write to.
     
169. *                  - NumByteToWrite : number of bytes to write to the FLASH,
     
170. *                    must be equal or less than "SPI_FLASH_PageSize" value.
     
171. * Output         : None
     
172. * Return         : None
     
173. *******************************************************************************/
     
174. void SPI_FLASH_PageWrite(u8* pBuffer, u32 WriteAddr, u16 NumByteToWrite)
     
175. {
     
176.   /* Enable the write access to the FLASH */
     
177.   SPI_FLASH_WriteEnable();
     
178. 
     
179.   /* Select the FLASH: Chip Select low */
     
180.   SPI_FLASH_CS_LOW();
     
181.   /* Send "Write to Memory " instruction */
     
182.   SPI_FLASH_SendByte(W25X_PageProgram);
     
183.   /* Send WriteAddr high nibble address byte to write to */
     
184.   SPI_FLASH_SendByte((WriteAddr & 0xFF0000) >> 16);
     
185.   /* Send WriteAddr medium nibble address byte to write to */
     
186.   SPI_FLASH_SendByte((WriteAddr & 0xFF00) >> 8);
     
187.   /* Send WriteAddr low nibble address byte to write to */
     
188.   SPI_FLASH_SendByte(WriteAddr & 0xFF);
     
189. 
     
190.   if(NumByteToWrite > SPI_FLASH_PerWritePageSize)
     
191.   {
     
192.      NumByteToWrite = SPI_FLASH_PerWritePageSize;
     
193.      //printf("\n\r Err: SPI_FLASH_PageWrite too large!");
     
194.   }
     
195. 
     
196.   /* while there is data to be written on the FLASH */
     
197.   while (NumByteToWrite--)
     
198.   {
     
199.     /* Send the current byte */
     
200.     SPI_FLASH_SendByte(*pBuffer);
     
201.     /* Point on the next byte to be written */
     
202.     pBuffer++;
     
203.   }
     
204. 
     
205.   /* Deselect the FLASH: Chip Select high */
     
206.   SPI_FLASH_CS_HIGH();
     
207. 
     
208.   /* Wait the end of Flash writing */
     
209.   SPI_FLASH_WaitForWriteEnd();
     
210. }
     
211. 
     
212. /*******************************************************************************
     
213. * Function Name  : SPI_FLASH_BufferWrite
     
214. * Description    : Writes block of data to the FLASH. In this function, the
     
215. *                  number of WRITE cycles are reduced, using Page WRITE sequence.
     
216. * Input          : - pBuffer : pointer to the buffer  containing the data to be
     
217. *                    written to the FLASH.
     
218. *                  - WriteAddr : FLASH's internal address to write to.
     
219. *                  - NumByteToWrite : number of bytes to write to the FLASH.
     
220. * Output         : None
     
221. * Return         : None
     
222. *******************************************************************************/
     
223. void SPI_FLASH_BufferWrite(u8* pBuffer, u32 WriteAddr, u16 NumByteToWrite)
     
224. {
     
225.   u8 NumOfPage = 0, NumOfSingle = 0, Addr = 0, count = 0, temp = 0;
     
226. 
     
227.   Addr = WriteAddr % SPI_FLASH_PageSize;
     
228.   count = SPI_FLASH_PageSize - Addr;
     
229.   NumOfPage =  NumByteToWrite / SPI_FLASH_PageSize;
     
230.   NumOfSingle = NumByteToWrite % SPI_FLASH_PageSize;
     
231. 
     
232.   if (Addr == 0) /* WriteAddr is SPI_FLASH_PageSize aligned  */
     
233.   {
     
234.     if (NumOfPage == 0) /* NumByteToWrite < SPI_FLASH_PageSize */
     
235.     {
     
236.       SPI_FLASH_PageWrite(pBuffer, WriteAddr, NumByteToWrite);
     
237.     }
     
238.     else /* NumByteToWrite > SPI_FLASH_PageSize */
     
239.     {
     
240.       while (NumOfPage--)
     
241.       {
     
242.         SPI_FLASH_PageWrite(pBuffer, WriteAddr, SPI_FLASH_PageSize);
     
243.         WriteAddr +=  SPI_FLASH_PageSize;
     
244.         pBuffer += SPI_FLASH_PageSize;
     
245.       }
     
246. 
     
247.       SPI_FLASH_PageWrite(pBuffer, WriteAddr, NumOfSingle);
     
248.     }
     
249.   }
     
250.   else /* WriteAddr is not SPI_FLASH_PageSize aligned  */
     
251.   {
     
252.     if (NumOfPage == 0) /* NumByteToWrite < SPI_FLASH_PageSize */
     
253.     {
     
254.       if (NumOfSingle > count) /* (NumByteToWrite + WriteAddr) > SPI_FLASH_PageSize */
     
255.       {
     
256.         temp = NumOfSingle - count;
     
257. 
     
258.         SPI_FLASH_PageWrite(pBuffer, WriteAddr, count);
     
259.         WriteAddr +=  count;
     
260.         pBuffer += count;
     
261. 
     
262.         SPI_FLASH_PageWrite(pBuffer, WriteAddr, temp);
     
263.       }
     
264.       else
     
265.       {
     
266.         SPI_FLASH_PageWrite(pBuffer, WriteAddr, NumByteToWrite);
     
267.       }
     
268.     }
     
269.     else /* NumByteToWrite > SPI_FLASH_PageSize */
     
270.     {
     
271.       NumByteToWrite -= count;
     
272.       NumOfPage =  NumByteToWrite / SPI_FLASH_PageSize;
     
273.       NumOfSingle = NumByteToWrite % SPI_FLASH_PageSize;
     
274. 
     
275.       SPI_FLASH_PageWrite(pBuffer, WriteAddr, count);
     
276.       WriteAddr +=  count;
     
277.       pBuffer += count;
     
278. 
     
279.       while (NumOfPage--)
     
280.       {
     
281.         SPI_FLASH_PageWrite(pBuffer, WriteAddr, SPI_FLASH_PageSize);
     
282.         WriteAddr +=  SPI_FLASH_PageSize;
     
283.         pBuffer += SPI_FLASH_PageSize;
     
284.       }
     
285. 
     
286.       if (NumOfSingle != 0)
     
287.       {
     
288.         SPI_FLASH_PageWrite(pBuffer, WriteAddr, NumOfSingle);
     
289.       }
     
290.     }
     
291.   }
     
292. }
     
293. 
     
294. /*******************************************************************************
     
295. * Function Name  : SPI_FLASH_BufferRead
     
296. * Description    : Reads a block of data from the FLASH.
     
297. * Input          : - pBuffer : pointer to the buffer that receives the data read
     
298. *                    from the FLASH.
     
299. *                  - ReadAddr : FLASH's internal address to read from.
     
300. *                  - NumByteToRead : number of bytes to read from the FLASH.
     
301. * Output         : None
     
302. * Return         : None
     
303. *******************************************************************************/
     
304. void SPI_FLASH_BufferRead(u8* pBuffer, u32 ReadAddr, u16 NumByteToRead)
     
305. {
     
306.   /* Select the FLASH: Chip Select low */
     
307.   SPI_FLASH_CS_LOW();
     
308. 
     
309.   /* Send "Read from Memory " instruction */
     
310.   SPI_FLASH_SendByte(W25X_ReadData);
     
311. 
     
312.   /* Send ReadAddr high nibble address byte to read from */
     
313.   SPI_FLASH_SendByte((ReadAddr & 0xFF0000) >> 16);
     
314.   /* Send ReadAddr medium nibble address byte to read from */
     
315.   SPI_FLASH_SendByte((ReadAddr& 0xFF00) >> 8);
     
316.   /* Send ReadAddr low nibble address byte to read from */
     
317.   SPI_FLASH_SendByte(ReadAddr & 0xFF);
     
318. 
     
319.   while (NumByteToRead--) /* while there is data to be read */
     
320.   {
     
321.     /* Read a byte from the FLASH */
     
322.     *pBuffer = SPI_FLASH_SendByte(Dummy_Byte);
     
323.     /* Point to the next location where the byte read will be saved */
     
324.     pBuffer++;
     
325.   }
     
326. 
     
327.   /* Deselect the FLASH: Chip Select high */
     
328.   SPI_FLASH_CS_HIGH();
     
329. }
     
330. 
     
331. /*******************************************************************************
     
332. * Function Name  : SPI_FLASH_ReadID
     
333. * Description    : Reads FLASH identification.
     
334. * Input          : None
     
335. * Output         : None
     
336. * Return         : FLASH identification
     
337. *******************************************************************************/
     
338. u32 SPI_FLASH_ReadID(void)
     
339. {
     
340.   u32 Temp = 0, Temp0 = 0, Temp1 = 0, Temp2 = 0;
     
341. 
     
342.   /* Select the FLASH: Chip Select low */
     
343.   SPI_FLASH_CS_LOW();
     
344. 
     
345.   /* Send "RDID " instruction */
     
346.   SPI_FLASH_SendByte(W25X_JedecDeviceID);
     
347. 
     
348.   /* Read a byte from the FLASH */
     
349.   Temp0 = SPI_FLASH_SendByte(Dummy_Byte);
     
350. 
     
351.   /* Read a byte from the FLASH */
     
352.   Temp1 = SPI_FLASH_SendByte(Dummy_Byte);
     
353. 
     
354.   /* Read a byte from the FLASH */
     
355.   Temp2 = SPI_FLASH_SendByte(Dummy_Byte);
     
356. 
     
357.   /* Deselect the FLASH: Chip Select high */
     
358.   SPI_FLASH_CS_HIGH();
     
359. 
     
360.   Temp = (Temp0 << 16) | (Temp1 << 8) | Temp2;
     
361. 
     
362.   return Temp;
     
363. }
     
364. /*******************************************************************************
     
365. * Function Name  : SPI_FLASH_ReadID
     
366. * Description    : Reads FLASH identification.
     
367. * Input          : None
     
368. * Output         : None
     
369. * Return         : FLASH identification
     
370. *******************************************************************************/
     
371. u32 SPI_FLASH_ReadDeviceID(void)
     
372. {
     
373.   u32 Temp = 0;
     
374. 
     
375.   /* Select the FLASH: Chip Select low */
     
376.   SPI_FLASH_CS_LOW();
     
377. 
     
378.   /* Send "RDID " instruction */
     
379.   SPI_FLASH_SendByte(W25X_DeviceID);
     
380.   SPI_FLASH_SendByte(Dummy_Byte);
     
381.   SPI_FLASH_SendByte(Dummy_Byte);
     
382.   SPI_FLASH_SendByte(Dummy_Byte);
     
383.   
     
384.   /* Read a byte from the FLASH */
     
385.   Temp = SPI_FLASH_SendByte(Dummy_Byte);
     
386. 
     
387.   /* Deselect the FLASH: Chip Select high */
     
388.   SPI_FLASH_CS_HIGH();
     
389. 
     
390.   return Temp;
     
391. }
     
392. /*******************************************************************************
     
393. * Function Name  : SPI_FLASH_StartReadSequence
     
394. * Description    : Initiates a read data byte (READ) sequence from the Flash.
     
395. *                  This is done by driving the /CS line low to select the device,
     
396. *                  then the READ instruction is transmitted followed by 3 bytes
     
397. *                  address. This function exit and keep the /CS line low, so the
     
398. *                  Flash still being selected. With this technique the whole
     
399. *                  content of the Flash is read with a single READ instruction.
     
400. * Input          : - ReadAddr : FLASH's internal address to read from.
     
401. * Output         : None
     
402. * Return         : None
     
403. *******************************************************************************/
     
404. void SPI_FLASH_StartReadSequence(u32 ReadAddr)
     
405. {
     
406.   /* Select the FLASH: Chip Select low */
     
407.   SPI_FLASH_CS_LOW();
     
408. 
     
409.   /* Send "Read from Memory " instruction */
     
410.   SPI_FLASH_SendByte(W25X_ReadData);
     
411. 
     
412.   /* Send the 24-bit address of the address to read from -----------------------*/
     
413.   /* Send ReadAddr high nibble address byte */
     
414.   SPI_FLASH_SendByte((ReadAddr & 0xFF0000) >> 16);
     
415.   /* Send ReadAddr medium nibble address byte */
     
416.   SPI_FLASH_SendByte((ReadAddr& 0xFF00) >> 8);
     
417.   /* Send ReadAddr low nibble address byte */
     
418.   SPI_FLASH_SendByte(ReadAddr & 0xFF);
     
419. }
     
420. 
     
421. /*******************************************************************************
     
422. * Function Name  : SPI_FLASH_ReadByte
     
423. * Description    : Reads a byte from the SPI Flash.
     
424. *                  This function must be used only if the Start_Read_Sequence
     
425. *                  function has been previously called.
     
426. * Input          : None
     
427. * Output         : None
     
428. * Return         : Byte Read from the SPI Flash.
     
429. *******************************************************************************/
     
430. u8 SPI_FLASH_ReadByte(void)
     
431. {
     
432.   return (SPI_FLASH_SendByte(Dummy_Byte));
     
433. }
     
434. 
     
435. /*******************************************************************************
     
436. * Function Name  : SPI_FLASH_SendByte
     
437. * Description    : Sends a byte through the SPI interface and return the byte
     
438. *                  received from the SPI bus.
     
439. * Input          : byte : byte to send.
     
440. * Output         : None
     
441. * Return         : The value of the received byte.
     
442. *******************************************************************************/
     
443. u8 SPI_FLASH_SendByte(u8 byte)
     
444. {
     
445.   /* Loop while DR register in not emplty */
     
446.   while (SPI_I2S_GetFlagStatus(SPI1, SPI_I2S_FLAG_TXE) == RESET);
     
447. 
     
448.   /* Send byte through the SPI1 peripheral */
     
449.   SPI_I2S_SendData(SPI1, byte);
     
450. 
     
451.   /* Wait to receive a byte */
     
452.   //while (SPI_I2S_GetFlagStatus(SPI1, SPI_I2S_FLAG_RXNE) == RESET);
     
453.   while(SPI_I2S_GetFlagStatus(SPI1, SPI_I2S_FLAG_BSY) == SET);
     
454. 
     
455.   /* Return the byte read from the SPI bus */
     
456.   return SPI_I2S_ReceiveData(SPI1);
     
457. }
     
458. 
     
459. /*******************************************************************************
     
460. * Function Name  : SPI_FLASH_SendHalfWord
     
461. * Description    : Sends a Half Word through the SPI interface and return the
     
462. *                  Half Word received from the SPI bus.
     
463. * Input          : Half Word : Half Word to send.
     
464. * Output         : None
     
465. * Return         : The value of the received Half Word.
     
466. *******************************************************************************/
     
467. u16 SPI_FLASH_SendHalfWord(u16 HalfWord)
     
468. {
     
469.   /* Loop while DR register in not emplty */
     
470.   while (SPI_I2S_GetFlagStatus(SPI1, SPI_I2S_FLAG_TXE) == RESET);
     
471. 
     
472.   /* Send Half Word through the SPI1 peripheral */
     
473.   SPI_I2S_SendData(SPI1, HalfWord);
     
474. 
     
475.   /* Wait to receive a Half Word */
     
476.   while (SPI_I2S_GetFlagStatus(SPI1, SPI_I2S_FLAG_RXNE) == RESET);
     
477. 
     
478.   /* Return the Half Word read from the SPI bus */
     
479.   return SPI_I2S_ReceiveData(SPI1);
     
480. }
     
481. 
     
482. /*******************************************************************************
     
483. * Function Name  : SPI_FLASH_WriteEnable
     
484. * Description    : Enables the write access to the FLASH.
     
485. * Input          : None
     
486. * Output         : None
     
487. * Return         : None
     
488. *******************************************************************************/
     
489. void SPI_FLASH_WriteEnable(void)
     
490. {
     
491.   /* Select the FLASH: Chip Select low */
     
492.   SPI_FLASH_CS_LOW();
     
493. 
     
494.   /* Send "Write Enable" instruction */
     
495.   SPI_FLASH_SendByte(W25X_WriteEnable);
     
496. 
     
497.   /* Deselect the FLASH: Chip Select high */
     
498.   SPI_FLASH_CS_HIGH();
     
499. }
     
500. 
     
501. /*******************************************************************************
     
502. * Function Name  : SPI_FLASH_WaitForWriteEnd
     
503. * Description    : Polls the status of the Write In Progress (WIP) flag in the
     
504. *                  FLASH's status  register  and  loop  until write  opertaion
     
505. *                  has completed.
     
506. * Input          : None
     
507. * Output         : None
     
508. * Return         : None
     
509. *******************************************************************************/
     
510. void SPI_FLASH_WaitForWriteEnd(void)
     
511. {
     
512.   u8 FLASH_Status = 0;
     
513. 
     
514.   /* Select the FLASH: Chip Select low */
     
515.   SPI_FLASH_CS_LOW();
     
516. 
     
517.   /* Send "Read Status Register" instruction */
     
518.   SPI_FLASH_SendByte(W25X_ReadStatusReg);
     
519. 
     
520.   /* Loop as long as the memory is busy with a write cycle */
     
521.   do
     
522.   {
     
523.     /* Send a dummy byte to generate the clock needed by the FLASH
     
524.     and put the value of the status register in FLASH_Status variable */
     
525.     FLASH_Status = SPI_FLASH_SendByte(Dummy_Byte);         
     
526.   }
     
527.   while ((FLASH_Status & WIP_Flag) == SET); /* Write in progress */
     
528. 
     
529.   /* Deselect the FLASH: Chip Select high */
     
530.   SPI_FLASH_CS_HIGH();
     
531. }
     
532. 
     
533. 
     
534. //进入掉电模式
     
535. void SPI_Flash_PowerDown(void)   
     
536. {
     
537.   /* Select the FLASH: Chip Select low */
     
538.   SPI_FLASH_CS_LOW();
     
539. 
     
540.   /* Send "Power Down" instruction */
     
541.   SPI_FLASH_SendByte(W25X_PowerDown);
     
542. 
     
543.   /* Deselect the FLASH: Chip Select high */
     
544.   SPI_FLASH_CS_HIGH();
     
545. }   
     
546. 
     
547. //唤醒
     
548. void SPI_Flash_WAKEUP(void)   
     
549. {
     
550.   /* Select the FLASH: Chip Select low */
     
551.   SPI_FLASH_CS_LOW();
     
552. 
     
553.   /* Send "Power Down" instruction */
     
554.   SPI_FLASH_SendByte(W25X_ReleasePowerDown);
     
555. 
     
556.   /* Deselect the FLASH: Chip Select high */
     
557.   SPI_FLASH_CS_HIGH();                   //等待TRES1
     
558. }   
     
559. 
     
560. /******************************END OF FILE*****************************/
     

复制代码

flyleaf

旧版是什么板子，到这个帖子下载配套的例程，每一项下面有板子的图片，对照来找找
【资料】野火产品资料合集（所有产品资料链接都在此处）-点击名称后下拉浏览器滚动条~
http://www.firebbs.cn/forum.php? ... 2686&fromuid=64
(出处: 野火论坛)

Alvin_Huang

flyleaf 发表于 2017-6-29 15:52
旧版是什么板子，到这个帖子下载配套的例程，每一项下面有板子的图片，对照来找找
【资料】野火产品资料合 ...

芯片是F103VET6的，好久之前买的了，能否看看代码有没有问题？查了好久都不知道什么问题。

Alvin_Huang

flyleaf 发表于 2017-6-29 15:52
旧版是什么板子，到这个帖子下载配套的例程，每一项下面有板子的图片，对照来找找
【资料】野火产品资料合 ...

野火M3的开发板

Alvin_Huang

已找到问题，FLASH的扇区保护了，查询FLASH的寄存器标志可知道，S2,S3,S4,S5的值都为1，把这几位置0则关闭保护，擦除成功。不知道是什么时候被保护的，搞了好久才弄明白，血的教训，以后用什么器件都要老老实实的看DataSheet啦。