STM32CUBUMX配置FLASH(W25Q128)--保姆级教程_stm32 w25q128

————————————————————————————————————
⏩ 大家好哇！我是小光，嵌入式爱好者，一个想要成为系统架构师的大三学生。
⏩最近在开发一个STM32H723ZGT6的板子，使用STM32CUBEMX做了很多驱动，包括ADC、UART、RS485、EEPROM(IIC)、FLASH(SPI)等等。
⏩本篇文章对STM32CUBEMX配置RS485做一个详细的使用教程。
⏩感谢你的阅读，不对的地方欢迎指正。
————————————————————————————————————

W25Q128简介

W25Q128是华邦公司推出的一款SPI接口的NOR Flash芯片，其存储空间为128Mbit，相当于16M字节。W25Q128V芯片是串行闪存，可以通过标准/两线/四线SPI控制。
W25Q128JV阵列被组织成65536个可编程页面，每个页面256字节。一次最多可编程256个字节。页面可以按16组（4KB扇区擦除）、128组（32KB块擦除）、256组（64KB块擦除或整个芯片（芯片擦除）擦除。W25Q128JV分别具有4096个可擦除扇区和256个可擦除块。小4KB扇区允许在需要数据和参数存储的应用中具有更大的灵活性。


具体可以看这个：通过数据手册带你全面解析闪存芯片W25Q128

实验环境

• STM32H723ZGT6开发板
• USB转串口
• W25Q128

硬件连接：

MX配置

板子、时钟、调试之类的配置就不说了，具体可以看看这篇：
STM32CUBEMX配置ADC(多通道轮询)(STM32H7)–保姆级教程
下面是SPI的具体配置

CS引脚配置

驱动代码

w25qxx.h

#ifndef W25Q128_W25QXX_H_
#define W25Q128_W25QXX_H_
 
#include "stm32H7xx_hal.h" //HAL库文件声明

//FLASH_CS 片选引脚定义
#define W25Q128_CS_GPIO_Port GPIOB
#define W25Q128_CS_Pin GPIO_PIN_12
 
//25系列FLASH芯片厂商与容量代号（厂商代号EF）
#define W25Q80    0XEF13
#define W25Q16    0XEF14
#define W25Q32    0XEF15
#define W25Q64    0XEF16
#define W25Q128   0XEF17
#define W25Q256 0XEF18
#define EX_FLASH_ADD 0x000000 //W25Q128的地址是24位宽
extern uint16_t W25QXX_TYPE;//定义W25QXX芯片型号
extern SPI_HandleTypeDef hspi2;
//
//指令表
#define W25X_WriteEnable             0x06
#define W25X_WriteDisable            0x04
#define W25X_ReadStatusReg1      0x05
#define W25X_ReadStatusReg2      0x35
#define W25X_ReadStatusReg3      0x15
#define W25X_WriteStatusReg1         0x01
#define W25X_WriteStatusReg2         0x31
#define W25X_WriteStatusReg3     0x11
#define W25X_ReadData             0x03
#define W25X_FastReadData         0x0B
#define W25X_FastReadDual         0x3B
#define W25X_PageProgram          0x02
#define W25X_BlockErase              0xD8
#define W25X_SectorErase          0x20
#define W25X_ChipErase            0xC7
#define W25X_PowerDown            0xB9
#define W25X_ReleasePowerDown    0xAB
#define W25X_DeviceID             0xAB
#define W25X_ManufactDeviceID    0x90
#define W25X_JedecDeviceID           0x9F
#define W25X_Enable4ByteAddr         0xB7
#define W25X_Exit4ByteAddr        0xE9
uint8_t SPI2_ReadWriteByte(uint8_t  TxData);//SPI2总线底层读写
void W25QXX_CS(uint8_t a);//W25QXX片选引脚控制
uint8_t W25QXX_Init(void);//初始化W25QXX函数
uint16_t  W25QXX_ReadID(void);//读取FLASH ID
uint8_t W25QXX_ReadSR(uint8_t regno);//读取状态寄存器
void W25QXX_4ByteAddr_Enable(void);//使能4字节地址模式
void W25QXX_Write_SR(uint8_t regno,uint8_t  sr);//写状态寄存器
void W25QXX_Write_Enable(void);//写使能
void W25QXX_Write_Disable(void);//写保护
void W25QXX_Write_NoCheck(uint8_t*  pBuffer,uint32_t WriteAddr,uint16_t  NumByteToWrite);//无检验写SPI FLASH
void W25QXX_Read(uint8_t* pBuffer,uint32_t  ReadAddr,uint16_t NumByteToRead);//读取flash
void W25QXX_Write(uint8_t* pBuffer,uint32_t  WriteAddr,uint16_t NumByteToWrite);//写入flash
void W25QXX_Erase_Chip(void);//整片擦除
void W25QXX_Erase_Sector(uint32_t  Dst_Addr);//扇区擦除
void W25QXX_Wait_Busy(void);//等待空闲
void W25QXX_PowerDown(void);//进入掉电模式
void W25QXX_WAKEUP(void);//唤醒
void W25QXX_Write_Page(uint8_t*  pBuffer,uint32_t WriteAddr,uint16_t  NumByteToWrite);
void delay_us(uint32_t us); //C文件中的函数声明
 
#endif /* W25Q128_W25QXX_H_ */
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64

w25qxx.c

#include "w25qxx.h"
#include "main.h"
uint16_t W25QXX_TYPE=W25Q128;//默认是W25Q128
//4Kbytes为一个Sector
//16个扇区为1个Block
//W25Q128
//容量为16M字节,共有128个Block,4096个Sector
//SPI2总线读写一个字节
//参数是写入的字节，返回值是读出的字节
uint8_t SPI2_ReadWriteByte(uint8_t TxData)
{
    uint8_t Rxdata;//定义一个变量Rxdata
     HAL_SPI_TransmitReceive(&hspi2,&TxData,&Rxdata,1,1000);//调用固件库函数收发数据
    return Rxdata;//返回收到的数据
}
void W25QXX_CS(uint8_t a)//软件控制函数（0为低电平，其他值为高电平）
{
    if(a==0)HAL_GPIO_WritePin(W25Q128_CS_GPIO_Port, W25Q128_CS_Pin, GPIO_PIN_RESET);
    else  HAL_GPIO_WritePin(W25Q128_CS_GPIO_Port,  W25Q128_CS_Pin, GPIO_PIN_SET);
}
//初始化SPI FLASH的IO口
uint8_t W25QXX_Init(void)
{
    uint8_t temp;//定义一个变量temp
    W25QXX_CS(1);//0片选开启，1片选关闭
    W25QXX_TYPE = W25QXX_ReadID();//读取FLASH  ID.
    if(W25QXX_TYPE == W25Q256)//SPI FLASH为W25Q256时才用设置为4字节地址模式
    {
       temp = W25QXX_ReadSR(3);//读取状态寄存器3，判断地址模式
       if((temp&0x01)==0)//如果不是4字节地址模式,则进入4字节地址模式
       {
           W25QXX_CS(0);//0片选开启，1片选关闭
           SPI2_ReadWriteByte(W25X_Enable4ByteAddr);//发送进入4字节地址模式指令
           W25QXX_CS(1);//0片选开启，1片选关闭
       }
    }
    if(W25QXX_TYPE==W25Q256||W25QXX_TYPE==W25Q128||W25QXX_TYPE==W25Q64
    ||W25QXX_TYPE==W25Q32||W25QXX_TYPE==W25Q16||W25QXX_TYPE==W25Q80)
    return 0; else return 1;//如果读出ID是现有型号列表中的一个，则识别芯片成功！
}
//读取W25QXX的状态寄存器，W25QXX一共有3个状态寄存器
//状态寄存器1：
//BIT7  6   5   4   3   2   1   0
//SPR   RV  TB BP2 BP1 BP0 WEL BUSY
//SPR:默认0,状态寄存器保护位,配合WP使用
//TB,BP2,BP1,BP0:FLASH区域写保护设置
//WEL:写使能锁定
//BUSY:忙标记位(1,忙;0,空闲)
//默认:0x00
//状态寄存器2：
//BIT7  6   5   4   3   2   1   0
//SUS   CMP LB3 LB2 LB1 (R) QE  SRP1
//状态寄存器3：
//BIT7      6    5    4   3   2   1   0
//HOLD/RST  DRV1 DRV0 (R) (R) WPS (R) (R)
//regno:状态寄存器号，范:1~3
//返回值:状态寄存器值
uint8_t W25QXX_ReadSR(uint8_t regno)
{
    uint8_t byte=0,command=0;
    switch(regno)
    {
        case 1:
            command=W25X_ReadStatusReg1;//读状态寄存器1指令
            break;
        case 2:
            command=W25X_ReadStatusReg2;//读状态寄存器2指令
            break;
        case 3:
            command=W25X_ReadStatusReg3;//读状态寄存器3指令
            break;
        default:
            command=W25X_ReadStatusReg1;//读状态寄存器1指令
            break;
    }
    W25QXX_CS(0);//0片选开启，1片选关闭
    SPI2_ReadWriteByte(command);//发送读取状态寄存器命令
    byte=SPI2_ReadWriteByte(0Xff);//读取一个字节
    W25QXX_CS(1);//0片选开启，1片选关闭
    return byte;//返回变量byte
}
//写W25QXX状态寄存器
void W25QXX_Write_SR(uint8_t regno,uint8_t  sr)
{
    uint8_t command=0;
    switch(regno)
    {
        case 1:
            command=W25X_WriteStatusReg1;//写状态寄存器1指令
            break;
        case 2:
            command=W25X_WriteStatusReg2;//写状态寄存器2指令
            break;
        case 3:
            command=W25X_WriteStatusReg3;//写状态寄存器3指令
            break;
        default:
            command=W25X_WriteStatusReg1;
            break;
    }
    W25QXX_CS(0);//0片选开启，1片选关闭
    SPI2_ReadWriteByte(command);//发送写取状态寄存器命令
    SPI2_ReadWriteByte(sr);//写入一个字节
    W25QXX_CS(1);//0片选开启，1片选关闭
}
//W25QXX写使能
//将WEL置位
void W25QXX_Write_Enable(void)
{
    W25QXX_CS(0);//0片选开启，1片选关闭
    SPI2_ReadWriteByte(W25X_WriteEnable);//发送写使能
    W25QXX_CS(1);//0片选开启，1片选关闭
}
//W25QXX写禁止
//将WEL清零
void W25QXX_Write_Disable(void)
{
    W25QXX_CS(0);//0片选开启，1片选关闭
    SPI2_ReadWriteByte(W25X_WriteDisable);//发送写禁止指令
    W25QXX_CS(1);//0片选开启，1片选关闭
}
//读取芯片ID
//高8位是厂商代号（本程序不判断厂商代号）
//低8位是容量大小
//0XEF13型号为W25Q80
//0XEF14型号为W25Q16
//0XEF15型号为W25Q32
//0XEF16型号为W25Q64
//0XEF17型号为W25Q128（目前洋桃2号开发板使用128容量芯片）
//0XEF18型号为W25Q256
uint16_t W25QXX_ReadID(void)
{
    uint16_t Temp = 0;
    W25QXX_CS(0);//0片选开启，1片选关闭
    SPI2_ReadWriteByte(0x90);//发送读取ID命令
    SPI2_ReadWriteByte(0x00);
    SPI2_ReadWriteByte(0x00);
    SPI2_ReadWriteByte(0x00);
    Temp|=SPI2_ReadWriteByte(0xFF)<<8;
    Temp|=SPI2_ReadWriteByte(0xFF);
    W25QXX_CS(1);//0片选开启，1片选关闭
    return Temp;
}
//读取SPI FLASH
//在指定地址开始读取指定长度的数据
//pBuffer:数据存储区
//ReadAddr:开始读取的地址(24bit)
//NumByteToRead:要读取的字节数(最大65535)
void W25QXX_Read(uint8_t* pBuffer,uint32_t  ReadAddr,uint16_t NumByteToRead)
{
    uint16_t i;
    W25QXX_CS(0);//0片选开启，1片选关闭
    SPI2_ReadWriteByte(W25X_ReadData);//发送读取命令
    if(W25QXX_TYPE==W25Q256)//如果是W25Q256的话地址为4字节的，要发送最高8位
    {
         SPI2_ReadWriteByte((uint8_t)((ReadAddr)>>24));
    }
     SPI2_ReadWriteByte((uint8_t)((ReadAddr)>>16));//发送24bit地址
     SPI2_ReadWriteByte((uint8_t)((ReadAddr)>>8));
    SPI2_ReadWriteByte((uint8_t)ReadAddr);
    for(i=0;i<NumByteToRead;i++)
    {
         pBuffer[i]=SPI2_ReadWriteByte(0XFF);//循环读数
    }
    W25QXX_CS(1);//0片选开启，1片选关闭
}
//SPI在一页(0~65535)内写入少于256个字节的数据
//在指定地址开始写入最大256字节的数据
//pBuffer:数据存储区
//WriteAddr:开始写入的地址(24bit)
//NumByteToWrite:要写入的字节数(最大256),该数不应该超过该页的剩余字节数!!!
void W25QXX_Write_Page(uint8_t*  pBuffer,uint32_t WriteAddr,uint16_t  NumByteToWrite)
{
    uint16_t i;
    W25QXX_Write_Enable();//SET WEL
    W25QXX_CS(0);//0片选开启，1片选关闭
    SPI2_ReadWriteByte(W25X_PageProgram);//发送写页命令
    if(W25QXX_TYPE==W25Q256)//如果是W25Q256的话地址为4字节的，要发送最高8位
    {
         SPI2_ReadWriteByte((uint8_t)((WriteAddr)>>24));
    }
     SPI2_ReadWriteByte((uint8_t)((WriteAddr)>>16));//发送24bit地址
     SPI2_ReadWriteByte((uint8_t)((WriteAddr)>>8));
    SPI2_ReadWriteByte((uint8_t)WriteAddr);
     for(i=0;i<NumByteToWrite;i++)SPI2_ReadWriteByte(pBuffer[i]);//循环写数
    W25QXX_CS(1);//0片选开启，1片选关闭
    W25QXX_Wait_Busy();//等待写入结束
}
//无检验写SPI FLASH
//必须确保所写的地址范围内的数据全部为0XFF,否则在非0XFF处写入的数据将失败!
//具有自动换页功能
//在指定地址开始写入指定长度的数据,但是要确保地址不越界!
//pBuffer:数据存储区
//WriteAddr:开始写入的地址(24bit)
//NumByteToWrite:要写入的字节数(最大65535)
//CHECK OK
void W25QXX_Write_NoCheck(uint8_t*  pBuffer,uint32_t WriteAddr,uint16_t  NumByteToWrite)
{
    uint16_t pageremain;
    pageremain=256-WriteAddr%256; //单页剩余的字节数
    if(NumByteToWrite<=pageremain)pageremain=NumByteToWrite;//不大于256个字节
    while(1)
    {
       W25QXX_Write_Page(pBuffer,WriteAddr,pageremain);
       if(NumByteToWrite==pageremain)break;//写入结束了
        else //NumByteToWrite>pageremain
       {
           pBuffer+=pageremain;
           WriteAddr+=pageremain;
           NumByteToWrite-=pageremain;            //减去已经写入了的字节数
           if(NumByteToWrite>256)pageremain=256; //一次可以写入256个字节
           else pageremain=NumByteToWrite;     //不够256个字节了
       }
    };
}
//写SPI FLASH
//在指定地址开始写入指定长度的数据
//该函数带擦除操作!
//pBuffer:数据存储区
//WriteAddr:开始写入的地址(24bit)
//NumByteToWrite:要写入的字节数(最大65535)
uint8_t W25QXX_BUFFER[4096];
void W25QXX_Write(uint8_t* pBuffer,uint32_t  WriteAddr,uint16_t NumByteToWrite)
{
    uint32_t secpos;
    uint16_t secoff;
    uint16_t secremain;
    uint16_t i;
    uint8_t* W25QXX_BUF;
    W25QXX_BUF=W25QXX_BUFFER;
    secpos=WriteAddr/4096;//扇区地址
    secoff=WriteAddr%4096;//在扇区内的偏移
    secremain=4096-secoff;//扇区剩余空间大小
    //printf("ad:%X,nb:%X\r\n",WriteAddr,NumByteToWrite);//测试用
    if(NumByteToWrite<=secremain)secremain=NumByteToWrite;//不大于4096个字节
    while(1)
    {
       W25QXX_Read(W25QXX_BUF,secpos*4096,4096);//读出整个扇区的内容
       for(i=0;i<secremain;i++)//校验数据
       {
           if(W25QXX_BUF[secoff+i]!=0XFF)break;//需要擦除
       }
       if(i<secremain)//需要擦除
       {
           W25QXX_Erase_Sector(secpos);//擦除这个扇区
           for(i=0;i<secremain;i++)//复制
           {
               W25QXX_BUF[i+secoff]=pBuffer[i];
           }
           W25QXX_Write_NoCheck(W25QXX_BUF,secpos*4096,4096);//写入整个扇区
       }else  W25QXX_Write_NoCheck(pBuffer,WriteAddr,secremain);//写已经擦除了的,直接写入扇区剩余区间.
       if(NumByteToWrite==secremain)break;//写入结束了
       else//写入未结束
       {
           secpos++;//扇区地址增1
           secoff=0;//偏移位置为0
           pBuffer+=secremain;  //指针偏移
           WriteAddr+=secremain;//写地址偏移
           NumByteToWrite-=secremain;//字节数递减
           if(NumByteToWrite>4096)secremain=4096;//下一个扇区还是写不完
           else  secremain=NumByteToWrite;//下一个扇区可以写完了
       }
    };
}
//擦除整个芯片
//等待时间超长...
void W25QXX_Erase_Chip(void)
{
    W25QXX_Write_Enable();//SET WEL
    W25QXX_Wait_Busy();//等待忙状态
    W25QXX_CS(0);//0片选开启，1片选关闭
    SPI2_ReadWriteByte(W25X_ChipErase);//发送片擦除命令
    W25QXX_CS(1);//0片选开启，1片选关闭
    W25QXX_Wait_Busy();//等待芯片擦除结束
}
//擦除一个扇区
//Dst_Addr:扇区地址 根据实际容量设置
//擦除一个扇区的最少时间:150ms
void W25QXX_Erase_Sector(uint32_t Dst_Addr)
{
    Dst_Addr*=4096;
    W25QXX_Write_Enable();//SET WEL
    W25QXX_Wait_Busy();
    W25QXX_CS(0);//0片选开启，1片选关闭
    SPI2_ReadWriteByte(W25X_SectorErase);//发送扇区擦除指令
    if(W25QXX_TYPE==W25Q256)//如果是W25Q256的话地址为4字节的，要发送最高8位
    {
         SPI2_ReadWriteByte((uint8_t)((Dst_Addr)>>24));
    }
    SPI2_ReadWriteByte((uint8_t)((Dst_Addr)>>16));//发送24bit地址
    SPI2_ReadWriteByte((uint8_t)((Dst_Addr)>>8));
    SPI2_ReadWriteByte((uint8_t)Dst_Addr);
    W25QXX_CS(1);//0片选开启，1片选关闭
    W25QXX_Wait_Busy();//等待擦除完成
}
//等待空闲
void W25QXX_Wait_Busy(void)
{
    while((W25QXX_ReadSR(1)&0x01)==0x01);//等待BUSY位清空
}
//进入掉电模式
void W25QXX_PowerDown(void)
{
    W25QXX_CS(0);//0片选开启，1片选关闭
    SPI2_ReadWriteByte(W25X_PowerDown);//发送掉电命令 0xB9
    W25QXX_CS(1);//0片选开启，1片选关闭
    delay_us(3);//等待TPD
}
//唤醒
void W25QXX_WAKEUP(void)
{
    W25QXX_CS(0);//0片选开启，1片选关闭
    SPI2_ReadWriteByte(W25X_ReleasePowerDown);//发送电源唤醒指令 0xAB
    W25QXX_CS(1);//0片选开启，1片选关闭
    delay_us(3);//等待TRES1
}
//延时
void delay_us(uint32_t us) //利用CPU循环实现的非精准应用的微秒延时函数
{
    uint32_t delay = (HAL_RCC_GetHCLKFreq() / 8000000 * us); //使用HAL_RCC_GetHCLKFreq()函数获取主频值，经算法得到1微秒的循环次数
    while (delay--); //循环delay次，达到1微秒延时
}


1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
175
176
177
178
179
180
181
182
183
184
185
186
187
188
189
190
191
192
193
194
195
196
197
198
199
200
201
202
203
204
205
206
207
208
209
210
211
212
213
214
215
216
217
218
219
220
221
222
223
224
225
226
227
228
229
230
231
232
233
234
235
236
237
238
239
240
241
242
243
244
245
246
247
248
249
250
251
252
253
254
255
256
257
258
259
260
261
262
263
264
265
266
267
268
269
270
271
272
273
274
275
276
277
278
279
280
281
282
283
284
285
286
287
288
289
290
291
292
293
294
295
296
297
298
299
300
301
302
303
304
305
306
307
308
309
310
311
312
313
314
315
316
317
318
319
320
321
322
323
324

main.c

		//W25Q128测试程序
		device_id = W25QXX_ReadID();
		printf("\r\nW25Q64 Device ID is 0x%04x\r\n", device_id);

		/* 为了验证，首先读取要写入地址处的数据 */
		printf("-------- read data before write -----------\r\n");
		W25QXX_Read(read_buf, 0, 10);
			
		for(i = 0; i < 10; i++) 
		{
			printf("[0x%08x]:0x%02x\r\n", i, *(read_buf+i));
		}
			
		/* 擦除该扇区 */
		printf("-------- erase sector 0 -----------\r\n");
		W25QXX_Erase_Sector(0);
		HAL_Delay(50);
		/* 再次读数据 */
		printf("-------- read data after erase -----------\r\n");
		W25QXX_Read(read_buf, 0, 10);
		for(i = 0; i < 10; i++) 
		{
			printf("[0x%08x]:0x%02x\r\n", i, *(read_buf+i));
		}
			
		/* 写数据 */
		printf("-------- write data -----------\r\n");
		for(i = 0; i < 10; i++) 
		{
			write_buf[i] = i;
		}
		W25QXX_Write(write_buf, 0, 10);
		HAL_Delay(50);
		/* 再次读数据 */
		printf("-------- read data after write -----------\r\n");
		W25QXX_Read(read_buf, 0, 10);
		for(i = 0; i < 10; i++) 
		{
			printf("[0x%08x]:0x%02x\r\n", i, *(read_buf+i));
		}
		
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41

测试结果

注意：在FLASH写数据之前一定要进行擦除。