I2s on CLing

PUYA I2S — 主机轮询收发（双板）

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

I2S — 主机轮询收发（双板）

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

功能简介

I2S（Inter-IC Sound）是专为数字音频设计的同步串行总线，三线（SCK 位时钟、WS 声道选择、SD 数据）+ 可选 MCLK 主时钟，常用于连接音频 DAC/ADC、CODEC、MEMS 麦克风。

PY32F403 的 SPI2 外设可复用为 I2S。本示例演示主机（Master）轮询收发：

先配置为 I2S_MODE_MASTER_TX，发送 16 个 16 位样本；
再切换为 I2S_MODE_MASTER_RX，接收 16 个样本；
轮询等待每步完成，最后比较收发数据；
一致则点亮绿灯，不一致则闪烁报警。

I2S 与 SPI 分时复用同一组引脚，区别在 HAL_I2S_Init 时选 I2S_* 模式而非 SPI_*。

硬件准备

两块 PY32F403 开发板（一主一发/收，或一块自连回环）
交叉连接 I2S 信号：主 SCK↔从 SCK，主 WS↔从 WS，主 SD↔从 SD（MOSI/MISO），共地
板载 LED / 按键用于交互（示例需按键触发一次传输）

完整代码（主机部分）

#include "main.h"

I2S_HandleTypeDef I2sHandle;
uint16_t TxBuff[16] = {1,2,3,4,5,6,7,8,9,10,11,12,13,14,15,16};
uint16_t RxBuff[16] = {0};
#define DATA_LENGTH 16

int main(void)
{
  HAL_Init();
  APP_SystemClockConfig();         /* 系统时钟：HSI */
  BSP_LED_Init(LED_GREEN);
  BSP_PB_Init(BUTTON_KEY, BUTTON_MODE_GPIO);

  while (BSP_PB_GetState(BUTTON_KEY) == 1) {}  /* 等按键触发 */

  /* === 主机发送 === */
  I2sHandle.Instance        = SPI2;            /* I2S 复用 SPI2 */
  I2sHandle.Init.Mode       = I2S_MODE_MASTER_TX; /* 主机发送 */
  I2sHandle.Init.Standard   = I2S_STANDARD_PHILIPS; /* 飞利浦标准 */
  I2sHandle.Init.DataFormat = I2S_DATAFORMAT_16B;  /* 16 位数据 */
  I2sHandle.Init.MCLKOutput = I2S_MCLKOUTPUT_DISABLE;
  I2sHandle.Init.AudioFreq  = I2S_AUDIOFREQ_8K;    /* 8kHz 采样率 */
  I2sHandle.Init.CPOL       = I2S_CPOL_HIGH;       /* 时钟极性 */
  if (HAL_I2S_Init(&I2sHandle) != HAL_OK) APP_ErrorHandler();

  if (HAL_I2S_Transmit(&I2sHandle, (uint16_t*)TxBuff, DATA_LENGTH, 5000) != HAL_OK)
    APP_ErrorHandler();
  while (HAL_I2S_GetState(&I2sHandle) != HAL_I2S_STATE_READY) {}

  HAL_Delay(1);  /* 给从机一点准备时间 */

  /* === 主机接收 === */
  I2sHandle.Init.Mode = I2S_MODE_MASTER_RX;     /* 切换为主机接收 */
  if (HAL_I2S_Init(&I2sHandle) != HAL_OK) APP_ErrorHandler();

  if (HAL_I2S_Receive(&I2sHandle, (uint16_t*)RxBuff, DATA_LENGTH, 5000) != HAL_OK)
    APP_ErrorHandler();
  while (HAL_I2S_GetState(&I2sHandle) != HAL_I2S_STATE_READY) {}

  APP_CheckEndOfTransfer();   /* 比较收发，亮灯/闪烁 */
  while (1) {}
}

代码分段讲解

1. 标准与极性

I2S_STANDARD_PHILIPS：标准飞利浦格式（WS 在第二个时钟沿变化，SD 在 WS 变化后一位有效）。另有 MSB/LSB 对齐、PCM 等格式，按 CODEC 手册选。
CPOL：串行时钟空闲极性，必须与对端一致。

2. 采样率 AudioFreq

I2S_AUDIOFREQ_8K 决定 SCK/WS 频率。HAL 会根据系统时钟自动计算分频；常见值 8k/16k/44.1k/48k。实际可用频率受主时钟约束，复杂场景需打开 MCLK 并精确配置。

3. 主机切换发/收

同一 I2sHandle 重新 HAL_I2S_Init 改 Mode 即可在 TX/RX 间切换（本例用两块板对传，先发后收）。真实音频链路通常是固定方向：MCU 做发送端驱动 DAC，或做接收端读 ADC。

4. 轮询

HAL_I2S_Transmit/Receive(..., Timeout) 阻塞直到完成或超时，代码简单但占 CPU。大数据量/连续音频建议用 IT 或 DMA 版（同目录有 _DMA / _IT）。

实验现象

按键后主机发送 {1..16}，再接收一帧；
收发一致（回环或正确对接），绿灯常亮；不一致则绿灯 500ms 闪烁。

常见问题

没声音 / 收不到数据？
- 确认 I2S 引脚（SCK/WS/SD）与 SPI2 复用引脚一致，且主从 Standard/CPOL/DataFormat/AudioFreq 完全相同。
- 主从共地，接线交叉正确。
想连续播放音频？
- 用 HAL_I2S_Transmit_DMA + 双缓冲，从 Flash/SD 卡取 PCM 数据不断送 DAC（如 WM8978、MAX98357A）。
采样率不准/有杂音？
- 检查系统时钟与 MCLK 配置；音频对时钟精度敏感，必要时开 MCLK 输出给 CODEC 作基准。

小结

I2S 配置要点：标准格式、数据位宽、声道极性 CPOL、采样率、主/从模式。
SPI2 可复用为 I2S，引脚与 SPI 相同。
轮询版适合教学；音频流用 DMA/中断。

拓展应用

驱动 I2S DAC（MAX98357A）播放 WAV/提示音。
读取 I2S MEMS 麦克风做录音/声控。
接 CODEC（WM8978）做双向音频（通话/采集）。
DMA + 双缓冲实现不间断音频流。

AT32 — I2S 音频总线

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

AT32 — I2S 音频总线

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

什么是 I2S 音频总线?

I2S 是数字音频传输标准，用于连接音频 DAC/ADC、MEMS 麦克风等音频设备。

示例列表

全双工 DMA — fullduplex_dma
半双工 DMA — halfduplex_dma
半双工中断 — halfduplex_interrupt
SPI/I2S 切换半双工轮询 — spii2s_switch_halfduplex_polling

AT32 I2S — SPI/I2S 切换半双工轮询

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

I2S — SPI/I2S 切换半双工轮询

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

功能简介

本示例演示 I2S 音频总线通信。I2S 是数字音频传输标准，常用于连接 DAC/ADC 音频芯片、MEMS 麦克风等。

完整代码

#include "at32f403a_407_board.h"
#include "at32f403a_407_clock.h"
#include <stdio.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)

static void i2s_config(i2s_operation_mode_type i2s3_mode, i2s_operation_mode_type i2s2_mode)
{
  i2s_init_type i2s_init_struct;
  
  /* i2s3 initialization */
  crm_periph_clock_enable(CRM_SPI3_PERIPH_CLOCK, TRUE);
  spi_i2s_reset(SPI3);
  i2s_default_para_init(&i2s_init_struct);
  
  i2s_init_struct.audio_protocol = I2S_AUDIO_PROTOCOL_PHILLIPS;
  i2s_init_struct.data_channel_format = I2S_DATA_16BIT_CHANNEL_32BIT;
  i2s_init_struct.mclk_output_enable = FALSE;
  i2s_init_struct.audio_sampling_freq = I2S_AUDIO_FREQUENCY_48K;
  i2s_init_struct.clock_polarity = I2S_CLOCK_POLARITY_LOW;
  i2s_init_struct.operation_mode = i2s3_mode;
  i2s_init(SPI3, &i2s_init_struct);
  
  /* i2s2 initialization */
  crm_periph_clock_enable(CRM_SPI2_PERIPH_CLOCK, TRUE);
  spi_i2s_reset(SPI2);
  i2s_init_struct.audio_protocol = I2S_AUDIO_PROTOCOL_PHILLIPS;
  i2s_init_struct.data_channel_format = I2S_DATA_16BIT_CHANNEL_32BIT;
  i2s_init_struct.mclk_output_enable = FALSE;
  i2s_init_struct.audio_sampling_freq = I2S_AUDIO_FREQUENCY_48K;
  i2s_init_struct.clock_polarity = I2S_CLOCK_POLARITY_LOW;
  i2s_init_struct.operation_mode =i2s2_mode;
  i2s_init(SPI2, &i2s_init_struct);
}

static void spi_config(void)
{
  spi_init_type spi_init_struct;
  
  /* master spi initialization */
  crm_periph_clock_enable(CRM_SPI3_PERIPH_CLOCK, TRUE);
  spi_i2s_reset(SPI3);
  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_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(SPI3, &spi_init_struct);
  
  spi_enable(SPI3, TRUE);
  
  /* slave spi initialization */
  crm_periph_clock_enable(CRM_SPI2_PERIPH_CLOCK, TRUE);
  spi_i2s_reset(SPI2);
  
  /* 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_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);

  spi_enable(SPI2, TRUE);
  
}

static void gpio_config(uint16_t spi_i2s_mode)
{
  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);

  /* master ws/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;
  gpio_initstructure.gpio_pins = GPIO_PINS_15;
  if(spi_i2s_mode == 0)
  {
    gpio_initstructure.gpio_mode = GPIO_MODE_OUTPUT;
  }
  else
  {
    gpio_initstructure.gpio_mode = GPIO_MODE_MUX;
  }
  gpio_init(GPIOA, &gpio_initstructure);
  if(spi_i2s_mode == 0)
  {
    /* non communication time: master pull up CS pin release slave */
    SPI_MASTER_CS_HIGH;
  }

  /* master ck 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_3;
  gpio_init(GPIOB, &gpio_initstructure);

  /* master sd pin */
  gpio_initstructure.gpio_pull = GPIO_PULL_UP;
  gpio_initstructure.gpio_pins = GPIO_PINS_5;
  gpio_init(GPIOB, &gpio_initstructure);

  /* slave ws 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_12;
  gpio_init(GPIOB, &gpio_initstructure);

  /* slave ck pin */
  gpio_initstructure.gpio_pull = GPIO_PULL_DOWN;
  gpio_initstructure.gpio_pins = GPIO_PINS_13;
  gpio_init(GPIOB, &gpio_initstructure);

  /* slave sd pin */
  gpio_initstructure.gpio_pull = GPIO_PULL_UP;
  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);
  
  /* first: i2s communication */
  gpio_config(1);
  i2s_config(I2S_MODE_MASTER_TX, I2S_MODE_SLAVE_RX);
  i2s_enable(SPI2, TRUE);
  i2s_enable(SPI3, TRUE);
  while(rx_index < 32)
  {
    /* i2s transmit data fill */
    while(spi_i2s_flag_get(SPI3, SPI_I2S_TDBE_FLAG) == RESET);
    spi_i2s_data_transmit(SPI3, i2s3_buffer_tx[tx_index++]);
    
    /* i2s receive data get */
    while(spi_i2s_flag_get(SPI2, SPI_I2S_RDBF_FLAG) == RESET);
    i2s2_buffer_rx[rx_index++] = spi_i2s_data_receive(SPI2);
  }
  
  /* 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);

  /* test result:the data check */
  transfer_status1 = buffer_compare(i2s2_buffer_rx, i2s3_buffer_tx, 32);

  /* receive buffer clear */
  tx_index = 0;
  rx_index = 0;
  for(index = 0; index < 32; index++)
  {
    i2s2_buffer_rx[index] = 0;
  }
  
  /* second: spi communication */
  gpio_config(0);
  spi_config();
  
  /* start communication: master pull down CS pin select slave */
  SPI_MASTER_CS_LOW;
  
  while(rx_index < 32)
  {
    /* spi transmit data fill */
    while(spi_i2s_flag_get(SPI3, SPI_I2S_TDBE_FLAG) == RESET);
    spi_i2s_data_transmit(SPI3, spi3_buffer_tx[tx_index++]);
    
    /* spi receive data get */
    while(spi_i2s_flag_get(SPI2, SPI_I2S_RDBF_FLAG) == RESET);
    spi2_buffer_rx[rx_index++] = spi_i2s_data_receive(SPI2);
  }
  
  /* 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_status2 = buffer_compare(spi2_buffer_rx, spi3_buffer_tx, 32);

  /* receive buffer clear */
  tx_index = 0;
  rx_index = 0;
  for(index = 0; index < 32; index++)
  {
    i2s2_buffer_rx[index] = 0;
  }
  
  /* third: i2s communication */
  gpio_config(1);
  i2s_config(I2S_MODE_SLAVE_TX, I2S_MODE_MASTER_RX);
  
  /* when slave transmission mode,the slave trans data need fill in advance */
  while(spi_i2s_flag_get(SPI3, SPI_I2S_TDBE_FLAG) == RESET);
  spi_i2s_data_transmit(SPI3, i2s3_buffer_tx[tx_index++]);
  
  i2s_enable(SPI3, TRUE);
  i2s_enable(SPI2, TRUE);
  while(rx_index < 32)
  {
    /* i2s receive data get */
    while(spi_i2s_flag_get(SPI2, SPI_I2S_RDBF_FLAG) == RESET);
    i2s2_buffer_rx[rx_index++] = spi_i2s_data_receive(SPI2);
    
    /* i2s transmit data fill */
    while(spi_i2s_flag_get(SPI3, SPI_I2S_TDBE_FLAG) == RESET);
    spi_i2s_data_transmit(SPI3, i2s3_buffer_tx[tx_index++]);
  }
  
  /* master half duplex receiving mode,the busy flag isnot usefull */

  /* test result:the data check */
  transfer_status3 = buffer_compare(i2s2_buffer_rx, i2s3_buffer_tx, 32);

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

代码讲解

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

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

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

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

AT32 I2S — 半双工 DMA

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

I2S — 半双工 DMA

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

功能简介

本示例演示 I2S 音频总线通信。I2S 是数字音频传输标准，常用于连接 DAC/ADC 音频芯片、MEMS 麦克风等。

完整代码

#include "at32f403a_407_board.h"
#include "at32f403a_407_clock.h"
#include <stdio.h>

static void dma_config(void)
{
  dma_init_type dma_init_struct;

  crm_periph_clock_enable(CRM_DMA1_PERIPH_CLOCK, TRUE);
  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 = 32;
  dma_init_struct.direction = DMA_DIR_MEMORY_TO_PERIPHERAL;
  dma_init_struct.memory_base_addr = (uint32_t)i2s3_buffer_tx;
  dma_init_struct.memory_data_width = DMA_MEMORY_DATA_WIDTH_HALFWORD;
  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_HALFWORD;
  dma_init_struct.peripheral_inc_enable = FALSE;
  dma_init_struct.priority = DMA_PRIORITY_HIGH;
  dma_init_struct.loop_mode_enable = FALSE;
  dma_init(DMA2_CHANNEL2, &dma_init_struct);
  
  /* use dma1_channel4 as spi2 receive channel */
  dma_reset(DMA1_CHANNEL4);
  dma_init_struct.buffer_size = 32;
  dma_init_struct.direction = DMA_DIR_PERIPHERAL_TO_MEMORY;
  dma_init_struct.memory_base_addr = (uint32_t)i2s2_buffer_rx;
  dma_init_struct.memory_data_width = DMA_MEMORY_DATA_WIDTH_HALFWORD;
  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_HALFWORD;
  dma_init_struct.peripheral_inc_enable = FALSE;
  dma_init_struct.priority = DMA_PRIORITY_HIGH;
  dma_init_struct.loop_mode_enable = FALSE;
  dma_init(DMA1_CHANNEL4, &dma_init_struct);
}

static void i2s_config(void)
{
  i2s_init_type i2s_init_struct;
  
  /* master i2s initialization */
  crm_periph_clock_enable(CRM_SPI3_PERIPH_CLOCK, TRUE);
  i2s_default_para_init(&i2s_init_struct);
  
  /* master transmission mode */
  i2s_init_struct.audio_protocol = I2S_AUDIO_PROTOCOL_PHILLIPS;
  i2s_init_struct.data_channel_format = I2S_DATA_16BIT_CHANNEL_32BIT;
  i2s_init_struct.mclk_output_enable = TRUE;
  i2s_init_struct.audio_sampling_freq = I2S_AUDIO_FREQUENCY_48K;
  i2s_init_struct.clock_polarity = I2S_CLOCK_POLARITY_LOW;
  i2s_init_struct.operation_mode = I2S_MODE_MASTER_TX;
  i2s_init(SPI3, &i2s_init_struct);
  
  /* use dma transmit */
  spi_i2s_dma_transmitter_enable(SPI3, TRUE);
  
  i2s_enable(SPI3, TRUE);
  
  /* slave i2s initialization */
  crm_periph_clock_enable(CRM_SPI2_PERIPH_CLOCK, TRUE);
  
  /* slave reception mode */
  i2s_init_struct.audio_protocol = I2S_AUDIO_PROTOCOL_PHILLIPS;
  i2s_init_struct.data_channel_format = I2S_DATA_16BIT_CHANNEL_32BIT;
  i2s_init_struct.mclk_output_enable = TRUE;
  i2s_init_struct.audio_sampling_freq = I2S_AUDIO_FREQUENCY_48K;
  i2s_init_struct.clock_polarity = I2S_CLOCK_POLARITY_LOW;
  i2s_init_struct.operation_mode = I2S_MODE_SLAVE_RX;
  i2s_init(SPI2, &i2s_init_struct);

  /* use dma receive */
  spi_i2s_dma_receiver_enable(SPI2, TRUE);
  
  i2s_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_GPIOC_PERIPH_CLOCK, TRUE);
  crm_periph_clock_enable(CRM_IOMUX_PERIPH_CLOCK, TRUE);
  gpio_pin_remap_config(SWJTAG_GMUX_010, TRUE);

  /* master i2s ws 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_15;
  gpio_init(GPIOA, &gpio_initstructure);

  /* master i2s ck 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 i2s sd 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);

  /* master i2s mck pin */
  gpio_initstructure.gpio_pull = GPIO_PULL_UP;
  gpio_initstructure.gpio_mode = GPIO_MODE_MUX;
  gpio_initstructure.gpio_pins = GPIO_PINS_7;
  gpio_init(GPIOC, &gpio_initstructure);

  /* slave i2s ws 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 i2s ck 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 i2s sd 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();
  dma_config();
  i2s_config();
  
  /* enable i2s slave dma to get data */
  dma_channel_enable(DMA1_CHANNEL4, TRUE);
  
  /* enable i2s master dma to fill data */
  dma_channel_enable(DMA2_CHANNEL2, TRUE);

  /* wait slave i2s data receive 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);

  /* test result:the data check */
  transfer_status = buffer_compare(i2s2_buffer_rx, i2s3_buffer_tx, 32);

  /* test result indicate:if passed ,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 必须一致。

AT32 I2S — 半双工中断

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

I2S — 半双工中断

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

功能简介

本示例演示 I2S 音频总线通信。I2S 是数字音频传输标准，常用于连接 DAC/ADC 音频芯片、MEMS 麦克风等。

完整代码

#include "at32f403a_407_board.h"
#include "at32f403a_407_clock.h"
#include <stdio.h>

static void i2s_config(i2s_data_channel_format_type format, i2s_audio_sampling_freq_type freq)
{
  i2s_init_type i2s_init_struct;
  
  /* master i2s initialization */
  crm_periph_clock_enable(CRM_SPI3_PERIPH_CLOCK, TRUE);
  nvic_irq_enable(SPI3_I2S3EXT_IRQn, 0, 0);
  spi_i2s_reset(SPI3);
  i2s_default_para_init(&i2s_init_struct);
  
  /* master transmission mode */
  i2s_init_struct.audio_protocol = I2S_AUDIO_PROTOCOL_PHILLIPS;
  i2s_init_struct.data_channel_format = format;
  i2s_init_struct.mclk_output_enable = TRUE;
  i2s_init_struct.audio_sampling_freq = freq;
  i2s_init_struct.clock_polarity = I2S_CLOCK_POLARITY_LOW;
  i2s_init_struct.operation_mode = I2S_MODE_MASTER_TX;
  i2s_init(SPI3, &i2s_init_struct);
  
  /* enable transmit data buffer empty interrupt */
  spi_i2s_interrupt_enable(SPI3, SPI_I2S_TDBE_INT, TRUE);
  
  /* slave i2s initialization */
  crm_periph_clock_enable(CRM_SPI2_PERIPH_CLOCK, TRUE);
  nvic_irq_enable(SPI2_I2S2EXT_IRQn, 0, 0);
  spi_i2s_reset(SPI2);
  
  /* slave reception mode */
  i2s_init_struct.audio_protocol = I2S_AUDIO_PROTOCOL_PHILLIPS;
  i2s_init_struct.data_channel_format = format;
  i2s_init_struct.mclk_output_enable = TRUE;
  i2s_init_struct.audio_sampling_freq = freq;
  i2s_init_struct.clock_polarity = I2S_CLOCK_POLARITY_LOW;
  i2s_init_struct.operation_mode =I2S_MODE_SLAVE_RX;
  i2s_init(SPI2, &i2s_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);
  crm_periph_clock_enable(CRM_GPIOC_PERIPH_CLOCK, TRUE);
  crm_periph_clock_enable(CRM_IOMUX_PERIPH_CLOCK, TRUE);
  gpio_pin_remap_config(SWJTAG_GMUX_010, TRUE);

  /* master i2s ws 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_15;
  gpio_init(GPIOA, &gpio_initstructure);

  /* master i2s ck 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 i2s sd 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);

  /* master i2s mck pin */
  gpio_initstructure.gpio_pull = GPIO_PULL_UP;
  gpio_initstructure.gpio_mode = GPIO_MODE_MUX;
  gpio_initstructure.gpio_pins = GPIO_PINS_7;
  gpio_init(GPIOC, &gpio_initstructure);

  /* slave i2s ws 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 i2s ck 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 i2s sd 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;
  nvic_priority_group_config(NVIC_PRIORITY_GROUP_4);
  system_clock_config();
  at32_board_init();
  at32_led_on(LED4);
  gpio_config();
  i2s_config(I2S_DATA_16BIT_CHANNEL_32BIT, I2S_AUDIO_FREQUENCY_48K);
  
  /* enable slave and master i2s to start communication */
  i2s_enable(SPI2, TRUE);
  i2s_enable(SPI3, TRUE);
  
  /* wait data receive end */
  while(rx_index < 32);
  
  /* 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);

  /* test result:the data check */
  transfer_status1 = buffer_compare(i2s2_buffer_rx, i2s3_buffer_tx, 32);

  /* receive buffer clear */
  tx_index = 0;
  rx_index = 0;
  for(index = 0; index < 32; index++)
  {
    i2s2_buffer_rx[index] = 0;
  }
  
  /* change frame format */
  i2s_config(I2S_DATA_24BIT_CHANNEL_32BIT, I2S_AUDIO_FREQUENCY_16K);
  
  /* enable slave and master i2s to start communication */
  i2s_enable(SPI2, TRUE);
  i2s_enable(SPI3, TRUE);
  
  /* wait data receive end */
  while(rx_index < 32);
  
  /* 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);

  /* test result:the data check */
  transfer_status2 = buffer_compare_24bits(i2s2_buffer_rx, i2s3_buffer_tx, 32);

  /* 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 设置中断的抢占优先级和子优先级。数字越小优先级越高。

AT32 I2S — 全双工 DMA

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

I2S — 全双工 DMA

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

功能简介

本示例演示 I2S 音频总线通信。I2S 是数字音频传输标准，常用于连接 DAC/ADC 音频芯片、MEMS 麦克风等。

完整代码

#include "at32f403a_407_board.h"
#include "at32f403a_407_clock.h"
#include <stdio.h>
#define TXBUF_SIZE                       32
#define RXBUF_SIZE                       TXBUF_SIZE

static void dma_config(void)
{
  dma_init_type dma_init_struct;

  crm_periph_clock_enable(CRM_DMA1_PERIPH_CLOCK, TRUE);
  
  /* use dma1_channel1 as spi2 transmit channel */
  dma_reset(DMA1_CHANNEL1);
  dma_default_para_init(&dma_init_struct);
  dma_init_struct.buffer_size = TXBUF_SIZE;
  dma_init_struct.memory_data_width = DMA_MEMORY_DATA_WIDTH_HALFWORD;
  dma_init_struct.memory_inc_enable = TRUE;
  dma_init_struct.peripheral_data_width = DMA_PERIPHERAL_DATA_WIDTH_HALFWORD;
  dma_init_struct.peripheral_inc_enable = FALSE;
  dma_init_struct.priority = DMA_PRIORITY_HIGH;
  dma_init_struct.loop_mode_enable = FALSE;
  dma_init_struct.memory_base_addr = (uint32_t)i2s2_buffer_tx;
  dma_init_struct.peripheral_base_addr = (uint32_t)&(SPI2->dt);
  dma_init_struct.direction = DMA_DIR_MEMORY_TO_PERIPHERAL;
  dma_init(DMA1_CHANNEL1, &dma_init_struct);
  dma_flexible_config(DMA1, FLEX_CHANNEL1, DMA_FLEXIBLE_SPI2_TX);
  
  /* use dma1_channel2 as spi2 receive channel */
  dma_reset(DMA1_CHANNEL2);
  dma_init_struct.buffer_size = RXBUF_SIZE;
  dma_init_struct.memory_data_width = DMA_MEMORY_DATA_WIDTH_HALFWORD;
  dma_init_struct.memory_inc_enable = TRUE;
  dma_init_struct.peripheral_data_width = DMA_PERIPHERAL_DATA_WIDTH_HALFWORD;
  dma_init_struct.peripheral_inc_enable = FALSE;
  dma_init_struct.priority = DMA_PRIORITY_HIGH;
  dma_init_struct.loop_mode_enable = FALSE;
  dma_init_struct.memory_base_addr = (uint32_t)i2s2_buffer_rx;
  dma_init_struct.peripheral_base_addr = (uint32_t)&(I2S2EXT->dt);
  dma_init_struct.direction = DMA_DIR_PERIPHERAL_TO_MEMORY;
  dma_init(DMA1_CHANNEL2, &dma_init_struct);
  dma_flexible_config(DMA1, FLEX_CHANNEL2, DMA_FLEXIBLE_I2S2EXT_RX);
  
  /* use dma1_channel3 as spi3 receive channel */
  dma_reset(DMA1_CHANNEL3);
  dma_init_struct.buffer_size = RXBUF_SIZE;
  dma_init_struct.memory_data_width = DMA_MEMORY_DATA_WIDTH_HALFWORD;
  dma_init_struct.memory_inc_enable = TRUE;
  dma_init_struct.peripheral_data_width = DMA_PERIPHERAL_DATA_WIDTH_HALFWORD;
  dma_init_struct.peripheral_inc_enable = FALSE;
  dma_init_struct.priority = DMA_PRIORITY_HIGH;
  dma_init_struct.loop_mode_enable = FALSE;
  dma_init_struct.memory_base_addr = (uint32_t)i2s3_buffer_rx;
  dma_init_struct.peripheral_base_addr = (uint32_t)&(SPI3->dt);
  dma_init_struct.direction = DMA_DIR_PERIPHERAL_TO_MEMORY;
  dma_init(DMA1_CHANNEL3, &dma_init_struct);
  dma_flexible_config(DMA1, FLEX_CHANNEL3, DMA_FLEXIBLE_SPI3_RX);
  
  /* use dma1_channel4 as spi3 transmit channel */
  dma_reset(DMA1_CHANNEL4);
  dma_init_struct.buffer_size = TXBUF_SIZE;
  dma_init_struct.memory_data_width = DMA_MEMORY_DATA_WIDTH_HALFWORD;
  dma_init_struct.memory_inc_enable = TRUE;
  dma_init_struct.peripheral_data_width = DMA_PERIPHERAL_DATA_WIDTH_HALFWORD;
  dma_init_struct.peripheral_inc_enable = FALSE;
  dma_init_struct.priority = DMA_PRIORITY_HIGH;
  dma_init_struct.loop_mode_enable = FALSE;
  dma_init_struct.memory_base_addr = (uint32_t)i2s3_buffer_tx;
  dma_init_struct.peripheral_base_addr = (uint32_t)&(I2S3EXT->dt);
  dma_init_struct.direction = DMA_DIR_MEMORY_TO_PERIPHERAL;
  dma_init(DMA1_CHANNEL4, &dma_init_struct);
  dma_flexible_config(DMA1, FLEX_CHANNEL4, DMA_FLEXIBLE_I2S3EXT_TX);
}

static void i2s_config(void)
{
  i2s_init_type i2s_init_struct;
  
  /* master i2s initialization */
  crm_periph_clock_enable(CRM_SPI2_PERIPH_CLOCK, TRUE);
  i2s_default_para_init(&i2s_init_struct);
  
  /* i2s2 as master transmission */
  i2s_init_struct.audio_protocol = I2S_AUDIO_PROTOCOL_PHILLIPS;
  i2s_init_struct.data_channel_format = I2S_DATA_16BIT_CHANNEL_32BIT;
  i2s_init_struct.mclk_output_enable = TRUE;
  i2s_init_struct.audio_sampling_freq = I2S_AUDIO_FREQUENCY_48K;
  i2s_init_struct.clock_polarity = I2S_CLOCK_POLARITY_LOW;
  i2s_init_struct.operation_mode = I2S_MODE_MASTER_TX;
  i2s_init(SPI2, &i2s_init_struct);
  
  /* i2s2ext as slave reception */
  i2s_init_struct.operation_mode =I2S_MODE_SLAVE_RX;
  i2s_init(I2S2EXT, &i2s_init_struct);
  
  /* use dma transmit and receive */
  spi_i2s_dma_transmitter_enable(SPI2, TRUE);
  spi_i2s_dma_receiver_enable(I2S2EXT, TRUE);
  
  i2s_enable(SPI2, TRUE);
  i2s_enable(I2S2EXT, TRUE);
  
  /* slave i2s initialization */
  crm_periph_clock_enable(CRM_SPI3_PERIPH_CLOCK, TRUE);
  
  /* i2s3 as slave reception */
  i2s_init_struct.audio_protocol = I2S_AUDIO_PROTOCOL_PHILLIPS;
  i2s_init_struct.data_channel_format = I2S_DATA_16BIT_CHANNEL_32BIT;
  i2s_init_struct.mclk_output_enable = TRUE;
  i2s_init_struct.audio_sampling_freq = I2S_AUDIO_FREQUENCY_48K;
  i2s_init_struct.clock_polarity = I2S_CLOCK_POLARITY_LOW;
  i2s_init_struct.operation_mode = I2S_MODE_SLAVE_RX;
  i2s_init(SPI3, &i2s_init_struct);
  
  /* i2s3ext as slave transmission */
  i2s_init_struct.operation_mode =I2S_MODE_SLAVE_TX;
  i2s_init(I2S3EXT, &i2s_init_struct);
  
  /* use dma transmit and receive */
  spi_i2s_dma_receiver_enable(SPI3, TRUE);
  spi_i2s_dma_transmitter_enable(I2S3EXT, TRUE);
  
  i2s_enable(SPI3, TRUE);
  i2s_enable(I2S3EXT, 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_GPIOC_PERIPH_CLOCK, TRUE);
  crm_periph_clock_enable(CRM_IOMUX_PERIPH_CLOCK, TRUE);
  gpio_pin_remap_config(SPI3_GMUX_0001, TRUE);

  /* master i2s ws 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_12;
  gpio_init(GPIOB, &gpio_initstructure);

  /* master i2s ck pin */
  gpio_initstructure.gpio_pull = GPIO_PULL_DOWN;
  gpio_initstructure.gpio_mode = GPIO_MODE_MUX;
  gpio_initstructure.gpio_pins = GPIO_PINS_13;
  gpio_init(GPIOB, &gpio_initstructure);

    /* master i2s sdext pin */
  gpio_initstructure.gpio_pull = GPIO_PULL_UP;
  gpio_initstructure.gpio_mode = GPIO_MODE_INPUT;
  gpio_initstructure.gpio_pins = GPIO_PINS_14;
  gpio_init(GPIOB, &gpio_initstructure);

  /* master i2s sd pin */
  gpio_initstructure.gpio_pull = GPIO_PULL_UP;
  gpio_initstructure.gpio_mode = GPIO_MODE_MUX;
  gpio_initstructure.gpio_pins = GPIO_PINS_15;
  gpio_init(GPIOB, &gpio_initstructure);

  /* slave i2s ws 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_4;
  gpio_init(GPIOA, &gpio_initstructure);

  /* slave i2s ck pin */
  gpio_initstructure.gpio_pull = GPIO_PULL_DOWN;
  gpio_initstructure.gpio_mode = GPIO_MODE_INPUT;
  gpio_initstructure.gpio_pins = GPIO_PINS_10;
  gpio_init(GPIOC, &gpio_initstructure);

  /* slave i2s sdext pin */
  gpio_initstructure.gpio_pull = GPIO_PULL_UP;
  gpio_initstructure.gpio_mode = GPIO_MODE_MUX;
  gpio_initstructure.gpio_pins = GPIO_PINS_11;
  gpio_init(GPIOC, &gpio_initstructure);

  /* slave i2s sd pin */
  gpio_initstructure.gpio_pull = GPIO_PULL_UP;
  gpio_initstructure.gpio_mode = GPIO_MODE_INPUT;
  gpio_initstructure.gpio_pins = GPIO_PINS_12;
  gpio_init(GPIOC, &gpio_initstructure);
}

int main(void)
{
  system_clock_config();
  at32_board_init();
  at32_led_on(LED4);
  tx_data_fill();
  gpio_config();
  dma_config();
  i2s_config();
  
  /* enable i2s slave dma to get and fill data */
  dma_channel_enable(DMA1_CHANNEL3, TRUE);
  dma_channel_enable(DMA1_CHANNEL4, TRUE);
  
  /* enable i2s master dma to get and fill data */
  dma_channel_enable(DMA1_CHANNEL2, TRUE);
  dma_channel_enable(DMA1_CHANNEL1, TRUE);
  
  /* wait master and slave spi data receive end */
  while(dma_flag_get(DMA1_FDT2_FLAG) == RESET)
  {
  }
  while(dma_flag_get(DMA1_FDT3_FLAG) == RESET)
  {
  }
  
  /* wait master and slave idle when communication end */
  while(spi_i2s_flag_get(SPI2, SPI_I2S_BF_FLAG) != RESET);
  while(spi_i2s_flag_get(SPI3, SPI_I2S_BF_FLAG) != RESET);

  /* test result:the data check */
  transfer_status1 = buffer_compare(i2s2_buffer_rx, i2s3_buffer_tx, TXBUF_SIZE);
  transfer_status2 = buffer_compare(i2s3_buffer_rx, i2s2_buffer_tx, TXBUF_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 配置：设置引脚为输出/输入模式，选择推挽/开漏输出，配置上拉/下拉。

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

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

PUYA — I2S 音频总线

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

PUYA — I2S 音频总线

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

什么是 I2S 音频总线?

I2S 是数字音频传输标准，用于连接音频 DAC/ADC、MEMS 麦克风等音频设备。

示例列表

I2S_TwoBoard_CommunicationMaster_DMA — I2S_TwoBoard_CommunicationMaster_DMA
I2S_TwoBoard_CommunicationMaster_IT — I2S_TwoBoard_CommunicationMaster_IT
I2S_TwoBoard_CommunicationMaster_Polling — I2S_TwoBoard_CommunicationMaster_Polling
I2S_TwoBoard_CommunicationSlave_DMA — I2S_TwoBoard_CommunicationSlave_DMA
I2S_TwoBoard_CommunicationSlave_IT — I2S_TwoBoard_CommunicationSlave_IT
I2S_TwoBoard_CommunicationSlave_Polling — I2S_TwoBoard_CommunicationSlave_Polling

重点推荐：I2S 主机轮询收发（双板）已整理为完整教学文档，讲解标准格式、采样率与 SPI2 复用。

PUYA I2S — I2S_TwoBoard_CommunicationMaster_DMA

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

I2S — I2S_TwoBoard_CommunicationMaster_DMA

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

功能简介

本示例演示 I2S 音频总线通信。I2S 是数字音频传输标准，常用于连接 DAC/ADC 音频芯片、MEMS 麦克风等。

完整代码

`1`	`#include "main.h"`

代码讲解

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

PUYA I2S — I2S_TwoBoard_CommunicationMaster_IT

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

I2S — I2S_TwoBoard_CommunicationMaster_IT

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

功能简介

本示例演示 I2S 音频总线通信。I2S 是数字音频传输标准，常用于连接 DAC/ADC 音频芯片、MEMS 麦克风等。

完整代码

`1`	`#include "main.h"`

代码讲解

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

PUYA I2S — I2S_TwoBoard_CommunicationSlave_DMA

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

I2S — I2S_TwoBoard_CommunicationSlave_DMA

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

功能简介

本示例演示 I2S 音频总线通信。I2S 是数字音频传输标准，常用于连接 DAC/ADC 音频芯片、MEMS 麦克风等。

完整代码

`1`	`#include "main.h"`

代码讲解

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

PUYA I2S — I2S_TwoBoard_CommunicationSlave_IT

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

I2S — I2S_TwoBoard_CommunicationSlave_IT

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

功能简介

本示例演示 I2S 音频总线通信。I2S 是数字音频传输标准，常用于连接 DAC/ADC 音频芯片、MEMS 麦克风等。

完整代码

`1`	`#include "main.h"`

代码讲解

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

PUYA I2S — I2S_TwoBoard_CommunicationSlave_Polling

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

I2S — I2S_TwoBoard_CommunicationSlave_Polling

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

功能简介

本示例演示 I2S 音频总线通信。I2S 是数字音频传输标准，常用于连接 DAC/ADC 音频芯片、MEMS 麦克风等。

完整代码

`1`	`#include "main.h"`

代码讲解

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