libftdi1学习笔记 5 - SPI Nor Flash

最新推荐文章于 2024-08-21 23:32:17 发布
最新推荐文章于 2024-08-21 23:32:17 发布
阅读量607 收藏 24
点赞数 25
文章标签： 学习 笔记 libftdi1
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/pq113_6/article/details/137083052
版权

目录

1.  初始化

2. CS控制例子

3. 读ID

3.1 制造商

3.2 容量大小

3.3 设置IO类型

3.3.1 setQSPIWinbond

3.3.2 setQSPIMxic

3.3.3 setQSPIMicrochip

3.3.4 setQSPIMicron

4. 写保护

5. 等待空闲

6. 擦除扇区

7. 页编程

8. 页读

9. 写

10. 读

11. 验证

基于MPSSE SPI实现Nor Flash的读写。也定义两组flash。

typedef enum
{
    SFLASH_PORT_0 = 0,
    SFLASH_PORT_1,
    SFLASH_PORT_MAX,
}sflash_port_e;

定义一个结构体记录flash的属性

typedef struct 
{
    sflash_io_e ioType;
    uint8_t spiPort;
    void (*pCSEnable)(uint8_t port, bool enable);

    sflash_manufactor_e manufactor;
    sflash_size size;
    sflash_addr_size_e addrSize;
}sflash_s;

ioType：表示flash的IO类型，一般支持3种接口方式：

typedef enum
{
    SFLASH_SPI = 0,
    SFLASH_DSPI,
    SFLASH_QSPI,
}sflash_io_e;

spiPort：表示该flash使用哪组SPI

pCSEnable：对应CS脚控制的接口函数

manufactor：该flash的生产商

typedef enum
{
    SFLASH_Winbond = 0,
    SFLASH_Cypress,
    SFLASH_ESMT,
    SFLASH_GigaDevice,
    SFLASH_MXIC,
    SFLASH_Micron,
    SFLASH_ISIS,
    SFLASH_Microchip,
    SFLASH_ZBit,
    SFLASH_FuDan,
    SFLASH_BOYA,
    SFLASH_Unknown,
}sflash_manufactor_e;

size：该flash的大小

typedef enum
{
    SFLASH_SIZE_256KB = 0,
    SFLASH_SIZE_512KB,
    SFLASH_SIZE_1MB,
    SFLASH_SIZE_2MB,
    SFLASH_SIZE_4MB,
    SFLASH_SIZE_8MB,
    SFLASH_SIZE_16MB,
    SFLASH_SIZE_32MB,
}sflash_size;

addrSize：该flash的地址宽度

typedef enum
{
    SFLASH_ADDR_24BIT = 3,
    SFLASH_ADDR_32BIT,
}sflash_addr_size_e;

1.  初始化

void sflashInit(uint8_t port, sflash_s init)
{
    if(port >= SFLASH_PORT_MAX)
        return;
    sflash[port] = init;
}

2. CS控制例子

初始化spi要根据实际情况配置CS的控制函数，例如：

#define SFLASH_CS_PIN       3
void sflash0CS(uint8_t port, bool enable)
{
    spiCPOL(port);
    mpsseGpioWrite(SFLASH_CS_PIN, !enable);
}

3. 读ID

通过命令0x9F读取flash的Jedec ID，其函数原型为：

uint32_t sflashReadJedecID(uint8_t port)

返回值即是id。

    uint8_t cmd[4] = {CMD_READ_ID, 0xff, 0xff, 0xff};
    uint32_t id;

    sflash[port].pCSEnable(port, true);
    spiWriteBytes(sflash[port].spiPort, cmd, 1);
    spiReadBytes(sflash[port].spiPort, cmd + 1, 3);
    sflash[port].pCSEnable(port, false);

    id = ((uint32_t)cmd[1] << 16) | (uint32_t)(cmd[2] << 8) | (uint32_t)(cmd[3]);

由于flash的QSPI方式和品牌商有关，这里根据ID做判断（注意，这套规则并不是所有厂商都符合）

3.1 制造商

由ID的16~23位确定品牌商

    switch (id & 0xff0000)
    {
        case 0xEF0000:
            sflash[port].manufactor = SFLASH_Winbond;
            printf("sflash Winbond\n");
            break;
        case 0x010000:
            sflash[port].manufactor = SFLASH_Cypress;
            printf("sflash Cypress\n");
            break;
        case 0x8C0000:
            sflash[port].manufactor = SFLASH_ESMT;
            printf("sflash ESMT\n");
            break;
        case 0xC80000:
            sflash[port].manufactor = SFLASH_GigaDevice;
            printf("sflash GigaDevice\n");
            break;
        case 0xC20000:
            sflash[port].manufactor = SFLASH_MXIC;
            printf("sflash MXIC\n");
            break;
        case 0x200000:
            sflash[port].manufactor = SFLASH_Micron;
            printf("sflash Micron\n");
            break;
        case 0x5E0000:
            sflash[port].manufactor = SFLASH_ZBit;
            printf("sflash ZBit\n");
            break;
        case 0x9D0000:
            sflash[port].manufactor = SFLASH_ISIS;
            printf("sflash ISIS\n");
            break;
        case 0xA10000:
            sflash[port].manufactor = SFLASH_FuDan;
            printf("sflash FuDan\n");
            break;
        case 0xBF0000:
            sflash[port].manufactor = SFLASH_Microchip;
            printf("sflash Microchip\n");
            break;
        case 0x680000:
            sflash[port].manufactor = SFLASH_BOYA;
            printf("sflash BOYA\n");
            break;
        default:
            sflash[port].manufactor = SFLASH_Unknown;
            printf("sflash Unknown\n");
            break;
    }

3.2 容量大小

根据ID的位0~7确定容量大小

    switch(id & 0xff)
    {
        case 0x12:
            sflash[port].size = SFLASH_SIZE_256KB;
            sflash[port].addrSize = SFLASH_ADDR_24BIT;
            printf("sflash size 256KB, 24bits address\n");
            break;
        case 0x13:
            sflash[port].size = SFLASH_SIZE_512KB;
            sflash[port].addrSize = SFLASH_ADDR_24BIT;
            printf("sflash size 512KB, 24bits address\n");
            break;
        case 0x14:
            sflash[port].size = SFLASH_SIZE_1MB;
            sflash[port].addrSize = SFLASH_ADDR_24BIT;
            printf("sflash size 1MB, 24bits address\n");
            break;
        case 0x15:
            sflash[port].size = SFLASH_SIZE_2MB;
            sflash[port].addrSize = SFLASH_ADDR_24BIT;
            printf("sflash size 2MB, 24bits address\n");
            break;
        case 0x16:
            sflash[port].size = SFLASH_SIZE_4MB;
            sflash[port].addrSize = SFLASH_ADDR_24BIT;
            printf("sflash size 4MB, 24bits address\n");
            break;
        case 0x17:
            sflash[port].size = SFLASH_SIZE_8MB;
            sflash[port].addrSize = SFLASH_ADDR_24BIT;
            printf("sflash size 8MB, 24bits address\n");
            break;
        case 0x18:
            sflash[port].size = SFLASH_SIZE_16MB;
            sflash[port].addrSize = SFLASH_ADDR_24BIT;
            printf("sflash size 16MB, 24bits address\n");
            break;
        case 0x19:
            sflash[port].size = SFLASH_SIZE_32MB;
            sflash[port].addrSize = SFLASH_ADDR_32BIT;
            printf("sflash size 32MB, 32bits address\n");
            break;
    }

3.3 设置IO类型

    if (sflash[port].ioType == SFLASH_QSPI)
    {
        sflashSetQSPI(true);
    }
    else
    {
        sflashSetQSPI(false);
    }

根据不同制造商设置flash的IO类型，这里只实现SPI和QSPI的方式，部分制造商的设定方式是一样的。

bool sflashSetQSPI(uint8_t port, bool enable)
{
    bool ret = false;
    switch(sflash[port].manufactor)
    {
        case SFLASH_Winbond:
        case SFLASH_GigaDevice:
        case SFLASH_Cypress:
        case SFLASH_ZBit:
        case SFLASH_BOYA:
        case SFLASH_FuDan:
            ret = setQSPIWinbond(port, enable);
            break;
        case SFLASH_MXIC:
        case SFLASH_ESMT:
        case SFLASH_ISIS:
            ret = setQSPIMxic(port, enable);
            break;
        case SFLASH_Microchip:
            ret = setQSPIMicrochip(port, enable);
            break;
        case SFLASH_Micron:
            ret = setQSPIMicron(port, enable);
            break;
        default:
            return false;
    }
    return ret;
}

3.3.1 setQSPIWinbond

第一种方式以Winbond为代表，QSPI的使能位在Status2寄存器中。

通过命令0x35读入该寄存器值，通过0x31写即可。

bool setQSPIWinbond(uint8_t port, bool enable)
{
    uint8_t cmd[2] = {0x35, 0xff};
    sflash[port].pCSEnable(port, true);
    if(spiWriteBytes(sflash[port].spiPort, cmd, 1) < 0)
        return false;
    if(spiReadBytes(sflash[port].spiPort, cmd + 1, 1) < 0)
        return false;
    sflash[port].pCSEnable(port, false);

    if(enable == true)
    {
        if ((cmd[1] & 0x02) == 0x02) //QE == 1
        {
            return true;
        }
        cmd[1] |= 0x02;
    }
    else
    {
        if ((cmd[1] & 0x02) == 0x00) //QE == 0
        {
            return true;
        }
        cmd[1] &= (uint8_t)0xFD;
    }

    cmd[0] = 0x31;

    sflash[port].pCSEnable(port, true);
    if(spiWriteBytes(sflash[port].spiPort, cmd, 2) < 0)
        return false;
    sflash[port].pCSEnable(port, false);
    return true;
}

3.3.2 setQSPIMxic

第二种方式以Mxic为代表，QSPI的使能位在Status寄存器的位6

通过命令0x05读入该寄存器，0x01写。

bool setQSPIMxic(uint8_t port, bool enable)
{
    uint8_t cmd[2] = {0x05, 0xff};
    sflash[port].pCSEnable(port, true);
    if(spiWriteBytes(sflash[port].spiPort, cmd, 1) < 0)
        return false;
    if(spiReadBytes(sflash[port].spiPort, cmd + 1, 1) < 0)
        return false;
    sflash[port].pCSEnable(port, false);

    if(enable == true)
    {
        if ((cmd[1] & 0x40) == 0x40) //QE == 1
        {
            return true;
        }
        cmd[1] |= 0x40;
    }
    else
    {
        if ((cmd[1] & 0x40) == 0x00) //QE == 0
        {
            return true;
        }
        cmd[1] &= (uint8_t)0xBF;
    }

    cmd[0] = 0x01;

    sflash[port].pCSEnable(port, true);
    if(spiWriteBytes(sflash[port].spiPort, cmd, 2) < 0)
        return false;
    sflash[port].pCSEnable(port, false);
    return true;
}

3.3.3 setQSPIMicrochip

Microchip的QSPI是 通过命令的方式使能（0x38）和禁止(0xFF)的。以SST26VF040A为例：

bool setQSPIMicrochip(uint8_t port, bool enable)
{
    uint8_t cmd[1] = {0x38};
    if(enable == true)
    {
        sflash[port].pCSEnable(port, true);
        if(spiWriteBytes(sflash[port].spiPort, cmd, 1) < 0)
            return false;
        sflash[port].pCSEnable(port, false);
    }
    else
    {
        cmd[0] = 0xff;
        sflash[port].pCSEnable(port, true);
        if(spiWriteBytes(sflash[port].spiPort, cmd, 1) < 0)
            return false;
        sflash[port].pCSEnable(port, false);
    }
    return true;
}

3.3.4 setQSPIMicron

Micron（以MT25QL256为例）的QSPI通过读写易失性配置寄存器的位7配置。

通过命令0x85读入该寄存器，0x81写。

bool setQSPIMicron(uint8_t port, bool enable)
{
    uint8_t cmd[2] = {0x85, 0xff};
    sflash[port].pCSEnable(port, true);
    if(spiWriteBytes(sflash[port].spiPort, cmd, 1) < 0)
        return false;
    if(spiReadBytes(sflash[port].spiPort, cmd + 1, 1) < 0)
        return false;
    sflash[port].pCSEnable(port, false);

    if(enable == true)
    {
        if ((cmd[1] & 0x80) == 0x80) //QE == 1
        {
            return true;
        }
        cmd[1] |= 0x80;
    }
    else
    {
        if ((cmd[1] & 0x80) == 0x00) //QE == 0
        {
            return true;
        }
        cmd[1] &= (uint8_t)0x7F;
    }

    cmd[0] = 0x81;

    sflash[port].pCSEnable(port, true);
    if(spiWriteBytes(sflash[port].spiPort, cmd, 2) < 0)
        return false;
    sflash[port].pCSEnable(port, false);
    return true;
}

4. 写保护

使能写的命令为：

#define CMD_WRITE_ENABLE        0x06

对应的函数：

void sflashWriteEnable(uint8_t port)
{
    uint8_t cmd[1] = {CMD_WRITE_ENABLE};
    sflash[port].pCSEnable(port, true);
    spiWriteBytes(sflash[port].spiPort, cmd, 1);
    sflash[port].pCSEnable(port, false);
}

禁止写的命令为：

#define CMD_WRITE_DISABLE       0x04

对应的函数：

void sflashWriteDisable(uint8_t port)
{
    uint8_t cmd[1] = {CMD_WRITE_DISABLE};
    sflash[port].pCSEnable(port, true);
    spiWriteBytes(sflash[port].spiPort, cmd, 1);
    sflash[port].pCSEnable(port, false);
}

5. 等待空闲

通过读状态寄存器等待设备空闲。

void sflashWaitFree(uint8_t port)
{
    while(true)
    {
        uint8_t cmd[2] = {CMD_READ_STATUS, 0xFF};
        sflash[port].pCSEnable(port, true);
        spiWriteBytes(sflash[port].spiPort, cmd, 1);
        spiReadBytes(sflash[port].spiPort, cmd + 1, 1);
        sflash[port].pCSEnable(port, false);

        if((cmd[1] & 0x01) == 0)
            break;
        usleep(1000);
    }
}

6. 擦除扇区

一般扇区大小为4096个字节，擦除扇区的命令

#define CMD_SECTOR_ERASE        0x20

命令后面接需要擦除扇区的起始地址。

在擦除命令前必须先设置写使能，擦除根据芯片不同可能需要几十ms才能完成（例如W25Q128FVxxIQ需要45ms，SST26VF032B需要25ms），等待一段时间后判断擦除是否完成，最后恢复写保护。

void sflashEraseSector(uint8_t port, uint32_t addr)
{
    uint8_t cmd[5] = {CMD_SECTOR_ERASE, 0, 0, 0, 0};
    uint8_t offset = 1;
    if(sflash[port].addrSize == SFLASH_ADDR_32BIT)
        cmd[offset++] = (uint8_t)(addr >> 24);
    cmd[offset++] = (uint8_t)(addr >> 16);
    cmd[offset++] = (uint8_t)(addr >> 8);
    cmd[offset++] = (uint8_t)(addr >> 0);
    sflashWriteEnable(port);
    sflash[port].pCSEnable(port, true);
    spiWriteBytes(sflash[port].spiPort, cmd, offset);
    sflash[port].pCSEnable(port, false);
    usleep(1000 * 20);
    sflashWaitFree(port);
    sflashWriteDisable(port);
}

7. 页编程

void sflashPageProgram(uint8_t port, uint32_t addr, uint8_t *buf, uint16_t len)

norflash的写不能按字节写，最小单位为页，一般页的大小为256字节。但是实际上页内是可以按照字节写的。比如可以在地址16的位置写10个字节数据。

地址的计算方式和擦除一样

    uint8_t cmd[5] = {CMD_PAGE_PROGRAM, 0, 0, 0, 0};
    uint8_t offset = 1;
    if(sflash[port].addrSize == SFLASH_ADDR_32BIT)
        cmd[offset++] = (uint8_t)(addr >> 24);
    cmd[offset++] = (uint8_t)(addr >> 16);
    cmd[offset++] = (uint8_t)(addr >> 8);
    cmd[offset++] = (uint8_t)(addr >> 0);

然后不同的接口有不同的命令，SPI的命令是0x02，QSPI的命令是0x32（这里有个特例，MXIC的芯片QPI的命令是0x38）。

#define CMD_PAGE_PROGRAM        0x02
#define CMD_PAGE_PROGRAM_QIO    0x32

注意，QPI的接口模式下，命令字是SPI方式发送的。 

    sflashWriteEnable(port);
    sflash[port].pCSEnable(port, true);
    if(sflash[port].ioType == SFLASH_QSPI)
    {
        cmd[0] = CMD_PAGE_PROGRAM_QIO;
        if(sflash[port].manufactor == SFLASH_MXIC)
        {
            cmd[0] = 0x38;
        }
        
        spiWriteBytes(sflash[port].spiPort, cmd, 1);
        qspiWriteBytes(sflash[port].spiPort, cmd + 1, offset);
        qspiWriteBytes(sflash[port].spiPort, buf, len);
    }
    else
    {
        cmd[0] = CMD_PAGE_PROGRAM;
        spiWriteBytes(sflash[port].spiPort, cmd, offset);
        spiWriteBytes(sflash[port].spiPort, buf, len);
    }
    sflash[port].pCSEnable(port, false);

最后等待编程结束

    sflashWaitFree(port);
    sflashWriteDisable(port);

8. 页读

对于flash来说，没有页读的概念，这里定义页读的方式是因为FTDI设备每笔最大通信是64K字节，每次读最好设置为256B，这是因为FTDI设备的最大传输字节数为64KB，由于GPIO模拟的SPI协议特别费字节，大了会超过64KB的大小，另外，太大了有时候会出现通讯错误

对于SPI接口，使用Fast Read命令0x0B，对于QSPI，使用0xEB命令。

#define CMD_FASTREAD            0x0B
#define CMD_FASTREAD_QIO        0xEB

地址的计算等同其他

    uint8_t cmd[5] = {CMD_FASTREAD, 0, 0, 0, 0};
    uint8_t offset = 1;
    if(sflash[port].addrSize == SFLASH_ADDR_32BIT)
        cmd[offset++] = (uint8_t)(addr >> 24);
    cmd[offset++] = (uint8_t)(addr >> 16);
    cmd[offset++] = (uint8_t)(addr >> 8);
    cmd[offset++] = (uint8_t)(addr >> 0);

写完地址后需要空读1-2个字节（QSPI是空读2个字节，SPI读空1个字节）

    sflash[port].pCSEnable(port, true);
    if(sflash[port].ioType == SFLASH_QSPI)
    {
        uint8_t dummy[2];
        cmd[0] = CMD_FASTREAD_QIO;
        spiWriteBytes(sflash[port].spiPort, cmd, 1);
        qspiWriteBytes(sflash[port].spiPort, cmd + 1, offset);
        qspiReadBytes(sflash[port].spiPort, dummy, 2);
        qspiReadBytes(sflash[port].spiPort, buf, len);
    }
    else
    {
        uint8_t dummy[1];
        cmd[0] = CMD_FASTREAD;
        spiWriteBytes(sflash[port].spiPort, cmd, offset);
        spiReadBytes(sflash[port].spiPort, dummy, 1);
        spiReadBytes(sflash[port].spiPort, buf, len);
    }
    sflash[port].pCSEnable(port, false);

9. 写

void sflashWrite(uint8_t port, uint32_t addr, uint8_t *buf, uint32_t len)

在写之前要确保flash已经擦除。

首先判断一下地址是不是页对齐，不是就先把不齐的部分编程。

    uint32_t offset = 0;
    uint16_t count;
    if(port >= SFLASH_PORT_MAX)
    if(len == 0)
        return;

    if((addr % sflashPageSize) > 0)
    {
        count = (len > (sflashPageSize - (addr % sflashPageSize))) ?
                    (uint16_t)(sflashPageSize - (addr % sflashPageSize)) : (uint16_t)len;
        sflashPageProgram(port, addr, buf, count);
        offset += count;
        len -= count;
        addr += count;
    }

剩余的数据写完

    while (len > 0)
    {
        count = (len > sflashPageSize) ? (uint16_t)sflashPageSize : (uint16_t)len;

        sflashPageProgram(port, addr, buf + offset, count);
        offset += count;
        len -= count;
        addr += count;
    }

10. 读

void sflashRead(uint8_t port, uint32_t addr, uint8_t *buf, uint32_t len)

读可以任意的地址读，没有特别的处理。

    uint32_t offset = 0;
    uint32_t readPageSize = 256;
    while(len > 0)
    {
        uint16_t count;
        count = (len > readPageSize) ? (uint16_t)readPageSize : (uint16_t)len;
        sflashPageRead(port, addr, buf + offset, count);
        offset += count;
        len -= count;
        addr += count;
    }

11. 验证

配置和SPI验证一样。这里只验证SPI、Mode0的方式。

擦除扇区->写随机数据->读入数据->比较读写的数据是否相等。

    #define EX_SFLASH_SIZE          2048
    uint8_t wrBuf[EX_SFLASH_SIZE];
    uint8_t rdBuf[EX_SFLASH_SIZE];
    int i;
    uint8_t port = 0;

然后产生随机数据

    srand(time(NULL));
    for(i = 0; i < EX_SFLASH_SIZE; i++)
    {
        wrBuf[i] = (uint8_t)rand();
        rdBuf[i] = 0;
    }

擦除一个扇区

 sflashEraseSector(port, 0 * 4096);

将随机数据写入flash

    sflashWrite(port, 0, wrBuf, EX_SFLASH_SIZE);

再从相同地址读回

    sflashRead(port, 0, rdBuf, EX_SFLASH_SIZE);

最后比较

    for(i = 0; i < EX_SFLASH_SIZE; i++)
    {
        if(wrBuf[i] != rdBuf[i])
        {
            printf("sflash test fail %d: %x!=%x\n", i, wrBuf[i], rdBuf[i]);
            break;
        }
    }
    printf("sflash test finish\n");

pq113_6
关注
  • 25
    点赞
  • 踩
  • 24
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
Cadence学习笔记1-原理图.pdf
11-16
Cadence学习笔记1-原理图.pdf
TMS320F28335学习笔记-SPI模块
08-04
在深入探讨TMS320F28335的SPI模块之前，我们先了解一些基本概念。SPI（Serial Peripheral Interface）是一种常见的同步串行通信协议，广泛应用于微控制器和外围设备之间，提供高速数据传输。它具有主设备（Master）...
QSPI Flash的原理与QSPI时序的Verilog实现
FPGA_张文奎的博客
03-09 3650
本节主要是讨论QSPI(Quad SPI，四线SPI总线)的相关内容
串行Flash控制器设计介绍（QSPI）
热门推荐
yangguoyu8023的博客
11-18 1万+
目录 1. 概述 2. 整体架构 3. AHB接口单元 3.1. 地址重映射功能 3.2. 写保护功能 3.3. 连续/非连续传输识别 3.4. Burst长度识别 3.5. AHB地址解码功能 4. DAC 4.1. AHB读操作 4.2. AHB写操作 4.3. 片内程序执行（XIP） 4.3.1. 从上电复位（POR）进入XIP模式 4.3.2. 其他方式进入XIP模式 4.3.3. 退出XIP模式 4.4. 上电启动引导（Boot） 5. INDAC 5.1. 间
libftdi1学习笔记 4 - MPSSE SPI
pq的博客
04-16 1514
与官方的方式不同，这里采用纯GPIO模式的方式实现SPI，这样可以定义任意GPIO为SPI，也可以实现QSPI。sck/mosi_io0/miso_io1/io2/io3分别对应SPI/QSPI的io，同样，所有io都必须属于同一组。注意，CS脚单独控制，用GPIO的方式控制。mode则表示spi的模式由于多个SPI从设备可以共用sck和数据口，只使用不同的cs即可。所以这里只定义2个spi设备。
RT-Thread Studio配置QSPI和SFUD
moumde的博客
08-14 3458
RT-Thread Studio配置QSPI和SFUD1 前言2 概述2.1 SPI和QSPI2.2 SFUD2.3 W25Q256FV3 移植过程3.1 开启相关组件3.2 QSPI配置3.3 SFUD配置 1 前言 本次采用的是正点原子STM32F767系列的板子，区别于F1及F4上的SPI，F7增加了QSPI。其上板载的W25Q256FV型号的Flash也是通过QSPI实现通信读写的。网上关于RT-Thread开启SPI使用SFUD进行FLASH进行读写的例子有很多，但是大部分都是基于ENV的，介
软件QSPI调试
闲客的博客
05-20 4167
相对于spi，qspi的是四条数据线并行传输数据，读写速度是普通spi的四倍。spi的工作模式有四种，但是qspi的工作模式只有两种也就是模式0（CPOL=0,CPOH=1）和模式3（CPOL=1,CPOL=1）. 在使用软件qspi前，需要先使能对应芯片的qspi功能，一般是先读取使能位的状态寄存器，根据状态寄存器的qspi状态位判断该芯片当前是否已开启qspi，qspi与普通spi不能同时使用...
STM32学习笔记-SPI总线通信
weixin_43073852的博客
12-28 5743
SPI总线通信
STM32F103学习笔记——SPI读写Flash(三）
weixin_45621528的博客
02-14 1550
  此系列文章是小白学习STM32的一些学习笔记。小白第一次写笔记文章，有不足或是错误之处，请多体谅和交流！ 目录1.FLASH指令编码表2.读取FLASH芯片ID函数3.FLASH写使能以及读取当前状态函数4.FLASH扇区擦除5.FLASH的页写入6.从FLASH读取数据 1.FLASH指令编码表   我们将FLASH芯片的各个指令用宏定义的方式定义下来，这样相对于纯16进制指令，使用的时候清晰明了。 2.读取FLASH芯片ID函数   读取FLASH的ID函数编写如下： u32 SPI_FLASH_R
STM32CubeMX学习笔记14 ---SPI总线
H2z1220的博客
03-06 2770
SPI 是英语Serial Peripheral interface的缩写，顾名思义就是串行外围设备接口。是Motorola(摩托罗拉)首先在其MC68HCXX系列处理器上定义的。SPI，是一种高速的，全双工，同步的通信总线，并且在芯片的管脚上只占用四根线，节约了芯片的管脚，同时为PCB的布局上节省空间，提供方便，主要应用在 EEPROM，FLASH，实时时钟，AD转换器，还有数字信号处理器和数字信号解码器之间。SPI主从模式。
stm32f103c8t6学习笔记（学习B站up江科大自化协）-SPI
weixin_74859061的博客
04-17 3489
CPHA表示的是时钟相位，决定是第一个时钟采样移入还是第二个时钟采样移入，并不是规定上升沿采样还是下降沿采样。在CPOL确定的情况下，CPHA会改变采样时刻的上升沿和下降沿，比如模式0的时候是SCK上升沿采样移入，模式1的时候是SCK下降沿采样移入。CPHA决定是第几个边沿采样，但不能单独决定是上升沿还是下降沿。模式0和3都是上升沿采样，模式1和2都是下降沿采样。非易失性存储器：数据不容易失去的存储器，数据掉电不丢失，存储在芯片中的数据在断电重启之后数据仍然保持原样。
xapp1257-multiboot-fallback-spi-flash.zip_MultiBoot spi_flash启动_
07-14
在本文中，我们将深入探讨基于外部SPI Flash的FPGA多重启动程序，这主要与Xilinx的应用笔记XAPP1257相关。多重启动（MultiBoot）功能是FPGA设计中的一个重要概念，它允许系统在遇到故障或需要更新时，能够无缝地切换...
笔记-webpack5学习指南-V1.0
08-29
笔记-webpack5学习指南-V1.0
云的学习笔记-云的学习笔记系统-云的学习笔记系统源码-云的学习笔记管理系统-基于ssm的云的学习笔记系统-ssm-java代码
04-16
云的学习笔记-云的学习笔记系统-云的学习笔记系统源码-云的学习笔记管理系统-云的学习笔记管理系统java代码-云的学习笔记系统设计与实现-基于ssm的云的学习笔记系统-基于Web的云的学习笔记系统设计与实现-云的学习...
Freertos学习笔记
qq_45031559的博客
08-21 635
Freertos学习笔记
零基础学习人工智能—Python—Pytorch学习（六）
kiba518的博客
08-21 884
前言 本文主要讲神经网络的上半部分。 这篇文章开始有很多公式了，这些公式都很简单，但是如果是不经常在脑海里思考公式的人，那可能需要多花点时间做一下自我训练，个人感觉，也就几天时间，就能把自己感觉给调整出来。 习惯了公式看下面内容就会轻松很多，另外如果要深入学习人工智能，熟练的认知公式也是个必须的事情。 另外，我发现我前面文章写的有歧义的地方还是挺多，虽然，已经改了一部分，但，可能还有没发现的，大...
一起学习LeetCode热题100道（48/100）
weixin_53224223的博客
08-20 537
7.注意：虽然代码中包含了回溯部分（即减少当前路径和的计数并从prefixSums中删除它），但在本问题中，由于树是无环的，并且我们不需要精确跟踪每条路径，因此这部分是多余的。输入：root = [5,4,8,11,null,13,4,7,2,null,null,5,1], targetSum = 22。输入：root = [10,5,-3,3,2,null,11,3,-2,null,1], targetSum = 8。1.这是主函数，接收根节点和目标和作为参数，并返回满足条件的路径数量。
day38-栈和队列理论学习【python】
最新发布
canGfly的博客
08-21 459
栈（Stack）: 使用 Python 的list实现。主要操作有pushpoppeek, 和is_empty。队列（Queue）: 使用实现。主要操作有enqueuedequeuepeek, 和is_empty。这两种数据结构可以通过这些操作灵活地处理和存储数据。在实际应用中，选择使用哪种数据结构取决于具体的需求和场景。ok了，就到这里叭～～～​​​。
Python3学习（一）
qq_54161774的博客
08-21 1241
python的基础语法
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值