FLASH简介
FLASH俗称闪存，和EEPROM一样，都是掉电数据不丢失的非易失行存储器，但FLASH的存储容量普遍大于EEPROM，现在像如U盘、SD卡、SSD固态硬盘以及STM32芯片内部存储程序的设备都是FLASH类型的存储器。由此可见FLASH对于我们学习和工作的重要性，EEPROM可以实现单字节的擦写，而FLASH都是一大片的擦写，就像是大规模杀伤性武器，其最小擦除单：扇区的大小也是4KB。
我们此次通过SPI对FLASH存储芯片W25Q64进行读写擦除的操作。
: d4 f$ n+ J0 {* U  k/ i2 v
对于FLASH内部结构的详细说明博主会专门整理一篇博客来说明，所以关于FLASH芯片的相关原理，本文中只做简单说明，侧重代码部分。
, B6 q; [: c' X& l% V6 t9 GFLASH详细说明的博客链接：（没有链接就说明还没有整理出）

W25Q64
W25Q64简介
3 C8 K. w; l8 k* H- P7 I就长这么个样子
  Y* j0 U$ F) h/ }# W' t5 k

" W" l& a9 z4 O; }5 x
STM32内部原理图如下：




0 L# D5 u% T0 {6 {- a. i4 b+ K/ VW25Q64是一种使用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


: S8 b. [# Z0 p1 _. X& XFLASH控制指令
FLASH芯片中规定了许多指令，只要SPI向FLASH发送相应的指令，FLASH就会执行相应的操作，所以我们对FLASH的一切操作都是基于这个指令集的，接下来介绍一下FLASH的控制指令：
# T2 k5 \0 g  s  B! f
" N. L* x: D# R
% j( V, d* l" g
) J2 ~' r; \& U, I' Y- z  B) S$ I表中第一列为指令名，第二列为相应的指令代码，第三列及后面的内容根据指令的不同而意义不同，其中带括号的字节参数，方向为 FLASH 向主机传输，即命令响应，不带括号的则为主机向 FLASH 传输。表中“A0~A23” 指 FLASH 芯片内部存储器组织的地址； “M0~M7” 为厂商号（ MANUFACTURER ID）； “ID0-ID15”为 FLASH 芯片的ID；“dummy”指该处可为任意数据；“D0~D7” 为 FLASH 内部存储矩阵的内容。
% V! J2 b9 f2 m看起来很复杂的样子，其实只要在需要执行相应操作时来查这个表，只要能够理解这些指令的使用方法，FLASH就算学会了。
. s0 q: y* M/ t
例如：要知道FLASH的ID，那就在指令中找对应的取ID指令“JEDEC ID”，仔细解读这个指令


可以看出对应的指令代码为“9F”，后面的三个字节带括号，代表这三个字节就是FLASH向STM32发送的数据，即这三个字节就是FLASH的ID，然后使用SPI进行读取就可以了。

5 W5 [1 ?* Y" e# t- Y我们一般是将这些指令宏定义在头文件中，便于使用：

1. #define W25X_WriteEnable                      0x06
   
2. #define W25X_WriteDisable                      0x04
   % \$ |1 P3 R1 I, Z: u' P
3. #define W25X_ReadStatusReg                      0x05
   
4. #define W25X_WriteStatusReg                      0x01
   % k  o( R# v& ?2 l9 k
5. #define W25X_ReadData                              0x03
   ! n* c% w! W' t  W* g; J3 E
6. #define W25X_FastReadData                      0x0B
   8 z+ h' O( i( r7 T! f& b
7. #define W25X_FastReadDual                      0x3B
   2 I" u4 `- ?' {9 M; G7 G8 E
8. #define W25X_PageProgram                      0x02
   9 e0 w, s5 M! q" o' O* F: E
9. #define W25X_BlockErase                              0xD8
   
10. #define W25X_SectorErase                      0x20
    
11. #define W25X_ChipErase                              0xC7
    
12. #define W25X_PowerDown                              0xB9
    
13. #define W25X_ReleasePowerDown              0xAB
    
14. #define W25X_DeviceID                              0xAB
    & i0 d1 c1 u# J
15. #define W25X_ManufactDeviceID         0x90
    
16. #define W25X_JedecDeviceID                      0x9F
    ; G5 h5 _7 h% J+ d7 d; F* M' I& e
17. 
    

复制代码

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

, K# {3 k" i/ O0 r  E
. y9 a0 u9 p- n0 B: k
/ v3 y, x5 U) u代码讲解
代码都是博主亲手写出来的，可以运行。
9 |; Q4 J. _* ^  s6 `  I7 W* v代码部分会用到SPI的代码，关于SPI的说明之前整理过：SPI详解
* T' U& v. w9 b7 a% M5 T& h! I
- T4 Z  a: _" h5 U7 Q  D  J, c读取芯片ID
& X0 w) k& g! d! `* c# {4 J8 p

1. /************************读取芯片ID*************************************/
   
2. uint32_t FLASH_ReadID(void)
   ! }9 g$ C5 \# G* V
3. {
   
4.         uint32_t temp,temp1,temp2,temp3;
   . b1 w2 V/ N1 o( v; p
5.         SPI_NSS_Begin();
   
6.         /* 发送取ID指令 */
   # z9 x. s8 H7 W
7.         SPI_SendData( W25X_JedecDeviceID);
   
8.         /* FLASH会连续发送三个字节数据 */
   
9.         temp1=SPI_SendData(Dummy_Byte);
   
10.         temp2=SPI_SendData(Dummy_Byte);
    # n! I: _) B  C5 L! R# l
11.         temp3=SPI_SendData(Dummy_Byte);
    
12.         SPI_NSS_Stop();
    ' n! M7 y4 F5 u. u, f
13.         /* 高为先行，将三个字节整理在一起 */
    ) D3 }3 B. s- }& D, b. d& N7 `
14.         temp=temp1<<16 | temp2<<8 | temp3;
    
15.         return temp;
    / B3 Q; L% P  w3 X- t" X8 B$ {' e+ F) d
16. }
    8 z9 Q; @, f$ B; A: Q8 ?- H5 ^

复制代码

5 A8 \+ N  \' z0 I# t8 l  l由于SPI是全双工通信，所以接收数据和发送数据用的是同一个函数
  O: }: H0 a) v5 L! F) n% w
7 ^6 P' D% ~9 z+ v/ T5 V, H发送写使能信号

1. /****************发送写使能信号****************************/
   ) }: _* I/ K3 S3 ]/ ~
2. void FLASH_WriteEnable(void)
   
3. {
   
4.         SPI_NSS_Begin();
   / t0 J9 j' y, A4 T( b; w1 r
5.         /* 发送相应的指令代码 */
   
6.         SPI_SendData(W25X_WriteEnable);
   
7.         SPI_NSS_Stop();
   . q5 u0 C# R) i0 J" p+ n5 B
8. }
   3 G* t( }- S  d7 _5 x% p! ?

复制代码

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

! a% d# a+ Z* H5 M等待FLASH不忙
( s7 S2 ]: M( D  I

1. /******************等待，直到不忙***********************************/
   
2. void FLASH_WaitBusy(void)
   
3. {
   7 l7 z$ c" c- h0 e: E
4.         uint8_t StatusReg=0x01;
   1 F8 K  F6 x; `2 G
5.         SPI_NSS_Begin();
   * X8 {' T# K/ k: o0 ~2 {+ @
6.    /* 读取状态寄存器中的数据，判断忙标志0x01位 置位代表忙 */
   
7.         SPI_SendData(W25X_ReadStatusReg);      
   
8.    /* 只读取状态寄存器的BUSY位，即第一位 */
   
9.         while((StatusReg & 0x01) == 1)
   
10.                 StatusReg=SPI_SendData(Dummy_Byte);
    - ~1 |& _+ V( M6 P
11.         SPI_NSS_Stop();
    ! ~  C; `: o3 I9 B
12. }
    
13. 
    ; ?4 Y" A7 F/ U  P
14. 
    

复制代码

* V2 C1 d7 s: z" R( F% ~# nFLASH在通讯的过程中需要一定的时间来执行操作，在这期间，传输数据是无效的，因为FLASH忙着呢，所以我们就要有一个函数来专门等！等到FLASH不忙了，再进行通讯，那怎么等呢？FLASH不忙了会给出一个信号——将状态寄存器的BUSY位重置（也就是0），所以我们需要不断的来检测状态寄存器中的BUSY位是否置位，利用读取寄存器状态的指令来获取状态寄存器当下的状态，然后根据寄存器的BUSY位（第1位）来判断FLASH是否处于忙碌状态。
简单来说，这就是个延时函数，延时直到FLASH空闲，可以进行下一步传输。
0 C3 K0 ^  b* a! O. s
. Y8 I9 P0 N. L, y6 {9 l
擦除扇区
( T+ y% r( B' ?4 m2 R

1. /******擦除扇区的内容,切记地址要对其到4kB，每个扇区的大小都是4KB********/
   / ?  r. n3 v4 Y6 \2 p( M+ T
2. void FLASH_SectorErase(uint32_t addr)
     b. W" h2 C& s% t
3. {
   / r$ _2 ~& @$ L
4.         /* 开始的时候要发送写使能信号*/
   
5.         FLASH_WriteEnable();
   
6.         SPI_NSS_Begin();
   
7.         /* 发送扇区擦除命令 */
   6 R: ^: S. L+ j  G
8.         SPI_SendData(W25X_SectorErase);
   & @" U7 C  Y- k' s
9.         /* 发送扇区的地址，高位先行 */
   $ l6 K. ~: e5 F
10.         SPI_SendData((addr & 0xff0000) >> 16);
    
11.         SPI_SendData((addr & 0xff00) >> 8);
    ( K+ i; y6 _; K: ^  L
12.         SPI_SendData(addr & 0xff);
    
13.         SPI_NSS_Stop();
    - _  U* z! f7 t  A0 y3 D0 t
14.         /* 最后也要等待FLASH处理完这次的信号再退出 */
    6 f- l% o+ d- I1 l: S7 @
15.         FLASH_WaitBusy();
    
16. }
    ' I+ J" a( M- H+ v3 b* _* L) H
17. 
    5 B: |+ A3 [1 g  L. \

复制代码

1 H1 F3 C5 f% h4 }* i; n扇区的擦除之前要发送一个写使能信号，先发送擦除指令，然后发送要擦除扇区的地址（分三个字节发出去），高位先行。
扇区上的内容不是1就是0，擦除的过程就是写1的过程（将一个扇区全部写1），因为在写入数据的时候，可以将1写为0，但不能将0写为1.


! ?# G- y! b' r8 s5 f& Z  A写入数据

1. /************按页写入数据，但写入之前要进行擦除***********/
   3 L$ a, O4 {) k
2. void FLASH_PageWrite(uint32_t addr , uint8_t* pBuffer ,uint8_t size)
   
3. {
   
4.         /* 开始的时候要发送写使能信号 */
   
5.         FLASH_WriteEnable();
   
6.         SPI_NSS_Begin();
   
7.         /* 发送页写入命令 */
   " X* q* ^$ q* y8 m. G9 f
8.         SPI_SendData(W25X_PageProgram);
   
9.         /* 发送写入的地址，高位先行 */
   * u1 \/ Q* S" J0 L- M8 D
10.         SPI_SendData((addr & 0xff0000) >> 16);
    
11.         SPI_SendData((addr & 0xff00) >> 8);
    + Q, W$ ~+ A, _
12.         SPI_SendData(addr & 0xff);
    # _1 A3 z5 F! E" m' }, w, `
13.         /* 逐位发送数据 */
    
14.         while(size--)
    
15.         {
    # ~  Q  r0 d3 y3 Z* L, y
16.                 SPI_SendData(*pBuffer);
    
17.                 pBuffer++;
    " w+ c5 Y0 L9 x5 N
18.         }
    5 y4 ~8 i: e! y5 `% ^/ X( s' W, L
19.         SPI_NSS_Stop();
    ; }: M' O" K; d! s
20.         /* 最后也要等待FLASH处理完这次的信号再退出 */
    # W+ d/ X, V9 i2 M3 x: k
21.         FLASH_WaitBusy();
    9 g2 S1 S# n$ r  G; H# O  ^( R
22. }
    & z+ V3 x. ?  w$ s8 r9 s7 ]
23. 
    

复制代码

在执行写入数据的时候函数的参数有三部分：
1.要写入的地址
2.要写入数据的首地址
3.要写入数据的大小
函数在执行的过程中，首先发送一个写使能信号，然后发送写数据指令，紧接着发送数据要写入的地址，然后就是逐位发送数据了，函数最后等FLASH处理完这次操作再退出。
# L6 ^2 W( W& i) @2 l# w

读取数据

1. /**********************读取指定地址、指定长度的数据******************/
   % C7 P' x4 N- a  F2 X% A
2. /* 因为读取在了指针中，所以不需要返回值 */
   
3. void FLASH_BufferRead(uint32_t addr , uint8_t* pBuffer ,uint16_t size)
   
4. {
   
5.         SPI_NSS_Begin();
   + T0 O: q- n% @9 V8 ]' e4 h
6.         /* 发送读取命令 */
   & L5 s0 i! G1 a8 U- n( F) L# l
7.         SPI_SendData(W25X_ReadData);
   
8.         /* 发送读取数据的地址，高位先行 */
   ! \$ F- _/ @$ P0 }7 q( z2 T& o5 C& t5 X
9.         SPI_SendData((addr & 0xff0000) >> 16);
   
10.         SPI_SendData((addr & 0xff00) >> 8);
    : U; j3 u3 V5 Q( W5 B
11.         SPI_SendData(addr & 0xff);
    7 s# `3 o9 Y8 c! x1 p7 r
12.         /* 逐位读取数据到指针上 */
    
13.         while(size--)
    
14.         {
    
15.                 *pBuffer=SPI_SendData(Dummy_Byte);
    
16.                 pBuffer++;
    ; U6 C5 j, H( s% F2 H
17.         }
    8 z- a6 X& Z! `$ A) |
18.         SPI_NSS_Stop();
    + z/ D& a# w. N5 I: ^; h
19. }
    " M" j$ j3 W( C/ H& Q, m
20. 
    

复制代码

在执行读出数据的时候函数的参数也有三部分：
1 G) |4 P# f4 G# N* X* O1.要读出的地址
* t; P" }" I# X! u! _+ L2.读出到指定地址
: O/ O9 S% ^, c7 N. [6 c* _; w6 N3.读出数据的大小
+ I2 Q; x) e# T. l& B% z# i" K4 {函数执行过程，首先发送读取指令（这时就不用发送写使能了），然后读取数据的地址，然后将数据逐位读取在固定地址中（地址最好是全局变量），使用时再从全局变量地址中获取数据。
8 Y9 F4 @/ O! g$ u- Z/ G! [9 a这里涉及到函数的返回值问题，具体分析链接：返回多个变量怎么办

. c: u6 ?1 J, n( _注
有一个问题当时困扰了博主一天，那就是发送和读取数据时，怎么把数据返回到主函数中，解决方法是，创建俩个全局变量数组，一个负责发送数据、另一个负责接收数据，这样就ok了
附上主函数
' Y( Q" p3 Y; Z0 p/ S: U

1. /**********************读取指定地址、指定长度的数据******************/
   
2. /* 因为读取在了指针中，所以不需要返回值 */
   - \/ H/ O0 J! }( u; @$ X- n/ o" ~
3. void FLASH_BufferRead(uint32_t addr , uint8_t* pBuffer ,uint16_t size)
   
4. {
   ; F2 |- J7 t$ u# E. M9 V2 h+ C9 t
5.         SPI_NSS_Begin();
   
6.         /* 发送读取命令 */
   
7.         SPI_SendData(W25X_ReadData);
   
8.         /* 发送读取数据的地址，高位先行 */
   / `! C/ J' V, i( o4 m6 t2 ^8 S3 ~& E
9.         SPI_SendData((addr & 0xff0000) >> 16);
   8 {9 l, N' j2 l3 g
10.         SPI_SendData((addr & 0xff00) >> 8);
    % _  `% N# G  V+ V/ h% v2 r: V
11.         SPI_SendData(addr & 0xff);
    
12.         /* 逐位读取数据到指针上 */
    
13.         while(size--)
    7 B7 q: S& x4 w# W( a; f3 v8 v, ]
14.         {
    $ ~. M5 ]+ a5 L6 H7 x8 T3 j& G1 s
15.                 *pBuffer=SPI_SendData(Dummy_Byte);
    3 O' a& m% }* s3 Q9 P( X
16.                 pBuffer++;
    
17.         }
    
18.         SPI_NSS_Stop();
      _' D1 w* M. {2 p- B0 |
19. }
    4 d9 T4 A5 G3 z$ U
20. 
    

复制代码

% d, X# _, j5 o6 u; {————————————————
* @% S3 b1 U$ f: s8 N' p# r  v版权声明：Aspirant-GQ

如有侵权请联系删除


0 j% m: K: Z# ~4 f  d: L% ~