stm32 操作W25Q256 W25Q16 spi flash

已于 2023-06-29 16:45:04 修改
阅读量7.1k 收藏 72
点赞数 12
分类专栏： STM32 文章标签： stm32 spi flash w25q128 w25q256
于 2022-07-27 20:34:22 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/u010261063/article/details/126022334
版权
本文档介绍了如何使用STM32通过SPI接口与华邦W25Q16 SPI Flash进行通信，包括SPI配置、读写操作以及芯片识别。代码中提供了初始化函数、读写函数和擦除函数，适用于正点原子F407电机开发板。测试表明，华邦W25Q16和W25Q256的SPI配置要求上升沿采集数据，且芯片在0x200000地址处写入的数据可以从0x000000读取，验证了其环形缓冲区特性。
摘要由CSDN通过智能技术生成

硬件连接

今天我使用W25Q16做了一个测试，发现了W25Q16内部是一个环形缓冲区，在0x200000地址处写入数据，我可以在0x000000处读取到0x200000地址的数据，从这里就可以正面W25Q16是一个环形缓冲区的norfalsh

本函数库来自正点原子官方，本人稍作修改和添加注释

W25Q16 2M Byte

在这里插入图片描述

W25Q256 32M Byte

在这里插入图片描述

spi 配置

2022-7-27 经过测试

  1. 华邦的 W25Q256JV 32M 字节 容量的spi flash没有问题 spi配置是 上升沿采集数据 —> CPOL =0 CPOA=0 或者是 CPOL=1 CPOA=1 hspi2.Init.CLKPolarity = SPI_POLARITY_LOW; hspi2.Init.CLKPhase = SPI_PHASE_1EDGE;
  2. 华邦的 W25Q16JVSSIQ 2M 字节 容量的spi flash没有问题

第1种配置

在这里插入图片描述

第2种配置

在这里插入图片描述

测试代码

  1. 需要修改CS片选引脚
  2. 需要选着spi外设

头文件

/**
 ****************************************************************************************************
 * @file        norflash.h
 * @author      正点原子团队(ALIENTEK)
 * @version     V1.0
 * @date        2021-10-26
 * @brief       NOR FLASH(25QXX) 驱动代码
 * @license     Copyright (c) 2020-2032, 广州市星翼电子科技有限公司
 ****************************************************************************************************
 * @attention
 *
 * 实验平台：正点原子 F407电机开发板
 * 在线视频：www.yuanzige.com
 * 技术论坛：http://www.openedv.com/forum.php
 * 公司网址：www.alientek.com
 * 购买地址：zhengdianyuanzi.tmall.com
 *
 * 修改说明
 * V1.0 20211026
 * 第一次发布
 *
 ****************************************************************************************************
 */

#ifndef __norflash_H
#define __norflash_H

#include "main.h"


/*
	2022-7-27 经过测试 华邦的 W25Q256JV   32M 字节 容量的spi flash没有问题  spi配置是  上升沿采集数据 ---> CPOL =0 CPOA=0  或者是 CPOL=1 CPOA=1   hspi2.Init.CLKPolarity = SPI_POLARITY_LOW;  hspi2.Init.CLKPhase = SPI_PHASE_1EDGE;
										华邦的  W25Q16JVSSIQ 2M 字节 容量的spi flash没有问题 
	
*/






/* SPI总线速度设置 */
#define SPI_SPEED_2         0
#define SPI_SPEED_4         1
#define SPI_SPEED_8         2
#define SPI_SPEED_16        3
#define SPI_SPEED_32        4
#define SPI_SPEED_64        5
#define SPI_SPEED_128       6
#define SPI_SPEED_256       7


/******************************************************************************************/
/* NORFLASH 片选 引脚 定义 */

#define NORFLASH_CS_GPIO_PORT           GPIOA
#define NORFLASH_CS_GPIO_PIN            GPIO_PIN_2
#define NORFLASH_CS_GPIO_CLK_ENABLE()   do{ __HAL_RCC_GPIOA_CLK_ENABLE(); }while(0)   /* PI口时钟使能 */

/******************************************************************************************/
//spi外设选择
extern SPI_HandleTypeDef hspi1;
#define HSPI hspi1

/* NORFLASH 片选信号 */
#define NORFLASH_CS(x)      do{ x ? \
                                  HAL_GPIO_WritePin(NORFLASH_CS_GPIO_PORT, NORFLASH_CS_GPIO_PIN, GPIO_PIN_SET) : \
                                  HAL_GPIO_WritePin(NORFLASH_CS_GPIO_PORT, NORFLASH_CS_GPIO_PIN, GPIO_PIN_RESET); \
                            }while(0)

/* FLASH芯片列表 */
#define W25Q80      0XEF13          /* W25Q80   芯片ID */
#define W25Q16      0XEF14          /* W25Q16   芯片ID */
#define W25Q32      0XEF15          /* W25Q32   芯片ID */
#define W25Q64      0XEF16          /* W25Q64   芯片ID */
#define W25Q128     0XEF17          /* W25Q128  芯片ID */
#define W25Q256     0XEF18          /* W25Q256  芯片ID */
#define BY25Q64     0X6816          /* BY25Q64  芯片ID */
#define BY25Q128    0X6817          /* BY25Q128 芯片ID */
#define NM25Q64     0X5216          /* NM25Q64  芯片ID */
#define NM25Q128    0X5217          /* NM25Q128 芯片ID */

extern uint16_t norflash_TYPE;      /* 定义FLASH芯片型号 */
 
/* 指令表 */
#define FLASH_WriteEnable           0x06 
#define FLASH_WriteDisable          0x04 
#define FLASH_ReadStatusReg1        0x05 
#define FLASH_ReadStatusReg2        0x35 
#define FLASH_ReadStatusReg3        0x15 
#define FLASH_WriteStatusReg1       0x01 
#define FLASH_WriteStatusReg2       0x31 
#define FLASH_WriteStatusReg3       0x11 
#define FLASH_ReadData              0x03 
#define FLASH_FastReadData          0x0B 
#define FLASH_FastReadDual          0x3B 
#define FLASH_FastReadQuad          0xEB  
#define FLASH_PageProgram           0x02 
#define FLASH_PageProgramQuad       0x32 
#define FLASH_BlockErase            0xD8 
#define FLASH_SectorErase           0x20 
#define FLASH_ChipErase             0xC7 
#define FLASH_PowerDown             0xB9 
#define FLASH_ReleasePowerDown      0xAB 
#define FLASH_DeviceID              0xAB 
#define FLASH_ManufactDeviceID      0x90 
#define FLASH_JedecDeviceID         0x9F 
#define FLASH_Enable4ByteAddr       0xB7
#define FLASH_Exit4ByteAddr         0xE9
#define FLASH_SetReadParam          0xC0 
#define FLASH_EnterQPIMode          0x38
#define FLASH_ExitQPIMode           0xFF

/* 静态函数 */
static void norflash_wait_busy(void);               /* 等待空闲 */
static void norflash_send_address(uint32_t address);/* 发送地址 */
static void norflash_write_page(uint8_t *pbuf, uint32_t addr, uint16_t datalen);    /* 写入page */
static void norflash_write_nocheck(uint8_t *pbuf, uint32_t addr, uint16_t datalen); /* 写flash,不带擦除 */

/* 普通函数 */
void norflash_init(void);                   /* 初始化25QXX */
uint16_t norflash_read_id(void);            /* 读取FLASH ID */
void norflash_write_enable(void);           /* 写使能 */
uint8_t norflash_read_sr(uint8_t regno);    /* 读取状态寄存器 */
void norflash_write_sr(uint8_t regno,uint8_t sr);   /* 写状态寄存器 */

void norflash_erase_chip(void);             /* 整片擦除 */
void norflash_erase_sector(uint32_t saddr); /* 扇区擦除 */
void norflash_read(uint8_t *pbuf, uint32_t addr, uint16_t datalen);     /* 读取flash */
void norflash_write(uint8_t *pbuf, uint32_t addr, uint16_t datalen);    /* 写入flash */

#endif

源文件

  1. 需要移植 spi读写函数
uint8_t spi2_read_write_byte(uint8_t send_data)
  1. 需要移植spi速度修改函数—也可以不修改–非必要
void spi2_set_speed(uint8_t speed)

spi flash操作库源文件

/**
 ****************************************************************************************************
 * @file        norflash.c
 * @author      正点原子团队(ALIENTEK)
 * @version     V1.0
 * @date        2021-10-26
 * @brief       NOR FLASH(25QXX) 驱动代码
 * @license     Copyright (c) 2020-2032, 广州市星翼电子科技有限公司
 ****************************************************************************************************
 * @attention
 *
 * 实验平台：正点原子 F407电机开发板
 * 在线视频：www.yuanzige.com
 * 技术论坛：http://www.openedv.com/forum.php
 * 公司网址：www.alientek.com
 * 购买地址：zhengdianyuanzi.tmall.com
 *
 * 修改说明
 * V1.0 20211026
 * 第一次发布
 *
 ****************************************************************************************************
 */


#include "norflash.h"
#include "stdio.h"

uint16_t g_norflash_type = NM25Q128;     /* 默认是NM25Q128 */
/*需要移植的代码：spi数据收发函数*/
uint8_t spi2_read_write_byte(uint8_t send_data)
{
    uint8_t recv_data;
    HAL_SPI_TransmitReceive(&HSPI, &send_data, &recv_data, 1, 0xffff);
    return recv_data;
}
/**
* @brief SPI2 速度设置函数
* @note SPI2 时钟选择来自 APB1, 即 PCLK1, 为 42Mhz
* SPI 速度 = PCLK1 / 2^(speed + 1)
* @param speed : SPI2 时钟分频系数
取值为 SPI_BAUDRATEPRESCALER_2~SPI_BAUDRATEPRESCALER_2 256
* @retval 无
*/
void spi2_set_speed(uint8_t speed)
{
    assert_param(IS_SPI_BAUDRATE_PRESCALER(speed));/* 判断有效性 */
    __HAL_SPI_DISABLE(&HSPI); /* 关闭 SPI */
    HSPI.Instance->CR1 &= 0xFFC7; /* 位 3-5 清零，用来设置波特率 */
    HSPI.Instance->CR1 |= speed << 3; /* 设置 SPI 速度 */
    __HAL_SPI_ENABLE(&HSPI); /* 使能 SPI */
}

/**
 * @brief       初始化SPI NOR FLASH
 * @param       无
 * @retval      无
 */
void norflash_init(void)
{

    spi2_set_speed(SPI_SPEED_4);            /* SPI2 切换到高速状态 21Mhz */
		uint8_t temp=0;
    g_norflash_type = norflash_read_id();   /* 读取FLASH ID. */

    if (g_norflash_type == W25Q256)         /* SPI FLASH为W25Q256, 必须使能4字节地址模式 */
    {
        temp = norflash_read_sr(3);         /* 读取状态寄存器3，判断地址模式 */

        if ((temp & 0x01) == 0)             /* 如果不是4字节地址模式,则进入4字节地址模式 */
        {
            norflash_write_enable();        /* 写使能 */
            temp |= 1 << 1;                 /* ADP=1, 上电4位地址模式 */
            norflash_write_sr(3, temp);     /* 写SR3 */

            NORFLASH_CS(0);
            spi2_read_write_byte(FLASH_Enable4ByteAddr);    /* 使能4字节地址指令 */
            NORFLASH_CS(1);
        }
    }

   // printf("ID:%x\r\n", g_norflash_type);
}

/**
 * @brief       等待空闲
 * @param       无
 * @retval      无
 */
static void norflash_wait_busy(void)
{
    while ((norflash_read_sr(1) & 0x01) == 0x01);   /* 等待BUSY位清空 */
}

/**
 * @brief       25QXX写使能
 *   @note      将S1寄存器的WEL置位
 * @param       无
 * @retval      无
 */
void norflash_write_enable(void)
{
    NORFLASH_CS(0);
    spi2_read_write_byte(FLASH_WriteEnable);   /* 发送写使能 */
    NORFLASH_CS(1);
}

/**
 * @brief       25QXX发送地址
 *   @note      根据芯片型号的不同, 发送24ibt / 32bit地址
 * @param       address : 要发送的地址
 * @retval      无
 */
static void norflash_send_address(uint32_t address)
{
    if (g_norflash_type == W25Q256) /* 只有W25Q256支持4字节地址模式 */
    {
        spi2_read_write_byte((uint8_t)((address) >> 24)); /* 发送 bit31 ~ bit24 地址 */
    }

    spi2_read_write_byte((uint8_t)((address) >> 16));   /* 发送 bit23 ~ bit16 地址 */
    spi2_read_write_byte((uint8_t)((address) >> 8));    /* 发送 bit15 ~ bit8  地址 */
    spi2_read_write_byte((uint8_t)address);             /* 发送 bit7  ~ bit0  地址 */
}

/**
 * @brief       读取25QXX的状态寄存器，25QXX一共有3个状态寄存器
 *   @note      状态寄存器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 ADP ADS
 *
 * @param       regno: 状态寄存器号，范:1~3
 * @retval      状态寄存器值
 */
uint8_t norflash_read_sr(uint8_t regno)
{
    uint8_t byte = 0, command = 0;

    switch (regno)
    {
        case 1:
            command = FLASH_ReadStatusReg1;  /* 读状态寄存器1指令 */
            break;

        case 2:
            command = FLASH_ReadStatusReg2;  /* 读状态寄存器2指令 */
            break;

        case 3:
            command = FLASH_ReadStatusReg3;  /* 读状态寄存器3指令 */
            break;

        default:
            command = FLASH_ReadStatusReg1;
            break;
    }

    NORFLASH_CS(0);
    spi2_read_write_byte(command);      /* 发送读寄存器命令 */
    byte = spi2_read_write_byte(0xFF);  /* 读取一个字节 */
    NORFLASH_CS(1);

    return byte;
}

/**
 * @brief       写25QXX状态寄存器
 *   @note      寄存器说明见norflash_read_sr函数说明
 * @param       regno: 状态寄存器号，范:1~3
 * @param       sr   : 要写入状态寄存器的值
 * @retval      无
 */
void norflash_write_sr(uint8_t regno, uint8_t sr)
{
    uint8_t command = 0;

    switch (regno)
    {
        case 1:
            command = FLASH_WriteStatusReg1;  /* 写状态寄存器1指令 */
            break;

        case 2:
            command = FLASH_WriteStatusReg2;  /* 写状态寄存器2指令 */
            break;

        case 3:
            command = FLASH_WriteStatusReg3;  /* 写状态寄存器3指令 */
            break;

        default:
            command = FLASH_WriteStatusReg1;
            break;
    }

    NORFLASH_CS(0);
    spi2_read_write_byte(command);  /* 发送读寄存器命令 */
    spi2_read_write_byte(sr);       /* 写入一个字节 */
    NORFLASH_CS(1);
}

/**
 * @brief       读取芯片ID
 * @param       无
 * @retval      FLASH芯片ID
 *   @note      芯片ID列表见: norflash.h, 芯片列表部分
 */
uint16_t norflash_read_id(void)
{
    uint16_t deviceid;

    NORFLASH_CS(0);
    spi2_read_write_byte(FLASH_ManufactDeviceID);   /* 发送读 ID 命令 */
    spi2_read_write_byte(0);    /* 写入一个字节 */
    spi2_read_write_byte(0);
    spi2_read_write_byte(0);
    deviceid = spi2_read_write_byte(0xFF) << 8;     /* 读取高8位字节 */
    deviceid |= spi2_read_write_byte(0xFF);         /* 读取低8位字节 */
    NORFLASH_CS(1);

    return deviceid;
}

/**
 * @brief       读取SPI FLASH
 *   @note      在指定地址开始读取指定长度的数据
 * @param       pbuf    : 数据存储区
 * @param       addr    : 开始读取的地址(最大32bit)
 * @param       datalen : 要读取的字节数(最大65535)
 * @retval      无
 */
void norflash_read(uint8_t *pbuf, uint32_t addr, uint16_t datalen)
{
    uint16_t i;

    NORFLASH_CS(0);
    spi2_read_write_byte(FLASH_ReadData);       /* 发送读取命令 */
    norflash_send_address(addr);                /* 发送地址 */

    for (i = 0; i < datalen; i++)
    {
        pbuf[i] = spi2_read_write_byte(0xFF);   /* 循环读取 */
    }

    NORFLASH_CS(1);
}

/**
 * @brief       SPI在一页(0~65535)内写入少于256个字节的数据
 *   @note      在指定地址开始写入最大256字节的数据
 * @param       pbuf    : 数据存储区
 * @param       addr    : 开始写入的地址(最大32bit)
 * @param       datalen : 要写入的字节数(最大256),该数不应该超过该页的剩余字节数!!!
 * @retval      无
 */
static void norflash_write_page(uint8_t *pbuf, uint32_t addr, uint16_t datalen)
{
    uint16_t i;

    norflash_write_enable();    /* 写使能 */

    NORFLASH_CS(0);
    spi2_read_write_byte(FLASH_PageProgram);    /* 发送写页命令 */
    norflash_send_address(addr);                /* 发送地址 */

    for (i = 0; i < datalen; i++)
    {
        spi2_read_write_byte(pbuf[i]);          /* 循环读取 */
    }

    NORFLASH_CS(1);
    norflash_wait_busy();       /* 等待写入结束 */
}

/**
 * @brief       无检验写SPI FLASH
 *   @note      必须确保所写的地址范围内的数据全部为0XFF,否则在非0XFF处写入的数据将失败!
 *              具有自动换页功能
 *              在指定地址开始写入指定长度的数据,但是要确保地址不越界!
 *
 * @param       pbuf    : 数据存储区
 * @param       addr    : 开始写入的地址(最大32bit)
 * @param       datalen : 要写入的字节数(最大65535)
 * @retval      无
 */
static void norflash_write_nocheck(uint8_t *pbuf, uint32_t addr, uint16_t datalen)
{
    uint16_t pageremain;
    pageremain = 256 - addr % 256;  /* 单页剩余的字节数 */

    if (datalen <= pageremain)      /* 不大于256个字节 */
    {
        pageremain = datalen;
    }

    while (1)
    {
        /* 当写入字节比页内剩余地址还少的时候, 一次性写完
         * 当写入直接比页内剩余地址还多的时候, 先写完整个页内剩余地址, 然后根据剩余长度进行不同处理
         */
        norflash_write_page(pbuf, addr, pageremain);

        if (datalen == pageremain)      /* 写入结束了 */
        {
            break;
        }
        else     /* datalen > pageremain */
        {
            pbuf += pageremain;         /* pbuf指针地址偏移,前面已经写了pageremain字节 */
            addr += pageremain;         /* 写地址偏移,前面已经写了pageremain字节 */
            datalen -= pageremain;      /* 写入总长度减去已经写入了的字节数 */

            if (datalen > 256)          /* 剩余数据还大于一页,可以一次写一页 */
            {
                pageremain = 256;       /* 一次可以写入256个字节 */
            }
            else     /* 剩余数据小于一页,可以一次写完 */
            {
                pageremain = datalen;   /* 不够256个字节了 */
            }
        }
    }
}

/**
 * @brief       写SPI FLASH
 *   @note      在指定地址开始写入指定长度的数据, 该函数带擦除操作!
 *              SPI FLASH 一般是: 256个字节为一个Page, 4Kbytes为一个Sector, 16个扇区为1个Block
 *              擦除的最小单位为Sector.
 *
 * @param       pbuf    : 数据存储区
 * @param       addr    : 开始写入的地址(最大32bit)
 * @param       datalen : 要写入的字节数(最大65535)
 * @retval      无
 */
uint8_t g_norflash_buf[4096];   /* 扇区缓存 */

void norflash_write(uint8_t *pbuf, uint32_t addr, uint16_t datalen)
{
    uint32_t secpos;
    uint16_t secoff;
    uint16_t secremain;
    uint16_t i;
    uint8_t *norflash_buf;

    norflash_buf = g_norflash_buf;
    secpos = addr / 4096;       /* 扇区地址 */
    secoff = addr % 4096;       /* 在扇区内的偏移 */
    secremain = 4096 - secoff;  /* 扇区剩余空间大小 */

    //printf("ad:%X,nb:%X\r\n", addr, datalen); /* 测试用 */
    if (datalen <= secremain)
    {
        secremain = datalen;    /* 不大于4096个字节 */
    }

    while (1)
    {
        norflash_read(norflash_buf, secpos * 4096, 4096);   /* 读出整个扇区的内容 */

        for (i = 0; i < secremain; i++)   /* 校验数据 */
        {
            if (norflash_buf[secoff + i] != 0XFF)
            {
                break;      /* 需要擦除, 直接退出for循环 */
            }
        }

        if (i < secremain)   /* 需要擦除 */
        {
            norflash_erase_sector(secpos);  /* 擦除这个扇区 */

            for (i = 0; i < secremain; i++)   /* 复制 */
            {
                norflash_buf[i + secoff] = pbuf[i];
            }

            norflash_write_nocheck(norflash_buf, secpos * 4096, 4096);  /* 写入整个扇区 */
        }
        else        /* 写已经擦除了的,直接写入扇区剩余区间. */
        {
            norflash_write_nocheck(pbuf, addr, secremain);  /* 直接写扇区 */
        }

        if (datalen == secremain)
        {
            break;  /* 写入结束了 */
        }
        else        /* 写入未结束 */
        {
            secpos++;               /* 扇区地址增1 */
            secoff = 0;             /* 偏移位置为0 */

            pbuf += secremain;      /* 指针偏移 */
            addr += secremain;      /* 写地址偏移 */
            datalen -= secremain;   /* 字节数递减 */

            if (datalen > 4096)
            {
                secremain = 4096;   /* 下一个扇区还是写不完 */
            }
            else
            {
                secremain = datalen;/* 下一个扇区可以写完了 */
            }
        }
    }
}

/**
 * @brief       擦除整个芯片
 *   @note      等待时间超长...
 * @param       无
 * @retval      无
 */
void norflash_erase_chip(void)
{
    norflash_write_enable();    /* 写使能 */
    norflash_wait_busy();       /* 等待空闲 */
    NORFLASH_CS(0);
    spi2_read_write_byte(FLASH_ChipErase);  /* 发送读寄存器命令 */
    NORFLASH_CS(1);
    norflash_wait_busy();       /* 等待芯片擦除结束 */
}

/**
 * @brief       擦除一个扇区
 *   @note      注意,这里是扇区地址,不是字节地址!!
 *              擦除一个扇区的最少时间:150ms
 *
 * @param       saddr : 扇区地址 根据实际容量设置
 * @retval      无
 */
void norflash_erase_sector(uint32_t saddr)
{
    //printf("fe:%x\r\n", saddr);   /* 监视falsh擦除情况,测试用 */
    saddr *= 4096;
    norflash_write_enable();        /* 写使能 */
    norflash_wait_busy();           /* 等待空闲 */

    NORFLASH_CS(0);
    spi2_read_write_byte(FLASH_SectorErase);    /* 发送写页命令 */
    norflash_send_address(saddr);   /* 发送地址 */
    NORFLASH_CS(1);
    norflash_wait_busy();           /* 等待扇区擦除完成 */
}

测试使用函数

重定向printf函数

/* 重定向printf函数 */
int fputc(int ch, FILE *f)
{
    HAL_UART_Transmit(&huart1, (uint8_t*)&ch, 1, 0xffff);
    return ch;
}

spi flash 测试函数


void spi_flash_test()
{
    int x = 0;
    norflash_init();
    uint8_t buf[256];

    for(x = 0; x < 256; x++)buf[x] = x;

    norflash_write(buf, 0, 256);
    memset(buf, 0, 256);
    norflash_read(buf, 0, 256);

    for(x = 0; x < 256; x++)
    {
        if(buf[x] != x)break;
    }

    if(x != 256)
    {
        printf("spi flash test fail\r\n");
    }
    else
    {
        printf("spi flash test ok\r\n");
    }
}

请添加图片描述

Car12
关注
专栏目录
W25Q256四字节模式读写程序
12-01
亲测可用的4字节nor flash读写程序， 经过优化可以直接使用，针对128M以上的FLASH可以直接使用，兼容128以下的芯片 已经应用到产品上，欢迎品鉴
stm32f103模拟SPI读写W25Q16亲测可用
01-17
在本实例中，我们将探讨如何使用STM32F103通过软件模拟SPI（Serial Peripheral Interface）协议来读写W25Q16闪存芯片。 W25Q16是一款常见的SPI接口闪存芯片，容量为16MB，适用于存储大量的数据，如程序代码、配置...
W25Q256被写保护如何修改
03-02 3238
W25Q256被写保护如何修改
stm32f469 Qspi+Dma驱动w25q256
xuanlving的博客
09-24 208
最近使用到stm32f469驱动w25q256，但硬件上只接了Qspi的clk、cs、io1、io2引脚，io3和io4接到普通io脚上，在此记录一下。
STM32 W25Q256驱动源码（使用SPI接口）
m0_71226271的博客
07-30 955
基于STM32的W25Q256驱动源码，使用SPI接口，软件CS。附上SPI配置
stm32+w25q256
weixin_69028524的博客
07-15 208
【代码】stm32+w25q256。
STM32CubeMX+FATFS+FREERTOS实现W25Q256虚拟U盘
chen18221987993的博客
02-09 6664
STM32CubeMX+FATFS+FREERTOS实现W25Q258虚拟U盘
STM32H743 驱动 W25Q256
烟波随笔
01-27 3314
STM32H743 驱动 W25Q256
STM32 W25Q64驱动程序 W25Q128驱动程序 W25Q32驱动程序
07-21
STM32系列微控制器在嵌入式领域广泛应用，而存储扩展是常见的需求，这就涉及到SPI接口的闪存芯片，如W25Q64、W25Q128和W25Q32。这些芯片是Winbond公司生产的串行闪存，具有高速、低功耗的特点，常用于存储固件、配置...
STM32cubeMX配置F103的硬件SPI读写W25QXX的FLASH
02-29
在这个特定的场景中，我们要探讨如何使用STM32CubeMX来配置STM32F103微控制器的硬件SPI接口，以便与W25Q128串行闪存进行通信。 **STM32F103微控制器**： STM32F103是STM32系列中的一个成员，属于高性能的ARM Cortex...
STM32H750VBT6-SPI-FLASH-W25QXX.rar
11-04
STM32 HAL库SPI接口访问W25Q系列FLASH的范例代码，采用STM32CUBEIDE开发平台，也适用于其它型号SPI接口FLASH的访问。具体介绍见CSDN博文《STM32存储左右互搏 SPI总线读写FLASH W25QXX》： ...
F103_SPI读写W25Q256.rar
06-03
测试时可用的，使用SPI,速度还不错，开了DMA，有需要的可以看看，挺多地方可以继续优化，同时可以简单修改，其他W25Qxx系列的芯片也是可用的.
STM32F429外部Flash w25q256驱动
01-08
spi5、w25q256、CubeMX
正点原子的W25Q256驱动
01-09
正点原子的W25Q256芯片的驱动程序。代码写了详细的注释，程序很容易看懂
STM32F767_W25Q256_good.zip
12-06
这是STM32F767用于W25Q256的源程序，下载解压后可以直接使用，非常方面，亲测可用，有问题欢迎大家交流！！！
【STM32】标准库-SPI-DMA收发数据-读写Flash(W25Q256JV)-仿printf和scanf输入输出
06-29
采用STM32F429IGT6单片机，KeilMDK5.32版本 使用SysTick系统滴答定时器进行延时 LED_R、LED_G、LED_B分别为PH10,PH11,PH12 Key1为PA0，Key2为PC13 KEIL5下载配置有FLASH与SRAM 用SPI5与Flash芯片通信(W25Q256JV)，使用了DMA进行收发数据，SPI是同步通信，同时收发数据(其实仅与发TX同步，作为主器件，Tx产生波特率时钟SCK信号) 利用可变参数宏实现printf与scanf 定义了Flash输入输出结构体，利用了共用体 发送与接收缓冲区大小均为一个扇区大小4096B NSS(CS)采用软件控制，因为Flash芯片每发送玩一个指令都要把CS拉高。 注意点：因为TX产生SCK时钟，故需要TX的DMA优先级要比RX的优先级低，本次TX和RX的DMA使用的是一个DMA(DMA2)，因为当收发一个数据后，TX和RX的DMA出现仲裁，TX需要发下一个数据，RX需要接收当前数据，为了防止一直发数据，故RX的DMA优先级需要比TX的高开启RX的DMA传输完成中断，在该中断中将CS拉高，结束通讯。
STM32模拟、硬件SPI驱动W25X系列(W25X40_W25X16)
07-10
在本主题中，我们将深入探讨如何使用STM32的模拟SPI（Software SPI）和硬件SPI（Hardware SPI）来驱动W25X系列的闪存芯片，如W25X40和W25X16。 1. **STM32模拟SPI**： 模拟SPI是通过GPIO端口模拟SPI协议中的SCK...
正点原子W25Q256驱动程序：高效、易用的嵌入式存储解决方案
最新发布
gitblog_09778的博客
10-17 752
正点原子W25Q256驱动程序：高效、易用的嵌入式存储解决方案 【下载地址】正点原子W25Q256驱动程序 本仓库提供正点原子的W25Q256芯片的驱动程序。该驱动程序代码中包含了详细的注释，使得程序易于理解和使用 项目地址: h...
CubeMX配置W25Q256FLASH SPI通信（实现任意位置读写）
m0_62743804的博客
08-13 3065
需要系统性的看一下W25Q256芯片手册。
使用STM32读写W25Q16JV
09-03
STM32与W25Q16JV的通信通常通过SPI（串行外设接口）进行。W25Q16JV是一款16M位（即2MB）的串行Flash存储器，支持标准的SPI、双SPI和四SPI操作模式。在STM32中读写W25Q16JV，你需要遵循以下步骤： 1. 初始化SPI接口：首先，你需要配置STM32的SPI接口，包括设置SPI的通信模式、速率、数据格式等，以便与W25Q16JV通信。 2. 上电自检（Power-On Reset）：在初始化SPI之后，可能需要向W25Q16JV发送一个复位命令，确保Flash处于已知状态。 3. 发送指令：W25Q16JV支持多种指令用于控制其操作，例如读取ID、读取数据、页编程、擦除等。你需要根据需要发送相应的指令，并附带必要的参数。 4. 读写数据：对于读操作，发送读取指令后，STM32可以从SPI接口读取数据；对于写操作，通常需要先发送写使能命令，然后发送页编程或块擦除等写操作指令，最后写入数据。 5. 等待操作完成：Flash写入操作需要一定时间，因此在写入数据后，可能需要检查W25Q16JV的忙状态寄存器，以确保操作已完成，再进行下一次操作。 6. 关闭SPI接口：在完成读写操作后，可以关闭SPI接口，以节省电能和避免对其他设备的干扰。
评论 3
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包

打赏作者

Car12

你的鼓励将是我创作的最大动力

¥1 ¥2 ¥4 ¥6 ¥10 ¥20
扫码支付：¥1
获取中
扫码支付

您的余额不足，请更换扫码支付或充值

打赏作者

实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

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

余额充值