FLASH简介
% T0 `" i( ^% H7 s) i" ^9 [- BFLASH俗称闪存，和EEPROM一样，都是掉电数据不丢失的非易失行存储器，但FLASH的存储容量普遍大于EEPROM，现在像如U盘、SD卡、SSD固态硬盘以及STM32芯片内部存储程序的设备都是FLASH类型的存储器。由此可见FLASH对于我们学习和工作的重要性，EEPROM可以实现单字节的擦写，而FLASH都是一大片的擦写，就像是大规模杀伤性武器，其最小擦除单：扇区的大小也是4KB。
, g3 v! m& K: T& C. |. \我们此次通过SPI对FLASH存储芯片W25Q64进行读写擦除的操作。

% F, H- S9 W& H" E  s对于FLASH内部结构的详细说明博主会专门整理一篇博客来说明，所以关于FLASH芯片的相关原理，本文中只做简单说明，侧重代码部分。
* J0 `- x1 L" j+ SFLASH详细说明的博客链接：（没有链接就说明还没有整理出）
' l) s+ [7 D/ l5 G
W25Q64
W25Q64简介
就长这么个样子
* r9 S1 t3 ~3 ?! @8 H8 K  U

3 ^( O/ J, ?, ~  g2 `
STM32内部原理图如下：

, f& s3 d# R/ T  E7 Y

4 C: r9 M5 b: Q1 X
W25Q64是一种使用SPI通信协议的NOR FLASH存储器，它 的CS/CLK/DIO/DO 引 脚 分 别 连 接 到 了 STM32 对 应 的 SPI 引 脚NSS/SCK/MOSI/MISO 上，其中 STM32 的 NSS 引脚是一个普通的 GPIO，不是 SPI 的专用NSS 引脚，所以程序中我们要使用软件控制的方式。FLASH 芯片中还有 WP 和 HOLD 引脚。 WP 引脚可控制写保护功能，当该引脚为低电平时，禁止写入数据。我们直接接电源，不使用写保护功能。 HOLD 引脚可用于暂停通讯，该引脚为低电平时，通讯暂停，数据输出引脚输出高阻抗状态，时钟和数据输入引脚无效。我们直接接电源，不使用通讯暂停功能。
: N2 X1 C7 u( ?5 H( D& H8 ~. p
W25Q64支持SPI通讯的模式0和模式3
( u. C4 M5 a4 R

) H- S( G* q6 s+ b* J3 {FLASH控制指令
FLASH芯片中规定了许多指令，只要SPI向FLASH发送相应的指令，FLASH就会执行相应的操作，所以我们对FLASH的一切操作都是基于这个指令集的，接下来介绍一下FLASH的控制指令：
0 r( \% e8 s. |! K
) x$ z- Q# T2 i# z- X! Y
/ y1 u' C* [) F  X9 k6 G: f0 g
表中第一列为指令名，第二列为相应的指令代码，第三列及后面的内容根据指令的不同而意义不同，其中带括号的字节参数，方向为 FLASH 向主机传输，即命令响应，不带括号的则为主机向 FLASH 传输。表中“A0~A23” 指 FLASH 芯片内部存储器组织的地址； “M0~M7” 为厂商号（ MANUFACTURER ID）； “ID0-ID15”为 FLASH 芯片的ID；“dummy”指该处可为任意数据；“D0~D7” 为 FLASH 内部存储矩阵的内容。
& B! u9 R8 {4 F: i看起来很复杂的样子，其实只要在需要执行相应操作时来查这个表，只要能够理解这些指令的使用方法，FLASH就算学会了。

  M. g. |! P' E# i; q6 d5 Z例如：要知道FLASH的ID，那就在指令中找对应的取ID指令“JEDEC ID”，仔细解读这个指令
$ L! n/ h: \% l2 U* X, L, o: z
- i1 \; H6 A# n: G: K0 q8 G
5 W" x. N8 Y+ E- }- x$ b可以看出对应的指令代码为“9F”，后面的三个字节带括号，代表这三个字节就是FLASH向STM32发送的数据，即这三个字节就是FLASH的ID，然后使用SPI进行读取就可以了。

我们一般是将这些指令宏定义在头文件中，便于使用：
1 O: z! D1 c" B

1. #define W25X_WriteEnable                      0x06
   
2. #define W25X_WriteDisable                      0x04
   2 D& J7 P( S6 ^" U% Z- Y9 {( n
3. #define W25X_ReadStatusReg                      0x05
   
4. #define W25X_WriteStatusReg                      0x01
   
5. #define W25X_ReadData                              0x03
   8 D4 p7 A; E  K2 b* D6 y
6. #define W25X_FastReadData                      0x0B
   
7. #define W25X_FastReadDual                      0x3B
   
8. #define W25X_PageProgram                      0x02
   
9. #define W25X_BlockErase                              0xD8
   2 s6 Q9 n$ v( p  h
10. #define W25X_SectorErase                      0x20
    $ T9 R' ^# c* {$ }/ E* A2 r$ j
11. #define W25X_ChipErase                              0xC7
    
12. #define W25X_PowerDown                              0xB9
    
13. #define W25X_ReleasePowerDown              0xAB
    7 E5 }# O" D$ t$ q- o$ [
14. #define W25X_DeviceID                              0xAB
    
15. #define W25X_ManufactDeviceID         0x90
    ! W5 g, Z, w1 ~( W
16. #define W25X_JedecDeviceID                      0x9F
    
17. 
    ' w6 T( V3 h/ d

复制代码

FLASH内部存储结构
FLASH的存储矩阵如图：其内存分为128块，每一块都有16个扇区，每个扇区大小为4KB，擦除数据的时候是以扇区为基本单位的。

" a. H7 G# r& U/ |6 t8 `

代码讲解
. y5 E" ?2 s) w0 B代码都是博主亲手写出来的，可以运行。
1 r% H/ {7 x5 H/ k, G* [代码部分会用到SPI的代码，关于SPI的说明之前整理过：SPI详解
- v. F$ f; `( o) a( {" f* {$ k" O
读取芯片ID
: T% j$ J( Y6 ?( J4 j) F$ |

1. /************************读取芯片ID*************************************/
   . S* b7 F% t$ q+ y( Q8 A5 F8 r5 o1 W
2. uint32_t FLASH_ReadID(void)
   , T" D4 S# i4 a$ \
3. {
   
4.         uint32_t temp,temp1,temp2,temp3;
   
5.         SPI_NSS_Begin();
   
6.         /* 发送取ID指令 */
   " a1 `4 x# g5 F3 p6 G6 M
7.         SPI_SendData( W25X_JedecDeviceID);
   
8.         /* FLASH会连续发送三个字节数据 */
   
9.         temp1=SPI_SendData(Dummy_Byte);
   5 y7 ~% Y9 m0 b9 R, k) {; j0 [) s
10.         temp2=SPI_SendData(Dummy_Byte);
    + }4 I& S& u; m) Q! }
11.         temp3=SPI_SendData(Dummy_Byte);
    * a7 y  E( Q* ]3 {3 Q
12.         SPI_NSS_Stop();
    " ^/ ?, q* |: s2 V$ y
13.         /* 高为先行，将三个字节整理在一起 */
    
14.         temp=temp1<<16 | temp2<<8 | temp3;
    
15.         return temp;
    
16. }
    

复制代码

由于SPI是全双工通信，所以接收数据和发送数据用的是同一个函数
, r; Z4 Q0 V4 j, y
发送写使能信号
9 b+ w" r+ f8 Q

1. /****************发送写使能信号****************************/
   
2. void FLASH_WriteEnable(void)
   " j0 T" h1 `( A& v+ H) W
3. {
   
4.         SPI_NSS_Begin();
   $ p/ Y, r  `' c" Z, b) y' n: e
5.         /* 发送相应的指令代码 */
   ( R2 t9 y- n$ b: H# a
6.         SPI_SendData(W25X_WriteEnable);
   4 x; z( |2 ~  l: B. S9 {+ I
7.         SPI_NSS_Stop();
   
8. }
   

复制代码

% [. ?% ?0 I/ r在向FLASH中执行写操作之前，都要进行写使能操作，通过发送写使能指令到FLASH来实现

* O5 ?' Z. {: [4 D7 U5 I等待FLASH不忙

1. /******************等待，直到不忙***********************************/
   : }" _$ M' d; d7 e! m
2. void FLASH_WaitBusy(void)
   # Q% S% B% D( ^5 p# K2 {
3. {
     n: {  `" j: d0 F- G. \, O0 M
4.         uint8_t StatusReg=0x01;
   
5.         SPI_NSS_Begin();
   
6.    /* 读取状态寄存器中的数据，判断忙标志0x01位 置位代表忙 */
   
7.         SPI_SendData(W25X_ReadStatusReg);      
   . ], \; |3 h1 p0 ?: i' N3 P
8.    /* 只读取状态寄存器的BUSY位，即第一位 */
   
9.         while((StatusReg & 0x01) == 1)
   3 g' q' i" i7 x1 b
10.                 StatusReg=SPI_SendData(Dummy_Byte);
    
11.         SPI_NSS_Stop();
    
12. }
    ( l) k, D: d* X+ i1 g8 V3 o
13. 
    
14. 
    

复制代码

FLASH在通讯的过程中需要一定的时间来执行操作，在这期间，传输数据是无效的，因为FLASH忙着呢，所以我们就要有一个函数来专门等！等到FLASH不忙了，再进行通讯，那怎么等呢？FLASH不忙了会给出一个信号——将状态寄存器的BUSY位重置（也就是0），所以我们需要不断的来检测状态寄存器中的BUSY位是否置位，利用读取寄存器状态的指令来获取状态寄存器当下的状态，然后根据寄存器的BUSY位（第1位）来判断FLASH是否处于忙碌状态。
  q4 i$ T9 z! j# C简单来说，这就是个延时函数，延时直到FLASH空闲，可以进行下一步传输。
0 W  t3 f& r: u" E3 u

( A- E" K4 `% j4 `$ p- V擦除扇区

1. /******擦除扇区的内容,切记地址要对其到4kB，每个扇区的大小都是4KB********/
   
2. void FLASH_SectorErase(uint32_t addr)
   
3. {
   # M' T3 D8 m( Q4 C; ]/ Q, k
4.         /* 开始的时候要发送写使能信号*/
   
5.         FLASH_WriteEnable();
   
6.         SPI_NSS_Begin();
   
7.         /* 发送扇区擦除命令 */
   
8.         SPI_SendData(W25X_SectorErase);
   
9.         /* 发送扇区的地址，高位先行 */
   
10.         SPI_SendData((addr & 0xff0000) >> 16);
    1 H  V' f6 n0 z
11.         SPI_SendData((addr & 0xff00) >> 8);
    
12.         SPI_SendData(addr & 0xff);
    ; v4 Z' G! n) `6 z
13.         SPI_NSS_Stop();
    $ V+ l0 i( J6 G) s) t3 m
14.         /* 最后也要等待FLASH处理完这次的信号再退出 */
    
15.         FLASH_WaitBusy();
    
16. }
    
17. 
    

复制代码

. B) Z* ^2 S8 q+ C& ?扇区的擦除之前要发送一个写使能信号，先发送擦除指令，然后发送要擦除扇区的地址（分三个字节发出去），高位先行。
7 T# [$ t* \4 ~  h% C6 G4 r扇区上的内容不是1就是0，擦除的过程就是写1的过程（将一个扇区全部写1），因为在写入数据的时候，可以将1写为0，但不能将0写为1.
6 o# r1 @; V* b

写入数据

1. /************按页写入数据，但写入之前要进行擦除***********/
   8 x+ K6 ]; D; X- ?
2. void FLASH_PageWrite(uint32_t addr , uint8_t* pBuffer ,uint8_t size)
   4 d; e  J) n( J/ l! d( K5 W
3. {
   
4.         /* 开始的时候要发送写使能信号 */
     }: k) F9 ]+ {- w& K# n' j6 ^
5.         FLASH_WriteEnable();
   $ G; P& m' T( l. A! i
6.         SPI_NSS_Begin();
   
7.         /* 发送页写入命令 */
   
8.         SPI_SendData(W25X_PageProgram);
   3 h7 S1 X! {' H$ R* \$ S
9.         /* 发送写入的地址，高位先行 */
   , o  I1 a; ]" z8 d, `
10.         SPI_SendData((addr & 0xff0000) >> 16);
    
11.         SPI_SendData((addr & 0xff00) >> 8);
    ) E& ~1 ^; `& e8 W
12.         SPI_SendData(addr & 0xff);
    
13.         /* 逐位发送数据 */
    $ D3 S) i; R* S; g
14.         while(size--)
    
15.         {
    
16.                 SPI_SendData(*pBuffer);
    
17.                 pBuffer++;
    
18.         }
    
19.         SPI_NSS_Stop();
    * H. K& y6 ]8 F1 T/ d
20.         /* 最后也要等待FLASH处理完这次的信号再退出 */
    4 w( p4 p5 t  _# A- Z
21.         FLASH_WaitBusy();
    ( V1 i- t1 f) A
22. }
    
23. 
    

复制代码

) [6 U) I8 L  @% v' T在执行写入数据的时候函数的参数有三部分：
4 y; @. x, x3 I; |+ B2 `- h6 b# a1.要写入的地址
! v% A3 z- x' r& b2.要写入数据的首地址
7 a9 B# J5 M- q* y/ |) g3.要写入数据的大小
/ d  h; |% f$ a! d( V函数在执行的过程中，首先发送一个写使能信号，然后发送写数据指令，紧接着发送数据要写入的地址，然后就是逐位发送数据了，函数最后等FLASH处理完这次操作再退出。
+ m! \, c; T6 i! P2 L

3 Z& ]% a+ e9 u% C( R读取数据
" a% h( e  t2 u& Q! p* k+ L0 U  j

1. /**********************读取指定地址、指定长度的数据******************/
   ; ]2 |9 z# O5 a+ [4 T
2. /* 因为读取在了指针中，所以不需要返回值 */
   : q" m7 J* b8 l5 O  n
3. void FLASH_BufferRead(uint32_t addr , uint8_t* pBuffer ,uint16_t size)
   , V& S8 U  A* s/ E6 k
4. {
   
5.         SPI_NSS_Begin();
   
6.         /* 发送读取命令 */
   , R' A7 V- {# m2 x
7.         SPI_SendData(W25X_ReadData);
   2 P4 s# B' j" _
8.         /* 发送读取数据的地址，高位先行 */
   $ s' J3 n- W- e, C0 h2 L' }: |7 w9 M
9.         SPI_SendData((addr & 0xff0000) >> 16);
   
10.         SPI_SendData((addr & 0xff00) >> 8);
    
11.         SPI_SendData(addr & 0xff);
    & c) D1 ^# r3 m  M
12.         /* 逐位读取数据到指针上 */
    $ I2 p3 i( p& F8 K' {& T
13.         while(size--)
    ( }/ k( _. @) `/ S) K8 f, l+ ?
14.         {
    
15.                 *pBuffer=SPI_SendData(Dummy_Byte);
    , Z7 j4 _7 C9 l  P% ^
16.                 pBuffer++;
    
17.         }
    & ~( b& ]% k2 Q' Q& W
18.         SPI_NSS_Stop();
    
19. }
    + X4 [( Q/ n' g2 @' Z
20. 
    & @# K! [& g2 ^, t$ u9 p" ^

复制代码

2 I4 Z6 c" ?. q; E; |7 m  |在执行读出数据的时候函数的参数也有三部分：
1.要读出的地址
( u; }2 G* [1 f2.读出到指定地址
3.读出数据的大小
- Q$ Z$ ]) ]* c函数执行过程，首先发送读取指令（这时就不用发送写使能了），然后读取数据的地址，然后将数据逐位读取在固定地址中（地址最好是全局变量），使用时再从全局变量地址中获取数据。
这里涉及到函数的返回值问题，具体分析链接：返回多个变量怎么办
; W6 \& a( H5 i2 F  h0 c( f  P
注
有一个问题当时困扰了博主一天，那就是发送和读取数据时，怎么把数据返回到主函数中，解决方法是，创建俩个全局变量数组，一个负责发送数据、另一个负责接收数据，这样就ok了
附上主函数
% X7 Q3 f" Z  ]3 `- y

1. /**********************读取指定地址、指定长度的数据******************/
   
2. /* 因为读取在了指针中，所以不需要返回值 */
   6 \4 {; N$ t! b' \' R- u' h, [3 `
3. void FLASH_BufferRead(uint32_t addr , uint8_t* pBuffer ,uint16_t size)
     |7 B" Y; C1 K3 J6 A: C
4. {
   
5.         SPI_NSS_Begin();
   
6.         /* 发送读取命令 */
   & E5 G" @% A% V& S7 s5 h
7.         SPI_SendData(W25X_ReadData);
   ! u5 x. C+ K4 a9 i
8.         /* 发送读取数据的地址，高位先行 */
   * h+ w0 ~' ]0 {! g" h
9.         SPI_SendData((addr & 0xff0000) >> 16);
   4 e* p3 R$ r. L3 c! p
10.         SPI_SendData((addr & 0xff00) >> 8);
    
11.         SPI_SendData(addr & 0xff);
    & o) t( D2 N8 b$ P
12.         /* 逐位读取数据到指针上 */
    
13.         while(size--)
    5 n& s/ m0 F$ _! y# w! a$ M' B
14.         {
    9 ~. [9 `% [0 g: z; P- d# B
15.                 *pBuffer=SPI_SendData(Dummy_Byte);
    
16.                 pBuffer++;
    
17.         }
    ) n: S8 }9 F& T; u2 y
18.         SPI_NSS_Stop();
    : f( n: N' c; X* d8 @
19. }
    ! ^' v* C, R/ r2 h
20. 
    

复制代码

! m: N8 M2 K7 h  A9 z9 g' _  t————————————————
) t% r' q5 K; _. z! g, B版权声明：Aspirant-GQ
/ F9 J) f' ^! l( O% u7 U
- ~6 q2 [' }2 g5 L/ {如有侵权请联系删除
! V( W( h' P) B2 a% D. n


* ]1 H6 a& ?2 n, q5 A7 }: {