收集整理了一份《2024年最新物联网嵌入式全套学习资料》，初衷也很简单，就是希望能够帮助到想自学提升的朋友。
一个人可以走的很快，但一群人才能走的更远！不论你是正从事IT行业的老鸟或是对IT行业感兴趣的新人
都欢迎加入我们的的圈子（技术交流、学习资源、职场吐槽、大厂内推、面试辅导），让我们一起学习成长！
本成员设置SPI工作在主机模式(SPI_Mode_Master)或从机模式(SPI_Mode_Slave )，这两个模式的最大区别为 SPI 的 SCK信号线的时序，SCK 的时序是由通讯中的主机产生的。若被配置为从机模式，STM32的 SPI外设将接受外来的 SCK信号。
(3) SPI_DataSize
本成员可以选择 SPI 通讯的数据帧大小是为 8 位(SPI_DataSize_8b)还是 16 位(SPI_DataSize_16b)。
(4) SPI_CPOL和 SPI_CPHA
这两个成员配置 SPI的时钟极性 CPOL和时钟相位 CPHA，这两个配置影响到 SPI的通讯模式，关于 CPOL和 CPHA 的说明参考前面“通讯模式”小节。
时钟极性 CPOL成员，可设置为高电平(SPI_CPOL_High)或低电平(SPI_CPOL_Low )。
时钟相位 CPHA 则可以设置为 SPI_CPHA_1Edge(在 SCK 的奇数边沿采集数据) 或SPI_CPHA_2Edge (在 SCK的偶数边沿采集数据) 。
(5) SPI_NSS
本成员配置 NSS 引脚的使用模式，可以选择为硬件模式(SPI_NSS_Hard )与软件模式（SPI_NSS_Soft )，在硬件模式中的 SPI 片选信号由 SPI 硬件自动产生，而软件模式则需要我们亲自把相应的 GPIO 端口拉高或置低产生非片选和片选信号。实际中软件模式应用比较多。
(6) SPI_BaudRatePrescaler
本成员设置波特率分频因子，分频后的时钟即为 SPI 的 SCK 信号线的时钟频率。这个成员参数可设置为 fpclk的 2、4、6、8、16、32、64、128、256分频。
(7) SPI_FirstBit
所有串行的通讯协议都会有 MSB 先行(高位数据在前)还是 LSB 先行(低位数据在前)的问题，而 STM32的 SPI模块可以通过这个结构体成员，对这个特性编程控制。
(8) SPI_CRCPolynomial
这是 SPI 的 CRC 校验中的多项式，若我们使用 CRC 校验时，就使用这个成员的参数(多项式)，来计算 CRC 的值。
配置完这些结构体成员后，我们要调用 SPI_Init 函数把这些参数写入到寄存器中，实现 SPI的初始化，然后调用 SPI_Cmd 来使能 SPI外设。
四、SPI—读写串行 FLASH 实验
FLSAH 存储器又称闪存，它与 EEPROM 都是掉电后数据不丢失的存储器，但 FLASH存储器容量普遍大于 EEPROM，现在基本取代了它的地位。我们生活中常用的 U 盘、SD卡、SSD 固态硬盘以及我们 STM32 芯片内部用于存储程序的设备，都是 FLASH 类型的存储器。在存储控制上，最主要的区别是 FLASH 芯片只能一大片一大片地擦写，而在“I2C章节”中我们了解到 EEPROM可以单个字节擦写。
本小节以一种使用 SPI 通讯的串行 FLASH 存储芯片的读写实验讲解 STM32 的SPI 使用方法。实验中 STM32 的 SPI 外设采用主模式，通过查询事件的方式来确保正常通讯。
1、硬件设计
本实验板中的 FLASH芯片(型号：W25Q64)是一种使用 SPI通讯协议的NOR FLASH存储 器 ， 它 的 CS/CLK/DIO/DO 引 脚 分 别 连 接 到 了 STM32 对 应 的 SPI 引 脚NSS/SCK/MOSI/MISO 上，其中 STM32的 NSS 引脚虽然是其片上 SPI外设的硬件引脚，但实际上后面的程序只是把它当成一个普通的 GPIO，使用软件的方式控制 NSS 信号，所以在 SPI的硬件设计中，NSS 可以随便选择普通的 GPIO，不必纠结于选择硬件 NSS信号。
FLASH 芯片中还有 WP 和 HOLD 引脚。WP 引脚可控制写保护功能，当该引脚为低电平时，禁止写入数据。我们直接接电源，不使用写保护功能。HOLD 引脚可用于暂停通讯，该引脚为低电平时，通讯暂停，数据输出引脚输出高阻抗状态，时钟和数据输入引脚无效。
我们直接接电源，不使用通讯暂停功能。关于 FLASH 芯片的更多信息，可参考其数据手册《W25Q64》来了解。若实验板 FLASH的型号或控制引脚不一样，只需根据我们的工程修改即可，程序的控制原理相同。
2、软件设计
为了使工程更加有条理，我们把读写 FLASH相关的代码独立分开存储，方便以后移植。
在“工程模板”之上新建“bsp_spi_flash.c”及“bsp_spi_ flash.h”文件，这些文件也可根据您的喜好命名，它们不属于 STM32标准库的内容，是由我们自己根据应用需要编写的。
1） 编程要点
初始化通讯使用的目标引脚及端口时钟；
使能 SPI外设的时钟；
配置 SPI外设的模式、地址、速率等参数并使能 SPI外设；
编写基本 SPI按字节收发的函数；
编写对 FLASH 擦除及读写操作的的函数；
编写测试程序，对读写数据进行校验。
2） 代码分析
SPI 硬件相关宏定义
我们把 SPI硬件相关的配置都以宏的形式定义到 “bsp_spi_ flash.h”文件中
1 /*SPI 接口定义-开头****************************/
2 #define FLASH_SPIx SPI1
3 #define FLASH_SPI_APBxClock_FUN RCC_APB2PeriphClockCmd
4 #define FLASH_SPI_CLK RCC_APB2Periph_SPI1
5
6 //CS(NSS)引脚 片选选普通 GPIO 即可
7 #define FLASH_SPI_CS_APBxClock_FUN RCC_APB2PeriphClockCmd
8 #define FLASH_SPI_CS_CLK RCC_APB2Periph_GPIOA
9 #define FLASH_SPI_CS_PORT GPIOA
10 #define FLASH_SPI_CS_PIN GPIO_Pin_4
11
12 //SCK 引脚
13 #define FLASH_SPI_SCK_APBxClock_FUN RCC_APB2PeriphClockCmd
14 #define FLASH_SPI_SCK_CLK RCC_APB2Periph_GPIOA
15 #define FLASH_SPI_SCK_PORT GPIOA
16 #define FLASH_SPI_SCK_PIN GPIO_Pin_5
17 //MISO 引脚
18 #define FLASH_SPI_MISO_APBxClock_FUN RCC_APB2PeriphClockCmd
19 #define FLASH_SPI_MISO_CLK RCC_APB2Periph_GPIOA
20 #define FLASH_SPI_MISO_PORT GPIOA
21 #define FLASH_SPI_MISO_PIN GPIO_Pin_6
22 //MOSI 引脚
23 #define FLASH_SPI_MOSI_APBxClock_FUN RCC_APB2PeriphClockCmd
24 #define FLASH_SPI_MOSI_CLK RCC_APB2Periph_GPIOA
25 #define FLASH_SPI_MOSI_PORT GPIOA
26 #define FLASH_SPI_MOSI_PIN GPIO_Pin_7
27
28 #define FLASH_SPI_CS_LOW() GPIO_ResetBits( FLASH_SPI_CS_PORT, FLASH_SPI_CS_PIN )
29 #define FLASH_SPI_CS_HIGH() GPIO_SetBits( FLASH_SPI_CS_PORT, FLASH_SPI_CS_PIN )
30
31 /*SPI 接口定义-结尾****************************/
以上代码根据硬件连接，把与 FLASH 通讯使用的 SPI 号 、GPIO 等都以宏封装起来，并且定义了控制 CS(NSS)引脚输出电平的宏，以便配置产生起始和停止信号时使用。
初始化 SPI 的 GPIO
利用上面的宏，编写 SPI的初始化函数。
1 /**
2 * @brief SPI_FLASH 初始化
3 * @param 无
4 * @retval 无
5 */
6 void SPI_FLASH_Init(void)
7 {
8 SPI_InitTypeDef SPI_InitStructure;
9 GPIO_InitTypeDef GPIO_InitStructure;
10
11 /* 使能 SPI 时钟 */
12 FLASH_SPI_APBxClock_FUN ( FLASH_SPI_CLK, ENABLE );
13
14 /* 使能 SPI 引脚相关的时钟 */
15 FLASH_SPI_CS_APBxClock_FUN ( FLASH_SPI_CS_CLK|FLASH_SPI_SCK_CLK|
16 FLASH_SPI_MISO_PIN|FLASH_SPI_MOSI_PIN, ENABLE );
17
18 /* 配置 SPI 的 CS 引脚，普通 IO 即可 */
19 GPIO_InitStructure.GPIO_Pin = FLASH_SPI_CS_PIN;
20 GPIO_InitStructure.GPIO_Speed = GPIO_Speed_50MHz;
21 GPIO_InitStructure.GPIO_Mode = GPIO_Mode_Out_PP;
22 GPIO_Init(FLASH_SPI_CS_PORT, &GPIO_InitStructure);
23
24 /* 配置 SPI 的 SCK 引脚*/
25 GPIO_InitStructure.GPIO_Pin = FLASH_SPI_SCK_PIN;
26 GPIO_InitStructure.GPIO_Mode = GPIO_Mode_AF_PP;
27 GPIO_Init(FLASH_SPI_SCK_PORT, &GPIO_InitStructure);
28
29 /* 配置 SPI 的 MF103-霸道引脚*/
30 GPIO_InitStructure.GPIO_Pin = FLASH_SPI_MISO_PIN;
31 GPIO_Init(FLASH_SPI_MISO_PORT, &GPIO_InitStructure);
32
33 /* 配置 SPI 的 MOSI 引脚*/
34 GPIO_InitStructure.GPIO_Pin = FLASH_SPI_MOSI_PIN;
35 GPIO_Init(FLASH_SPI_MOSI_PORT, &GPIO_InitStructure);
36
37 /* 停止信号 FLASH: CS 引脚高电平*/
38 FLASH_SPI_CS_HIGH();
39 //为方便讲解，以下省略 SPI 模式初始化部分
40 }
与所有使用到 GPIO的外设一样，都要先把使用到的 GPIO引脚模式初始化，配置好复用功能。GPIO初始化流程如下：
(1) 使用GPIO_InitTypeDef定义 GPIO初始化结构体变量，以便下面用于存储GPIO配置；
(2) 调用库函数 RCC_APB2PeriphClockCmd 来使能 SPI引脚使用的 GPIO 端口时钟。
(3) 向 GPIO 初始化结构体赋值，把 SCK/MOSI/MISO 引脚初始化成复用推挽模式。而CS(NSS)引脚由于使用软件控制，我们把它配置为普通的推挽输出模式。
(4) 使用以上初始化结构体的配置，调用 GPIO_Init 函数向寄存器写入参数，完成 GPIO 的初始化。
配置 SPI 的模式
以上只是配置了 SPI 使用的引脚，对 SPI 外设模式的配置。在配置 STM32 的 SPI 模式前，我们要先了解从机端的 SPI 模式。本例子中可通过查阅 FLASH 数据手册《W25Q64》获取。根据 FLASH 芯片的说明，它支持 SPI模式 0及模式 3，支持双线全双工，使用 MSB先行模式，支持最高通讯时钟为 104MHz，数据帧长度为 8 位。我们要把 STM32 的 SPI 外设中的这些参数配置一致。
1 /**
2 * @brief SPI_FLASH 引脚初始化
3 * @param 无
4 * @retval 无
5 */
6 void SPI_FLASH_Init(void)
7 {
8 /*为方便讲解，省略了 SPI 的 GPIO 初始化部分*/
9 //......
10
11 SPI_InitTypeDef SPI_InitStructure;
12 /* SPI 模式配置 */
13 // FLASH 芯片 支持 SPI 模式 0 及模式 3，据此设置 CPOL CPHA
14 SPI_InitStructure.SPI_Direction = SPI_Direction_2Lines_FullDuplex;
15 SPI_InitStructure.SPI_Mode = SPI_Mode_Master;
16 SPI_InitStructure.SPI_DataSize = SPI_DataSize_8b;
17 SPI_InitStructure.SPI_CPOL = SPI_CPOL_High;
18 SPI_InitStructure.SPI_CPHA = SPI_CPHA_2Edge;
19 SPI_InitStructure.SPI_NSS = SPI_NSS_Soft;
20 SPI_InitStructure.SPI_BaudRatePrescaler = SPI_BaudRatePrescaler_4;
21 SPI_InitStructure.SPI_FirstBit = SPI_FirstBit_MSB;
22 SPI_InitStructure.SPI_CRCPolynomial = 7;
23 SPI_Init(FLASH_SPIx, &SPI_InitStructure);
24
25 /* 使能 SPI */
26 SPI_Cmd(FLASH_SPIx, ENABLE);
27 }
这段代码中，把 STM32 的 SPI 外设配置为主机端，双线全双工模式，数据帧长度为 8位，使用 SPI 模式 3(CPOL=1，CPHA=1)，NSS 引脚由软件控制以及 MSB 先行模式。代码中把 SPI的时钟频率配置成了 4分频，实际上可以配置成 2分频以提高通讯速率，读者可亲自尝试一下。最后一个成员为 CRC 计算式，由于我们与 FLASH 芯片通讯不需要 CRC 校验，并没有使能 SPI的 CRC功能，这时 CRC计算式的成员值是无效的。
赋值结束后调用库函数 SPI_Init 把这些配置写入寄存器，并调用 SPI_Cmd 函数使能外设。
使用 SPI 发送和接收一个字节的数据
初始化好SPI外设后，就可以使用SPI通讯了，复杂的数据通讯都是由单个字节数据收发组成的，我们看看它的代码实现。
1 #define Dummy_Byte 0xFF
2 /**
3 * @brief 使用 SPI 发送一个字节的数据
4 * @param byte：要发送的数据
5 * @retval 返回接收到的数据
6 */
7 u8 SPI_FLASH_SendByte(u8 byte)
8 {
9 SPITimeout = SPIT_FLAG_TIMEOUT;
10
11 /* 等待发送缓冲区为空，TXE 事件 */
12 while (SPI_I2S_GetFlagStatus(FLASH_SPIx, SPI_I2S_FLAG_TXE) == RESET)
13 {
14 if ((SPITimeout--) == 0) return SPI_TIMEOUT_UserCallback(0);
15 }
16
17 /* 写入数据寄存器，把要写入的数据写入发送缓冲区 */
18 SPI_I2S_SendData(FLASH_SPIx, byte);
19
20 SPITimeout = SPIT_FLAG_TIMEOUT;
21
22 /* 等待接收缓冲区非空，RXNE 事件 */
23 while (SPI_I2S_GetFlagStatus(FLASH_SPIx, SPI_I2S_FLAG_RXNE) == RESET)
24 {
25 if ((SPITimeout--) == 0) return SPI_TIMEOUT_UserCallback(1);
26 }
27
28 /* 读取数据寄存器，获取接收缓冲区数据 */
29 return SPI_I2S_ReceiveData(FLASH_SPIx);
30 }
31
32 /**
33 * @brief 使用 SPI 读取一个字节的数据
34 * @param 无
35 * @retval 返回接收到的数据
36 */
37 u8 SPI_FLASH_ReadByte(void)
38 {
39 return (SPI_FLASH_SendByte(Dummy_Byte));
40 }
SPI_FLASH_SendByte 发送单字节函数中包含了等待事件的超时处理，这部分原理跟I2C 中的一样，在此不再赘述。
SPI_FLASH_SendByte 函数实现了前面讲解的“SPI通讯过程”：
(1) 本函数中不包含 SPI 起始和停止信号，只是收发的主要过程，所以在调用本函数前后要做好起始和停止信号的操作；
(2) 对 SPITimeout 变量赋值为宏 SPIT_FLAG_TIMEOUT。这个 SPITimeout 变量在下面的 while 循环中每次循环减 1，该循环通过调用库函数 SPI_I2S_GetFlagStatus 检测事件，若检测到事件，则进入通讯的下一阶段，若未检测到事件则停留在此处一直检测，当检测 SPIT_FLAG_TIMEOUT次都还没等待到事件则认为通讯失败，调用的 SPI_TIMEOUT_UserCallback输出调试信息，并退出通讯；
(3) 通过检测 TXE 标志，获取发送缓冲区的状态，若发送缓冲区为空，则表示可能存在的上一个数据已经发送完毕；
(4) 等待至发送缓冲区为空后，调用库函数 SPI_I2S_SendData 把要发送的数据“byte”写入到 SPI 的数据寄存器 DR，写入 SPI 数据寄存器的数据会存储到发送缓冲区，由 SPI外设发送出去；
(5) 写入完毕后等待 RXNE 事件，即接收缓冲区非空事件。由于 SPI 双线全双工模式下 MOSI 与 MISO 数据传输是同步的(请对比“SPI 通讯过程”阅读)，当接收缓冲区非空时，表示上面的数据发送完毕，且接收缓冲区也收到新的数据；
(6) 等待至接收缓冲区非空时，通过调用库函数 SPI_I2S_ReceiveData 读取 SPI 的数据寄存器 DR，就可以获取接收缓冲区中的新数据了。代码中使用关键字“return”把接收到的这个数据作为 SPI_FLASH_SendByte 函数的返回值，所以我们可以看到在下面定义的 SPI 接收数据函数 SPI_FLASH_ReadByte，它只是简单地调用了SPI_FLASH_SendByte 函数发送数据“Dummy_Byte”，然后获取其返回值(因为不关注发送的数据，所以此时的输入参数“Dummy_Byte”可以为任意值)。可以这样做的原因是 SPI 的接收过程和发送过程实质是一样的，收发同步进行，关键在于我们的上层应用中，关注的是发送还是接收的数据。
控制 FLASH 的指令
搞定 SPI 的基本收发单元后，还需要了解如何对 FLASH 芯片进行读写。FLASH 芯片自定义了很多指令，我们通过控制 STM32 利用 SPI 总线向 FLASH 芯片发送指令，FLASH芯片收到后就会执行相应的操作。
而这些指令，对主机端(STM32)来说，只是它遵守最基本的 SPI通讯协议发送出的数据，但在设备端(FLASH芯片)把这些数据解释成不同的意义，所以才成为指令。查看 FLASH芯片的数据手册《W25Q64》，可了解各种它定义的各种指令的功能及指令格式
定义 FLASH 指令编码表
为了方便使用，我们把 FLASH芯片的常用指令编码使用宏来封装起来，后面需要发送
指令编码的时候我们直接使用这些宏即可
FLASH 指令编码表
1 /*FLASH 常用命令*/
2 #define W25X_WriteEnable 0x06
3 #define W25X_WriteDisable 0x04
4 #define W25X_ReadStatusReg 0x05
5 #define W25X_WriteStatusReg 0x01
6 #define W25X_ReadData 0x03
7 #define W25X_FastReadData 0x0B
8 #define W25X_FastReadDual 0x3B
9 #define W25X_PageProgram 0x02
10 #define W25X_BlockErase 0xD8
11 #define W25X_SectorErase 0x20
12 #define W25X_ChipErase 0xC7
13 #define W25X_PowerDown 0xB9
14 #define W25X_ReleasePowerDown 0xAB
15 #define W25X_DeviceID 0xAB
16 #define W25X_ManufactDeviceID 0x90
17 #define W25X_JedecDeviceID 0x9F
18 /*其它*/
19 #define sFLASH_ID 0XEF4017
20 #define Dummy_Byte 0xFF
读取 FLASH 芯片 ID
根据“JEDEC”指令的时序，我们把读取 FLASH ID 的过程编写成一个函数。
读取 FLASH 芯片 ID
1 /**
2 * @brief 读取 FLASH ID
3 * @param 无
4 * @retval FLASH ID
5 */
6 u32 SPI_FLASH_ReadID(void)
7 {
8 u32 Temp = 0, Temp0 = 0, Temp1 = 0, Temp2 = 0;
9
10 /* 开始通讯：CS 低电平 */
11 SPI_FLASH_CS_LOW();
12
13 /* 发送 JEDEC 指令，读取 ID */
14 SPI_FLASH_SendByte(W25X_JedecDeviceID);
15
16 /* 读取一个字节数据 */
17 Temp0 = SPI_FLASH_SendByte(Dummy_Byte);
18
19 /* 读取一个字节数据 */
20 Temp1 = SPI_FLASH_SendByte(Dummy_Byte);
21
22 /* 读取一个字节数据 */
23 Temp2 = SPI_FLASH_SendByte(Dummy_Byte);
24
25 /* 停止通讯：CS 高电平 */
26 SPI_FLASH_CS_HIGH();
27
28 /*把数据组合起来，作为函数的返回值*/
29 Temp = (Temp0 << 16) | (Temp1 << 8) | Temp2;
30
31 return Temp;
32 }
这段代码利用控制 CS 引脚电平的宏“SPI_FLASH_CS_LOW/HIGH”以及前面编写的单字节收发函数 SPI_FLASH_SendByte，很清晰地实现了“JEDEC ID”指令的时序：发送一个字节的指令编码“W25X_JedecDeviceID”，然后读取 3 个字节，获取 FLASH 芯片对该指令的响应，最后把读取到的这 3 个数据合并到一个变量 Temp 中，然后作为函数返回值，把该返回值与我们定义的宏“sFLASH_ID”对比，即可知道 FLASH 芯片是否正常。
FLASH 写使能以及读取当前状态
在向 FLASH 芯片存储矩阵写入数据前，首先要使能写操作，通过“Write Enable”命令即可写使能。
1 /**
2 * @brief 向 FLASH 发送 写使能 命令
3 * @param none
4 * @retval none
5 */
6 void SPI_FLASH_WriteEnable(void)
7 {
8 /* 通讯开始：CS 低 */
9 SPI_FLASH_CS_LOW();
10
11 /* 发送写使能命令*/
12 SPI_FLASH_SendByte(W25X_WriteEnable);
13
14 /*通讯结束：CS 高 */
15 SPI_FLASH_CS_HIGH();
16 }
与 EEPROM 一样，由于 FLASH 芯片向内部存储矩阵写入数据需要消耗一定的时间，并不是在总线通讯结束的一瞬间完成的，所以在写操作后需要确认 FLASH芯片“空闲”时才能进行再次写入。为了表示自己的工作状态，FLASH 芯片定义了一个状态寄存器。
我们只关注这个状态寄存器的第0位“BUSY”，当这个位为“1”时，表明FLASH芯片处于忙碌状态，它可能正在对内部的存储矩阵进行“擦除”或“数据写入”的操作。
利用指令表中的“Read Status Register”指令可以获取 FLASH 芯片状态寄存器的内容，其时序见下图
只要向 FLASH 芯片发送了读状态寄存器的指令，FLASH 芯片就会持续向主机返回最新的状态寄存器内容，直到收到 SPI通讯的停止信号。据此我们编写了具有等待 FLASH 芯片写入结束功能的函数。
1 /* WIP(busy)标志，FLASH 内部正在写入 */
2 #define WIP_Flag 0x01
3
4 /**
5 * @brief 等待 WIP(BUSY)标志被置 0，即等待到 FLASH 内部数据写入完毕
6 * @param none
7 * @retval none
8 */
9 void SPI_FLASH_WaitForWriteEnd(void)
10 {
11 u8 FLASH_Status = 0;
12
13 /* 选择 FLASH: CS 低 */
14 SPI_FLASH_CS_LOW();
15
16 /* 发送 读状态寄存器 命令 */
17 SPI_FLASH_SendByte(W25X_ReadStatusReg);
18
19 /* 若 FLASH 忙碌，则等待 */
20 do
21 {
22 /* 读取 FLASH 芯片的状态寄存器 */
23 FLASH_Status = SPI_FLASH_SendByte(Dummy_Byte);
24 }
25 while ((FLASH_Status & WIP_Flag) == SET); /* 正在写入标志 */
26
27 /* 停止信号 FLASH: CS 高 */
28 SPI_FLASH_CS_HIGH();
29 }
这段代码发送读状态寄存器的指令编码“W25X_ReadStatusReg”后，在 while 循环里持续获取寄存器的内容并检验它的“WIP_Flag 标志”(即 BUSY 位)，一直等待到该标志表示写入结束时才退出本函数，以便继续后面与 FLASH 芯片的数据通讯。
FLASH 扇区擦除
由于 FLASH存储器的特性决定了它只能把原来为“1”的数据位改写成“0”，而原来为“0”的数据位不能直接改写为“1”。所以这里涉及到数据“擦除”的概念，在写入前，必须要对目标存储矩阵进行擦除操作，把矩阵中的数据位擦除为“1”，在数据写入的时候，如果要存储数据“1”，那就不修改存储矩阵 ，在要存储数据“0”时，才更改该位。通常，对存储矩阵擦除的基本操作单位都是多个字节进行，如本例子中的 FLASH芯片支持“扇区擦除”、“块擦除”以及“整片擦除”。
扇区擦除指令的第一个字节为指令编码，紧接着发送的 3 个字节用于表示要擦除的存
储矩阵地址。要注意的是在扇区擦除指令前，还需要先发送“写使能”指令，发送扇区擦
除指令后，通过读取寄存器状态等待扇区擦除操作完毕
1 /**
2 * @brief 擦除 FLASH 扇区
3 * @param SectorAddr：要擦除的扇区地址
4 * @retval 无
5 */
6 void SPI_FLASH_SectorErase(u32 SectorAddr)
7 {
8 /* 发送 FLASH 写使能命令 */
9 SPI_FLASH_WriteEnable();
10 SPI_FLASH_WaitForWriteEnd();
11 /* 擦除扇区 */
12 /* 选择 FLASH: CS 低电平 */
13 SPI_FLASH_CS_LOW();
14 /* 发送扇区擦除指令*/
15 SPI_FLASH_SendByte(W25X_SectorErase);
16 /*发送擦除扇区地址的高位*/
17 SPI_FLASH_SendByte((SectorAddr & 0xFF0000) >> 16);
18 /* 发送擦除扇区地址的中位 */
19 SPI_FLASH_SendByte((SectorAddr & 0xFF00) >> 8);
20 /* 发送擦除扇区地址的低位 */
21 SPI_FLASH_SendByte(SectorAddr & 0xFF);
22 /* 停止信号 FLASH: CS 高电平 */
23 SPI_FLASH_CS_HIGH();
24 /* 等待擦除完毕*/
25 SPI_FLASH_WaitForWriteEnd();
26 }
这段代码调用的函数在前面都已讲解，只要注意发送擦除地址时高位在前即可。调用扇区擦除指令时注意输入的地址要对齐到 4KB。
FLASH 的页写入
目标扇区被擦除完毕后，就可以向它写入数据了。与 EEPROM 类似，FLASH 芯片也有页写入命令，使用页写入命令最多可以一次向 FLASH 传输 256个字节的数据，我们把这个单位为页大小。FLASH 页写入的时序见图 。
从时序图可知，第 1 个字节为“页写入指令”编码，2-4 字节为要写入的“地址 A”，接着的是要写入的内容，最多个可以发送 256 字节数据，这些数据将会从“地址 A”开始，按顺序写入到 FLASH的存储矩阵。若发送的数据超出 256个，则会覆盖前面发送的数据。与擦除指令不一样，页写入指令的地址并不要求按 256 字节对齐，只要确认目标存储单元是擦除状态即可(即被擦除后没有被写入过)。所以，若对“地址 x”执行页写入指令后，发送了 200 个字节数据后终止通讯，下一次再执行页写入指令，从“地址(x+200)”开始写入200个字节也是没有问题的(小于256均可)。 只是在实际应用中由于基本擦除单元是4KB，一般都以扇区为单位进行读写。
把页写入时序封装成函数
FLASH 的页写入
1 /**
2 * @brief 对 FLASH 按页写入数据，调用本函数写入数据前需要先擦除扇区
3 * @param pBuffer，要写入数据的指针
4 * @param WriteAddr，写入地址
5 * @param NumByteToWrite，写入数据长度，必须小于等于页大小
6 * @retval 无
7 */
8 void SPI_FLASH_PageWrite(u8* pBuffer, u32 WriteAddr, u16 NumByteToWrite)
9 {
10 /* 发送 FLASH 写使能命令 */
11 SPI_FLASH_WriteEnable();
12
13 /* 选择 FLASH: CS 低电平 */
14 SPI_FLASH_CS_LOW();
15 /* 写送写指令*/
16 SPI_FLASH_SendByte(W25X_PageProgram);
17 /*发送写地址的高位*/
18 SPI_FLASH_SendByte((WriteAddr & 0xFF0000) >> 16);
19 /*发送写地址的中位*/
20 SPI_FLASH_SendByte((WriteAddr & 0xFF00) >> 8);
21 /*发送写地址的低位*/
22 SPI_FLASH_SendByte(WriteAddr & 0xFF);
23
24 if (NumByteToWrite > SPI_FLASH_PerWritePageSize)
25 {
26 NumByteToWrite = SPI_FLASH_PerWritePageSize;
27 FLASH_ERROR("SPI_FLASH_PageWrite too large!");
28 }
29
30 /* 写入数据*/
31 while (NumByteToWrite--)
32 {
33 /* 发送当前要写入的字节数据 */
34 SPI_FLASH_SendByte(*pBuffer);
35 /* 指向下一字节数据 */
36 pBuffer++;
37 }
38
39 /* 停止信号 FLASH: CS 高电平 */
40 SPI_FLASH_CS_HIGH();
41
42 /* 等待写入完毕*/
43 SPI_FLASH_WaitForWriteEnd();
44 }
这段代码的内容为：先发送“写使能”命令，接着才开始页写入时序，然后发送指令编码、地址，再把要写入的数据一个接一个地发送出去，发送完后结束通讯，检查 FLASH状态寄存器，等待 FLASH 内部写入结束。
不定量数据写入
应用的时候我们常常要写入不定量的数据，直接调用“页写入”函数并不是特别方便，所以我们在它的基础上编写了“不定量数据写入”的函数。
1 /**
2 * @brief 对 FLASH 写入数据，调用本函数写入数据前需要先擦除扇区
3 * @param pBuffer，要写入数据的指针
4 * @param WriteAddr，写入地址
5 * @param NumByteToWrite，写入数据长度
6 * @retval 无
7 */
8 void SPI_FLASH_BufferWrite(u8* pBuffer, u32 WriteAddr, u16 NumByteToWrite)
9 {
10 u8 NumOfPage = 0, NumOfSingle = 0, Addr = 0, count = 0, temp = 0;
11
12 /*mod 运算求余，若 writeAddr 是 SPI_FLASH_PageSize 整数倍，
13 运算结果 Addr 值为 0*/
14 Addr = WriteAddr % SPI_FLASH_PageSize;
15
16 /*差 count 个数据值，刚好可以对齐到页地址*/
17 count = SPI_FLASH_PageSize - Addr;
18 /*计算出要写多少整数页*/
19 NumOfPage = NumByteToWrite / SPI_FLASH_PageSize;
20 /*mod 运算求余，计算出剩余不满一页的字节数*/
21 NumOfSingle = NumByteToWrite % SPI_FLASH_PageSize;
22
23 /* Addr=0,则 WriteAddr 刚好按页对齐 aligned */
24 if (Addr == 0)
25 {
26 /* NumByteToWrite < SPI_FLASH_PageSize */
27 if (NumOfPage == 0)
28 {
29 SPI_FLASH_PageWrite(pBuffer, WriteAddr,
30 NumByteToWrite);
31 }
32 else /* NumByteToWrite > SPI_FLASH_PageSize */
33 {
34 /*先把整数页都写了*/
35 while (NumOfPage--)
36 {
37 SPI_FLASH_PageWrite(pBuffer, WriteAddr,
38 SPI_FLASH_PageSize);
39 WriteAddr += SPI_FLASH_PageSize;
40 pBuffer += SPI_FLASH_PageSize;
41 }
42 /*若有多余的不满一页的数据，把它写完*/
43 SPI_FLASH_PageWrite(pBuffer, WriteAddr,
44 NumOfSingle);
45 }
46 }
47 /* 若地址与 SPI_FLASH_PageSize 不对齐 */
48 else
49 {
50 /* NumByteToWrite < SPI_FLASH_PageSize */
51 if (NumOfPage == 0)
52 {
53 /*当前页剩余的 count 个位置比 NumOfSingle 小，一页写不完*/
54 if (NumOfSingle > count)
55 {
56 temp = NumOfSingle - count;
57 /*先写满当前页*/
58 SPI_FLASH_PageWrite(pBuffer, WriteAddr, count);
59
60 WriteAddr += count;
61 pBuffer += count;
62 /*再写剩余的数据*/
63 SPI_FLASH_PageWrite(pBuffer, WriteAddr, temp);
64 }
65 else /*当前页剩余的 count 个位置能写完 NumOfSingle 个数据*/
66 {
67 SPI_FLASH_PageWrite(pBuffer, WriteAddr,
68 NumByteToWrite);
69 }
70 }
71 else /* NumByteToWrite > SPI_FLASH_PageSize */
72 {
73 /*地址不对齐多出的 count 分开处理，不加入这个运算*/
74 NumByteToWrite -= count;
75 NumOfPage = NumByteToWrite / SPI_FLASH_PageSize;
76 NumOfSingle = NumByteToWrite % SPI_FLASH_PageSize;
77
78 /* 先写完 count 个数据，为的是让下一次要写的地址对齐 */
79 SPI_FLASH_PageWrite(pBuffer, WriteAddr, count);
80
81 /* 接下来就重复地址对齐的情况 */
82 WriteAddr += count;
83 pBuffer += count;
84 /*把整数页都写了*/
85 while (NumOfPage--)
86 {
87 SPI_FLASH_PageWrite(pBuffer, WriteAddr,
88 SPI_FLASH_PageSize);
89 WriteAddr += SPI_FLASH_PageSize;
**收集整理了一份《2024年最新物联网嵌入式全套学习资料》，初衷也很简单，就是希望能够帮助到想自学提升的朋友。**
**[如果你需要这些资料，可以戳这里获取](https://gitee.com/vip204888)**
**一个人可以走的很快，但一群人才能走的更远！不论你是正从事IT行业的老鸟或是对IT行业感兴趣的新人**
**都欢迎加入我们的的圈子（技术交流、学习资源、职场吐槽、大厂内推、面试辅导），让我们一起学习成长！**
