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

对于FLASH内部结构的详细说明博主会专门整理一篇博客来说明，所以关于FLASH芯片的相关原理，本文中只做简单说明，侧重代码部分。
FLASH详细说明的博客链接：（没有链接就说明还没有整理出）

8 q0 M" r3 j; ?W25Q64
% T' K2 q! {. r  Q  EW25Q64简介
/ V; R; ?  g+ F就长这么个样子

# \! M( @2 j& D  D! _

STM32内部原理图如下：



# x4 J& g% p5 X7 k+ D) P% R9 Q
4 e; a( |' L* I0 a- k4 a: AW25Q64是一种使用SPI通信协议的NOR FLASH存储器，它 的CS/CLK/DIO/DO 引 脚 分 别 连 接 到 了 STM32 对 应 的 SPI 引 脚NSS/SCK/MOSI/MISO 上，其中 STM32 的 NSS 引脚是一个普通的 GPIO，不是 SPI 的专用NSS 引脚，所以程序中我们要使用软件控制的方式。FLASH 芯片中还有 WP 和 HOLD 引脚。 WP 引脚可控制写保护功能，当该引脚为低电平时，禁止写入数据。我们直接接电源，不使用写保护功能。 HOLD 引脚可用于暂停通讯，该引脚为低电平时，通讯暂停，数据输出引脚输出高阻抗状态，时钟和数据输入引脚无效。我们直接接电源，不使用通讯暂停功能。
2 @" ^$ e0 @9 N/ q6 o! G
W25Q64支持SPI通讯的模式0和模式3
! q* E7 O, D! C- w4 C" m8 U
$ O! ~. }- M! }/ c! c0 ~
FLASH控制指令
7 u! ^( R. @/ p& ~  o$ `$ B, UFLASH芯片中规定了许多指令，只要SPI向FLASH发送相应的指令，FLASH就会执行相应的操作，所以我们对FLASH的一切操作都是基于这个指令集的，接下来介绍一下FLASH的控制指令：



表中第一列为指令名，第二列为相应的指令代码，第三列及后面的内容根据指令的不同而意义不同，其中带括号的字节参数，方向为 FLASH 向主机传输，即命令响应，不带括号的则为主机向 FLASH 传输。表中“A0~A23” 指 FLASH 芯片内部存储器组织的地址； “M0~M7” 为厂商号（ MANUFACTURER ID）； “ID0-ID15”为 FLASH 芯片的ID；“dummy”指该处可为任意数据；“D0~D7” 为 FLASH 内部存储矩阵的内容。
+ C) }5 Q0 ]4 H3 B9 u# c5 M看起来很复杂的样子，其实只要在需要执行相应操作时来查这个表，只要能够理解这些指令的使用方法，FLASH就算学会了。
. `9 x1 R" K3 f3 v* ^
例如：要知道FLASH的ID，那就在指令中找对应的取ID指令“JEDEC ID”，仔细解读这个指令
" {0 T  W. m" u6 [
! c3 Y& [0 `1 s! w8 q/ [
可以看出对应的指令代码为“9F”，后面的三个字节带括号，代表这三个字节就是FLASH向STM32发送的数据，即这三个字节就是FLASH的ID，然后使用SPI进行读取就可以了。

& S% G% o7 W4 K, r" o  R; G我们一般是将这些指令宏定义在头文件中，便于使用：

1. #define W25X_WriteEnable                      0x06
   
2. #define W25X_WriteDisable                      0x04
   
3. #define W25X_ReadStatusReg                      0x05
   , j3 O- q# C4 t9 O
4. #define W25X_WriteStatusReg                      0x01
   
5. #define W25X_ReadData                              0x03
   
6. #define W25X_FastReadData                      0x0B
   
7. #define W25X_FastReadDual                      0x3B
   & d7 @- ]7 {$ P& X; }2 Q7 m
8. #define W25X_PageProgram                      0x02
   
9. #define W25X_BlockErase                              0xD8
   & D( e2 l1 x8 I
10. #define W25X_SectorErase                      0x20
    ) ], q2 ~8 ~' ^7 Y  V) V$ j
11. #define W25X_ChipErase                              0xC7
    
12. #define W25X_PowerDown                              0xB9
    % O* H3 Z$ Q8 m1 ~
13. #define W25X_ReleasePowerDown              0xAB
      H: T* Y' o+ u" q. `
14. #define W25X_DeviceID                              0xAB
    + L) ^! @+ ^3 h9 ?5 C
15. #define W25X_ManufactDeviceID         0x90
    % ]' L# e& k6 z/ K( x( O
16. #define W25X_JedecDeviceID                      0x9F
    3 F& \( b1 D) t& w
17. 
    

复制代码

FLASH内部存储结构
- l. Y( X6 F, Z0 l/ iFLASH的存储矩阵如图：其内存分为128块，每一块都有16个扇区，每个扇区大小为4KB，擦除数据的时候是以扇区为基本单位的。
- {  W- K- K/ S6 }& a


. W! V# Q6 l' E* r0 h% Q- M. Z) `代码讲解
' {0 P: a/ h1 Z9 x, H3 j代码都是博主亲手写出来的，可以运行。
代码部分会用到SPI的代码，关于SPI的说明之前整理过：SPI详解

读取芯片ID

1. /************************读取芯片ID*************************************/
   
2. uint32_t FLASH_ReadID(void)
   
3. {
   
4.         uint32_t temp,temp1,temp2,temp3;
   
5.         SPI_NSS_Begin();
   / m/ u( E2 I( L/ c7 ?% F
6.         /* 发送取ID指令 */
   
7.         SPI_SendData( W25X_JedecDeviceID);
   
8.         /* FLASH会连续发送三个字节数据 */
   ; b2 c1 h2 j3 j. Y
9.         temp1=SPI_SendData(Dummy_Byte);
   ! u" }+ ?7 ]6 q1 j- O
10.         temp2=SPI_SendData(Dummy_Byte);
    
11.         temp3=SPI_SendData(Dummy_Byte);
    
12.         SPI_NSS_Stop();
    
13.         /* 高为先行，将三个字节整理在一起 */
    
14.         temp=temp1<<16 | temp2<<8 | temp3;
    
15.         return temp;
    & z: I) W# m4 L# Y6 u9 _
16. }
    ; k" s* \7 L6 `( j$ T

复制代码

由于SPI是全双工通信，所以接收数据和发送数据用的是同一个函数
- F+ {: ^- d' a3 Q- Q! L1 g
& d5 w7 J3 W  u) i! _, Q, i发送写使能信号
( _1 ~2 ~; k5 W2 E

1. /****************发送写使能信号****************************/
   8 k! N: L+ w) T
2. void FLASH_WriteEnable(void)
   
3. {
   9 a  f# O  r4 V# i! h/ h
4.         SPI_NSS_Begin();
   ' p( T# ?- q  y9 y9 w  M
5.         /* 发送相应的指令代码 */
   ' w+ I! ?, E% P, D- y
6.         SPI_SendData(W25X_WriteEnable);
   
7.         SPI_NSS_Stop();
   
8. }
   ) B( ^# n2 }1 u, z! O* T# |/ }

复制代码

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

等待FLASH不忙

1. /******************等待，直到不忙***********************************/
   
2. void FLASH_WaitBusy(void)
   
3. {
   
4.         uint8_t StatusReg=0x01;
   * A2 X! J: r9 ?% s
5.         SPI_NSS_Begin();
   + H1 X/ D# [/ u7 u* b6 A
6.    /* 读取状态寄存器中的数据，判断忙标志0x01位 置位代表忙 */
   0 k" M8 q" J  x. F7 K
7.         SPI_SendData(W25X_ReadStatusReg);      
   
8.    /* 只读取状态寄存器的BUSY位，即第一位 */
   * A; r" J4 I$ k# p; ]1 W$ V
9.         while((StatusReg & 0x01) == 1)
   
10.                 StatusReg=SPI_SendData(Dummy_Byte);
    ) r4 E! C6 i' @5 r9 F. e
11.         SPI_NSS_Stop();
    
12. }
    * [/ C! S* E5 p% J1 y
13. 
    4 f( t: C4 z! O! @0 e
14. 
    

复制代码

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


擦除扇区

1. /******擦除扇区的内容,切记地址要对其到4kB，每个扇区的大小都是4KB********/
   
2. void FLASH_SectorErase(uint32_t addr)
   
3. {
   # W. c# I3 H3 J# t8 e3 \3 M
4.         /* 开始的时候要发送写使能信号*/
   ) ~6 s9 }* i2 y6 f4 t
5.         FLASH_WriteEnable();
   
6.         SPI_NSS_Begin();
   
7.         /* 发送扇区擦除命令 */
   & |9 t& L# N* r
8.         SPI_SendData(W25X_SectorErase);
     M- l; a& W! I4 q
9.         /* 发送扇区的地址，高位先行 */
   2 x  z. K; C0 h) `* `0 J& Y
10.         SPI_SendData((addr & 0xff0000) >> 16);
    
11.         SPI_SendData((addr & 0xff00) >> 8);
    : t* L9 `  `( j- x" M  u
12.         SPI_SendData(addr & 0xff);
    * F/ r4 E, q  d) s
13.         SPI_NSS_Stop();
    
14.         /* 最后也要等待FLASH处理完这次的信号再退出 */
    
15.         FLASH_WaitBusy();
    4 ]" Q2 I- r; j2 M. w5 ]( a
16. }
      |3 y1 a' g) A! F
17. 
    

复制代码

& C4 J" U7 B: s扇区的擦除之前要发送一个写使能信号，先发送擦除指令，然后发送要擦除扇区的地址（分三个字节发出去），高位先行。
  n1 `' Z/ U: P4 h# q5 T扇区上的内容不是1就是0，擦除的过程就是写1的过程（将一个扇区全部写1），因为在写入数据的时候，可以将1写为0，但不能将0写为1.

/ C) p' t4 S. ?8 Y. y
写入数据

1. /************按页写入数据，但写入之前要进行擦除***********/
   " ]" v6 w& [/ u
2. void FLASH_PageWrite(uint32_t addr , uint8_t* pBuffer ,uint8_t size)
   1 ?$ |; L* }0 d0 K( @
3. {
   
4.         /* 开始的时候要发送写使能信号 */
   . d$ a$ c: m8 U+ d
5.         FLASH_WriteEnable();
   
6.         SPI_NSS_Begin();
   
7.         /* 发送页写入命令 */
   
8.         SPI_SendData(W25X_PageProgram);
   & x. i% c, l9 j- `  a! p$ C
9.         /* 发送写入的地址，高位先行 */
   3 ~! o& w4 C# c
10.         SPI_SendData((addr & 0xff0000) >> 16);
    - I( r- [* h+ H* g
11.         SPI_SendData((addr & 0xff00) >> 8);
    8 g9 \! U" y7 ]7 z
12.         SPI_SendData(addr & 0xff);
    
13.         /* 逐位发送数据 */
    * Y1 f% ]! v( `" X
14.         while(size--)
    
15.         {
    
16.                 SPI_SendData(*pBuffer);
    & B* a: e0 H- U3 B7 k; e. S7 u! n
17.                 pBuffer++;
    # L- F3 q* l5 I, Z; r
18.         }
    
19.         SPI_NSS_Stop();
    
20.         /* 最后也要等待FLASH处理完这次的信号再退出 */
    # ^. x( n3 z/ C- U' F, K
21.         FLASH_WaitBusy();
    9 E- w: r3 k$ I) m$ H6 m: c
22. }
    2 t' b8 d9 p$ h
23. 
    

复制代码

/ U, t% W9 K) ]& n, [+ B2 u* f在执行写入数据的时候函数的参数有三部分：
) }% [* C, S7 F9 V. c& M6 B  ^1.要写入的地址
2.要写入数据的首地址
" Z: Q8 w& G* u0 u+ P$ n0 ~: B3.要写入数据的大小
函数在执行的过程中，首先发送一个写使能信号，然后发送写数据指令，紧接着发送数据要写入的地址，然后就是逐位发送数据了，函数最后等FLASH处理完这次操作再退出。


; @- w+ B, |. t读取数据
7 r. i7 J1 j7 r, y2 h$ K

1. /**********************读取指定地址、指定长度的数据******************/
   3 T" M$ u, t7 }3 K( |
2. /* 因为读取在了指针中，所以不需要返回值 */
   * e3 S. K9 A- {" U" D
3. void FLASH_BufferRead(uint32_t addr , uint8_t* pBuffer ,uint16_t size)
   
4. {
   
5.         SPI_NSS_Begin();
   1 q: ?6 g" t3 |7 b6 F+ T% p" A. o6 r5 N
6.         /* 发送读取命令 */
   ; _, R- p# n$ j5 q: J9 N6 _6 o
7.         SPI_SendData(W25X_ReadData);
   
8.         /* 发送读取数据的地址，高位先行 */
   ) s4 J# \+ G: Y8 o- x
9.         SPI_SendData((addr & 0xff0000) >> 16);
   
10.         SPI_SendData((addr & 0xff00) >> 8);
    
11.         SPI_SendData(addr & 0xff);
    
12.         /* 逐位读取数据到指针上 */
    
13.         while(size--)
    % w  C/ Q+ U$ k7 R; c8 c
14.         {
    $ x" }8 i' j0 u2 p: l
15.                 *pBuffer=SPI_SendData(Dummy_Byte);
    $ J. w+ q8 M. i% S! ?3 C# B/ ]
16.                 pBuffer++;
    
17.         }
    1 O4 a8 U, o& \" q+ q
18.         SPI_NSS_Stop();
    
19. }
    ) J' \6 U4 I1 }: N& [1 A
20. 
    0 D- Q4 j/ l4 }2 E. L

复制代码

- o3 {- V, I1 `: Z5 {在执行读出数据的时候函数的参数也有三部分：
7 ?+ G5 h5 o. t! I4 x1.要读出的地址
2.读出到指定地址
3.读出数据的大小
函数执行过程，首先发送读取指令（这时就不用发送写使能了），然后读取数据的地址，然后将数据逐位读取在固定地址中（地址最好是全局变量），使用时再从全局变量地址中获取数据。
这里涉及到函数的返回值问题，具体分析链接：返回多个变量怎么办
0 f/ u9 q7 b, b+ s
9 y9 b- Q& @6 B注
5 O; ]* ]+ V5 u1 T& x有一个问题当时困扰了博主一天，那就是发送和读取数据时，怎么把数据返回到主函数中，解决方法是，创建俩个全局变量数组，一个负责发送数据、另一个负责接收数据，这样就ok了
) B& ^+ N+ L# H9 X; `* v' `附上主函数
  A7 x, l" Z' l5 z

1. /**********************读取指定地址、指定长度的数据******************/
   
2. /* 因为读取在了指针中，所以不需要返回值 */
   4 [2 _4 n: ?& k0 A
3. void FLASH_BufferRead(uint32_t addr , uint8_t* pBuffer ,uint16_t size)
   , c) Q4 ]- M* ?$ P9 A! c7 |
4. {
     h6 s) m( G0 }/ }: R- {0 C
5.         SPI_NSS_Begin();
   8 m* p; b$ `( W# B. T7 z) Y, g2 v
6.         /* 发送读取命令 */
   
7.         SPI_SendData(W25X_ReadData);
   
8.         /* 发送读取数据的地址，高位先行 */
   
9.         SPI_SendData((addr & 0xff0000) >> 16);
   0 F& F; A* Y7 B9 P1 D0 i" Y
10.         SPI_SendData((addr & 0xff00) >> 8);
    6 o3 J4 ?& N0 A; P% I
11.         SPI_SendData(addr & 0xff);
    
12.         /* 逐位读取数据到指针上 */
    
13.         while(size--)
    
14.         {
    ' k" m- {! l( _% E3 q5 N4 |0 [
15.                 *pBuffer=SPI_SendData(Dummy_Byte);
    
16.                 pBuffer++;
    , r& \+ h: Y+ m" s& B% H% l; ?' g
17.         }
    
18.         SPI_NSS_Stop();
    " A2 R& V0 A1 @9 J* L
19. }
    
20. 
    

复制代码

3 M' Z  e# g0 @& z5 D" ~8 u————————————————
9 p2 c% g. E' B1 _) q  U版权声明：Aspirant-GQ
  t" M' l" m2 M/ W
6 y9 K8 R* T6 u. g) ]0 c) Z如有侵权请联系删除



8 y8 ^+ U. k. K0 Z0 Y" X# @