21ic电子技术开发论坛 › 单片机与嵌入式系统 › GigaDevice GD32 MCU › 【GD32H757Z海棠派使用手册】第十一讲 SPI-SPI NOR FLAS ...
返回列表 发新帖我要提问

[研电赛技术支持] 【GD32H757Z海棠派使用手册】第十一讲 SPI-SPI NOR FLASH读写实验

[复制链接]
3440|1
 楼主| 聚沃科技 发表于 2024-6-4 11:21 | 显示全部楼层 |阅读模式
开发板, 单片机, GD32, flash, FLASH读写
本帖最后由 聚沃科技 于 2024-6-5 10:26 编辑

H757首图.png
11.1 实验内容
通过本实验主要学习以下内容：
• SPI简介
• GD32H7 SPI简介
• SPI NOR FLASH——GD25Q128ESIGR简介
• 使用GD32H7 SPI接口实现对GD25Q128ESIGR的读写操作
11.2 实验原理
11.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脚来控制：
图片1.png
每个通讯时刻，只有一个从机NSS被主机选中，选中方式为主机拉低响应的NSS（CS）脚。
SPI的数据线只有一条（虽然有MOSI和MISO，但实际上每个CLK主机都只能发送和接受一个bit），所以称之为单线SPI。从SPI衍生出来的还有4线制SPI（QSPI）和8线制SPI（OSPI）以及其他多线制SPI，这个我们后面具体再聊。
11.2.2 GD32H7 SPI简介
GD32H7 的SPI主要特性如下：
◼ 具有全双工、 半双工和单工模式的主从操作；
◼ 32位宽度，独立的发送和接收FIFO；
◼ 4位到32位数据帧格式；
◼ 低位在前或高位在前的数据位顺序；
◼ 软件和硬件NSS管理， MOSI与MISO引脚复用功能的交换；
◼ 硬件CRC计算、发送和校验；
◼ 发送和接收支持DMA模式；
◼ 支持SPI TI模式；
◼ 多主机多从机功能；
◼ 配置和设置保护；
◼ 可调的数据帧之间的最小延时和NSS与数据流之间的最小延时；
◼ 主机模式错误可触发中断，上溢、 下溢和CRC错误检测；
◼ 可调的主设备接收器采样时间；
◼ 可配置的FIFO阈值（数据打包） ；
◼ 在从机模式，下溢条件可配置；
◼ 支持SPI四线功能的主机模式（只有SPI3 / 4）。  
以下为GD32H7 SPI的框图：
图片2.png
如果小伙伴用过GD的其他系列MCU的SPI的话，就会发现H7和其他系列再SPI上的一个很大的不同，比如聚沃发布的紫藤派开发板用到的GD32F470的SPI是通过一个发送缓冲区和一个接受缓冲区这两个缓冲区来进行数据收发的，而H7产品则采用FIFO的模式进行数据收发管理，且发送FIFO（TXFIFO）对应TX位移寄存器，接受FIFO（RXFIFO）对应RX位移寄存器。当CPU或DMA将数据写到TXFIFO中（需要先判断TXFIFO是否有足够的空间能够写入数据），TXFIFO中的数据将会被转移到TX位移寄存器中，实现发送；反之，当RX位移寄存器收到数据，会将数据转移到RXFIFO中（需要保证RXFIFO有足够的空间存入数据），RXFIFO会通知CPU或者DMA取走数据。
GD32H7的SPI TxFIFO和RxFIFO的大小都为16*32位，FIFO的存在使得当CPU或者DMA来不及处理SPI数据时，能够防止发生数据过载或丢失。需要提醒的是，SPI正在发送的数据不一定是最新写到TxFIFO中的数据，因为最新数据在TxFIFO的末尾；CPU或者DMA接收到的数据不一定就是SPI最新的数据，因为SPI最新的数据在RxFIFO的末尾。
全双工模式下，当GD32H7 SPI主机TX位移寄存器被写入数据时，TX位移寄存器通过 MOSI 信号线将字节传送给从机，从机也将自己的位移寄存器内容通过 MISO 信号线返回给主机的RX位移寄存器。外设的写操作和读操作是同步完成的。如果只进行写操作，主机只需忽略接收到的字节；反之，若主机要读取从机的一个字节，就必须发送一个空字节来引发从机的传输。
SPI数据bit在CLK的有效边沿被锁存，而有效边沿是可以选择的，分别为：
• 第一个上升沿
• 第一个下降沿
• 第二个下降沿
• 第二个上升沿
通过SPI_CFG1寄存器中的CKPL位和CKPH位来设置有效锁存沿。其中CKPL 位决定了空闲状态时 SCK 的电平， CKPH 位决定了第一个或第二个时钟跳变沿为有效采样边沿。SPI_CFG1中的 LF 位可以配置数据顺序， 当 LF=1 时， SPI 先发送 LSB 位，当LF=0时，则先发送 MSB 位。SPI_CFG0 中的 DZ[4:0] 位域配置数据长度， 可以设置数据长度为4位至32位。下图为SPI的时序图：
图片3.png
4线SPI（QSPI）的时序图如下(CKPL=1, CKPH=1, LF=0)  ，我们可以看到QSPI是通过MOSI、MISO、IO2、IO3来进行数据收或发，所以QSPI是工作在半双工模式：
图片3.png
这里再介绍下SPI的NSS（片选）功能。NSS电平由主机来控制，主机将需要操作的从机NSS拉低，从而使该从机在总线上生效。
主机控制NSS的方式有两种——硬件方式和软件方式。主机硬件NSS模式下，NSS脚只能选择特定IO口（具体见datasheet中IO口功能表），当开始进行数据读写时，NSS自动拉低，这种方式的优点是主机NSS由硬件自动控制，缺点是只能控制一个从机；主机NSS软件模式下，NSS可以使用任意IO口，需要控制哪个从机，软件将对于IO拉低即可，这种方式的优点是可以实现一个主机多个从机的通讯，缺点是软件需要介入控制NSS脚。
从机获取NSS状态的方式也有两种——硬件方式和软件方式。从机硬件NSS模式下，SPI 从NSS引脚获取 NSS 电平， 在软件NSS 模式（NSSIM = 1） 下， SPI根据SNSSI 位得到NSS电平。
SPI除了单线全双工模式外，还有很多其他方式，比如可以实现只用MOSI进行数据收和发的半双工通讯，这样就可以省下MISO用作他处了，具体可以参考GD32FH7系列官方用户手册。
这里着重介绍下H7 SPI的数据长度和SPI_CFG0中的BYTEN（bit23）和WORDEN（bit24）。BYTEN和WORDEN用来指示对FIFO的访问宽度：
账号密码_Sheet1.png
建议SPI的数据长度设置（SPI_CFG0 中的 DZ[4:0] 位域）和FIFO访问宽度匹配，比如设置SPI数据长度为8，则需要配置FIFO访问宽度为字节访问，若配置FIFO访问宽度为半字访问，当发送一个8位数据时，总线上会产生16个clock，从而导致数据错位。
下面介绍下SPI的发送和接受流程：
发送流程
在完成初始化过程之后， SPI模块使能并保持在空闲状态。在主机模式下， 当软件写一个数据到TxFIFO时，发送过程开始。在从机模式下，当SCK引脚上的SCK信号开始翻转， 且NSS引脚电平有效， 发送过程开始。 所以， 在从机模式下，应用程序必须确保在数据发送开始前， 数据已经写入TxFIFO中。  
当SPI开始发送一个数据帧时， 首先将这个数据帧从TxFIFO加载到移位寄存器中，然后开始发送加载的数据。
对SPI_TDATA的写访问由TP——TxFIFO数据包空间有效标志事件管理。
图片5.png
当TP标志设置为1时，应用程序对SPI数据寄存器写入适当数量的数据，以传输数据包的内容。在上传新的完整包后，应用程序检查TP值，检查TxFIFO是否可以接收额外的数据包，如果TP = 1，则逐包上传，直到TP读取0。
在主机模式下， 若想要实现连续发送功能， 那么在当前数据帧发送完成前， 软件应该将下一个数据写入SPI_TDATA寄存器中。 只要TxFIFO中存在数据， 数据发送便一直继续， 直至TxFIFO变为空。   
接收流程
在最后一个采样时钟边沿之后， 接收到的数据将从移位寄存器存入到RxFIFO， 且RP——RxFIFO数据包空间有效标志 位置1。
图片6.png
软件通过读SPI_RDATA寄存器获得接收的数据， 此操作会自动清除RP标志位（当RxFIFO数据量少于FIFOLVL标准）。 在全双工主机模式（MFD）中， 仅当TxFIFO非空时，硬件才接收下一个数据帧。
对SPI_RDATA的读访问由RP事件管理。 当RP标志设置为1时，应用程序读取SPI数据寄存器相当数量的数据，以下载单个数据包内容。下载完整数据包后，应用程序会检查RP值，查看RxFIFO中是否有其他数据包，如果有，则逐包下载，直到RP读到0。
接收数据时， 主机提供时钟信号， 当主机停止或挂起SPI时才会停止接收流程。主机通过将MSTART位置1来启动流程， 可通过向SPI_CTL0寄存器的MSPDR为写1来请求挂起，或者向MASP位写1来设置上溢挂起。
11.2.3 SPI FLASH——GD25Q128ESIGR简介
GD25Q128ESIGR是一款容量为128Mbit（即16Mbyte）的SPI接口的NOR FLASH，其支持SPI和QSPI模式，芯片示意图如下：
图片7.png
GD25Q128ESIGR管脚定义如下：
图片8.png
GD25Q128ESIGR内部flash结构如下：
图片9.png
下面介绍GD25Q128ESIGR的一些功能码。
Write Enable (WREN) (06H) ：接受到该命令后，GD25Q128ESIGR做好接受数据并进行存储的准备，时序如下：
图片10.png
Read Status Register (RDSR) (05H or 35H or 15H)  ：读GD25Q128ESIGR的状态，时序如下：
图片11.png
Read Data Bytes (READ) (03H)  ：接受到该命令后，GD25Q128ESIGR将数据准备好供主机读走，时序如下：
图片12.png
Dual Output Fast Read (3BH)  ：使GD25Q128ESIGR切换到QSPI模式，时序如下：
图片13.png
Quad Output Fast Read (6BH)  ：QSPI读命令，时序如下：
图片14.png
Quad Page Program (32H)   ：QSPI写命令，时序如下：
图片15.png
Quad Page Program (32H)   ：QSPI写命令，时序如下：
图片16.png
GD25Q128ESIGR就介绍到这里，读者可以在兆易创新官网下载该NOR FLASH的datasheet以获取更多信息。
11.3 硬件设计
海棠派开发板SPI——NOR FLASH的硬件设计如下：
图片17.png
从图中可以看出，本实验使用的是普通单线SPI，GD25Q128ESIGR的片选由GD32H757的PF6控制，并采用主机NSS软件模式，GD25Q128ESIGR的SO、SI和SCLK分别和GD32H757的PF8（SPI4_MISO）、PB9（SPI4_MOSI）以及PF7（SPI4_CLK）相连。
11.4 代码解析
11.4.1 SPI初始化函数
在driver_spi.c文件中定义了SPI初始化函数driver_spi_init：
复制
  1. C
    

  2. void driver_spi_init(typdef_spi_struct *spix)
    

  3. {
    

  4.     spi_parameter_struct spi_init_struct;    
    

  5.     rcu_periph_clock_enable(spix->rcu_spi_x);
    

  6.     /* spi configure */
    

  7.     spi_i2s_deinit(spix->spi_x);
    


  8. 

  9.     spix->spi_sck_gpio->speed=GPIO_OSPEED_60MHZ;
    

  10.     spix->spi_mosi_gpio->speed=GPIO_OSPEED_60MHZ;
    

  11.     spix->spi_miso_gpio->speed=GPIO_OSPEED_60MHZ;
    

  12.     
    

  13.     driver_gpio_general_init(spix->spi_cs_gpio);    
    

  14.     driver_gpio_general_init(spix->spi_sck_gpio);
    

  15.     driver_gpio_general_init(spix->spi_mosi_gpio);
    

  16.     driver_gpio_general_init(spix->spi_miso_gpio);        
    


  17. 

  18.     if(spix->spi_mode==MODE_DMA)
    

  19.     {
    

  20.         if(spix->spi_rx_dma!=NULL)
    

  21.         {
    

  22.             if(spix->frame_size==SPI_DATASIZE_8BIT){
    

  23.                 driver_dma_com_init(spix->spi_rx_dma,(uint32_t)&SPI_RDATA(spix->spi_x),NULL,DMA_Width_8BIT,DMA_PERIPH_TO_MEMORY);
    

  24.             }
    

  25.             else if(spix->frame_size==SPI_DATASIZE_16BIT){
    

  26.                 driver_dma_com_init(spix->spi_rx_dma,(uint32_t)&SPI_RDATA(spix->spi_x),NULL,DMA_Width_16BIT,DMA_PERIPH_TO_MEMORY);
    

  27.             }
    

  28.             else if(spix->frame_size==SPI_DATASIZE_32BIT){
    

  29.                 driver_dma_com_init(spix->spi_rx_dma,(uint32_t)&SPI_RDATA(spix->spi_x),NULL,DMA_Width_32BIT,DMA_PERIPH_TO_MEMORY);
    

  30.             }            
    

  31.         }            
    

  32.             
    

  33.         if(spix->spi_tx_dma!=NULL)
    

  34.         {
    

  35.             if(spix->frame_size==SPI_DATASIZE_8BIT){
    

  36.                 driver_dma_com_init(spix->spi_tx_dma,(uint32_t)&SPI_TDATA(spix->spi_x),NULL,DMA_Width_8BIT,DMA_MEMORY_TO_PERIPH);
    

  37.             }
    

  38.             else if(spix->frame_size==SPI_DATASIZE_16BIT){
    

  39.                 driver_dma_com_init(spix->spi_tx_dma,(uint32_t)&SPI_TDATA(spix->spi_x),NULL,DMA_Width_16BIT,DMA_MEMORY_TO_PERIPH);
    

  40.             }
    

  41.             else if(spix->frame_size==SPI_DATASIZE_32BIT){
    

  42.                 driver_dma_com_init(spix->spi_tx_dma,(uint32_t)&SPI_TDATA(spix->spi_x),NULL,DMA_Width_32BIT,DMA_MEMORY_TO_PERIPH);
    

  43.             }            
    

  44.         }            
    

  45.     }
    

  46.     
    

  47.     if(spix->spi_cs_gpio!=NULL)
    

  48.     {
    

  49.         driver_gpio_pin_set(spix->spi_cs_gpio);
    

  50.     }
    

  51.     
    

  52.     spi_struct_para_init(&spi_init_struct);
    

  53.     /* SPI3 parameter config */
    

  54.     spi_init_struct.trans_mode = SPI_TRANSMODE_FULLDUPLEX;
    

  55.     spi_init_struct.device_mode = spix->device_mode;
    

  56.     spi_init_struct.data_size = spix->frame_size;
    

  57.     spi_init_struct.clock_polarity_phase = spix->clock_polarity_phase;
    

  58.     if(spix->device_mode==SPI_MASTER){
    

  59.         spi_init_struct.nss = SPI_NSS_SOFT;
    

  60.     }else{
    

  61.         spi_init_struct.nss = SPI_NSS_HARD;        
    

  62.     }
    

  63.     spi_init_struct.prescale = spix->prescale;
    

  64.     spi_init_struct.endian = spix->endian;
    

  65.     spi_init(spix->spi_x, &spi_init_struct);
    

  66.     
    

  67.     /* enable SPI byte access */
    

  68.     spi_byte_access_enable(spix->spi_x);
    

  69.     
    

  70.         /* configure SPI current data number  */
    

  71.     spi_current_data_num_config(spix->spi_x, 0);
    


  72. 

  73.     spi_nss_output_enable(spix->spi_x);
    

  74.     
    

  75.     /* enable SPI3 */
    

  76.     spi_enable(spix->spi_x);
    

  77.     
    

  78.     /* start SPI master transfer */
    

  79.     spi_master_transfer_start(spix->spi_x, SPI_TRANS_START);    
    

  80. }
11.4.2 SPI轮训接受一个数函数
在driver_spi.c文件中定义了使用轮训方式发送接受一个字节数据函数driver_spi_master_transmit_receive_byte：
复制
  1. C
    

  2. uint8_t driver_spi_master_transmit_receive_byte(typdef_spi_struct *spix,uint8_t byte)
    

  3. {
    

  4.     
    

  5.     spi_i2s_flag_clear(spix->spi_x, SPI_STATC_TXURERRC|SPI_STATC_RXORERRC|SPI_STATC_CRCERRC|SPI_STATC_FERRC|SPI_STATC_CONFERRC);    
    

  6.              
    

  7.     driver_spi_flag_wait_timeout(spix,SPI_FLAG_TP,SET);
    


  8. 

  9.     spi_i2s_data_transmit(spix->spi_x,byte);
    


  10. 

  11.     driver_spi_flag_wait_timeout(spix,SPI_FLAG_RP,SET);
    


  12. 

  13.     return spi_i2s_data_receive(spix->spi_x);                
    

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

  2. Drv_Err driver_spi_flag_wait_timeout(typdef_spi_struct *spix, uint32_t flag ,FlagStatus wait_state)
    

  3. {
    

  4.     __IO uint64_t timeout = driver_tick;    
    

  5.     while(wait_state!=spi_i2s_flag_get(spix->spi_x, flag)){
    

  6.         if((timeout+SPI_TIMEOUT_MS) <= driver_tick) {              
    

  7.             return DRV_ERROR;
    

  8.         } 
    

  9.     }
    

  10.     return DRV_SUCCESS;
    

  11. }
11.4.3 SPI NOR FLASH 接口bsp层函数
操作NOR FLASH的函数都定义在bsp层文件bsp_spi_nor.c中，这个文件中定义的函数都是针对NOR FLASH特性来实现的，我们选取几个函数进行介绍。
1. NOR FLASH按sector擦除函数bsp_spi_nor_sector_erase，该函数流程是：使能NOR FLASH的写功能->拉低片选->向NOR FLASH发送sector擦除指令SE（0x20）->从低地址到高地址发送需要擦除的地址->拉高片选->等待NOR FALSH内部操作完成（循环去读NOR FLASH状态，直到读出编程状态为0）
复制
  1. C
    

  2. void bsp_spi_nor_sector_erase(uint32_t sector_addr)
    

  3. {
    

  4.     /* send write enable instruction */
    

  5.     bsp_spi_nor_write_enable();
    

  6.     /* sector erase */
    

  7.     /* select the flash: chip select low */
    

  8.     bsp_spi_nor_cs_low();
    

  9.     /* send sector erase instruction */
    

  10.     driver_spi_master_transmit_receive_byte(&BOARD_SPI,SE);
    

  11.     /* send sector_addr high nibble address byte */
    

  12.     driver_spi_master_transmit_receive_byte(&BOARD_SPI,(sector_addr & 0xFF0000) >> 16);
    

  13.     /* send sector_addr medium nibble address byte */
    

  14.     driver_spi_master_transmit_receive_byte(&BOARD_SPI,(sector_addr & 0xFF00) >> 8);
    

  15.     /* send sector_addr low nibble address byte */
    

  16.     driver_spi_master_transmit_receive_byte(&BOARD_SPI,sector_addr & 0xFF);
    

  17.     /* deselect the flash: chip select high */
    

  18.     bsp_spi_nor_cs_high();
    


  19. 

  20.     /* wait the end of flash writing */
    

  21.     bsp_spi_nor_wait_for_write_end();
    

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

  2. void bsp_spi_nor_page_write(uint8_t* pbuffer, uint32_t write_addr, uint16_t num_byte_to_write)
    

  3. {
    

  4.     /* enable the write access to the flash */
    

  5.     bsp_spi_nor_write_enable();
    


  6. 

  7.     /* select the flash: chip select low */
    

  8.     bsp_spi_nor_cs_low();
    


  9. 

  10.     /* send "write to memory" instruction */
    

  11.     driver_spi_master_transmit_receive_byte(&BOARD_SPI,WRITE);
    

  12.     /* send write_addr high nibble address byte to write to */
    

  13.     driver_spi_master_transmit_receive_byte(&BOARD_SPI,(write_addr & 0xFF0000) >> 16);
    

  14.     /* send write_addr medium nibble address byte to write to */
    

  15.     driver_spi_master_transmit_receive_byte(&BOARD_SPI,(write_addr & 0xFF00) >> 8);
    

  16.     /* send write_addr low nibble address byte to write to */
    

  17.     driver_spi_master_transmit_receive_byte(&BOARD_SPI,write_addr & 0xFF);
    


  18. 

  19.     /* while there is data to be written on the flash */
    

  20.     while(num_byte_to_write--){
    

  21.         /* send the current byte */
    

  22.         driver_spi_master_transmit_receive_byte(&BOARD_SPI,*pbuffer);
    

  23.         /* point on the next byte to be written */
    

  24.         pbuffer++;
    

  25.     }
    


  26. 

  27.     /* deselect the flash: chip select high */
    

  28.     bsp_spi_nor_cs_high();
    


  29. 

  30.     /* wait the end of flash writing */
    

  31.     bsp_spi_nor_wait_for_write_end();
    

  32. }
3. 按buffer写数据函数bsp_spi_nor_buffer_write，该函数实现任意长度数据写入，使用page写函数搭配算法，可以跨page进行写数据：
复制
  1. C
    

  2. void bsp_spi_nor_buffer_write(uint8_t* pbuffer, uint32_t write_addr, uint16_t num_byte_to_write)
    

  3. {
    

  4.     uint8_t num_of_page = 0, num_of_single = 0, addr = 0, count = 0, temp = 0;
    


  5. 

  6.     addr          = write_addr % SPI_FLASH_PAGE_SIZE;
    

  7.     count         = SPI_FLASH_PAGE_SIZE - addr;
    

  8.     num_of_page   = num_byte_to_write / SPI_FLASH_PAGE_SIZE;
    

  9.     num_of_single = num_byte_to_write % SPI_FLASH_PAGE_SIZE;
    


  10. 

  11.      /* write_addr is SPI_FLASH_PAGE_SIZE aligned  */
    

  12.     if(0 == addr){
    

  13.         /* num_byte_to_write < SPI_FLASH_PAGE_SIZE */
    

  14.         if(0 == num_of_page)
    

  15.             bsp_spi_nor_page_write(pbuffer,write_addr,num_byte_to_write);
    

  16.         /* num_byte_to_write > SPI_FLASH_PAGE_SIZE */
    

  17.         else{
    

  18.             while(num_of_page--){
    

  19.                 bsp_spi_nor_page_write(pbuffer,write_addr,SPI_FLASH_PAGE_SIZE);
    

  20.                 write_addr += SPI_FLASH_PAGE_SIZE;
    

  21.                 pbuffer += SPI_FLASH_PAGE_SIZE;
    

  22.             }
    

  23.             bsp_spi_nor_page_write(pbuffer,write_addr,num_of_single);
    

  24.         }
    

  25.     }else{
    

  26.         /* write_addr is not SPI_FLASH_PAGE_SIZE aligned  */
    

  27.         if(0 == num_of_page){
    

  28.             /* (num_byte_to_write + write_addr) > SPI_FLASH_PAGE_SIZE */
    

  29.             if(num_of_single > count){
    

  30.                 temp = num_of_single - count;
    

  31.                 bsp_spi_nor_page_write(pbuffer,write_addr,count);
    

  32.                 write_addr += count;
    

  33.                 pbuffer += count;
    

  34.                 bsp_spi_nor_page_write(pbuffer,write_addr,temp);
    

  35.             }else
    

  36.                 bsp_spi_nor_page_write(pbuffer,write_addr,num_byte_to_write);
    

  37.         }else{
    

  38.             /* num_byte_to_write > SPI_FLASH_PAGE_SIZE */
    

  39.             num_byte_to_write -= count;
    

  40.             num_of_page = num_byte_to_write / SPI_FLASH_PAGE_SIZE;
    

  41.             num_of_single = num_byte_to_write % SPI_FLASH_PAGE_SIZE;
    


  42. 

  43.             bsp_spi_nor_page_write(pbuffer,write_addr, count);
    

  44.             write_addr += count;
    

  45.             pbuffer += count;
    


  46. 

  47.             while(num_of_page--){
    

  48.                 bsp_spi_nor_page_write(pbuffer,write_addr,SPI_FLASH_PAGE_SIZE);
    

  49.                 write_addr += SPI_FLASH_PAGE_SIZE;
    

  50.                 pbuffer += SPI_FLASH_PAGE_SIZE;
    

  51.             }
    


  52. 

  53.             if(0 != num_of_single)
    

  54.                 bsp_spi_nor_page_write(pbuffer,write_addr,num_of_single);
    

  55.         }
    

  56.     }
    

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

  2. void bsp_spi_nor_buffer_read(uint8_t* pbuffer, uint32_t read_addr, uint16_t num_byte_to_read)
    

  3. {
    

  4.     /* select the flash: chip slect low */
    

  5.     bsp_spi_nor_cs_low();
    


  6. 

  7.     /* send "read from memory " instruction */
    

  8.     driver_spi_master_transmit_receive_byte(&BOARD_SPI,READ);
    


  9. 

  10.     /* send read_addr high nibble address byte to read from */
    

  11.     driver_spi_master_transmit_receive_byte(&BOARD_SPI,(read_addr & 0xFF0000) >> 16);
    

  12.     /* send read_addr medium nibble address byte to read from */
    

  13.     driver_spi_master_transmit_receive_byte(&BOARD_SPI,(read_addr& 0xFF00) >> 8);
    

  14.     /* send read_addr low nibble address byte to read from */
    

  15.     driver_spi_master_transmit_receive_byte(&BOARD_SPI,read_addr & 0xFF);
    


  16. 

  17.     /* while there is data to be read */
    

  18.     while(num_byte_to_read--){
    

  19.         /* read a byte from the flash */
    

  20.         *pbuffer = driver_spi_master_transmit_receive_byte(&BOARD_SPI,NOR_DUMMY_BYTE);
    

  21.         /* point to the next location where the byte read will be saved */
    

  22.         pbuffer++;
    

  23.     }
    


  24. 

  25.     /* deselect the flash: chip select high */
    

  26.     bsp_spi_nor_cs_high();
    

  27. }
11.4.4 main函数实现
以下为main函数代码：
复制
  1. C
    

  2. int main(void)
    

  3. {
    

  4.     //延时、共用驱动部分初始化 
    

  5.     driver_init();
    

  6.           
    

  7.     //初始化LED组和默认状态
    

  8.     bsp_led_group_init();
    

  9.     bsp_led_on(&LED1);
    

  10.     bsp_led_off(&LED2);     
    


  11. 

  12.     //初始化UART打印
    

  13.     bsp_uart_init(&BOARD_UART);
    


  14. 

  15.     //初始化SPI    
    

  16.     bsp_spi_init(&BOARD_SPI);
    

  17.   
    

  18.     //初始化SPI NOR     
    

  19.     bsp_spi_nor_init();
    

  20.   
    

  21.     printf_log("\n\rSPI Flash:GD25Q configured...\n\r");
    


  22. 

  23.     //读取flash id
    

  24.     flash_id = bsp_spi_nor_read_id();
    

  25.     printf_log("\n\rThe Flash_ID:0x%X\n\r",flash_id);
    


  26. 

  27.     //比对flash id是否一致
    

  28.     if(SFLASH_4B_ID == flash_id || SFLASH_16B_ID == flash_id)
    

  29.     {
    

  30.         printf_log("\n\rWrite to tx_buffer:\n\r");
    


  31. 

  32.         //准备数据
    

  33.         for(uint16_t i = 0; i < BUFFER_SIZE; i++){
    

  34.             tx_buffer[i] = i;
    

  35.             printf_log("0x%02X ",tx_buffer[i]);
    

  36.             if(15 == i%16){
    

  37.                 printf_log("\n\r");
    

  38.             }
    

  39.         }
    

  40.         printf_log("\n\r");
    

  41.         printf_log("\n\rRead from rx_buffer:\n\r");
    

  42.         
    

  43.         //擦除要写入的sector
    

  44.         bsp_spi_nor_sector_erase(FLASH_WRITE_ADDRESS);
    

  45.         //写入数据 
    

  46.         bsp_spi_nor_buffer_write(tx_buffer,FLASH_WRITE_ADDRESS,TX_BUFFER_SIZE);
    


  47. 

  48.         //延时等待写完成
    

  49.         delay_ms(10);
    


  50. 

  51.         //回读写入数据
    

  52.         bsp_spi_nor_buffer_read(rx_buffer,FLASH_READ_ADDRESS,RX_BUFFER_SIZE);
    

  53.         
    

  54.         /* printf_log rx_buffer value */
    

  55.         for(uint16_t i = 0; i < BUFFER_SIZE; i++){
    

  56.             printf_log("0x%02X ", rx_buffer[i]);
    

  57.             if(15 == i%16){
    

  58.                 printf_log("\n\r");
    

  59.             }
    

  60.         }
    

  61.         printf_log("\n\r");
    

  62.         //比较回读和写入数据
    

  63.         if(ERROR == memory_compare(tx_buffer,rx_buffer,BUFFER_SIZE)){
    

  64.             printf_log("Err:Data Read and Write aren't Matching.\n\r");            
    

  65.             //写入错误
    

  66.             /* turn off all leds */
    

  67.             bsp_led_on(&LED2);
    

  68.             /* turn off all leds */
    

  69.             bsp_led_on(&LED1);           
    

  70.             while(1);
    

  71.         }else{
    

  72.             printf_log("\n\rSPI-GD25Q16 Test Passed!\n\r");
    

  73.         }
    

  74.     }else{ //ID读取错误
    

  75.         /* spi flash read id fail */
    

  76.         printf_log("\n\rSPI Flash: Read ID Fail!\n\r");
    

  77.         /* turn off all leds */
    

  78.         bsp_led_on(&LED2);
    

  79.         /* turn off all leds */
    

  80.         bsp_led_on(&LED1);           
    

  81.         while(1);
    

  82.     }
    


  83. 

  84.     while(1){
    

  85.         /* turn off all leds */
    

  86.         bsp_led_toggle(&LED2);
    

  87.         /* turn off all leds */
    

  88.         bsp_led_toggle(&LED1);        
    

  89.         delay_ms(200);
    

  90.     }
    

  91. }
main函数中实现了向特定NOR FLASH地址写数据，并回读出来，并将写入的数据和回读出来的数据进行对比，看是否写入成功。
11.5 实验结果
将本实验例程烧录到GD32H757紫海棠派开发板中，将会显示对外部SPI flash写入以及读取的数据以及最终的校验结果，如果写入读取校验正确，将会显示SPI-GD25QXX Test Passed，LED1和LED2将会交替闪烁。

本教程由GD32 MCU方案商聚沃科技原创发布，了解更多GD32 MCU教程，关注聚沃科技官网，GD32MCU技术交流群：859440462



图片13.png
回复

收藏 举报

相关帖子
chenjun89 发表于 2024-6-5 08:09 来自手机 | 显示全部楼层
QSPI接口的NOR FLASH通信速度更快
回复

收藏 举报

返回列表 发新帖
高级模式
B Color Image Link Quote Code Smilies
您需要登录后才可以回帖 登录 | 注册

本版积分规则

聚沃科技

170

主题

190

帖子

13

粉丝
快速回复 在线客服 返回列表 返回顶部