AT32 — SPI 总线 on CLing

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）信号要手动拉低选中从机
时钟频率不能超过从设备的最大速率

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，了解另一种常用的低速通信总线。