[研电赛技术支持] 【GD32F303红枫派使用手册】第十九讲 SPI-SPI NOR FLASH读写实验

[复制链接]
4477|1
 楼主| 聚沃科技 发表于 2024-6-19 10:00 | 显示全部楼层 |阅读模式
红枫派首图.png
19.1 实验内容
通过本实验主要学习以下内容:
• SPI简介
• GD32F303 SPI简介
• SPI NOR FLASH——GD25Q32ESIGR简介
使用GD32F303 SPI接口实现对GD25Q32ESIGR的读写操作
19.2 实验原理
19.2.1 SPI简介
SPISerial Peripheral interface),顾名思义是串行外设接口,和UART不同的是,SPI是同步通讯接口,所以带有时钟线,而UART是异步通讯接口,不需要时钟线。
SPI通常使用4根线,分别为SCKMOSIMISONSSCS):
• SCK:串列时脉,由主机发出
• MOSI:主机输出从机输入信号(数据由主机发出)
• MISO:主机输入从机输出信号(数据由从机发出)
• NSS:片选信号,由主机发出,一般是低电位有效
SPI默认为全双工工作,在这种工作模式下,主机通过MOSI线发送数据的同时,也在MISO线上接受数据,简单来说就是主机和从机之间进行数据交换。
SPI是一个可以实现一主多从的通讯接口,从机的片选由主机NSS脚来控制:
图片1.png
每个通讯时刻,只有一个从机NSS被主机选中,选中方式为主机拉低响应的NSSCS)脚。
SPI的数据线只有一条(虽然有MOSIMISO,但实际上每个CLK主机都只能发送和接受一个bit),所以称之为单线SPI。从SPI衍生出来的还有4线制SPIQSPI)和8线制SPIOSPI)以及其他多线制SPI,这个我们后面具体再聊。
19.2.2 GD32F303 SPI简介
GD32F303的主要特性如下:
具有全双工和单工模式的主从操作;
◼ 16位宽度,独立的发送和接收缓冲区;
◼ 8位或16位数据帧格式;
低位在前或高位在前的数据位顺序;
软件和硬件NSS管理;
硬件CRC计算、发送和校验;
发送和接收支持DMA模式;
支持SPI TI模式;
支持SPI NSS脉冲模式
支持SPI四线功能的主机模式(仅在SPI0中)   
以下为GD32F303 SPI的框图:
图片2.png
我们可以看到GD32F303有一个发送缓冲区和一个接受缓冲区这两个缓冲区都对应的是SPI_DATA寄存器,向SPI_DATA寄存器写数据将会把数据存入发送缓冲区,从SPI_DATA读数据,将从接受缓冲区获得数据。GD32F303还有一个移位寄存器,当主机发送缓冲区被写入数据时,数据将立刻转移到移位寄存器,移位寄存器通过 MOSI 信号线将字节传送给从机,从机也将自己的移位寄存器中的内容通过 MISO 信号线返回给主机。这样,两个移位寄存器中的内容就被交换。外设的写操作和读操作是同步完成的。如果只进行写操作,主机只需忽略接收到的字节;反之,若主机要读取从机的一个字节,就必须发送一个空字节来引发从机的传输。
SPI数据bitCLK的有效边沿被锁存,而有效边沿是可以选择的,分别为:
第一个上升沿
第一个下降沿
第二个下降沿
第二个上升沿
通过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的时序图:
图片3.png
4线SPIQSPI)的时序图如下(CKPL=1, CKPH=1, LF=0)  ,我们可以看到QSPI是通过MOSIMISOIO2IO3来进行数据收或发,所以QSPI是工作在半双工模式:
图片4.png
这里再介绍下SPINSS(片选)功能。NSS电平由主机来控制,主机将需要操作的从机NSS拉低,从而使该从机在总线上生效。
主机控制NSS的方式有两种——硬件方式和软件方式。主机硬件NSS模式下,NSS脚只能选择特定IO口(具体见datasheetIO口功能表),当开始进行数据读写时,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(发送缓冲区空) 位置 1TBE 标志位置 1, 说明发送缓冲区为空, 此时如果需要发送更多数据, 软件应该继续写 SPI_DATA 寄存器。在主机模式下, 若想要实现连续发送功能, 那么在当前数据帧发送完成前, 软件应该将下一个数据写入 SPI_DATA 寄存器中。  
接收流程
在最后一个采样时钟边沿之后, 接收到的数据将从移位寄存器存入到接收缓冲区, RBNE(接收缓冲区非空) 位置 1。软件通过读 SPI_DATA 寄存器获得接收的数据, 此操作会自动清除RBNE 标志位。   
19.2.3 SPI FLASH——GD25Q32ESIGR简介
GD25Q32ESIGR是一款容量为32Mbit(即4Mbyte)的SPI接口的NOR FLASH,其支持SPIQSPI模式,芯片示意图如下:
图片5.png
GD25Q32ESIGR管脚定义如下:
图片6.png
GD25Q32ESIGR内部flash结构如下:
图片7.png
下面介绍GD25Q32ESIGR的一些功能码。
Write Enable (WREN) (06H) :接受到该命令后,GD25Q32ESIGR做好接受数据并进行存储的准备,时序如下:
图片8.png
Read Status Register (RDSR) (05H or 35H or 15H)  :读GD25Q32ESIGR的状态,时序如下:
图片9.png
Read Data Bytes (READ) (03H)  :接受到该命令后,GD25Q32ESIGR将数据准备好供主机读走,时序如下:
图片10.png
Dual Output Fast Read (3BH)  :使GD25Q32ESIGR切换到QSPI模式,时序如下:
图片11.png
Quad Output Fast Read (6BH)  QSPI读命令,时序如下:
图片12.png
Quad Page Program (32H)   QSPI写命令,时序如下:
图片13.png
Sector Erase (SE) (20H)  Sector擦除命令,时序如下:
图片14.png
GD25Q32ESIGR就介绍到这里,读者可以在兆易创新官网下载该NOR FLASHdatasheet以获取更多信息。
19.3 硬件设计
红枫派开发板SPI——NOR FLASH的硬件设计如下:
图片15.png
图片16.png
从图中可以看出,本实验使用的是普通单线SPIGD25Q32ESIGR的片选由GD32F303ZET6PG14控制(因PG14不是SPINSS管脚,所以本实验用主机NSS软件模式),GD25Q32ESIGRSOSISCLK分别和GD32F303ZET6PB4SPI2_MISO)、PB5SPI2_MOSI)以及PB3SPI2_CLK)相连。
19.4 代码解析
19.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.     driver_gpio_general_init(spix->spi_cs_gpio);   
  9.     driver_gpio_general_init(spix->spi_sck_gpio);
  10.     driver_gpio_general_init(spix->spi_mosi_gpio);
  11.     driver_gpio_general_init(spix->spi_miso_gpio);        
  12.     if(spix->spi_mode==MODE_DMA)
  13.     {
  14.         if(spix->spi_rx_dma!=NULL)
  15.         {
  16.             if(spix->frame_size==SPI_FRAMESIZE_8BIT)
  17.             {
  18.                 driver_dma_com_init(spix->spi_rx_dma,(uint32_t)&SPI_DATA(spix->spi_x),NULL,DMA_Width_8BIT,DMA_PERIPHERAL_TO_MEMORY);
  19.             }
  20.             else
  21.             {
  22.                 driver_dma_com_init(spix->spi_rx_dma,(uint32_t)&SPI_DATA(spix->spi_x),NULL,DMA_Width_16BIT,DMA_PERIPHERAL_TO_MEMORY);
  23.             }     
  24.             if(spix->spi_tx_dma!=NULL)
  25.             {
  26.                 if(spix->frame_size==SPI_FRAMESIZE_8BIT)
  27.                 {
  28.                     driver_dma_com_init(spix->spi_tx_dma,(uint32_t)&SPI_DATA(spix->spi_x),NULL,DMA_Width_8BIT,DMA_MEMORY_TO_PERIPHERAL);
  29.                 }
  30.                 else
  31.                 {
  32.                     driver_dma_com_init(spix->spi_tx_dma,(uint32_t)&SPI_DATA(spix->spi_x),NULL,DMA_Width_16BIT,DMA_MEMORY_TO_PERIPHERAL);
  33.                 }            
  34.             }            
  35.           }
  36.     }
  37.    
  38.     if(spix->spi_cs_gpio!=NULL)
  39.     {
  40.         driver_gpio_pin_set(spix->spi_cs_gpio);
  41.     }
  42.    
  43.     spi_struct_para_init(&spi_init_struct);
  44.     spi_init_struct.trans_mode = SPI_TRANSMODE_FULLDUPLEX;
  45.     spi_init_struct.device_mode = spix->device_mode;
  46.     spi_init_struct.frame_size = spix->frame_size;
  47.     spi_init_struct.clock_polarity_phase = spix->clock_polarity_phase;
  48.     if(spix->device_mode==SPI_MASTER){
  49.         spi_init_struct.nss = SPI_NSS_SOFT;
  50.     }else{
  51.         spi_init_struct.nss = SPI_NSS_HARD;        
  52.     }
  53.     spi_init_struct.prescale = spix->prescale;
  54.     spi_init_struct.endian = spix->endian;
  55.     spi_init(spix->spi_x, &spi_init_struct);
  56.     spi_enable(spix->spi_x);
  57. }
19.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.     SPI_DATA(spix->spi_x);
  5.     SPI_STAT(spix->spi_x);      
  6.     driver_spi_flag_wait_timeout(spix,SPI_FLAG_TBE,SET);
  7.     spi_i2s_data_transmit(spix->spi_x,byte);
  8.     DRV_ERROR==driver_spi_flag_wait_timeout(spix,SPI_FLAG_RBNE,SET);
  9.     return spi_i2s_data_receive(spix->spi_x);               
  10. }
上面函数中有带超时功能的等待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.     uint32_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. }
19.4.3 SPI NOR FLASH 接口bsp层函数
操作NOR FLASH的函数都定义在bsp层文件bsp_spi_nor.c中,这个文件中定义的函数都是针对NOR FLASH特性来实现的,我们选取几个函数进行介绍。
1. NOR FLASHsector擦除函数bsp_spi_nor_sector_erase,该函数流程是:使能NOR FLASH的写功能->拉低片选->NOR FLASH发送sector擦除指令SE0x20->从低地址到高地址发送需要擦除的地址->拉高片选->等待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.     /* wait the end of flash writing */
  20.     bsp_spi_nor_wait_for_write_end();
  21. }
2. page写数据函数bsp_spi_nor_page_write,该函数实现在page范围内写数据,该函数流程是:使能NOR FLASH的写功能->拉低片选->NOR FLASH发送写指令WRITE0x02->从低地址到高地址发送要写的地址(每次进行写数据时,只需要给初始地址即可,写完一个数据后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.     /* select the flash: chip select low */
  7.     bsp_spi_nor_cs_low();

  8.     /* send "write to memory" instruction */
  9.     driver_spi_master_transmit_receive_byte(&BOARD_SPI,WRITE);
  10.     /* send write_addr high nibble address byte to write to */
  11.     driver_spi_master_transmit_receive_byte(&BOARD_SPI,(write_addr & 0xFF0000) >> 16);
  12.     /* send write_addr medium nibble address byte to write to */
  13.     driver_spi_master_transmit_receive_byte(&BOARD_SPI,(write_addr & 0xFF00) >> 8);
  14.     /* send write_addr low nibble address byte to write to */
  15.     driver_spi_master_transmit_receive_byte(&BOARD_SPI,write_addr & 0xFF);

  16.     /* while there is data to be written on the flash */
  17.     while(num_byte_to_write--){
  18.         /* send the current byte */
  19.         driver_spi_master_transmit_receive_byte(&BOARD_SPI,*pbuffer);
  20.         /* point on the next byte to be written */
  21.         pbuffer++;
  22.     }

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

  25.     /* wait the end of flash writing */
  26.     bsp_spi_nor_wait_for_write_end();
  27. }
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.     addr          = write_addr % SPI_FLASH_PAGE_SIZE;
  6.     count         = SPI_FLASH_PAGE_SIZE - addr;
  7.     num_of_page   = num_byte_to_write / SPI_FLASH_PAGE_SIZE;
  8.     num_of_single = num_byte_to_write % SPI_FLASH_PAGE_SIZE;

  9.      /* write_addr is SPI_FLASH_PAGE_SIZE aligned  */
  10.     if(0 == addr){
  11.         /* num_byte_to_write < SPI_FLASH_PAGE_SIZE */
  12.         if(0 == num_of_page)
  13.             bsp_spi_nor_page_write(pbuffer,write_addr,num_byte_to_write);
  14.         /* num_byte_to_write > SPI_FLASH_PAGE_SIZE */
  15.         else{
  16.             while(num_of_page--){
  17.                 bsp_spi_nor_page_write(pbuffer,write_addr,SPI_FLASH_PAGE_SIZE);
  18.                 write_addr += SPI_FLASH_PAGE_SIZE;
  19.                 pbuffer += SPI_FLASH_PAGE_SIZE;
  20.             }
  21.             bsp_spi_nor_page_write(pbuffer,write_addr,num_of_single);
  22.         }
  23.     }else{
  24.         /* write_addr is not SPI_FLASH_PAGE_SIZE aligned  */
  25.         if(0 == num_of_page){
  26.             /* (num_byte_to_write + write_addr) > SPI_FLASH_PAGE_SIZE */
  27.             if(num_of_single > count){
  28.                 temp = num_of_single - count;
  29.                 bsp_spi_nor_page_write(pbuffer,write_addr,count);
  30.                 write_addr += count;
  31.                 pbuffer += count;
  32.                 bsp_spi_nor_page_write(pbuffer,write_addr,temp);
  33.             }else
  34.                 bsp_spi_nor_page_write(pbuffer,write_addr,num_byte_to_write);
  35.         }else{
  36.             /* num_byte_to_write > SPI_FLASH_PAGE_SIZE */
  37.             num_byte_to_write -= count;
  38.             num_of_page = num_byte_to_write / SPI_FLASH_PAGE_SIZE;
  39.             num_of_single = num_byte_to_write % SPI_FLASH_PAGE_SIZE;

  40.             bsp_spi_nor_page_write(pbuffer,write_addr, count);
  41.             write_addr += count;
  42.             pbuffer += count;

  43.             while(num_of_page--){
  44.                 bsp_spi_nor_page_write(pbuffer,write_addr,SPI_FLASH_PAGE_SIZE);
  45.                 write_addr += SPI_FLASH_PAGE_SIZE;
  46.                 pbuffer += SPI_FLASH_PAGE_SIZE;
  47.             }

  48.             if(0 != num_of_single)
  49.                 bsp_spi_nor_page_write(pbuffer,write_addr,num_of_single);
  50.         }
  51.     }
  52. }
4. buffer读数据函数bsp_spi_nor_buffer_read,该函数实现任意地址读数据,该函数流程是:拉低片选->NOR FLASH发送读指令READ0x03->从低地址到高地址发送要读的地址(每次进行读数据时,只需要给初始地址即可,读完一个数据后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.     /* send "read from memory " instruction */
  7.     driver_spi_master_transmit_receive_byte(&BOARD_SPI,READ);

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

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

  21.     /* deselect the flash: chip select high */
  22.     bsp_spi_nor_cs_high();
  23. }
19.4.4 main函数实现
以下为main函数代码:
  1. C
  2. int main(void)
  3. {
  4.     //延时、共用驱动部分初始化
  5.     driver_init();         
  6.     //初始化LED组和默认状态
  7.     bsp_led_group_init();
  8.     bsp_led_on(&LED0);
  9.     bsp_led_off(&LED1);     
  10.     //初始化UART打印
  11.     bsp_uart_init(&BOARD_UART);
  12.     //初始化SPI   
  13.     bsp_spi_init(&BOARD_SPI);  
  14.     //初始化SPI NOR     
  15.     bsp_spi_nor_init();  
  16.     printf("\n\rSPI Flash:GD25Q32E configured...\n\r");
  17.     //读取flash id
  18.     flash_id = bsp_spi_nor_read_id();
  19.     printf("\n\rThe Flash_ID:0x%X\n\r",flash_id);
  20.     //比对flash id是否一致
  21.     if(SFLASH_ID == flash_id)
  22.         {
  23.         printf("\n\r\n\rWrite to tx_buffer:\n\r\n\r");
  24.         //准备数据
  25.         for(uint16_t i = 0; i < BUFFER_SIZE; i ++){
  26.             tx_buffer[i] = i;
  27.             printf("0x%02X ",tx_buffer[i]);
  28.             if(15 == i%16)
  29.                 printf("\n\r");
  30.         }

  31.         printf("\n\r\n\rRead from rx_buffer:\n\r");        
  32.         //擦除要写入的sector
  33.         bsp_spi_nor_sector_erase(FLASH_WRITE_ADDRESS);
  34.         //写入数据
  35.         bsp_spi_nor_buffer_write(tx_buffer,FLASH_WRITE_ADDRESS,TX_BUFFER_SIZE);
  36.         //延时等待写完成
  37.         delay_ms(10);
  38.         //回读写入数据
  39.         bsp_spi_nor_buffer_read(rx_buffer,FLASH_READ_ADDRESS,RX_BUFFER_SIZE);        
  40.         /* printf rx_buffer value */
  41.         for(uint16_t i = 0; i <= 255; i ++){
  42.             printf("0x%02X ", rx_buffer[i]);
  43.             if(15 == i%16)
  44.                 printf("\n\r");
  45.         }
  46.         //比较回读和写入数据
  47.         if(ERROR == memory_compare(tx_buffer,rx_buffer,256)){
  48.             printf("Err:Data Read and Write aren't Matching.\n\r");
  49.             /* spi flash read id fail */
  50.             printf("\n\rSPI Flash: Read ID Fail!\n\r");
  51.             
  52.             //写入错误
  53.             /* turn off all leds */
  54.             bsp_led_on(&LED0);
  55.             /* turn off all leds */
  56.             bsp_led_on(&LED1);           
  57.             while(1);
  58.         }else{
  59.             printf("\n\rSPI-GD25Q16 Test Passed!\n\r");
  60.         }
  61.     }else{ //ID读取错误
  62.         /* spi flash read id fail */
  63.         printf("\n\rSPI Flash: Read ID Fail!\n\r");
  64.         /* turn off all leds */
  65.         bsp_led_on(&LED0);
  66.         /* turn off all leds */
  67.         bsp_led_on(&LED1);           
  68.         while(1);
  69.     }

  70.     while(1){
  71.         /* turn off all leds */
  72.         bsp_led_toggle(&LED0);
  73.         /* turn off all leds */
  74.         bsp_led_toggle(&LED1);        
  75.         delay_ms(200);
  76.     }
  77. }
main函数中实现了向特定NOR FLASH地址写数据,并回读出来,并将写入的数据和回读出来的数据进行对比,看是否写入成功。
19.5 实验结果
使用USB-TypeC线,连接电脑和板上USB to UART口后,配置好串口调试助手,即可看到MCUSPI NOR flash的擦写读过程。
图片17.png

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


yangxiaor520 发表于 2024-6-19 18:27 来自手机 | 显示全部楼层
之前那个紫藤派是什么关系?
您需要登录后才可以回帖 登录 | 注册

本版积分规则

170

主题

190

帖子

13

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