FLASHSPI

因为稍后要用到字库等，所以先把Flash弄了，使用SPI接口，神舟的2Mbyte，原子的6Mbyte，都是W25X系列。神舟真是小气的可以，搞个Flash和EEPROM一样大。

与SD的读写byte一样。

初始化之后读取Flash ID以此来判断是否初始化成功。

主要是一些读写，擦除函数。主要用的神舟代码这次，有部分借鉴原子的

初始化，读取ID，擦除，读写都OK了。

FLASHSPI_CONFIG_H

 1 #ifndef __FLASHSPI_CONFIG_H
 2 #define __FLASHSPI_CONFIG_H
 3 //#include "sys.h"
 4 
 5 /**
 6   * @brief  SPI_FLASH SPI Interface pins
 7   */
 8 
 9 #define SPI_FLASH_SPI                           SPI1
10 #define SPI_FLASH_SPI_CLK                       RCC_APB2Periph_SPI1
11 #define SPI_FLASH_SPI_SCK_PIN                   GPIO_Pin_5                  /* PA.05 */
12 #define SPI_FLASH_SPI_SCK_GPIO_PORT             GPIOA                       /* GPIOA */
13 #define SPI_FLASH_SPI_SCK_GPIO_CLK              RCC_APB2Periph_GPIOA
14 #define SPI_FLASH_SPI_MISO_PIN                  GPIO_Pin_6                  /* PA.06 */
15 #define SPI_FLASH_SPI_MISO_GPIO_PORT            GPIOA                       /* GPIOA */
16 #define SPI_FLASH_SPI_MISO_GPIO_CLK             RCC_APB2Periph_GPIOA
17 #define SPI_FLASH_SPI_MOSI_PIN                  GPIO_Pin_7                  /* PA.07 */
18 #define SPI_FLASH_SPI_MOSI_GPIO_PORT            GPIOA                       /* GPIOA */
19 #define SPI_FLASH_SPI_MOSI_GPIO_CLK             RCC_APB2Periph_GPIOA
20 #define SPI_FLASH_CS_PIN                        GPIO_Pin_9                  /* PB.09 */
21 #define SPI_FLASH_CS_GPIO_PORT                  GPIOB                       /* GPIOD */
22 #define SPI_FLASH_CS_GPIO_CLK                   RCC_APB2Periph_GPIOB
23 
24 #define SD_CS_PIN                         GPIO_Pin_11             /* PD.11 */
25 #define SD_CS_GPIO_PORT                   GPIOD                   /* GPIOD */
26 #define SD_CS_GPIO_CLK                    RCC_APB2Periph_GPIOD
27 
28 /* Private define ------------------------------------------------------------*/
29 //W25X系列/Q系列芯片列表       
30 //W25Q80 ID  0XEF13
31 //W25Q16 ID  0XEF14
32 //W25Q32 ID  0XEF15
33 //W25Q32 ID  0XEF16    
34 //指令 90h Manufacturer/Device ID (ID7-ID0)
35 #define W25Q80     0XEF13     
36 #define W25Q16     0XEF14
37 #define W25Q32     0XEF15
38 #define W25Q64     0XEF16
39 //指令 9Fh JEDEC ID      (ID15-ID0)
40 //#define W25Q80     0XEF3014     
41 //#define W25Q16     0XEF3015
42 //#define W25Q32     0XEF3016
43 //#define W25Q64     0XEF3017
44 
45 #define W25X_WriteEnable        0x06 
46 #define W25X_WriteDisable        0x04 
47 #define W25X_ReadStatusReg        0x05 
48 #define W25X_WriteStatusReg        0x01 
49 #define W25X_ReadData            0x03 
50 #define W25X_FastReadData        0x0B 
51 #define W25X_FastReadDual        0x3B 
52 #define W25X_PageProgram        0x02 
53 #define W25X_BlockErase            0xD8 
54 #define W25X_SectorErase        0x20 
55 #define W25X_ChipErase            0xC7 
56 #define W25X_PowerDown            0xB9 
57 #define W25X_ReleasePowerDown    0xAB 
58 #define W25X_DeviceID            0xAB 
59 #define W25X_ManufactDeviceID    0x90 
60 #define W25X_JedecDeviceID        0x9F 
61 
62 #define WIP_Flag                0x01  /* Write In Progress (WIP) flag */
63 
64 #define Dummy_Byte              0xFF//0xA5
65 
66 /* Private typedef -----------------------------------------------------------*/
67 //#define SPI_FLASH_PageSize      4096
68 #define SPI_FLASH_PageSize      256
69 #define SPI_FLASH_PerWritePageSize      256
70 
71 /* Exported macro ------------------------------------------------------------*/
72 /* Select SPI FLASH: Chip Select pin low  */
73 #define SPI_FLASH_CS_LOW()       GPIO_ResetBits(SPI_FLASH_CS_GPIO_PORT, SPI_FLASH_CS_PIN)
74 /* Deselect SPI FLASH: Chip Select pin high */
75 #define SPI_FLASH_CS_HIGH()      GPIO_SetBits(SPI_FLASH_CS_GPIO_PORT, SPI_FLASH_CS_PIN)
76 
77 /*----- Low layer function -----*/
78 u8 SPI_FLASH_ReadByte(void);
79 u8 SPI_FLASH_SendByte(u8 byte);
80 u16 SPI_FLASH_SendHalfWord(u16 HalfWord);
81 void SPI_FLASH_WriteEnable(void);
82 void SPI_FLASH_WriteDisable(void);
83 void SPI_FLASH_WaitForWriteEnd(void);
84 
85 /* Exported functions ------------------------------------------------------- */
86 /*----- High layer function -----*/
87 void SPI_FLASH_Init(void);
88 void SPI_Flash_PowerDown(void);
89 void SPI_Flash_WAKEUP(void);
90 void SPI_FLASH_SectorErase(u32 SectorAddr);
91 void SPI_FLASH_ChipErase(void);
92 void SPI_FLASH_PageWrite(u8* pBuffer, u32 WriteAddr, u16 NumByteToWrite);
93 void SPI_FLASH_BufferWrite(u8* pBuffer, u32 WriteAddr, u16 NumByteToWrite);
94 void SPI_FLASH_BufferRead(u8* pBuffer, u32 ReadAddr, u16 NumByteToRead);
95 void SPI_FLASH_StartReadSequence(u32 ReadAddr);
96 u32  SPI_FLASH_ReadJedecID(void);
97 u32  SPI_FLASH_ReadDeviceID(void);
98 
99 #endif

spi_config.c

  1 #include "stm32f10x.h"
  2 #include "stm32f10x_gpio.h"
  3 #include "stm32f10x_rcc.h"
  4 #include "stm32f10x_rtc.h"
  5 #include "stm32f10x_spi.h"
  6 #include "flashspi_config.h"
  7 #include "spi_config.h"
  8 
  9 //Flash pin map:FlashCS-PB9 MISO-PA6 MOSI-PA7 SCK-PA5 SDCS-PD11
 10 void SPI_FLASH_Init(void)
 11 {
 12   SPI_InitTypeDef  SPI_InitStructure;
 13   GPIO_InitTypeDef GPIO_InitStructure;
 14 
 15   
 16   /* Enable SPI1 and GPIO clocks */
 17   /*!< SPI_FLASH_SPI_CS_GPIO, SPI_FLASH_SPI_MOSI_GPIO, 
 18        SPI_FLASH_SPI_MISO_GPIO, SPI_FLASH_SPI_DETECT_GPIO 
 19        and SPI_FLASH_SPI_SCK_GPIO Periph clock enable */
 20   RCC_APB2PeriphClockCmd(SPI_FLASH_CS_GPIO_CLK | SPI_FLASH_SPI_MOSI_GPIO_CLK |
 21                          SPI_FLASH_SPI_MISO_GPIO_CLK | SPI_FLASH_SPI_SCK_GPIO_CLK |
 22                          RCC_APB2Periph_GPIOD, ENABLE);
 23 
 24   /* Disable SD CS  */
 25   GPIO_InitStructure.GPIO_Pin = SD_CS_PIN;
 26   GPIO_InitStructure.GPIO_Mode = GPIO_Mode_Out_PP;
 27   GPIO_InitStructure.GPIO_Speed = GPIO_Speed_50MHz;
 28   GPIO_Init(SD_CS_GPIO_PORT, &GPIO_InitStructure);
 29   GPIO_SetBits(SD_CS_GPIO_PORT, SD_CS_PIN);
 30 
 31   /*!< SPI_FLASH_SPI Periph clock enable */
 32   RCC_APB2PeriphClockCmd(SPI_FLASH_SPI_CLK, ENABLE);
 33   /*!< AFIO Periph clock enable */
 34   RCC_APB2PeriphClockCmd(RCC_APB2Periph_AFIO, ENABLE);
 35   /*!< Remap SPI3 Pins */
 36   //GPIO_PinRemapConfig(GPIO_Remap_SPI3,ENABLE);  
 37   
 38   /*!< Configure SPI_FLASH_SPI pins: SCK */
 39   GPIO_InitStructure.GPIO_Pin = SPI_FLASH_SPI_SCK_PIN;
 40   GPIO_InitStructure.GPIO_Speed = GPIO_Speed_50MHz;
 41   GPIO_InitStructure.GPIO_Mode = GPIO_Mode_AF_PP;
 42   GPIO_Init(SPI_FLASH_SPI_SCK_GPIO_PORT, &GPIO_InitStructure);
 43 
 44   /*!< Configure SPI_FLASH_SPI pins: MISO */
 45   GPIO_InitStructure.GPIO_Pin = SPI_FLASH_SPI_MISO_PIN;
 46   GPIO_Init(SPI_FLASH_SPI_MISO_GPIO_PORT, &GPIO_InitStructure);
 47 
 48   /*!< Configure SPI_FLASH_SPI pins: MOSI */
 49   GPIO_InitStructure.GPIO_Pin = SPI_FLASH_SPI_MOSI_PIN;
 50   GPIO_Init(SPI_FLASH_SPI_MOSI_GPIO_PORT, &GPIO_InitStructure);
 51 
 52   /*!< Configure SPI_FLASH_SPI_CS_PIN pin: SPI_FLASH Card CS pin */
 53   GPIO_InitStructure.GPIO_Pin = SPI_FLASH_CS_PIN;
 54   GPIO_InitStructure.GPIO_Mode = GPIO_Mode_Out_PP;
 55   GPIO_Init(SPI_FLASH_CS_GPIO_PORT, &GPIO_InitStructure);
 56 
 57   /* Deselect the FLASH: Chip Select high */
 58   SPI_FLASH_CS_HIGH();
 59 
 60   /* SPI1 configuration */
 61   // W25X16: data input on the DIO pin is sampled on the rising edge of the CLK. 
 62   // Data on the DO and DIO pins are clocked out on the falling edge of CLK.
 63   SPI_InitStructure.SPI_Direction = SPI_Direction_2Lines_FullDuplex;
 64   SPI_InitStructure.SPI_Mode = SPI_Mode_Master;
 65   SPI_InitStructure.SPI_DataSize = SPI_DataSize_8b;
 66   SPI_InitStructure.SPI_CPOL = SPI_CPOL_High;
 67   SPI_InitStructure.SPI_CPHA = SPI_CPHA_2Edge;
 68   SPI_InitStructure.SPI_NSS = SPI_NSS_Soft;
 69   SPI_InitStructure.SPI_BaudRatePrescaler = SPI_BaudRatePrescaler_4;
 70   SPI_InitStructure.SPI_FirstBit = SPI_FirstBit_MSB;
 71   SPI_InitStructure.SPI_CRCPolynomial = 7;
 72   SPI_Init(SPI1, &SPI_InitStructure);
 73 
 74   /* Enable SPI1  */
 75   SPI_Cmd(SPI1, ENABLE);
 76 }
 77 
 78 u8 SPI_FLASH_ReadByte(void)
 79 {
 80     return  SPI1_ReadWriteByte(0xFF);
 81 }
 82 
 83 u8 SPI_FLASH_SendByte(u8 byte)
 84 {
 85     return  SPI1_ReadWriteByte(byte);
 86 }
 87 
 88 /*******************************************************************************
 89 * Function Name  : SPI_FLASH_WriteEnable
 90 * Description    : Enables the write access to the FLASH.
 91 * Input          : None
 92 * Output         : None
 93 * Return         : None
 94 *******************************************************************************/
 95 void SPI_FLASH_WriteEnable(void)
 96 {
 97   /* Select the FLASH: Chip Select low */
 98   SPI_FLASH_CS_LOW();
 99 
100   /* Send "Write Enable" instruction */
101   SPI_FLASH_SendByte(W25X_WriteEnable);
102 
103   /* Deselect the FLASH: Chip Select high */
104   SPI_FLASH_CS_HIGH();
105 }
106 
107 /*******************************************************************************
108 * Function Name  : SPI_FLASH_WriteDisable
109 * Description    : Disables the write access to the FLASH.
110 * Input          : None
111 * Output         : None
112 * Return         : None
113 *******************************************************************************/
114 void SPI_FLASH_WriteDisable(void)
115 {
116   /* Select the FLASH: Chip Select low */
117   SPI_FLASH_CS_LOW();
118 
119   /* Send "Write Enable" instruction */
120   SPI_FLASH_SendByte(W25X_WriteDisable);
121 
122   /* Deselect the FLASH: Chip Select high */
123   SPI_FLASH_CS_HIGH();
124 }
125 
126 /*******************************************************************************
127 * Function Name  : SPI_FLASH_WaitForWriteEnd
128 * Description    : Polls the status of the Write In Progress (WIP) flag in the
129 *                  FLASH's status  register  and  loop  until write  opertaion
130 *                  has completed.
131 * Input          : None
132 * Output         : None
133 * Return         : None
134 *******************************************************************************/
135 void SPI_FLASH_WaitForWriteEnd(void)
136 {
137   u8 FLASH_Status = 0;
138 
139   /* Select the FLASH: Chip Select low */
140   SPI_FLASH_CS_LOW();
141 
142   /* Send "Read Status Register" instruction */
143   SPI_FLASH_SendByte(W25X_ReadStatusReg);
144 
145   /* Loop as long as the memory is busy with a write cycle */
146   do
147   {
148     /* Send a dummy byte to generate the clock needed by the FLASH
149     and put the value of the status register in FLASH_Status variable */
150     FLASH_Status = SPI_FLASH_SendByte(Dummy_Byte);
151 
152   }
153   while ((FLASH_Status & WIP_Flag) == SET); /* Write in progress */
154 
155   /* Deselect the FLASH: Chip Select high */
156   SPI_FLASH_CS_HIGH();
157 }
158 
159 //进入掉电模式
160 void SPI_Flash_PowerDown(void)   
161 { 
162   /* Select the FLASH: Chip Select low */
163   SPI_FLASH_CS_LOW();
164 
165   /* Send "Power Down" instruction */
166   SPI_FLASH_SendByte(W25X_PowerDown);
167 
168   /* Deselect the FLASH: Chip Select high */
169   SPI_FLASH_CS_HIGH();
170 }   
171 
172 //唤醒
173 void SPI_Flash_WAKEUP(void)   
174 {
175   /* Select the FLASH: Chip Select low */
176   SPI_FLASH_CS_LOW();
177 
178   /* Send "Power Down" instruction */
179   SPI_FLASH_SendByte(W25X_ReleasePowerDown);
180 
181   /* Deselect the FLASH: Chip Select high */
182   SPI_FLASH_CS_HIGH();                             //等待TRES1
183 }   
184 
185 /*******************************************************************************
186 * Function Name  : SPI_FLASH_SectorErase
187 * Description    : Erases the specified FLASH sector.
188 * Input          : SectorAddr: address of the sector to erase.
189 * Output         : None
190 * Return         : None
191 *******************************************************************************/
192 void SPI_FLASH_SectorErase(u32 SectorAddr)
193 {
194   /* Send write enable instruction */
195   SPI_FLASH_WriteEnable();
196 
197   /* Sector Erase */
198   /* Select the FLASH: Chip Select low */
199   SPI_FLASH_CS_LOW();
200   /* Send Sector Erase instruction */
201   SPI_FLASH_SendByte(W25X_SectorErase);
202   /* Send SectorAddr high nibble address byte */
203   SPI_FLASH_SendByte((SectorAddr & 0xFF0000) >> 16);
204   /* Send SectorAddr medium nibble address byte */
205   SPI_FLASH_SendByte((SectorAddr & 0xFF00) >> 8);
206   /* Send SectorAddr low nibble address byte */
207   SPI_FLASH_SendByte(SectorAddr & 0xFF);
208   /* Deselect the FLASH: Chip Select high */
209   SPI_FLASH_CS_HIGH();
210 
211   /* Wait the end of Flash writing */
212   SPI_FLASH_WaitForWriteEnd();
213 }
214 
215 /*******************************************************************************
216 * Function Name  : SPI_FLASH_BulkErase
217 * Description    : Erases the entire FLASH.
218 * Input          : None
219 * Output         : None
220 * Return         : None
221 *******************************************************************************/
222 void SPI_FLASH_ChipErase(void)
223 {
224   /* Send write enable instruction */
225   SPI_FLASH_WriteEnable();
226 
227   /* Bulk Erase */
228   /* Select the FLASH: Chip Select low */
229   SPI_FLASH_CS_LOW();
230   /* Send Bulk Erase instruction  */
231   SPI_FLASH_SendByte(W25X_ChipErase);
232   /* Deselect the FLASH: Chip Select high */
233   SPI_FLASH_CS_HIGH();
234 
235   /* Wait the end of Flash writing */
236   SPI_FLASH_WaitForWriteEnd();
237 }
238 
239 /*******************************************************************************
240 * Function Name  : SPI_FLASH_PageWrite
241 * Description    : Writes more than one byte to the FLASH with a single WRITE
242 *                  cycle(Page WRITE sequence). The number of byte can't exceed
243 *                  the FLASH page size.
244 * Input          : - pBuffer : pointer to the buffer  containing the data to be
245 *                    written to the FLASH.
246 *                  - WriteAddr : FLASH's internal address to write to.
247 *                  - NumByteToWrite : number of bytes to write to the FLASH,
248 *                    must be equal or less than "SPI_FLASH_PageSize" value.
249 * Output         : None
250 * Return         : None
251 *******************************************************************************/
252 void SPI_FLASH_PageWrite(u8* pBuffer, u32 WriteAddr, u16 NumByteToWrite)
253 {
254   /* Enable the write access to the FLASH */
255   SPI_FLASH_WriteEnable();
256 
257   /* Select the FLASH: Chip Select low */
258   SPI_FLASH_CS_LOW();
259   /* Send "Write to Memory " instruction */
260   SPI_FLASH_SendByte(W25X_PageProgram);
261   /* Send WriteAddr high nibble address byte to write to */
262   SPI_FLASH_SendByte((WriteAddr & 0xFF0000) >> 16);
263   /* Send WriteAddr medium nibble address byte to write to */
264   SPI_FLASH_SendByte((WriteAddr & 0xFF00) >> 8);
265   /* Send WriteAddr low nibble address byte to write to */
266   SPI_FLASH_SendByte(WriteAddr & 0xFF);
267 
268   if(NumByteToWrite > SPI_FLASH_PerWritePageSize)
269   {
270      NumByteToWrite = SPI_FLASH_PerWritePageSize;
271      printf("\n\r Err: SPI_FLASH_PageWrite too large!");
272   }
273 
274   /* while there is data to be written on the FLASH */
275   while (NumByteToWrite--)
276   {
277     /* Send the current byte */
278     SPI_FLASH_SendByte(*pBuffer);
279     /* Point on the next byte to be written */
280     pBuffer++;
281   }
282 
283   /* Deselect the FLASH: Chip Select high */
284   SPI_FLASH_CS_HIGH();
285 
286   /* Wait the end of Flash writing */
287   SPI_FLASH_WaitForWriteEnd();
288 }
289 
290 /*******************************************************************************
291 * Function Name  : SPI_FLASH_BufferWrite
292 * Description    : Writes block of data to the FLASH. In this function, the
293 *                  number of WRITE cycles are reduced, using Page WRITE sequence.
294 * Input          : - pBuffer : pointer to the buffer  containing the data to be
295 *                    written to the FLASH.
296 *                  - WriteAddr : FLASH's internal address to write to.
297 *                  - NumByteToWrite : number of bytes to write to the FLASH.
298 * Output         : None
299 * Return         : None
300 *******************************************************************************/
301 void SPI_FLASH_BufferWrite(u8* pBuffer, u32 WriteAddr, u16 NumByteToWrite)
302 {
303   u8 NumOfPage = 0, NumOfSingle = 0, Addr = 0, count = 0, temp = 0;
304 
305   Addr = WriteAddr % SPI_FLASH_PageSize;
306   count = SPI_FLASH_PageSize - Addr;
307   NumOfPage =  NumByteToWrite / SPI_FLASH_PageSize;
308   NumOfSingle = NumByteToWrite % SPI_FLASH_PageSize;
309 
310   if (Addr == 0) /* WriteAddr is SPI_FLASH_PageSize aligned  */
311   {
312     if (NumOfPage == 0) /* NumByteToWrite < SPI_FLASH_PageSize */
313     {
314       SPI_FLASH_PageWrite(pBuffer, WriteAddr, NumByteToWrite);
315     }
316     else /* NumByteToWrite > SPI_FLASH_PageSize */
317     {
318       while (NumOfPage--)
319       {
320         SPI_FLASH_PageWrite(pBuffer, WriteAddr, SPI_FLASH_PageSize);
321         WriteAddr +=  SPI_FLASH_PageSize;
322         pBuffer += SPI_FLASH_PageSize;
323       }
324 
325       SPI_FLASH_PageWrite(pBuffer, WriteAddr, NumOfSingle);
326     }
327   }
328   else /* WriteAddr is not SPI_FLASH_PageSize aligned  */
329   {
330     if (NumOfPage == 0) /* NumByteToWrite < SPI_FLASH_PageSize */
331     {
332       if (NumOfSingle > count) /* (NumByteToWrite + WriteAddr) > SPI_FLASH_PageSize */
333       {
334         temp = NumOfSingle - count;
335 
336         SPI_FLASH_PageWrite(pBuffer, WriteAddr, count);
337         WriteAddr +=  count;
338         pBuffer += count;
339 
340         SPI_FLASH_PageWrite(pBuffer, WriteAddr, temp);
341       }
342       else
343       {
344         SPI_FLASH_PageWrite(pBuffer, WriteAddr, NumByteToWrite);
345       }
346     }
347     else /* NumByteToWrite > SPI_FLASH_PageSize */
348     {
349       NumByteToWrite -= count;
350       NumOfPage =  NumByteToWrite / SPI_FLASH_PageSize;
351       NumOfSingle = NumByteToWrite % SPI_FLASH_PageSize;
352 
353       SPI_FLASH_PageWrite(pBuffer, WriteAddr, count);
354       WriteAddr +=  count;
355       pBuffer += count;
356 
357       while (NumOfPage--)
358       {
359         SPI_FLASH_PageWrite(pBuffer, WriteAddr, SPI_FLASH_PageSize);
360         WriteAddr +=  SPI_FLASH_PageSize;
361         pBuffer += SPI_FLASH_PageSize;
362       }
363 
364       if (NumOfSingle != 0)
365       {
366         SPI_FLASH_PageWrite(pBuffer, WriteAddr, NumOfSingle);
367       }
368     }
369   }
370 }
371 
372 /*******************************************************************************
373 * Function Name  : SPI_FLASH_BufferRead
374 * Description    : Reads a block of data from the FLASH.
375 * Input          : - pBuffer : pointer to the buffer that receives the data read
376 *                    from the FLASH.
377 *                  - ReadAddr : FLASH's internal address to read from.
378 *                  - NumByteToRead : number of bytes to read from the FLASH.
379 * Output         : None
380 * Return         : None
381 *******************************************************************************/
382 void SPI_FLASH_BufferRead(u8* pBuffer, u32 ReadAddr, u16 NumByteToRead)
383 {
384   /* Select the FLASH: Chip Select low */
385   SPI_FLASH_CS_LOW();
386 
387   /* Send "Read from Memory " instruction */
388   SPI_FLASH_SendByte(W25X_ReadData);
389 
390   /* Send ReadAddr high nibble address byte to read from */
391   SPI_FLASH_SendByte((ReadAddr & 0xFF0000) >> 16);
392   /* Send ReadAddr medium nibble address byte to read from */
393   SPI_FLASH_SendByte((ReadAddr& 0xFF00) >> 8);
394   /* Send ReadAddr low nibble address byte to read from */
395   SPI_FLASH_SendByte(ReadAddr & 0xFF);
396 
397   while (NumByteToRead--) /* while there is data to be read */
398   {
399     /* Read a byte from the FLASH */
400     *pBuffer = SPI_FLASH_SendByte(Dummy_Byte);
401     /* Point to the next location where the byte read will be saved */
402     pBuffer++;
403   }
404 
405   /* Deselect the FLASH: Chip Select high */
406   SPI_FLASH_CS_HIGH();
407 }
408 
409 /*******************************************************************************
410 * Function Name  : SPI_FLASH_StartReadSequence
411 * Description    : Initiates a read data byte (READ) sequence from the Flash.
412 *                  This is done by driving the /CS line low to select the device,
413 *                  then the READ instruction is transmitted followed by 3 bytes
414 *                  address. This function exit and keep the /CS line low, so the
415 *                  Flash still being selected. With this technique the whole
416 *                  content of the Flash is read with a single READ instruction.
417 * Input          : - ReadAddr : FLASH's internal address to read from.
418 * Output         : None
419 * Return         : None
420 *******************************************************************************/
421 void SPI_FLASH_StartReadSequence(u32 ReadAddr)
422 {
423   /* Select the FLASH: Chip Select low */
424   SPI_FLASH_CS_LOW();
425 
426   /* Send "Read from Memory " instruction */
427   SPI_FLASH_SendByte(W25X_ReadData);
428 
429   /* Send the 24-bit address of the address to read from -----------------------*/
430   /* Send ReadAddr high nibble address byte */
431   SPI_FLASH_SendByte((ReadAddr & 0xFF0000) >> 16);
432   /* Send ReadAddr medium nibble address byte */
433   SPI_FLASH_SendByte((ReadAddr& 0xFF00) >> 8);
434   /* Send ReadAddr low nibble address byte */
435   SPI_FLASH_SendByte(ReadAddr & 0xFF);
436 }
437 
438 /*******************************************************************************
439 * Function Name  : SPI_FLASH_ReadJedecID
440 * Description    : Reads FLASH identification.
441 * Input          : None
442 * Output         : None
443 * Return         : FLASH identification
444 *******************************************************************************/
445 u32 SPI_FLASH_ReadJedecID(void)
446 {
447   u32 Temp = 0, Temp0 = 0, Temp1 = 0, Temp2 = 0;
448 
449   /* Select the FLASH: Chip Select low */
450   SPI_FLASH_CS_LOW();
451 
452   /* Send "RDID " instruction */
453   SPI_FLASH_SendByte(W25X_JedecDeviceID);
454 
455   /* Read a byte from the FLASH */
456   Temp0 = SPI_FLASH_SendByte(Dummy_Byte);
457 
458   /* Read a byte from the FLASH */
459   Temp1 = SPI_FLASH_SendByte(Dummy_Byte);
460 
461   /* Read a byte from the FLASH */
462   Temp2 = SPI_FLASH_SendByte(Dummy_Byte);
463 
464   /* Deselect the FLASH: Chip Select high */
465   SPI_FLASH_CS_HIGH();
466 
467   Temp = (Temp0 << 16) | (Temp1 << 8) | Temp2;
468 
469   return Temp;
470 }
471 /*******************************************************************************
472 * Function Name  : SPI_FLASH_ReadID
473 * Description    : Reads FLASH identification.
474 * Input          : None
475 * Output         : None
476 * Return         : FLASH identification
477 *******************************************************************************/
478 u32 SPI_FLASH_ReadDeviceID(void)
479 {
480   u32 Temp = 0;
481 
482   /* Select the FLASH: Chip Select low */
483   SPI_FLASH_CS_LOW();
484 
485   /* Send "RDID " instruction */
486   SPI_FLASH_SendByte(W25X_DeviceID);
487   SPI_FLASH_SendByte(Dummy_Byte);
488   SPI_FLASH_SendByte(Dummy_Byte);
489   SPI_FLASH_SendByte(Dummy_Byte);
490   
491   /* Read a byte from the FLASH */
492   Temp = SPI_FLASH_SendByte(Dummy_Byte);
493 
494   /* Deselect the FLASH: Chip Select high */
495   SPI_FLASH_CS_HIGH();
496 
497   return Temp;
498 }

     SPI_FLASH_Init();
  printf("\r\n SPI_FLASH_ReadJedecID：%x \n\r",SPI_FLASH_ReadJedecID());
  printf("\r\n SPI_FLASH_ReadDeviceID：%x \n\r",SPI_FLASH_ReadDeviceID());
  SPI_FLASH_SectorErase(0);
  for(sd_size=0;sd_size<512;sd_size++)buf[sd_size]=0x55;
        SPI_FLASH_BufferWrite(buf,0,500);
        SPI_FLASH_BufferRead(buf,0,512);
        for(sd_size=0;sd_size<512;sd_size++)printf("%x ",buf[sd_size]);//打印0扇区数据