stm32之软件SPI读写W25Q64存储器应用案例

于 2024-09-06 09:16:40 发布
阅读量619 收藏 15
点赞数 14
分类专栏： STM32 文章标签： stm32 SPI通信 W25Q64 flash 存储器 嵌入式开发 单片机
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/Mr_Jaychong/article/details/141934578
版权

系列文章目录

1. stm32之SPI通信协议

文章目录

前言

提示：本文主要用作在学习江科大自化协STM32入门教程后做的归纳总结笔记，旨在学习记录，如有侵权请联系作者

本案例使用软件SPI通信的方式实现了STM32与W25Q64 Flash存储器的通信，完成了常见的Flash存储器操作如读ID、页写、扇区擦除、读取数据等。

一、电路接线图

下图所示为W25Q64模块硬件接线图，左边是W25Q64模块作为从机，右边是stm32作为主机。为了方便下一章节硬件SPI的接线，这里直接就选择了硬件SPI1外设的接线方式。其中PA4对应主机的从机选择线SPI1_NSS连接到从机的CS引脚，PA5对应主机的时钟同步线SPI1_SCK连接到从机的CLK引脚，PA6对应主机的主机输入从机输出线SPI1_MISO连接到从机的DO引脚，PA7对应主机的主机输出从机输入线SPI1_MOSI连接到从机的DI引脚。最后，W25Q64模块的VCC和GND分别接到stm32的电源正负极进行供电。

在这里插入图片描述

二、应用案例代码

MySPI.h：

#ifndef __MYSPI_H
#define __MYSPI_H

void MySPI_Init(void);
void MySPI_Start(void);
void MySPI_Stop(void);
uint8_t MySPI_SwapByte(uint8_t ByteSend);

#endif

MySPI.c：

#include "stm32f10x.h"                  // Device header

void MySPI_W_SS(uint8_t BitValue)
{
	GPIO_WriteBit(GPIOA, GPIO_Pin_4, (BitAction)BitValue);
}

void MySPI_W_SCK(uint8_t BitValue)
{
	GPIO_WriteBit(GPIOA, GPIO_Pin_5, (BitAction)BitValue);
}

void MySPI_W_MOSI(uint8_t BitValue)
{
	GPIO_WriteBit(GPIOA, GPIO_Pin_7, (BitAction)BitValue);
}

uint8_t MySPI_R_MISO(void)
{
	return GPIO_ReadInputDataBit(GPIOA, GPIO_Pin_6);
}

void MySPI_Init(void)
{
	RCC_APB2PeriphClockCmd(RCC_APB2Periph_GPIOA, ENABLE);
	
	GPIO_InitTypeDef GPIO_InitStructure;
	GPIO_InitStructure.GPIO_Mode = GPIO_Mode_Out_PP;
	GPIO_InitStructure.GPIO_Pin = GPIO_Pin_4 | GPIO_Pin_5 | GPIO_Pin_7;
	GPIO_InitStructure.GPIO_Speed = GPIO_Speed_50MHz;
	GPIO_Init(GPIOA, &GPIO_InitStructure);
	
	GPIO_InitStructure.GPIO_Mode = GPIO_Mode_IPU;
	GPIO_InitStructure.GPIO_Pin = GPIO_Pin_6;
	GPIO_InitStructure.GPIO_Speed = GPIO_Speed_50MHz;
	GPIO_Init(GPIOA, &GPIO_InitStructure);
	
	MySPI_W_SS(1);
	MySPI_W_SCK(0);
}

void MySPI_Start(void)
{
	MySPI_W_SS(0);
}

void MySPI_Stop(void)
{
	MySPI_W_SS(1);
}

uint8_t MySPI_SwapByte(uint8_t ByteSend)
{
	uint8_t i, ByteReceive = 0x00;
	
	for (i = 0; i < 8; i ++)
	{
		MySPI_W_MOSI(ByteSend & (0x80 >> i));
		MySPI_W_SCK(1);
		if (MySPI_R_MISO() == 1){ByteReceive |= (0x80 >> i);}
		MySPI_W_SCK(0);
	}
	
	return ByteReceive;
}

W25Q64.h：

#ifndef __W25Q64_H
#define __W25Q64_H

void W25Q64_Init(void);
void W25Q64_ReadID(uint8_t *MID, uint16_t *DID);
void W25Q64_PageProgram(uint32_t Address, uint8_t *DataArray, uint16_t Count);
void W25Q64_SectorErase(uint32_t Address);
void W25Q64_ReadData(uint32_t Address, uint8_t *DataArray, uint32_t Count);

#endif

W25Q64_Ins.h：

#ifndef __W25Q64_INS_H
#define __W25Q64_INS_H

#define W25Q64_WRITE_ENABLE							0x06
#define W25Q64_WRITE_DISABLE						0x04
#define W25Q64_READ_STATUS_REGISTER_1				0x05
#define W25Q64_READ_STATUS_REGISTER_2				0x35
#define W25Q64_WRITE_STATUS_REGISTER				0x01
#define W25Q64_PAGE_PROGRAM							0x02
#define W25Q64_QUAD_PAGE_PROGRAM					0x32
#define W25Q64_BLOCK_ERASE_64KB						0xD8
#define W25Q64_BLOCK_ERASE_32KB						0x52
#define W25Q64_SECTOR_ERASE_4KB						0x20
#define W25Q64_CHIP_ERASE							0xC7
#define W25Q64_ERASE_SUSPEND						0x75
#define W25Q64_ERASE_RESUME							0x7A
#define W25Q64_POWER_DOWN							0xB9
#define W25Q64_HIGH_PERFORMANCE_MODE				0xA3
#define W25Q64_CONTINUOUS_READ_MODE_RESET			0xFF
#define W25Q64_RELEASE_POWER_DOWN_HPM_DEVICE_ID		0xAB
#define W25Q64_MANUFACTURER_DEVICE_ID				0x90
#define W25Q64_READ_UNIQUE_ID						0x4B
#define W25Q64_JEDEC_ID								0x9F
#define W25Q64_READ_DATA							0x03
#define W25Q64_FAST_READ							0x0B
#define W25Q64_FAST_READ_DUAL_OUTPUT				0x3B
#define W25Q64_FAST_READ_DUAL_IO					0xBB
#define W25Q64_FAST_READ_QUAD_OUTPUT				0x6B
#define W25Q64_FAST_READ_QUAD_IO					0xEB
#define W25Q64_OCTAL_WORD_READ_QUAD_IO				0xE3

#define W25Q64_DUMMY_BYTE							0xFF

#endif

W25Q64.c：

#include "stm32f10x.h"                  // Device header
#include "MySPI.h"
#include "W25Q64_Ins.h"

void W25Q64_Init(void)
{
	MySPI_Init();
}

void W25Q64_ReadID(uint8_t *MID, uint16_t *DID)
{
	MySPI_Start();
	MySPI_SwapByte(W25Q64_JEDEC_ID);
	*MID = MySPI_SwapByte(W25Q64_DUMMY_BYTE);
	*DID = MySPI_SwapByte(W25Q64_DUMMY_BYTE);
	*DID <<= 8;
	*DID |= MySPI_SwapByte(W25Q64_DUMMY_BYTE);
	MySPI_Stop();
}

void W25Q64_WriteEnable(void)
{
	MySPI_Start();
	MySPI_SwapByte(W25Q64_WRITE_ENABLE);
	MySPI_Stop();
}

void W25Q64_WaitBusy(void)
{
	uint32_t Timeout;
	MySPI_Start();
	MySPI_SwapByte(W25Q64_READ_STATUS_REGISTER_1);
	Timeout = 100000;
	while ((MySPI_SwapByte(W25Q64_DUMMY_BYTE) & 0x01) == 0x01)
	{
		Timeout --;
		if (Timeout == 0)
		{
			break;
		}
	}
	MySPI_Stop();
}

void W25Q64_PageProgram(uint32_t Address, uint8_t *DataArray, uint16_t Count)
{
	uint16_t i;
	
	W25Q64_WriteEnable();
	
	MySPI_Start();
	MySPI_SwapByte(W25Q64_PAGE_PROGRAM);
	MySPI_SwapByte(Address >> 16);
	MySPI_SwapByte(Address >> 8);
	MySPI_SwapByte(Address);
	for (i = 0; i < Count; i ++)
	{
		MySPI_SwapByte(DataArray[i]);
	}
	MySPI_Stop();
	
	W25Q64_WaitBusy();
}

void W25Q64_SectorErase(uint32_t Address)
{
	W25Q64_WriteEnable();
	
	MySPI_Start();
	MySPI_SwapByte(W25Q64_SECTOR_ERASE_4KB);
	MySPI_SwapByte(Address >> 16);
	MySPI_SwapByte(Address >> 8);
	MySPI_SwapByte(Address);
	MySPI_Stop();
	
	W25Q64_WaitBusy();
}

void W25Q64_ReadData(uint32_t Address, uint8_t *DataArray, uint32_t Count)
{
	uint32_t i;
	MySPI_Start();
	MySPI_SwapByte(W25Q64_READ_DATA);
	MySPI_SwapByte(Address >> 16);
	MySPI_SwapByte(Address >> 8);
	MySPI_SwapByte(Address);
	for (i = 0; i < Count; i ++)
	{
		DataArray[i] = MySPI_SwapByte(W25Q64_DUMMY_BYTE);
	}
	MySPI_Stop();
}

main.c：

#include "stm32f10x.h"                  // Device header
#include "Delay.h"
#include "OLED.h"
#include "W25Q64.h"

uint8_t MID;
uint16_t DID;

uint8_t ArrayWrite[] = {0x01, 0x02, 0x03, 0x04};
uint8_t ArrayRead[4];

int main(void)
{
	OLED_Init();
	W25Q64_Init();
	
	OLED_ShowString(1, 1, "MID:   DID:");
	OLED_ShowString(2, 1, "W:");
	OLED_ShowString(3, 1, "R:");
	
	W25Q64_ReadID(&MID, &DID);
	OLED_ShowHexNum(1, 5, MID, 2);
	OLED_ShowHexNum(1, 12, DID, 4);
	
	W25Q64_SectorErase(0x000000);
	W25Q64_PageProgram(0x000000, ArrayWrite, 4);
	
	W25Q64_ReadData(0x000000, ArrayRead, 4);
	
	OLED_ShowHexNum(2, 3, ArrayWrite[0], 2);
	OLED_ShowHexNum(2, 6, ArrayWrite[1], 2);
	OLED_ShowHexNum(2, 9, ArrayWrite[2], 2);
	OLED_ShowHexNum(2, 12, ArrayWrite[3], 2);
	
	OLED_ShowHexNum(3, 3, ArrayRead[0], 2);
	OLED_ShowHexNum(3, 6, ArrayRead[1], 2);
	OLED_ShowHexNum(3, 9, ArrayRead[2], 2);
	OLED_ShowHexNum(3, 12, ArrayRead[3], 2);
	
	while (1)
	{
		
	}
}

完整工程：stm32之软件SPI读写W25Q64存储器

三、应用案例分析

从整体架构来看主要分为SPI通信模块、W25Q64模块，接下来重点分析一下SPI通信模块以及W25Q64模块。

3.1 SPI通信模块

SPI通信模块主要封装了一个模块初始化函数和三个时序单元模块。

SPI模块初始化函数：

void MySPI_Init(void)
{
	RCC_APB2PeriphClockCmd(RCC_APB2Periph_GPIOA, ENABLE);
	
	GPIO_InitTypeDef GPIO_InitStructure;
	GPIO_InitStructure.GPIO_Mode = GPIO_Mode_Out_PP;
	GPIO_InitStructure.GPIO_Pin = GPIO_Pin_4 | GPIO_Pin_5 | GPIO_Pin_7;
	GPIO_InitStructure.GPIO_Speed = GPIO_Speed_50MHz;
	GPIO_Init(GPIOA, &GPIO_InitStructure);
	
	GPIO_InitStructure.GPIO_Mode = GPIO_Mode_IPU;
	GPIO_InitStructure.GPIO_Pin = GPIO_Pin_6;
	GPIO_InitStructure.GPIO_Speed = GPIO_Speed_50MHz;
	GPIO_Init(GPIOA, &GPIO_InitStructure);
	
	MySPI_W_SS(1);
	MySPI_W_SCK(0);
}

这个没什么好讲的了，都是一样的套路了。

这里要注意一下的就是PA4（SS）、PA5（SCK）、PA7（MOSI）引脚配置为推挽输出模式（GPIO_Mode_Out_PP），用于主设备主动输出信号。PA6（MISO）配置为上拉输入模式（GPIO_Mode_IPU），表示从设备的数据通过此引脚传输到主设备。

最后再设置一下总线的初始状态即可，设置 SS 引脚为高电平，即取消选择从设备，然后初始化时钟引脚为低电平。

三个时序单元模块：

三个时序单元分别是起始信号、终止信号以及交换一个字节。

起始信号、终止信号：

void MySPI_Start(void)
{
	MySPI_W_SS(0);
}

void MySPI_Stop(void)
{
	MySPI_W_SS(1);
}

起始条件：SS从高电平切换到低电平
终止条件：SS从低电平切换到高电平

交换一个字节：

uint8_t MySPI_SwapByte(uint8_t ByteSend)
{
	uint8_t i, ByteReceive = 0x00;
	
	for (i = 0; i < 8; i ++)
	{
		MySPI_W_MOSI(ByteSend & (0x80 >> i));
		MySPI_W_SCK(1);
		if (MySPI_R_MISO() == 1){ByteReceive |= (0x80 >> i);}
		MySPI_W_SCK(0);
	}
	
	return ByteReceive;
}

交换一个字节(模式0)：
CPOL=0：空闲状态时，SCK为低电平
CPHA=0：SCK第一个边沿移入数据，第二个边沿移出数据

交换一个字节的时序这里用的是模式0。起始信号之后先立刻将数据的最高位B7移出，然后在SCK的第一个上升沿后读入B7，然后在SCK的第一个下降沿移出次高位B6，然后在SCK的第二个上升沿读入B6，然后在SCK的第二个下降沿移出B5…如此循环8次，最终在SCK的第八个上升沿读入B0完成一个字节的交换。

至于关于代码部分的按位与(提取字节中的每一位)和按位或(设置字节中的某位)以及左移、右移操作的解析在我之前的一篇文章里已经详细地分析过了，如果有不懂的就翻回去看看就行了，这里就不再累述了。

文章传送门：计算机常见运算之左移操作、右移操作以及按位与、按位或

3.2 W25Q64模块

W25Q64模块主要由模块初始化函数、写使能、页编程(写入数据)、读取数据、忙等待、读取ID号以及扇区擦除等模块组成。

W25Q64模块初始化函数：

void W25Q64_Init(void)
{
	MySPI_Init();
}

调用MySPI_Init()函数，完成引脚配置和SPI的初始化。

写使能：

void W25Q64_WriteEnable(void)
{
	MySPI_Start();
	MySPI_SwapByte(W25Q64_WRITE_ENABLE);// 发送写使能命令
	MySPI_Stop();
}

发送写使能命令，以允许后续的写入或擦除操作。

页编程(写入数据)：

void W25Q64_PageProgram(uint32_t Address, uint8_t *DataArray, uint16_t Count) 
{
    uint16_t i;
    
    W25Q64_WriteEnable(); // 写使能
    
    MySPI_Start();
    MySPI_SwapByte(W25Q64_PAGE_PROGRAM); // 发送页编程命令
    MySPI_SwapByte(Address >> 16); // 发送地址高8位
    MySPI_SwapByte(Address >> 8);  // 发送地址中8位
    MySPI_SwapByte(Address);       // 发送地址低8位

    for (i = 0; i < Count; i ++) { // 发送要写入的数据
        MySPI_SwapByte(DataArray[i]);
    }

    MySPI_Stop();
    
    W25Q64_WaitBusy(); // 等待存储器空闲
}

页编程操作首先通过W25Q64_WriteEnable()函数启用写操作，然后发送页编程命令W25Q64_PAGE_PROGRAM，接着发送地址，并逐字节将数据写入存储器。

读数据：

void W25Q64_ReadData(uint32_t Address, uint8_t *DataArray, uint32_t Count) 
{
    uint32_t i;
    MySPI_Start();
    MySPI_SwapByte(W25Q64_READ_DATA); // 发送读取数据命令
    MySPI_SwapByte(Address >> 16); // 发送地址高8位
    MySPI_SwapByte(Address >> 8);  // 发送地址中8位
    MySPI_SwapByte(Address);       // 发送地址低8位
    for (i = 0; i < Count; i ++) { // 读取数据
        DataArray[i] = MySPI_SwapByte(W25Q64_DUMMY_BYTE);
    }
    MySPI_Stop();
}

读取数据命令W25Q64_READ_DATA，发送要读取的地址，然后通过SPI逐字节读取指定数量的数据到DataArray中。

忙等待：

void W25Q64_WaitBusy(void)
{
	uint32_t Timeout;
	MySPI_Start();
	MySPI_SwapByte(W25Q64_READ_STATUS_REGISTER_1);// 读取状态寄存器1
	Timeout = 100000;
	while ((MySPI_SwapByte(W25Q64_DUMMY_BYTE) & 0x01) == 0x01){// 检查忙标志位
		Timeout --;
		if (Timeout == 0)
		{
			break;
		}
	}
	MySPI_Stop();
}

发送读取状态寄存器1命令，进入循环等待存储器空闲（即状态寄存器的最低位变为0），避免在存储器仍处于忙碌时进行新的操作。

读厂商、设备ID：

void W25Q64_ReadID(uint8_t *MID, uint16_t *DID) 
{
    MySPI_Start(); // 片选低电平，开始通信
    MySPI_SwapByte(W25Q64_JEDEC_ID); // 发送读取ID命令
    *MID = MySPI_SwapByte(W25Q64_DUMMY_BYTE); // 接收制造商ID
    *DID = MySPI_SwapByte(W25Q64_DUMMY_BYTE); // 接收设备ID高8位
    *DID <<= 8;
    *DID |= MySPI_SwapByte(W25Q64_DUMMY_BYTE); // 接收设备ID低8位
    MySPI_Stop(); // 片选高电平，结束通信
}
  • 首先，调用MySPI_Start()开始SPI通信，然后发送读取设备ID命令W25Q64_JEDEC_ID。随后，通过MySPI_SwapByte函数接收制造商ID和设备ID。
  • 制造商ID（MID）为一个字节，设备ID（DID）为两个字节。

扇区擦除：

void W25Q64_SectorErase(uint32_t Address) 
{
    W25Q64_WriteEnable(); // 写使能
    
    MySPI_Start();
    MySPI_SwapByte(W25Q64_SECTOR_ERASE_4KB); // 发送扇区擦除命令
    MySPI_SwapByte(Address >> 16); // 发送地址高8位
    MySPI_SwapByte(Address >> 8);  // 发送地址中8位
    MySPI_SwapByte(Address);       // 发送地址低8位
    MySPI_Stop();
    
    W25Q64_WaitBusy(); // 等待存储器空闲
}

扇区擦除命令W25Q64_SECTOR_ERASE_4KB用于擦除特定地址所在的扇区，地址通过三次发送高、中、低8位地址来指定。

3.3 主程序

主程序整体代码逻辑大概是，首先读取从机的ID信息并显示在OLED屏幕上，然后执行一个扇区擦除操作，接着在该扇区中写入4个字节的数据，最后将写入的数据读取出来，并在OLED上显示。

#include "stm32f10x.h"                  // Device header
#include "Delay.h"
#include "OLED.h"
#include "W25Q64.h"

uint8_t MID;// 制造商ID (Manufacturer ID)
uint16_t DID;// 设备ID (Device ID)

uint8_t ArrayWrite[] = {0x01, 0x02, 0x03, 0x04};
uint8_t ArrayRead[4];

int main(void)
{
	// 硬件初始化
	OLED_Init();
	W25Q64_Init();
	
	
	OLED_ShowString(1, 1, "MID:   DID:");
	OLED_ShowString(2, 1, "W:");
	OLED_ShowString(3, 1, "R:");
	
	// 读取并显示W25Q64的ID信息
	W25Q64_ReadID(&MID, &DID);
	OLED_ShowHexNum(1, 5, MID, 2);
	OLED_ShowHexNum(1, 12, DID, 4);
	
	// 擦除W25Q64的一个扇区并写入数据
	W25Q64_SectorErase(0x000000);
	W25Q64_PageProgram(0x000000, ArrayWrite, 4);
	
	// 读取数据并显示
	W25Q64_ReadData(0x000000, ArrayRead, 4);
	
	OLED_ShowHexNum(2, 3, ArrayWrite[0], 2);
	OLED_ShowHexNum(2, 6, ArrayWrite[1], 2);
	OLED_ShowHexNum(2, 9, ArrayWrite[2], 2);
	OLED_ShowHexNum(2, 12, ArrayWrite[3], 2);
	
	OLED_ShowHexNum(3, 3, ArrayRead[0], 2);
	OLED_ShowHexNum(3, 6, ArrayRead[1], 2);
	OLED_ShowHexNum(3, 9, ArrayRead[2], 2);
	OLED_ShowHexNum(3, 12, ArrayRead[3], 2);
	
	while (1)
	{
		
	}
}
钟剑锋-JeffChong
关注
  • 14
    点赞
  • 踩
  • 15
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
【STM32】软件SPI读写W25Q64芯片
weixin_63135906的博客
02-18 2480
W25Qxx系列是一种低成本、小型化、使用简单的非易失性存储器，常应用于数据存储字库存储固件程序存储等场景存储介质：Nor Flash（闪存）时钟频率：80MHz / 160MHz (Dual SPI) / 320MHz (Quad SPI)存储容量（24位地址）：在51单片机中学过一款比较经典的存储芯片AT24C02（I2C通信协议），蓝桥杯嵌入式板子上用的也是AT24C02（I2C通信协议），容量一般是kb级别的。
STM32通过SPI软件读写W25Q64
TENET123的博客
06-22 1047
代码包括STM32通过SPI软件读写W25Q64
STM32学习笔记（十一）丨SPI通信（W25Q64芯片简介，使用SPI读写W25Q64存储器芯片）
电子德彪西的博客
07-14 7857
Bilibili课程 江协科技 STM32个人学习笔记
【STM32】硬件SPI读写W25Q64芯片
weixin_63135906的博客
02-19 1241
STM32内部集成了硬件SPI收发电路，可以由硬件自动执行时钟生成、数据收发等功能，减轻CPU的负担可配置8位/16位数据帧、高位先行/低位先行时钟频率： fPCLK / (2, 4, 8, 16, 32, 64, 128, 256)支持多主机模型、主或从操作可精简为半双工/单工通信支持DMA兼容I2S协议（音频）STM32F103C8T6硬件SPI资源：SPI1（APB2）、SPI2（APB1）
STM32--软件SPI读写W25Q64（中）
m0_61593113的博客
08-30 1016
事前等待，效率会高一点，因为写完之后不等，程序可以执行其他代码，在执行其他代码期间，来消耗等待的时间，说不定下一次事前等待的时候，时间已经被耗过去了。由于指令比较多，每个指令都对应一个指令码，如果直接在程序里写一个数字，那意义就不太明显，可读性不高。页编程一次性写入数据的范围是0~256，所以是16位的，如果这个Count是uint8_t的话，只能存0~255，这样当我们写256个数据时，就会出现问题。最后一个指令，读取数据，流程是先发送一个指令，在发送3个字节的地址，再转入接收，就可以依次接收数据了。
STM32-SPI通信（W25Q64芯片简介，使用SPI读写W25Q64存储器芯片）
zhuxinmingde的博客
07-30 3660
​  SPI（Serial Peripheral Interface）是由Motorola公司开发的一种通用数据总线四根通信线：SCK（Serial Clock）、MOSI（Master Output Slave Input）、MISO（Master Input Slave Output）、SS（Slave Select）。同步，全双工；支持总线挂载多设备（SPI仅支持一主多从）；在不同情况下，通信线的名称可能有所变化：MOSI：DI（对从机而言）；MISO：DO（对从机而言）；
​​​​​​​STM32通过SPI硬件读写W25Q64
L_Z_J_I的博客
08-16 752
​​​​​​​STM32通过SPI硬件读写W25Q64
STM32通过SPI硬件读写W25Q64
TENET123的博客
06-22 1303
代码包括STM32通过SPI硬件读写W25Q64
STM32CubeMx之硬件SPI驱动W25Q64
热门推荐
weixin_44453694的博客
04-04 1万+
SPI是串行外设接口（Serial Peripheral Interface）的缩写，是一种高速的，全双工，同步的通信总线，并且在芯片的管脚上只占用四根线。 W25Q64(64M-bit)是为系统提供一个最小的空间、引脚和功耗的存储器解决方案的串行Flash存储器。W25Q64的内存空间结构：一页256字节，4K(4096字节)为一个扇区，16个扇区为1块，容量为8M字节,共有128个块,2048个扇区。 W25Q64驱动方式为SPI，支持SPI总线的工作模式0(0，0)和3( 1，1)。模式0和模式3。
我在高职教STM32——ADC电压采集与光敏电阻（3）
gmc832002的博客
08-27 775
本文是《ADC电压采集与光敏电阻》的第三篇，针对STM32的ADC配置要点做了解读，并明确的实验目标、工程文件和编程要点。
智能停车解决方案：STM32无人收费机器人助力停车场管理（详细流程）
嵌入式极客小张
09-05 989
智能无人停车场收费机器人旨在通过自动化技术提升停车场的管理效率和用户体验。该系统通过监测车辆的进出情况，实现自动收费和停车位管理，减少人工干预，提高停车场的智能化水平。本项目实现了一个智能无人停车场收费机器人，主要功能包括：车辆检测：通过超声波传感器实时监测车辆的进出情况。照明控制：根据环境光线自动控制补光灯的开关，提升夜间停车场的安全性。自动收费：通过Wi-Fi模块与后台服务器进行通信，实现车辆离开时的自动扣款。
STM32（F103ZET6）第十九课：FreeRtos的移植和使用
2401_83971583的博客
08-28 1005
裸机执行流程：前后台系统操作系统执行流程：加入操作系统的作用：用户想要实现多个任务并行的效果，但是单片机只有一个核心，同时只能处理一件事，通过加入操作系统，可以实现任务快速的切换，给人一种多个任务同时在执行的错觉。
stm32之SPI通信协议
Mr_Jaychong的博客
09-05 593
本文主要探讨SPI通信协议。关于SPI通信的内容我主要会分为两大块来讲，第一块，就是介绍协议规则，然后用软件模拟的形式来实现协议。第二块，就是介绍stm32的SPI外设，然后用硬件来实现协议。
STM32（十）：ADC模数转换器
最新发布
weixin_52307528的博客
09-05 484
ADC可以将引脚上连续变化的转换为内存中存储的，建立模拟电路到数字电路的桥梁。12位逐次逼近型ADC，1us转换时间，分辨率：0~2^12-1输入电压范围：0~3.3V，转换结果范围：0~409518个输入通道，可测量16个外部（16个GPIO口）和2个内部信号源（内部温度传感器和内部参考电压1.2v基准电压）规则组和注入组两个转换单元模拟看门狗自动监测输入电压范围。
STM32（一）简介
m0_73597306的博客
09-05 87
通过程序配置外设来完成功能
STM32高级定时器生成互补PWM的原理与代码实现
Joseph Wen的博客
09-05 735
本文通过一个具体实例，详细阐述了STM32高级定时器产生互补PWM信号的原理。文章提供了生成互补PWM所需的代码实现，并利用Keil模拟器中的逻辑分析仪工具对生成的PWM信号进行了验证和分析。
【STM32+HAL库】---- 硬件IIC驱动0.96OLED
欢迎来到我的博客
09-04 727
硬件开发板：STM32G0B1RET6 软件平台：cubemax+keil+VScode 内容原著声明 代码借鉴学习于以下文章： STM32 使用硬件IIC驱动0.96寸4针IOLED显示器（HAL库） 1 新建cubemax工程 1.1 配置系统时钟RCC 1.2 配置引脚 1.3 导出工程 略… 2 代码 2.1 OLED_IIC_Config.h /** * ********************************************************************
STM32
2301_78104311的博客
08-29 1157
（以下操作环境为Keil5和proteus8.9）
stm32fc8t6 spidma w25q128
11-01
STM32F4C8T6是一款由STMicroelectronics生产的32位ARM Cortex-M4微控制器，具有丰富的外设和高性能。它内置了SPI接口，可以与其他SPI设备进行通信。 SPI（Serial Peripheral Interface）是一种串行外设接口，用于在微控制器之间传输数据。通过SPI接口，STM32F4C8T6可以与其他SPI设备（如传感器、存储器等）进行通信，以实现数据的收发和控制。 W25Q128是一款由Winbond生产的闪存存储器芯片，具有128Mb（16MB）的存储容量。它采用SPI接口，可以与STM32F4C8T6进行连接，并提供存储空间用于程序代码、数据和其他信息。W25Q128具有快速的读写速度和低功耗特性，适用于嵌入式系统中的存储需求。 通过使用STM32F4C8T6的SPI接口和DMA（Direct Memory Access）功能，可以实现高效的数据传输和存储操作。DMA可以在不占用CPU的情况下，直接将数据从SPI接口读取或写入W25Q128存储器。这样可以提高系统性能，并减轻CPU的负担。 综上所述，STM32F4C8T6与SPIDMA（SPI接口和DMA）结合使用，可以方便地与W25Q128存储器进行通信和存储操作，从而实现高性能和高效率的嵌入式系统设计。
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值