SPI on CLing

PUYA SPI — 全双工主机（DMA）（HAL 库）

Tue, 08 Sep 2026 14:52:21 +0800

SPI — 全双工主机（DMA）（HAL 库）

固件库: PY32F0xx_Firmware V1.5.0
芯片: PY32F030
源文件: PUYA/PY32F0xx_Firmware_V1.5.0/Projects/PY32F030-STK/Example/SPI/SPI_TwoBoards_FullDuplexMaster_DMA/Src/main.c

功能简介

SPI（Serial Peripheral Interface）是一种四线制、全双工、同步串行总线，速率远高于 I2C，常用于 LCD、Flash、ADC、无线通信模块等。

本示例演示 SPI1 主机 + DMA 全双工通信：

主机通过 HAL_SPI_TransmitReceive_DMA() 同时收发 15 字节；
数据搬运由 DMA 完成，CPU 在传输期间可腾出手做别的事；
传输完成后回调函数里校验收发是否一致，一致则点亮绿灯。
本工程仅提供主机（Master DMA）示例；同目录另有时钟/引脚由 HAL_SPI_MspInit 配置（在 py32f0xx_hal_msp.c 中绑定 SPI1 引脚与 DMA 通道）。

说明：PY32F0xx V1.5.0 的 STK 示例里 SPI 全双工只提供了 DMA 版（无纯轮询版）。若想用轮询，可把 HAL_SPI_TransmitReceive_DMA 换成 HAL_SPI_TransmitReceive（轮询版 API 同样存在），二者配置完全一致。

硬件准备

两块 PY32F030 开发板（一主一从），或用一块板把 MOSI↔MISO 短接做回环
交叉连接：主 MOSI↔从 MOSI，主 MISO↔从 MISO，主 SCK↔从 SCK，主 NSS↔从 NSS，共地
板载 LED / 按键用于交互（示例需按键触发一次传输）

完整代码（主机部分）

#include "main.h"

#define DATA_LENGTH 15

SPI_HandleTypeDef Spi1Handle;
uint8_t TxBuff[15] = {1,2,3,4,5,6,7,8,9,10,11,12,13,14,15};
uint8_t RxBuff[15] = {0};
DMA_HandleTypeDef HdmaCh1;   /* 发送 DMA 通道 */
DMA_HandleTypeDef HdmaCh2;   /* 接收 DMA 通道 */

int main(void)
{
  HAL_Init();
  APP_SystemClockConfig();    /* 配置系统时钟（HSI 8MHz） */

  BSP_LED_Init(LED_GREEN);
  BSP_PB_Init(BUTTON_KEY, BUTTON_MODE_GPIO);

  /* SPI1 参数配置 */
  Spi1Handle.Instance               = SPI1;
  Spi1Handle.Init.BaudRatePrescaler = SPI_BAUDRATEPRESCALER_256; /* 波特率预分频 256 */
  Spi1Handle.Init.Direction         = SPI_DIRECTION_2LINES;      /* 全双工（2 线） */
  Spi1Handle.Init.CLKPolarity       = SPI_POLARITY_LOW;          /* 时钟极性：空闲低 */
  Spi1Handle.Init.CLKPhase          = SPI_PHASE_1EDGE;           /* 第 1 个边沿采样 */
  Spi1Handle.Init.DataSize          = SPI_DATASIZE_8BIT;         /* 8 位数据 */
  Spi1Handle.Init.FirstBit          = SPI_FIRSTBIT_MSB;          /* 高位先发 */
  Spi1Handle.Init.NSS               = SPI_NSS_HARD_OUTPUT;       /* NSS 硬件输出（主机自动拉低） */
  Spi1Handle.Init.Mode              = SPI_MODE_MASTER;           /* 主机模式 */
  if (HAL_SPI_DeInit(&Spi1Handle) != HAL_OK) APP_ErrorHandler();
  if (HAL_SPI_Init(&Spi1Handle) != HAL_OK)   APP_ErrorHandler();

  /* 等按键按下，启动一次全双工收发（DMA 方式） */
  while (BSP_PB_GetState(BUTTON_KEY) == 1) {}
  if (HAL_SPI_TransmitReceive_DMA(&Spi1Handle, (uint8_t*)TxBuff,
                                  (uint8_t*)RxBuff, DATA_LENGTH) != HAL_OK)
  {
    APP_ErrorHandler();
  }

  APP_WaitAndCheckEndOfTransfer();  /* 等传输完成并校验 */

  while (1) {}
}

/* 等待 SPI 回到 READY，再比较收发缓冲 */
static void APP_WaitAndCheckEndOfTransfer(void)
{
  while (Spi1Handle.State != HAL_SPI_STATE_READY) {}
  if (APP_Buffercmp8((uint8_t*)TxBuff, (uint8_t*)RxBuff, DATA_LENGTH))
    APP_LedBlinking();   /* 不一致：闪烁报警 */
  else
    BSP_LED_On(LED_GREEN); /* 一致：绿灯常亮 */
}

代码分段讲解

1. 时钟极性 / 相位（CPOL / CPHA）

SPI 通信双方必须 CPOL、CPHA 一致，否则收到的是错位数据：

本例 CPOL=LOW, CPHA=1EDGE 对应 Mode 0（常用默认）。
四种组合：Mode0(0,0)、Mode1(0,1)、Mode2(1,0)、Mode3(1,1)，按从设备手册选择。

2. 全双工本质

SPI 移位寄存器决定了“发的同时也在收”。HAL_SPI_TransmitReceive 把 TxBuff 逐位发出，同时把 MISO 上的数据逐位存入 RxBuff。回环（MOSI 接 MISO）时，发什么就收到什么，便于自测。

3. DMA vs 轮询

DMA 版：HAL_SPI_TransmitReceive_DMA 启动后由 DMA 控制器搬运数据，CPU 立刻返回，可在回调/状态查询里做别的事，适合大数据量。
轮询版：把上面函数换成 HAL_SPI_TransmitReceive(&Spi1Handle, Tx, Rx, len)（阻塞直到完成），代码更短，适合小数据量教学。

4. NSS 片选

本例 SPI_NSS_HARD_OUTPUT：主机 NSS 引脚由硬件自动在传输时拉低、结束后拉高，省去手动控制。若用软件片选，改 SPI_NSS_SOFT 并自行 HAL_GPIO_WritePin(NSS, RESET/SET)。

实验现象

按下用户键后启动一次 15 字节全双工收发；
回环或正确对接从机时，收发一致，绿灯常亮；
数据异常则绿灯 500ms 周期闪烁。

常见问题

收不到数据 / 全是 0xFF？
- 检查 CPOL/CPHA 是否与从机一致。
- 确认接线：MOSI-MOSI、MISO-MISO、SCK-SCK、NSS-NSS，并共地。
- 波特率（BaudRatePrescaler）不要超过从机最大 SPI 时钟。
想用轮询版？
- 直接调用 HAL_SPI_TransmitReceive()（不带 _DMA），其余配置不变。
DMA 传输只发不收 / 卡在 BUSY？
- 确认 HAL_SPI_MspInit 中已为 SPI1 的 TX/RX 绑定正确的 DMA 通道并使能 DMA 时钟；传输完成需等 State == HAL_SPI_STATE_READY。

小结

SPI 主机配置要点：波特率分频、CPOL/CPHA、数据位宽、MSB/LSB、NSS 方式、主/从模式。
全双工 = 同时收发；回环自测最方便。
DMA 适合大批量数据，轮询版更简单；两者配置相同，仅启动函数不同。

拓展应用

驱动 SPI Flash（W25Qxx）、LCD（ST7735/ILI9341）、SD 卡（SPI 模式）。
对接 SPI ADC（如 ADS1118）、无线模块（nRF24L01、SX1278）。
改用 SPI_NSS_SOFT 一主多从，用不同 NSS 选片。
把 DMA 版改为中断/DMA 双缓冲，实现连续高速数据流（音频、屏幕刷新）。

AT32 — SPI 总线

Tue, 08 Sep 2026 14:52:21 +0800

AT32 — SPI 总线

固件库: AT32F403A_407_Firmware_Library V2.2.2
示例数: 8

什么是 SPI 总线?

SPI 是高速同步串行接口，支持全双工通信。常用于连接 Flash、LCD、传感器等外设，速度可达几十 MHz。

示例列表

CRC 校验轮询传输 — crc_transfer_polling
全双工 DMA (JTAG 引脚) — fullduplex_dma_jtagpin
全双工轮询通信 — fullduplex_polling
半双工 DMA (JTAG 引脚) — halfduplex_dma_jtagpin
半双工中断 — halfduplex_interrupt
半双工收发切换 — halfduplex_transceiver_switch
只接收模式轮询 — only_receive_mode_polling
W25Q Flash 读写 — w25q_flash

AT32 SPI — CRC 校验轮询传输

Tue, 08 Sep 2026 14:52:21 +0800

SPI — CRC 校验轮询传输

固件库: AT32F403A_407_Firmware_Library V2.2.2
芯片: AT32
源文件: AT32/AT32F403A_407_Firmware_Library_V2.2.2/project/at_start_f403a/examples/spi/crc_transfer_polling/src/main.c

功能简介

本示例演示 SPI 通信中使用 CRC 校验。发送方自动附加 CRC，接收方自动校验，确保数据完整性。

硬件准备

需要主机和从机两块板子，或使用回环连接（MOSI→MISO）

完整代码

#include "at32f403a_407_board.h"
#include "at32f403a_407_clock.h"
#include <stdio.h>
#define SPI_MASTER_CS_HIGH   gpio_bits_set(GPIOA, GPIO_PINS_4)
#define SPI_MASTER_CS_LOW    gpio_bits_reset(GPIOA, GPIO_PINS_4)
#define BUFFER_SIZE          32

static void spi_config(void)
{
  spi_init_type spi_init_struct;
  
  /* master spi initialization */
  crm_periph_clock_enable(CRM_SPI1_PERIPH_CLOCK, TRUE);
  spi_default_para_init(&spi_init_struct);
  
  /* dual line unidirectional full-duplex mode */
  spi_init_struct.transmission_mode = SPI_TRANSMIT_FULL_DUPLEX;
  spi_init_struct.master_slave_mode = SPI_MODE_MASTER;
  spi_init_struct.mclk_freq_division = SPI_MCLK_DIV_8;
  spi_init_struct.first_bit_transmission = SPI_FIRST_BIT_MSB;
  spi_init_struct.frame_bit_num = SPI_FRAME_16BIT;
  spi_init_struct.clock_polarity = SPI_CLOCK_POLARITY_LOW;
  spi_init_struct.clock_phase = SPI_CLOCK_PHASE_2EDGE;
  spi_init_struct.cs_mode_selection = SPI_CS_SOFTWARE_MODE;
  spi_init(SPI1, &spi_init_struct);
  
  /* hardware crc calculation config */
  spi_crc_polynomial_set(SPI1, 7);
  spi_crc_enable(SPI1, TRUE);
  
  spi_enable(SPI1, TRUE);
  
  /* slave spi initialization */
  crm_periph_clock_enable(CRM_SPI2_PERIPH_CLOCK, TRUE);
  
  /* dual line unidirectional full-duplex mode */
  spi_init_struct.transmission_mode = SPI_TRANSMIT_FULL_DUPLEX;
  spi_init_struct.master_slave_mode = SPI_MODE_SLAVE;
  spi_init_struct.mclk_freq_division = SPI_MCLK_DIV_8;
  spi_init_struct.first_bit_transmission = SPI_FIRST_BIT_MSB;
  spi_init_struct.frame_bit_num = SPI_FRAME_16BIT;
  spi_init_struct.clock_polarity = SPI_CLOCK_POLARITY_LOW;
  spi_init_struct.clock_phase = SPI_CLOCK_PHASE_2EDGE;
  spi_init_struct.cs_mode_selection = SPI_CS_HARDWARE_MODE;
  spi_init(SPI2, &spi_init_struct);
  
  /* hardware crc calculation config */
  spi_crc_polynomial_set(SPI2, 7);
  spi_crc_enable(SPI2, TRUE);
  
  spi_enable(SPI2, TRUE);
}

static void gpio_config(void)
{
  gpio_init_type gpio_initstructure;
  crm_periph_clock_enable(CRM_GPIOA_PERIPH_CLOCK, TRUE);
  crm_periph_clock_enable(CRM_GPIOB_PERIPH_CLOCK, TRUE);
  
  /* master spi cs pin */
  gpio_initstructure.gpio_out_type = GPIO_OUTPUT_PUSH_PULL;
  gpio_initstructure.gpio_pull = GPIO_PULL_UP;
  gpio_initstructure.gpio_mode = GPIO_MODE_OUTPUT;
  gpio_initstructure.gpio_drive_strength = GPIO_DRIVE_STRENGTH_STRONGER;
  gpio_initstructure.gpio_pins = GPIO_PINS_4;
  gpio_init(GPIOA, &gpio_initstructure);
  
  /* non communication time: master pull up CS pin release slave */
  SPI_MASTER_CS_HIGH;
  
  /* master spi sck pin */
  gpio_initstructure.gpio_out_type = GPIO_OUTPUT_PUSH_PULL;
  gpio_initstructure.gpio_pull = GPIO_PULL_DOWN;
  gpio_initstructure.gpio_mode = GPIO_MODE_MUX;
  gpio_initstructure.gpio_drive_strength = GPIO_DRIVE_STRENGTH_STRONGER;
  gpio_initstructure.gpio_pins = GPIO_PINS_5;
  gpio_init(GPIOA, &gpio_initstructure);
  
  /* master spi miso pin */
  gpio_initstructure.gpio_out_type = GPIO_OUTPUT_PUSH_PULL;
  gpio_initstructure.gpio_pull = GPIO_PULL_UP;
  gpio_initstructure.gpio_mode = GPIO_MODE_INPUT;
  gpio_initstructure.gpio_drive_strength = GPIO_DRIVE_STRENGTH_STRONGER;
  gpio_initstructure.gpio_pins = GPIO_PINS_6;
  gpio_init(GPIOA, &gpio_initstructure);
  
  /* master spi mosi pin */
  gpio_initstructure.gpio_out_type = GPIO_OUTPUT_PUSH_PULL;
  gpio_initstructure.gpio_pull = GPIO_PULL_UP;
  gpio_initstructure.gpio_mode = GPIO_MODE_MUX;
  gpio_initstructure.gpio_drive_strength = GPIO_DRIVE_STRENGTH_STRONGER;
  gpio_initstructure.gpio_pins = GPIO_PINS_7;
  gpio_init(GPIOA, &gpio_initstructure);
  
  /* slave spi cs pin */
  gpio_initstructure.gpio_out_type = GPIO_OUTPUT_PUSH_PULL;
  gpio_initstructure.gpio_pull = GPIO_PULL_UP;
  gpio_initstructure.gpio_mode = GPIO_MODE_INPUT;
  gpio_initstructure.gpio_drive_strength = GPIO_DRIVE_STRENGTH_STRONGER;
  gpio_initstructure.gpio_pins = GPIO_PINS_12;
  gpio_init(GPIOB, &gpio_initstructure);
  
  /* slave spi sck pin */
  gpio_initstructure.gpio_out_type = GPIO_OUTPUT_PUSH_PULL;
  gpio_initstructure.gpio_pull = GPIO_PULL_DOWN;
  gpio_initstructure.gpio_mode = GPIO_MODE_INPUT;
  gpio_initstructure.gpio_drive_strength = GPIO_DRIVE_STRENGTH_STRONGER;
  gpio_initstructure.gpio_pins = GPIO_PINS_13;
  gpio_init(GPIOB, &gpio_initstructure);
  
  /* slave spi miso pin */
  gpio_initstructure.gpio_out_type = GPIO_OUTPUT_PUSH_PULL;
  gpio_initstructure.gpio_pull = GPIO_PULL_UP;
  gpio_initstructure.gpio_mode = GPIO_MODE_MUX;
  gpio_initstructure.gpio_drive_strength = GPIO_DRIVE_STRENGTH_STRONGER;
  gpio_initstructure.gpio_pins = GPIO_PINS_14;
  gpio_init(GPIOB, &gpio_initstructure);
  
  /* slave spi mosi pin */
  gpio_initstructure.gpio_out_type = GPIO_OUTPUT_PUSH_PULL;
  gpio_initstructure.gpio_pull = GPIO_PULL_UP;
  gpio_initstructure.gpio_mode = GPIO_MODE_INPUT;
  gpio_initstructure.gpio_drive_strength = GPIO_DRIVE_STRENGTH_STRONGER;
  gpio_initstructure.gpio_pins = GPIO_PINS_15;
  gpio_init(GPIOB, &gpio_initstructure);
}

int main(void)
{
  system_clock_config();
  at32_board_init();
  at32_led_on(LED4);
  gpio_config();
  spi_config();
  
  /* start communication: master pull down CS pin select slave */
  SPI_MASTER_CS_LOW;
  
  /* transfer procedure:the "BUFFER_SIZE-1" data transfer */
  while(tx_index < BUFFER_SIZE - 1)
  {
    /* slave and master transmit data fill */
    while(spi_i2s_flag_get(SPI2, SPI_I2S_TDBE_FLAG) == RESET);
    spi_i2s_data_transmit(SPI2, spi2_tx_buffer[tx_index]);
    while(spi_i2s_flag_get(SPI1, SPI_I2S_TDBE_FLAG) == RESET);
    spi_i2s_data_transmit(SPI1, spi1_tx_buffer[tx_index++]);
    
    /* slave and master receive data get */
    while(spi_i2s_flag_get(SPI2, SPI_I2S_RDBF_FLAG) == RESET);
    spi2_rx_buffer[rx_index] = spi_i2s_data_receive(SPI2);
    while(spi_i2s_flag_get(SPI1, SPI_I2S_RDBF_FLAG) == RESET);
    spi1_rx_buffer[rx_index++] = spi_i2s_data_receive(SPI1);
  }
  
  /* wait master and slave transmit data buffer empty */
  while(spi_i2s_flag_get(SPI1, SPI_I2S_TDBE_FLAG) == RESET);
  while(spi_i2s_flag_get(SPI2, SPI_I2S_TDBE_FLAG) == RESET);

  /* transfer procedure:the last data and crc transfer */
  /* slave the last transmit data fill and crc transfer setting */
  spi_i2s_data_transmit(SPI2, spi2_tx_buffer[tx_index]);
  spi_crc_next_transmit(SPI2);
  
  /* master the last transmit data fill and crc transfer setting */
  spi_i2s_data_transmit(SPI1, spi1_tx_buffer[tx_index]);
  spi_crc_next_transmit(SPI1);
  
  /* wait master and slave the last data transfer end */
  while(spi_i2s_flag_get(SPI1, SPI_I2S_RDBF_FLAG) == RESET);
  spi1_rx_buffer[rx_index] = spi_i2s_data_receive(SPI1);
  while(spi_i2s_flag_get(SPI2, SPI_I2S_RDBF_FLAG) == RESET);
  spi2_rx_buffer[rx_index] = spi_i2s_data_receive(SPI2);
  
  /* wait master and slave the crc transfer end */
  while(spi_i2s_flag_get(SPI1, SPI_I2S_RDBF_FLAG) == RESET);
  while(spi_i2s_flag_get(SPI2, SPI_I2S_RDBF_FLAG) == RESET);
  
  /* wait master and slave idle when communication end */
  while(spi_i2s_flag_get(SPI1, SPI_I2S_BF_FLAG) != RESET);
  while(spi_i2s_flag_get(SPI2, SPI_I2S_BF_FLAG) != RESET);
  
  /* end communication: master pull up CS pin release slave */
  SPI_MASTER_CS_HIGH;

  /* test result:the data and crc check */
  transfer_status1 = buffer_compare(spi2_rx_buffer, spi1_tx_buffer, BUFFER_SIZE);
  transfer_status2 = buffer_compare(spi1_rx_buffer, spi2_tx_buffer, BUFFER_SIZE);
  if((spi_i2s_flag_get(SPI1, SPI_CCERR_FLAG)) != RESET)
  {
    spi_i2s_flag_clear(SPI1, SPI_CCERR_FLAG);
    transfer_status2 = ERROR;
  }
  if((spi_i2s_flag_get(SPI2, SPI_CCERR_FLAG)) != RESET)
  {
    spi_i2s_flag_clear(SPI2, SPI_CCERR_FLAG);
    transfer_status1 = ERROR;
  }
  crc1_value = spi_i2s_data_receive(SPI1);
  crc2_value = spi_i2s_data_receive(SPI2);

  /* test result indicate:if SUCCESS ,led2 lights */
  if((transfer_status1 == SUCCESS) && (transfer_status2 == SUCCESS))
  {
    at32_led_on(LED2);
  }
  else
  {
    at32_led_on(LED3);
  }
  while(1)
  {
  }
}

代码讲解

系统时钟初始化：配置 MCU 的主频和时钟树。不同芯片的时钟配置不同，一般由工具生成。

板级初始化：初始化开发板上的 LED、按键等基础外设。

GPIO 配置：设置引脚为输出/输入模式，选择推挽/开漏输出，配置上拉/下拉。

SPI 配置：设置主/从模式、时钟极性（CPOL）、时钟相位（CPHA）、分频系数。主机和从机的 CPOL/CPHA 必须一致。

实验现象

主机和从机互相交换数据
数据校验通过则 LED 指示成功

注意事项

CPOL 和 CPHA 必须主机从机一致
片选（CS）信号要手动拉低选中从机
时钟频率不能超过从设备的最大速率

AT32 SPI — 半双工 DMA (JTAG 引脚)

Tue, 08 Sep 2026 14:52:21 +0800

SPI — 半双工 DMA (JTAG 引脚)

固件库: AT32F403A_407_Firmware_Library V2.2.2
芯片: AT32
源文件: AT32/AT32F403A_407_Firmware_Library_V2.2.2/project/at_start_f403a/examples/spi/halfduplex_dma_jtagpin/src/main.c

功能简介

本示例演示 SPI 半双工通信。同一时刻只能收或发，但只需要一根数据线（MOSI/MISO 复用）。

硬件准备

需要主机和从机两块板子，或使用回环连接（MOSI→MISO）

完整代码

#include "at32f403a_407_board.h"
#include "at32f403a_407_clock.h"
#define SPI_MASTER_CS_HIGH   gpio_bits_set(GPIOA, GPIO_PINS_15)
#define SPI_MASTER_CS_LOW    gpio_bits_reset(GPIOA, GPIO_PINS_15)
#define BUFFER_SIZE          32

static void dma_config(void)
{
  dma_init_type dma_init_struct;
  crm_periph_clock_enable(CRM_DMA1_PERIPH_CLOCK, TRUE);
  
  /* use dma1_channel4 as spi2 receive channel */
  dma_reset(DMA1_CHANNEL4);
  dma_default_para_init(&dma_init_struct);
  dma_init_struct.buffer_size = BUFFER_SIZE;
  dma_init_struct.direction = DMA_DIR_PERIPHERAL_TO_MEMORY;
  dma_init_struct.memory_base_addr = (uint32_t)spi2_rx_buffer;
  dma_init_struct.memory_data_width = DMA_MEMORY_DATA_WIDTH_BYTE;
  dma_init_struct.memory_inc_enable = TRUE;
  dma_init_struct.peripheral_base_addr = (uint32_t)&(SPI2->dt);
  dma_init_struct.peripheral_data_width = DMA_PERIPHERAL_DATA_WIDTH_BYTE;
  dma_init_struct.peripheral_inc_enable = FALSE;
  dma_init_struct.priority = DMA_PRIORITY_MEDIUM;
  dma_init_struct.loop_mode_enable = FALSE;
  dma_init(DMA1_CHANNEL4, &dma_init_struct);
  
  crm_periph_clock_enable(CRM_DMA2_PERIPH_CLOCK, TRUE);
  
  /* use dma2_channel2 as spi3 transmit channel */
  dma_reset(DMA2_CHANNEL2);
  dma_default_para_init(&dma_init_struct);
  dma_init_struct.buffer_size = BUFFER_SIZE;
  dma_init_struct.direction = DMA_DIR_MEMORY_TO_PERIPHERAL;
  dma_init_struct.memory_base_addr = (uint32_t)spi3_tx_buffer;
  dma_init_struct.memory_data_width = DMA_MEMORY_DATA_WIDTH_BYTE;
  dma_init_struct.memory_inc_enable = TRUE;
  dma_init_struct.peripheral_base_addr = (uint32_t)&(SPI3->dt);
  dma_init_struct.peripheral_data_width = DMA_PERIPHERAL_DATA_WIDTH_BYTE;
  dma_init_struct.peripheral_inc_enable = FALSE;
  dma_init_struct.priority = DMA_PRIORITY_MEDIUM;
  dma_init_struct.loop_mode_enable = FALSE;
  dma_init(DMA2_CHANNEL2, &dma_init_struct);
}

static void spi_config(void)
{
  spi_init_type spi_init_struct;
  
  /* spi master initialization */
  crm_periph_clock_enable(CRM_SPI3_PERIPH_CLOCK, TRUE);
  spi_default_para_init(&spi_init_struct);
  
  /* single line bidirectional half duplex mode-transmitting */
  spi_init_struct.transmission_mode = SPI_TRANSMIT_HALF_DUPLEX_TX;
  spi_init_struct.master_slave_mode = SPI_MODE_MASTER;
  spi_init_struct.mclk_freq_division = SPI_MCLK_DIV_8;
  spi_init_struct.first_bit_transmission = SPI_FIRST_BIT_MSB;
  spi_init_struct.frame_bit_num = SPI_FRAME_8BIT;
  spi_init_struct.clock_polarity = SPI_CLOCK_POLARITY_LOW;
  spi_init_struct.clock_phase = SPI_CLOCK_PHASE_2EDGE;
  spi_init_struct.cs_mode_selection = SPI_CS_SOFTWARE_MODE;
  spi_init(SPI3, &spi_init_struct);
  
  /* use dma transmit */
  spi_i2s_dma_transmitter_enable(SPI3, TRUE);
  
  spi_enable(SPI3, TRUE);
  
  /* spi slave initialization */
  crm_periph_clock_enable(CRM_SPI2_PERIPH_CLOCK, TRUE);
  
  /* single line bidirectional half duplex mode-receiving */
  spi_init_struct.transmission_mode = SPI_TRANSMIT_HALF_DUPLEX_RX;
  spi_init_struct.master_slave_mode = SPI_MODE_SLAVE;
  spi_init_struct.mclk_freq_division = SPI_MCLK_DIV_8;
  spi_init_struct.first_bit_transmission = SPI_FIRST_BIT_MSB;
  spi_init_struct.frame_bit_num = SPI_FRAME_8BIT;
  spi_init_struct.clock_polarity = SPI_CLOCK_POLARITY_LOW;
  spi_init_struct.clock_phase = SPI_CLOCK_PHASE_2EDGE;
  spi_init_struct.cs_mode_selection = SPI_CS_HARDWARE_MODE;
  spi_init(SPI2, &spi_init_struct);
  
  /* use dma receive */
  spi_i2s_dma_receiver_enable(SPI2, TRUE);
  
  spi_enable(SPI2, TRUE);
}

static void gpio_config(void)
{
  gpio_init_type gpio_initstructure;
  crm_periph_clock_enable(CRM_GPIOA_PERIPH_CLOCK, TRUE);
  crm_periph_clock_enable(CRM_GPIOB_PERIPH_CLOCK, TRUE);
  crm_periph_clock_enable(CRM_IOMUX_PERIPH_CLOCK, TRUE);
  gpio_pin_remap_config(SWJTAG_GMUX_010, TRUE);
  gpio_pin_remap_config(SPI3_GMUX_0010, TRUE);
  
  /* master cs pin */
  gpio_initstructure.gpio_out_type = GPIO_OUTPUT_PUSH_PULL;
  gpio_initstructure.gpio_drive_strength = GPIO_DRIVE_STRENGTH_STRONGER;
  gpio_initstructure.gpio_pull = GPIO_PULL_UP;
  gpio_initstructure.gpio_mode = GPIO_MODE_OUTPUT;
  gpio_initstructure.gpio_pins = GPIO_PINS_15;
  gpio_init(GPIOA, &gpio_initstructure);
  
  /* non communication time: master pull up CS pin release slave */
  SPI_MASTER_CS_HIGH;
  
  /* master sck pin */
  gpio_initstructure.gpio_pull = GPIO_PULL_DOWN;
  gpio_initstructure.gpio_mode = GPIO_MODE_MUX;
  gpio_initstructure.gpio_pins = GPIO_PINS_3;
  gpio_init(GPIOB, &gpio_initstructure);

  /* master mosi pin */
  gpio_initstructure.gpio_pull = GPIO_PULL_UP;
  gpio_initstructure.gpio_mode = GPIO_MODE_MUX;
  gpio_initstructure.gpio_pins = GPIO_PINS_5;
  gpio_init(GPIOB, &gpio_initstructure);
  
  /* slave cs pin */
  gpio_initstructure.gpio_pull = GPIO_PULL_UP;
  gpio_initstructure.gpio_mode = GPIO_MODE_INPUT;
  gpio_initstructure.gpio_pins = GPIO_PINS_12;
  gpio_init(GPIOB, &gpio_initstructure);
  
  /* slave sck pin */
  gpio_initstructure.gpio_pull = GPIO_PULL_DOWN;
  gpio_initstructure.gpio_mode = GPIO_MODE_INPUT;
  gpio_initstructure.gpio_pins = GPIO_PINS_13;
  gpio_init(GPIOB, &gpio_initstructure);

  /* slave miso pin */
  gpio_initstructure.gpio_pull = GPIO_PULL_UP;
  gpio_initstructure.gpio_mode = GPIO_MODE_MUX;
  gpio_initstructure.gpio_pins = GPIO_PINS_14;
  gpio_init(GPIOB, &gpio_initstructure);
}

int main(void)
{
  system_clock_config();
  at32_board_init();
  at32_led_on(LED4);
  
  gpio_config();
  dma_config();
  spi_config();
  
  /* start communication: master pull down CS pin select slave */
  SPI_MASTER_CS_LOW;
  
  /* enable spi slave dma to get data */
  dma_channel_enable(DMA1_CHANNEL4, TRUE);
  
  /* enable spi master dma to fill data */
  dma_channel_enable(DMA2_CHANNEL2, TRUE);
  
  /* wait master spi data fill end */
  while(dma_flag_get(DMA2_FDT2_FLAG) == RESET)
  {
  }
  
  /* wait slave spi data get end */
  while(dma_flag_get(DMA1_FDT4_FLAG) == RESET)
  {
  }
  
  /* wait master and slave idle when communication end */
  while(spi_i2s_flag_get(SPI3, SPI_I2S_BF_FLAG) != RESET);
  while(spi_i2s_flag_get(SPI2, SPI_I2S_BF_FLAG) != RESET);
  
  /* end communication: master pull up CS pin release slave */
  SPI_MASTER_CS_HIGH;

  /* test result:the data check */
  transfer_status = buffer_compare(spi2_rx_buffer, spi3_tx_buffer, BUFFER_SIZE);

  /* test result indicate:if SUCCESS ,led2 lights */
  if(transfer_status == SUCCESS)
  {
    at32_led_on(LED2);
  }
  else
  {
    at32_led_on(LED3);
  }
  while(1)
  {
  }
}

代码讲解

系统时钟初始化：配置 MCU 的主频和时钟树。不同芯片的时钟配置不同，一般由工具生成。

板级初始化：初始化开发板上的 LED、按键等基础外设。

GPIO 配置：设置引脚为输出/输入模式，选择推挽/开漏输出，配置上拉/下拉。

DMA 配置：设置源地址、目标地址、传输方向、数据宽度。DMA 搬运数据不占用 CPU。

SPI 配置：设置主/从模式、时钟极性（CPOL）、时钟相位（CPHA）、分频系数。主机和从机的 CPOL/CPHA 必须一致。

实验现象

主机和从机互相交换数据
数据校验通过则 LED 指示成功

注意事项

CPOL 和 CPHA 必须主机从机一致
片选（CS）信号要手动拉低选中从机
时钟频率不能超过从设备的最大速率

AT32 SPI — 半双工收发切换

Tue, 08 Sep 2026 14:52:21 +0800

SPI — 半双工收发切换

固件库: AT32F403A_407_Firmware_Library V2.2.2
芯片: AT32
源文件: AT32/AT32F403A_407_Firmware_Library_V2.2.2/project/at_start_f403a/examples/spi/halfduplex_transceiver_switch/src/main.c

功能简介

本示例演示 SPI 半双工通信。同一时刻只能收或发，但只需要一根数据线（MOSI/MISO 复用）。

硬件准备

需要主机和从机两块板子，或使用回环连接（MOSI→MISO）

完整代码

#include "at32f403a_407_board.h"
#include "at32f403a_407_clock.h"
#define SPI_MASTER_CS_HIGH   gpio_bits_set(GPIOA, GPIO_PINS_4)
#define SPI_MASTER_CS_LOW    gpio_bits_reset(GPIOA, GPIO_PINS_4)
#define BUFFER_SIZE          32

static void spi_config(void)
{
  /* master spi initialization */
  crm_periph_clock_enable(CRM_SPI1_PERIPH_CLOCK, TRUE);
  nvic_irq_enable(SPI1_IRQn, 0, 0);
  spi_default_para_init(&spi_init_struct);
  
  /* single line bidirectional half duplex mode - transmitting */
  spi_init_struct.transmission_mode = SPI_TRANSMIT_HALF_DUPLEX_TX;
  spi_init_struct.master_slave_mode = SPI_MODE_MASTER;
  spi_init_struct.mclk_freq_division = SPI_MCLK_DIV_256;
  spi_init_struct.first_bit_transmission = SPI_FIRST_BIT_MSB;
  spi_init_struct.frame_bit_num = SPI_FRAME_8BIT;
  spi_init_struct.clock_polarity = SPI_CLOCK_POLARITY_LOW;
  spi_init_struct.clock_phase = SPI_CLOCK_PHASE_2EDGE;
  spi_init_struct.cs_mode_selection = SPI_CS_SOFTWARE_MODE;
  spi_init(SPI1, &spi_init_struct);
  
  /* enable transmit data buffer empty interrupt */
  spi_i2s_interrupt_enable(SPI1, SPI_I2S_TDBE_INT, TRUE);
  
  /* slave spi initialization */
  crm_periph_clock_enable(CRM_SPI2_PERIPH_CLOCK, TRUE);
  nvic_irq_enable(SPI2_I2S2EXT_IRQn, 0, 0);
  
  /* single line bidirectional half duplex mode - receiving */
  spi_init_struct.transmission_mode = SPI_TRANSMIT_HALF_DUPLEX_RX;
  spi_init_struct.master_slave_mode = SPI_MODE_SLAVE;
  spi_init_struct.mclk_freq_division = SPI_MCLK_DIV_256;
  spi_init_struct.first_bit_transmission = SPI_FIRST_BIT_MSB;
  spi_init_struct.frame_bit_num = SPI_FRAME_8BIT;
  spi_init_struct.clock_polarity = SPI_CLOCK_POLARITY_LOW;
  spi_init_struct.clock_phase = SPI_CLOCK_PHASE_2EDGE;
  spi_init_struct.cs_mode_selection = SPI_CS_HARDWARE_MODE;
  spi_init(SPI2, &spi_init_struct);

  /* enable receive data buffer full interrupt */
  spi_i2s_interrupt_enable(SPI2, SPI_I2S_RDBF_INT, TRUE);
}

static void gpio_config(void)
{
  gpio_init_type gpio_initstructure;
  crm_periph_clock_enable(CRM_GPIOA_PERIPH_CLOCK, TRUE);
  crm_periph_clock_enable(CRM_GPIOB_PERIPH_CLOCK, TRUE);
  gpio_default_para_init(&gpio_initstructure);
  
  /* master spi cs pin */
  gpio_initstructure.gpio_out_type = GPIO_OUTPUT_PUSH_PULL;
  gpio_initstructure.gpio_pull = GPIO_PULL_UP;
  gpio_initstructure.gpio_mode = GPIO_MODE_OUTPUT;
  gpio_initstructure.gpio_drive_strength = GPIO_DRIVE_STRENGTH_STRONGER;
  gpio_initstructure.gpio_pins = GPIO_PINS_4;
  gpio_init(GPIOA, &gpio_initstructure);
  
  /* non communication time: master pull up CS pin release slave */
  SPI_MASTER_CS_HIGH;

  /* master spi sck pin */
  gpio_initstructure.gpio_out_type = GPIO_OUTPUT_PUSH_PULL;
  gpio_initstructure.gpio_drive_strength = GPIO_DRIVE_STRENGTH_STRONGER;
  gpio_initstructure.gpio_pull = GPIO_PULL_DOWN;
  gpio_initstructure.gpio_mode = GPIO_MODE_MUX;
  gpio_initstructure.gpio_pins = GPIO_PINS_5;
  gpio_init(GPIOA, &gpio_initstructure);

  /* master spi mosi pin */
  gpio_initstructure.gpio_pull = GPIO_PULL_UP;
  gpio_initstructure.gpio_mode = GPIO_MODE_MUX;
  gpio_initstructure.gpio_pins = GPIO_PINS_7;
  gpio_init(GPIOA, &gpio_initstructure);
  
  /* slave spi cs pin */
  gpio_initstructure.gpio_out_type = GPIO_OUTPUT_PUSH_PULL;
  gpio_initstructure.gpio_pull = GPIO_PULL_UP;
  gpio_initstructure.gpio_mode = GPIO_MODE_INPUT;
  gpio_initstructure.gpio_drive_strength = GPIO_DRIVE_STRENGTH_STRONGER;
  gpio_initstructure.gpio_pins = GPIO_PINS_12;
  gpio_init(GPIOB, &gpio_initstructure);

  /* slave spi sck pin */
  gpio_initstructure.gpio_pull = GPIO_PULL_DOWN;
  gpio_initstructure.gpio_mode = GPIO_MODE_INPUT;
  gpio_initstructure.gpio_pins = GPIO_PINS_13;
  gpio_init(GPIOB, &gpio_initstructure);

  /* slave spi miso pin */
  gpio_initstructure.gpio_pull = GPIO_PULL_UP;
  gpio_initstructure.gpio_mode = GPIO_MODE_MUX;
  gpio_initstructure.gpio_pins = GPIO_PINS_14;
  gpio_init(GPIOB, &gpio_initstructure);
}

int main(void)
{
  system_clock_config();
  at32_board_init();
  at32_led_on(LED4);
  nvic_priority_group_config(NVIC_PRIORITY_GROUP_4);
  gpio_config();
  
  /* config spi1 send spi2 receive */
  spi_config();
  
  /* start communication: master pull down CS pin select slave */
  SPI_MASTER_CS_LOW;
  
  spi_enable(SPI2, TRUE);
  spi_enable(SPI1, TRUE);
  
  /* wait data receive end */
  while(rx_index < BUFFER_SIZE);
  
  /* wait master and slave idle when communication end */
  while(spi_i2s_flag_get(SPI1, SPI_I2S_BF_FLAG) != RESET);
  while(spi_i2s_flag_get(SPI2, SPI_I2S_BF_FLAG) != RESET);
  
  /* end communication: master pull up CS pin release slave */
  SPI_MASTER_CS_HIGH;
  
  /* test result:the data check */
  transfer_status1 = buffer_compare(spi2_rx_buffer, spi1_tx_buffer, BUFFER_SIZE);
  
  /* config spi2 send spi1 receive */
  spi_enable(SPI1, FALSE);
  spi_enable(SPI2, FALSE);
    
  rx_index = 0;
  tx_index = 0;
  spi_i2s_interrupt_enable(SPI1, SPI_I2S_TDBE_INT, FALSE);
  spi_i2s_interrupt_enable(SPI2, SPI_I2S_RDBF_INT, FALSE);
  
  /* single line bidirectional half duplex mode - receiving */
  spi_init_struct.transmission_mode = SPI_TRANSMIT_HALF_DUPLEX_RX;
  spi_init_struct.master_slave_mode = SPI_MODE_MASTER;
  spi_init_struct.cs_mode_selection = SPI_CS_SOFTWARE_MODE;
  spi_init(SPI1, &spi_init_struct);
  
  /* single line bidirectional half duplex mode - transmitting */
  spi_init_struct.transmission_mode = SPI_TRANSMIT_HALF_DUPLEX_TX;
  spi_init_struct.master_slave_mode = SPI_MODE_SLAVE;
  spi_init_struct.cs_mode_selection = SPI_CS_HARDWARE_MODE;
  spi_init(SPI2, &spi_init_struct);

  spi_i2s_interrupt_enable(SPI1, SPI_I2S_RDBF_INT, TRUE);
  spi_i2s_interrupt_enable(SPI2, SPI_I2S_TDBE_INT, TRUE);
  
  /* start communication: master pull down CS pin select slave */
  SPI_MASTER_CS_LOW;
  
  spi_enable(SPI2, TRUE);
  spi_enable(SPI1, TRUE);
  
  /* wait slave data receive end */
  while(rx_index < BUFFER_SIZE);
  
  /* master half duplex receiving modethe busy flag isnot usefull */
  
  /* end communication: master pull up CS pin release slave */
  SPI_MASTER_CS_HIGH;
  
  /* test result:the data check */
  transfer_status2 = buffer_compare(spi1_rx_buffer, spi2_tx_buffer, BUFFER_SIZE);

  /* test result indicate:if passed ,led2 lights */
  if((transfer_status1 == SUCCESS) && (transfer_status2 == SUCCESS))
  {
    at32_led_on(LED2);
  }
  else
  {
    at32_led_on(LED3);
  }
  while(1)
  {
  }
}

代码讲解

系统时钟初始化：配置 MCU 的主频和时钟树。不同芯片的时钟配置不同，一般由工具生成。

板级初始化：初始化开发板上的 LED、按键等基础外设。

GPIO 配置：设置引脚为输出/输入模式，选择推挽/开漏输出，配置上拉/下拉。

SPI 配置：设置主/从模式、时钟极性（CPOL）、时钟相位（CPHA）、分频系数。主机和从机的 CPOL/CPHA 必须一致。

中断优先级配置：NVIC 设置中断的抢占优先级和子优先级。数字越小优先级越高。

实验现象

主机和从机互相交换数据
数据校验通过则 LED 指示成功

注意事项

CPOL 和 CPHA 必须主机从机一致
片选（CS）信号要手动拉低选中从机
时钟频率不能超过从设备的最大速率

AT32 SPI — 半双工中断

Tue, 08 Sep 2026 14:52:21 +0800

SPI — 半双工中断

固件库: AT32F403A_407_Firmware_Library V2.2.2
芯片: AT32
源文件: AT32/AT32F403A_407_Firmware_Library_V2.2.2/project/at_start_f403a/examples/spi/halfduplex_interrupt/src/main.c

功能简介

本示例演示 SPI 半双工通信。同一时刻只能收或发，但只需要一根数据线（MOSI/MISO 复用）。

硬件准备

需要主机和从机两块板子，或使用回环连接（MOSI→MISO）

完整代码

#include "at32f403a_407_board.h"
#include "at32f403a_407_clock.h"
#define SPI_MASTER_CS_HIGH   gpio_bits_set(GPIOA, GPIO_PINS_4)
#define SPI_MASTER_CS_LOW    gpio_bits_reset(GPIOA, GPIO_PINS_4)
#define BUFFER_SIZE          32

static void spi_config(void)
{
  spi_init_type spi_init_struct;
  
  /* master spi initialization */
  crm_periph_clock_enable(CRM_SPI1_PERIPH_CLOCK, TRUE);
  nvic_irq_enable(SPI1_IRQn, 0, 0);
  spi_default_para_init(&spi_init_struct);
  
  /* single line bidirectional half duplex mode - transmitting */
  spi_init_struct.transmission_mode = SPI_TRANSMIT_HALF_DUPLEX_TX;
  spi_init_struct.master_slave_mode =SPI_MODE_MASTER;
  spi_init_struct.mclk_freq_division = SPI_MCLK_DIV_8;
  spi_init_struct.first_bit_transmission = SPI_FIRST_BIT_MSB;
  spi_init_struct.frame_bit_num = SPI_FRAME_8BIT;
  spi_init_struct.clock_polarity = SPI_CLOCK_POLARITY_LOW;
  spi_init_struct.clock_phase = SPI_CLOCK_PHASE_2EDGE;
  spi_init_struct.cs_mode_selection = SPI_CS_SOFTWARE_MODE;
  spi_init(SPI1, &spi_init_struct);
  
  /* enable transmit data buffer empty interrupt */
  spi_i2s_interrupt_enable(SPI1, SPI_I2S_TDBE_INT, TRUE);
  
  /* slave spi initialization */
  crm_periph_clock_enable(CRM_SPI2_PERIPH_CLOCK, TRUE);
  nvic_irq_enable(SPI2_I2S2EXT_IRQn, 0, 0);

  /* single line bidirectional half duplex mode - receiving */
  spi_init_struct.transmission_mode = SPI_TRANSMIT_HALF_DUPLEX_RX;
  spi_init_struct.master_slave_mode =SPI_MODE_SLAVE;
  spi_init_struct.mclk_freq_division = SPI_MCLK_DIV_8;
  spi_init_struct.first_bit_transmission = SPI_FIRST_BIT_MSB;
  spi_init_struct.frame_bit_num = SPI_FRAME_8BIT;
  spi_init_struct.clock_polarity = SPI_CLOCK_POLARITY_LOW;
  spi_init_struct.clock_phase = SPI_CLOCK_PHASE_2EDGE;
  spi_init_struct.cs_mode_selection = SPI_CS_HARDWARE_MODE;
  spi_init(SPI2, &spi_init_struct);
  
  /* enable receive data buffer full interrupt */
  spi_i2s_interrupt_enable(SPI2, SPI_I2S_RDBF_INT, TRUE);
}

static void gpio_config(void)
{
  gpio_init_type gpio_initstructure;
  crm_periph_clock_enable(CRM_GPIOA_PERIPH_CLOCK, TRUE);
  crm_periph_clock_enable(CRM_GPIOB_PERIPH_CLOCK, TRUE);
  
  gpio_default_para_init(&gpio_initstructure);
  
  /* master spi cs pin */
  gpio_initstructure.gpio_out_type = GPIO_OUTPUT_PUSH_PULL;
  gpio_initstructure.gpio_pull = GPIO_PULL_UP;
  gpio_initstructure.gpio_mode = GPIO_MODE_OUTPUT;
  gpio_initstructure.gpio_drive_strength = GPIO_DRIVE_STRENGTH_STRONGER;
  gpio_initstructure.gpio_pins = GPIO_PINS_4;
  gpio_init(GPIOA, &gpio_initstructure);
  
  /* non communication time: master pull up CS pin release slave */
  SPI_MASTER_CS_HIGH;

  /* master spi sck pin */
  gpio_initstructure.gpio_out_type = GPIO_OUTPUT_PUSH_PULL;
  gpio_initstructure.gpio_drive_strength = GPIO_DRIVE_STRENGTH_STRONGER;
  gpio_initstructure.gpio_pull = GPIO_PULL_DOWN;
  gpio_initstructure.gpio_mode = GPIO_MODE_MUX;
  gpio_initstructure.gpio_pins = GPIO_PINS_5;
  gpio_init(GPIOA, &gpio_initstructure);

  /* master spi mosi pin */
  gpio_initstructure.gpio_pull = GPIO_PULL_UP;
  gpio_initstructure.gpio_mode = GPIO_MODE_MUX;
  gpio_initstructure.gpio_pins = GPIO_PINS_7;
  gpio_init(GPIOA, &gpio_initstructure);
  
  /* slave spi cs pin */
  gpio_initstructure.gpio_out_type = GPIO_OUTPUT_PUSH_PULL;
  gpio_initstructure.gpio_pull = GPIO_PULL_UP;
  gpio_initstructure.gpio_mode = GPIO_MODE_INPUT;
  gpio_initstructure.gpio_drive_strength = GPIO_DRIVE_STRENGTH_STRONGER;
  gpio_initstructure.gpio_pins = GPIO_PINS_12;
  gpio_init(GPIOB, &gpio_initstructure);
  
  /* slave spi sck pin */
  gpio_initstructure.gpio_pull = GPIO_PULL_DOWN;
  gpio_initstructure.gpio_mode = GPIO_MODE_INPUT;
  gpio_initstructure.gpio_pins = GPIO_PINS_13;
  gpio_init(GPIOB, &gpio_initstructure);

  /* slave spi miso pin */
  gpio_initstructure.gpio_pull = GPIO_PULL_UP;
  gpio_initstructure.gpio_mode = GPIO_MODE_MUX;
  gpio_initstructure.gpio_pins = GPIO_PINS_14;
  gpio_init(GPIOB, &gpio_initstructure);
}

int main(void)
{
  system_clock_config();
  at32_board_init();
  at32_led_on(LED4);
  nvic_priority_group_config(NVIC_PRIORITY_GROUP_4);
  gpio_config();
  /* config spi1 send spi2 receive */
  spi_config();
  
  /* start communication: master pull down CS pin select slave */
  SPI_MASTER_CS_LOW;
  
  spi_enable(SPI2, TRUE);
  spi_enable(SPI1, TRUE);
  
  /* wait slave data receive end */
  while(rx_index < BUFFER_SIZE);
  
  /* wait master and slave idle when communication end */
  while(spi_i2s_flag_get(SPI1, SPI_I2S_BF_FLAG) != RESET);
  while(spi_i2s_flag_get(SPI2, SPI_I2S_BF_FLAG) != RESET);
  
  /* end communication: master pull up CS pin release slave */
  SPI_MASTER_CS_HIGH;

  /* test result:the data check */
  transfer_status = buffer_compare(spi2_rx_buffer, spi1_tx_buffer, BUFFER_SIZE);

  /* test result indicate:if SUCCESS ,led2 lights */
  if(transfer_status==SUCCESS)
  {
    at32_led_on(LED2);
  }
  else
  {
    at32_led_on(LED3);
  }
  while(1)
  {
  }
}

代码讲解

系统时钟初始化：配置 MCU 的主频和时钟树。不同芯片的时钟配置不同，一般由工具生成。

板级初始化：初始化开发板上的 LED、按键等基础外设。

GPIO 配置：设置引脚为输出/输入模式，选择推挽/开漏输出，配置上拉/下拉。

SPI 配置：设置主/从模式、时钟极性（CPOL）、时钟相位（CPHA）、分频系数。主机和从机的 CPOL/CPHA 必须一致。

中断优先级配置：NVIC 设置中断的抢占优先级和子优先级。数字越小优先级越高。

实验现象

主机和从机互相交换数据
数据校验通过则 LED 指示成功

注意事项

CPOL 和 CPHA 必须主机从机一致
片选（CS）信号要手动拉低选中从机
时钟频率不能超过从设备的最大速率

AT32 SPI — 全双工 DMA (JTAG 引脚)

Tue, 08 Sep 2026 14:52:21 +0800

SPI — 全双工 DMA (JTAG 引脚)

固件库: AT32F403A_407_Firmware_Library V2.2.2
芯片: AT32
源文件: AT32/AT32F403A_407_Firmware_Library_V2.2.2/project/at_start_f403a/examples/spi/fullduplex_dma_jtagpin/src/main.c

功能简介

本示例演示 SPI 全双工通信。主机和从机可以同时收发数据，速度比 I2C 快得多。适合高速数据传输场景。

硬件准备

需要主机和从机两块板子，或使用回环连接（MOSI→MISO）

完整代码

#include "at32f403a_407_board.h"
#include "at32f403a_407_clock.h"
#define SPI_MASTER_CS_HIGH   gpio_bits_set(GPIOA, GPIO_PINS_15)
#define SPI_MASTER_CS_LOW    gpio_bits_reset(GPIOA, GPIO_PINS_15)
#define BUFFER_SIZE          32

static void dma_config(void)
{
  dma_init_type dma_init_struct;
  crm_periph_clock_enable(CRM_DMA1_PERIPH_CLOCK, TRUE);
  
  /* use dma1_channel1 as spi1 transmit channel */
  dma_reset(DMA1_CHANNEL1);
  dma_default_para_init(&dma_init_struct);
  dma_init_struct.buffer_size = BUFFER_SIZE;
  dma_init_struct.direction = DMA_DIR_MEMORY_TO_PERIPHERAL;
  dma_init_struct.memory_base_addr = (uint32_t)spi1_tx_buffer;
  dma_init_struct.memory_data_width = DMA_MEMORY_DATA_WIDTH_BYTE;
  dma_init_struct.memory_inc_enable = TRUE;
  dma_init_struct.peripheral_base_addr = (uint32_t)&(SPI1->dt);
  dma_init_struct.peripheral_data_width = DMA_PERIPHERAL_DATA_WIDTH_BYTE;
  dma_init_struct.peripheral_inc_enable = FALSE;
  dma_init_struct.priority = DMA_PRIORITY_MEDIUM;
  dma_init_struct.loop_mode_enable = FALSE;
  dma_init(DMA1_CHANNEL1, &dma_init_struct);
  dma_flexible_config(DMA1, FLEX_CHANNEL1, DMA_FLEXIBLE_SPI1_TX);
  
  /* use dma1_channel2 as spi1 receive channel */
  dma_reset(DMA1_CHANNEL2);
  dma_init_struct.buffer_size = BUFFER_SIZE;
  dma_init_struct.direction = DMA_DIR_PERIPHERAL_TO_MEMORY;
  dma_init_struct.memory_base_addr = (uint32_t)spi1_rx_buffer;
  dma_init_struct.memory_data_width = DMA_MEMORY_DATA_WIDTH_BYTE;
  dma_init_struct.memory_inc_enable = TRUE;
  dma_init_struct.peripheral_base_addr = (uint32_t)&(SPI1->dt);
  dma_init_struct.peripheral_data_width = DMA_PERIPHERAL_DATA_WIDTH_BYTE;
  dma_init_struct.peripheral_inc_enable = FALSE;
  dma_init_struct.priority = DMA_PRIORITY_MEDIUM;
  dma_init_struct.loop_mode_enable = FALSE;
  dma_init(DMA1_CHANNEL2, &dma_init_struct);
  dma_flexible_config(DMA1, FLEX_CHANNEL2, DMA_FLEXIBLE_SPI1_RX);
  
  crm_periph_clock_enable(CRM_DMA2_PERIPH_CLOCK, TRUE);
  
  /* use dma2_channel1 as spi2 transmit channel */
  dma_reset(DMA2_CHANNEL1);
  dma_default_para_init(&dma_init_struct);
  dma_init_struct.buffer_size = BUFFER_SIZE;
  dma_init_struct.direction = DMA_DIR_MEMORY_TO_PERIPHERAL;
  dma_init_struct.memory_base_addr = (uint32_t)spi2_tx_buffer;
  dma_init_struct.memory_data_width = DMA_MEMORY_DATA_WIDTH_BYTE;
  dma_init_struct.memory_inc_enable = TRUE;
  dma_init_struct.peripheral_base_addr = (uint32_t)&(SPI2->dt);
  dma_init_struct.peripheral_data_width = DMA_PERIPHERAL_DATA_WIDTH_BYTE;
  dma_init_struct.peripheral_inc_enable = FALSE;
  dma_init_struct.priority = DMA_PRIORITY_MEDIUM;
  dma_init_struct.loop_mode_enable = FALSE;
  dma_init(DMA2_CHANNEL1, &dma_init_struct);
  dma_flexible_config(DMA2, FLEX_CHANNEL1, DMA_FLEXIBLE_SPI2_TX);
  
  /* use dma2_channel2 as spi2 receive channel */
  dma_reset(DMA2_CHANNEL2);
  dma_init_struct.buffer_size = BUFFER_SIZE;
  dma_init_struct.direction = DMA_DIR_PERIPHERAL_TO_MEMORY;
  dma_init_struct.memory_base_addr = (uint32_t)spi2_rx_buffer;
  dma_init_struct.memory_data_width = DMA_MEMORY_DATA_WIDTH_BYTE;
  dma_init_struct.memory_inc_enable = TRUE;
  dma_init_struct.peripheral_base_addr = (uint32_t)&(SPI2->dt);
  dma_init_struct.peripheral_data_width = DMA_PERIPHERAL_DATA_WIDTH_BYTE;
  dma_init_struct.peripheral_inc_enable = FALSE;
  dma_init_struct.priority = DMA_PRIORITY_MEDIUM;
  dma_init_struct.loop_mode_enable = FALSE;
  dma_init(DMA2_CHANNEL2, &dma_init_struct);
  dma_flexible_config(DMA2, FLEX_CHANNEL2, DMA_FLEXIBLE_SPI2_RX);
}

static void spi_config(void)
{
  /* spi master initialization */
  crm_periph_clock_enable(CRM_SPI1_PERIPH_CLOCK, TRUE);
  spi_default_para_init(&spi_init_struct);
  
  /* dual line unidirectional full-duplex mode */
  spi_init_struct.transmission_mode = SPI_TRANSMIT_FULL_DUPLEX;
  spi_init_struct.master_slave_mode = SPI_MODE_MASTER;
  spi_init_struct.mclk_freq_division = SPI_MCLK_DIV_8;
  spi_init_struct.first_bit_transmission = SPI_FIRST_BIT_LSB;
  spi_init_struct.frame_bit_num = SPI_FRAME_8BIT;
  spi_init_struct.clock_polarity = SPI_CLOCK_POLARITY_LOW;
  spi_init_struct.clock_phase = SPI_CLOCK_PHASE_2EDGE;
  spi_init_struct.cs_mode_selection = SPI_CS_SOFTWARE_MODE;
  spi_init(SPI1, &spi_init_struct);
  
  /* use dma transmit and receive */
  spi_i2s_dma_transmitter_enable(SPI1, TRUE);
  spi_i2s_dma_receiver_enable(SPI1, TRUE);
  
  spi_enable(SPI1, TRUE);
  
  /* spi slave initialization */
  crm_periph_clock_enable(CRM_SPI2_PERIPH_CLOCK, TRUE);
  
  /* dual line unidirectional full-duplex mode */
  spi_init_struct.transmission_mode = SPI_TRANSMIT_FULL_DUPLEX;
  spi_init_struct.master_slave_mode = SPI_MODE_SLAVE;
  spi_init_struct.mclk_freq_division = SPI_MCLK_DIV_8;
  spi_init_struct.first_bit_transmission = SPI_FIRST_BIT_LSB;
  spi_init_struct.frame_bit_num = SPI_FRAME_8BIT;
  spi_init_struct.clock_polarity = SPI_CLOCK_POLARITY_LOW;
  spi_init_struct.clock_phase = SPI_CLOCK_PHASE_2EDGE;
  spi_init_struct.cs_mode_selection = SPI_CS_HARDWARE_MODE;
  spi_init(SPI2, &spi_init_struct);
  
  /* use dma transmit and receive */
  spi_i2s_dma_transmitter_enable(SPI2, TRUE);
  spi_i2s_dma_receiver_enable(SPI2, TRUE);
  
  spi_enable(SPI2, TRUE);
}

static void gpio_config(void)
{
  gpio_init_type gpio_initstructure;
  crm_periph_clock_enable(CRM_GPIOA_PERIPH_CLOCK, TRUE);
  crm_periph_clock_enable(CRM_GPIOB_PERIPH_CLOCK, TRUE);
  crm_periph_clock_enable(CRM_IOMUX_PERIPH_CLOCK, TRUE);
  gpio_pin_remap_config(SWJTAG_MUX_010, TRUE);
  gpio_pin_remap_config(SPI1_MUX_01, TRUE);
  gpio_default_para_init(&gpio_initstructure);
  
  /* spi master gpio initialization */
  /* spi1 cs pin */
  gpio_initstructure.gpio_out_type = GPIO_OUTPUT_PUSH_PULL;
  gpio_initstructure.gpio_drive_strength = GPIO_DRIVE_STRENGTH_STRONGER;
  gpio_initstructure.gpio_pull = GPIO_PULL_UP;
  gpio_initstructure.gpio_mode = GPIO_MODE_OUTPUT;
  gpio_initstructure.gpio_pins = GPIO_PINS_15;
  gpio_init(GPIOA, &gpio_initstructure);
  
  /* non communication time: master pull up CS pin release slave */
  SPI_MASTER_CS_HIGH;
  
  /* spi1 sck pin */
  gpio_initstructure.gpio_out_type = GPIO_OUTPUT_PUSH_PULL;
  gpio_initstructure.gpio_drive_strength = GPIO_DRIVE_STRENGTH_STRONGER;
  gpio_initstructure.gpio_pull = GPIO_PULL_DOWN;
  gpio_initstructure.gpio_mode = GPIO_MODE_MUX;
  gpio_initstructure.gpio_pins = GPIO_PINS_3;
  gpio_init(GPIOB, &gpio_initstructure);

  /* spi1 miso pin */
  gpio_initstructure.gpio_pull = GPIO_PULL_UP;
  gpio_initstructure.gpio_mode = GPIO_MODE_INPUT;
  gpio_initstructure.gpio_pins = GPIO_PINS_4;
  gpio_init(GPIOB, &gpio_initstructure);

  /* spi1 mosi pin */
  gpio_initstructure.gpio_pull = GPIO_PULL_UP;
  gpio_initstructure.gpio_mode = GPIO_MODE_MUX;
  gpio_initstructure.gpio_pins = GPIO_PINS_5;
  gpio_init(GPIOB, &gpio_initstructure);
  
  /* spi2 gpio initialization */
  /* spi2 cs pin */
  gpio_initstructure.gpio_out_type = GPIO_OUTPUT_PUSH_PULL;
  gpio_initstructure.gpio_drive_strength = GPIO_DRIVE_STRENGTH_STRONGER;
  gpio_initstructure.gpio_pull = GPIO_PULL_UP;
  gpio_initstructure.gpio_mode = GPIO_MODE_INPUT;
  gpio_initstructure.gpio_pins = GPIO_PINS_12;
  gpio_init(GPIOB, &gpio_initstructure);

  /* spi2 sck pin */
  gpio_initstructure.gpio_pull = GPIO_PULL_DOWN;
  gpio_initstructure.gpio_mode = GPIO_MODE_INPUT;
  gpio_initstructure.gpio_pins = GPIO_PINS_13;
  gpio_init(GPIOB, &gpio_initstructure);

  /* spi2 miso pin */
  gpio_initstructure.gpio_pull = GPIO_PULL_UP;
  gpio_initstructure.gpio_mode = GPIO_MODE_MUX;
  gpio_initstructure.gpio_pins = GPIO_PINS_14;
  gpio_init(GPIOB, &gpio_initstructure);

  /* spi2 mosi pin */
  gpio_initstructure.gpio_pull = GPIO_PULL_UP;
  gpio_initstructure.gpio_mode = GPIO_MODE_INPUT;
  gpio_initstructure.gpio_pins = GPIO_PINS_15;
  gpio_init(GPIOB, &gpio_initstructure);
}

int main(void)
{
  __IO uint32_t index = 0;
  system_clock_config();
  at32_board_init();
  at32_led_on(LED4);
  dma_config();
  gpio_config();
  spi_config();
  
  /* start communication: master pull down CS pin select slave */
  SPI_MASTER_CS_LOW;
  
  /* enable spi slave dma to fill and get data */
  dma_channel_enable(DMA2_CHANNEL1, TRUE);
  dma_channel_enable(DMA2_CHANNEL2, TRUE);
  
  /* enable spi master dma to fill and get data */
  dma_channel_enable(DMA1_CHANNEL1, TRUE);
  dma_channel_enable(DMA1_CHANNEL2, TRUE);
  
  /* wait master and slave spi data receive end */
  while(dma_flag_get(DMA1_FDT2_FLAG) == RESET)
  {
  }
  while(dma_flag_get(DMA2_FDT2_FLAG) == RESET)
  {
  }
  
  /* wait master and slave idle when communication end */
  while(spi_i2s_flag_get(SPI1, SPI_I2S_BF_FLAG) != RESET);
  while(spi_i2s_flag_get(SPI2, SPI_I2S_BF_FLAG) != RESET);
  
  /* end communication: master pull up CS pin release slave */
  SPI_MASTER_CS_HIGH;

  /* test result:the data check */
  transfer_status1 = buffer_compare(spi2_rx_buffer, spi1_tx_buffer, BUFFER_SIZE);
  transfer_status2 = buffer_compare(spi1_rx_buffer, spi2_tx_buffer, BUFFER_SIZE);

  /* test result indicate:if SUCCESS ,led2 lights */
  if((transfer_status1 == SUCCESS) && (transfer_status2 == SUCCESS))
  {
    at32_led_on(LED2);
  }
  else
  {
    at32_led_on(LED3);
  }
  while(1)
  {
  }
}

代码讲解

系统时钟初始化：配置 MCU 的主频和时钟树。不同芯片的时钟配置不同，一般由工具生成。

板级初始化：初始化开发板上的 LED、按键等基础外设。

GPIO 配置：设置引脚为输出/输入模式，选择推挽/开漏输出，配置上拉/下拉。

DMA 配置：设置源地址、目标地址、传输方向、数据宽度。DMA 搬运数据不占用 CPU。

SPI 配置：设置主/从模式、时钟极性（CPOL）、时钟相位（CPHA）、分频系数。主机和从机的 CPOL/CPHA 必须一致。

实验现象

主机和从机互相交换数据
数据校验通过则 LED 指示成功

注意事项

CPOL 和 CPHA 必须主机从机一致
片选（CS）信号要手动拉低选中从机
时钟频率不能超过从设备的最大速率

AT32 SPI — 全双工轮询通信

Tue, 08 Sep 2026 14:52:21 +0800

SPI — 全双工轮询通信

固件库: AT32F403A_407_Firmware_Library V2.2.2
芯片: AT32
源文件: AT32/AT32F403A_407_Firmware_Library_V2.2.2/project/at_start_f403a/examples/spi/fullduplex_polling/src/main.c

功能简介

本示例演示 SPI 全双工通信。主机和从机可以同时收发数据，速度比 I2C 快得多。适合高速数据传输场景。

硬件准备

需要主机和从机两块板子，或使用回环连接（MOSI→MISO）

完整代码

#include "at32f403a_407_board.h"
#include "at32f403a_407_clock.h"
#include <stdio.h>
#define SPI1_AS_MASTER_CS_HIGH   gpio_bits_set(GPIOA, GPIO_PINS_4)
#define SPI1_AS_MASTER_CS_LOW    gpio_bits_reset(GPIOA, GPIO_PINS_4)
#define SPI2_AS_MASTER_CS_HIGH   gpio_bits_set(GPIOB, GPIO_PINS_12)
#define SPI2_AS_MASTER_CS_LOW    gpio_bits_reset(GPIOB, GPIO_PINS_12)
#define BUFFER_SIZE              32

static void spi_config(void)
{
  /* master spi initialization */
  crm_periph_clock_enable(CRM_SPI1_PERIPH_CLOCK, TRUE);
  spi_default_para_init(&spi_init_struct);
  
  /* dual line unidirectional full-duplex mode */
  spi_init_struct.transmission_mode = SPI_TRANSMIT_FULL_DUPLEX;
  spi_init_struct.master_slave_mode = SPI_MODE_MASTER;
  spi_init_struct.mclk_freq_division = SPI_MCLK_DIV_8;
  spi_init_struct.first_bit_transmission = SPI_FIRST_BIT_LSB;
  spi_init_struct.frame_bit_num = SPI_FRAME_8BIT;
  spi_init_struct.clock_polarity = SPI_CLOCK_POLARITY_LOW;
  spi_init_struct.clock_phase = SPI_CLOCK_PHASE_2EDGE;
  spi_init_struct.cs_mode_selection = SPI_CS_SOFTWARE_MODE;
  spi_init(SPI1, &spi_init_struct);
  
  spi_enable(SPI1, TRUE);
  
  /* slave spi initialization */
  crm_periph_clock_enable(CRM_SPI2_PERIPH_CLOCK, TRUE);
  
  /* dual line unidirectional full-duplex mode */
  spi_init_struct.transmission_mode = SPI_TRANSMIT_FULL_DUPLEX;
  spi_init_struct.master_slave_mode = SPI_MODE_SLAVE;
  spi_init_struct.mclk_freq_division = SPI_MCLK_DIV_8;
  spi_init_struct.first_bit_transmission = SPI_FIRST_BIT_LSB;
  spi_init_struct.frame_bit_num = SPI_FRAME_8BIT;
  spi_init_struct.clock_polarity = SPI_CLOCK_POLARITY_LOW;
  spi_init_struct.clock_phase = SPI_CLOCK_PHASE_2EDGE;
  spi_init_struct.cs_mode_selection = SPI_CS_HARDWARE_MODE;
  spi_init(SPI2, &spi_init_struct);

  spi_enable(SPI2, TRUE);
}

static void gpio_config(uint16_t spi1_mode, uint16_t spi2_mode)
{
  gpio_init_type gpio_initstructure;
  crm_periph_clock_enable(CRM_GPIOA_PERIPH_CLOCK, TRUE);
  crm_periph_clock_enable(CRM_GPIOB_PERIPH_CLOCK, TRUE);
  gpio_default_para_init(&gpio_initstructure);
  
  /* spi1 cs pin */
  gpio_initstructure.gpio_out_type = GPIO_OUTPUT_PUSH_PULL;
  gpio_initstructure.gpio_pull = GPIO_PULL_UP;
  gpio_initstructure.gpio_drive_strength = GPIO_DRIVE_STRENGTH_STRONGER;
  if(spi1_mode == SPI_MODE_MASTER)
  {
    gpio_initstructure.gpio_mode = GPIO_MODE_OUTPUT;
  }
  else
  {
    gpio_initstructure.gpio_mode = GPIO_MODE_INPUT;
  }
  gpio_initstructure.gpio_pins = GPIO_PINS_4;
  gpio_init(GPIOA, &gpio_initstructure);
  
  /* spi1 sck pin */
  gpio_initstructure.gpio_pull = GPIO_PULL_DOWN;
  if(spi1_mode == SPI_MODE_MASTER)
  {
    gpio_initstructure.gpio_mode = GPIO_MODE_MUX;
  }
  else
  {
    gpio_initstructure.gpio_mode = GPIO_MODE_INPUT;
  }
  gpio_initstructure.gpio_pins = GPIO_PINS_5;
  gpio_init(GPIOA, &gpio_initstructure);

  /* spi1 miso pin */
  gpio_initstructure.gpio_pull = GPIO_PULL_UP;
  if(spi1_mode == SPI_MODE_MASTER)
  {
    gpio_initstructure.gpio_mode = GPIO_MODE_INPUT;
  }
  else
  {
    gpio_initstructure.gpio_mode = GPIO_MODE_MUX;
  }
  gpio_initstructure.gpio_pins = GPIO_PINS_6;
  gpio_init(GPIOA, &gpio_initstructure);

  /* spi1 mosi pin */
  gpio_initstructure.gpio_pull = GPIO_PULL_UP;
  if(spi1_mode == SPI_MODE_MASTER)
  {
    gpio_initstructure.gpio_mode = GPIO_MODE_MUX;
  }
  else
  {
    gpio_initstructure.gpio_mode = GPIO_MODE_INPUT;
  }
  gpio_initstructure.gpio_pins = GPIO_PINS_7;
  gpio_init(GPIOA, &gpio_initstructure);
  
  /* spi2 cs pin */
  gpio_initstructure.gpio_out_type = GPIO_OUTPUT_PUSH_PULL;
  gpio_initstructure.gpio_pull = GPIO_PULL_UP;
  gpio_initstructure.gpio_drive_strength = GPIO_DRIVE_STRENGTH_STRONGER;
  if(spi2_mode == SPI_MODE_SLAVE)
  {
    gpio_initstructure.gpio_mode = GPIO_MODE_INPUT;
  }
  else
  {
    gpio_initstructure.gpio_mode = GPIO_MODE_OUTPUT;
  }
  gpio_initstructure.gpio_pins = GPIO_PINS_12;
  gpio_init(GPIOB, &gpio_initstructure);

  /* spi2 sck pin */
  gpio_initstructure.gpio_pull = GPIO_PULL_DOWN;
  if(spi2_mode == SPI_MODE_SLAVE)
  {
    gpio_initstructure.gpio_mode = GPIO_MODE_INPUT;
  }
  else
  {
    gpio_initstructure.gpio_mode = GPIO_MODE_MUX;
  }
  gpio_initstructure.gpio_pins = GPIO_PINS_13;
  gpio_init(GPIOB, &gpio_initstructure);

  /* spi2 miso pin */
  gpio_initstructure.gpio_pull = GPIO_PULL_UP;
  if(spi2_mode == SPI_MODE_SLAVE)
  {
    gpio_initstructure.gpio_mode = GPIO_MODE_MUX;
  }
  else
  {
    gpio_initstructure.gpio_mode = GPIO_MODE_INPUT;
  }
  gpio_initstructure.gpio_pins = GPIO_PINS_14;
  gpio_init(GPIOB, &gpio_initstructure);

  /* spi2 mosi pin */
  gpio_initstructure.gpio_pull = GPIO_PULL_UP;
  if(spi2_mode == SPI_MODE_SLAVE)
  {
    gpio_initstructure.gpio_mode = GPIO_MODE_INPUT;
  }
  else
  {
    gpio_initstructure.gpio_mode = GPIO_MODE_MUX;
  }
  gpio_initstructure.gpio_pins = GPIO_PINS_15;
  gpio_init(GPIOB, &gpio_initstructure);
  
  /* non communication time: master pull up CS pin release slave */
  if(spi1_mode == SPI_MODE_MASTER)
  {
    SPI1_AS_MASTER_CS_HIGH;
  }
  if(spi2_mode == SPI_MODE_MASTER)
  {
    SPI2_AS_MASTER_CS_HIGH;
  }
}

int main(void)
{
  __IO uint32_t index = 0;
  system_clock_config();
  at32_board_init();
  at32_led_on(LED4);
  gpio_config(SPI_MODE_MASTER, SPI_MODE_SLAVE);
  spi_config();
  
  /* start communication: master pull down CS pin select slave */
  SPI1_AS_MASTER_CS_LOW;
  
  /* transfer procedure:the "BUFFER_SIZE" data transfer */
  while(tx_index < BUFFER_SIZE)
  {
    /* slave and master transmit data fill */
    while(spi_i2s_flag_get(SPI2, SPI_I2S_TDBE_FLAG) == RESET);
    spi_i2s_data_transmit(SPI2, spi2_tx_buffer[tx_index]);
    while(spi_i2s_flag_get(SPI1, SPI_I2S_TDBE_FLAG) == RESET);
    spi_i2s_data_transmit(SPI1, spi1_tx_buffer[tx_index++]);
    
    /* slave and master receive data get */
    while(spi_i2s_flag_get(SPI2, SPI_I2S_RDBF_FLAG) == RESET);
    spi2_rx_buffer[rx_index] = spi_i2s_data_receive(SPI2);
    while(spi_i2s_flag_get(SPI1, SPI_I2S_RDBF_FLAG) == RESET);
    spi1_rx_buffer[rx_index++] = spi_i2s_data_receive(SPI1);
  }
  
  /* wait master and slave idle when communication end */
  while(spi_i2s_flag_get(SPI1, SPI_I2S_BF_FLAG) != RESET);
  while(spi_i2s_flag_get(SPI2, SPI_I2S_BF_FLAG) != RESET);
  
  /* end communication: master pull up CS pin release slave */
  SPI1_AS_MASTER_CS_HIGH;
  
  /* test result:the data check */
  transfer_status1 = buffer_compare(spi2_rx_buffer, spi1_tx_buffer, BUFFER_SIZE);
  transfer_status2 = buffer_compare(spi1_rx_buffer, spi2_tx_buffer, BUFFER_SIZE);
  
  spi_enable(SPI1, FALSE);
  spi_enable(SPI2, FALSE);
  
  /* master & slave mode switch */
  gpio_config(SPI_MODE_SLAVE, SPI_MODE_MASTER);
  spi_init_struct.master_slave_mode =SPI_MODE_SLAVE;
  spi_init_struct.cs_mode_selection = SPI_CS_HARDWARE_MODE;
  spi_init(SPI1, &spi_init_struct);
  
  spi_init_struct.master_slave_mode =SPI_MODE_MASTER;
  spi_init_struct.cs_mode_selection = SPI_CS_SOFTWARE_MODE;
  spi_init(SPI2, &spi_init_struct);
  
  /* receive buffer clear */
  tx_index = 0;
  rx_index = 0;
  for(index = 0; index < BUFFER_SIZE; index++)
  {
    spi1_rx_buffer[index] = 0;
    spi2_rx_buffer[index] = 0;
  }
  
  spi_enable(SPI2, TRUE);
  spi_enable(SPI1, TRUE);
  
  /* start communication: master pull down CS pin select slave */
  SPI2_AS_MASTER_CS_LOW;

  /* transfer procedure:the "BUFFER_SIZE" data transfer */
  while(tx_index < BUFFER_SIZE)
  {
    /* slave and master transmit data fill */
    while(spi_i2s_flag_get(SPI1, SPI_I2S_TDBE_FLAG) == RESET);
    spi_i2s_data_transmit(SPI1, spi1_tx_buffer[tx_index]);
    while(spi_i2s_flag_get(SPI2, SPI_I2S_TDBE_FLAG) == RESET);
    spi_i2s_data_transmit(SPI2, spi2_tx_buffer[tx_index++]);
    
    /* slave and master receive data get */
    while(spi_i2s_flag_get(SPI1, SPI_I2S_RDBF_FLAG) == RESET);
    spi1_rx_buffer[rx_index] = spi_i2s_data_receive(SPI1);
    while(spi_i2s_flag_get(SPI2, SPI_I2S_RDBF_FLAG) == RESET);
    spi2_rx_buffer[rx_index++] = spi_i2s_data_receive(SPI2);
  }
  
  /* wait master and slave idle when communication end */
  while(spi_i2s_flag_get(SPI2, SPI_I2S_BF_FLAG) != RESET);
  while(spi_i2s_flag_get(SPI1, SPI_I2S_BF_FLAG) != RESET);
  
  /* end communication: master pull up CS pin release slave */
  SPI2_AS_MASTER_CS_HIGH;

  /* test result:the data check */
  transfer_status3 = buffer_compare(spi2_rx_buffer, spi1_tx_buffer, BUFFER_SIZE);
  transfer_status4 = buffer_compare(spi1_rx_buffer, spi2_tx_buffer, BUFFER_SIZE);

  /* test result indicate:if SUCCESS ,led2 lights */
  if((transfer_status1 == SUCCESS) && (transfer_status2 == SUCCESS) && \
     (transfer_status3 == SUCCESS) && (transfer_status4 == SUCCESS))
  {
    at32_led_on(LED2);
  }
  else
  {
    at32_led_on(LED3);
  }
  while(1)
  {
  }
}

代码讲解

系统时钟初始化：配置 MCU 的主频和时钟树。不同芯片的时钟配置不同，一般由工具生成。

板级初始化：初始化开发板上的 LED、按键等基础外设。

GPIO 配置：设置引脚为输出/输入模式，选择推挽/开漏输出，配置上拉/下拉。

SPI 配置：设置主/从模式、时钟极性（CPOL）、时钟相位（CPHA）、分频系数。主机和从机的 CPOL/CPHA 必须一致。

实验现象

主机和从机互相交换数据
数据校验通过则 LED 指示成功

注意事项

CPOL 和 CPHA 必须主机从机一致
片选（CS）信号要手动拉低选中从机
时钟频率不能超过从设备的最大速率

AT32 SPI — 只接收模式轮询

Tue, 08 Sep 2026 14:52:21 +0800

SPI — 只接收模式轮询

固件库: AT32F403A_407_Firmware_Library V2.2.2
芯片: AT32
源文件: AT32/AT32F403A_407_Firmware_Library_V2.2.2/project/at_start_f403a/examples/spi/only_receive_mode_polling/src/main.c

功能简介

本示例演示 SPI 总线通信。SPI 是高速同步串行接口，常用于连接 Flash、LCD、传感器等外设。

硬件准备

需要主机和从机两块板子，或使用回环连接（MOSI→MISO）

完整代码

#include "at32f403a_407_board.h"
#include "at32f403a_407_clock.h"
#define SPI_MASTER_CS_HIGH   gpio_bits_set(GPIOA, GPIO_PINS_4)
#define SPI_MASTER_CS_LOW    gpio_bits_reset(GPIOA, GPIO_PINS_4)
#define BUFFER_SIZE          32

static void spi_config(void)
{
  spi_init_type spi_init_struct;
  
  /* master spi initialization */
  crm_periph_clock_enable(CRM_SPI1_PERIPH_CLOCK, TRUE);
  spi_default_para_init(&spi_init_struct);
  
  /* dual line unidirectional full-duplex mode */
  spi_init_struct.transmission_mode = SPI_TRANSMIT_FULL_DUPLEX;
  spi_init_struct.master_slave_mode = SPI_MODE_MASTER;
  spi_init_struct.mclk_freq_division = SPI_MCLK_DIV_8;
  spi_init_struct.first_bit_transmission = SPI_FIRST_BIT_LSB;
  spi_init_struct.frame_bit_num = SPI_FRAME_8BIT;
  spi_init_struct.clock_polarity = SPI_CLOCK_POLARITY_LOW;
  spi_init_struct.clock_phase = SPI_CLOCK_PHASE_2EDGE;
  spi_init_struct.cs_mode_selection = SPI_CS_SOFTWARE_MODE;
  spi_init(SPI1, &spi_init_struct);
  
  spi_enable(SPI1, TRUE);
  
  /* slave spi initialization */
  crm_periph_clock_enable(CRM_SPI2_PERIPH_CLOCK, TRUE);
  
  /* dual line unidirectional simplex receive-only mode */
  spi_init_struct.transmission_mode = SPI_TRANSMIT_SIMPLEX_RX;
  spi_init_struct.master_slave_mode = SPI_MODE_SLAVE;
  spi_init_struct.mclk_freq_division = SPI_MCLK_DIV_8;
  spi_init_struct.first_bit_transmission = SPI_FIRST_BIT_LSB;
  spi_init_struct.frame_bit_num = SPI_FRAME_8BIT;
  spi_init_struct.clock_polarity = SPI_CLOCK_POLARITY_LOW;
  spi_init_struct.clock_phase = SPI_CLOCK_PHASE_2EDGE;
  spi_init_struct.cs_mode_selection = SPI_CS_HARDWARE_MODE;
  spi_init(SPI2, &spi_init_struct);
  
  spi_enable(SPI2, TRUE);
}

static void gpio_config(void)
{
  gpio_init_type gpio_initstructure;
  crm_periph_clock_enable(CRM_GPIOA_PERIPH_CLOCK, TRUE);
  crm_periph_clock_enable(CRM_GPIOB_PERIPH_CLOCK, TRUE);
  gpio_default_para_init(&gpio_initstructure);
  
  /* master spi cs pin */
  gpio_initstructure.gpio_out_type = GPIO_OUTPUT_PUSH_PULL;
  gpio_initstructure.gpio_pull = GPIO_PULL_UP;
  gpio_initstructure.gpio_mode = GPIO_MODE_OUTPUT;
  gpio_initstructure.gpio_drive_strength = GPIO_DRIVE_STRENGTH_STRONGER;
  gpio_initstructure.gpio_pins = GPIO_PINS_4;
  gpio_init(GPIOA, &gpio_initstructure);
  
  /* non communication time: master pull up CS pin release slave */
  SPI_MASTER_CS_HIGH;
  
  /* master spi sck pin */
  gpio_initstructure.gpio_pull = GPIO_PULL_DOWN;
  gpio_initstructure.gpio_mode = GPIO_MODE_MUX;
  gpio_initstructure.gpio_pins = GPIO_PINS_5;
  gpio_init(GPIOA, &gpio_initstructure);
  
  /* master spi mosi pin */
  gpio_initstructure.gpio_pull = GPIO_PULL_UP;
  gpio_initstructure.gpio_mode = GPIO_MODE_MUX;
  gpio_initstructure.gpio_pins = GPIO_PINS_7;
  gpio_init(GPIOA, &gpio_initstructure);
  
  /* slave spi cs pin */
  gpio_initstructure.gpio_out_type = GPIO_OUTPUT_PUSH_PULL;
  gpio_initstructure.gpio_pull = GPIO_PULL_UP;
  gpio_initstructure.gpio_mode = GPIO_MODE_INPUT;
  gpio_initstructure.gpio_drive_strength = GPIO_DRIVE_STRENGTH_STRONGER;
  gpio_initstructure.gpio_pins = GPIO_PINS_12;
  gpio_init(GPIOB, &gpio_initstructure);
  
  /* slave spi sck pin */
  gpio_initstructure.gpio_pull = GPIO_PULL_DOWN;
  gpio_initstructure.gpio_mode = GPIO_MODE_INPUT;
  gpio_initstructure.gpio_pins = GPIO_PINS_13;
  gpio_init(GPIOB, &gpio_initstructure);

  /* slave spi mosi pin */
  gpio_initstructure.gpio_pull = GPIO_PULL_UP;
  gpio_initstructure.gpio_mode = GPIO_MODE_INPUT;
  gpio_initstructure.gpio_pins = GPIO_PINS_15;
  gpio_init(GPIOB, &gpio_initstructure);
}

int main(void)
{
  system_clock_config();
  at32_board_init();
  at32_led_on(LED4);
  gpio_config();
  spi_config();
  
  /* start communication: master pull down CS pin select slave */
  SPI_MASTER_CS_LOW;
  
  /* transfer procedure:the "BUFFER_SIZE" data transfer */
  while(tx_index < BUFFER_SIZE)
  {
    /* master transmit data fill */
    while(spi_i2s_flag_get(SPI1, SPI_I2S_TDBE_FLAG) == RESET);
    spi_i2s_data_transmit(SPI1, spi1_tx_buffer[tx_index++]);
    
    /* slave receive data get */
    while(spi_i2s_flag_get(SPI2, SPI_I2S_RDBF_FLAG) == RESET);
    spi2_rx_buffer[rx_index++] = spi_i2s_data_receive(SPI2);
  }
  
  /* wait master and slave idle when communication end */
  while(spi_i2s_flag_get(SPI1, SPI_I2S_BF_FLAG) != RESET);
  while(spi_i2s_flag_get(SPI2, SPI_I2S_BF_FLAG) != RESET);
  
  /* end communication: master pull up CS pin release slave */
  SPI_MASTER_CS_HIGH;

  /* test result:the data check */
  transfer_status = buffer_compare(spi2_rx_buffer, spi1_tx_buffer, BUFFER_SIZE);

  /* test result indicate:if SUCCESS ,led2 lights */
  if(transfer_status == SUCCESS)
  {
    at32_led_on(LED2);
  }
  else
  {
    at32_led_on(LED3);
  }
  while(1)
  {
  }
}

代码讲解

系统时钟初始化：配置 MCU 的主频和时钟树。不同芯片的时钟配置不同，一般由工具生成。

板级初始化：初始化开发板上的 LED、按键等基础外设。

GPIO 配置：设置引脚为输出/输入模式，选择推挽/开漏输出，配置上拉/下拉。

SPI 配置：设置主/从模式、时钟极性（CPOL）、时钟相位（CPHA）、分频系数。主机和从机的 CPOL/CPHA 必须一致。

实验现象

主机和从机互相交换数据
数据校验通过则 LED 指示成功

注意事项

CPOL 和 CPHA 必须主机从机一致
片选（CS）信号要手动拉低选中从机
时钟频率不能超过从设备的最大速率

CIU32 — SPI 总线

Tue, 08 Sep 2026 14:52:21 +0800

CIU32 — SPI 总线

固件库: CIU32F003_STDLib V1.0.3
示例数: 3

什么是 SPI 总线?

SPI 是高速同步串行接口，支持全双工通信。常用于连接 Flash、LCD、传感器等外设，速度可达几十 MHz。

示例列表

SPI1 主机 GPIO 片选 — SPI1_Master_GPIO_As_NSS
SPI1 主机轮询 — SPI1_Master_Poll
SPI1 从机中断 — SPI1_Slave_Interrupt

CIU32 SPI — SPI1 从机中断

Tue, 08 Sep 2026 14:52:21 +0800

SPI — SPI1 从机中断

固件库: CIU32F003_STDLib V1.0.3
芯片: CIU32
源文件: CIU32/CIU32F003_STDLib_V1.0.3/Projects/SPI/SPI1_Slave_Interrupt/Source/main.c

功能简介

本示例演示 SPI 总线通信。SPI 是高速同步串行接口，常用于连接 Flash、LCD、传感器等外设。

硬件准备

需要主机和从机两块板子，或使用回环连接（MOSI→MISO）

完整代码

#include "main.h"

int main(void)
{
    /* ϵͳʱ */
    system_clock_config();
  
    /* GPIOʼ */
    gpio_init();
    
    /* SPIʼΪģʽ */
    spi1_init();
    
    /* NVICʼ */
    nvic_init();
    
    /* ȴ */
    while(g_send_count < 8);
    
    /* ȴ */
    while(g_recv_count < 8);
    
    while(1)
    {
    }
}

代码讲解

系统时钟初始化：配置 MCU 的主频和时钟树。不同芯片的时钟配置不同，一般由工具生成。

GPIO 配置：设置引脚为输出/输入模式，选择推挽/开漏输出，配置上拉/下拉。

中断优先级配置：NVIC 设置中断的抢占优先级和子优先级。数字越小优先级越高。

实验现象

主机和从机互相交换数据
数据校验通过则 LED 指示成功

注意事项

CPOL 和 CPHA 必须主机从机一致
片选（CS）信号要手动拉低选中从机
时钟频率不能超过从设备的最大速率

CIU32 SPI — SPI1 主机 GPIO 片选

Tue, 08 Sep 2026 14:52:21 +0800

SPI — SPI1 主机 GPIO 片选

固件库: CIU32F003_STDLib V1.0.3
芯片: CIU32
源文件: CIU32/CIU32F003_STDLib_V1.0.3/Projects/SPI/SPI1_Master_GPIO_As_NSS/Source/main.c

功能简介

本示例演示 SPI 总线通信。SPI 是高速同步串行接口，常用于连接 Flash、LCD、传感器等外设。

硬件准备

需要主机和从机两块板子，或使用回环连接（MOSI→MISO）

完整代码

#include "main.h"

int main(void)
{
    uint32_t index = 0;
    
    /* ϵͳʱ */
    system_clock_config();
    
    /* GPIOʼ */
    gpio_init();

    /* SPIʼ */
    spi1_init();
    
    /* SPIģʽ,Ƭѡź */
    std_gpio_reset_pin(NSS_PORT, NSS_PIN);
    std_spi_set_nss_output(SPI_NSS_OUTPUT_LOW);

    /* SPIݴ */
    for(index=0; index<8; index++)
    {
        /* ȴݼĴΪ */
        while(std_spi_get_flag(SPI_FLAG_TXFE) != SPI_FLAG_TXFE);
        /*  */ 
        std_spi_write_data(g_send_buffer[index]);
        
        /* ȴݼĴǿ */
        while(std_spi_get_flag(SPI_FLAG_RXFNE) != SPI_FLAG_RXFNE);
        /*  */ 
        g_recv_buffer[index] = std_spi_read_data();
    }

    /* SPIƬѡźţͨ */
    while(!std_spi_get_flag(SPI_FLAG_TXFE));
    while(std_spi_get_flag(SPI_FLAG_BUSY));
    std_spi_set_nss_output(SPI_NSS_OUTPUT_HIGH);
    std_gpio_set_pin(NSS_PORT, NSS_PIN);
    
    while(1)
    {
    }
}

代码讲解

系统时钟初始化：配置 MCU 的主频和时钟树。不同芯片的时钟配置不同，一般由工具生成。

GPIO 配置：设置引脚为输出/输入模式，选择推挽/开漏输出，配置上拉/下拉。

SPI 配置：设置主/从模式、时钟极性（CPOL）、时钟相位（CPHA）、分频系数。主机和从机的 CPOL/CPHA 必须一致。

实验现象

主机和从机互相交换数据
数据校验通过则 LED 指示成功

注意事项

CPOL 和 CPHA 必须主机从机一致
片选（CS）信号要手动拉低选中从机
时钟频率不能超过从设备的最大速率

CIU32 SPI — SPI1 主机轮询

Tue, 08 Sep 2026 14:52:21 +0800

SPI — SPI1 主机轮询

固件库: CIU32F003_STDLib V1.0.3
芯片: CIU32
源文件: CIU32/CIU32F003_STDLib_V1.0.3/Projects/SPI/SPI1_Master_Poll/Source/main.c

功能简介

本示例演示 SPI 总线通信。SPI 是高速同步串行接口，常用于连接 Flash、LCD、传感器等外设。

硬件准备

需要主机和从机两块板子，或使用回环连接（MOSI→MISO）

完整代码

#include "main.h"

int main(void)
{
    uint32_t index = 0;
    
    /* ϵͳʱ */
    system_clock_config();
    
    /* GPIOʼ */
    gpio_init();

    /* SPIʼ */
    spi1_init();
    
    /* SPIģʽ,Ƭѡź */
    std_spi_set_nss_output(SPI_NSS_OUTPUT_LOW);

    /* SPIݴ */
    for(index=0; index<8; index++)
    {
        /* ȴݼĴΪ */
        while(std_spi_get_flag(SPI_FLAG_TXFE) != SPI_FLAG_TXFE);
        /*  */
        std_spi_write_data(g_send_buffer[index]);
        
        /* ȴݼĴǿ */
        while(std_spi_get_flag(SPI_FLAG_RXFNE) != SPI_FLAG_RXFNE);
        /*  */ 
        g_recv_buffer[index] = std_spi_read_data();
    }

    /* SPIƬѡźţͨ */
    while(!std_spi_get_flag(SPI_FLAG_TXFE));
    while(std_spi_get_flag(SPI_FLAG_BUSY));
    std_spi_set_nss_output(SPI_NSS_OUTPUT_HIGH);
    
    while(1)
    {
    }
}

代码讲解

系统时钟初始化：配置 MCU 的主频和时钟树。不同芯片的时钟配置不同，一般由工具生成。

GPIO 配置：设置引脚为输出/输入模式，选择推挽/开漏输出，配置上拉/下拉。

SPI 配置：设置主/从模式、时钟极性（CPOL）、时钟相位（CPHA）、分频系数。主机和从机的 CPOL/CPHA 必须一致。

实验现象

主机和从机互相交换数据
数据校验通过则 LED 指示成功

注意事项

CPOL 和 CPHA 必须主机从机一致
片选（CS）信号要手动拉低选中从机
时钟频率不能超过从设备的最大速率

GD32 — SPI 同步串行总线 (SPI)

Tue, 08 Sep 2026 14:52:21 +0800

GD32 — SPI 同步串行总线 (SPI)

固件库: GD32F30x_Firmware_Library V3.0.3
示例数: 7
推荐入门: SPI_master_slave_fullduplex_polling（主从全双工轮询）

什么是 SPI？

SPI（Serial Peripheral Interface，串行外设接口）是 Motorola 提出的一种高速、全双工、同步串行总线。它和 I2C 一样也是"板内短距离"通信总线，但速度更快（GD32F30x 的 SPI 最高可达 30 MHz 左右，而 I2C 通常只有 400 kHz / 1 MHz），因此常被用来接 Flash、LCD 屏、SD 卡、射频模块、ADC/DAC 等需要大数据吞吐量的外设。

一句话记忆：I2C 是"省线"的总线，SPI 是"图快"的总线。

四根信号线

信号	全称	方向	说明
SCK	Serial Clock	主机 → 从机	时钟线，由主机产生，数据在时钟边沿被采样
MOSI	Master Out Slave In	主机 → 从机	主机发、从机收
MISO	Master In Slave Out	从机 → 主机	从机发、主机收
NSS / CS	Slave Select / Chip Select	主机 → 从机	片选，低电平选中某个从机

因为 MOSI 和 MISO 各走各的，所以 SPI 天然全双工——主机发一个字节的同时，从机也在回一个字节。这也是为什么 SPI 比 I2C（半双工，同一根线来回切换）快得多。

NSS 为什么重要？ 一根 SPI 总线上可以挂多个从机，它们共用 SCK/MOSI/MISO，但每个从机独占一根 NSS。主机想跟谁说话，就把谁的 NSS 拉低（其余保持高电平）。这就是为什么 SPI 叫"一主多从"却不需要像 I2C 那样给从机分配地址。

CPOL 与 CPHA（时钟极性 / 时钟相位）

SPI 没有统一的"起始位/停止位"帧格式，双方靠时钟的极性和相位对齐数据。这是新手最容易踩坑的地方：

CPOL（Clock Polarity，时钟极性）：空闲时 SCK 的电平。
- CPOL = 0：空闲为低电平
- CPOL = 1：空闲为高电平
CPHA（Clock Phase，时钟相位）：数据在第几个边沿被采样。
- CPHA = 0：在第 1 个时钟边沿采样（CPOL=0 时即上升沿）
- CPHA = 1：在第 2 个时钟边沿采样

CPOL 和 CPHA 组合出 4 种模式（模式 0~3）。主从双方必须配置成同一种模式，否则采样到的数据就是错的（典型的"乱码"来源）。最常见的模式 0 对应 CPOL=0, CPHA=0= 本库里的 SPI_CK_PL_LOW_PH_1EDGE。

还有几个需要理解的概念

主从（Master / Slave）：时钟只能由主机产生。从机永远跟着主机的 SCK 走。
帧长度（Frame Size）：通常是 8 位（一个字节），也可以配成 16 位。
波特率分频（Prescaler）：SPI 时钟 = APB 时钟 / 分频系数。从机有最高速率限制，分频要足够大。
NSS 软 / 硬（SPI_NSS_SOFT / SPI_NSS_HARD）：
- 软 NSS：片选由软件通过普通 GPIO 拉高拉低，库里用 spi_nss_internal_software_config() 或自己控制 GPIO。
- 硬 NSS：由 SPI 外设内部硬件自动管理 NSS 引脚（从机模式下尤其常用，NSS 被拉低才真正开始通信）。

GD32F30x 的 SPI 资源

GD32F30x 通常有 SPI0 / SPI1 / SPI2 三路 SPI（不同型号略有差异）。
SPI0 / SPI1 挂载在 APB2 总线（高速），SPI2 挂载在 APB1 总线（低速）。
部分 SPI 支持引脚重映射，需要在 rcu_periph_clock_enable(RCU_AF) 之后调用 gpio_pin_remap_config()。

三种数据收发方式

方式	特点	适用场景
轮询（Polling）	死等标志位，最简单但占用 CPU	教学、数据量小
中断（Interrupt）	收发完成进中断，CPU 可干别的	中等数据量
DMA	数据自动搬运，CPU 几乎不参与	大批量数据（如 LCD 刷屏、Flash 读写）

本模块入门示例 SPI_master_slave_fullduplex_polling 采用轮询方式，逻辑最直观，建议先吃透它。

常用库函数速查

函数	作用
`spi_init(SPIx, &spi_init_struct)`	按结构体初始化 SPI
`spi_enable(SPIx)` / `spi_disable(SPIx)`	使能/关闭 SPI
`spi_i2s_data_transmit(SPIx, data)`	发送一个字节/半字
`spi_i2s_data_receive(SPIx)`	读取接收数据寄存器
`spi_i2s_flag_get(SPIx, flag)`	查询标志位（TBE / RBNE 等）
`spi_nss_internal_software_config(SPIx, mode)`	软件 NSS 控制（拉高/拉低）
`spi_crc_on(SPIx)` / `spi_crc_next(SPIx)`	开启 / 触发下一次 CRC

两个关键标志位

TBE（Transmit Buffer Empty，发送缓冲空）：发送寄存器空了、可以塞下一个数据。轮询发送时 while(RESET == spi_i2s_flag_get(SPIx, SPI_FLAG_TBE)); 就是在等它。
RBNE（Receive Buffer Not Empty，接收缓冲非空）：收到了一个数据、等着被读走。轮询接收时 while(RESET == spi_i2s_flag_get(SPIx, SPI_FLAG_RBNE));。

为什么要"先发后收"都等 TBE / RBNE？ 因为 SPI 是全双工的：主机每发出去 1 位，从机也同时回 1 位。所以"发送一个字节"和"接收一个字节"天然是同一个 8 个时钟周期里完成的。主机拉低 NSS 后，每发一个字节就会从从机收一个字节，因此收发循环总是"等 TBE 发 → 等 RBNE 收"成对出现。

示例列表

SPI 主从全双工轮询 — SPI_master_slave_fullduplex_polling ★ 入门推荐
SPI 主从全双工 DMA — SPI_master_slave_fullduplex_dma
SPI 主从 NSS 硬件模式 — SPI_master_slave_fullduplex_nssp_mode
SPI 主从 TI 模式 — SPI_master_slave_fullduplex_ti_mode
SPI 主从单工 DMA — SPI_master_slave_simplex_dma
SPI 主发从收中断 — SPI_master_transmit_slave_receive_interrupt
I2S 主发从收 DMA — I2S_master_transmit_slave_receive_dma

学习路径建议

先跑通 SPI_master_slave_fullduplex_polling，理解"开时钟 → 配 GPIO（AF 复用）→ 配 SPI 参数 → 拉低 NSS → 轮询收发 → 拉高 NSS"这一整套流程。
再研究 SPI_master_slave_fullduplex_dma，把轮询换成 DMA，体会 CPU 占用率的变化。
需要接真实芯片（如 W25Q 系列 Flash、LCD）时，重点查它的模式（CPOL/CPHA）和最高速率，把分频配对。

下一篇：SPI 主从全双工轮询

GD32 SPI — I2S 主发从收 DMA

Tue, 08 Sep 2026 14:52:21 +0800

SPI — I2S 主发从收 DMA

固件库: GD32F30x_Firmware_Library V3.0.3
芯片: GD32
源文件: GD32F30x_Firmware_Library_V3.0.3/Examples/SPI/I2S_master_transmit_slave_receive_dma/main.c

功能简介

本示例演示 SPI 总线通信。SPI 是高速同步串行接口，常用于连接 Flash、LCD、传感器等外设。

硬件准备

需要主机和从机两块板子，或使用回环连接（MOSI→MISO）

完整代码

#include "gd32f30x.h"
#include "gd32f307c_eval.h"
#define arraysize         10

void rcu_config(void);
void gpio_config(void);
void dma_config(void);
void spi_config(void);

/*!
    \brief      main function
    \param[in]  none
    \param[out] none
    \retval     none
*/
int main(void)
{
    /* init led2 */
    gd_eval_led_init(LED2);

    /* peripheral clock enable */
    rcu_config();
    /* GPIO config */
    gpio_config();
    /* DMA config */
    dma_config();
    /* SPI config */
    spi_config();

    /* SPI enable */
    i2s_enable(SPI2);
    i2s_enable(SPI1);

    /* DMA channel enable */
    dma_channel_enable(DMA0,DMA_CH4);
    dma_channel_enable(DMA1,DMA_CH0);

    /* SPI DMA enable */
    spi_dma_enable(SPI2, SPI_DMA_RECEIVE);
    spi_dma_enable(SPI1, SPI_DMA_TRANSMIT);

    /* wait DMA transmit complete */
    while(!dma_flag_get(DMA0, DMA_CH4, DMA_INTF_FTFIF));
    while(!dma_flag_get(DMA1, DMA_CH0, DMA_INTF_FTFIF));

    /* compare receive data with send data */
    if(memory_compare(spi2_receive_array, spi1_send_array, arraysize))
        gd_eval_led_on(LED2);
    else
        gd_eval_led_off(LED2);

    while(1);
}

void rcu_config(void)
{
#ifdef GD32F30X_CL
    rcu_pll2_config(RCU_PLL2_MUL8);
    rcu_osci_on(RCU_PLL2_CK);
    while((RCU_CTL & RCU_CTL_PLL2STB) == 0)
    {
    }
    rcu_i2s1_clock_config(RCU_I2S1SRC_CKPLL2_MUL2);
    rcu_i2s2_clock_config(RCU_I2S2SRC_CKPLL2_MUL2);
#endif

    rcu_periph_clock_enable(RCU_SPI1);
    rcu_periph_clock_enable(RCU_SPI2);
    rcu_periph_clock_enable(RCU_GPIOA);
    rcu_periph_clock_enable(RCU_GPIOB);
    rcu_periph_clock_enable(RCU_DMA0);
    rcu_periph_clock_enable(RCU_DMA1);
}

void gpio_config(void)
{
    /* I2S1 GPIO config: I2S1_WS/PB12, I2S1_CK/PB13, I2S_SD/PB15 */
    gpio_init(GPIOB, GPIO_MODE_AF_PP, GPIO_OSPEED_50MHZ, GPIO_PIN_12 | GPIO_PIN_13 |GPIO_PIN_15);

    /* I2S2 GPIO config: I2S2_WS/PA15, I2S2_CK/PB3, I2S2_SD/PB5 */
    gpio_init(GPIOB, GPIO_MODE_IN_FLOATING, GPIO_OSPEED_50MHZ, GPIO_PIN_3 | GPIO_PIN_5);
    gpio_init(GPIOA, GPIO_MODE_IN_FLOATING, GPIO_OSPEED_50MHZ, GPIO_PIN_15);
}

void dma_config(void)
{
    dma_parameter_struct dma_init_struct;
    
    /* SPI1 transmit dma config: DMA0,DMA_CH4  */
    dma_deinit(DMA0, DMA_CH4);
    dma_init_struct.periph_addr  = (uint32_t)&SPI_DATA(SPI1);
    dma_init_struct.memory_addr  = (uint32_t)spi1_send_array;
    dma_init_struct.direction    = DMA_MEMORY_TO_PERIPHERAL;
    dma_init_struct.memory_width = DMA_MEMORY_WIDTH_8BIT;
    dma_init_struct.periph_width = DMA_PERIPHERAL_WIDTH_8BIT;
    dma_init_struct.priority     = DMA_PRIORITY_LOW;
    dma_init_struct.number       = arraysize;
    dma_init_struct.periph_inc   = DMA_PERIPH_INCREASE_DISABLE;
    dma_init_struct.memory_inc   = DMA_MEMORY_INCREASE_ENABLE;
    dma_init(DMA0, DMA_CH4, &dma_init_struct);
    /* configure DMA mode */
    dma_circulation_disable(DMA0, DMA_CH4);
    dma_memory_to_memory_disable(DMA0, DMA_CH4);

    /* SPI2 receive dma config: DMA1-DMA_CH0 */
    dma_deinit(DMA1, DMA_CH0);
    dma_init_struct.periph_addr  = (uint32_t)&SPI_DATA(SPI2);
    dma_init_struct.memory_addr  = (uint32_t)spi2_receive_array;
    dma_init_struct.direction    = DMA_PERIPHERAL_TO_MEMORY;
    dma_init_struct.priority     = DMA_PRIORITY_HIGH;
    dma_init(DMA1, DMA_CH0, &dma_init_struct);
    /* configure DMA mode */
    dma_circulation_disable(DMA1, DMA_CH0);
    dma_memory_to_memory_disable(DMA1, DMA_CH0);
}

void spi_config(void)
{
    spi_i2s_deinit(SPI1);
    spi_i2s_deinit(SPI2);

    i2s_init(SPI1, I2S_MODE_MASTERTX, I2S_STD_PHILIPS, I2S_CKPL_LOW);
    i2s_psc_config(SPI1, I2S_AUDIOSAMPLE_11K, I2S_FRAMEFORMAT_DT16B_CH16B, I2S_MCKOUT_DISABLE);
    
    i2s_init(SPI2, I2S_MODE_SLAVERX, I2S_STD_PHILIPS, I2S_CKPL_LOW);
    i2s_psc_config(SPI2, I2S_AUDIOSAMPLE_11K, I2S_FRAMEFORMAT_DT16B_CH16B, I2S_MCKOUT_DISABLE);
}

代码讲解

GPIO 配置：设置引脚为输出/输入模式，选择推挽/开漏输出，配置上拉/下拉。

DMA 配置：设置源地址、目标地址、传输方向、数据宽度。DMA 搬运数据不占用 CPU。

SPI 配置：设置主/从模式、时钟极性（CPOL）、时钟相位（CPHA）、分频系数。主机和从机的 CPOL/CPHA 必须一致。

实验现象

主机和从机互相交换数据
数据校验通过则 LED 指示成功

注意事项

CPOL 和 CPHA 必须主机从机一致
片选（CS）信号要手动拉低选中从机
时钟频率不能超过从设备的最大速率

GD32 SPI — SPI 主从 NSS 硬件模式

Tue, 08 Sep 2026 14:52:21 +0800

SPI — SPI 主从 NSS 硬件模式

固件库: GD32F30x_Firmware_Library V3.0.3
芯片: GD32
源文件: GD32F30x_Firmware_Library_V3.0.3/Examples/SPI/SPI_master_slave_fullduplex_nssp_mode/main.c

功能简介

本示例演示 SPI 全双工通信。主机和从机可以同时收发数据，速度比 I2C 快得多。适合高速数据传输场景。

硬件准备

需要主机和从机两块板子，或使用回环连接（MOSI→MISO）

完整代码

#include "gd32f30x.h"
#include "gd32f307c_eval.h"
#define arraysize         10

void rcu_config(void);
void gpio_config(void);
void dma_config(void);
void spi_config(void);

/*!
    \brief      main function
    \param[in]  none
    \param[out] none
    \retval     none
*/
int main(void)
{
    /* init led2 and led3 */
    gd_eval_led_init(LED2);
    gd_eval_led_init(LED3);

    /* peripheral clock enable */
    rcu_config();
    /* GPIO config */
    gpio_config();
    /* DMA config */
    dma_config();
    /* SPI config */
    spi_config();

    /* SPI NSSP mode enable */
    spi_nssp_mode_enable(SPI0);
    spi_nss_output_enable(SPI0);

    /* SPI enable */
    spi_enable(SPI2);
    spi_enable(SPI0);

    /* DMA channel enable */
    dma_channel_enable(DMA0,DMA_CH1);
    dma_channel_enable(DMA0,DMA_CH2);
    dma_channel_enable(DMA1,DMA_CH0);
    dma_channel_enable(DMA1,DMA_CH1);

    /* SPI DMA enable */
    spi_dma_enable(SPI2, SPI_DMA_TRANSMIT);
    spi_dma_enable(SPI2, SPI_DMA_RECEIVE);
    spi_dma_enable(SPI0, SPI_DMA_TRANSMIT);
    spi_dma_enable(SPI0, SPI_DMA_RECEIVE);

    /* wait dma transmit complete */
    while(!dma_flag_get(DMA0,DMA_CH2,DMA_FLAG_FTF));
    while(!dma_flag_get(DMA1,DMA_CH1,DMA_FLAG_FTF));
    while(!dma_flag_get(DMA1,DMA_CH0,DMA_FLAG_FTF));
    while(!dma_flag_get(DMA0,DMA_CH1,DMA_FLAG_FTF));

    /* compare receive data with send data */
    if(memory_compare(spi2_receive_array, spi0_send_array, arraysize))
        gd_eval_led_on(LED2);
    else
        gd_eval_led_off(LED2);
    if(memory_compare(spi0_receive_array, spi2_send_array, arraysize))
        gd_eval_led_on(LED3);
    else
        gd_eval_led_off(LED3);

    while(1);
}

void rcu_config(void)
{
    rcu_periph_clock_enable(RCU_GPIOA);
    rcu_periph_clock_enable(RCU_GPIOB);
    rcu_periph_clock_enable(RCU_GPIOC);
    rcu_periph_clock_enable(RCU_DMA0);
    rcu_periph_clock_enable(RCU_DMA1);
    rcu_periph_clock_enable(RCU_SPI0);
    rcu_periph_clock_enable(RCU_SPI2);
    rcu_periph_clock_enable(RCU_AF);
}

void gpio_config(void)
{
    /* JTAG-DP disabled and SW-DP enabled, so SPI0 can use PB3 and PB4 */
    gpio_pin_remap_config(GPIO_SWJ_SWDPENABLE_REMAP,ENABLE);

    gpio_pin_remap_config(GPIO_SPI0_REMAP, ENABLE);
    /* SPI0 GPIO config: NSS/PA15, SCK/PB3, MOSI/PB5 */
    gpio_init(GPIOA, GPIO_MODE_AF_PP, GPIO_OSPEED_50MHZ, GPIO_PIN_15);
    gpio_init(GPIOB, GPIO_MODE_AF_PP, GPIO_OSPEED_50MHZ, GPIO_PIN_3 | GPIO_PIN_5);
    /* SPI0 GPIO config: MISO/PB4 */
    gpio_init(GPIOB, GPIO_MODE_IN_FLOATING, GPIO_OSPEED_50MHZ, GPIO_PIN_4);
    
    gpio_pin_remap_config(GPIO_SPI2_REMAP, ENABLE);
    /* SPI2 GPIO config: NSS/PA4 */
    gpio_init(GPIOA, GPIO_MODE_IN_FLOATING, GPIO_OSPEED_50MHZ, GPIO_PIN_4);
    /* SPI2 GPIO config: SCK/PC10, MOSI/PC12 */
    gpio_init(GPIOC, GPIO_MODE_IN_FLOATING, GPIO_OSPEED_50MHZ, GPIO_PIN_10 |GPIO_PIN_12);
    /* SPI2 GPIO config: MISO/PC11 */
    gpio_init(GPIOC, GPIO_MODE_AF_PP, GPIO_OSPEED_50MHZ, GPIO_PIN_11);
}

void dma_config(void)
{
    dma_parameter_struct dma_init_struct;
    
    /* SPI0 transmit dma config:DMA0-DMA_CH2  */
    dma_deinit(DMA0, DMA_CH2);
    dma_init_struct.periph_addr  = (uint32_t)&SPI_DATA(SPI0);
    dma_init_struct.memory_addr  = (uint32_t)spi0_send_array;
    dma_init_struct.direction    = DMA_MEMORY_TO_PERIPHERAL;
    dma_init_struct.memory_width = DMA_MEMORY_WIDTH_8BIT;
    dma_init_struct.periph_width = DMA_PERIPHERAL_WIDTH_8BIT;
    dma_init_struct.priority     = DMA_PRIORITY_LOW;
    dma_init_struct.number       = arraysize;
    dma_init_struct.periph_inc   = DMA_PERIPH_INCREASE_DISABLE;
    dma_init_struct.memory_inc   = DMA_MEMORY_INCREASE_ENABLE;
    dma_init(DMA0, DMA_CH2, &dma_init_struct);
    /* configure DMA mode */
    dma_circulation_disable(DMA0, DMA_CH2);
    dma_memory_to_memory_disable(DMA0, DMA_CH2);

    /* SPI0 receive dma config:DMA0-DMA_CH1  */
    dma_deinit(DMA0, DMA_CH1);
    dma_init_struct.periph_addr  = (uint32_t)&SPI_DATA(SPI0);
    dma_init_struct.memory_addr  = (uint32_t)spi0_receive_array;
    dma_init_struct.direction    = DMA_PERIPHERAL_TO_MEMORY;
    dma_init_struct.priority     = DMA_PRIORITY_HIGH;
    dma_init(DMA0, DMA_CH1, &dma_init_struct);
    /* configure DMA mode */
    dma_circulation_disable(DMA0, DMA_CH1);
    dma_memory_to_memory_disable(DMA0, DMA_CH1);

    /* SPI2 transmit dma config:DMA1,DMA_CH1  */
    dma_deinit(DMA1, DMA_CH1);
    dma_init_struct.periph_addr  = (uint32_t)&SPI_DATA(SPI2);
    dma_init_struct.memory_addr  = (uint32_t)spi2_send_array;
    dma_init_struct.direction    = DMA_MEMORY_TO_PERIPHERAL;
    dma_init_struct.priority     = DMA_PRIORITY_MEDIUM;
    dma_init(DMA1, DMA_CH1, &dma_init_struct);
    /* configure DMA mode */
    dma_circulation_disable(DMA1, DMA_CH1);
    dma_memory_to_memory_disable(DMA1, DMA_CH1);

    /* SPI2 receive dma config:DMA1,DMA_CH0  */
    dma_deinit(DMA1, DMA_CH0);
    dma_init_struct.periph_addr  = (uint32_t)&SPI_DATA(SPI2);
    dma_init_struct.memory_addr  = (uint32_t)spi2_receive_array;
    dma_init_struct.direction    = DMA_PERIPHERAL_TO_MEMORY;
    dma_init_struct.priority     = DMA_PRIORITY_ULTRA_HIGH;
    dma_init(DMA1, DMA_CH0, &dma_init_struct);
    /* configure DMA mode */
    dma_circulation_disable(DMA1, DMA_CH0);
    dma_memory_to_memory_disable(DMA1, DMA_CH0);
}

void spi_config(void)
{
    spi_parameter_struct spi_init_struct;

    /* SPI0 parameter config */
    spi_init_struct.trans_mode           = SPI_TRANSMODE_FULLDUPLEX;
    spi_init_struct.device_mode          = SPI_MASTER;
    spi_init_struct.frame_size           = SPI_FRAMESIZE_8BIT;
    spi_init_struct.clock_polarity_phase = SPI_CK_PL_HIGH_PH_1EDGE;
    spi_init_struct.nss                  = SPI_NSS_HARD;
    spi_init_struct.prescale             = SPI_PSC_256;
    spi_init_struct.endian               = SPI_ENDIAN_MSB;
    spi_init(SPI0, &spi_init_struct);

    /* SPI2 parameter config */
    spi_init_struct.device_mode = SPI_SLAVE;
    spi_init_struct.nss         = SPI_NSS_HARD;
    spi_init(SPI2, &spi_init_struct);
}

代码讲解

GPIO 配置：设置引脚为输出/输入模式，选择推挽/开漏输出，配置上拉/下拉。

DMA 配置：设置源地址、目标地址、传输方向、数据宽度。DMA 搬运数据不占用 CPU。

SPI 配置：设置主/从模式、时钟极性（CPOL）、时钟相位（CPHA）、分频系数。主机和从机的 CPOL/CPHA 必须一致。

实验现象

主机和从机互相交换数据
数据校验通过则 LED 指示成功

注意事项

CPOL 和 CPHA 必须主机从机一致
片选（CS）信号要手动拉低选中从机
时钟频率不能超过从设备的最大速率

GD32 SPI — SPI 主从 TI 模式

Tue, 08 Sep 2026 14:52:21 +0800

SPI — SPI 主从 TI 模式

固件库: GD32F30x_Firmware_Library V3.0.3
芯片: GD32
源文件: GD32F30x_Firmware_Library_V3.0.3/Examples/SPI/SPI_master_slave_fullduplex_ti_mode/main.c

功能简介

本示例演示 SPI 全双工通信。主机和从机可以同时收发数据，速度比 I2C 快得多。适合高速数据传输场景。

硬件准备

需要主机和从机两块板子，或使用回环连接（MOSI→MISO）

完整代码

#include "gd32f30x.h"
#include "gd32f307c_eval.h"
#define arraysize         10

void rcu_config(void);
void gpio_config(void);
void dma_config(void);
void spi_config(void);

/*!
    \brief      main function
    \param[in]  none
    \param[out] none
    \retval     none
*/
int main(void)
{
    /* init led2 and led3 */
    gd_eval_led_init(LED2);
    gd_eval_led_init(LED3);

    /* peripheral clock enable */
    rcu_config();
    /* GPIO config */
    gpio_config();
    /* DMA config */
    dma_config();
    /* SPI config */
    spi_config();
    
    /* SPI ti mode enable */
    spi_ti_mode_enable(SPI2);
    spi_ti_mode_enable(SPI0);

    /* SPI enable */
    spi_enable(SPI2);
    spi_enable(SPI0);

    /* DMA channel enable */
    dma_channel_enable(DMA0, DMA_CH1);
    dma_channel_enable(DMA0, DMA_CH2);
    dma_channel_enable(DMA1, DMA_CH0);
    dma_channel_enable(DMA1, DMA_CH1);

    /* SPI DMA enable */
    spi_dma_enable(SPI2, SPI_DMA_TRANSMIT);
    spi_dma_enable(SPI2, SPI_DMA_RECEIVE);
    spi_dma_enable(SPI0, SPI_DMA_TRANSMIT);
    spi_dma_enable(SPI0, SPI_DMA_RECEIVE);

    /* wait dma transmit complete */
    while(!dma_flag_get(DMA0,DMA_CH2,DMA_INTF_FTFIF));
    while(!dma_flag_get(DMA1,DMA_CH1,DMA_INTF_FTFIF));
    while(!dma_flag_get(DMA1,DMA_CH0,DMA_INTF_FTFIF));
    while(!dma_flag_get(DMA0,DMA_CH1,DMA_INTF_FTFIF));

    /* compare receive data with send data */
    if(memory_compare(spi2_receive_array, spi0_send_array, arraysize))
        gd_eval_led_on(LED2);
    else
        gd_eval_led_off(LED2);
    if(memory_compare(spi0_receive_array, spi2_send_array, arraysize))
        gd_eval_led_on(LED3);
    else
        gd_eval_led_off(LED3);

    while(1);
}

void rcu_config(void)
{
    rcu_periph_clock_enable(RCU_GPIOA);
    rcu_periph_clock_enable(RCU_GPIOB);
    rcu_periph_clock_enable(RCU_GPIOC);
    rcu_periph_clock_enable(RCU_DMA0);
    rcu_periph_clock_enable(RCU_DMA1);
    rcu_periph_clock_enable(RCU_SPI0);
    rcu_periph_clock_enable(RCU_SPI2);
    rcu_periph_clock_enable(RCU_AF);
}

void gpio_config(void)
{
    /* JTAG-DP disabled and SW-DP enabled, so SPI0 can use PB3 and PB4 */
    gpio_pin_remap_config(GPIO_SWJ_SWDPENABLE_REMAP,ENABLE);

    gpio_pin_remap_config(GPIO_SPI0_REMAP, ENABLE);
    /* SPI0 GPIO config: NSS/PA15, SCK/PB3, MOSI/PB5 */
    gpio_init(GPIOA, GPIO_MODE_AF_PP, GPIO_OSPEED_50MHZ, GPIO_PIN_15);
    gpio_init(GPIOB, GPIO_MODE_AF_PP, GPIO_OSPEED_50MHZ, GPIO_PIN_3 | GPIO_PIN_5);
    /* SPI0 GPIO config: MISO/PB4 */
    gpio_init(GPIOB, GPIO_MODE_IN_FLOATING, GPIO_OSPEED_50MHZ, GPIO_PIN_4);
    
    gpio_pin_remap_config(GPIO_SPI2_REMAP, ENABLE);
    /* SPI2 GPIO config: NSS/PA4 */
    gpio_init(GPIOA, GPIO_MODE_IN_FLOATING, GPIO_OSPEED_50MHZ, GPIO_PIN_4);
    /* SPI2 GPIO config: SCK/PC10, MOSI/PC12 */
    gpio_init(GPIOC, GPIO_MODE_IN_FLOATING, GPIO_OSPEED_50MHZ, GPIO_PIN_10 |GPIO_PIN_12);
    /* SPI2 GPIO config: MISO/PC11 */
    gpio_init(GPIOC, GPIO_MODE_AF_PP, GPIO_OSPEED_50MHZ, GPIO_PIN_11);
}

void dma_config(void)
{
    dma_parameter_struct dma_init_struct;
    
    /* SPI0 transmit dma config:DMA0-DMA_CH2  */
    dma_deinit(DMA0, DMA_CH2);
    dma_init_struct.periph_addr  = (uint32_t)&SPI_DATA(SPI0);
    dma_init_struct.memory_addr  = (uint32_t)spi0_send_array;
    dma_init_struct.direction    = DMA_MEMORY_TO_PERIPHERAL;
    dma_init_struct.memory_width = DMA_MEMORY_WIDTH_8BIT;
    dma_init_struct.periph_width = DMA_PERIPHERAL_WIDTH_8BIT;
    dma_init_struct.priority     = DMA_PRIORITY_LOW;
    dma_init_struct.number       = arraysize;
    dma_init_struct.periph_inc   = DMA_PERIPH_INCREASE_DISABLE;
    dma_init_struct.memory_inc   = DMA_MEMORY_INCREASE_ENABLE;
    dma_init(DMA0, DMA_CH2, &dma_init_struct);
    /* configure DMA mode */
    dma_circulation_disable(DMA0, DMA_CH2);
    dma_memory_to_memory_disable(DMA0, DMA_CH2);

    /* SPI0 receive dma config:DMA0-DMA_CH1  */
    dma_deinit(DMA0, DMA_CH1);
    dma_init_struct.periph_addr  = (uint32_t)&SPI_DATA(SPI0);
    dma_init_struct.memory_addr  = (uint32_t)spi0_receive_array;
    dma_init_struct.direction    = DMA_PERIPHERAL_TO_MEMORY;
    dma_init_struct.priority     = DMA_PRIORITY_HIGH;
    dma_init(DMA0, DMA_CH1, &dma_init_struct);
    /* configure DMA mode */
    dma_circulation_disable(DMA0, DMA_CH1);
    dma_memory_to_memory_disable(DMA0, DMA_CH1);

    /* SPI2 transmit dma config:DMA1,DMA_CH1  */
    dma_deinit(DMA1, DMA_CH1);
    dma_init_struct.periph_addr  = (uint32_t)&SPI_DATA(SPI2);
    dma_init_struct.memory_addr  = (uint32_t)spi2_send_array;
    dma_init_struct.direction    = DMA_MEMORY_TO_PERIPHERAL;
    dma_init_struct.priority     = DMA_PRIORITY_MEDIUM;
    dma_init(DMA1, DMA_CH1, &dma_init_struct);
    /* configure DMA mode */
    dma_circulation_disable(DMA1, DMA_CH1);
    dma_memory_to_memory_disable(DMA1, DMA_CH1);

    /* SPI2 receive dma config:DMA1,DMA_CH0  */
    dma_deinit(DMA1, DMA_CH0);
    dma_init_struct.periph_addr  = (uint32_t)&SPI_DATA(SPI2);
    dma_init_struct.memory_addr  = (uint32_t)spi2_receive_array;
    dma_init_struct.direction    = DMA_PERIPHERAL_TO_MEMORY;
    dma_init_struct.priority     = DMA_PRIORITY_ULTRA_HIGH;
    dma_init(DMA1, DMA_CH0, &dma_init_struct);
    /* configure DMA mode */
    dma_circulation_disable(DMA1, DMA_CH0);
    dma_memory_to_memory_disable(DMA1, DMA_CH0);
}

void spi_config(void)
{
    spi_parameter_struct spi_init_struct;

    /* SPI0 parameter config */
    spi_init_struct.trans_mode           = SPI_TRANSMODE_FULLDUPLEX;
    spi_init_struct.device_mode          = SPI_MASTER;
    spi_init_struct.frame_size           = SPI_FRAMESIZE_8BIT;
    spi_init_struct.clock_polarity_phase = SPI_CK_PL_HIGH_PH_2EDGE;
    spi_init_struct.nss                  = SPI_NSS_HARD;
    spi_init_struct.prescale             = SPI_PSC_16;
    spi_init_struct.endian               = SPI_ENDIAN_MSB;
    spi_init(SPI0, &spi_init_struct);

    /* SPI2 parameter config */
    spi_init_struct.trans_mode  = SPI_TRANSMODE_FULLDUPLEX;
    spi_init_struct.device_mode = SPI_SLAVE;
    spi_init_struct.nss         = SPI_NSS_HARD;
    spi_init_struct.prescale    = SPI_PSC_16;
    spi_init(SPI2, &spi_init_struct);
}

代码讲解

GPIO 配置：设置引脚为输出/输入模式，选择推挽/开漏输出，配置上拉/下拉。

DMA 配置：设置源地址、目标地址、传输方向、数据宽度。DMA 搬运数据不占用 CPU。

SPI 配置：设置主/从模式、时钟极性（CPOL）、时钟相位（CPHA）、分频系数。主机和从机的 CPOL/CPHA 必须一致。

实验现象

主机和从机互相交换数据
数据校验通过则 LED 指示成功

注意事项

CPOL 和 CPHA 必须主机从机一致
片选（CS）信号要手动拉低选中从机
时钟频率不能超过从设备的最大速率

GD32 SPI — SPI 主从单工 DMA

Tue, 08 Sep 2026 14:52:21 +0800

SPI — SPI 主从单工 DMA

固件库: GD32F30x_Firmware_Library V3.0.3
芯片: GD32
源文件: GD32F30x_Firmware_Library_V3.0.3/Examples/SPI/SPI_master_slave_simplex_dma/main.c

功能简介

本示例演示 SPI 总线通信。SPI 是高速同步串行接口，常用于连接 Flash、LCD、传感器等外设。

硬件准备

需要主机和从机两块板子，或使用回环连接（MOSI→MISO）

完整代码

#include "gd32f30x.h"
#include "gd32f307c_eval.h"
#define SLVAE_TRAMSMIT_MASTER_RECEIVE
#define ARRAYSIZE                  10
#define SET_SPI0_NSS_HIGH          gpio_bit_set(GPIOA,GPIO_PIN_3);
#define SET_SPI0_NSS_LOW           gpio_bit_reset(GPIOA,GPIO_PIN_3);

void rcu_config(void);
void gpio_config(void);
void dma_config(void);
void spi_config(void);
ErrStatus memory_compare(uint8_t *src, uint8_t *dst, uint8_t length);

/*!
    \brief      main function
    \param[in]  none
    \param[out] none
    \retval     none
*/
int main(void)
{
    /* initialize the LEDs */
    gd_eval_led_init(LED2);
    gd_eval_led_init(LED3);

    /* enable peripheral clock */
    rcu_config();
    /* configure GPIO */
    gpio_config();
    /* configure DMA */
    dma_config();
    /* configure SPI */
    spi_config();

    SET_SPI0_NSS_HIGH

#ifdef MASTER_TRAMSMIT_SLVAE_RECEIVE
    /* enable DMA channel */
    /* SPI0_Tx DMA channel */
    dma_channel_enable(DMA0, DMA_CH2);
    /* SPI2_Rx DMA channel */
    dma_channel_enable(DMA1, DMA_CH0);

    /* enable SPI DMA */
    spi_dma_enable(SPI2, SPI_DMA_RECEIVE);
    spi_dma_enable(SPI0, SPI_DMA_TRANSMIT);
#endif /* master send and slave receive */

#ifdef SLVAE_TRAMSMIT_MASTER_RECEIVE
    /* enable DMA channel */
    /* SPI0_Rx DMA channel */
    dma_channel_enable(DMA0, DMA_CH1);
    /* SPI2_Tx DMA channel */
    dma_channel_enable(DMA1, DMA_CH1);

    /* enable SPI DMA */
    spi_dma_enable(SPI2, SPI_DMA_TRANSMIT);
    spi_dma_enable(SPI0, SPI_DMA_RECEIVE);
#endif /* slave send and master receive */
    SET_SPI0_NSS_LOW

    /* enable SPI */
    spi_enable(SPI2);
    spi_enable(SPI0);

#ifdef MASTER_TRAMSMIT_SLVAE_RECEIVE
    /* wait DMA transmit completed */
    while(!dma_flag_get(DMA0, DMA_CH2, DMA_FLAG_FTF)) {
    }
    while(!dma_flag_get(DMA1, DMA_CH0, DMA_FLAG_FTF)) {
    }

    /* compare receive data with send data */
    if(ERROR != memory_compare(spi2_receive_array, spi0_send_array, ARRAYSIZE)) {
        gd_eval_led_on(LED2);
    } else {
        gd_eval_led_off(LED2);
    }
#endif /* master send and slave receive */

#ifdef SLVAE_TRAMSMIT_MASTER_RECEIVE
    /* wait DMA transmit complete */
    while(!dma_flag_get(DMA1, DMA_CH1, DMA_FLAG_FTF)) {
    }
    while(!dma_flag_get(DMA0, DMA_CH1, DMA_FLAG_FTF)) {
    }

    /* compare receive data with send data */
    if(ERROR != memory_compare(spi0_receive_array, spi2_send_array, ARRAYSIZE)) {
        gd_eval_led_on(LED3);
    } else {
        gd_eval_led_off(LED3);
    }
#endif /* slave send and master receive */

    SET_SPI0_NSS_HIGH

    /* disable SPI */
    spi_disable(SPI0);
    spi_disable(SPI2);

    while(1) {
    }
}

void rcu_config(void)
{
    rcu_periph_clock_enable(RCU_GPIOA);
    rcu_periph_clock_enable(RCU_GPIOC);
    rcu_periph_clock_enable(RCU_DMA0);
    rcu_periph_clock_enable(RCU_DMA1);
    rcu_periph_clock_enable(RCU_SPI0);
    rcu_periph_clock_enable(RCU_SPI2);
    rcu_periph_clock_enable(RCU_AF);
}

void gpio_config(void)
{
    /* SPI0 GPIO config: SCK/PA5, MISO/PA6, MOSI/PA7 */
    gpio_init(GPIOA, GPIO_MODE_AF_PP, GPIO_OSPEED_50MHZ, GPIO_PIN_5 | GPIO_PIN_7);
    gpio_init(GPIOA, GPIO_MODE_IN_FLOATING, GPIO_OSPEED_50MHZ, GPIO_PIN_6);
    /* PA3 as NSS */
    gpio_init(GPIOA, GPIO_MODE_OUT_PP, GPIO_OSPEED_50MHZ, GPIO_PIN_3);

    gpio_pin_remap_config(GPIO_SPI2_REMAP, ENABLE);
    /* SPI2 GPIO config: NSS/PA4, SCK/PC10, MISO/PC11, MOSI/PC12 */
    gpio_init(GPIOC, GPIO_MODE_IN_FLOATING, GPIO_OSPEED_50MHZ, GPIO_PIN_10 | GPIO_PIN_12);
    gpio_init(GPIOC, GPIO_MODE_AF_PP, GPIO_OSPEED_50MHZ, GPIO_PIN_11);
    gpio_init(GPIOA, GPIO_MODE_IN_FLOATING, GPIO_OSPEED_50MHZ, GPIO_PIN_4);
}

void dma_config(void)
{
    dma_parameter_struct dma_init_struct;
    dma_struct_para_init(&dma_init_struct);

    /* configure SPI0 transmit DMA: DMA_CH2 */
    dma_deinit(DMA0, DMA_CH2);
    dma_init_struct.periph_addr  = (uint32_t)&SPI_DATA(SPI0);
    dma_init_struct.memory_addr  = (uint32_t)spi0_send_array;
    dma_init_struct.direction    = DMA_MEMORY_TO_PERIPHERAL;
    dma_init_struct.memory_width = DMA_MEMORY_WIDTH_8BIT;
    dma_init_struct.periph_width = DMA_PERIPHERAL_WIDTH_16BIT;
    dma_init_struct.priority     = DMA_PRIORITY_LOW;
    dma_init_struct.number       = ARRAYSIZE;
    dma_init_struct.periph_inc   = DMA_PERIPH_INCREASE_DISABLE;
    dma_init_struct.memory_inc   = DMA_MEMORY_INCREASE_ENABLE;
    dma_init(DMA0, DMA_CH2, &dma_init_struct);
    /* configure DMA mode */
    dma_circulation_disable(DMA0, DMA_CH2);
    dma_memory_to_memory_disable(DMA0, DMA_CH2);

    /* configure SPI0 receive DMA: DMA_CH1 */
    dma_deinit(DMA0, DMA_CH1);
    dma_init_struct.periph_addr  = (uint32_t)&SPI_DATA(SPI0);
    dma_init_struct.memory_addr  = (uint32_t)spi0_receive_array;
    dma_init_struct.direction    = DMA_PERIPHERAL_TO_MEMORY;
    dma_init_struct.priority     = DMA_PRIORITY_HIGH;
    dma_init(DMA0, DMA_CH1, &dma_init_struct);
    /* configure DMA mode */
    dma_circulation_disable(DMA0, DMA_CH1);
    dma_memory_to_memory_disable(DMA0, DMA_CH1);

    /* SPI2 transmit dma config:DMA1,DMA_CH1  */
    dma_deinit(DMA1, DMA_CH1);
    dma_init_struct.periph_addr  = (uint32_t)&SPI_DATA(SPI2);
    dma_init_struct.memory_addr  = (uint32_t)spi2_send_array;
    dma_init_struct.direction    = DMA_MEMORY_TO_PERIPHERAL;
    dma_init_struct.priority     = DMA_PRIORITY_MEDIUM;
    dma_init(DMA1, DMA_CH1, &dma_init_struct);
    /* configure DMA mode */
    dma_circulation_disable(DMA1, DMA_CH1);
    dma_memory_to_memory_disable(DMA1, DMA_CH1);

    /* SPI2 receive dma config:DMA1,DMA_CH0  */
    dma_deinit(DMA1, DMA_CH0);
    dma_init_struct.periph_addr  = (uint32_t)&SPI_DATA(SPI2);
    dma_init_struct.memory_addr  = (uint32_t)spi2_receive_array;
    dma_init_struct.direction    = DMA_PERIPHERAL_TO_MEMORY;
    dma_init_struct.priority     = DMA_PRIORITY_ULTRA_HIGH;
    dma_init(DMA1, DMA_CH0, &dma_init_struct);
    /* configure DMA mode */
    dma_circulation_disable(DMA1, DMA_CH0);
    dma_memory_to_memory_disable(DMA1, DMA_CH0);
}

void spi_config(void)
{
    spi_parameter_struct spi_init_struct;
    /* deinitialize SPI and the parameters */
    spi_i2s_deinit(SPI0);
    spi_i2s_deinit(SPI2);
    spi_struct_para_init(&spi_init_struct);

    /* configure SPI0 parameter */
#ifdef MASTER_TRAMSMIT_SLVAE_RECEIVE
    spi_init_struct.trans_mode           = SPI_TRANSMODE_FULLDUPLEX;
#endif /* master send and slave receive */
#ifdef SLVAE_TRAMSMIT_MASTER_RECEIVE
    spi_init_struct.trans_mode           = SPI_TRANSMODE_RECEIVEONLY;
#endif /* slave send and master receive */
    spi_init_struct.device_mode          = SPI_MASTER;
    spi_init_struct.frame_size           = SPI_FRAMESIZE_8BIT;
    spi_init_struct.clock_polarity_phase = SPI_CK_PL_HIGH_PH_2EDGE;
    spi_init_struct.nss                  = SPI_NSS_SOFT;
    spi_init_struct.prescale             = SPI_PSC_256;
    spi_init_struct.endian               = SPI_ENDIAN_MSB;
    spi_init(SPI0, &spi_init_struct);

    /* configure SPI2 parameter */
#ifdef MASTER_TRAMSMIT_SLVAE_RECEIVE
    spi_init_struct.trans_mode           = SPI_TRANSMODE_RECEIVEONLY;
#endif /* master send and slave receive */
#ifdef SLVAE_TRAMSMIT_MASTER_RECEIVE
    spi_init_struct.trans_mode           = SPI_TRANSMODE_FULLDUPLEX;
#endif /* slave send and master receive */
    spi_init_struct.device_mode          = SPI_SLAVE;
    spi_init(SPI2, &spi_init_struct);
}

代码讲解

GPIO 配置：设置引脚为输出/输入模式，选择推挽/开漏输出，配置上拉/下拉。

DMA 配置：设置源地址、目标地址、传输方向、数据宽度。DMA 搬运数据不占用 CPU。

SPI 配置：设置主/从模式、时钟极性（CPOL）、时钟相位（CPHA）、分频系数。主机和从机的 CPOL/CPHA 必须一致。

实验现象

主机和从机互相交换数据
数据校验通过则 LED 指示成功

注意事项

CPOL 和 CPHA 必须主机从机一致
片选（CS）信号要手动拉低选中从机
时钟频率不能超过从设备的最大速率

GD32 SPI — SPI 主从全双工 DMA

Tue, 08 Sep 2026 14:52:21 +0800

SPI — SPI 主从全双工 DMA

固件库: GD32F30x_Firmware_Library V3.0.3
芯片: GD32
源文件: GD32F30x_Firmware_Library_V3.0.3/Examples/SPI/SPI_master_slave_fullduplex_dma/main.c

功能简介

本示例演示 SPI 全双工通信。主机和从机可以同时收发数据，速度比 I2C 快得多。适合高速数据传输场景。

硬件准备

需要主机和从机两块板子，或使用回环连接（MOSI→MISO）

完整代码

#include "gd32f30x.h"
#include "gd32f307c_eval.h"
#define SPI_CRC_ENABLE             1
#define ARRAYSIZE                  10
#define SET_SPI0_NSS_HIGH          gpio_bit_set(GPIOA,GPIO_PIN_3);
#define SET_SPI0_NSS_LOW           gpio_bit_reset(GPIOA,GPIO_PIN_3);

void rcu_config(void);
void gpio_config(void);
void dma_config(void);
void spi_config(void);

/*!
    \brief      main function
    \param[in]  none
    \param[out] none
    \retval     none
*/
int main(void)
{
    /* init led2 and led3 */
    gd_eval_led_init(LED2);
    gd_eval_led_init(LED3);

    /* peripheral clock enable */
    rcu_config();
    /* GPIO config */
    gpio_config();
    /* DMA config */
    dma_config();
    /* SPI config */
    spi_config();

    SET_SPI0_NSS_HIGH

    /* SPI enable */
    spi_enable(SPI2);
    spi_enable(SPI0);

    /* DMA channel enable */
    dma_channel_enable(DMA0, DMA_CH1);
    dma_channel_enable(DMA0, DMA_CH2);
    dma_channel_enable(DMA1, DMA_CH0);
    dma_channel_enable(DMA1, DMA_CH1);

    SET_SPI0_NSS_LOW

    /* SPI DMA enable */
    spi_dma_enable(SPI2, SPI_DMA_TRANSMIT);
    spi_dma_enable(SPI2, SPI_DMA_RECEIVE);
    spi_dma_enable(SPI0, SPI_DMA_TRANSMIT);
    spi_dma_enable(SPI0, SPI_DMA_RECEIVE);

    /* wait dma transmit complete */
    while(!dma_flag_get(DMA0,DMA_CH2, DMA_FLAG_FTF)) {
    }
    while(!dma_flag_get(DMA1,DMA_CH1, DMA_FLAG_FTF)) {
    }
    while(!dma_flag_get(DMA1,DMA_CH0, DMA_FLAG_FTF)) {
    }
    while(!dma_flag_get(DMA0,DMA_CH1, DMA_FLAG_FTF)) {
    }

    SET_SPI0_NSS_HIGH

#if SPI_CRC_ENABLE
    /* check the CRC error status  */
    if(SET != spi_i2s_flag_get(SPI0, SPI_FLAG_CRCERR)) {
        gd_eval_led_on(LED2);
    } else {
        gd_eval_led_off(LED2);
    }

    if(SET != spi_i2s_flag_get(SPI2, SPI_FLAG_CRCERR)) {
        gd_eval_led_on(LED3);
    } else {
        gd_eval_led_off(LED3);
    }
#else
    /* compare receive data with send data */
    if(memory_compare(spi2_receive_array, spi0_send_array, ARRAYSIZE))
        gd_eval_led_on(LED2);
    else
        gd_eval_led_off(LED2);
    if(memory_compare(spi0_receive_array, spi2_send_array, ARRAYSIZE))
        gd_eval_led_on(LED3);
    else
        gd_eval_led_off(LED3);
#endif /* enable CRC function */

    while(1);
}

void rcu_config(void)
{
    rcu_periph_clock_enable(RCU_GPIOA);
    rcu_periph_clock_enable(RCU_GPIOC);
    rcu_periph_clock_enable(RCU_DMA0);
    rcu_periph_clock_enable(RCU_DMA1);
    rcu_periph_clock_enable(RCU_SPI0);
    rcu_periph_clock_enable(RCU_SPI2);
    rcu_periph_clock_enable(RCU_AF);
}

void gpio_config(void)
{
    /* SPI0 GPIO config: SCK/PA5, MISO/PA6, MOSI/PA7 */
    gpio_init(GPIOA, GPIO_MODE_AF_PP, GPIO_OSPEED_50MHZ, GPIO_PIN_5 | GPIO_PIN_7);
    gpio_init(GPIOA, GPIO_MODE_IN_FLOATING, GPIO_OSPEED_50MHZ, GPIO_PIN_6);
    /* PA3 as NSS */
    gpio_init(GPIOA, GPIO_MODE_OUT_PP, GPIO_OSPEED_50MHZ, GPIO_PIN_3);

    gpio_pin_remap_config(GPIO_SPI2_REMAP, ENABLE);
    /* SPI2 GPIO config: NSS/PA4, SCK/PC10, MISO/PC11, MOSI/PC12 */
    gpio_init(GPIOC, GPIO_MODE_IN_FLOATING, GPIO_OSPEED_50MHZ, GPIO_PIN_10 | GPIO_PIN_12);
    gpio_init(GPIOC, GPIO_MODE_AF_PP, GPIO_OSPEED_50MHZ, GPIO_PIN_11);
    gpio_init(GPIOA, GPIO_MODE_IN_FLOATING, GPIO_OSPEED_50MHZ, GPIO_PIN_4);
}

void dma_config(void)
{
    dma_parameter_struct dma_init_struct;
    
    /* SPI0 transmit dma config:DMA0-DMA_CH2  */
    dma_deinit(DMA0, DMA_CH2);
    dma_init_struct.periph_addr  = (uint32_t)&SPI_DATA(SPI0);
    dma_init_struct.memory_addr  = (uint32_t)spi0_send_array;
    dma_init_struct.direction    = DMA_MEMORY_TO_PERIPHERAL;
    dma_init_struct.memory_width = DMA_MEMORY_WIDTH_8BIT;
    dma_init_struct.periph_width = DMA_PERIPHERAL_WIDTH_8BIT;
    dma_init_struct.priority     = DMA_PRIORITY_LOW;
    dma_init_struct.number       = ARRAYSIZE;
    dma_init_struct.periph_inc   = DMA_PERIPH_INCREASE_DISABLE;
    dma_init_struct.memory_inc   = DMA_MEMORY_INCREASE_ENABLE;
    dma_init(DMA0, DMA_CH2, &dma_init_struct);
    /* configure DMA mode */
    dma_circulation_disable(DMA0, DMA_CH2);
    dma_memory_to_memory_disable(DMA0, DMA_CH2);

    /* SPI0 receive dma config:DMA0-DMA_CH1  */
    dma_deinit(DMA0, DMA_CH1);
    dma_init_struct.periph_addr  = (uint32_t)&SPI_DATA(SPI0);
    dma_init_struct.memory_addr  = (uint32_t)spi0_receive_array;
    dma_init_struct.direction    = DMA_PERIPHERAL_TO_MEMORY;
    dma_init_struct.priority     = DMA_PRIORITY_HIGH;
    dma_init(DMA0, DMA_CH1, &dma_init_struct);
    /* configure DMA mode */
    dma_circulation_disable(DMA0, DMA_CH1);
    dma_memory_to_memory_disable(DMA0, DMA_CH1);

    /* SPI2 transmit dma config:DMA1,DMA_CH1  */
    dma_deinit(DMA1, DMA_CH1);
    dma_init_struct.periph_addr  = (uint32_t)&SPI_DATA(SPI2);
    dma_init_struct.memory_addr  = (uint32_t)spi2_send_array;
    dma_init_struct.direction    = DMA_MEMORY_TO_PERIPHERAL;
    dma_init_struct.priority     = DMA_PRIORITY_MEDIUM;
    dma_init(DMA1, DMA_CH1, &dma_init_struct);
    /* configure DMA mode */
    dma_circulation_disable(DMA1, DMA_CH1);
    dma_memory_to_memory_disable(DMA1, DMA_CH1);

    /* SPI2 receive dma config:DMA1,DMA_CH0  */
    dma_deinit(DMA1, DMA_CH0);
    dma_init_struct.periph_addr  = (uint32_t)&SPI_DATA(SPI2);
    dma_init_struct.memory_addr  = (uint32_t)spi2_receive_array;
    dma_init_struct.direction    = DMA_PERIPHERAL_TO_MEMORY;
    dma_init_struct.priority     = DMA_PRIORITY_ULTRA_HIGH;

    dma_init(DMA1, DMA_CH0, &dma_init_struct);
    /* configure DMA mode */
    dma_circulation_disable(DMA1, DMA_CH0);
    dma_memory_to_memory_disable(DMA1, DMA_CH0);
}

void spi_config(void)
{
    spi_parameter_struct spi_init_struct;

    /* SPI0 parameter config */
    spi_init_struct.trans_mode           = SPI_TRANSMODE_FULLDUPLEX;
    spi_init_struct.device_mode          = SPI_MASTER;
    spi_init_struct.frame_size           = SPI_FRAMESIZE_8BIT;
    spi_init_struct.clock_polarity_phase = SPI_CK_PL_LOW_PH_2EDGE;
    spi_init_struct.nss                  = SPI_NSS_SOFT;
    spi_init_struct.prescale             = SPI_PSC_256;
    spi_init_struct.endian               = SPI_ENDIAN_MSB;
    spi_init(SPI0, &spi_init_struct);

    /* SPI2 parameter config */
    spi_init_struct.device_mode = SPI_SLAVE;
    spi_init_struct.nss         = SPI_NSS_HARD;
    spi_init(SPI2, &spi_init_struct);
}

代码讲解

GPIO 配置：设置引脚为输出/输入模式，选择推挽/开漏输出，配置上拉/下拉。

DMA 配置：设置源地址、目标地址、传输方向、数据宽度。DMA 搬运数据不占用 CPU。

SPI 配置：设置主/从模式、时钟极性（CPOL）、时钟相位（CPHA）、分频系数。主机和从机的 CPOL/CPHA 必须一致。

实验现象

主机和从机互相交换数据
数据校验通过则 LED 指示成功

注意事项

CPOL 和 CPHA 必须主机从机一致
片选（CS）信号要手动拉低选中从机
时钟频率不能超过从设备的最大速率

GD32 SPI — SPI 主从全双工轮询

Tue, 08 Sep 2026 14:52:21 +0800

SPI — SPI 主从全双工轮询

固件库: GD32F30x_Firmware_Library V3.0.3
芯片: GD32F30x（以 GD32F307 评估板为例）
源文件: GD32F30x_Firmware_Library_V3.0.3/Examples/SPI/SPI_master_slave_fullduplex_polling/main.c
配套例程: SPI_master_slave_fullduplex_polling

功能简介

本示例把同一块板子上的两个 SPI 外设连在一起，一个当"主机"（SPI0），一个当"从机"（SPI2），用杜邦线把它们的信号线交叉对接，让两者互相发送一数组数据，再校验收到的内容是否和对方发出去的一致。

SPI0 作为主机：主动产生时钟，发送 spi0_send_array[]（10 字节：0xA1~0xAA），并接收从机回的数据。
SPI2 作为从机：跟着主机的时钟走，发送 spi2_send_array[]（10 字节：0xB1~0xBA），并接收主机回的数据。
因为是全双工，主机发 1 字节的同时也从从机收 1 字节；收完后用 memory_compare() 比对：
- 从机 SPI2 收到的 == 主机发出的 → LED2 亮
- 主机 SPI0 收到的 == 从机发出的 → LED3 亮

为什么要"自己和自己通信"？真实项目里 SPI 主机是 MCU、从机是外部芯片。但评估板上没有现成从芯片时，用另一路 SPI 当从机是验证 SPI 通信逻辑最省事的办法——你完全掌控双方时序，出问题好定位。

本示例默认 SPI_CRC_ENABLE = 0（关闭 CRC 校验），走最简单的 10 字节纯收发逻辑，最适合入门。

硬件准备

1. 开发板

GD32F30x 评估板一块（例程按 GD32F307C EVAL 板编写，LED2/LED3 由 gd_eval_led_init 初始化）。

2. 杜邦线（关键！）

把板上的 SPI0 和 SPI2 用线交叉对接。SPI2 例程里做了引脚重映射（GPIO_SPI2_REMAP），所以 SPI2 用的是 PC 口。具体接法：

主机 SPI0	从机 SPI2（重映射后）	说明
PA3	PA4	NSS（片选）：主机用 PA3 当软件片选，去选从机的 NSS(PA4)
PA5 (SCK)	PC10 (SCK)	时钟
PA6 (MISO)	PC11 (MOSI)	主机收 = 从机发
PA7 (MOSI)	PC12 (MISO)	主机发 = 从机收

注意 MISO / MOSI 的接法：主机 MOSI(PA7) 接从机"数据输入脚"——在重映射后从机 SPI2 的数据输入脚是 PC12（例程把它配成了 AF_PP 输出）。主机的 MISO(PA6) 接从机的数据输出脚 PC11（配成 IN_FLOATING 输入）。一句话：把"主发"对"从收"，“主收"对"从发”。

3. 串口 / 调试器（可选）

本例用 LED 指示结果，不需要串口。想看具体收发数组可用调试器看 spi0_receive_array[] / spi2_receive_array[]。

完整代码（带中文注释）

#include "gd32f30x.h"
#include "gd32f307c_eval.h"

/* 是否开启 CRC 校验，本示例教学默认关闭 */
#define SPI_CRC_ENABLE             0
/* 收发数组长度 */
#define ARRAYSIZE                  10

/* 用宏控制主机片选 NSS（PA3）：拉高=取消选中，拉低=选中从机 */
#define SET_SPI0_NSS_HIGH          gpio_bit_set(GPIOA, GPIO_PIN_3);
#define SET_SPI0_NSS_LOW           gpio_bit_reset(GPIOA, GPIO_PIN_3);

/* 待发送数据：主机 SPI0 发 0xA1~0xAA，从机 SPI2 发 0xB1~0xBA */
uint8_t spi0_send_array[ARRAYSIZE] = {0xA1, 0xA2, 0xA3, 0xA4, 0xA5, 0xA6, 0xA7, 0xA8, 0xA9, 0xAA};
uint8_t spi2_send_array[ARRAYSIZE] = {0xB1, 0xB2, 0xB3, 0xB4, 0xB5, 0xB6, 0xB7, 0xB8, 0xB9, 0xBA};
/* 接收缓冲区 */
uint8_t spi0_receive_array[ARRAYSIZE];
uint8_t spi2_receive_array[ARRAYSIZE];

/* 函数声明 */
void rcu_config(void);
void gpio_config(void);
void spi_config(void);
ErrStatus memory_compare(uint8_t* psrc, uint8_t* pdst, uint16_t length);

/*!
    \brief      main function
*/
int main(void)
{
    /* 收发/接收计数 */
    uint8_t send_n = 0, receive_n = 0;

    /* 初始化 LED2 和 LED3，用于指示收发是否一致 */
    gd_eval_led_init(LED2);
    gd_eval_led_init(LED3);

    /* 外设时钟使能 */
    rcu_config();
    /* GPIO 复用功能配置 */
    gpio_config();
    /* SPI 参数配置 */
    spi_config();

    /* 先拉高 NSS，确保从机未被选中 */
    SET_SPI0_NSS_HIGH

    /* 使能两个 SPI（注意：先使能从机，再使能主机也行，顺序不强制） */
    spi_enable(SPI2);
    spi_enable(SPI0);

    /* 拉低 NSS，正式选中从机，开始通信 */
    SET_SPI0_NSS_LOW

    /* ---------- 关闭 CRC 时的主逻辑 ---------- */
#if SPI_CRC_ENABLE
    /* （此处为 CRC 分支，略） */
#else
    /* 一字节一字节地收发：主机和从机同时各发各的、各收各的 */
    while(send_n < ARRAYSIZE){
        /* 等从机发送缓冲空，塞入从机要发的数据 */
        while(RESET == spi_i2s_flag_get(SPI2, SPI_FLAG_TBE));
        spi_i2s_data_transmit(SPI2, spi2_send_array[send_n]);
        /* 等主机发送缓冲空，塞入主机要发的数据 */
        while(RESET == spi_i2s_flag_get(SPI0, SPI_FLAG_TBE));
        spi_i2s_data_transmit(SPI0, spi0_send_array[send_n++]);

        /* 等从机收到数据，读走 */
        while(RESET == spi_i2s_flag_get(SPI2, SPI_FLAG_RBNE));
        spi2_receive_array[receive_n] = spi_i2s_data_receive(SPI2);
        /* 等主机收到数据，读走 */
        while(RESET == spi_i2s_flag_get(SPI0, SPI_FLAG_RBNE));
        spi0_receive_array[receive_n++] = spi_i2s_data_receive(SPI0);
    }

    /* 全部发完，拉高 NSS，结束通信 */
    SET_SPI0_NSS_HIGH

    /* 校验：从机收到的 应等于 主机发出的 */
    if(memory_compare(spi2_receive_array, spi0_send_array, ARRAYSIZE)) {
        gd_eval_led_on(LED2);      /* 一致 → LED2 亮 */
    } else {
        gd_eval_led_off(LED2);
    }

    /* 校验：主机收到的 应等于 从机发出的 */
    if(memory_compare(spi0_receive_array, spi2_send_array, ARRAYSIZE)) {
        gd_eval_led_on(LED3);      /* 一致 → LED3 亮 */
    } else {
        gd_eval_led_off(LED3);
    }
#endif /* enable CRC function */

    /* 死循环，停在这里方便观察 LED */
    while(1);
}

/*!
    \brief      时钟配置：打开用到的外设时钟
*/
void rcu_config(void)
{
    rcu_periph_clock_enable(RCU_GPIOA);   /* SPI0 引脚在 PA 口 */
    rcu_periph_clock_enable(RCU_GPIOC);   /* 重映射后的 SPI2 引脚在 PC 口 */
    rcu_periph_clock_enable(RCU_SPI0);    /* 主机 SPI0 */
    rcu_periph_clock_enable(RCU_SPI2);    /* 从机 SPI2 */
    rcu_periph_clock_enable(RCU_AF);      /* 引脚重映射必须开 AF 时钟 */
}

/*!
    \brief      GPIO 配置
*/
void gpio_config(void)
{
    /* SPI0（主机）引脚：SCK/PA5、MOSI/PA7 设为复用推挽输出；MISO/PA6 浮空输入 */
    gpio_init(GPIOA, GPIO_MODE_AF_PP, GPIO_OSPEED_50MHZ, GPIO_PIN_5 | GPIO_PIN_7);
    gpio_init(GPIOA, GPIO_MODE_IN_FLOATING, GPIO_OSPEED_50MHZ, GPIO_PIN_6);
    /* 主机片选 NSS 用普通 GPIO(PA3) 软件控制，推挽输出 */
    gpio_init(GPIOA, GPIO_MODE_OUT_PP, GPIO_OSPEED_50MHZ, GPIO_PIN_3);

    /* 开启 SPI2 引脚重映射，重映射后 SPI2 用 PC10/11/12 */
    gpio_pin_remap_config(GPIO_SPI2_REMAP, ENABLE);
    /* SPI2（从机）引脚：SCK/PC10、MOSI/PC12 浮空输入（这些是"从机的数据输入脚"） */
    gpio_init(GPIOC, GPIO_MODE_IN_FLOATING, GPIO_OSPEED_50MHZ, GPIO_PIN_10 | GPIO_PIN_12);
    /* 从机数据输出脚 MISO/PC11 设为复用推挽 */
    gpio_init(GPIOC, GPIO_MODE_AF_PP, GPIO_OSPEED_50MHZ, GPIO_PIN_11);
    /* 从机 NSS(PA4) 浮空输入，由主机 PA3 拉低来选中 */
    gpio_init(GPIOA, GPIO_MODE_IN_FLOATING, GPIO_OSPEED_50MHZ, GPIO_PIN_4);
}

/*!
    \brief      SPI 参数配置
*/
void spi_config(void)
{
    spi_parameter_struct spi_init_struct;

    /* ---- SPI0（主机）参数 ---- */
    spi_init_struct.trans_mode           = SPI_TRANSMODE_FULLDUPLEX;  /* 全双工 */
    spi_init_struct.device_mode          = SPI_MASTER;               /* 主机 */
    spi_init_struct.frame_size           = SPI_FRAMESIZE_8BIT;        /* 8 位一帧 */
    spi_init_struct.clock_polarity_phase = SPI_CK_PL_LOW_PH_1EDGE;   /* 模式0：CPOL=0,CPHA=0 */
    spi_init_struct.nss                  = SPI_NSS_SOFT;             /* 软件控制 NSS */
    spi_init_struct.prescale             = SPI_PSC_256;              /* 分频256，降速便于观察 */
    spi_init_struct.endian               = SPI_ENDIAN_MSB;           /* 高位先传 */
    spi_init(SPI0, &spi_init_struct);

    /* ---- SPI2（从机）参数 ---- */
    /* 复用同一结构体，只改两项：从机模式 + 硬件 NSS */
    spi_init_struct.device_mode = SPI_SLAVE;
    spi_init_struct.nss         = SPI_NSS_HARD;   /* 从机用硬件 NSS：NSS 被拉低才工作 */
    spi_init(SPI2, &spi_init_struct);
}

/*!
    \brief      比较两个数组是否完全一致
*/
ErrStatus memory_compare(uint8_t* psrc, uint8_t* pdst, uint16_t length)
{
    while(length--){
        if(*psrc != *pdst){
            return ERROR;   /* 有任意一字节不同就返回错误 */
        }
        psrc++;
        pdst++;
    }
    return SUCCESS;
}

代码分段讲解

1. 宏与全局数组

#define SPI_CRC_ENABLE  0
#define ARRAYSIZE       10
#define SET_SPI0_NSS_HIGH  gpio_bit_set(GPIOA, GPIO_PIN_3);
#define SET_SPI0_NSS_LOW   gpio_bit_reset(GPIOA, GPIO_PIN_3);

SPI_CRC_ENABLE 控制是否启用 CRC 校验，教学版设为 0，走简单分支。
SET_SPI0_NSS_* 把"片选拉高/拉低"封装成宏。SPI 通信必须先拉低 NSS 选中从机，结束后拉高。
两个发送数组：主机发 0xA1~0xAA，从机发 0xB1~0xBA。它们内容不同，正好用来验证"收到的确实是对方发的"。

2. 时钟与 GPIO 配置

SPI 的引脚是复用功能（AF），不是普通 GPIO，所以：

SPI0 的 SCK/MOSI 配成 GPIO_MODE_AF_PP（复用推挽）；MISO 配 IN_FLOATING（浮空输入，由对方驱动）。
gpio_pin_remap_config(GPIO_SPI2_REMAP, ENABLE) 把 SPI2 从默认引脚挪到 PC10/11/12，重映射必须开 RCU_AF 时钟，这一点常被忘记。
主机 NSS(PA3) 只是个普通输出脚，由软件拉高拉低，所以配 OUT_PP。
从机 NSS(PA4) 配 IN_FLOATING，因为它被配成了 SPI_NSS_HARD——由 SPI 硬件自动检测这个引脚是否被拉低。

为什么主机的 MOSI(PA7) 接的是从机的 PC12（配成 AF_PP），而主机的 MISO(PA6) 接的是从机的 PC11（配成 IN_FLOATING）？ 因为对"从机 SPI2"来说，PC12 是它的数据输入（DI）、PC11 是它的数据输出（DO）。主机 MOSI（主发）对接从机 DI，主机 MISO（主收）对接从机 DO。名字叫 MOSI/MISO 是站在主机视角；接到从机时要看从机那端是 DI 还是 DO。

3. SPI 参数配置

1
2

spi_init_struct.clock_polarity_phase = SPI_CK_PL_LOW_PH_1EDGE;  // 模式 0
spi_init_struct.prescale             = SPI_PSC_256;            // 大幅分频

主从必须使用相同的 CPOL/CPHA（模式），否则采样错位、数据全错。本例两者都用同一结构体初始化，天然一致。
SPI_PSC_256 把 SPI 时钟分得极低（APB 时钟 / 256），仅为方便观察；真实项目里在从机允许范围内尽量取高分频值以提高速率。
主机 SPI_NSS_SOFT，从机 SPI_NSS_HARD：这是 SPI 主从对接的常见搭配——主机用任意 GPIO 当片选，从机用硬件 NSS 引脚感知是否被选中。

4. 主循环：收发成对出现

while(send_n < ARRAYSIZE){
    while(RESET == spi_i2s_flag_get(SPI2, SPI_FLAG_TBE));
    spi_i2s_data_transmit(SPI2, spi2_send_array[send_n]);
    while(RESET == spi_i2s_flag_get(SPI0, SPI_FLAG_TBE));
    spi_i2s_data_transmit(SPI0, spi0_send_array[send_n++]);

    while(RESET == spi_i2s_flag_get(SPI2, SPI_FLAG_RBNE));
    spi2_receive_array[receive_n] = spi_i2s_data_receive(SPI2);
    while(RESET == spi_i2s_flag_get(SPI0, SPI_FLAG_RBNE));
    spi0_receive_array[receive_n++] = spi_i2s_data_receive(SPI0);
}

这是 SPI 全双工的本质体现：

等两个 SPI 的 TBE（发送缓冲空），分别把各自要发的数据写进发送寄存器。主机写数据的同时会产生 8 个 SCK 时钟，从机跟着这个时钟把它的数据也移位出来。
等两个 SPI 的 RBNE（接收缓冲非空），把各自收到的数据读走。
因为一帧 8 位里主机发 1 字节、从机也回 1 字节，所以"发"和"收"永远成对，循环里先 TBE 后 RBNE 各两行。

为什么从机也要等 TBE 才发？ 从机没有自己的时钟，它的发送也是靠主机提供的 SCK 来移位。主机每发一个字节就产生 8 个时钟，从机借这 8 个时钟把自己的发送寄存器移出去、把主机的移进来。所以只要主机在发，从机就能收发，二者节奏完全由主机时钟同步。

5. 结束与校验

SET_SPI0_NSS_HIGH                      // 拉高 NSS，通信结束
if(memory_compare(spi2_receive_array, spi0_send_array, ARRAYSIZE))
    gd_eval_led_on(LED2);              // 从机收对 → LED2
if(memory_compare(spi0_receive_array, spi2_send_array, ARRAYSIZE))
    gd_eval_led_on(LED3);              // 主机收对 → LED3

拉高 NSS 告诉从机"别再通信了"。然后用逐字节比较判断互收是否成功。两个 LED 都亮代表主从收发完全正确。

实验现象

下载程序并复位后，接线正确的前提下：
- LED2 亮：表示 SPI2 从机收到的数据 == 主机 SPI0 发出的 0xA1~0xAA。
- LED3 亮：表示 SPI0 主机收到的数据 == 从机 SPI2 发出的 0xB1~0xBA。
两个 LED 都亮 = 全双工收发成功。
若用调试器暂停，可观察 spi2_receive_array[] 应为 {0xA1..0xAA}，spi0_receive_array[] 应为 {0xB1..0xBA}。

因为是"同一块板子内部两个 SPI 互连"，只要接线对、配置对，几乎必然成功，非常适合拿来建立 SPI 的直观认识。

常见问题

Q1：两个 LED 都不亮 / 只有一个亮，收的数据对不上？
最常见原因是接线接反了。重点检查：主机 MOSI(PA7) 必须接从机的数据输入脚（重映射后是 PC12），主机 MISO(PA6) 必须接从机的数据输出脚（PC11）。把 MOSI/MISO 当成"同名直连"是最常见的错接。

Q2：主从的 CPOL/CPHA 要怎么配？
必须完全一致。本例主从都用 SPI_CK_PL_LOW_PH_1EDGE（模式 0）。若你后续接外部芯片（如 W25Q Flash），要先查手册它的 SPI 模式是多少，把 MCU 配成同一个。

Q3：为什么从机用 SPI_NSS_HARD，主机用 SPI_NSS_SOFT？
这是 SPI 主从的常规搭配。主机随便挑一个 GPIO（本例 PA3）用软件拉高拉低当片选；从机的 NSS 引脚（PA4）被硬件监控——只有它被拉低，从机才认为"被选中"并开始通信。若从机也用软件 NSS，则它不会去检测外部 PA4 电平。

Q4：分频 SPI_PSC_256 这么慢，能调快吗？
可以。256 只是为了教学便于观察。真实项目中在从机允许的最高速率内尽量取小分频以提高吞吐。注意 SPI2 在 APB1 上、SPI0 在 APB2 上，二者挂载总线不同，但本例主从分频一致即可。

Q5：为什么我接了线还是不通，但仿真看发送数组没问题？
检查三件事：① RCU_AF 时钟是否打开（用到重映射必须开）；② gpio_pin_remap_config(GPIO_SPI2_REMAP, ENABLE) 是否调用；③ NSS 是否先在 spi_enable 之前/之后被拉低。SPI 必须在 NSS 为低期间通信。

Q6：开启 CRC（SPI_CRC_ENABLE = 1）后逻辑有什么不同？
开启后，循环里会先发前 9 个字节，最后再各发 1 个字节并追加发送 CRC 值，然后双方各收 1 个数据字节 + 1 个 CRC 字节，最后读 SPI_FLAG_CRCERR 标志判断 CRC 是否出错。CRC 用于在噪声环境下检测数据对错，教学阶段建议先关掉理解基础收发。

小结

本示例完整展示了 SPI 主从全双工轮询的核心套路：

开时钟：RCU_GPIOx + RCU_SPIx + 用到重映射时的 RCU_AF。
配 GPIO：SCK/MOSI 复用推挽，MISO 浮空输入；NSS 主机用普通 GPIO。
配 SPI 参数：模式（全双工/主从）、帧长、CPOL/CPHA、分频、NSS 软/硬、MSB/LSB——主从模式必须一致。
拉低 NSS → 轮询 TBE 发、轮询 RBNE 收（成对）→ 拉高 NSS。
校验：比较收/发数组，用 LED 等直观指示结果。

记住 SPI 的"三件套"——四线、全双工、主从同模式，你就掌握了它的灵魂。

拓展应用

掌握这个基础例程后，你可以往这些方向走：

驱动 SPI Flash（如 W25Q64 / W25Q128）：这是 SPI 最经典的应用。把例程里的从机换成 Flash 芯片，按芯片手册的指令集（写使能→擦除→页编程→读）就能做出"掉电不丢数据"的存储模块。
驱动 LCD / OLED 屏（如 ST7735、SSD1306 用 SPI 接口）：用 SPI 高速刷屏，比用 GPIO 模拟快得多。
驱动 ADC / DAC（如 ADS1256、MCP4822）：用 SPI 读取高精度采样值或输出模拟电压。
接 SD 卡 / TF 卡：在 SPI 模式下读写文件系统（配合 FatFs）。
把轮询升级为 DMA：当数据量大（如连续采 1024 点波形、刷整屏图像）时，改用 SPI_master_slave_fullduplex_dma 例程，让数据自动搬运、CPU 去干别的事。
一主多从：保留一个主机 SPI，用多根 NSS 分别选通多个从机（Flash、LCD、传感器），实现单总线扩展多个外设。

想进一步提速或减轻 CPU 负担，建议直接阅读同目录的 SPI_master_slave_fullduplex_dma 例程。

GD32 SPI — SPI 主发从收中断

Tue, 08 Sep 2026 14:52:21 +0800

SPI — SPI 主发从收中断

固件库: GD32F30x_Firmware_Library V3.0.3
芯片: GD32
源文件: GD32F30x_Firmware_Library_V3.0.3/Examples/SPI/SPI_master_transmit_slave_receive_interrupt/main.c

功能简介

本示例演示 SPI 总线通信。SPI 是高速同步串行接口，常用于连接 Flash、LCD、传感器等外设。

硬件准备

需要主机和从机两块板子，或使用回环连接（MOSI→MISO）

完整代码

#include "gd32f30x.h"
#include "gd32f30x_it.h"
#include "gd32f307c_eval.h"
#define SPI_CRC_ENABLE                 1
#define ARRAYSIZE                      10
#define SET_SPI0_NSS_HIGH              gpio_bit_set(GPIOA,GPIO_PIN_3);
#define SET_SPI0_NSS_LOW               gpio_bit_reset(GPIOA,GPIO_PIN_3);
__IO uint32_t send_n = 0, receive_n = 0;

void rcu_config(void);
void gpio_config(void);
void spi_config(void);

/*!
    \brief      main function
    \param[in]  none
    \param[out] none
    \retval     none
*/
int main(void)
{
    /* init led2 */
    gd_eval_led_init(LED2);

    /* NVIC config */
    nvic_priority_group_set(NVIC_PRIGROUP_PRE1_SUB3);
    nvic_irq_enable(SPI0_IRQn,1,1);
    nvic_irq_enable(SPI2_IRQn,0,1);

    /* peripheral clock enable */
    rcu_config();
    /* GPIO config */
    gpio_config();
    /* SPI config */
    spi_config();

    SET_SPI0_NSS_HIGH

    /* SPI int enable */
    spi_i2s_interrupt_enable(SPI0, SPI_I2S_INT_TBE);
    spi_i2s_interrupt_enable(SPI2, SPI_I2S_INT_RBNE);

    SET_SPI0_NSS_LOW

    /* SPI enable */
    spi_enable(SPI2);
    spi_enable(SPI0);

    /* wait transmit complete */
    while(receive_n < ARRAYSIZE);

#if SPI_CRC_ENABLE
    /* check the CRC error status  */
    if(SET != spi_i2s_flag_get(SPI2, SPI_FLAG_CRCERR)) {
        gd_eval_led_on(LED2);
    } else {
        gd_eval_led_off(LED2);
    }

    SET_SPI0_NSS_HIGH

#else
    /* compare receive data with send data */
    if(memory_compare(spi2_receive_array, spi0_send_array, ARRAYSIZE))
        gd_eval_led_on(LED2);
    else
        gd_eval_led_off(LED2);
#endif /* enable CRC function */

    while(1);
   
}

void rcu_config(void)
{
    rcu_periph_clock_enable(RCU_GPIOA);
    rcu_periph_clock_enable(RCU_GPIOC);
    rcu_periph_clock_enable(RCU_SPI0);
    rcu_periph_clock_enable(RCU_SPI2);
    rcu_periph_clock_enable(RCU_AF);
}

void gpio_config(void)
{
    /* SPI0 GPIO config:SCK/PA5, MOSI/PA7 */
    gpio_init(GPIOA, GPIO_MODE_AF_PP, GPIO_OSPEED_50MHZ, GPIO_PIN_5 | GPIO_PIN_7);
    /* config PA3 as SPI0_NSS */
    gpio_init(GPIOA, GPIO_MODE_OUT_PP, GPIO_OSPEED_50MHZ, GPIO_PIN_3);

    gpio_pin_remap_config(GPIO_SPI2_REMAP,ENABLE);
    /* SPI2 GPIO config: NSS/PA4, SCK/PC10, MISO/PC11 */
    gpio_init(GPIOC, GPIO_MODE_IN_FLOATING, GPIO_OSPEED_50MHZ, GPIO_PIN_10 |GPIO_PIN_11);
    gpio_init(GPIOA, GPIO_MODE_IN_FLOATING, GPIO_OSPEED_50MHZ, GPIO_PIN_4);
}

void spi_config(void)
{
    spi_parameter_struct  spi_init_struct;

    /* SPI0 parameter config */
    spi_init_struct.trans_mode           = SPI_TRANSMODE_BDTRANSMIT;
    spi_init_struct.device_mode          = SPI_MASTER;
    spi_init_struct.frame_size           = SPI_FRAMESIZE_8BIT;
    spi_init_struct.clock_polarity_phase = SPI_CK_PL_HIGH_PH_2EDGE;
    spi_init_struct.nss                  = SPI_NSS_SOFT;
    spi_init_struct.prescale             = SPI_PSC_256;
    spi_init_struct.endian               = SPI_ENDIAN_MSB;
    spi_init(SPI0, &spi_init_struct);

    /* SPI2 parameter config */
    spi_init_struct.trans_mode  = SPI_TRANSMODE_BDRECEIVE;
    spi_init_struct.device_mode = SPI_SLAVE;
    spi_init_struct.nss         = SPI_NSS_HARD;
    spi_init(SPI2, &spi_init_struct);
#if SPI_CRC_ENABLE
    /* configure SPI CRC function */
    spi_crc_polynomial_set(SPI0, 7);
    spi_crc_polynomial_set(SPI2, 7);
    spi_crc_on(SPI0);
    spi_crc_on(SPI2);
#endif /* enable CRC function */
}

代码讲解

GPIO 配置：设置引脚为输出/输入模式，选择推挽/开漏输出，配置上拉/下拉。

SPI 配置：设置主/从模式、时钟极性（CPOL）、时钟相位（CPHA）、分频系数。主机和从机的 CPOL/CPHA 必须一致。

中断优先级配置：NVIC 设置中断的抢占优先级和子优先级。数字越小优先级越高。

实验现象

主机和从机互相交换数据
数据校验通过则 LED 指示成功

注意事项

CPOL 和 CPHA 必须主机从机一致
片选（CS）信号要手动拉低选中从机
时钟频率不能超过从设备的最大速率

PUYA — SPI 总线

Tue, 08 Sep 2026 14:52:21 +0800

PUYA — SPI 总线

固件库: PY32F002B_Firmware V1.2.1
示例数: 5

什么是 SPI 总线?

SPI 是高速同步串行接口，支持全双工通信。常用于连接 Flash、LCD、传感器等外设，速度可达几十 MHz。

示例列表

SPI_FullDuplex_ExternalFLASH — SPI_FullDuplex_ExternalFLASH
SPI_TwoBoards_FullDuplexMaster_IT — SPI_TwoBoards_FullDuplexMaster_IT
SPI_TwoBoards_FullDuplexMaster_Polling — SPI_TwoBoards_FullDuplexMaster_Polling
SPI_TwoBoards_FullDuplexSlave_IT — SPI_TwoBoards_FullDuplexSlave_IT
SPI_TwoBoards_FullDuplexSlave_Polling — SPI_TwoBoards_FullDuplexSlave_Polling

PUYA — SPI 总线

Tue, 08 Sep 2026 14:52:21 +0800

PUYA — SPI 总线

固件库: PY32F0xx_Firmware V1.5.0
示例数: 2

什么是 SPI 总线?

SPI 是高速同步串行接口，支持全双工通信。常用于连接 Flash、LCD、传感器等外设，速度可达几十 MHz。

示例列表

SPI_TwoBoards_FullDuplexMaster_DMA — SPI_TwoBoards_FullDuplexMaster_DMA
SPI_TwoBoards_FullDuplexSlave_DMA — SPI_TwoBoards_FullDuplexSlave_DMA

重点推荐：SPI 全双工主机（DMA）已整理为完整教学文档，并补充了轮询版用法说明。

PUYA — SPI 总线

Tue, 08 Sep 2026 14:52:21 +0800

PUYA — SPI 总线

固件库: PY32F403_Firmware V1.4.5
示例数: 7

什么是 SPI 总线?

SPI 是高速同步串行接口，支持全双工通信。常用于连接 Flash、LCD、传感器等外设，速度可达几十 MHz。

示例列表

SPI_FullDuplex_ExternalFLASH — SPI_FullDuplex_ExternalFLASH
SPI_TwoBoards_FullDuplexMaster_DMA — SPI_TwoBoards_FullDuplexMaster_DMA
SPI_TwoBoards_FullDuplexMaster_IT — SPI_TwoBoards_FullDuplexMaster_IT
SPI_TwoBoards_FullDuplexMaster_Polling — SPI_TwoBoards_FullDuplexMaster_Polling
SPI_TwoBoards_FullDuplexSlave_DMA — SPI_TwoBoards_FullDuplexSlave_DMA
SPI_TwoBoards_FullDuplexSlave_IT — SPI_TwoBoards_FullDuplexSlave_IT
SPI_TwoBoards_FullDuplexSlave_Polling — SPI_TwoBoards_FullDuplexSlave_Polling

PUYA — SPI 总线

Tue, 08 Sep 2026 14:52:21 +0800

PUYA — SPI 总线

固件库: PY32L020_Firmware V1.2.1
示例数: 5

什么是 SPI 总线?

SPI 是高速同步串行接口，支持全双工通信。常用于连接 Flash、LCD、传感器等外设，速度可达几十 MHz。

示例列表

SPI_FullDuplex_ExternalFLASH — SPI_FullDuplex_ExternalFLASH
SPI_TwoBoards_FullDuplexMaster_IT — SPI_TwoBoards_FullDuplexMaster_IT
SPI_TwoBoards_FullDuplexMaster_Polling — SPI_TwoBoards_FullDuplexMaster_Polling
SPI_TwoBoards_FullDuplexSlave_IT — SPI_TwoBoards_FullDuplexSlave_IT
SPI_TwoBoards_FullDuplexSlave_Polling — SPI_TwoBoards_FullDuplexSlave_Polling

PUYA SPI — SPI_FullDuplex_ExternalFLASH

Tue, 08 Sep 2026 14:52:21 +0800

SPI — SPI_FullDuplex_ExternalFLASH

固件库: PY32F002B_Firmware V1.2.1
芯片: PUYA
源文件: PUYA/PY32F002B_Firmware_V1.2.1/Projects/PY32F002B-STK/Example/SPI/SPI_FullDuplex_ExternalFLASH/Src/main.c

功能简介

本示例演示通过 SPI 接口读写 W25Q 系列 Flash 芯片。W25Q 是最常用的外部 SPI Flash，广泛用于存储固件、字库、图片等数据。

硬件准备

需要主机和从机两块板子，或使用回环连接（MOSI→MISO）

完整代码

1
2
3

#include "main.h"
#define DATA_LENGTH       15
#define FLASH_ADDR        0

代码讲解

代码结构清晰，主要包含外设初始化配置和主循环中的功能逻辑。请结合注释理解每一步的含义。

实验现象

主机和从机互相交换数据
数据校验通过则 LED 指示成功

注意事项

CPOL 和 CPHA 必须主机从机一致
片选（CS）信号要手动拉低选中从机
时钟频率不能超过从设备的最大速率

PUYA SPI — SPI_FullDuplex_ExternalFLASH

Tue, 08 Sep 2026 14:52:21 +0800

SPI — SPI_FullDuplex_ExternalFLASH

固件库: PY32F403_Firmware V1.4.5
芯片: PUYA
源文件: PUYA/PY32F403_Firmware_V1.4.5/Projects/PY32F403-STK/Example/SPI/SPI_FullDuplex_ExternalFLASH/Src/main.c

功能简介

本示例演示通过 SPI 接口读写 W25Q 系列 Flash 芯片。W25Q 是最常用的外部 SPI Flash，广泛用于存储固件、字库、图片等数据。

硬件准备

需要主机和从机两块板子，或使用回环连接（MOSI→MISO）

完整代码

1
2
3

#include "main.h"
#define DATA_LENGTH       15
#define FLASH_ADDR        0

代码讲解

代码结构清晰，主要包含外设初始化配置和主循环中的功能逻辑。请结合注释理解每一步的含义。

实验现象

主机和从机互相交换数据
数据校验通过则 LED 指示成功

注意事项

CPOL 和 CPHA 必须主机从机一致
片选（CS）信号要手动拉低选中从机
时钟频率不能超过从设备的最大速率

PUYA SPI — SPI_FullDuplex_ExternalFLASH

Tue, 08 Sep 2026 14:52:21 +0800

SPI — SPI_FullDuplex_ExternalFLASH

固件库: PY32L020_Firmware V1.2.1
芯片: PUYA
源文件: PUYA/PY32L020_Firmware_V1.2.1/Projects/PY32L020-STK/Example/SPI/SPI_FullDuplex_ExternalFLASH/Src/main.c

功能简介

本示例演示通过 SPI 接口读写 W25Q 系列 Flash 芯片。W25Q 是最常用的外部 SPI Flash，广泛用于存储固件、字库、图片等数据。

硬件准备

需要主机和从机两块板子，或使用回环连接（MOSI→MISO）

完整代码

1
2
3

#include "main.h"
#define DATA_LENGTH       15
#define FLASH_ADDR        0

代码讲解

代码结构清晰，主要包含外设初始化配置和主循环中的功能逻辑。请结合注释理解每一步的含义。

实验现象

主机和从机互相交换数据
数据校验通过则 LED 指示成功

注意事项

CPOL 和 CPHA 必须主机从机一致
片选（CS）信号要手动拉低选中从机
时钟频率不能超过从设备的最大速率

PUYA SPI — SPI_TwoBoards_FullDuplexMaster_DMA

Tue, 08 Sep 2026 14:52:21 +0800

SPI — SPI_TwoBoards_FullDuplexMaster_DMA

固件库: PY32F403_Firmware V1.4.5
芯片: PUYA
源文件: PUYA/PY32F403_Firmware_V1.4.5/Projects/PY32F403-STK/Example/SPI/SPI_TwoBoards_FullDuplexMaster_DMA/Src/main.c

功能简介

本示例演示 SPI 全双工通信。主机和从机可以同时收发数据，速度比 I2C 快得多。适合高速数据传输场景。

硬件准备

需要主机和从机两块板子，或使用回环连接（MOSI→MISO）

完整代码

1
2

#include "main.h"
#define DATA_LENGTH       15

代码讲解

代码结构清晰，主要包含外设初始化配置和主循环中的功能逻辑。请结合注释理解每一步的含义。

实验现象

主机和从机互相交换数据
数据校验通过则 LED 指示成功

注意事项

CPOL 和 CPHA 必须主机从机一致
片选（CS）信号要手动拉低选中从机
时钟频率不能超过从设备的最大速率

PUYA SPI — SPI_TwoBoards_FullDuplexMaster_IT

Tue, 08 Sep 2026 14:52:21 +0800

SPI — SPI_TwoBoards_FullDuplexMaster_IT

固件库: PY32F002B_Firmware V1.2.1
芯片: PUYA
源文件: PUYA/PY32F002B_Firmware_V1.2.1/Projects/PY32F002B-STK/Example/SPI/SPI_TwoBoards_FullDuplexMaster_IT/Src/main.c

功能简介

本示例演示 SPI 全双工通信。主机和从机可以同时收发数据，速度比 I2C 快得多。适合高速数据传输场景。

硬件准备

需要主机和从机两块板子，或使用回环连接（MOSI→MISO）

完整代码

1
2

#include "main.h"
#define DATA_LENGTH       15

代码讲解

代码结构清晰，主要包含外设初始化配置和主循环中的功能逻辑。请结合注释理解每一步的含义。

实验现象

主机和从机互相交换数据
数据校验通过则 LED 指示成功

注意事项

CPOL 和 CPHA 必须主机从机一致
片选（CS）信号要手动拉低选中从机
时钟频率不能超过从设备的最大速率

PUYA SPI — SPI_TwoBoards_FullDuplexMaster_IT

Tue, 08 Sep 2026 14:52:21 +0800

SPI — SPI_TwoBoards_FullDuplexMaster_IT

固件库: PY32F403_Firmware V1.4.5
芯片: PUYA
源文件: PUYA/PY32F403_Firmware_V1.4.5/Projects/PY32F403-STK/Example/SPI/SPI_TwoBoards_FullDuplexMaster_IT/Src/main.c

功能简介

本示例演示 SPI 全双工通信。主机和从机可以同时收发数据，速度比 I2C 快得多。适合高速数据传输场景。

硬件准备

需要主机和从机两块板子，或使用回环连接（MOSI→MISO）

完整代码

1
2

#include "main.h"
#define DATA_LENGTH       15

代码讲解

代码结构清晰，主要包含外设初始化配置和主循环中的功能逻辑。请结合注释理解每一步的含义。

实验现象

主机和从机互相交换数据
数据校验通过则 LED 指示成功

注意事项

CPOL 和 CPHA 必须主机从机一致
片选（CS）信号要手动拉低选中从机
时钟频率不能超过从设备的最大速率

PUYA SPI — SPI_TwoBoards_FullDuplexMaster_IT

Tue, 08 Sep 2026 14:52:21 +0800

SPI — SPI_TwoBoards_FullDuplexMaster_IT

固件库: PY32L020_Firmware V1.2.1
芯片: PUYA
源文件: PUYA/PY32L020_Firmware_V1.2.1/Projects/PY32L020-STK/Example/SPI/SPI_TwoBoards_FullDuplexMaster_IT/Src/main.c

功能简介

本示例演示 SPI 全双工通信。主机和从机可以同时收发数据，速度比 I2C 快得多。适合高速数据传输场景。

硬件准备

需要主机和从机两块板子，或使用回环连接（MOSI→MISO）

完整代码

1
2

#include "main.h"
#define DATA_LENGTH       15

代码讲解

代码结构清晰，主要包含外设初始化配置和主循环中的功能逻辑。请结合注释理解每一步的含义。

实验现象

主机和从机互相交换数据
数据校验通过则 LED 指示成功

注意事项

CPOL 和 CPHA 必须主机从机一致
片选（CS）信号要手动拉低选中从机
时钟频率不能超过从设备的最大速率

PUYA SPI — SPI_TwoBoards_FullDuplexMaster_Polling

Tue, 08 Sep 2026 14:52:21 +0800

SPI — SPI_TwoBoards_FullDuplexMaster_Polling

固件库: PY32F002B_Firmware V1.2.1
芯片: PUYA
源文件: PUYA/PY32F002B_Firmware_V1.2.1/Projects/PY32F002B-STK/Example/SPI/SPI_TwoBoards_FullDuplexMaster_Polling/Src/main.c

功能简介

本示例演示 SPI 全双工通信。主机和从机可以同时收发数据，速度比 I2C 快得多。适合高速数据传输场景。

硬件准备

需要主机和从机两块板子，或使用回环连接（MOSI→MISO）

完整代码

1
2

#include "main.h"
#define DATA_LENGTH       15

代码讲解

代码结构清晰，主要包含外设初始化配置和主循环中的功能逻辑。请结合注释理解每一步的含义。

实验现象

主机和从机互相交换数据
数据校验通过则 LED 指示成功

注意事项

CPOL 和 CPHA 必须主机从机一致
片选（CS）信号要手动拉低选中从机
时钟频率不能超过从设备的最大速率

PUYA SPI — SPI_TwoBoards_FullDuplexMaster_Polling

Tue, 08 Sep 2026 14:52:21 +0800

SPI — SPI_TwoBoards_FullDuplexMaster_Polling

固件库: PY32F403_Firmware V1.4.5
芯片: PUYA
源文件: PUYA/PY32F403_Firmware_V1.4.5/Projects/PY32F403-STK/Example/SPI/SPI_TwoBoards_FullDuplexMaster_Polling/Src/main.c

功能简介

本示例演示 SPI 全双工通信。主机和从机可以同时收发数据，速度比 I2C 快得多。适合高速数据传输场景。

硬件准备

需要主机和从机两块板子，或使用回环连接（MOSI→MISO）

完整代码

1
2

#include "main.h"
#define DATA_LENGTH       15

代码讲解

代码结构清晰，主要包含外设初始化配置和主循环中的功能逻辑。请结合注释理解每一步的含义。

实验现象

主机和从机互相交换数据
数据校验通过则 LED 指示成功

注意事项

CPOL 和 CPHA 必须主机从机一致
片选（CS）信号要手动拉低选中从机
时钟频率不能超过从设备的最大速率

PUYA SPI — SPI_TwoBoards_FullDuplexMaster_Polling

Tue, 08 Sep 2026 14:52:21 +0800

SPI — SPI_TwoBoards_FullDuplexMaster_Polling

固件库: PY32L020_Firmware V1.2.1
芯片: PUYA
源文件: PUYA/PY32L020_Firmware_V1.2.1/Projects/PY32L020-STK/Example/SPI/SPI_TwoBoards_FullDuplexMaster_Polling/Src/main.c

功能简介

本示例演示 SPI 全双工通信。主机和从机可以同时收发数据，速度比 I2C 快得多。适合高速数据传输场景。

硬件准备

需要主机和从机两块板子，或使用回环连接（MOSI→MISO）

完整代码

1
2

#include "main.h"
#define DATA_LENGTH       15

代码讲解

代码结构清晰，主要包含外设初始化配置和主循环中的功能逻辑。请结合注释理解每一步的含义。

实验现象

主机和从机互相交换数据
数据校验通过则 LED 指示成功

注意事项

CPOL 和 CPHA 必须主机从机一致
片选（CS）信号要手动拉低选中从机
时钟频率不能超过从设备的最大速率

PUYA SPI — SPI_TwoBoards_FullDuplexSlave_DMA

Tue, 08 Sep 2026 14:52:21 +0800

SPI — SPI_TwoBoards_FullDuplexSlave_DMA

固件库: PY32F0xx_Firmware V1.5.0
芯片: PUYA
源文件: PUYA/PY32F0xx_Firmware_V1.5.0/Projects/PY32F030-STK/Example/SPI/SPI_TwoBoards_FullDuplexSlave_DMA/Src/main.c

功能简介

本示例演示 SPI 全双工通信。主机和从机可以同时收发数据，速度比 I2C 快得多。适合高速数据传输场景。

硬件准备

需要主机和从机两块板子，或使用回环连接（MOSI→MISO）

完整代码

1
2

#include "main.h"
#define DATA_LENGTH       15

代码讲解

代码结构清晰，主要包含外设初始化配置和主循环中的功能逻辑。请结合注释理解每一步的含义。

实验现象

主机和从机互相交换数据
数据校验通过则 LED 指示成功

注意事项

CPOL 和 CPHA 必须主机从机一致
片选（CS）信号要手动拉低选中从机
时钟频率不能超过从设备的最大速率

PUYA SPI — SPI_TwoBoards_FullDuplexSlave_DMA

Tue, 08 Sep 2026 14:52:21 +0800

SPI — SPI_TwoBoards_FullDuplexSlave_DMA

固件库: PY32F403_Firmware V1.4.5
芯片: PUYA
源文件: PUYA/PY32F403_Firmware_V1.4.5/Projects/PY32F403-STK/Example/SPI/SPI_TwoBoards_FullDuplexSlave_DMA/Src/main.c

功能简介

本示例演示 SPI 全双工通信。主机和从机可以同时收发数据，速度比 I2C 快得多。适合高速数据传输场景。

硬件准备

需要主机和从机两块板子，或使用回环连接（MOSI→MISO）

完整代码

1
2

#include "main.h"
#define DATA_LENGTH       15

代码讲解

代码结构清晰，主要包含外设初始化配置和主循环中的功能逻辑。请结合注释理解每一步的含义。

实验现象

主机和从机互相交换数据
数据校验通过则 LED 指示成功

注意事项

CPOL 和 CPHA 必须主机从机一致
片选（CS）信号要手动拉低选中从机
时钟频率不能超过从设备的最大速率

PUYA SPI — SPI_TwoBoards_FullDuplexSlave_IT

Tue, 08 Sep 2026 14:52:21 +0800

SPI — SPI_TwoBoards_FullDuplexSlave_IT

固件库: PY32F002B_Firmware V1.2.1
芯片: PUYA
源文件: PUYA/PY32F002B_Firmware_V1.2.1/Projects/PY32F002B-STK/Example/SPI/SPI_TwoBoards_FullDuplexSlave_IT/Src/main.c

功能简介

本示例演示 SPI 全双工通信。主机和从机可以同时收发数据，速度比 I2C 快得多。适合高速数据传输场景。

硬件准备

需要主机和从机两块板子，或使用回环连接（MOSI→MISO）

完整代码

1
2

#include "main.h"
#define DATA_LENGTH       15

代码讲解

代码结构清晰，主要包含外设初始化配置和主循环中的功能逻辑。请结合注释理解每一步的含义。

实验现象

主机和从机互相交换数据
数据校验通过则 LED 指示成功

注意事项

CPOL 和 CPHA 必须主机从机一致
片选（CS）信号要手动拉低选中从机
时钟频率不能超过从设备的最大速率

PUYA SPI — SPI_TwoBoards_FullDuplexSlave_IT

Tue, 08 Sep 2026 14:52:21 +0800

SPI — SPI_TwoBoards_FullDuplexSlave_IT

固件库: PY32F403_Firmware V1.4.5
芯片: PUYA
源文件: PUYA/PY32F403_Firmware_V1.4.5/Projects/PY32F403-STK/Example/SPI/SPI_TwoBoards_FullDuplexSlave_IT/Src/main.c

功能简介

本示例演示 SPI 全双工通信。主机和从机可以同时收发数据，速度比 I2C 快得多。适合高速数据传输场景。

硬件准备

需要主机和从机两块板子，或使用回环连接（MOSI→MISO）

完整代码

1
2

#include "main.h"
#define DATA_LENGTH       15

代码讲解

代码结构清晰，主要包含外设初始化配置和主循环中的功能逻辑。请结合注释理解每一步的含义。

实验现象

主机和从机互相交换数据
数据校验通过则 LED 指示成功

注意事项

CPOL 和 CPHA 必须主机从机一致
片选（CS）信号要手动拉低选中从机
时钟频率不能超过从设备的最大速率

PUYA SPI — SPI_TwoBoards_FullDuplexSlave_IT

Tue, 08 Sep 2026 14:52:21 +0800

SPI — SPI_TwoBoards_FullDuplexSlave_IT

固件库: PY32L020_Firmware V1.2.1
芯片: PUYA
源文件: PUYA/PY32L020_Firmware_V1.2.1/Projects/PY32L020-STK/Example/SPI/SPI_TwoBoards_FullDuplexSlave_IT/Src/main.c

功能简介

本示例演示 SPI 全双工通信。主机和从机可以同时收发数据，速度比 I2C 快得多。适合高速数据传输场景。

硬件准备

需要主机和从机两块板子，或使用回环连接（MOSI→MISO）

完整代码

1
2

#include "main.h"
#define DATA_LENGTH       15

代码讲解

代码结构清晰，主要包含外设初始化配置和主循环中的功能逻辑。请结合注释理解每一步的含义。

实验现象

主机和从机互相交换数据
数据校验通过则 LED 指示成功

注意事项

CPOL 和 CPHA 必须主机从机一致
片选（CS）信号要手动拉低选中从机
时钟频率不能超过从设备的最大速率

PUYA SPI — SPI_TwoBoards_FullDuplexSlave_Polling

Tue, 08 Sep 2026 14:52:21 +0800

SPI — SPI_TwoBoards_FullDuplexSlave_Polling

固件库: PY32F002B_Firmware V1.2.1
芯片: PUYA
源文件: PUYA/PY32F002B_Firmware_V1.2.1/Projects/PY32F002B-STK/Example/SPI/SPI_TwoBoards_FullDuplexSlave_Polling/Src/main.c

功能简介

本示例演示 SPI 全双工通信。主机和从机可以同时收发数据，速度比 I2C 快得多。适合高速数据传输场景。

硬件准备

需要主机和从机两块板子，或使用回环连接（MOSI→MISO）

完整代码

1
2

#include "main.h"
#define DATA_LENGTH       15

代码讲解

代码结构清晰，主要包含外设初始化配置和主循环中的功能逻辑。请结合注释理解每一步的含义。

实验现象

主机和从机互相交换数据
数据校验通过则 LED 指示成功

注意事项

CPOL 和 CPHA 必须主机从机一致
片选（CS）信号要手动拉低选中从机
时钟频率不能超过从设备的最大速率

PUYA SPI — SPI_TwoBoards_FullDuplexSlave_Polling

Tue, 08 Sep 2026 14:52:21 +0800

SPI — SPI_TwoBoards_FullDuplexSlave_Polling

固件库: PY32F403_Firmware V1.4.5
芯片: PUYA
源文件: PUYA/PY32F403_Firmware_V1.4.5/Projects/PY32F403-STK/Example/SPI/SPI_TwoBoards_FullDuplexSlave_Polling/Src/main.c

功能简介

本示例演示 SPI 全双工通信。主机和从机可以同时收发数据，速度比 I2C 快得多。适合高速数据传输场景。

硬件准备

需要主机和从机两块板子，或使用回环连接（MOSI→MISO）

完整代码

1
2

#include "main.h"
#define DATA_LENGTH       15

代码讲解

代码结构清晰，主要包含外设初始化配置和主循环中的功能逻辑。请结合注释理解每一步的含义。

实验现象

主机和从机互相交换数据
数据校验通过则 LED 指示成功

注意事项

CPOL 和 CPHA 必须主机从机一致
片选（CS）信号要手动拉低选中从机
时钟频率不能超过从设备的最大速率

PUYA SPI — SPI_TwoBoards_FullDuplexSlave_Polling

Tue, 08 Sep 2026 14:52:21 +0800

SPI — SPI_TwoBoards_FullDuplexSlave_Polling

固件库: PY32L020_Firmware V1.2.1
芯片: PUYA
源文件: PUYA/PY32L020_Firmware_V1.2.1/Projects/PY32L020-STK/Example/SPI/SPI_TwoBoards_FullDuplexSlave_Polling/Src/main.c

功能简介

本示例演示 SPI 全双工通信。主机和从机可以同时收发数据，速度比 I2C 快得多。适合高速数据传输场景。

硬件准备

需要主机和从机两块板子，或使用回环连接（MOSI→MISO）

完整代码

1
2

#include "main.h"
#define DATA_LENGTH       15

代码讲解

代码结构清晰，主要包含外设初始化配置和主循环中的功能逻辑。请结合注释理解每一步的含义。

实验现象

主机和从机互相交换数据
数据校验通过则 LED 指示成功

注意事项

CPOL 和 CPHA 必须主机从机一致
片选（CS）信号要手动拉低选中从机
时钟频率不能超过从设备的最大速率

PUYA SPI — 全双工主机（中断方式）（LL 库）

Tue, 08 Sep 2026 14:52:21 +0800

SPI — 全双工主机（中断方式）（LL 库）

HAL vs LL：PUYA 固件库提供 HAL 和 LL 两套 API。

HAL 库：封装度高，可移植性强，适合快速开发

LL 库：接近寄存器操作，代码精简效率高，适合性能敏感场景本文使用 LL 库版本。

固件库: PY32F0xx_Firmware V1.5.0
芯片: PY32F030（PY32F002A / F003 同库可参考）
源文件: PUYA/PY32F0xx_Firmware_V1.5.0/Projects/PY32F030-STK/Example_LL/SPI/SPI_TwoBoards_FullDuplexMaster_IT_Init/Src/main.c

功能简介

本示例演示 SPI 全双工主机（Master），使用中断方式：按键后使能 SPI1，通过 TXE/RXNE 中断逐字节发送 15 字节，同时接收对方回环的数据，结束后比对收发一致性——一致则点亮 LED，否则 LED 闪烁。

说明：PUYA 的 LL 示例库里 SPI 只有 DMA 和中断（IT）两种版本，没有轮询（Polling）版。你点名要的 SPI_TwoBoards_FullDuplexMaster_Polling 在 LL 中不存在，这里用最接近、也最能体现 LL 风格的 ..._IT_Init（中断方式）来替代。HAL 版则有 ..._Master_DMA，可作为对照。

与 HAL 版（HAL_SPI_TransmitReceive）相比，LL 版把“每个字节的收发”交给中断回调函数 APP_SpiTxCallback() / APP_SpiRxCallback() 完成，主循环只需等传输完成——这正是 LL 在“不阻塞 CPU”场景下的典型写法。

硬件准备

两块 PY32F030 开发板（一块主机、一块从机，跑对应 Slave 示例做回环）
SPI 连线：主机 PB3(SCK) ↔ 从机 SCK，PB4(MISO) ↔ MISO，PB5(MOSI) ↔ MOSI
主机板载按键（KEY）、绿 LED

完整代码

#include "main.h"
#include "py32f030xx_ll_Start_Kit.h"

uint8_t aTxBuffer[] = {1,2,3,4,5,6,7,8,9,10,11,12,13,14,15};
uint8_t ubNbDataToTransmit = sizeof(aTxBuffer);
uint8_t ubTransmitIndex = 0;

uint8_t aRxBuffer[sizeof(aTxBuffer)] = {0};
uint8_t ubNbDataToReceive = sizeof(aTxBuffer);
uint8_t ubReceiveIndex = 0;

static void APP_SystemClockConfig(void);
static void APP_ConfigSPI(void);
static void APP_WaitAndCheckEndOfTransfer(void);
static uint8_t APP_Buffercmp8(uint8_t* pBuffer1, uint8_t* pBuffer2, uint8_t BufferLength);
static void APP_LedBlinking(void);

int main(void)
{
  APP_SystemClockConfig();
  BSP_LED_Init(LED_GREEN);
  BSP_PB_Init(BUTTON_KEY, BUTTON_MODE_GPIO);

  APP_ConfigSPI();                        /* 配置 SPI1 + 中断 */

  while (BSP_PB_GetState(BUTTON_KEY) == 1);   /* 等按键 */

  LL_SPI_Enable(SPI1);                    /* 使能 SPI1，中断随即开始搬运 */
  APP_WaitAndCheckEndOfTransfer();        /* 等传输完并校验 */

  while (1) {}
}

/**
  * @brief  SPI1 配置（PB3/4/5 复用 + 参数 + 中断）
  */
static void APP_ConfigSPI(void)
{
  LL_SPI_InitTypeDef   SPI_InitStruct = {0};
  LL_GPIO_InitTypeDef GPIO_InitStruct = {0};

  LL_APB1_GRP2_EnableClock(LL_APB1_GRP2_PERIPH_SPI1);
  LL_IOP_GRP1_EnableClock(LL_IOP_GRP1_PERIPH_GPIOB);

  /* PB3=SCK, PB4=MISO, PB5=MOSI，全部复用 AF0 */
  GPIO_InitStruct.Pin        = LL_GPIO_PIN_3;
  GPIO_InitStruct.Mode       = LL_GPIO_MODE_ALTERNATE;
  GPIO_InitStruct.Speed      = LL_GPIO_SPEED_FREQ_HIGH;
  GPIO_InitStruct.OutputType = LL_GPIO_OUTPUT_PUSHPULL;
  GPIO_InitStruct.Pull       = LL_GPIO_PULL_UP;
  GPIO_InitStruct.Alternate  = LL_GPIO_AF_0;
  LL_GPIO_Init(GPIOB, &GPIO_InitStruct);

  GPIO_InitStruct.Pin = LL_GPIO_PIN_4;
  GPIO_InitStruct.Pull = LL_GPIO_PULL_NO;     /* MISO 无需上拉 */
  LL_GPIO_Init(GPIOB, &GPIO_InitStruct);

  GPIO_InitStruct.Pin = LL_GPIO_PIN_5;
  GPIO_InitStruct.Pull = LL_GPIO_PULL_NO;
  LL_GPIO_Init(GPIOB, &GPIO_InitStruct);

  /* SPI1 中断 */
  NVIC_SetPriority(SPI1_IRQn, 1);
  NVIC_EnableIRQ(SPI1_IRQn);

  /* SPI 参数：全双工、主机、8 位、极性高/相位1边沿、软件 NSS、128 分频 */
  SPI_InitStruct.TransferDirection = LL_SPI_FULL_DUPLEX;
  SPI_InitStruct.Mode              = LL_SPI_MODE_MASTER;
  SPI_InitStruct.DataWidth         = LL_SPI_DATAWIDTH_8BIT;
  SPI_InitStruct.ClockPolarity     = LL_SPI_POLARITY_HIGH;
  SPI_InitStruct.ClockPhase        = LL_SPI_PHASE_1EDGE;
  SPI_InitStruct.NSS               = LL_SPI_NSS_SOFT;
  SPI_InitStruct.BaudRate          = LL_SPI_BAUDRATEPRESCALER_DIV128;
  SPI_InitStruct.BitOrder          = LL_SPI_MSB_FIRST;
  LL_SPI_Init(SPI1, &SPI_InitStruct);

  LL_SPI_SetRxFIFOThreshold(SPI1, LL_SPI_RX_FIFO_TH_QUARTER);  /* RXNE 在收到 1 字节时置位 */

  LL_SPI_EnableIT_TXE(SPI1);   /* 使能“发送空”中断 */
  LL_SPI_EnableIT_RXNE(SPI1);  /* 使能“接收非空”中断 */
  LL_SPI_EnableIT_ERR(SPI1);   /* 使能错误中断 */
}

/* 以下回调由 SPI1 中断服务程序调用（在 stm32py32xx_it.c 中） */
void APP_SpiRxCallback(void)
{
  aRxBuffer[ubReceiveIndex++] = LL_SPI_ReceiveData8(SPI1);   /* 读 DR 同时清 RXNE */
}
void APP_SpiTxCallback(void)
{
  LL_SPI_TransmitData8(SPI1, aTxBuffer[ubTransmitIndex++]);  /* 写 DR 启动一次收发 */
}
void APP_SpiTransferErrorCallback(void)
{
  LL_SPI_DisableIT_RXNE(SPI1);
  LL_SPI_DisableIT_TXE(SPI1);
  APP_LedBlinking();
}

/**
  * @brief  等待收发完成并比对
  */
static void APP_WaitAndCheckEndOfTransfer(void)
{
  while (ubTransmitIndex != ubNbDataToTransmit) {}   /* 等发完 */
  LL_SPI_DisableIT_TXE(SPI1);
  while (ubNbDataToReceive > ubReceiveIndex) {}      /* 等收完 */
  LL_SPI_DisableIT_RXNE(SPI1);

  if (APP_Buffercmp8((uint8_t*)aTxBuffer, (uint8_t*)aRxBuffer, ubNbDataToTransmit))
    APP_LedBlinking();
  else
    BSP_LED_On(LED_GREEN);
}
/* APP_Buffercmp8 / APP_LedBlinking / 时钟与错误处理 略 */

代码分段讲解

1. GPIO 复用与 SPI 参数

PB3/4/5 设为 LL_GPIO_MODE_ALTERNATE + Alternate = LL_GPIO_AF_0 接到 SPI1。SPI 参数结构体 LL_SPI_InitTypeDef 与 HAL 的 SPI_HandleTypeDef.Init 字段几乎一一对应：全双工、主机、8 位、CPOL/CPHA、软件 NSS、波特率分频、MSB 优先。

2. 中断方式的核心：TXE / RXNE 回调

HAL 的 HAL_SPI_TransmitReceive() 内部要么轮询、要么用 DMA；LL 这里走中断：

使能 LL_SPI_EnableIT_TXE()：发送缓冲区空时进中断 → APP_SpiTxCallback() 写一个字节，SPI 硬件同时自动收一个字节；
使能 LL_SPI_EnableIT_RXNE()：收到一个字节进中断 → APP_SpiRxCallback() 读走它。

因为 SPI 是全双工，每发一个必然同时收一个，所以两个索引独立推进，主循环只需等两者都到头。

3. FIFO 阈值

LL_SPI_SetRxFIFOThreshold(..., LL_SPI_RX_FIFO_TH_QUARTER) 让 RXNE 在“收到 1 个字节”时就置位（而不是等 FIFO 半满），保证逐字节中断行为正确。这是 LL 才需要你显式关心的底层细节。

4. 为什么 LL 没有“轮询 SPI”示例

SPI 全双工收发天然适合“发一个收一个”的流式处理，用中断/DMA 比忙等更高效；而 HAL 为了 API 对称提供了 HAL_SPI_TransmitReceive（轮询版）。LL 把“怎么搬”的选择权完全交给你——你可以轻松把本例的 IT 改成轮询（去掉中断、在主循环里查 LL_SPI_IsActiveFlag_TXE）。

实验现象

主从板 SPI 四线连好，从机跑 Slave 示例。
主机按下 KEY，SPI1 使能，开始全双工收发 15 字节。
收发结束，数据比对一致 → 绿 LED 常亮；不一致 → 绿 LED 闪烁。

常见问题

收发数据对不上？
- 确认主从 CPOL/CPHA 一致（本例极性高/相位1边沿）。
- 确认 NSS 处理：本例用软件 NSS（LL_SPI_NSS_SOFT），硬件 NSS 引脚未参与，接线时从机片选要正确拉低。
只进 TX 中断不出 RX？
- 多半是 MISO 线没连通或主从没共地；SPI 收不到字节，RXNE 永远不会置位。
想用 DMA？
- 参考 SPI_TwoBoards_FullDuplexMaster_DMA_Init，用 LL_DMA_* 把缓冲区交给 DMA 搬运，CPU 零参与。

小结

LL 的 SPI 全双工主机 = 配 GPIO 复用 + 配 SPI 参数 + 选中断/DMA/轮询搬运 + 使能。
相比 HAL 的一行 HAL_SPI_TransmitReceive，LL 让你自己决定“字节怎么搬”，中断回调写法最贴近硬件。
SPI 没有 LL 轮询示例，但把 IT 版本去掉中断、改轮询标志即可等价实现。

拓展应用

把 IT 改成纯轮询（查 LL_SPI_IsActiveFlag_TXE/RXNE），代码更简单便于理解。
改用 DMA 搬运长帧，提升吞吐（参考 _DMA_Init）。
接真实 SPI 器件（LCD、Flash、传感器），把回环逻辑换成器件寄存器读写。
增加超时判断，避免从机异常时主循环死等。

AT32 SPI — 读写 W25Q Flash（外部存储芯片）

Tue, 08 Sep 2026 15:03:00 +0800

SPI — 读写 W25Q Flash

难度: ⭐⭐（需要了解 SPI 基本概念）
固件库: AT32F403A_407_Firmware_Library V2.2.2
源文件: project/at_start_f403a/examples/spi/w25q_flash/src/main.c

这个实验是干嘛的？

MCU 内部的 Flash 空间有限（几百 KB），存不下大文件（字库、图片、音频）。这时候就需要外部 Flash 芯片。

W25Q 系列是最常用的 SPI Flash，容量从 1MB 到 256MB 都有，价格便宜（几毛钱），接口简单（4 根线）。

本实验做的事情：

通过 SPI 读取 Flash 芯片的 ID（确认芯片存在且型号正确）
擦除一个扇区（Flash 必须先擦后写）
写入 512 字节测试数据
读回数据并与原始数据比对
数据一致 → LED 亮（成功），不一致 → LED 灭（失败）

硬件准备

你需要一个 W25Q Flash 模块（淘宝几块钱）：

开发板          W25Q 模块
  PA4 (CS)  ──→  CS
  PA5 (SCK) ──→  CLK
  PA6 (MISO)←──  DO
  PA7 (MOSI)──→  DI
  3.3V      ──→  VCC
  GND       ──→  GND

注意：

CS 是片选信号，拉低选中芯片
SPI 通信必须共地
W25Q 供电 3.3V，不要接 5V

SPI 基础知识

SPI 是一种同步、全双工的串行通信接口，只需要 4 根线：

信号	全称	方向	说明
SCK	Serial Clock	主→从	时钟信号，主机产生
MOSI	Master Out Slave In	主→从	主机发数据给从机
MISO	Master In Slave Out	从→主	从机发数据给主机
CS	Chip Select	主→从	片选，拉低选中从机

SPI 的特点：

速度比 I2C 快得多（可达几十 MHz）
全双工：主机和从机可以同时收发
每个从机需要一根独立的 CS 线

完整代码

#include "at32f403a_407_board.h"
#include "at32f403a_407_clock.h"
#include "spi_flash.h"    // W25Q 驱动（官方封装好的）

/* 测试地址和缓冲区大小 */
#define FLASH_TEST_ADDR    0x1000    // 测试起始地址
#define BUF_SIZE           0x256     // 512 字节

uint8_t tx_buffer[BUF_SIZE];   // 发送缓冲区
uint8_t rx_buffer[BUF_SIZE];   // 接收缓冲区
volatile error_status transfer_status = ERROR;

/* 填充测试数据：0x00, 0x01, 0x02, ... 0xFF */
void tx_data_fill(void)
{
  uint32_t i;
  for(i = 0; i < BUF_SIZE; i++)
  {
    tx_buffer[i] = i;
  }
}

/* 缓冲区比对 */
error_status buffer_compare(uint8_t* p1, uint8_t* p2, uint16_t len)
{
  while(len--)
  {
    if(*p1 != *p2) return ERROR;
    p1++;
    p2++;
  }
  return SUCCESS;
}

int main(void)
{
  __IO uint32_t flash_id = 0;

  system_clock_config();
  at32_board_init();
  tx_data_fill();
  uart_print_init(115200);

  /* ===== 第一步：初始化 SPI Flash ===== */
  spiflash_init();

  /* ===== 第二步：读取芯片 ID ===== */
  flash_id = spiflash_read_id();

  /* 验证 ID 是否是 W25Q 系列 */
  if(flash_id != W25Q128 && flash_id != W25Q64 &&
     flash_id != W25Q32  && flash_id != W25Q16 && flash_id != W25Q80)
  {
    printf("flash id check error! id: %x\r\n", flash_id);
    // LED 快闪报错
    for(int i = 0; i < 50; i++)
    {
      at32_led_toggle(LED2);
      at32_led_toggle(LED3);
      delay_ms(200);
    }
    return 1;
  }
  else
  {
    printf("flash id check success! id: %x\r\n", flash_id);
  }

  /* ===== 第三步：擦除扇区 ===== */
  // Flash 必须先擦后写！擦除后所有字节变成 0xFF
  spiflash_sector_erase(FLASH_TEST_ADDR / SPIF_SECTOR_SIZE);

  /* ===== 第四步：写入数据 ===== */
  spiflash_write(tx_buffer, FLASH_TEST_ADDR, BUF_SIZE);

  /* ===== 第五步：读回数据 ===== */
  spiflash_read(rx_buffer, FLASH_TEST_ADDR, BUF_SIZE);

  /* 打印读到的数据 */
  printf("Read Data: ");
  for(int i = 0; i < BUF_SIZE; i++)
  {
    printf("%x ", rx_buffer[i]);
  }

  /* ===== 第六步：比对验证 ===== */
  transfer_status = buffer_compare(rx_buffer, tx_buffer, BUF_SIZE);

  if(transfer_status == SUCCESS)
  {
    printf("\r\nflash data read write success!\r\n");
    at32_led_on(LED2);   // LED2 亮 = 成功
  }
  else
  {
    printf("\r\nflash data read write ERROR!\r\n");
    at32_led_off(LED2);  // LED2 灭 = 失败
  }

  while(1) {}
}

代码分段讲解

1. 初始化 SPI Flash

`1`	`spiflash_init();`

这行做了什么：

配置 SPI1 为主机模式
配置时钟极性（CPOL）和相位（CPHA）—— W25Q 要求 CPOL=0, CPHA=0
配置 CS 引脚（PA4）为 GPIO 输出
拉高 CS（不选中芯片）

2. 读取芯片 ID

`1`	`flash_id = spiflash_read_id();`

每个 W25Q 芯片都有一个唯一的制造商 ID + 设备 ID：

W25Q80 → 0xEF14
W25Q16 → 0xEF15
W25Q32 → 0xEF16
W25Q64 → 0xEF17
W25Q128 → 0xEF18

读 ID 的命令是 0x90，SPI 时序：

1
2

主机发送: [0x90] [0x00] [0x00] [0x00] [dummy] [dummy]
从机返回: [dummy] [dummy] [dummy] [dummy] [制造商ID] [设备ID]

3. 擦除扇区

`1`	`spiflash_sector_erase(FLASH_TEST_ADDR / SPIF_SECTOR_SIZE);`

Flash 的铁律：必须先擦后写！

Flash 只能把 1 写成 0，不能把 0 写成 1。所以写之前必须先擦除（把所有位变成 1 = 0xFF）。

W25Q 的最小擦除单位是扇区（4KB）。擦除命令是 0x20。

4. 写入数据

`1`	`spiflash_write(tx_buffer, FLASH_TEST_ADDR, BUF_SIZE);`

写入流程：

发送写使能命令（0x06）— 必须先使能才能写
发送页编程命令（0x02）+ 地址 + 数据
等待写入完成（读状态寄存器，等 BUSY 位清零）

注意：W25Q 一次最多写 256 字节（一页），跨页需要分多次写。

5. 读取数据

`1`	`spiflash_read(rx_buffer, FLASH_TEST_ADDR, BUF_SIZE);`

读取最简单：发送读命令（0x03）+ 地址，然后持续读取数据。没有长度限制。

实验现象

串口输出：

1
2
3

flash id check success! id: ef16
Read Data: 0 1 2 3 4 5 6 7 8 9 a b c d e f 10 11 ...
flash data read write success!

LED2 亮起表示读写成功
如果 LED 快闪，说明芯片 ID 读取失败（接线问题）

常见问题

Q: 读到的 ID 是 0x0000 或 0xFFFF？

检查接线：CS、SCK、MOSI、MISO 是否正确
检查供电：W25Q 需要 3.3V
检查 SPI 模式：CPOL=0, CPHA=0

Q: 写入后读出来的数据不对？

是否先擦除了？Flash 必须先擦后写
擦除后检查是否全为 0xFF
写入地址是否对齐（扇区边界 4KB 对齐）

Q: 想存储大文件怎么办？

Flash 文件系统：FatFs + SPI Flash
或者简单方案：固定地址存储，自己管理地址分配

小结

概念	说明
SPI	高速同步串行接口，4 线制
W25Q	最常用的 SPI Flash 芯片
先擦后写	Flash 的铁律，擦除后全为 0xFF
扇区	最小擦除单位，W25Q 是 4KB
页写入	一次最多写 256 字节

学了 SPI 能做什么？

SPI 是连接"高速外设"的主力接口：

存储与显示

项目	原理	难度
字库存储	中文字库烧录到 W25Q，LCD 显示中文	⭐⭐⭐
图片存储	BMP/JPG 图片存 Flash，LCD 显示	⭐⭐⭐
数据记录	传感器数据存 Flash，掉电不丢失	⭐⭐
固件升级	新固件存 Flash，IAP 从 Flash 加载运行	⭐⭐⭐⭐
LCD 驱动	SPI 接口的 TFT LCD（ST7735、ILI9341）	⭐⭐⭐
OLED 显示	SPI 接口的 OLED 屏（SSD1306）	⭐⭐

传感器与通信

项目	原理	难度
SD 卡读写	SPI 模式访问 SD 卡，实现大容量存储	⭐⭐⭐
加速度计	SPI 接口的 MEMS 传感器（MPU6050）	⭐⭐⭐
LoRa 通信	SPI 接口的 LoRa 模块（SX1278）	⭐⭐⭐⭐
以太网	SPI 接口的以太网芯片（W5500）	⭐⭐⭐⭐
CAN 控制器	SPI 接口的 CAN 芯片（MCP2515）	⭐⭐⭐

核心思路：SPI 的核心优势是速度快。Flash、LCD、传感器这些需要大量数据传输的外设，几乎都用 SPI。掌握了 SPI，你就打开了连接各种高速外设的大门。

下一步：学会了 SPI，可以学 I2C 读写 EEPROM，了解另一种常用的低速通信总线。