FLASH简介
FLASH俗称闪存，和EEPROM一样，都是掉电数据不丢失的非易失行存储器，但FLASH的存储容量普遍大于EEPROM，现在像如U盘、SD卡、SSD固态硬盘以及STM32芯片内部存储程序的设备都是FLASH类型的存储器。由此可见FLASH对于我们学习和工作的重要性，EEPROM可以实现单字节的擦写，而FLASH都是一大片的擦写，就像是大规模杀伤性武器，其最小擦除单：扇区的大小也是4KB。
我们此次通过SPI对FLASH存储芯片W25Q64进行读写擦除的操作。

对于FLASH内部结构的详细说明博主会专门整理一篇博客来说明，所以关于FLASH芯片的相关原理，本文中只做简单说明，侧重代码部分。
FLASH详细说明的博客链接：（没有链接就说明还没有整理出）
8 q! [. ^2 h5 k) W: `
W25Q64
' C8 I1 m1 s- |! v0 EW25Q64简介
' B' D2 Y7 p9 Z8 m0 R& r- f) r' _$ U就长这么个样子

2 a* D# t' s& s( |# \6 p

STM32内部原理图如下：
0 ?6 H9 h  P! n9 q
, x2 J) ~% d& u1 V) u* @; \5 S
4 k1 U. b6 B8 @( r0 b5 S- F
# @3 S: {8 S& s( Y  H, h
! T8 e5 w) ?4 v1 _W25Q64是一种使用SPI通信协议的NOR FLASH存储器，它 的CS/CLK/DIO/DO 引 脚 分 别 连 接 到 了 STM32 对 应 的 SPI 引 脚NSS/SCK/MOSI/MISO 上，其中 STM32 的 NSS 引脚是一个普通的 GPIO，不是 SPI 的专用NSS 引脚，所以程序中我们要使用软件控制的方式。FLASH 芯片中还有 WP 和 HOLD 引脚。 WP 引脚可控制写保护功能，当该引脚为低电平时，禁止写入数据。我们直接接电源，不使用写保护功能。 HOLD 引脚可用于暂停通讯，该引脚为低电平时，通讯暂停，数据输出引脚输出高阻抗状态，时钟和数据输入引脚无效。我们直接接电源，不使用通讯暂停功能。

W25Q64支持SPI通讯的模式0和模式3

' L+ H/ p/ c1 n4 _. K* j
FLASH控制指令
3 O, t% m2 R  m9 a1 B$ }$ MFLASH芯片中规定了许多指令，只要SPI向FLASH发送相应的指令，FLASH就会执行相应的操作，所以我们对FLASH的一切操作都是基于这个指令集的，接下来介绍一下FLASH的控制指令：
$ a# e% m( F% v2 i7 C, a
5 q8 |& z# e# ^9 M, t1 V# R

6 A  a1 S1 q( t表中第一列为指令名，第二列为相应的指令代码，第三列及后面的内容根据指令的不同而意义不同，其中带括号的字节参数，方向为 FLASH 向主机传输，即命令响应，不带括号的则为主机向 FLASH 传输。表中“A0~A23” 指 FLASH 芯片内部存储器组织的地址； “M0~M7” 为厂商号（ MANUFACTURER ID）； “ID0-ID15”为 FLASH 芯片的ID；“dummy”指该处可为任意数据；“D0~D7” 为 FLASH 内部存储矩阵的内容。
看起来很复杂的样子，其实只要在需要执行相应操作时来查这个表，只要能够理解这些指令的使用方法，FLASH就算学会了。

" e; Q4 }; R* u, q0 S: R4 L例如：要知道FLASH的ID，那就在指令中找对应的取ID指令“JEDEC ID”，仔细解读这个指令

# f- e+ t- ^& d$ O- P1 ~
可以看出对应的指令代码为“9F”，后面的三个字节带括号，代表这三个字节就是FLASH向STM32发送的数据，即这三个字节就是FLASH的ID，然后使用SPI进行读取就可以了。
: z3 H6 P; T$ a% y( n" M% K
我们一般是将这些指令宏定义在头文件中，便于使用：
2 l7 l# x* f0 [1 U

1. #define W25X_WriteEnable                      0x06
   
2. #define W25X_WriteDisable                      0x04
   
3. #define W25X_ReadStatusReg                      0x05
   
4. #define W25X_WriteStatusReg                      0x01
   % {- G8 N* |' o, l9 i8 N$ o
5. #define W25X_ReadData                              0x03
   
6. #define W25X_FastReadData                      0x0B
   ' G" K5 Z  K$ \
7. #define W25X_FastReadDual                      0x3B
   + s! `, C: d1 R2 Q! q. U' Y
8. #define W25X_PageProgram                      0x02
   
9. #define W25X_BlockErase                              0xD8
   ( Z! L# W. A  ^( R8 N/ V+ ?
10. #define W25X_SectorErase                      0x20
    
11. #define W25X_ChipErase                              0xC7
    / T- \7 B+ m. G$ u1 _6 c( A3 k
12. #define W25X_PowerDown                              0xB9
    
13. #define W25X_ReleasePowerDown              0xAB
    ( t2 \/ j. a1 |8 Z+ O
14. #define W25X_DeviceID                              0xAB
    ) }; z! d4 O& h5 U; U
15. #define W25X_ManufactDeviceID         0x90
    . I/ }; o1 A9 I7 F& ^/ }
16. #define W25X_JedecDeviceID                      0x9F
    
17. 
    6 \2 a# |% C+ g( H

复制代码

FLASH内部存储结构
2 P, f# G+ [- T0 FFLASH的存储矩阵如图：其内存分为128块，每一块都有16个扇区，每个扇区大小为4KB，擦除数据的时候是以扇区为基本单位的。
9 k3 n7 |& j6 `/ l

0 H$ q% k# B+ |4 R6 G1 ?" ^
代码讲解
代码都是博主亲手写出来的，可以运行。
0 d* u9 V# x/ o% H代码部分会用到SPI的代码，关于SPI的说明之前整理过：SPI详解
3 p/ j6 ~. D9 N% e% \3 w
读取芯片ID
9 `- z1 D3 L( _' _- f/ H: y' j6 l

1. /************************读取芯片ID*************************************/
   
2. uint32_t FLASH_ReadID(void)
   0 z: w/ Y6 H- D7 m
3. {
   
4.         uint32_t temp,temp1,temp2,temp3;
   3 e0 @2 a# L4 o& ^) G, w- j+ y
5.         SPI_NSS_Begin();
   8 f4 t  {+ U! p6 H" b7 |( P
6.         /* 发送取ID指令 */
   # g: k7 q# r' p6 J0 }1 C, b
7.         SPI_SendData( W25X_JedecDeviceID);
   * m' ?7 V8 ]; Q4 u$ A# A
8.         /* FLASH会连续发送三个字节数据 */
   
9.         temp1=SPI_SendData(Dummy_Byte);
   
10.         temp2=SPI_SendData(Dummy_Byte);
    
11.         temp3=SPI_SendData(Dummy_Byte);
    7 N$ M* e$ _3 s+ L2 g
12.         SPI_NSS_Stop();
    
13.         /* 高为先行，将三个字节整理在一起 */
      F3 j/ w: H0 M2 q# y& z- a/ h
14.         temp=temp1<<16 | temp2<<8 | temp3;
    
15.         return temp;
    % i. S( X3 Z9 `5 C0 Z! L" Z
16. }
    . |: c8 j( ]& ^+ b

复制代码

由于SPI是全双工通信，所以接收数据和发送数据用的是同一个函数
7 Y8 D! ?2 s* r
  Q5 N$ r4 [: T发送写使能信号
3 K, ?4 v/ b+ j: a; ?+ v  |! _! I6 M

1. /****************发送写使能信号****************************/
   
2. void FLASH_WriteEnable(void)
   
3. {
   ; B! z+ \/ p! r' N$ D" u
4.         SPI_NSS_Begin();
   
5.         /* 发送相应的指令代码 */
   
6.         SPI_SendData(W25X_WriteEnable);
   
7.         SPI_NSS_Stop();
   * I6 N/ Y% ~( ^0 @" k+ W
8. }
   

复制代码

在向FLASH中执行写操作之前，都要进行写使能操作，通过发送写使能指令到FLASH来实现

/ q( k! }; i% I等待FLASH不忙
# @/ y5 @, I  t; _% H/ u. N

1. /******************等待，直到不忙***********************************/
   * @) u. E* i. P0 R: Q( }. _
2. void FLASH_WaitBusy(void)
   8 |: E+ P( A  {; T- [7 u3 I8 Z* y/ e
3. {
   
4.         uint8_t StatusReg=0x01;
   
5.         SPI_NSS_Begin();
   9 R) m& ~  t% H, N
6.    /* 读取状态寄存器中的数据，判断忙标志0x01位 置位代表忙 */
   
7.         SPI_SendData(W25X_ReadStatusReg);      
   
8.    /* 只读取状态寄存器的BUSY位，即第一位 */
   * d* U) s5 p5 D2 m- ^8 B4 M& N8 b
9.         while((StatusReg & 0x01) == 1)
   
10.                 StatusReg=SPI_SendData(Dummy_Byte);
    
11.         SPI_NSS_Stop();
    ' Q- x/ G1 B+ p+ U* a, R" _  ?- D
12. }
    ( z5 u6 Y# x  _. r, {) {
13. 
    
14. 
    5 g% O! K1 e& }9 b4 k3 X

复制代码

FLASH在通讯的过程中需要一定的时间来执行操作，在这期间，传输数据是无效的，因为FLASH忙着呢，所以我们就要有一个函数来专门等！等到FLASH不忙了，再进行通讯，那怎么等呢？FLASH不忙了会给出一个信号——将状态寄存器的BUSY位重置（也就是0），所以我们需要不断的来检测状态寄存器中的BUSY位是否置位，利用读取寄存器状态的指令来获取状态寄存器当下的状态，然后根据寄存器的BUSY位（第1位）来判断FLASH是否处于忙碌状态。
( z1 I0 k! O0 P* A7 E  z0 i简单来说，这就是个延时函数，延时直到FLASH空闲，可以进行下一步传输。
( j& [$ ?/ w5 K4 [9 Z0 v$ Q" E& K
1 Q/ Q# u* O" c/ X, @( B' v
擦除扇区

1. /******擦除扇区的内容,切记地址要对其到4kB，每个扇区的大小都是4KB********/
   
2. void FLASH_SectorErase(uint32_t addr)
   
3. {
   - K: C: S: l6 J' G2 a1 q
4.         /* 开始的时候要发送写使能信号*/
   3 C! E% Y9 w  y  h3 I8 N
5.         FLASH_WriteEnable();
   
6.         SPI_NSS_Begin();
   
7.         /* 发送扇区擦除命令 */
   
8.         SPI_SendData(W25X_SectorErase);
   3 [1 B% ]3 U4 K9 u& q! Z9 _: k
9.         /* 发送扇区的地址，高位先行 */
   
10.         SPI_SendData((addr & 0xff0000) >> 16);
    " V+ D0 @8 N, Z! u
11.         SPI_SendData((addr & 0xff00) >> 8);
    
12.         SPI_SendData(addr & 0xff);
    # X- q( f7 I0 K# y* F0 w; `
13.         SPI_NSS_Stop();
    
14.         /* 最后也要等待FLASH处理完这次的信号再退出 */
    
15.         FLASH_WaitBusy();
    3 m3 O( W) E/ L  [, d; J
16. }
    + F( R; w& r* j6 J1 i
17. 
    

复制代码

# C, V$ L1 y- H扇区的擦除之前要发送一个写使能信号，先发送擦除指令，然后发送要擦除扇区的地址（分三个字节发出去），高位先行。
扇区上的内容不是1就是0，擦除的过程就是写1的过程（将一个扇区全部写1），因为在写入数据的时候，可以将1写为0，但不能将0写为1.

" }1 p0 y2 i, }3 u. W5 G& ~/ V$ r
写入数据
6 t+ E1 V! Q5 Z6 D# A

1. /************按页写入数据，但写入之前要进行擦除***********/
   
2. void FLASH_PageWrite(uint32_t addr , uint8_t* pBuffer ,uint8_t size)
   
3. {
   : f% S6 O& K* m/ B( _9 u4 z! l1 F
4.         /* 开始的时候要发送写使能信号 */
   6 Q8 R7 i9 j' j5 c6 f; L) C: h- a
5.         FLASH_WriteEnable();
   ' Y( \+ h! P" ]5 x8 q
6.         SPI_NSS_Begin();
   $ Y0 v: {# P  h" z8 l
7.         /* 发送页写入命令 */
   2 c# Q6 n" c5 m- [: X
8.         SPI_SendData(W25X_PageProgram);
   
9.         /* 发送写入的地址，高位先行 */
   
10.         SPI_SendData((addr & 0xff0000) >> 16);
    - A( W: ]% d- c2 t1 N( t2 m
11.         SPI_SendData((addr & 0xff00) >> 8);
    
12.         SPI_SendData(addr & 0xff);
    , |5 n; b6 ?6 H! u! k
13.         /* 逐位发送数据 */
    
14.         while(size--)
    5 l' J9 \4 t1 ?* _. I% q$ h
15.         {
    
16.                 SPI_SendData(*pBuffer);
    
17.                 pBuffer++;
    
18.         }
    
19.         SPI_NSS_Stop();
    : p5 W( Y% K  [0 w3 z7 A
20.         /* 最后也要等待FLASH处理完这次的信号再退出 */
    & `' p7 [  G# t# h+ \7 N
21.         FLASH_WaitBusy();
    
22. }
    * U  {3 [+ B5 H4 `# @9 l
23. 
    

复制代码

在执行写入数据的时候函数的参数有三部分：
7 y" K2 ^6 \& E6 M1.要写入的地址
: t1 v2 r7 r8 O2.要写入数据的首地址
# [/ [! k3 t8 N3.要写入数据的大小
函数在执行的过程中，首先发送一个写使能信号，然后发送写数据指令，紧接着发送数据要写入的地址，然后就是逐位发送数据了，函数最后等FLASH处理完这次操作再退出。

& r# P# r) X+ y, s
读取数据
/ l% o5 E+ }7 w' |: t6 A! \

1. /**********************读取指定地址、指定长度的数据******************/
   . K. S. I' D) S/ S5 Y/ D$ E0 w
2. /* 因为读取在了指针中，所以不需要返回值 */
   8 A* H( O% e  D: ?. D' ]
3. void FLASH_BufferRead(uint32_t addr , uint8_t* pBuffer ,uint16_t size)
   
4. {
   8 R7 M4 T* X, L* A! ~
5.         SPI_NSS_Begin();
   
6.         /* 发送读取命令 */
   
7.         SPI_SendData(W25X_ReadData);
   
8.         /* 发送读取数据的地址，高位先行 */
   
9.         SPI_SendData((addr & 0xff0000) >> 16);
   8 E# v/ u# W' ~8 C
10.         SPI_SendData((addr & 0xff00) >> 8);
    
11.         SPI_SendData(addr & 0xff);
    
12.         /* 逐位读取数据到指针上 */
    + G/ i' P/ }" ?' }3 v4 s
13.         while(size--)
    
14.         {
    
15.                 *pBuffer=SPI_SendData(Dummy_Byte);
    
16.                 pBuffer++;
    2 X1 B$ }1 _4 k8 c+ N8 K" P& a
17.         }
    
18.         SPI_NSS_Stop();
    ) M; h2 D) z5 X' q1 c! D
19. }
    5 X( B7 ?. G" p9 R9 t
20. 
    

复制代码

在执行读出数据的时候函数的参数也有三部分：
" t4 \: c" Y8 F1.要读出的地址
2.读出到指定地址
) g( g4 f+ v. |+ w3.读出数据的大小
函数执行过程，首先发送读取指令（这时就不用发送写使能了），然后读取数据的地址，然后将数据逐位读取在固定地址中（地址最好是全局变量），使用时再从全局变量地址中获取数据。
0 O; C4 l; y. {- ]! b. I  V; R/ |这里涉及到函数的返回值问题，具体分析链接：返回多个变量怎么办

注
有一个问题当时困扰了博主一天，那就是发送和读取数据时，怎么把数据返回到主函数中，解决方法是，创建俩个全局变量数组，一个负责发送数据、另一个负责接收数据，这样就ok了
附上主函数
8 _6 \3 y' G8 p) _; ~8 O: C5 M

1. /**********************读取指定地址、指定长度的数据******************/
   
2. /* 因为读取在了指针中，所以不需要返回值 */
   
3. void FLASH_BufferRead(uint32_t addr , uint8_t* pBuffer ,uint16_t size)
     u- \) j# M5 ]& ^9 }! ]; W4 @
4. {
   ' J( v. P9 F0 k$ p( D
5.         SPI_NSS_Begin();
   . m6 N1 Q. f. M0 T' Y* W9 y- {
6.         /* 发送读取命令 */
   0 g* t0 U: q  B' H: j
7.         SPI_SendData(W25X_ReadData);
   9 f" \4 ^  ~3 R3 P1 \5 e
8.         /* 发送读取数据的地址，高位先行 */
   
9.         SPI_SendData((addr & 0xff0000) >> 16);
   & p! _2 c+ D. t4 E1 q2 s' @
10.         SPI_SendData((addr & 0xff00) >> 8);
    
11.         SPI_SendData(addr & 0xff);
    
12.         /* 逐位读取数据到指针上 */
    " o% R/ _* |! B/ B) X7 O2 h
13.         while(size--)
    * q% ], W, d2 v
14.         {
    
15.                 *pBuffer=SPI_SendData(Dummy_Byte);
    ( U# g# u8 h. u! c: t; x
16.                 pBuffer++;
      \0 [; M( t# l' G" E8 l
17.         }
    2 v+ h+ J% H! [* b( A
18.         SPI_NSS_Stop();
    
19. }
    
20. 
    - Z* t8 m% i& N

复制代码

————————————————
版权声明：Aspirant-GQ
. |( H: W3 O% V& b
/ M+ ?" L' z; h: X# f如有侵权请联系删除
: f# d( R) e/ E" j6 t