【GD32F303红枫派开发板使用手册】第十九讲 SPI-SPI NOR FLASH读写实验

聚沃科技 2024-06-19 192

描述

19.1 实验内容

通过本实验主要学习以下内容：

SPI简介
GD32F303 SPI简介
SPI NOR FLASH——GD25Q32ESIGR简介
使用GD32F303 SPI接口实现对GD25Q32ESIGR的读写操作

19.2 实验原理

19.2.1 SPI简介

SPI（Serial Peripheral interface），顾名思义是串行外设接口，和UART不同的是，SPI是同步通讯接口，所以带有时钟线，而UART是异步通讯接口，不需要时钟线。

SPI通常使用4根线，分别为SCK、MOSI、MISO、NSS（CS）：

SCK：串列时脉，由主机发出
MOSI：主机输出从机输入信号（数据由主机发出）
MISO：主机输入从机输出信号（数据由从机发出）
NSS：片选信号，由主机发出，一般是低电位有效

SPI默认为全双工工作，在这种工作模式下，主机通过MOSI线发送数据的同时，也在MISO线上接受数据，简单来说就是主机和从机之间进行数据交换。

SPI是一个可以实现一主多从的通讯接口，从机的片选由主机NSS脚来控制：

每个通讯时刻，只有一个从机NSS被主机选中，选中方式为主机拉低响应的NSS（CS）脚。

SPI的数据线只有一条（虽然有MOSI和MISO，但实际上每个CLK主机都只能发送和接受一个bit），所以称之为单线SPI。从SPI衍生出来的还有4线制SPI（QSPI）和8线制SPI（OSPI）以及其他多线制SPI，这个我们后面具体再聊。

19.2.2 GD32F303 SPI简介

GD32F303的主要特性如下：

◼ 具有全双工和单工模式的主从操作；
◼ 16位宽度，独立的发送和接收缓冲区；
◼ 8位或16位数据帧格式；
◼ 低位在前或高位在前的数据位顺序；
◼ 软件和硬件NSS管理；
◼ 硬件CRC计算、发送和校验；
◼ 发送和接收支持DMA模式；
◼ 支持SPI TI模式；
◼ 支持SPI NSS脉冲模式
◼ 支持SPI四线功能的主机模式（仅在SPI0中）

以下为GD32F303 SPI的框图：

我们可以看到GD32F303有一个发送缓冲区和一个接受缓冲区这两个缓冲区都对应的是SPI_DATA寄存器，向SPI_DATA寄存器写数据将会把数据存入发送缓冲区，从SPI_DATA读数据，将从接受缓冲区获得数据。GD32F303还有一个移位寄存器，当主机发送缓冲区被写入数据时，数据将立刻转移到移位寄存器，移位寄存器通过 MOSI 信号线将字节传送给从机，从机也将自己的移位寄存器中的内容通过 MISO 信号线返回给主机。这样，两个移位寄存器中的内容就被交换。外设的写操作和读操作是同步完成的。如果只进行写操作，主机只需忽略接收到的字节；反之，若主机要读取从机的一个字节，就必须发送一个空字节来引发从机的传输。

SPI数据bit在CLK的有效边沿被锁存，而有效边沿是可以选择的，分别为：

第一个上升沿
第一个下降沿
第二个下降沿
第二个上升沿

通过SPI_CTL0寄存器中的CKPL位和CKPH位来设置有效锁存沿。其中CKPL 位决定了空闲状态时 SCK 的电平， CKPH 位决定了第一个或第二个时钟跳变沿为有效采样边沿。SPI_CTL0 中的 LF 位可以配置数据顺序，当 LF=1 时， SPI 先发送 LSB 位，当LF=0时，则先发送 MSB 位。SPI_CTL0 中的 FF16 位配置数据长度，当 FF16=1 时，数据长度为 16位，否则为 8 位。下图为SPI的时序图：

4线SPI（QSPI）的时序图如下(CKPL=1, CKPH=1, LF=0) ，我们可以看到QSPI是通过MOSI、MISO、IO2、IO3来进行数据收或发，所以QSPI是工作在半双工模式：

这里再介绍下SPI的NSS（片选）功能。NSS电平由主机来控制，主机将需要操作的从机NSS拉低，从而使该从机在总线上生效。

主机控制NSS的方式有两种——硬件方式和软件方式。主机硬件NSS模式下，NSS脚只能选择特定IO口（具体见datasheet中IO口功能表），当开始进行数据读写时，NSS自动拉低，这种方式的优点是主机NSS由硬件自动控制，缺点是只能控制一个从机；主机NSS软件模式下，NSS可以使用任意IO口，需要控制哪个从机，软件将对于IO拉低即可，这种方式的优点是可以实现一个主机多个从机的通讯，缺点是软件需要介入控制NSS脚。

注意：GD32F303 主机硬件NSS模式下，一旦开始第一次数据读取，NSS被硬件自动拉低后，将不会自行拉高，从机将处于始终被片选的状态下。

从机获取NSS状态的方式也有两种——硬件方式和软件方式。从机硬件NSS模式下，SPI 从NSS引脚获取 NSS 电平，在软件NSS 模式（SWNSSEN = 1）下， SPI 根据SWNSS 位得到NSS电平。

SPI除了单线全双工模式外，还有很多其他方式，比如可以实现只用MOSI进行数据收和发的半双工通讯，这样就可以省下MISO用作他处了，具体可以参考GD32F30x系列官方用户手册。

下面介绍下SPI的发送和接受流程：

发送流程
在完成初始化过程之后， SPI 模块使能并保持在空闲状态。在主机模式下，当软件写一个数据到发送缓冲区时，发送过程开始。在从机模式下，当 SCK 引脚上的 SCK 信号开始翻转，且NSS 引脚电平为低，发送过程开始。所以，在从机模式下，应用程序必须确保在数据发送开始前，数据已经写入发送缓冲区中。
当 SPI 开始发送一个数据帧时，首先将这个数据帧从数据缓冲区加载到移位寄存器中，然后开始发送加载的数据。在数据帧的第一位发送之后， TBE（发送缓冲区空）位置 1。 TBE 标志位置 1，说明发送缓冲区为空，此时如果需要发送更多数据，软件应该继续写 SPI_DATA 寄存器。在主机模式下，若想要实现连续发送功能，那么在当前数据帧发送完成前，软件应该将下一个数据写入 SPI_DATA 寄存器中。

接收流程
在最后一个采样时钟边沿之后，接收到的数据将从移位寄存器存入到接收缓冲区，且 RBNE（接收缓冲区非空）位置 1。软件通过读 SPI_DATA 寄存器获得接收的数据，此操作会自动清除RBNE 标志位。

19.2.3 SPI FLASH——GD25Q32ESIGR简介

GD25Q32ESIGR是一款容量为32Mbit（即4Mbyte）的SPI接口的NOR FLASH，其支持SPI和QSPI模式，芯片示意图如下：

GD25Q32ESIGR管脚定义如下：

GD25Q32ESIGR内部flash结构如下：

下面介绍GD25Q32ESIGR的一些功能码。

Write Enable (WREN) (06H) ：接受到该命令后，GD25Q32ESIGR做好接受数据并进行存储的准备，时序如下：

Read Status Register (RDSR) (05H or 35H or 15H) ：读GD25Q32ESIGR的状态，时序如下：

Read Data Bytes (READ) (03H) ：接受到该命令后，GD25Q32ESIGR将数据准备好供主机读走，时序如下：

Dual Output Fast Read (3BH) ：使GD25Q32ESIGR切换到QSPI模式，时序如下：

Quad Output Fast Read (6BH) ：QSPI读命令，时序如下：

Quad Page Program (32H) ：QSPI写命令，时序如下：

Sector Erase (SE) (20H) ：Sector擦除命令，时序如下：

GD25Q32ESIGR就介绍到这里，读者可以在兆易创新官网下载该NOR FLASH的datasheet以获取更多信息。

19.3 硬件设计

红枫派开发板SPI——NOR FLASH的硬件设计如下：

从图中可以看出，本实验使用的是普通单线SPI，GD25Q32ESIGR的片选由GD32F303ZET6的PG14控制（因PG14不是SPI的NSS管脚，所以本实验用主机NSS软件模式），GD25Q32ESIGR的SO、SI和SCLK分别和GD32F303ZET6的PB4（SPI2_MISO）、PB5（SPI2_MOSI）以及PB3（SPI2_CLK）相连。

19.4 代码解析

19.4.1 SPI初始化函数

在driver_spi.c文件中定义了SPI初始化函数driver_spi_init：

C
void driver_spi_init(typdef_spi_struct *spix)
{
    spi_parameter_struct spi_init_struct;
    rcu_periph_clock_enable(spix->rcu_spi_x);
    /* spi configure */
    spi_i2s_deinit(spix->spi_x);
    driver_gpio_general_init(spix->spi_cs_gpio);
    driver_gpio_general_init(spix->spi_sck_gpio);
    driver_gpio_general_init(spix->spi_mosi_gpio);
    driver_gpio_general_init(spix->spi_miso_gpio);
    if(spix->spi_mode==MODE_DMA)
    {
        if(spix->spi_rx_dma!=NULL)
        {
            if(spix->frame_size==SPI_FRAMESIZE_8BIT)
            {
                driver_dma_com_init(spix->spi_rx_dma,(uint32_t)&SPI_DATA(spix->spi_x),NULL,DMA_Width_8BIT,DMA_PERIPHERAL_TO_MEMORY);
            }
            else
            {
                driver_dma_com_init(spix->spi_rx_dma,(uint32_t)&SPI_DATA(spix->spi_x),NULL,DMA_Width_16BIT,DMA_PERIPHERAL_TO_MEMORY);
            }
            if(spix->spi_tx_dma!=NULL)
            {
                if(spix->frame_size==SPI_FRAMESIZE_8BIT)
                {
                    driver_dma_com_init(spix->spi_tx_dma,(uint32_t)&SPI_DATA(spix->spi_x),NULL,DMA_Width_8BIT,DMA_MEMORY_TO_PERIPHERAL);
                }
                else
                {
                    driver_dma_com_init(spix->spi_tx_dma,(uint32_t)&SPI_DATA(spix->spi_x),NULL,DMA_Width_16BIT,DMA_MEMORY_TO_PERIPHERAL);
                }
            }
          }
    }

    if(spix->spi_cs_gpio!=NULL)
    {
        driver_gpio_pin_set(spix->spi_cs_gpio);
    }

    spi_struct_para_init(&spi_init_struct);
    spi_init_struct.trans_mode = SPI_TRANSMODE_FULLDUPLEX;
    spi_init_struct.device_mode = spix->device_mode;
    spi_init_struct.frame_size = spix->frame_size;
    spi_init_struct.clock_polarity_phase = spix->clock_polarity_phase;
    if(spix->device_mode==SPI_MASTER){
        spi_init_struct.nss = SPI_NSS_SOFT;
    }else{
        spi_init_struct.nss = SPI_NSS_HARD;
    }
    spi_init_struct.prescale = spix->prescale;
    spi_init_struct.endian = spix->endian;
    spi_init(spix->spi_x, &spi_init_struct);
    spi_enable(spix->spi_x);
}

19.4.2 SPI轮训接受一个数函数

在driver_spi.c文件中定义了使用轮训方式发送接受一个字节数据函数driver_spi_master_transmit_receive_byte：

C
uint8_t driver_spi_master_transmit_receive_byte(typdef_spi_struct *spix,uint8_t byte)
{
    SPI_DATA(spix->spi_x);
    SPI_STAT(spix->spi_x);
    driver_spi_flag_wait_timeout(spix,SPI_FLAG_TBE,SET);
    spi_i2s_data_transmit(spix->spi_x,byte);
    DRV_ERROR==driver_spi_flag_wait_timeout(spix,SPI_FLAG_RBNE,SET);
    return spi_i2s_data_receive(spix->spi_x);
}

上面函数中有带超时功能的等待SPI状态的函数driver_spi_flag_wait_timeout，该函数定义在driver_spi.c：

C
Drv_Err driver_spi_flag_wait_timeout(typdef_spi_struct *spix, uint32_t flag ,FlagStatus wait_state)
{
    uint32_t timeout = driver_tick;
    while(wait_state!=spi_i2s_flag_get(spix->spi_x, flag)){
        if((timeout+SPI_TIMEOUT_MS) <= driver_tick) {
            return DRV_ERROR;
        }
    }
    return DRV_SUCCESS;
}

19.4.3 SPI NOR FLASH 接口bsp层函数

操作NOR FLASH的函数都定义在bsp层文件bsp_spi_nor.c中，这个文件中定义的函数都是针对NOR FLASH特性来实现的，我们选取几个函数进行介绍。

NOR FLASH按sector擦除函数bsp_spi_nor_sector_erase，该函数流程是：使能NOR FLASH的写功能->拉低片选->向NOR FLASH发送sector擦除指令SE（0x20）->从低地址到高地址发送需要擦除的地址->拉高片选->等待NOR FALSH内部操作完成（循环去读NOR FLASH状态，直到读出编程状态为0）

C
void bsp_spi_nor_sector_erase(uint32_t sector_addr)
{
    /* send write enable instruction */
    bsp_spi_nor_write_enable();
    /* sector erase */
    /* select the flash: chip select low */
    bsp_spi_nor_cs_low();
    /* send sector erase instruction */
    driver_spi_master_transmit_receive_byte(&BOARD_SPI,SE);
    /* send sector_addr high nibble address byte */
    driver_spi_master_transmit_receive_byte(&BOARD_SPI,(sector_addr & 0xFF0000) >> 16);
    /* send sector_addr medium nibble address byte */
    driver_spi_master_transmit_receive_byte(&BOARD_SPI,(sector_addr & 0xFF00) >> 8);
    /* send sector_addr low nibble address byte */
    driver_spi_master_transmit_receive_byte(&BOARD_SPI,sector_addr & 0xFF);
    /* deselect the flash: chip select high */
    bsp_spi_nor_cs_high();
    /* wait the end of flash writing */
    bsp_spi_nor_wait_for_write_end();
}

按page写数据函数bsp_spi_nor_page_write，该函数实现在page范围内写数据，该函数流程是：使能NOR FLASH的写功能->拉低片选->向NOR FLASH发送写指令WRITE（0x02）->从低地址到高地址发送要写的地址（每次进行写数据时，只需要给初始地址即可，写完一个数据后NOR FLASH内部会自动把地址+1）->写数据->拉高片选->等待NOR FALSH内部操作完成（循环去读NOR FLASH状态，直到读出编程状态为0）

C
void bsp_spi_nor_page_write(uint8_t* pbuffer, uint32_t write_addr, uint16_t num_byte_to_write)
{
    /* enable the write access to the flash */
    bsp_spi_nor_write_enable();

    /* select the flash: chip select low */
    bsp_spi_nor_cs_low();

    /* send "write to memory" instruction */
    driver_spi_master_transmit_receive_byte(&BOARD_SPI,WRITE);
    /* send write_addr high nibble address byte to write to */
    driver_spi_master_transmit_receive_byte(&BOARD_SPI,(write_addr & 0xFF0000) >> 16);
    /* send write_addr medium nibble address byte to write to */
    driver_spi_master_transmit_receive_byte(&BOARD_SPI,(write_addr & 0xFF00) >> 8);
    /* send write_addr low nibble address byte to write to */
    driver_spi_master_transmit_receive_byte(&BOARD_SPI,write_addr & 0xFF);

    /* while there is data to be written on the flash */
    while(num_byte_to_write--){
        /* send the current byte */
        driver_spi_master_transmit_receive_byte(&BOARD_SPI,*pbuffer);
        /* point on the next byte to be written */
        pbuffer++;
    }

    /* deselect the flash: chip select high */
    bsp_spi_nor_cs_high();

    /* wait the end of flash writing */
    bsp_spi_nor_wait_for_write_end();
}

按buffer写数据函数bsp_spi_nor_buffer_write，该函数实现任意长度数据写入，使用page写函数搭配算法，可以跨page进行写数据：

C
void bsp_spi_nor_buffer_write(uint8_t* pbuffer, uint32_t write_addr, uint16_t num_byte_to_write)
{
    uint8_t num_of_page = 0, num_of_single = 0, addr = 0, count = 0, temp = 0;

    addr          = write_addr % SPI_FLASH_PAGE_SIZE;
    count         = SPI_FLASH_PAGE_SIZE - addr;
    num_of_page = num_byte_to_write / SPI_FLASH_PAGE_SIZE;
    num_of_single = num_byte_to_write % SPI_FLASH_PAGE_SIZE;

     /* write_addr is SPI_FLASH_PAGE_SIZE aligned */
    if(0 == addr){
        /* num_byte_to_write < SPI_FLASH_PAGE_SIZE */
        if(0 == num_of_page)
            bsp_spi_nor_page_write(pbuffer,write_addr,num_byte_to_write);
        /* num_byte_to_write > SPI_FLASH_PAGE_SIZE */
        else{
            while(num_of_page--){
                bsp_spi_nor_page_write(pbuffer,write_addr,SPI_FLASH_PAGE_SIZE);
                write_addr += SPI_FLASH_PAGE_SIZE;
                pbuffer += SPI_FLASH_PAGE_SIZE;
            }
            bsp_spi_nor_page_write(pbuffer,write_addr,num_of_single);
        }
    }else{
        /* write_addr is not SPI_FLASH_PAGE_SIZE aligned */
        if(0 == num_of_page){
            /* (num_byte_to_write + write_addr) > SPI_FLASH_PAGE_SIZE */
            if(num_of_single > count){
                temp = num_of_single - count;
                bsp_spi_nor_page_write(pbuffer,write_addr,count);
                write_addr += count;
                pbuffer += count;
                bsp_spi_nor_page_write(pbuffer,write_addr,temp);
            }else
                bsp_spi_nor_page_write(pbuffer,write_addr,num_byte_to_write);
        }else{
            /* num_byte_to_write > SPI_FLASH_PAGE_SIZE */
            num_byte_to_write -= count;
            num_of_page = num_byte_to_write / SPI_FLASH_PAGE_SIZE;
            num_of_single = num_byte_to_write % SPI_FLASH_PAGE_SIZE;

            bsp_spi_nor_page_write(pbuffer,write_addr, count);
            write_addr += count;
            pbuffer += count;

            while(num_of_page--){
                bsp_spi_nor_page_write(pbuffer,write_addr,SPI_FLASH_PAGE_SIZE);
                write_addr += SPI_FLASH_PAGE_SIZE;
                pbuffer += SPI_FLASH_PAGE_SIZE;
            }

            if(0 != num_of_single)
                bsp_spi_nor_page_write(pbuffer,write_addr,num_of_single);
        }
    }
}

按buffer读数据函数bsp_spi_nor_buffer_read，该函数实现任意地址读数据，该函数流程是：拉低片选->向NOR FLASH发送读指令READ（0x03）->从低地址到高地址发送要读的地址（每次进行读数据时，只需要给初始地址即可，读完一个数据后NOR FLASH内部会自动把地址+1）->读数据->拉高片选：

C
void bsp_spi_nor_buffer_read(uint8_t* pbuffer, uint32_t read_addr, uint16_t num_byte_to_read)
{
    /* select the flash: chip slect low */
    bsp_spi_nor_cs_low();

    /* send "read from memory " instruction */
    driver_spi_master_transmit_receive_byte(&BOARD_SPI,READ);

    /* send read_addr high nibble address byte to read from */
    driver_spi_master_transmit_receive_byte(&BOARD_SPI,(read_addr & 0xFF0000) >> 16);
    /* send read_addr medium nibble address byte to read from */
    driver_spi_master_transmit_receive_byte(&BOARD_SPI,(read_addr& 0xFF00) >> 8);
    /* send read_addr low nibble address byte to read from */
    driver_spi_master_transmit_receive_byte(&BOARD_SPI,read_addr & 0xFF);

    /* while there is data to be read */
    while(num_byte_to_read--){
        /* read a byte from the flash */
        *pbuffer = driver_spi_master_transmit_receive_byte(&BOARD_SPI,DUMMY_BYTE);
        /* point to the next location where the byte read will be saved */
        pbuffer++;
    }

    /* deselect the flash: chip select high */
    bsp_spi_nor_cs_high();
}

19.4.4 main函数实现

以下为main函数代码：

C
int main(void)
{
    //延时、共用驱动部分初始化
    driver_init();
    //初始化LED组和默认状态
    bsp_led_group_init();
    bsp_led_on(&LED0);
    bsp_led_off(&LED1);
    //初始化UART打印
    bsp_uart_init(&BOARD_UART);
    //初始化SPI
    bsp_spi_init(&BOARD_SPI);
    //初始化SPI NOR
    bsp_spi_nor_init();
    printf("\n\rSPI Flash:GD25Q32E configured...\n\r");
    //读取flash id
    flash_id = bsp_spi_nor_read_id();
    printf("\n\rThe Flash_ID:0x%X\n\r",flash_id);
    //比对flash id是否一致
    if(SFLASH_ID == flash_id)
        {
        printf("\n\r\n\rWrite to tx_buffer:\n\r\n\r");
        //准备数据
        for(uint16_t i = 0; i < BUFFER_SIZE; i ++){
            tx_buffer[i] = i;
            printf("0x%02X ",tx_buffer[i]);
            if(15 == i%16)
                printf("\n\r");
        }

        printf("\n\r\n\rRead from rx_buffer:\n\r");
        //擦除要写入的sector
        bsp_spi_nor_sector_erase(FLASH_WRITE_ADDRESS);
        //写入数据
        bsp_spi_nor_buffer_write(tx_buffer,FLASH_WRITE_ADDRESS,TX_BUFFER_SIZE);
        //延时等待写完成
        delay_ms(10);
        //回读写入数据
        bsp_spi_nor_buffer_read(rx_buffer,FLASH_READ_ADDRESS,RX_BUFFER_SIZE);
        /* printf rx_buffer value */
        for(uint16_t i = 0; i <= 255; i ++){
            printf("0x%02X ", rx_buffer[i]);
            if(15 == i%16)
                printf("\n\r");
        }
        //比较回读和写入数据
        if(ERROR == memory_compare(tx_buffer,rx_buffer,256)){
            printf("Err:Data Read and Write aren't Matching.\n\r");
            /* spi flash read id fail */
            printf("\n\rSPI Flash: Read ID Fail!\n\r");

            //写入错误
            /* turn off all leds */
            bsp_led_on(&LED0);
            /* turn off all leds */
            bsp_led_on(&LED1);
            while(1);
        }else{
            printf("\n\rSPI-GD25Q16 Test Passed!\n\r");
        }
    }else{ //ID读取错误
        /* spi flash read id fail */
        printf("\n\rSPI Flash: Read ID Fail!\n\r");
        /* turn off all leds */
        bsp_led_on(&LED0);
        /* turn off all leds */
        bsp_led_on(&LED1);
        while(1);
    }

    while(1){
        /* turn off all leds */
        bsp_led_toggle(&LED0);
        /* turn off all leds */
        bsp_led_toggle(&LED1);
        delay_ms(200);
    }
}

main函数中实现了向特定NOR FLASH地址写数据，并回读出来，并将写入的数据和回读出来的数据进行对比，看是否写入成功。

19.5 实验结果

使用USB-TypeC线，连接电脑和板上USB to UART口后，配置好串口调试助手，即可看到MCU对SPI NOR flash的擦写读过程。

本教程由GD32 MCU方案商聚沃科技原创发布，了解更多GD32 MCU教程，关注聚沃科技官网

打开APP阅读更多精彩内容