I2C on CLing

PUYA I2C — 主机轮询通信（HAL 库）

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

I2C — 主机轮询通信（HAL 库）

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

功能简介

I2C（Inter-Integrated Circuit）是一种两线制（SCL 时钟 + SDA 数据）、半双工、一主多从的串行总线，常用于连接 EEPROM、传感器、OLED 屏等。

本示例演示主机（Master）工作方式：

主机先向从机地址 0xA0 发送 15 字节；
再向同一地址接收 15 字节（示例用两块板回环对接，从机把收到的数据原样发回）；
CPU 用轮询方式等待每笔传输完成（HAL_I2C_Master_Transmit/Receive 内部即轮询）；
收发一致则点亮绿灯，不一致则闪烁报警。

虽然工程里函数名带 Master，实际传输由 HAL_I2C_Master_Transmit/Receive 完成，内部是轮询等待，符合“主机轮询通信”的教学目标。

硬件准备

两块 PY32F030 开发板（一主一从），或用一块板把 SDA/SCL 自连做回环
SCL、SDA 各接 4.7kΩ 上拉电阻到 VDD（I2C 开漏总线必须上拉）
交叉连接：主 SCL↔从 SCL，主 SDA↔从 SDA，共地
串口/LED 用于观察结果

完整代码（主机部分）

#include "main.h"

#define DATA_LENGTH      15                /* 数据长度 */
#define I2C_ADDRESS      0xA0              /* 从机地址（7 位地址左移后的写地址） */
#define I2C_SPEEDCLOCK   100000           /* 通信速率 100K */
#define I2C_DUTYCYCLE    I2C_DUTYCYCLE_16_9 /* 快速模式占空比 */

I2C_HandleTypeDef I2cHandle;
uint8_t aTxBuffer[15] = {1,2,3,4,5,6,7,8,9,10,11,12,13,14,15};
uint8_t aRxBuffer[15] = {0};

int main(void)
{
  HAL_Init();

  /* 初始化 LED 与按键 */
  BSP_LED_Init(LED_GREEN);
  BSP_PB_Init(BUTTON_KEY, BUTTON_MODE_GPIO);

  /* I2C 参数配置 */
  I2cHandle.Instance           = I2C;             /* PY32F0xx 的 I2C 外设名 */
  I2cHandle.Init.ClockSpeed    = I2C_SPEEDCLOCK;   /* 100K */
  I2cHandle.Init.DutyCycle     = I2C_DUTYCYCLE;    /* 快速模式占空比 */
  I2cHandle.Init.OwnAddress1   = I2C_ADDRESS;      /* 自身地址（主模式可不严格） */
  I2cHandle.Init.GeneralCallMode = I2C_GENERALCALL_DISABLE;
  I2cHandle.Init.NoStretchMode   = I2C_NOSTRETCH_DISABLE; /* 允许时钟拉伸 */
  if (HAL_I2C_Init(&I2cHandle) != HAL_OK)
  {
    APP_ErrorHandler();
  }

  /* 等待用户按键按下，再开始通信（避免一上电就发） */
  while (BSP_PB_GetState(BUTTON_KEY) == 1) {}

  /* 主机发送 15 字节，超时 5000ms */
  while (HAL_I2C_Master_Transmit(&I2cHandle, I2C_ADDRESS,
                                 (uint8_t *)aTxBuffer, DATA_LENGTH, 5000) != HAL_OK)
  {
    APP_ErrorHandler();
  }
  while (HAL_I2C_GetState(&I2cHandle) != HAL_I2C_STATE_READY); /* 等发送完成 */

  /* 主机接收 15 字节 */
  while (HAL_I2C_Master_Receive(&I2cHandle, I2C_ADDRESS,
                                (uint8_t *)aRxBuffer, DATA_LENGTH, 5000) != HAL_OK)
  {
    APP_ErrorHandler();
  }
  while (HAL_I2C_GetState(&I2cHandle) != HAL_I2C_STATE_READY);

  /* 校验收发数据 */
  APP_CheckEndOfTransfer();

  while (1) {}
}

/* 比较发送与接收缓冲；一致亮灯，否则闪烁 */
static void APP_CheckEndOfTransfer(void)
{
  if (APP_Buffercmp8((uint8_t*)aTxBuffer, (uint8_t*)aRxBuffer, DATA_LENGTH))
    APP_LedBlinking();
  else
    BSP_LED_On(LED_GREEN);
}

代码分段讲解

1. 地址说明

I2C_ADDRESS = 0xA0 是含读写位的 8 位地址（即 7 位地址 0x50 左移 1 位）。HAL 的 HAL_I2C_Master_Transmit/Receive 内部会自动根据读/写把最低位置 0/1，调用时直接传 0xA0 即可（底层会有兼容处理）。实际对接外部芯片时，请以其数据手册给出的 7 位地址为准。

2. 速率与占空比

ClockSpeed = 100000：标准模式 100kbps；可改 400000 进入快速模式。
快速模式下 DutyCycle 控制 SCL 高低电平比（16_9 或 2）。

3. 轮询方式

HAL_I2C_Master_Transmit(..., Timeout) 内部不断查询状态寄存器直到完成或超时，期间 CPU 被占用，简单但效率低。对性能敏感的场景可改用 IT（中断）或 DMA 版本（同目录有 I2C_TwoBoard_CommunicationMaster_IT / _DMA）。

4. 时钟拉伸

NoStretchMode = DISABLE 表示允许从机在忙时拉低 SCL（时钟拉伸），这是 I2C 规范允许的流控机制，绝大多数从机需要。

实验现象

按下用户键后，主机发送 1~15；
若从机把数据原样返回，主机收到一致数据，绿灯常亮；
若数据不一致或总线异常，绿灯以 500ms 周期闪烁报警。

常见问题

总线卡死 / 收不到数据？
- SCL、SDA 必须有上拉电阻（4.7kΩ 到 VDD），开漏总线无上拉无法拉高。
- 检查接线：SCL↔SCL、SDA↔SDA、主从共地。
- 确认从机地址与数据手册一致（区分 7 位 / 8 位地址）。
HAL_I2C_Master_Transmit 返回 HAL_BUSY/HAL_TIMEOUT？
- 总线可能被某次异常拉低（SDA 卡在低）。可尝试复位或从机重新上电。
- 适当增大 Timeout（如 5000ms）。
写 EEPROM 后马上读不到？
- EEPROM 写周期约 5ms，需在写后延时再读。
如何只读单字节传感器（如温湿度）？
- 先 HAL_I2C_Master_Transmit 发寄存器地址，再 HAL_I2C_Master_Receive 读数据（即“写寄存器指针 + 读数据”组合）。

小结

I2C 主机轮询三步：初始化 HAL_I2C_Init → Master_Transmit 发 → Master_Receive 收。
总线必须上拉，地址要与从机匹配，主从共地。
轮询版代码最简单，适合初学；追求效率改用 IT/DMA 版。

拓展应用

驱动 OLED（SSD1306）、AT24Cxx EEPROM、各类 I2C 传感器（BMP280、SHT30）。
一主多从：用不同从机地址挂多个设备，轮流访问。
用 HAL_I2C_Mem_Write/Read 直接读写带寄存器的器件（如 I2C_MEMADD_SIZE_8BIT）。
把轮询升级为中断/DMA，释放 CPU。

AT32 — I2C 总线

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

AT32 — I2C 总线

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

什么是 I2C 总线?

I2C 只需两根线（SCL+SDA）就能连接多个设备。标准速率 100Kbps，快速模式 400Kbps。每个设备有唯一地址。

示例列表

DMA 通信 — communication_dma
中断通信 — communication_int
轮询通信 — communication_poll
EEPROM 读写 — eeprom
内存地址写入 — memory_write

AT32 I2C — DMA 通信

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

I2C — DMA 通信

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

功能简介

本示例演示 I2C + DMA 通信。大数据量传输时，DMA 可以大幅降低 CPU 负载。

硬件准备

I2C 从设备（如 EEPROM、传感器模块）
SCL/SDA 线上需要 4.7K 上拉电阻

完整代码

#include "at32f403a_407_board.h"
#include "at32f403a_407_clock.h"
#include "i2c_application.h"
#define I2C_TIMEOUT                      0xFFFFFFFF
#define I2Cx_SPEED                       100000
#define I2Cx_ADDRESS                     0xA0
#define I2Cx_PORT                        I2C1
#define I2Cx_CLK                         CRM_I2C1_PERIPH_CLOCK
#define I2Cx_SCL_PIN                     GPIO_PINS_6
#define I2Cx_SCL_GPIO_PORT               GPIOB
#define I2Cx_SCL_GPIO_CLK                CRM_GPIOB_PERIPH_CLOCK
#define I2Cx_SDA_PIN                     GPIO_PINS_7
#define I2Cx_SDA_GPIO_PORT               GPIOB
#define I2Cx_SDA_GPIO_CLK                CRM_GPIOB_PERIPH_CLOCK
#define I2Cx_DMA_CLK                     CRM_DMA1_PERIPH_CLOCK
#define I2Cx_DMA_TX_CHANNEL              DMA1_CHANNEL6
#define I2Cx_DMA_TX_IRQn                 DMA1_Channel6_IRQn
#define I2Cx_DMA_RX_CHANNEL              DMA1_CHANNEL7
#define I2Cx_DMA_RX_IRQn                 DMA1_Channel7_IRQn
#define I2Cx_EVT_IRQn                    I2C1_EVT_IRQn
#define I2Cx_ERR_IRQn                    I2C1_ERR_IRQn
#define BUF_SIZE                         8
#define MASTER_BOARD

void i2c_lowlevel_init(i2c_handle_type* hi2c)
{
  gpio_init_type gpio_initstructure;

  if(hi2c->i2cx == I2Cx_PORT)
  {
    /* i2c periph clock enable */
    crm_periph_clock_enable(I2Cx_CLK, TRUE);
    crm_periph_clock_enable(I2Cx_SCL_GPIO_CLK, TRUE);
    crm_periph_clock_enable(I2Cx_SDA_GPIO_CLK, TRUE);

    /* gpio configuration */
    gpio_initstructure.gpio_out_type       = GPIO_OUTPUT_OPEN_DRAIN;
    gpio_initstructure.gpio_pull           = GPIO_PULL_NONE;
    gpio_initstructure.gpio_mode           = GPIO_MODE_MUX;
    gpio_initstructure.gpio_drive_strength = GPIO_DRIVE_STRENGTH_MODERATE;

    /* configure i2c pins: scl */
    gpio_initstructure.gpio_pins = I2Cx_SCL_PIN;
    gpio_init(I2Cx_SCL_GPIO_PORT, &gpio_initstructure);

    /* configure i2c pins: sda */
    gpio_initstructure.gpio_pins = I2Cx_SDA_PIN;
    gpio_init(I2Cx_SDA_GPIO_PORT, &gpio_initstructure);

    /* configure and enable i2c dma channel interrupt */
    nvic_irq_enable(I2Cx_DMA_TX_IRQn, 0, 0);
    nvic_irq_enable(I2Cx_DMA_RX_IRQn, 0, 0);

    /* configure and enable i2c interrupt */
    nvic_irq_enable(I2Cx_EVT_IRQn, 0, 0);
    nvic_irq_enable(I2Cx_ERR_IRQn, 0, 0);

    /* i2c dma tx and rx channels configuration */
    /* enable the dma clock */
    crm_periph_clock_enable(I2Cx_DMA_CLK, TRUE);

    /* i2c dma channel configuration */
    hi2c->dma_tx_channel = I2Cx_DMA_TX_CHANNEL;
    hi2c->dma_rx_channel = I2Cx_DMA_RX_CHANNEL;

    dma_reset(hi2c->dma_tx_channel);
    dma_reset(hi2c->dma_rx_channel);

    dma_default_para_init(&hi2c->dma_init_struct);
    hi2c->dma_init_struct.peripheral_inc_enable    = FALSE;
    hi2c->dma_init_struct.memory_inc_enable        = TRUE;
    hi2c->dma_init_struct.peripheral_data_width    = DMA_PERIPHERAL_DATA_WIDTH_BYTE;
    hi2c->dma_init_struct.memory_data_width        = DMA_MEMORY_DATA_WIDTH_BYTE;
    hi2c->dma_init_struct.loop_mode_enable         = FALSE;
    hi2c->dma_init_struct.priority                 = DMA_PRIORITY_LOW;
    hi2c->dma_init_struct.direction                = DMA_DIR_MEMORY_TO_PERIPHERAL;

    dma_init(hi2c->dma_tx_channel, &hi2c->dma_init_struct);
    dma_init(hi2c->dma_rx_channel, &hi2c->dma_init_struct);

    i2c_init(hi2c->i2cx, I2C_FSMODE_DUTY_2_1, I2Cx_SPEED);

    i2c_own_address1_set(hi2c->i2cx, I2C_ADDRESS_MODE_7BIT, I2Cx_ADDRESS);
  }
}

int main(void)
{
  i2c_status_type i2c_status;

  /* config nvic priority group */
  nvic_priority_group_config(NVIC_PRIORITY_GROUP_4);

  system_clock_config();

  at32_board_init();

  hi2cx.i2cx = I2Cx_PORT;

  i2c_config(&hi2cx);

  while(1)
  {

#if defined (MASTER_BOARD)

    /* wait for key USER_BUTTON press before starting the communication */
    while(at32_button_press() != USER_BUTTON)
    {
    }

    /* start the request reception process */
    if((i2c_status = i2c_master_transmit_dma(&hi2cx, I2Cx_ADDRESS, tx_buf, BUF_SIZE, I2C_TIMEOUT)) != I2C_OK)
    {
      error_handler(i2c_status);
    }

    /* wait for the communication to end */
    if(i2c_wait_end(&hi2cx, I2C_TIMEOUT) != I2C_OK)
    {
      error_handler(i2c_status);
    }

    delay_ms(10);

    /* start the request reception process */
    if((i2c_status = i2c_master_receive_dma(&hi2cx, I2Cx_ADDRESS, rx_buf, BUF_SIZE, I2C_TIMEOUT)) != I2C_OK)
    {
      error_handler(i2c_status);
    }

    /* wait for the communication to end */
    if(i2c_wait_end(&hi2cx, I2C_TIMEOUT) != I2C_OK)
    {
      error_handler(i2c_status);
    }

    if(buffer_compare(tx_buf, rx_buf, BUF_SIZE) == 0)
    {
      at32_led_on(LED3);
    }
    else
    {
      error_handler(i2c_status);
    }

#else

    /* wait for key USER_BUTTON press before starting the communication */
    while(at32_button_press() != USER_BUTTON)
    {
    }

    /* start the transmission process */
    if((i2c_status = i2c_slave_receive_dma(&hi2cx, rx_buf, BUF_SIZE, I2C_TIMEOUT)) != I2C_OK)
    {
      error_handler(i2c_status);
    }

    /* wait for the communication to end */
    if(i2c_wait_end(&hi2cx, I2C_TIMEOUT) != I2C_OK)
    {
      error_handler(i2c_status);
    }

    if((i2c_status = i2c_slave_transmit_dma(&hi2cx, tx_buf, BUF_SIZE, I2C_TIMEOUT)) != I2C_OK)
    {
      error_handler(i2c_status);
    }

    /* wait for the communication to end */
    if(i2c_wait_end(&hi2cx, I2C_TIMEOUT) != I2C_OK)
    {
      error_handler(i2c_status);
    }

    if(buffer_compare(tx_buf, rx_buf, BUF_SIZE) == 0)
    {
      at32_led_on(LED3);
    }
    else
    {
      error_handler(i2c_status);
    }

#endif

  }
}

代码讲解

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

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

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

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

I2C 配置：设置通信速率（标准 100K / 快速 400K / 快速+ 1M）、从机地址、时钟拉伸。

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

延时：使用系统延时函数控制 LED 翻转间隔。

实验现象

主机和从机完成数据收发
校验通过 LED 指示成功

注意事项

I2C 总线需要上拉电阻（一般 4.7K）
从机地址要与设备手册一致（注意 7 位/8 位地址的区别）
写 EEPROM 后需要等待 5ms 以上再读

AT32 I2C — 轮询通信

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

I2C — 轮询通信

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

功能简介

本示例演示 I2C 轮询方式通信。CPU 等待每个字节传输完成，简单但效率较低。

硬件准备

I2C 从设备（如 EEPROM、传感器模块）
SCL/SDA 线上需要 4.7K 上拉电阻

完整代码

#include "at32f403a_407_board.h"
#include "at32f403a_407_clock.h"
#include "i2c_application.h"
#define I2C_TIMEOUT                      0xFFFFFFFF
#define I2Cx_SPEED                       100000
#define I2Cx_ADDRESS                     0xA0
#define I2Cx_PORT                        I2C1
#define I2Cx_CLK                         CRM_I2C1_PERIPH_CLOCK
#define I2Cx_SCL_PIN                     GPIO_PINS_6
#define I2Cx_SCL_GPIO_PORT               GPIOB
#define I2Cx_SCL_GPIO_CLK                CRM_GPIOB_PERIPH_CLOCK
#define I2Cx_SDA_PIN                     GPIO_PINS_7
#define I2Cx_SDA_GPIO_PORT               GPIOB
#define I2Cx_SDA_GPIO_CLK                CRM_GPIOB_PERIPH_CLOCK
#define BUF_SIZE                         8
#define MASTER_BOARD

void i2c_lowlevel_init(i2c_handle_type* hi2c)
{
  gpio_init_type gpio_initstructure;

  if(hi2c->i2cx == I2Cx_PORT)
  {
    /* i2c periph clock enable */
    crm_periph_clock_enable(I2Cx_CLK, TRUE);
    crm_periph_clock_enable(I2Cx_SCL_GPIO_CLK, TRUE);
    crm_periph_clock_enable(I2Cx_SDA_GPIO_CLK, TRUE);

    /* gpio configuration */
    gpio_initstructure.gpio_out_type       = GPIO_OUTPUT_OPEN_DRAIN;
    gpio_initstructure.gpio_pull           = GPIO_PULL_NONE;
    gpio_initstructure.gpio_mode           = GPIO_MODE_MUX;
    gpio_initstructure.gpio_drive_strength = GPIO_DRIVE_STRENGTH_MODERATE;

    /* configure i2c pins: scl */
    gpio_initstructure.gpio_pins = I2Cx_SCL_PIN;
    gpio_init(I2Cx_SCL_GPIO_PORT, &gpio_initstructure);

    /* configure i2c pins: sda */
    gpio_initstructure.gpio_pins = I2Cx_SDA_PIN;
    gpio_init(I2Cx_SDA_GPIO_PORT, &gpio_initstructure);

    i2c_init(hi2c->i2cx, I2C_FSMODE_DUTY_2_1, I2Cx_SPEED);

    i2c_own_address1_set(hi2c->i2cx, I2C_ADDRESS_MODE_7BIT, I2Cx_ADDRESS);
  }
}

int main(void)
{
  i2c_status_type i2c_status;

  system_clock_config();

  at32_board_init();

  hi2cx.i2cx = I2Cx_PORT;

  i2c_config(&hi2cx);

  while(1)
  {

#if defined (MASTER_BOARD)

    /* wait for key USER_BUTTON press before starting the communication */
    while(at32_button_press() != USER_BUTTON)
    {
    }

    /* start the request reception process */
    if((i2c_status = i2c_master_transmit(&hi2cx, I2Cx_ADDRESS, tx_buf, BUF_SIZE, I2C_TIMEOUT)) != I2C_OK)
    {
      error_handler(i2c_status);
    }

    delay_ms(10);

    /* start the request reception process */
    if((i2c_status = i2c_master_receive(&hi2cx, I2Cx_ADDRESS, rx_buf, BUF_SIZE, I2C_TIMEOUT)) != I2C_OK)
    {
      error_handler(i2c_status);
    }

    if(buffer_compare(tx_buf, rx_buf, BUF_SIZE) == 0)
    {
      at32_led_on(LED3);
    }
    else
    {
      error_handler(i2c_status);
    }
#else

    /* wait for key USER_BUTTON press before starting the communication */
    while(at32_button_press() != USER_BUTTON)
    {
    }

    /* start the transmission process */
    if((i2c_status = i2c_slave_receive(&hi2cx, rx_buf, BUF_SIZE, I2C_TIMEOUT)) != I2C_OK)
    {
      error_handler(i2c_status);
    }

    if((i2c_status = i2c_slave_transmit(&hi2cx, tx_buf, BUF_SIZE, I2C_TIMEOUT)) != I2C_OK)
    {
      error_handler(i2c_status);
    }

    if(buffer_compare(tx_buf, rx_buf, BUF_SIZE) == 0)
    {
      at32_led_on(LED3);
    }
    else
    {
      error_handler(i2c_status);
    }
#endif

  }
}

代码讲解

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

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

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

I2C 配置：设置通信速率（标准 100K / 快速 400K / 快速+ 1M）、从机地址、时钟拉伸。

延时：使用系统延时函数控制 LED 翻转间隔。

实验现象

主机和从机完成数据收发
校验通过 LED 指示成功

注意事项

I2C 总线需要上拉电阻（一般 4.7K）
从机地址要与设备手册一致（注意 7 位/8 位地址的区别）
写 EEPROM 后需要等待 5ms 以上再读

AT32 I2C — 内存地址写入

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

I2C — 内存地址写入

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

功能简介

本示例演示 I2C 总线通信。I2C 只需两根线（SCL+SDA）就能连接多个设备，是最常用的低速通信总线。

硬件准备

I2C 从设备（如 EEPROM、传感器模块）
SCL/SDA 线上需要 4.7K 上拉电阻

完整代码

#include "at32f403a_407_board.h"
#include "at32f403a_407_clock.h"
#include "i2c_application.h"
#define I2C_TIMEOUT                      0xFFFFFFFF
#define I2Cx_SPEED                       100000
#define I2Cx_ADDRESS                     0xA0
#define I2Cx_PORT                        I2C2
#define I2Cx_CLK                         CRM_I2C2_PERIPH_CLOCK
#define I2Cx_SCL_PIN                     GPIO_PINS_10
#define I2Cx_SCL_GPIO_PORT               GPIOB
#define I2Cx_SCL_GPIO_CLK                CRM_GPIOB_PERIPH_CLOCK
#define I2Cx_SDA_PIN                     GPIO_PINS_11
#define I2Cx_SDA_GPIO_PORT               GPIOB
#define I2Cx_SDA_GPIO_CLK                CRM_GPIOB_PERIPH_CLOCK
#define I2Cx_DMA_CLK                     CRM_DMA1_PERIPH_CLOCK
#define I2Cx_DMA_TX_CHANNEL              DMA1_CHANNEL4
#define I2Cx_DMA_TX_IRQn                 DMA1_Channel4_IRQn
#define I2Cx_DMA_RX_CHANNEL              DMA1_CHANNEL5
#define I2Cx_DMA_RX_IRQn                 DMA1_Channel5_IRQn
#define I2Cx_EVT_IRQn                    I2C2_EVT_IRQn
#define I2Cx_ERR_IRQn                    I2C2_ERR_IRQn
#define BUF_SIZE                         8

void i2c_lowlevel_init(i2c_handle_type* hi2c)
{
  gpio_init_type gpio_initstructure;

  if(hi2c->i2cx == I2Cx_PORT)
  {
    /* i2c periph clock enable */
    crm_periph_clock_enable(I2Cx_CLK, TRUE);
    crm_periph_clock_enable(I2Cx_SCL_GPIO_CLK, TRUE);
    crm_periph_clock_enable(I2Cx_SDA_GPIO_CLK, TRUE);

    /* gpio configuration */
    gpio_initstructure.gpio_out_type       = GPIO_OUTPUT_OPEN_DRAIN;
    gpio_initstructure.gpio_pull           = GPIO_PULL_NONE;
    gpio_initstructure.gpio_mode           = GPIO_MODE_MUX;
    gpio_initstructure.gpio_drive_strength = GPIO_DRIVE_STRENGTH_MODERATE;

    /* configure i2c pins: scl */
    gpio_initstructure.gpio_pins = I2Cx_SCL_PIN;
    gpio_init(I2Cx_SCL_GPIO_PORT, &gpio_initstructure);

    /* configure i2c pins: sda */
    gpio_initstructure.gpio_pins = I2Cx_SDA_PIN;
    gpio_init(I2Cx_SDA_GPIO_PORT, &gpio_initstructure);

    /* configure and enable i2c dma channel interrupt */
    nvic_irq_enable(I2Cx_DMA_TX_IRQn, 0, 0);
    nvic_irq_enable(I2Cx_DMA_RX_IRQn, 0, 0);

    /* configure and enable i2c interrupt */
    nvic_irq_enable(I2Cx_EVT_IRQn, 0, 0);
    nvic_irq_enable(I2Cx_ERR_IRQn, 0, 0);

    /* i2c dma tx and rx channels configuration */
    /* enable the dma clock */
    crm_periph_clock_enable(I2Cx_DMA_CLK, TRUE);

    /* i2c dma channel configuration */
    hi2c->dma_tx_channel = I2Cx_DMA_TX_CHANNEL;
    hi2c->dma_rx_channel = I2Cx_DMA_RX_CHANNEL;

    dma_reset(hi2c->dma_tx_channel);
    dma_reset(hi2c->dma_rx_channel);

    dma_default_para_init(&hi2c->dma_init_struct);
    hi2c->dma_init_struct.peripheral_inc_enable    = FALSE;
    hi2c->dma_init_struct.memory_inc_enable        = TRUE;
    hi2c->dma_init_struct.peripheral_data_width    = DMA_PERIPHERAL_DATA_WIDTH_BYTE;
    hi2c->dma_init_struct.memory_data_width        = DMA_MEMORY_DATA_WIDTH_BYTE;
    hi2c->dma_init_struct.loop_mode_enable         = FALSE;
    hi2c->dma_init_struct.priority                 = DMA_PRIORITY_LOW;
    hi2c->dma_init_struct.direction                = DMA_DIR_MEMORY_TO_PERIPHERAL;

    dma_init(hi2c->dma_tx_channel, &hi2c->dma_init_struct);
    dma_init(hi2c->dma_rx_channel, &hi2c->dma_init_struct);

    i2c_init(hi2c->i2cx, I2C_FSMODE_DUTY_2_1, I2Cx_SPEED);

    i2c_own_address1_set(hi2c->i2cx, I2C_ADDRESS_MODE_7BIT, I2Cx_ADDRESS);
  }
}

int main(void)
{
  i2c_status_type i2c_status;

  /* config nvic priority group */
  nvic_priority_group_config(NVIC_PRIORITY_GROUP_4);

  system_clock_config();

  at32_board_init();

  hi2cx.i2cx = I2Cx_PORT;

  i2c_config(&hi2cx);

  while(1)
  {
    /* wait for key USER_BUTTON press before starting the communication */
    while(at32_button_press() != USER_BUTTON)
    {
    }

    /* write data to memory device */
    if((i2c_status = i2c_memory_write(&hi2cx, I2C_MEM_ADDR_WIDIH_8, I2Cx_ADDRESS, 0x00, tx_buf1, BUF_SIZE, I2C_TIMEOUT)) != I2C_OK)
    {
      error_handler(i2c_status);
    }

    delay_ms(5);

    /* read data from memory device */
    if((i2c_status = i2c_memory_read(&hi2cx, I2C_MEM_ADDR_WIDIH_8, I2Cx_ADDRESS, 0x00, rx_buf1, BUF_SIZE, I2C_TIMEOUT)) != I2C_OK)
    {
      error_handler(i2c_status);
    }

    /* write data to memory device */
    if((i2c_status = i2c_memory_write_int(&hi2cx, I2C_MEM_ADDR_WIDIH_8, I2Cx_ADDRESS, 0x00, tx_buf2, BUF_SIZE, I2C_TIMEOUT)) != I2C_OK)
    {
      error_handler(i2c_status);
    }

    /* wait for the communication to end */
    if(i2c_wait_end(&hi2cx, I2C_TIMEOUT) != I2C_OK)
    {
      error_handler(i2c_status);
    }

    delay_ms(5);

    /* read data from memory device */
    if((i2c_status = i2c_memory_read_int(&hi2cx, I2C_MEM_ADDR_WIDIH_8, I2Cx_ADDRESS, 0x00, rx_buf2, BUF_SIZE, I2C_TIMEOUT)) != I2C_OK)
    {
      error_handler(i2c_status);
    }

    /* wait for the communication to end */
    if(i2c_wait_end(&hi2cx, I2C_TIMEOUT) != I2C_OK)
    {
      error_handler(i2c_status);
    }

    /* write data to memory device */
    if((i2c_status = i2c_memory_write_dma(&hi2cx, I2C_MEM_ADDR_WIDIH_8, I2Cx_ADDRESS, 0x00, tx_buf3, BUF_SIZE, I2C_TIMEOUT)) != I2C_OK)
    {
      error_handler(i2c_status);
    }

    /* wait for the communication to end */
    if(i2c_wait_end(&hi2cx, I2C_TIMEOUT) != I2C_OK)
    {
      error_handler(i2c_status);
    }

    delay_ms(5);

    /* read data from memory device */
    if((i2c_status = i2c_memory_read_dma(&hi2cx, I2C_MEM_ADDR_WIDIH_8, I2Cx_ADDRESS, 0x00, rx_buf3, BUF_SIZE, I2C_TIMEOUT)) != I2C_OK)
    {
      error_handler(i2c_status);
    }

    /* wait for the communication to end */
    if(i2c_wait_end(&hi2cx, I2C_TIMEOUT) != I2C_OK)
    {
      error_handler(i2c_status);
    }

    if((buffer_compare(tx_buf1, rx_buf1, BUF_SIZE) == 0) &&
       (buffer_compare(tx_buf2, rx_buf2, BUF_SIZE) == 0) &&
       (buffer_compare(tx_buf3, rx_buf3, BUF_SIZE) == 0))
    {
      at32_led_on(LED3);
    }
    else
    {
      error_handler(i2c_status);
    }

  }
}

代码讲解

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

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

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

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

I2C 配置：设置通信速率（标准 100K / 快速 400K / 快速+ 1M）、从机地址、时钟拉伸。

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

延时：使用系统延时函数控制 LED 翻转间隔。

实验现象

主机和从机完成数据收发
校验通过 LED 指示成功

注意事项

I2C 总线需要上拉电阻（一般 4.7K）
从机地址要与设备手册一致（注意 7 位/8 位地址的区别）
写 EEPROM 后需要等待 5ms 以上再读

AT32 I2C — 中断通信

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

I2C — 中断通信

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

功能简介

本示例演示 I2C 中断方式通信。每完成一个字节触发中断，CPU 在中断中处理后续操作，效率更高。

硬件准备

I2C 从设备（如 EEPROM、传感器模块）
SCL/SDA 线上需要 4.7K 上拉电阻

完整代码

#include "at32f403a_407_board.h"
#include "at32f403a_407_clock.h"
#include "i2c_application.h"
#define I2C_TIMEOUT                      0xFFFFFFFF
#define I2Cx_SPEED                       100000
#define I2Cx_ADDRESS                     0xA0
#define I2Cx_PORT                        I2C1
#define I2Cx_CLK                         CRM_I2C1_PERIPH_CLOCK
#define I2Cx_SCL_PIN                     GPIO_PINS_6
#define I2Cx_SCL_GPIO_PORT               GPIOB
#define I2Cx_SCL_GPIO_CLK                CRM_GPIOB_PERIPH_CLOCK
#define I2Cx_SDA_PIN                     GPIO_PINS_7
#define I2Cx_SDA_GPIO_PORT               GPIOB
#define I2Cx_SDA_GPIO_CLK                CRM_GPIOB_PERIPH_CLOCK
#define I2Cx_EVT_IRQn                    I2C1_EVT_IRQn
#define I2Cx_ERR_IRQn                    I2C1_ERR_IRQn
#define BUF_SIZE                         8
#define MASTER_BOARD

void i2c_lowlevel_init(i2c_handle_type* hi2c)
{
  gpio_init_type gpio_initstructure;

  if(hi2c->i2cx == I2Cx_PORT)
  {
    /* i2c periph clock enable */
    crm_periph_clock_enable(I2Cx_CLK, TRUE);
    crm_periph_clock_enable(I2Cx_SCL_GPIO_CLK, TRUE);
    crm_periph_clock_enable(I2Cx_SDA_GPIO_CLK, TRUE);

    /* gpio configuration */
    gpio_initstructure.gpio_out_type       = GPIO_OUTPUT_OPEN_DRAIN;
    gpio_initstructure.gpio_pull           = GPIO_PULL_NONE;
    gpio_initstructure.gpio_mode           = GPIO_MODE_MUX;
    gpio_initstructure.gpio_drive_strength = GPIO_DRIVE_STRENGTH_MODERATE;

    /* configure i2c pins: scl */
    gpio_initstructure.gpio_pins = I2Cx_SCL_PIN;
    gpio_init(I2Cx_SCL_GPIO_PORT, &gpio_initstructure);

    /* configure i2c pins: sda */
    gpio_initstructure.gpio_pins = I2Cx_SDA_PIN;
    gpio_init(I2Cx_SDA_GPIO_PORT, &gpio_initstructure);

    /* configure and enable i2c interrupt */
    nvic_irq_enable(I2Cx_EVT_IRQn, 0, 0);
    nvic_irq_enable(I2Cx_ERR_IRQn, 0, 0);

    i2c_init(hi2c->i2cx, I2C_FSMODE_DUTY_2_1, I2Cx_SPEED);

    i2c_own_address1_set(hi2c->i2cx, I2C_ADDRESS_MODE_7BIT, I2Cx_ADDRESS);
  }
}

int main(void)
{
  i2c_status_type i2c_status;

  /* config nvic priority group */
  nvic_priority_group_config(NVIC_PRIORITY_GROUP_4);

  system_clock_config();

  at32_board_init();

  hi2cx.i2cx = I2Cx_PORT;

  i2c_config(&hi2cx);

  while(1)
  {

#if defined (MASTER_BOARD)

    /* wait for key USER_BUTTON press before starting the communication */
    while(at32_button_press() != USER_BUTTON)
    {
    }

    /* start the request reception process */
    if((i2c_status = i2c_master_transmit_int(&hi2cx, I2Cx_ADDRESS, tx_buf, BUF_SIZE, I2C_TIMEOUT)) != I2C_OK)
    {
      error_handler(i2c_status);
    }

    /* wait for the communication to end */
    if(i2c_wait_end(&hi2cx, I2C_TIMEOUT) != I2C_OK)
    {
      error_handler(i2c_status);
    }

    delay_ms(10);

    /* start the request reception process */
    if((i2c_status = i2c_master_receive_int(&hi2cx, I2Cx_ADDRESS, rx_buf, BUF_SIZE, I2C_TIMEOUT)) != I2C_OK)
    {
      error_handler(i2c_status);
    }

    /* wait for the communication to end */
    if(i2c_wait_end(&hi2cx, I2C_TIMEOUT) != I2C_OK)
    {
      error_handler(i2c_status);
    }

    if(buffer_compare(tx_buf, rx_buf, BUF_SIZE) == 0)
    {
      at32_led_on(LED3);
    }
    else
    {
      error_handler(i2c_status);
    }

#else

    /* wait for key USER_BUTTON press before starting the communication */
    while(at32_button_press() != USER_BUTTON)
    {
    }

    /* start the transmission process */
    if((i2c_status = i2c_slave_receive_int(&hi2cx, rx_buf, BUF_SIZE, I2C_TIMEOUT)) != I2C_OK)
    {
      error_handler(i2c_status);
    }

    /* wait for the communication to end */
    if(i2c_wait_end(&hi2cx, I2C_TIMEOUT) != I2C_OK)
    {
      error_handler(i2c_status);
    }

    if((i2c_status = i2c_slave_transmit_int(&hi2cx, tx_buf, BUF_SIZE, I2C_TIMEOUT)) != I2C_OK)
    {
      error_handler(i2c_status);
    }

    /* wait for the communication to end */
    if(i2c_wait_end(&hi2cx, I2C_TIMEOUT) != I2C_OK)
    {
      error_handler(i2c_status);
    }

    if(buffer_compare(tx_buf, rx_buf, BUF_SIZE) == 0)
    {
      at32_led_on(LED3);
    }
    else
    {
      error_handler(i2c_status);
    }
#endif

  }
}

代码讲解

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

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

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

I2C 配置：设置通信速率（标准 100K / 快速 400K / 快速+ 1M）、从机地址、时钟拉伸。

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

延时：使用系统延时函数控制 LED 翻转间隔。

实验现象

主机和从机完成数据收发
校验通过 LED 指示成功

注意事项

I2C 总线需要上拉电阻（一般 4.7K）
从机地址要与设备手册一致（注意 7 位/8 位地址的区别）
写 EEPROM 后需要等待 5ms 以上再读

CIU32 — I2C 总线

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

CIU32 — I2C 总线

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

什么是 I2C 总线?

I2C 只需两根线（SCL+SDA）就能连接多个设备。标准速率 100Kbps，快速模式 400Kbps。每个设备有唯一地址。

示例列表

GPIO 模拟 I2C 主机 — GPIO_Simulate_I2C_Master
I2C1 从机中断 — I2C1_Slave_Interrupt
I2C1 从机轮询 — I2C1_Slave_Poll

CIU32 I2C — GPIO 模拟 I2C 主机

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

I2C — GPIO 模拟 I2C 主机

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

功能简介

本示例演示 I2C 总线通信。I2C 只需两根线（SCL+SDA）就能连接多个设备，是最常用的低速通信总线。

硬件准备

I2C 从设备（如 EEPROM、传感器模块）
SCL/SDA 线上需要 4.7K 上拉电阻

完整代码

#include "main.h"

int main(void)
{    
    /* ϵͳʱ */
    system_clock_config();
    
    /* GPIOʼ */
    gpio_init();
    
    /* I2C */
    bsp_i2c_master_send();
    
    /* I2C */
    bsp_i2c_master_receive();
    
    while(1)
    {
    }
}

代码讲解

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

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

实验现象

主机和从机完成数据收发
校验通过 LED 指示成功

注意事项

I2C 总线需要上拉电阻（一般 4.7K）
从机地址要与设备手册一致（注意 7 位/8 位地址的区别）
写 EEPROM 后需要等待 5ms 以上再读

CIU32 I2C — I2C1 从机轮询

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

I2C — I2C1 从机轮询

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

功能简介

本示例演示 I2C 轮询方式通信。CPU 等待每个字节传输完成，简单但效率较低。

硬件准备

I2C 从设备（如 EEPROM、传感器模块）
SCL/SDA 线上需要 4.7K 上拉电阻

完整代码

#include "main.h"

int main(void)
{    
    /* ϵͳʱ */
    system_clock_config();
    
    /* I2C1LED GPIOʼ */
    gpio_init();
    
    /* I2C1ʼΪģʽ */
    i2c1_slave_init();
    
    /* LEDָʾӻ */
    std_gpio_reset_pin(LED_GPIO_PORT, LED_PIN);

    /* I2C */
    bsp_i2c1_slave_receive();
    
    /* I2C */
    bsp_i2c1_slave_send();
    
    while(1)
    {
        
    }
}

代码讲解

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

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

实验现象

主机和从机完成数据收发
校验通过 LED 指示成功

注意事项

I2C 总线需要上拉电阻（一般 4.7K）
从机地址要与设备手册一致（注意 7 位/8 位地址的区别）
写 EEPROM 后需要等待 5ms 以上再读

CIU32 I2C — I2C1 从机中断

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

I2C — I2C1 从机中断

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

功能简介

本示例演示 I2C 中断方式通信。每完成一个字节触发中断，CPU 在中断中处理后续操作，效率更高。

硬件准备

I2C 从设备（如 EEPROM、传感器模块）
SCL/SDA 线上需要 4.7K 上拉电阻

完整代码

#include "main.h"

int main(void)
{    
    /* ϵͳʱ */
    system_clock_config();
    
    /* I2C1LED GPIOʼ */
    gpio_init();
    
    /* I2C1ʼΪģʽ */
    i2c1_slave_init();
    
    /* NVICʼ */
    nvic_init();
    
    /* LEDָʾӻ */
    std_gpio_reset_pin(LED_GPIO_PORT, LED_PIN);
    
    while(1)
    {
       
    }
}

代码讲解

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

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

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

实验现象

主机和从机完成数据收发
校验通过 LED 指示成功

注意事项

I2C 总线需要上拉电阻（一般 4.7K）
从机地址要与设备手册一致（注意 7 位/8 位地址的区别）
写 EEPROM 后需要等待 5ms 以上再读

GD32 — I2C 串行总线 (I2C)

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

GD32 — I2C 串行总线 (I2C)

固件库: GD32F30x_Firmware_Library V3.0.3
示例数: 14
推荐入门: I2C_EEPROM（EEPROM 读写）

什么是 I2C 总线？

I2C（Inter-Integrated Circuit，常读作 “I-squared-C” 或 “I-two-C”）是飞利浦（现 NXP）提出的一种两线式、半双工、多主多从同步串行总线。它和 SPI 恰好形成对比：

特性	I2C	SPI
信号线	2 根（SCL、SDA）	4 根（SCK、MOSI、MISO、NSS）
拓扑	一主多从，靠地址区分	一主多从，靠片选区分
速度	标准 100K / 快速 400K / 快速+ 1M bps	可达数十 MHz
全/半双工	半双工（同一条数据线收发切换）	全双工
硬件开销	省线，适合多设备	每加一个从机多一根 NSS

一句话记忆：I2C 用最少的线（两根）挂一堆设备，每个设备有地址；SPI 用更多的线换速度。

两根信号线

SCL（Serial Clock）：时钟线，由主机产生。
SDA（Serial Data）：数据线，主从都可以在上面发数据（所以半双工）。

两根线都必须是开漏（Open-Drain）输出 + 外部上拉电阻。这是 I2C 能"多主多从"还能"线与"仲裁的硬件基础——任何设备拉低总线即生效，释放后由上拉电阻拉高。这也是为什么 GPIO 要配成 GPIO_MODE_AF_OD（复用开漏），且板上必须接 4.7kΩ 左右的上拉。

一帧数据的样子

一个典型的 I2C 写操作（以写 EEPROM 为例）：

`1`	`[START] [从机地址+W] [ACK] [寄存器地址] [ACK] [数据1] [ACK] ... [STOP]`

START（起始条件）：SCL 高电平时，SDA 由高变低。
从机地址：7 位地址 + 1 位读写方向位（0=写，1=读），共 8 位。
ACK（应答）：每传完一个字节，接收方在第 9 个时钟把 SDA 拉低表示"收到了"。没拉低就是 NACK。
STOP（停止条件）：SCL 高电平时，SDA 由低变高。

7 位地址 vs 8 位地址的坑：很多新手把 0xA0 当成"地址"。其实 0xA0 是8 位写法（含读写位），真正的 7 位地址是 0xA0 >> 1 = 0x50。库函数 i2c_master_addressing() 会自动帮你拼上读写位，所以你传 0xA0（或 0x50）都行——本例 I2CX_SLAVE_ADDRESS7 直接写成 0xA0，库会处理。入门阶段记住：见到偶数 0xA0 这种"带读写位"的写法，是 I2C 器件的常见俗写，别慌。

GD32F30x 的 I2C 资源

通常有 I2C0 / I2C1 两路。
本例用 I2C0，引脚为 PB6（SCL）/ PB7（SDA），硬件复用（RCU_AF 默认已映射，无需额外 remap）。
速率由 i2c_clock_config() 设定，常用 100000（标准）或 400000（快速）。

常用库函数速查

函数	作用
`i2c_clock_config(I2CX, speed, duty)`	设置速率（如 100000）和占空比
`i2c_mode_addr_config(I2CX, mode, fmt, addr)`	配置主/从模式、地址位数、自身地址
`i2c_enable(I2CX)` / `i2c_ack_config(I2CX, ACK)`	使能 I2C / 开启自动应答
`i2c_start_on_bus(I2CX)`	产生 START 条件
`i2c_master_addressing(I2CX, addr, dir)`	发送从机地址 + 方向（自动拼读写位）
`i2c_data_transmit(I2CX, data)`	发送一个字节
`i2c_data_receive(I2CX)`	读取一个字节
`i2c_stop_on_bus(I2CX)`	产生 STOP 条件
`i2c_flag_get(I2CX, flag)`	查询标志位（SBSEND / ADDSEND / TBE / RBNE / BTC / I2CBSY 等）

几个关键标志位

I2C_FLAG_I2CBSY：总线忙。发 START 前要确认它为 0（空闲）。
I2C_FLAG_SBSEND：起始条件已发出。
I2C_FLAG_ADDSEND：地址已发出且收到从机 ACK（地址匹配成功）。必须读/清这个标志，否则卡死。
I2C_FLAG_TBE：发送数据寄存器空，可以塞下一个字节。
I2C_FLAG_BTC：字节传输完成（一字节发完且 ACK 收到）。本例靠它判断"该发下一个了"。
I2C_FLAG_RBNE：接收数据寄存器非空，可以读走。

为什么 I2C 代码看起来那么"啰嗦"？

和 GPIO/USART 不同，官方 I2C 例程几乎都是状态机 + 超时写法（i2c_process_enum 状态：START → SEND_ADDRESS → CLEAR_ADDRESS_FLAG → TRANSMIT_DATA → STOP）。原因是 I2C 是"带应答的协议"，每一步都要等对方 ACK，且可能因为从机没接好而永久卡住。加上 timeout 计数和 i2c_bus_reset() 复位，就是为了让通信卡死时能自救。入门看 I2C_EEPROM 的 eeprom_byte_write_timeout() 就能理解这套套路。

示例列表

I2C EEPROM 读写 — I2C_EEPROM ★ 入门推荐
I2C EEPROM DMA — I2C_EEPROM_dma
I2C EEPROM 中断 — I2C_EEPROM_interrput
I2C 主机发送 — Master_transmitter
I2C 主机接收 — Master_receiver
I2C 主机接收 1 字节 — Master_receiver_one_byte
I2C 主机接收 2 字节 — Master_receiver_two_bytes
I2C 主发从收 — Master_transmitter&slave_receiver
I2C 主收从发中断 — Master_receiver&slave_transmitter_interrupt
I2C 主发从收 DMA — Master_transmitter&slave_receiver_dma
I2C 主发从收中断 — Master_transmitter&slave_receiver_interrupt
I2C 从机接收 — Slave_receiver
I2C 从机发送 — Slave_transmitter
I2C 快速模式+ 通信 — Fast_mode_plus_communication

学习路径建议

先跑通 I2C_EEPROM，理解"START → 发地址 → 等 ACK → 发寄存器地址 → 发数据 → STOP"这一整套"字节写"流程，以及配套的页写 / 顺序读 / 等待就绪逻辑。
再读 Master_transmitter / Master_receiver 看纯主机收发的最小骨架。
数据量大时升级到 I2C_EEPROM_dma 或 I2C_EEPROM_interrput，把轮询等待替换成 DMA/中断。

下一篇：I2C EEPROM 读写

GD32 I2C — I2C EEPROM DMA

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

I2C — I2C EEPROM DMA

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

功能简介

本示例演示通过 I2C 接口读写 EEPROM（如 AT24C02）。EEPROM 是最常用的 I2C 从设备，掉电不丢失数据，适合存储配置参数。

硬件准备

AT24C02 或类似 EEPROM 模块
连接：SCL→PB10, SDA→PB11（具体引脚参考代码）
注意上拉电阻（模块通常自带）

完整代码

#include <stdio.h>
#include "gd32f30x.h"
#include "gd32f307c_eval.h"
#include "systick.h"
#include "i2c.h"
#include "at24cxx.h"

int main(void)
{
    /* configure systick */
    systick_config();

    /* configure LEDs */
    led_config();

    /* configure USART */
    gd_eval_com_init(EVAL_COM0);

    printf("I2C-24C02 configured....\n\r");

    /* configure GPIO */
    gpio_config();

    /* configure I2C */
    i2c_config();

    /* initialize EEPROM  */
    i2c_eeprom_init();

    printf("\r\nThe I2C is hardware interface ");
    printf("\r\nThe speed is %d", I2C_SPEED);

    if(I2C_OK == i2c_24c02_test()) {
        while(1) {
            /* turn off all LEDs */
            gd_eval_led_off(LED2);
            gd_eval_led_off(LED3);
            gd_eval_led_off(LED4);
            gd_eval_led_off(LED5);
            /* turn on a LED */
            led_turn_on(count % 4);
            count++;
            if(count >= 4) {
                count = 0;
            }
            delay_1ms(500);
        }
    }
    /* turn on all LEDs */
    gd_eval_led_on(LED2);
    gd_eval_led_on(LED3);
    gd_eval_led_on(LED4);
    gd_eval_led_on(LED5);

    while(1) {
    }

}

代码讲解

printf 输出：通过串口打印调试信息。需要先调用 uart_print_init 完成重定向。

I2C 配置：设置通信速率（标准 100K / 快速 400K / 快速+ 1M）、从机地址、时钟拉伸。

实验现象

按下按键后，向 EEPROM 写入数据并读回
写入和读出的数据一致则 LED 亮起

注意事项

I2C 总线需要上拉电阻（一般 4.7K）
从机地址要与设备手册一致（注意 7 位/8 位地址的区别）
写 EEPROM 后需要等待 5ms 以上再读

GD32 I2C — I2C EEPROM 读写

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

I2C — I2C EEPROM 读写

固件库: GD32F30x_Firmware_Library V3.0.3
芯片: GD32F30x（以 GD32F307 评估板为例）
源文件: GD32F30x_Firmware_Library_V3.0.3/Examples/I2C/I2C_EEPROM/main.c
配套文件: i2c.c / i2c.h（底层驱动）、at24cxx.c / at24cxx.h（EEPROM 读写逻辑）
评估板 EEPROM: AT24C02（I2C 接口，2Kbit = 256 字节）

功能简介

本示例演示用 I2C 硬件外设 读写一颗 AT24C02 EEPROM（电可擦可编程只读存储器）。EEPROM 最大的特点是掉电不丢数据，常用来存设备配置、校准参数、运行计数等。

整个流程一句话概括：

准备好 256 字节的测试数据 i2c_buffer_write[i] = i（即 0x00~0xFF）。
通过 I2C 把这批数据写入 AT24C02（从地址 0 开始）。
再从 AT24C02 读回同样 256 字节到 i2c_buffer_read[]。
逐字节比较写入和读回是否一致，全部一致则测试通过（I2C_OK）。
测试通过 → LED2~LED5 循环流水闪烁；失败 → 4 颗 LED 全亮，表示读写出错。

本例的亮点（也是难点）是：I2C 收发全部用"状态机 + 超时"实现，每一步都等从机 ACK、带超时保护和总线复位，非常贴近真实工程的健壮写法。

硬件准备

1. 开发板 + EEPROM 模块

GD32F30x 评估板（例程按 GD32F307C EVAL 编写，LED2~LED5 由 gd_eval_led_init 初始化）。
AT24C02 模块（或板载 EEPROM）。本例 I2C 地址宏 I2CX_SLAVE_ADDRESS7 = 0xA0。

2. 接线（I2C0：PB6/PB7）

信号	MCU 引脚	接 EEPROM
SCL	PB6	EEPROM SCL
SDA	PB7	EEPROM SDA

关键：I2C 的两根线必须接上拉电阻（通常 4.7kΩ 到 3.3V）。大多数 EEPROM 模块板载了上拉，直接连即可；若自己搭电路，别忘了加上拉，否则总线拉不高、通信必失败。

3. 串口（强烈建议）

例程用 printf 打印调试信息（“AT24C02 writing…"、“test passed!"、出错字节等）。把 PA9/PA10 接到 USB 转串口，波特率 115200（评估板 gd_eval_com_init 默认）即可在串口助手查看全过程。

完整代码（带中文注释）

由于本例代码分散在 main.c、i2c.c、at24cxx.c 三个文件，下面按"从顶到底"的顺序摘出最核心、最该读懂的部分，并配上中文注释。完整工程文件请直接查看源码目录。

1) main.c —— 主流程

#include <stdio.h>
#include "gd32f30x.h"
#include "gd32f307c_eval.h"
#include "systick.h"
#include "i2c.h"
#include "at24cxx.h"

uint8_t count = 0;

void led_turn_on(uint8_t led_number);
void led_config(void);

void led_config(void)
{
    gd_eval_led_init(LED2);
    gd_eval_led_init(LED3);
    gd_eval_led_init(LED4);
    gd_eval_led_init(LED5);
    gd_eval_led_off(LED2);
    gd_eval_led_off(LED3);
    gd_eval_led_off(LED4);
    gd_eval_led_off(LED5);
}

int main(void)
{
    /* 系统滴答定时器（提供 delay_1ms 时基） */
    systick_config();
    /* LED 初始化 */
    led_config();
    /* 串口初始化（用于 printf 打印） */
    gd_eval_com_init(EVAL_COM0);

    printf("I2C-24C02 configured....\n\r");

    /* GPIO 配置：把 PB6/PB7 设成 I2C 复用开漏 */
    gpio_config();
    /* I2C 外设配置：速率 100K、自身 7 位地址、使能、开启 ACK */
    i2c_config();
    /* 初始化 EEPROM 驱动（记录器件地址 0xA0） */
    i2c_eeprom_init();

    printf("\r\nThe I2C is hardware interface ");
    printf("\r\nThe speed is %d", I2C_SPEED);

    /* 执行读写自测 */
    if(I2C_OK == i2c_24c02_test()) {
        /* 测试通过：4 颗 LED 循环流水，每 500ms 切换 */
        while(1) {
            gd_eval_led_off(LED2);
            gd_eval_led_off(LED3);
            gd_eval_led_off(LED4);
            gd_eval_led_off(LED5);
            led_turn_on(count % 4);
            count++;
            if(count >= 4) count = 0;
            delay_1ms(500);
        }
    }
    /* 测试失败：4 颗 LED 全亮，停在这里 */
    gd_eval_led_on(LED2);
    gd_eval_led_on(LED3);
    gd_eval_led_on(LED4);
    gd_eval_led_on(LED5);
    while(1) {}
}

2) i2c.h —— 关键宏定义（先记住这些）

#define I2C_SPEED               100000      /* 标准模式 100Kbps */
#define I2CX_SLAVE_ADDRESS7     0xA0        /* AT24C02 的 8 位地址写法（含读写位） */
#define I2C_PAGE_SIZE           8           /* AT24C02 每页 8 字节（页写上限） */

#define I2CX                    I2C0
#define RCU_GPIO_I2C            RCU_GPIOB
#define RCU_I2C                 RCU_I2C0
#define I2C_SCL_PORT            GPIOB
#define I2C_SDA_PORT            GPIOB
#define I2C_SCL_PIN             GPIO_PIN_6  /* PB6 = SCL */
#define I2C_SDA_PIN             GPIO_PIN_7  /* PB7 = SDA */

3) i2c.c —— GPIO 与 I2C 外设配置

void gpio_config(void)
{
    rcu_periph_clock_enable(RCU_GPIO_I2C);
    /* I2C 引脚必须是 复用开漏(AF_OD) + 外部上拉 */
    gpio_init(I2C_SCL_PORT, GPIO_MODE_AF_OD, GPIO_OSPEED_50MHZ, I2C_SCL_PIN);
    gpio_init(I2C_SDA_PORT, GPIO_MODE_AF_OD, GPIO_OSPEED_50MHZ, I2C_SDA_PIN);
}

void i2c_config(void)
{
    rcu_periph_clock_enable(RCU_I2C);
    /* 配置速率：100000 bps，占空比 2（快速模式才讲究，标准模式随意） */
    i2c_clock_config(I2CX, I2C_SPEED, I2C_DTCY_2);
    /* 配置 I2C 为主机模式、7 位地址格式、自身地址 0xA0 */
    i2c_mode_addr_config(I2CX, I2C_I2CMODE_ENABLE, I2C_ADDFORMAT_7BITS, I2CX_SLAVE_ADDRESS7);
    i2c_enable(I2CX);                 /* 使能 I2C 外设 */
    i2c_ack_config(I2CX, I2C_ACK_ENABLE);  /* 开启自动应答（读多字节时必须） */
}

4) at24cxx.c —— 最核心的"状态机写一字节”

下面这个函数 eeprom_byte_write_timeout() 把 I2C 写一字节的完整协议展示得最清楚。注意它是一个 switch 状态机，timeout 防止卡死：

uint8_t eeprom_byte_write_timeout(uint8_t *p_buffer, uint8_t write_address)
{
    uint8_t  state = I2C_START;
    uint16_t timeout = 0;
    uint8_t  i2c_timeout_flag = 0;

    i2c_ack_config(I2CX, I2C_ACK_ENABLE);

    while(!(i2c_timeout_flag)) {
        switch(state) {
        case I2C_START:
            /* ① 等总线空闲（不忙）才发 START */
            while(i2c_flag_get(I2CX, I2C_FLAG_I2CBSY) && (timeout < I2C_TIME_OUT)) {
                timeout++;
            }
            if(timeout < I2C_TIME_OUT) {
                i2c_start_on_bus(I2CX);      /* 产生 START 条件 */
                timeout = 0;
                state = I2C_SEND_ADDRESS;
            } else {
                timeout = 0;
                state = I2C_START;           /* 超时：重来 */
                printf("i2c bus is busy in WRITE BYTE!\n");
            }
            break;

        case I2C_SEND_ADDRESS:
            /* ② 等 START 已发出（SBSEND） */
            while((! i2c_flag_get(I2CX, I2C_FLAG_SBSEND)) && (timeout < I2C_TIME_OUT)) {
                timeout++;
            }
            if(timeout < I2C_TIME_OUT) {
                /* 发送从机地址 + 写方向（库会自动拼读写位） */
                i2c_master_addressing(I2CX, eeprom_address, I2C_TRANSMITTER);
                timeout = 0;
                state = I2C_CLEAR_ADDRESS_FLAG;
            } else {
                timeout = 0;
                state = I2C_START;
            }
            break;

        case I2C_CLEAR_ADDRESS_FLAG:
            /* ③ 等从机回应地址 ACK（ADDSEND），然后必须清除该标志 */
            while((! i2c_flag_get(I2CX, I2C_FLAG_ADDSEND)) && (timeout < I2C_TIME_OUT)) {
                timeout++;
            }
            if(timeout < I2C_TIME_OUT) {
                i2c_flag_clear(I2CX, I2C_FLAG_ADDSEND);
                timeout = 0;
                state = I2C_TRANSMIT_DATA;
            } else {
                timeout = 0;
                state = I2C_START;
            }
            break;

        case I2C_TRANSMIT_DATA:
            /* ④ 等发送缓冲空（TBE），先发 EEPROM 内部地址（写哪个存储单元） */
            while((! i2c_flag_get(I2CX, I2C_FLAG_TBE)) && (timeout < I2C_TIME_OUT)) {
                timeout++;
            }
            if(timeout < I2C_TIME_OUT) {
                i2c_data_transmit(I2CX, write_address);  /* EEPROM 内地址 */
                timeout = 0;
            }
            /* 等字节传完（BTC），再发真正的数据字节 */
            while((!i2c_flag_get(I2CX, I2C_FLAG_BTC)) && (timeout < I2C_TIME_OUT)) {
                timeout++;
            }
            if(timeout < I2C_TIME_OUT) {
                i2c_data_transmit(I2CX, *p_buffer);      /* 实际要写的数据 */
                timeout = 0;
            }
            /* 再等 BTC，准备结束 */
            while((!i2c_flag_get(I2CX, I2C_FLAG_BTC)) && (timeout < I2C_TIME_OUT)) {
                timeout++;
            }
            if(timeout < I2C_TIME_OUT) {
                state = I2C_STOP;
                timeout = 0;
            }
            break;

        case I2C_STOP:
            /* ⑤ 发 STOP 条件，结束本次通信 */
            i2c_stop_on_bus(I2CX);
            while((I2C_CTL0(I2CX) & I2C_CTL0_STOP) && (timeout < I2C_TIME_OUT)) {
                timeout++;
            }
            if(timeout < I2C_TIME_OUT) {
                timeout = 0;
                state = I2C_END;
                i2c_timeout_flag = I2C_OK;
            }
            break;

        default:
            state = I2C_START;
            i2c_timeout_flag = I2C_OK;
            timeout = 0;
            break;
        }
    }
    return I2C_END;
}

5) at24cxx.c —— 自测函数 i2c_24c02_test()

uint8_t i2c_24c02_test(void)
{
    uint16_t i;
    uint8_t i2c_buffer_write[BUFFER_SIZE];   /* BUFFER_SIZE = 256 */
    uint8_t i2c_buffer_read[BUFFER_SIZE];

    printf("\r\nAT24C02 writing...\r\n");
    /* 准备测试数据：0,1,2,...,255 */
    for(i = 0; i < BUFFER_SIZE; i++) {
        i2c_buffer_write[i] = i;
    }
    /* 整片写入（内部做了分页写） */
    eeprom_buffer_write_timeout(i2c_buffer_write, EEP_FIRST_PAGE, BUFFER_SIZE);

    printf("AT24C02 reading...\r\n");
    /* 整片读回 */
    eeprom_buffer_read_timeout(i2c_buffer_read, EEP_FIRST_PAGE, BUFFER_SIZE);

    /* 逐字节比对 */
    for(i = 0; i < BUFFER_SIZE; i++) {
        if(i2c_buffer_read[i] != i2c_buffer_write[i]) {
            printf("Err:data read and write aren't matching.\n\r");
            return I2C_FAIL;     /* 任一字节不一致 → 失败 */
        }
    }
    printf("I2C-AT24C02 test passed!\n\r");
    return I2C_OK;               /* 全部一致 → 成功 */
}

其余 eeprom_page_write_timeout()（页写）、eeprom_buffer_write_timeout()（跨页拆分）、eeprom_buffer_read_timeout()（含"复合格式"读：先写地址再发重复 START 切到读方向）、eeprom_wait_standby_state_timeout()（等 EEPROM 写完就绪）都是在这套状态机骨架上的扩展。它们的核心套路一致：START → 地址 → 等 ACK → 数据 → STOP，只是数据段多循环几次、或读之前多发一次"重复起始（Repeated START）"。

代码分段讲解

1. I2C 引脚为什么是"复用开漏”？

1
2

gpio_init(I2C_SCL_PORT, GPIO_MODE_AF_OD, GPIO_OSPEED_50MHZ, I2C_SCL_PIN);
gpio_init(I2C_SDA_PORT, GPIO_MODE_AF_OD, GPIO_OSPEED_50MHZ, I2C_SDA_PIN);

I2C 总线是**线与（wired-AND）**结构：任何设备都能把线拉低，但只能靠上拉电阻拉高。如果用推挽输出，两个设备一个拉高一个拉低就会"短路"打架。开漏输出恰好满足"谁想拉低谁拉，否则释放由电阻拉高"，配合外部上拉电阻，这就是 I2C 能多主多从、还能仲裁的硬件基础。漏了上拉电阻 = 通信必失败，这是 I2C 头号新手坑。

2. 速率、地址、应答三件套

1
2
3

i2c_clock_config(I2CX, I2C_SPEED, I2C_DTCY_2);          // 速率 100K
i2c_mode_addr_config(I2CX, ..., I2C_ADDFORMAT_7BITS, 0xA0);  // 7 位地址
i2c_ack_config(I2CX, I2C_ACK_ENABLE);                   // 开启自动应答

I2C_SPEED = 100000：标准模式。想提速改 400000（快速模式）；EEPROM 通常都支持。
0xA0：AT24C02 的 8 位地址俗写（含读写位）。i2c_master_addressing() 会按 7 位地址格式自动处理，所以这里传 0xA0 没问题。
ACK 必须开启：读多字节时，主机每收一个字节都要回 ACK 告诉从机"继续发"，最后一个字节才回 NACK 表示"到此为止"。

3. 状态机：每一步都在"等 ACK + 防卡死"

观察 eeprom_byte_write_timeout()，整段逻辑被拆成 5 个状态：I2C_START → I2C_SEND_ADDRESS → I2C_CLEAR_ADDRESS_FLAG → I2C_TRANSMIT_DATA → I2C_STOP。每个状态里都是 while(标志未到 && timeout < I2C_TIME_OUT) 这种带超时的等待：

等 I2C_FLAG_I2CBSY 为 0 → 总线空闲才能发 START。
等 I2C_FLAG_SBSEND → START 已发出。
等 I2C_FLAG_ADDSEND → 从机回了地址 ACK；必须 i2c_flag_clear() 清掉它，不清会卡死。
等 I2C_FLAG_TBE / BTC → 数据发出去、且收到从机对数据的 ACK。

超时就 state = I2C_START 重来，必要时 i2c_bus_reset() 把总线"抖"回正常。这种写法比"裸等标志"健壮得多，是真实工程里 I2C 的标配。

为什么要"先发 EEPROM 内地址、再发数据"？ AT24C02 这类 EEPROM 在收到器件地址后，还要再收一个"你想写哪个存储单元"的字地址（0x00~0xFF），之后才是真正的数据。所以一帧里主机连续发：器件地址(写) → 字地址 → 数据。读操作更复杂：先以"写方向"发器件地址+字地址告诉它"我要读的位置"，再发一次重复 START以"读方向"访问，然后开始收数据。

4. 页写与"等待就绪"

AT24C02 内部按"页"组织，每页 8 字节（I2C_PAGE_SIZE）。一次 I2C 写操作最多连续写一页，跨页必须拆成多次（每次都要重新 START+地址）。eeprom_buffer_write_timeout() 就是做这个"按 8 字节分页、跨页拆分"的活。

而且EEPROM 写慢——发完 STOP 后它要花几毫秒把数据固化到存储阵列，这段时间里它不响应任何访问。所以每次写完后都要 eeprom_wait_standby_state_timeout()：不断发 START+地址，直到从机回 ACK 表示"我忙完了、可以再聊了"。如果你写完立刻读，读到的会是旧数据或 NACK。

5. 读回来的数据怎么验证？

i2c_24c02_test() 用 i2c_buffer_write[i]=i 造了 0~255 的递增序列，写进去再读回来逐字节比。全对返回 I2C_OK，main 里就让 LED 流水；有错立刻 I2C_FAIL、LED 全亮。串口还会把出错的具体字节打印出来，方便排查。

实验现象

串口输出（115200 波特）：

I2C-24C02 configured....
The I2C is hardware interface
The speed is 100000
AT24C02 writing...
AT24C02 reading...
I2C-AT24C02 test passed!

LED 行为：
- 测试通过 → LED2、LED3、LED4、LED5 以 500ms 间隔循环流水闪烁。
- 测试失败（读写不一致）→ 4 颗 LED 全部常亮，程序停在末尾死循环。
若把接线拔掉或地址写错，串口会打出 i2c bus is busy ... / 各种 timeout 信息，最终触发失败分支。

常见问题

Q1：串口没任何输出 / 一直打 “i2c bus is busy”？
99% 是物理接线或上拉问题。检查：① PB6/PB7 是否真正接到了 EEPROM 的 SCL/SDA；② 总线上是否接了上拉电阻（4.7kΩ 到 3.3V）；③ EEPROM 供电是否正常。总线拉不高，I2C 永远判"忙"。

Q2：为什么 I2C 地址写成 0xA0 而不是 0x50？
0xA0 是 8 位写法（7 位地址 0x50 左移 1 位 = 0xA0，最低位是读写方向位）。AT24C02 的数据手册里器件地址常直接给成 0xA0（写）/ 0xA1（读）这种"含读写位"的写法。GD32 库函数 i2c_master_addressing() 会按你给的格式自动拼方向位，传 0xA0 即可，不必自己再移位。

Q3：为什么写完要等那么久才能读？
EEPROM 内部是"浮栅"工艺，写/擦要毫秒级时间。写完后它处于"忙"状态，期间不响应 I2C 访问。例程里的 eeprom_wait_standby_state_timeout() 就是反复探测它"忙完没有"。如果你自己写代码，记得写后延时 5~10ms 或轮询 ACK 再读。

Q4：可以一次写超过 8 字节吗？
不能在一次 I2C 连续写里超过一页（AT24C02 是 8 字节/页）。超过会从页首"回卷"覆盖。例程的 eeprom_buffer_write_timeout() 已替你按 8 字节分页、跨页拆分处理，所以传 256 字节也没问题。

Q5：为什么代码里那么多 timeout 和 i2c_bus_reset？
因为 I2C 是带应答的协议，从机没接好 / 总线被拉死时若"裸等标志"会永久卡住。带超时 + 总线复位是工业级写法，保证"卡了能恢复"。初学可先忽略 timeout 细节，重点理解状态机的 5 步顺序。

Q6：我想换成 AT24C04 / AT24C128 等更大容量怎么办？
主要改两点：① 器件地址（大容量页结构不同，字地址可能是 2 字节）；② I2C_PAGE_SIZE（页大小随型号变，如 AT24C64 是 32 字节）。地址格式（7 位/10 位）和页写逻辑要对照对应手册调整。

小结

本示例把 I2C 最核心的"主机写从机"协议完整走了一遍，记住这条主线：

开时钟 + 配 GPIO（AF_OD + 上拉）：SCL/PB6、SDA/PB7，千万别忘上拉电阻。
配 I2C 外设：速率、7 位地址、使能、开启 ACK。
通信五步状态机：START → 发地址(等 ACK) → 发字地址 → 发数据 → STOP，每步都等标志 + 防超时。
EEPROM 特有两件事：按页写（≤8 字节/页，跨页拆分）、写后等"就绪"再读。
验证：写进去什么、读回来什么，逐字节比对，用 LED / 串口给出结果。

I2C 比 SPI “省线但啰嗦”，吃透了 EEPROM 这一例，你基本就掌握了所有 I2C 从器件的读写套路。

拓展应用

掌握了 I2C EEPROM 读写后，可以延伸至大量 I2C 从设备：

存配置参数：把设备的校准值、用户设置写入 EEPROM，掉电不丢，上电读取恢复。
其它 I2C 传感器：如温湿度 SHT30、气压 BMP280、IMU MPU6050、光照 BH1750——它们的读写同样是"START → 地址 → 寄存器地址 → 数据/读回"这套协议，只是寄存器定义不同。
RTC 时钟芯片（PCF8563 / DS3231）：I2C 读时间、设闹钟。
I/O 扩展芯片（PCF8574 / MCP23017）：用 I2C 扩展 GPIO 口，省 MCU 引脚。
OLED 显示屏（SSD1306 的 I2C 版本）：用 I2C 刷小屏。
升级为 DMA / 中断：数据量大时改用同目录 I2C_EEPROM_dma / I2C_EEPROM_interrput，把轮询等待换成 DMA 或中断，释放 CPU。
多从机挂载：同一组 PB6/PB7 上可并挂多个 I2C 器件（EEPROM + 传感器 + RTC），靠各自不同地址区分，体现 I2C “两根线挂一片设备"的优势。

想看更简洁的纯主机收发骨架，可阅读同目录的 Master_transmitter / Master_receiver 例程。

GD32 I2C — I2C EEPROM 中断

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

I2C — I2C EEPROM 中断

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

功能简介

本示例演示通过 I2C 接口读写 EEPROM（如 AT24C02）。EEPROM 是最常用的 I2C 从设备，掉电不丢失数据，适合存储配置参数。

硬件准备

AT24C02 或类似 EEPROM 模块
连接：SCL→PB10, SDA→PB11（具体引脚参考代码）
注意上拉电阻（模块通常自带）

完整代码

#include <stdio.h>
#include "gd32f30x.h"
#include "gd32f307c_eval.h"
#include "systick.h"
#include "i2c.h"
#include "at24cxx.h"

int main(void)
{
    /* configure systick */
    systick_config();

    /* configure LEDs */
    led_config();

    /* configure USART */
    gd_eval_com_init(EVAL_COM0);

    printf("I2C-24C02 configured....\n\r");

    /* configure the NVIC */
    i2c_nvic_config();

    /* configure GPIO */
    gpio_config();

    /* configure I2C */
    i2c_config();

    /* initialize EEPROM  */
    i2c_eeprom_init();

    printf("\r\nThe I2C is hardware interface ");
    printf("\r\nThe speed is %d", I2C_SPEED);

    if(I2C_OK == i2c_24c02_test()) {
        while(1) {
            /* turn off all LEDs */
            gd_eval_led_off(LED2);
            gd_eval_led_off(LED3);
            gd_eval_led_off(LED4);
            gd_eval_led_off(LED5);
            /* turn on a LED */
            led_turn_on(count % 4);
            count++;
            if(count >= 4) {
                count = 0;
            }
            delay_1ms(500);
        }
    }
    /* turn on all LEDs */
    gd_eval_led_on(LED2);
    gd_eval_led_on(LED3);
    gd_eval_led_on(LED4);
    gd_eval_led_on(LED5);

    while(1) {
    }

}

void i2c_nvic_config(void)
{
    nvic_priority_group_set(NVIC_PRIGROUP_PRE1_SUB3);
    nvic_irq_enable(I2C0_EV_IRQn, 0, 2);
    nvic_irq_enable(I2C0_ER_IRQn, 0, 1);
}

代码讲解

printf 输出：通过串口打印调试信息。需要先调用 uart_print_init 完成重定向。

I2C 配置：设置通信速率（标准 100K / 快速 400K / 快速+ 1M）、从机地址、时钟拉伸。

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

实验现象

按下按键后，向 EEPROM 写入数据并读回
写入和读出的数据一致则 LED 亮起

注意事项

I2C 总线需要上拉电阻（一般 4.7K）
从机地址要与设备手册一致（注意 7 位/8 位地址的区别）
写 EEPROM 后需要等待 5ms 以上再读

GD32 I2C — I2C Fast-mode+ 通信

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

I2C — I2C Fast-mode+ 通信

固件库: GD32F30x_Firmware_Library V3.0.3
芯片: GD32
源文件: GD32F30x_Firmware_Library_V3.0.3/Examples/I2C/Fast_mode_ plus_communication/main.c

功能简介

本示例演示 I2C 总线通信。I2C 只需两根线（SCL+SDA）就能连接多个设备，是最常用的低速通信总线。

硬件准备

I2C 从设备（如 EEPROM、传感器模块）
SCL/SDA 线上需要 4.7K 上拉电阻

完整代码

#include "gd32f30x.h"
#include <stdio.h>
#include "gd32f307c_eval.h"
#define I2C0_SLAVE_ADDRESS7    0x82
#define I2C1_SLAVE_ADDRESS7    0x72

void rcu_config(void);
void gpio_config(void);
void i2c_config(void);
ErrStatus memory_compare(uint8_t *src, uint8_t *dst, uint16_t length);

/*!
    \brief      main function
    \param[in]  none
    \param[out] none
    \retval     none
*/
int main(void)
{
    uint8_t i;

    /* initialize led */
    gd_eval_led_init(LED2);
    gd_eval_led_init(LED3);
    /* configure RCU */
    rcu_config();
    /* configure GPIO */
    gpio_config();
    /* configure I2C */
    i2c_config();

    for(i = 0; i < 16; i++) {
        i2c_transmitter[i] = i + 0x80;
    }
    /* wait until I2C bus is idle */
    while(i2c_flag_get(I2C0, I2C_FLAG_I2CBSY));
    /* send a start condition to I2C bus */
    i2c_start_on_bus(I2C0);
    /* wait until SBSEND bit is set */
    while(!i2c_flag_get(I2C0, I2C_FLAG_SBSEND));
    /* send slave address to I2C bus */
    i2c_master_addressing(I2C0, I2C1_SLAVE_ADDRESS7, I2C_RECEIVER);
    /* wait until ADDSEND bit is set */
    while(!i2c_flag_get(I2C0, I2C_FLAG_ADDSEND));
    /* clear ADDSEND bit */
    i2c_flag_clear(I2C0, I2C_FLAG_ADDSEND);
    /* wait until ADDSEND bit is set */
    while(!i2c_flag_get(I2C1, I2C_FLAG_ADDSEND));
    /* clear ADDSEND bit */
    i2c_flag_clear(I2C1, I2C_FLAG_ADDSEND);

    for(i = 0; i < 15; i++) {
        /* send a data byte */
        i2c_data_transmit(I2C1, i2c_transmitter[i]);
        /* wait until the transmission data register is empty */
        while(!i2c_flag_get(I2C1, I2C_FLAG_TBE));
        /* wait until the RBNE bit is set */
        while(!i2c_flag_get(I2C0, I2C_FLAG_RBNE));
        /* read a data from I2C_DATA */
        i2c_receiver[i] = i2c_data_receive(I2C0);
    }
    /* send a NACK for the last data byte */
    i2c_ack_config(I2C0, I2C_ACK_DISABLE);
    /* send a data byte */
    i2c_data_transmit(I2C1, i2c_transmitter[i]);
    /* wait until the transmission data register is empty */
    while(!i2c_flag_get(I2C1, I2C_FLAG_TBE));
    /* the master doesn't acknowledge for the last byte */
    while(!i2c_flag_get(I2C1, I2C_FLAG_AERR));
    /* send a stop condition to I2C bus */
    i2c_stop_on_bus(I2C0);
    while(I2C_CTL0(I2C0) & 0x0200);
    i2c_receiver[i] = i2c_data_receive(I2C0);
    i2c_ack_config(I2C0, I2C_ACK_ENABLE);
    /* clear the bit of AE */
    i2c_flag_clear(I2C1, I2C_FLAG_AERR);

    /* compare the transmit buffer and the receive buffer */
    state = memory_compare(i2c_transmitter, i2c_receiver, 16);
    /* if success, LED2 and LED3 are on */
    if(SUCCESS == state) {
        gd_eval_led_on(LED2);
        gd_eval_led_on(LED3);
    } else {
        /* if failed, LED2 and LED3 are off */
        gd_eval_led_off(LED2);
        gd_eval_led_off(LED3);
    }
    while(1) {
    }
}

void rcu_config(void)
{
    /* enable GPIOB clock */
    rcu_periph_clock_enable(RCU_GPIOB);
    /* enable I2C1 clock */
    rcu_periph_clock_enable(RCU_I2C1);
    /* enable I2C0 clock */
    rcu_periph_clock_enable(RCU_I2C0);
}

void gpio_config(void)
{
    /* connect PB6 to I2C0_SCL */
    /* connect PB7 to I2C0_SDA */
    /* connect PB10 to I2C1_SCL */
    /* connect PB11 to I2C1_SDA */
    gpio_init(GPIOB, GPIO_MODE_AF_OD, GPIO_OSPEED_50MHZ, GPIO_PIN_6 | GPIO_PIN_7 | GPIO_PIN_10 | GPIO_PIN_11);
}

void i2c_config(void)
{
    /* I2C clock configure */
    i2c_clock_config(I2C0, 1000000, I2C_DTCY_16_9);
    /* I2C address configure */
    i2c_mode_addr_config(I2C0, I2C_I2CMODE_ENABLE, I2C_ADDFORMAT_7BITS, I2C0_SLAVE_ADDRESS7);
    /* enable I2C0 */
    i2c_enable(I2C0);
    /* enable acknowledge */
    i2c_ack_config(I2C0, I2C_ACK_ENABLE);
    i2c_clock_config(I2C1, 1000000, I2C_DTCY_16_9);
    /* I2C address configure */
    i2c_mode_addr_config(I2C1, I2C_I2CMODE_ENABLE, I2C_ADDFORMAT_7BITS, I2C1_SLAVE_ADDRESS7);
    /* enable I2C1 */
    i2c_enable(I2C1);
    /* enable acknowledge */
    i2c_ack_config(I2C1, I2C_ACK_ENABLE);
}

代码讲解

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

I2C 配置：设置通信速率（标准 100K / 快速 400K / 快速+ 1M）、从机地址、时钟拉伸。

实验现象

主机和从机完成数据收发
校验通过 LED 指示成功

注意事项

I2C 总线需要上拉电阻（一般 4.7K）
从机地址要与设备手册一致（注意 7 位/8 位地址的区别）
写 EEPROM 后需要等待 5ms 以上再读

GD32 I2C — I2C 从机发送

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

I2C — I2C 从机发送

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

功能简介

本示例演示 I2C 总线通信。I2C 只需两根线（SCL+SDA）就能连接多个设备，是最常用的低速通信总线。

硬件准备

I2C 从设备（如 EEPROM、传感器模块）
SCL/SDA 线上需要 4.7K 上拉电阻

完整代码

#include "gd32f30x.h"
#define I2C_10BIT_ADDRESS      0
#define I2C0_OWN_ADDRESS7      0x82
#define I2C0_SLAVE_ADDRESS7    0x72
#define I2C0_OWN_ADDRESS10     0x0322

void rcu_config(void);
void gpio_config(void);
void i2c_config(void);

/*!
    \brief      main function
    \param[in]  none
    \param[out] none
    \retval     none
*/
int main(void)
{
    uint8_t i;

    /* cofigure RCU */
    rcu_config();
    /* cofigure GPIO */
    gpio_config();
    /* cofigure I2C */
    i2c_config();

    for(i = 0; i < 16; i++) {
        i2c_transmitter[i] = i + 0x80;
    }

#if I2C_10BIT_ADDRESS
    /* wait until ADDSEND bit is set */
    while(!i2c_flag_get(I2C0, I2C_FLAG_ADDSEND));
    /* clear ADDSEND bit */
    i2c_flag_clear(I2C0, I2C_FLAG_ADDSEND);
    /* wait until ADDSEND bit is set */
    while(!i2c_flag_get(I2C0, I2C_FLAG_ADDSEND));
    /* clear ADDSEND bit */
    i2c_flag_clear(I2C0, I2C_FLAG_ADDSEND);
#else
    /* wait until ADDSEND bit is set */
    while(!i2c_flag_get(I2C0, I2C_FLAG_ADDSEND));
    /* clear ADDSEND bit */
    i2c_flag_clear(I2C0, I2C_FLAG_ADDSEND);
#endif
    /* wait until the transmission data register is empty */
    while(!i2c_flag_get(I2C0, I2C_FLAG_TBE));

    for(i = 0; i < 16; i++) {
        /* send a data byte */
        i2c_data_transmit(I2C0, i2c_transmitter[i]);
        /* wait until the transmission data register is empty */
        while(!i2c_flag_get(I2C0, I2C_FLAG_TBE));
    }
    /* the master doesn't acknowledge for the last byte */
    while(!i2c_flag_get(I2C0, I2C_FLAG_AERR));
    /* clear the bit of AERR */
    i2c_flag_clear(I2C0, I2C_FLAG_AERR);

    while(1) {
    }
}

void rcu_config(void)
{
    /* enable GPIOB clock */
    rcu_periph_clock_enable(RCU_GPIOB);
    /* enable I2C0 clock */
    rcu_periph_clock_enable(RCU_I2C0);
}

void gpio_config(void)
{
    /* connect PB6 to I2C0_SCL */
    /* connect PB7 to I2C0_SDA */
    gpio_init(GPIOB, GPIO_MODE_AF_OD, GPIO_OSPEED_50MHZ, GPIO_PIN_6 | GPIO_PIN_7);
}

void i2c_config(void)
{
    /* cofigure I2C clock */
    i2c_clock_config(I2C0, 400000, I2C_DTCY_2);
    /* cofigure I2C address */
#if I2C_10BIT_ADDRESS
    i2c_mode_addr_config(I2C0, I2C_I2CMODE_ENABLE, I2C_ADDFORMAT_10BITS, I2C0_OWN_ADDRESS10);
#else
    i2c_mode_addr_config(I2C0, I2C_I2CMODE_ENABLE, I2C_ADDFORMAT_7BITS, I2C0_OWN_ADDRESS7);
#endif
    /* enable I2C0 */
    i2c_enable(I2C0);
    /* enable acknowledge */
    i2c_ack_config(I2C0, I2C_ACK_ENABLE);
}

代码讲解

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

I2C 配置：设置通信速率（标准 100K / 快速 400K / 快速+ 1M）、从机地址、时钟拉伸。

实验现象

主机和从机完成数据收发
校验通过 LED 指示成功

注意事项

I2C 总线需要上拉电阻（一般 4.7K）
从机地址要与设备手册一致（注意 7 位/8 位地址的区别）
写 EEPROM 后需要等待 5ms 以上再读

GD32 I2C — I2C 从机接收

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

I2C — I2C 从机接收

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

功能简介

本示例演示 I2C 总线通信。I2C 只需两根线（SCL+SDA）就能连接多个设备，是最常用的低速通信总线。

硬件准备

I2C 从设备（如 EEPROM、传感器模块）
SCL/SDA 线上需要 4.7K 上拉电阻

完整代码

#include "gd32f30x.h"
#define I2C0_OWN_ADDRESS7      0x82

void rcu_config(void);
void gpio_config(void);
void i2c_config(void);

/*!
    \brief      main function
    \param[in]  none
    \param[out] none
    \retval     none
*/
int main(void)
{
    uint8_t i;

    /* cofigure RCU */
    rcu_config();
    /* cofigure GPIO */
    gpio_config();
    /* cofigure I2C */
    i2c_config();

    i = 0;
    /* wait until ADDSEND bit is set */
    while(!i2c_flag_get(I2C0, I2C_FLAG_ADDSEND));
    /* clear ADDSEND bit */
    i2c_flag_clear(I2C0, I2C_FLAG_ADDSEND);
    for(i = 0; i < 16; i++) {
        /* wait until the RBNE bit is set */
        while(!i2c_flag_get(I2C0, I2C_FLAG_RBNE));

        /* read a data byte from I2C_DATA */
        i2c_receiver[i] = i2c_data_receive(I2C0);
    }
    /* wait until the STPDET bit is set */
    while(!i2c_flag_get(I2C0, I2C_FLAG_STPDET));
    /* clear the STPDET bit */
    i2c_enable(I2C0);

    while(1) {
    }
}

void rcu_config(void)
{
    /* enable GPIOB clock */
    rcu_periph_clock_enable(RCU_GPIOB);
    /* enable I2C0 clock */
    rcu_periph_clock_enable(RCU_I2C0);
}

void gpio_config(void)
{
    /* connect PB6 to I2C0_SCL */
    /* connect PB7 to I2C0_SDA */
    gpio_init(GPIOB, GPIO_MODE_AF_OD, GPIO_OSPEED_50MHZ, GPIO_PIN_6 | GPIO_PIN_7);
}

void i2c_config(void)
{
    /* cofigure I2C clock */
    i2c_clock_config(I2C0, 100000, I2C_DTCY_2);
    /* cofigure I2C address */
    i2c_mode_addr_config(I2C0, I2C_I2CMODE_ENABLE, I2C_ADDFORMAT_7BITS, I2C0_OWN_ADDRESS7);
    /* enable I2C0 */
    i2c_enable(I2C0);
    /* enable acknowledge */
    i2c_ack_config(I2C0, I2C_ACK_ENABLE);
}

代码讲解

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

I2C 配置：设置通信速率（标准 100K / 快速 400K / 快速+ 1M）、从机地址、时钟拉伸。

实验现象

主机和从机完成数据收发
校验通过 LED 指示成功

注意事项

I2C 总线需要上拉电阻（一般 4.7K）
从机地址要与设备手册一致（注意 7 位/8 位地址的区别）
写 EEPROM 后需要等待 5ms 以上再读

GD32 I2C — I2C 主发从收

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

I2C — I2C 主发从收

固件库: GD32F30x_Firmware_Library V3.0.3
芯片: GD32
源文件: GD32F30x_Firmware_Library_V3.0.3/Examples/I2C/Master_transmitter&slave_receiver/main.c

功能简介

本示例演示 I2C 总线通信。I2C 只需两根线（SCL+SDA）就能连接多个设备，是最常用的低速通信总线。

硬件准备

I2C 从设备（如 EEPROM、传感器模块）
SCL/SDA 线上需要 4.7K 上拉电阻

完整代码

#include "gd32f30x.h"
#include <stdio.h>
#include "gd32f307c_eval.h"
#define I2C0_SLAVE_ADDRESS7    0x82
#define I2C1_SLAVE_ADDRESS7    0x72

void rcu_config(void);
void gpio_config(void);
void i2c_config(void);
ErrStatus memory_compare(uint8_t *src, uint8_t *dst, uint16_t length);

/*!
    \brief      main function
    \param[in]  none
    \param[out] none
    \retval     none
*/
int main(void)
{
    uint8_t i;
    gd_eval_led_init(LED2);
    gd_eval_led_init(LED3);
    rcu_config();
    gpio_config();
    i2c_config();

    for(i = 0; i < 16; i++) {
        i2c_transmitter[i] = i + 0x80;
    }

    /* wait until I2C bus is idle */
    while(i2c_flag_get(I2C0, I2C_FLAG_I2CBSY));

    /* send a start condition to I2C bus */
    i2c_start_on_bus(I2C0);

    /* wait until SBSEND bit is set */
    while(!i2c_flag_get(I2C0, I2C_FLAG_SBSEND));

    /* send slave address to I2C bus*/
    i2c_master_addressing(I2C0, I2C1_SLAVE_ADDRESS7, I2C_TRANSMITTER);

    /* wait until ADDSEND bit is set*/
    while(!i2c_flag_get(I2C0, I2C_FLAG_ADDSEND));
    while(!i2c_flag_get(I2C1, I2C_FLAG_ADDSEND));
    /* clear ADDSEND bit */
    i2c_flag_clear(I2C0, I2C_FLAG_ADDSEND);
    i2c_flag_clear(I2C1, I2C_FLAG_ADDSEND);
    for(i = 0; i < 16; i++) {
        /* send a data byte */
        i2c_data_transmit(I2C0, i2c_transmitter[i]);
        /* wait until the transmission data register is empty*/
        while(!i2c_flag_get(I2C0, I2C_FLAG_TBE));
        /* wait until the RBNE bit is set */
        while(!i2c_flag_get(I2C1, I2C_FLAG_RBNE));
        /* read a data from I2C_DATA */
        i2c_receiver[i] = i2c_data_receive(I2C1);
    }
    /* send a stop condition to I2C bus*/
    i2c_stop_on_bus(I2C0);
    /* wait until stop condition generate */
    while(I2C_CTL0(I2C0) & 0x0200);
    while(!i2c_flag_get(I2C1, I2C_FLAG_STPDET));
    /* clear the STPDET bit */
    i2c_enable(I2C1);
    state = memory_compare(i2c_transmitter, i2c_receiver, 16);
    if(SUCCESS == state) {
        gd_eval_led_on(LED2);
        gd_eval_led_on(LED3);
    } else {
        gd_eval_led_off(LED2);
        gd_eval_led_off(LED3);
    }
    while(1);
}

void rcu_config(void)
{
    /* enable GPIOB clock */
    rcu_periph_clock_enable(RCU_GPIOB);
    /* enable I2C1 clock */
    rcu_periph_clock_enable(RCU_I2C1);
    /* enable I2C0 clock */
    rcu_periph_clock_enable(RCU_I2C0);
}

void gpio_config(void)
{
    /* connect PB6 to I2C0_SCL */
    /* connect PB7 to I2C0_SDA */
    /* connect PB10 to I2C1_SCL */
    /* connect PB11 to I2C1_SDA */
    gpio_init(GPIOB, GPIO_MODE_AF_OD, GPIO_OSPEED_50MHZ, GPIO_PIN_6 | GPIO_PIN_7 | GPIO_PIN_10 | GPIO_PIN_11);
}

void i2c_config(void)
{
    /* configure I2C0 clock */
    i2c_clock_config(I2C0, 100000, I2C_DTCY_2);
    /* configure I2C0 address */
    i2c_mode_addr_config(I2C0, I2C_I2CMODE_ENABLE, I2C_ADDFORMAT_7BITS, I2C0_SLAVE_ADDRESS7);
    /* enable I2C0 */
    i2c_enable(I2C0);
    /* enable acknowledge */
    i2c_ack_config(I2C0, I2C_ACK_ENABLE);
    /* configure I2C1 clock */
    i2c_clock_config(I2C1, 100000, I2C_DTCY_2);
    /* configure I2C1 address */
    i2c_mode_addr_config(I2C1, I2C_I2CMODE_ENABLE, I2C_ADDFORMAT_7BITS, I2C1_SLAVE_ADDRESS7);
    /* enable I2C1 */
    i2c_enable(I2C1);
    /* enable acknowledge */
    i2c_ack_config(I2C1, I2C_ACK_ENABLE);
}

代码讲解

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

I2C 配置：设置通信速率（标准 100K / 快速 400K / 快速+ 1M）、从机地址、时钟拉伸。

实验现象

主机和从机完成数据收发
校验通过 LED 指示成功

注意事项

I2C 总线需要上拉电阻（一般 4.7K）
从机地址要与设备手册一致（注意 7 位/8 位地址的区别）
写 EEPROM 后需要等待 5ms 以上再读

GD32 I2C — I2C 主发从收 DMA

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

I2C — I2C 主发从收 DMA

固件库: GD32F30x_Firmware_Library V3.0.3
芯片: GD32
源文件: GD32F30x_Firmware_Library_V3.0.3/Examples/I2C/Master_transmitter&slave_receiver_dma/main.c

功能简介

本示例演示 I2C + DMA 通信。大数据量传输时，DMA 可以大幅降低 CPU 负载。

硬件准备

I2C 从设备（如 EEPROM、传感器模块）
SCL/SDA 线上需要 4.7K 上拉电阻

完整代码

#include "gd32f30x.h"
#include <stdio.h>
#include "gd32f307c_eval.h"
#define I2C0_SLAVE_ADDRESS7      0x82
#define I2C1_SLAVE_ADDRESS7      0x72
#define ARRAYNUM(arr_nanme)      (uint32_t)(sizeof(arr_nanme) / sizeof(*(arr_nanme)))
#define I2C0_DATA_ADDRESS        0x40005410
#define I2C1_DATA_ADDRESS        0x40005810
#define BUFFER_SIZE              (ARRAYNUM(i2c0_buff_tx)-1)

void rcu_config(void);
void gpio_config(void);
void i2c_config(void);
ErrStatus memory_compare(uint8_t *src, uint8_t *dst, uint16_t length);

/*!
    \brief      main function
    \param[in]  none
    \param[out] none
    \retval     none
*/
int main(void)
{
    dma_parameter_struct dma_init_struct;

    gd_eval_led_init(LED2);
    gd_eval_led_init(LED3);
    rcu_config();
    gpio_config();
    i2c_config();

    /* initialize DMA channel4 */
    dma_deinit(DMA0, DMA_CH4);
    dma_struct_para_init(&dma_init_struct);

    dma_init_struct.direction = DMA_PERIPHERAL_TO_MEMORY;
    dma_init_struct.memory_addr = (uint32_t)i2c1_buff_rx;
    dma_init_struct.memory_inc = DMA_MEMORY_INCREASE_ENABLE;
    dma_init_struct.memory_width = DMA_MEMORY_WIDTH_8BIT;
    dma_init_struct.number = BUFFER_SIZE;
    dma_init_struct.periph_addr = I2C1_DATA_ADDRESS;
    dma_init_struct.periph_inc = DMA_PERIPH_INCREASE_DISABLE;
    dma_init_struct.periph_width = DMA_PERIPHERAL_WIDTH_8BIT;
    dma_init_struct.priority = DMA_PRIORITY_ULTRA_HIGH;
    dma_init(DMA0, DMA_CH4, &dma_init_struct);

    /* initialize DMA channel5 */
    dma_deinit(DMA0, DMA_CH5);
    dma_init_struct.direction = DMA_MEMORY_TO_PERIPHERAL;
    dma_init_struct.memory_addr = (uint32_t)i2c0_buff_tx;
    dma_init_struct.periph_addr = I2C0_DATA_ADDRESS;
    dma_init_struct.priority = DMA_PRIORITY_HIGH;
    dma_init(DMA0, DMA_CH5, &dma_init_struct);

    /* wait until I2C bus is idle */
    while(i2c_flag_get(I2C0, I2C_FLAG_I2CBSY));

    /* send a start condition to I2C bus */
    i2c_start_on_bus(I2C0);

    /* wait until SBSEND bit is set */
    while(!i2c_flag_get(I2C0, I2C_FLAG_SBSEND));

    /* send slave address to I2C bus*/
    i2c_master_addressing(I2C0, I2C1_SLAVE_ADDRESS7, I2C_TRANSMITTER);

    /* wait until ADDSEND bit is set*/
    while(!i2c_flag_get(I2C1, I2C_FLAG_ADDSEND));
    while(!i2c_flag_get(I2C0, I2C_FLAG_ADDSEND));
    /* clear ADDSEND bit */
    i2c_flag_clear(I2C0, I2C_FLAG_ADDSEND);
    i2c_flag_clear(I2C1, I2C_FLAG_ADDSEND);

    /* enable I2C1 DMA */
    i2c_dma_config(I2C1, I2C_DMA_ON);
    /* enable I2C0 DMA */
    i2c_dma_config(I2C0, I2C_DMA_ON);
    /* enable DMA0 channel4 */
    dma_channel_enable(DMA0, DMA_CH4);
    /* enable DMA0 channel5 */
    dma_channel_enable(DMA0, DMA_CH5);

    /* DMA0 channel4 full transfer finish flag */
    while(!dma_flag_get(DMA0, DMA_CH4, DMA_FLAG_FTF));
    /* DMA0 channel5 full transfer finish flag */
    while(!dma_flag_get(DMA0, DMA_CH5, DMA_FLAG_FTF));

    /* send a stop condition to I2C bus*/
    i2c_stop_on_bus(I2C0);
    /* wait until stop condition generate */
    while(I2C_CTL0(I2C0) & 0x0200);
    while(!i2c_flag_get(I2C1, I2C_FLAG_STPDET));
    /* clear the STPDET bit */
    i2c_enable(I2C1);
    state = memory_compare(i2c0_buff_tx, i2c1_buff_rx, BUFFER_SIZE);
    if(SUCCESS == state) {
        gd_eval_led_on(LED2);
        gd_eval_led_on(LED3);
    } else {
        gd_eval_led_off(LED2);
        gd_eval_led_off(LED3);
    }
    while(1) {
    }
}

void rcu_config(void)
{
    /* enable GPIOB clock */
    rcu_periph_clock_enable(RCU_GPIOB);
    /* enable I2C1 clock */
    rcu_periph_clock_enable(RCU_I2C1);
    /* enable I2C0 clock */
    rcu_periph_clock_enable(RCU_I2C0);
    /* enable DMA0 clock */
    rcu_periph_clock_enable(RCU_DMA0);
}

void gpio_config(void)
{
    /* connect PB6 to I2C0_SCL */
    /* connect PB7 to I2C0_SDA */
    /* connect PB10 to I2C1_SCL */
    /* connect PB11 to I2C1_SDA */
    gpio_init(GPIOB, GPIO_MODE_AF_OD, GPIO_OSPEED_50MHZ, GPIO_PIN_6 | GPIO_PIN_7 | GPIO_PIN_10 | GPIO_PIN_11);
}

void i2c_config(void)
{
    /* configure I2C0 clock */
    i2c_clock_config(I2C0, 100000, I2C_DTCY_2);
    /* configure I2C0 address */
    i2c_mode_addr_config(I2C0, I2C_I2CMODE_ENABLE, I2C_ADDFORMAT_7BITS, I2C0_SLAVE_ADDRESS7);
    /* enable I2C0 */
    i2c_enable(I2C0);
    /* enable acknowledge */
    i2c_ack_config(I2C0, I2C_ACK_ENABLE);
    /* configure I2C1 clock */
    i2c_clock_config(I2C1, 100000, I2C_DTCY_2);
    /* configure I2C1 address */
    i2c_mode_addr_config(I2C1, I2C_I2CMODE_ENABLE, I2C_ADDFORMAT_7BITS, I2C1_SLAVE_ADDRESS7);
    /* enable I2C1 */
    i2c_enable(I2C1);
    /* enable acknowledge */
    i2c_ack_config(I2C1, I2C_ACK_ENABLE);
}

代码讲解

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

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

I2C 配置：设置通信速率（标准 100K / 快速 400K / 快速+ 1M）、从机地址、时钟拉伸。

实验现象

主机和从机完成数据收发
校验通过 LED 指示成功

注意事项

I2C 总线需要上拉电阻（一般 4.7K）
从机地址要与设备手册一致（注意 7 位/8 位地址的区别）
写 EEPROM 后需要等待 5ms 以上再读

GD32 I2C — I2C 主发从收中断

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

I2C — I2C 主发从收中断

固件库: GD32F30x_Firmware_Library V3.0.3
芯片: GD32
源文件: GD32F30x_Firmware_Library_V3.0.3/Examples/I2C/Master_transmitter&slave_receiver_interrupt/main.c

功能简介

本示例演示 I2C 中断方式通信。每完成一个字节触发中断，CPU 在中断中处理后续操作，效率更高。

硬件准备

I2C 从设备（如 EEPROM、传感器模块）
SCL/SDA 线上需要 4.7K 上拉电阻

完整代码

#include "gd32f30x.h"
#include <stdio.h>
#include "I2C_IE.h"
#include "gd32f307c_eval.h"

void rcu_config(void);
void gpio_config(void);
void i2c_config(void);
void i2c_nvic_config(void);
ErrStatus memory_compare(uint8_t *src, uint8_t *dst, uint16_t length);

/*!
    \brief      main function
    \param[in]  none
    \param[out] none
    \retval     none
*/
int main(void)
{
    uint8_t i;

    /* initialize LED2, LED3, as the transfer instruction */
    gd_eval_led_init(LED2);
    gd_eval_led_init(LED3);
    rcu_config();
    gpio_config();
    i2c_config();
    i2c_nvic_config();

    for(i = 0; i < 16; i++) {
        i2c_buffer_transmitter[i] = i + 0x80;
    }
    /* initialize i2c_txbuffer, i2c_rxbuffer, I2C_nBytes and status */
    i2c_txbuffer = i2c_buffer_transmitter;
    i2c_rxbuffer = i2c_buffer_receiver;
    I2C_nBytes = 16;
    status = ERROR;

    /* enable the I2C0 interrupt */
    i2c_interrupt_enable(I2C0, I2C_INT_ERR);
    i2c_interrupt_enable(I2C0, I2C_INT_BUF);
    i2c_interrupt_enable(I2C0, I2C_INT_EV);
    /* enable the I2C1 interrupt */
    i2c_interrupt_enable(I2C1, I2C_INT_ERR);
    i2c_interrupt_enable(I2C1, I2C_INT_BUF);
    i2c_interrupt_enable(I2C1, I2C_INT_EV);

    /* the master waits until the I2C bus is idle */
    while(i2c_flag_get(I2C0, I2C_FLAG_I2CBSY));

    /* the master sends a start condition to I2C bus */
    i2c_start_on_bus(I2C0);

    while((I2C_nBytes > 0));
    while(SUCCESS != status);
    /* if the transfer is successfully completed, LED2 and LED3 is on */
    state = memory_compare(i2c_buffer_transmitter, i2c_buffer_receiver, 16);
    if(SUCCESS == state) {
        /* if success, LED2 and LED3 are on */
        gd_eval_led_on(LED2);
        gd_eval_led_on(LED3);
    } else {
        /* if failed, LED2 and LED3 are off */
        gd_eval_led_off(LED2);
        gd_eval_led_off(LED3);
    }
    while(1) {
    }
}

void rcu_config(void)
{
    /* enable GPIOB clock */
    rcu_periph_clock_enable(RCU_GPIOB);
    /* enable I2C1 clock */
    rcu_periph_clock_enable(RCU_I2C1);
    /* enable I2C0 clock */
    rcu_periph_clock_enable(RCU_I2C0);
}

void gpio_config(void)
{
    /* connect PB6 to I2C0_SCL */
    /* connect PB7 to I2C0_SDA */
    /* connect PB10 to I2C1_SCL */
    /* connect PB11 to I2C1_SDA */
    gpio_init(GPIOB, GPIO_MODE_AF_OD, GPIO_OSPEED_50MHZ, GPIO_PIN_6 | GPIO_PIN_7 | GPIO_PIN_10 | GPIO_PIN_11);
}

void i2c_config(void)
{
    /* configure I2C clock */
    i2c_clock_config(I2C0, 100000, I2C_DTCY_2);
    /* configure I2C address */
    i2c_mode_addr_config(I2C0, I2C_I2CMODE_ENABLE, I2C_ADDFORMAT_7BITS, I2C0_SLAVE_ADDRESS7);
    /* enable I2C0 */
    i2c_enable(I2C0);
    /* enable acknowledge */
    i2c_ack_config(I2C0, I2C_ACK_ENABLE);
    i2c_clock_config(I2C1, 100000, I2C_DTCY_2);
    /* configure I2C address */
    i2c_mode_addr_config(I2C1, I2C_I2CMODE_ENABLE, I2C_ADDFORMAT_7BITS, I2C1_SLAVE_ADDRESS7);
    /* enable I2C1 */
    i2c_enable(I2C1);
    /* enable acknowledge */
    i2c_ack_config(I2C1, I2C_ACK_ENABLE);
}

void i2c_nvic_config(void)
{
    nvic_priority_group_set(NVIC_PRIGROUP_PRE1_SUB3);
    nvic_irq_enable(I2C0_EV_IRQn, 0, 3);
    nvic_irq_enable(I2C1_EV_IRQn, 0, 4);
    nvic_irq_enable(I2C0_ER_IRQn, 0, 2);
    nvic_irq_enable(I2C1_ER_IRQn, 0, 1);
}

代码讲解

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

I2C 配置：设置通信速率（标准 100K / 快速 400K / 快速+ 1M）、从机地址、时钟拉伸。

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

实验现象

主机和从机完成数据收发
校验通过 LED 指示成功

注意事项

I2C 总线需要上拉电阻（一般 4.7K）
从机地址要与设备手册一致（注意 7 位/8 位地址的区别）
写 EEPROM 后需要等待 5ms 以上再读

GD32 I2C — I2C 主机发送

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

I2C — I2C 主机发送

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

功能简介

本示例演示 I2C 总线通信。I2C 只需两根线（SCL+SDA）就能连接多个设备，是最常用的低速通信总线。

硬件准备

I2C 从设备（如 EEPROM、传感器模块）
SCL/SDA 线上需要 4.7K 上拉电阻

完整代码

#include "gd32f30x.h"
#define I2C0_OWN_ADDRESS7      0x72
#define I2C0_SLAVE_ADDRESS7    0x82

void rcu_config(void);
void gpio_config(void);
void i2c_config(void);

/*!
    \brief      main function
    \param[in]  none
    \param[out] none
    \retval     none
*/
int main(void)
{
    uint8_t i;

    /* cofigure RCU */
    rcu_config();
    /* cofigure GPIO */
    gpio_config();
    /* cofigure I2C */
    i2c_config();

    for(i = 0; i < 16; i++) {
        i2c_transmitter[i] = i + 0x80;
    }

    /* wait until I2C bus is idle */
    while(i2c_flag_get(I2C0, I2C_FLAG_I2CBSY));
    /* send a start condition to I2C bus */
    i2c_start_on_bus(I2C0);
    /* wait until SBSEND bit is set */
    while(!i2c_flag_get(I2C0, I2C_FLAG_SBSEND));
    /* send slave address to I2C bus */
    i2c_master_addressing(I2C0, I2C0_SLAVE_ADDRESS7, I2C_TRANSMITTER);
    /* wait until ADDSEND bit is set */
    while(!i2c_flag_get(I2C0, I2C_FLAG_ADDSEND));
    /* clear ADDSEND bit */
    i2c_flag_clear(I2C0, I2C_FLAG_ADDSEND);
    /* wait until the transmit data buffer is empty */
    while(!i2c_flag_get(I2C0, I2C_FLAG_TBE));

    for(i = 0; i < 16; i++) {
        /* data transmission */
        i2c_data_transmit(I2C0, i2c_transmitter[i]);
        /* wait until the TBE bit is set */
        while(!i2c_flag_get(I2C0, I2C_FLAG_TBE));
    }
    /* send a stop condition to I2C bus */
    i2c_stop_on_bus(I2C0);
    /* wait until stop condition generate */
    while(I2C_CTL0(I2C0) & 0x0200);

    /* infinite loop */
    while(1) {
    }
}

void rcu_config(void)
{
    /* enable GPIOB clock */
    rcu_periph_clock_enable(RCU_GPIOB);
    /* enable I2C0 clock */
    rcu_periph_clock_enable(RCU_I2C0);
}

void gpio_config(void)
{
    /* connect PB6 to I2C0_SCL */
    /* connect PB7 to I2C0_SDA */
    gpio_init(GPIOB, GPIO_MODE_AF_OD, GPIO_OSPEED_50MHZ, GPIO_PIN_6 | GPIO_PIN_7);
}

void i2c_config(void)
{
    /* cofigure I2C clock */
    i2c_clock_config(I2C0, 100000, I2C_DTCY_2);
    /* cofigure I2C address */
    i2c_mode_addr_config(I2C0, I2C_I2CMODE_ENABLE, I2C_ADDFORMAT_7BITS, I2C0_OWN_ADDRESS7);
    /* enable I2C0 */
    i2c_enable(I2C0);
    /* enable acknowledge */
    i2c_ack_config(I2C0, I2C_ACK_ENABLE);
}

代码讲解

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

I2C 配置：设置通信速率（标准 100K / 快速 400K / 快速+ 1M）、从机地址、时钟拉伸。

实验现象

主机和从机完成数据收发
校验通过 LED 指示成功

注意事项

I2C 总线需要上拉电阻（一般 4.7K）
从机地址要与设备手册一致（注意 7 位/8 位地址的区别）
写 EEPROM 后需要等待 5ms 以上再读

GD32 I2C — I2C 主机接收

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

I2C — I2C 主机接收

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

功能简介

本示例演示 I2C 总线通信。I2C 只需两根线（SCL+SDA）就能连接多个设备，是最常用的低速通信总线。

硬件准备

I2C 从设备（如 EEPROM、传感器模块）
SCL/SDA 线上需要 4.7K 上拉电阻

完整代码

#include "gd32f30x.h"
#define I2C_10BIT_ADDRESS      0
#define I2C0_OWN_ADDRESS7      0x72
#define I2C0_SLAVE_ADDRESS7    0x82
#define I2C0_SLAVE_ADDRESS10   0x0322

void rcu_config(void);
void gpio_config(void);
void i2c_config(void);

/*!
    \brief      main function
    \param[in]  none
    \param[out] none
    \retval     none
*/
int main(void)
{
    uint8_t i;
#if I2C_10BIT_ADDRESS
    uint8_t slave10_first_byte, slave10_second_byte;
#endif

    /* configure RCU  */
    rcu_config();
    /* configure GPIO */
    gpio_config();
    /* configure I2C */
    i2c_config();

    /* wait until I2C bus is idle */
    while(i2c_flag_get(I2C0, I2C_FLAG_I2CBSY));
    /* send a start condition to I2C bus */
    i2c_start_on_bus(I2C0);
    /* wait until SBSEND bit is set */
    while(!i2c_flag_get(I2C0, I2C_FLAG_SBSEND));

#if I2C_10BIT_ADDRESS
    slave10_first_byte = (0xF0) | (uint8_t)((I2C0_SLAVE_ADDRESS10 & 0x0300) >> 7);
    /* send slave address first byte to I2C bus */
    i2c_master_addressing(I2C0, slave10_first_byte, I2C_TRANSMITTER);
    /* wait until ADD10SEND bit is set */
    while(!i2c_flag_get(I2C0, I2C_FLAG_ADD10SEND));
    /* the second byte contains the remaining 8 bits of the 10-bit address */
    slave10_second_byte = (uint8_t)(I2C0_SLAVE_ADDRESS10 & 0x00FF);
    /* send slave address 2nd byte to I2C bus */
    i2c_master_addressing(I2C0, slave10_second_byte, I2C_TRANSMITTER);
    /* wait until ADDSEND bit is set */
    while(!i2c_flag_get(I2C0, I2C_FLAG_ADDSEND));
    /* clear ADDSEND bit */
    i2c_flag_clear(I2C0, I2C_FLAG_ADDSEND);
    /* send a start condition to I2C bus */
    i2c_start_on_bus(I2C0);
    /* wait until SBSEND bit is set */
    while(!i2c_flag_get(I2C0, I2C_FLAG_SBSEND));
    /* send slave address first byte to I2C bus */
    i2c_master_addressing(I2C0, slave10_first_byte, I2C_RECEIVER);
#else
    /* send slave address to I2C bus */
    i2c_master_addressing(I2C0, I2C0_SLAVE_ADDRESS7, I2C_RECEIVER);
#endif
    /* wait until ADDSEND bit is set */
    while(!i2c_flag_get(I2C0, I2C_FLAG_ADDSEND));
    /* clear ADDSEND bit */
    i2c_flag_clear(I2C0, I2C_FLAG_ADDSEND);

    for(i = 0; i < 16; i++) {
        if(13 == i) {
            /* wait until the second last data byte is received into the shift register */
            while(!i2c_flag_get(I2C0, I2C_FLAG_BTC));
            /* disable acknowledge */
            i2c_ack_config(I2C0, I2C_ACK_DISABLE);
        }
        /* wait until the RBNE bit is set */
        while(!i2c_flag_get(I2C0, I2C_FLAG_RBNE));
        /* read a data from I2C_DATA */
        i2c_receiver[i] = i2c_data_receive(I2C0);
    }
    /* send a stop condition to I2C bus */
    i2c_stop_on_bus(I2C0);
    /* wait until stop condition generate */
    while(I2C_CTL0(I2C0) & 0x0200);
    /* enable acknowledge */
    i2c_ack_config(I2C0, I2C_ACK_ENABLE);

    while(1) {
    }
}

void rcu_config(void)
{
    /* enable GPIOB clock */
    rcu_periph_clock_enable(RCU_GPIOB);
    /* enable I2C0 clock */
    rcu_periph_clock_enable(RCU_I2C0);
}

void gpio_config(void)
{
    /* connect PB6 to I2C0_SCL */
    /* connect PB7 to I2C0_SDA */
    gpio_init(GPIOB, GPIO_MODE_AF_OD, GPIO_OSPEED_50MHZ, GPIO_PIN_6 | GPIO_PIN_7);
}

void i2c_config(void)
{
    /* configure I2C clock */
    i2c_clock_config(I2C0, 400000, I2C_DTCY_2);
    /* configure I2C address */
    i2c_mode_addr_config(I2C0, I2C_I2CMODE_ENABLE, I2C_ADDFORMAT_7BITS, I2C0_OWN_ADDRESS7);
    /* enable I2C0 */
    i2c_enable(I2C0);
    /* enable acknowledge */
    i2c_ack_config(I2C0, I2C_ACK_ENABLE);
}

代码讲解

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

I2C 配置：设置通信速率（标准 100K / 快速 400K / 快速+ 1M）、从机地址、时钟拉伸。

实验现象

主机和从机完成数据收发
校验通过 LED 指示成功

注意事项

I2C 总线需要上拉电阻（一般 4.7K）
从机地址要与设备手册一致（注意 7 位/8 位地址的区别）
写 EEPROM 后需要等待 5ms 以上再读

GD32 I2C — I2C 主机接收 1 字节

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

I2C — I2C 主机接收 1 字节

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

功能简介

本示例演示 I2C 总线通信。I2C 只需两根线（SCL+SDA）就能连接多个设备，是最常用的低速通信总线。

硬件准备

I2C 从设备（如 EEPROM、传感器模块）
SCL/SDA 线上需要 4.7K 上拉电阻

完整代码

#include "gd32f30x.h"
#define I2C0_SLAVE_ADDRESS7    0x72
#define I2C1_SLAVE_ADDRESS7    0x82

void rcu_config(void);
void gpio_config(void);
void i2c_config(void);

/*!
    \brief      main function
    \param[in]  none
    \param[out] none
    \retval     none
*/
int main(void)
{
    uint8_t i;

    /* cofigure RCU */
    rcu_config();
    /* cofigure GPIO */
    gpio_config();
    /* cofigure I2C */
    i2c_config();

    i = 0;
    /* wait until I2C bus is idle */
    while(i2c_flag_get(I2C0, I2C_FLAG_I2CBSY));
    /* send a start condition to I2C bus */
    i2c_start_on_bus(I2C0);
    /* wait until SBSEND bit is set */
    while(!i2c_flag_get(I2C0, I2C_FLAG_SBSEND));
    /* send slave address to I2C bus */
    i2c_master_addressing(I2C0, I2C1_SLAVE_ADDRESS7, I2C_RECEIVER);
    /* wait until ADDSEND bit is set */
    while(!i2c_flag_get(I2C0, I2C_FLAG_ADDSEND));

    /* N=1,reset ACKEN bit before clearing ADDRSEND bit */
    i2c_ack_config(I2C0, I2C_ACK_DISABLE);
    /* clear ADDSEND bit */
    i2c_flag_clear(I2C0, I2C_FLAG_ADDSEND);
    /* N=1,send stop condition after clearing ADDRSEND bit */
    i2c_stop_on_bus(I2C0);
    /* wait until the RBNE bit is set */
    while(!i2c_flag_get(I2C0, I2C_FLAG_RBNE));
    /* read a data from I2C_DATA */
    i2c_receiver[i++] = i2c_data_receive(I2C0);
    /* wait until stop condition generate */
    while(I2C_CTL0(I2C0) & 0x0200);
    /* Enable Acknowledge */
    i2c_ack_config(I2C0, I2C_ACK_ENABLE);

    while(1) {
    }
}

void rcu_config(void)
{
    /* enable GPIOB clock */
    rcu_periph_clock_enable(RCU_GPIOB);
    /* enable I2C0 clock */
    rcu_periph_clock_enable(RCU_I2C0);
}

void gpio_config(void)
{
    /* connect PB6 to I2C0_SCL */
    /* connect PB7 to I2C0_SDA */
    gpio_init(GPIOB, GPIO_MODE_AF_OD, GPIO_OSPEED_50MHZ, GPIO_PIN_6 | GPIO_PIN_7);
}

void i2c_config(void)
{
    /* cofigure I2C clock */
    i2c_clock_config(I2C0, 100000, I2C_DTCY_2);
    /* cofigure I2C address */
    i2c_mode_addr_config(I2C0, I2C_I2CMODE_ENABLE, I2C_ADDFORMAT_7BITS, I2C0_SLAVE_ADDRESS7);
    /* enable I2C0 */
    i2c_enable(I2C0);
    /* enable acknowledge */
    i2c_ack_config(I2C0, I2C_ACK_ENABLE);
}

代码讲解

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

I2C 配置：设置通信速率（标准 100K / 快速 400K / 快速+ 1M）、从机地址、时钟拉伸。

实验现象

主机和从机完成数据收发
校验通过 LED 指示成功

注意事项

I2C 总线需要上拉电阻（一般 4.7K）
从机地址要与设备手册一致（注意 7 位/8 位地址的区别）
写 EEPROM 后需要等待 5ms 以上再读

GD32 I2C — I2C 主机接收 2 字节

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

I2C — I2C 主机接收 2 字节

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

功能简介

本示例演示 I2C 总线通信。I2C 只需两根线（SCL+SDA）就能连接多个设备，是最常用的低速通信总线。

硬件准备

I2C 从设备（如 EEPROM、传感器模块）
SCL/SDA 线上需要 4.7K 上拉电阻

完整代码

#include "gd32f30x.h"
#define I2C0_OWN_ADDRESS7      0x72
#define I2C0_SLAVE_ADDRESS7    0x82

void rcu_config(void);
void gpio_config(void);
void i2c_config(void);

/*!
    \brief      main function
    \param[in]  none
    \param[out] none
    \retval     none
*/
int main(void)
{
    uint8_t i;

    /* cofigure RCU */
    rcu_config();
    /* cofigure GPIO */
    gpio_config();
    /* cofigure I2C */
    i2c_config();

    i = 0;
    /* send a NACK for the next data byte which will be received into the shift register */
    i2c_ackpos_config(I2C0, I2C_ACKPOS_NEXT);
    /* wait until I2C bus is idle */
    while(i2c_flag_get(I2C0, I2C_FLAG_I2CBSY));
    /* send a start condition to I2C bus */
    i2c_start_on_bus(I2C0);
    /* wait until SBSEND bit is set */
    while(!i2c_flag_get(I2C0, I2C_FLAG_SBSEND));
    /* send slave address to I2C bus */
    i2c_master_addressing(I2C0, I2C0_SLAVE_ADDRESS7, I2C_RECEIVER);
    /* disable ACK before clearing ADDSEND bit */
    i2c_ack_config(I2C0, I2C_ACK_DISABLE);
    /* wait until ADDSEND bit is set */
    while(!i2c_flag_get(I2C0, I2C_FLAG_ADDSEND));
    /* clear ADDSEND bit */
    i2c_flag_clear(I2C0, I2C_FLAG_ADDSEND);
    /* Wait until the last data byte is received into the shift register */
    while(!i2c_flag_get(I2C0, I2C_FLAG_BTC));
    /* wait until the RBNE bit is set */
    while(!i2c_flag_get(I2C0, I2C_FLAG_RBNE));

    /* read a data from I2C_DATA */
    i2c_receiver[i++] = i2c_data_receive(I2C0);
    /* wait until the RBNE bit is set */
    while(!i2c_flag_get(I2C0, I2C_FLAG_RBNE));
    /* read a data from I2C_DATA */
    i2c_receiver[i++] = i2c_data_receive(I2C0);
    /* send a stop condition */
    i2c_stop_on_bus(I2C0);
    /* wait until stop condition generate */
    while(I2C_CTL0(I2C0) & 0x0200);
    i2c_ackpos_config(I2C0, I2C_ACKPOS_CURRENT);
    /* enable acknowledge */
    i2c_ack_config(I2C0, I2C_ACK_ENABLE);

    while(1) {
    }
}

void rcu_config(void)
{
    /* enable GPIOB clock */
    rcu_periph_clock_enable(RCU_GPIOB);
    /* enable I2C0 clock */
    rcu_periph_clock_enable(RCU_I2C0);
}

void gpio_config(void)
{
    /* connect PB6 to I2C0_SCL */
    /* connect PB7 to I2C0_SDA */
    gpio_init(GPIOB, GPIO_MODE_AF_OD, GPIO_OSPEED_50MHZ, GPIO_PIN_6 | GPIO_PIN_7);
}

void i2c_config(void)
{
    /* cofigure I2C clock */
    i2c_clock_config(I2C0, 100000, I2C_DTCY_2);
    /* cofigure I2C address */
    i2c_mode_addr_config(I2C0, I2C_I2CMODE_ENABLE, I2C_ADDFORMAT_7BITS, I2C0_OWN_ADDRESS7);
    /* enable I2C0 */
    i2c_enable(I2C0);
    /* enable acknowledge */
    i2c_ack_config(I2C0, I2C_ACK_ENABLE);
}

代码讲解

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

I2C 配置：设置通信速率（标准 100K / 快速 400K / 快速+ 1M）、从机地址、时钟拉伸。

实验现象

主机和从机完成数据收发
校验通过 LED 指示成功

注意事项

I2C 总线需要上拉电阻（一般 4.7K）
从机地址要与设备手册一致（注意 7 位/8 位地址的区别）
写 EEPROM 后需要等待 5ms 以上再读

GD32 I2C — I2C 主收从发中断

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

I2C — I2C 主收从发中断

固件库: GD32F30x_Firmware_Library V3.0.3
芯片: GD32
源文件: GD32F30x_Firmware_Library_V3.0.3/Examples/I2C/Master_receiver&slave_transmitter_interrupt/main.c

功能简介

本示例演示 I2C 中断方式通信。每完成一个字节触发中断，CPU 在中断中处理后续操作，效率更高。

硬件准备

I2C 从设备（如 EEPROM、传感器模块）
SCL/SDA 线上需要 4.7K 上拉电阻

完整代码

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

void rcu_config(void);
void gpio_config(void);
void i2c_config(void);
void i2c_nvic_config(void);
ErrStatus memory_compare(uint8_t *src, uint8_t *dst, uint16_t length);

/*!
    \brief      main function
    \param[in]  none
    \param[out] none
    \retval     none
*/
int main(void)
{
    uint8_t i;

    /* initialize LED2, LED3, as the transfer instruction */
    gd_eval_led_init(LED2);
    gd_eval_led_init(LED3);
    rcu_config();
    gpio_config();
    i2c_config();
    i2c_nvic_config();

    for(i = 0; i < 16; i++) {
        i2c_buffer_transmitter[i] = i + 0x80;
    }
    /* initialize i2c_txbuffer, i2c_rxbuffer, I2C_nBytes and status */
    i2c_txbuffer = i2c_buffer_transmitter;
    i2c_rxbuffer = i2c_buffer_receiver;
    I2C_nBytes = 16;
    status = ERROR;

    /* enable the I2C0 interrupt */
    i2c_interrupt_enable(I2C0, I2C_INT_ERR);
    i2c_interrupt_enable(I2C0, I2C_INT_BUF);
    i2c_interrupt_enable(I2C0, I2C_INT_EV);
    /* enable the I2C1 interrupt */
    i2c_interrupt_enable(I2C1, I2C_INT_ERR);
    i2c_interrupt_enable(I2C1, I2C_INT_BUF);
    i2c_interrupt_enable(I2C1, I2C_INT_EV);

    if(2 == I2C_nBytes) {
        /* send ACK for the next byte */
        i2c_ackpos_config(I2C0, I2C_ACKPOS_NEXT);
    }
    /* the master waits until the I2C bus is idle */
    while(i2c_flag_get(I2C0, I2C_FLAG_I2CBSY));
    /* the master sends a start condition to I2C bus */
    i2c_start_on_bus(I2C0);

    while(I2C_nBytes > 0);
    while(SUCCESS != status);
    /* if the transfer is successfully completed, LED2 and LED3 is on */
    state = memory_compare(i2c_buffer_transmitter, i2c_buffer_receiver, 16);
    if(SUCCESS == state) {
        /* if success, LED2 and LED3 are on */
        gd_eval_led_on(LED2);
        gd_eval_led_on(LED3);
    } else {
        /* if failed, LED2 and LED3 are off */
        gd_eval_led_off(LED2);
        gd_eval_led_off(LED3);
    }
    while(1)
    {}
}

void rcu_config(void)
{
    /* enable GPIOB clock */
    rcu_periph_clock_enable(RCU_GPIOB);
    /* enable I2C1 clock */
    rcu_periph_clock_enable(RCU_I2C1);
    /* enable I2C0 clock */
    rcu_periph_clock_enable(RCU_I2C0);
}

void gpio_config(void)
{
    /* connect PB6 to I2C0_SCL */
    /* connect PB7 to I2C0_SDA */
    /* connect PB10 to I2C1_SCL */
    /* connect PB11 to I2C1_SDA */
    gpio_init(GPIOB, GPIO_MODE_AF_OD, GPIO_OSPEED_50MHZ, GPIO_PIN_6 | GPIO_PIN_7 | GPIO_PIN_10 | GPIO_PIN_11);
}

void i2c_config(void)
{
    /* configure I2C clock */
    i2c_clock_config(I2C0, 100000, I2C_DTCY_2);
    /* configure I2C address */
    i2c_mode_addr_config(I2C0, I2C_I2CMODE_ENABLE, I2C_ADDFORMAT_7BITS, I2C0_SLAVE_ADDRESS7);
    /* enable I2C0 */
    i2c_enable(I2C0);
    /* enable acknowledge */
    i2c_ack_config(I2C0, I2C_ACK_ENABLE);
    i2c_clock_config(I2C1, 100000, I2C_DTCY_2);
    /* I2C address configure */
    i2c_mode_addr_config(I2C1, I2C_I2CMODE_ENABLE, I2C_ADDFORMAT_7BITS, I2C1_SLAVE_ADDRESS7);
    /* enable I2C1 */
    i2c_enable(I2C1);
    /* enable acknowledge */
    i2c_ack_config(I2C1, I2C_ACK_ENABLE);
}

void i2c_nvic_config(void)
{
    nvic_priority_group_set(NVIC_PRIGROUP_PRE1_SUB3);
    nvic_irq_enable(I2C0_EV_IRQn, 0, 3);
    nvic_irq_enable(I2C1_EV_IRQn, 0, 4);
    nvic_irq_enable(I2C0_ER_IRQn, 0, 2);
    nvic_irq_enable(I2C1_ER_IRQn, 0, 1);
}

代码讲解

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

I2C 配置：设置通信速率（标准 100K / 快速 400K / 快速+ 1M）、从机地址、时钟拉伸。

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

实验现象

主机和从机完成数据收发
校验通过 LED 指示成功

注意事项

I2C 总线需要上拉电阻（一般 4.7K）
从机地址要与设备手册一致（注意 7 位/8 位地址的区别）
写 EEPROM 后需要等待 5ms 以上再读

PUYA — I2C 总线

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

PUYA — I2C 总线

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

什么是 I2C 总线?

I2C 只需两根线（SCL+SDA）就能连接多个设备。标准速率 100Kbps，快速模式 400Kbps。每个设备有唯一地址。

示例列表

I2C 主机中断通信 — I2C_TwoBoard_CommunicationMaster_IT
I2C 主机轮询通信 — I2C_TwoBoard_CommunicationMaster_Polling
I2C 从机中断通信 — I2C_TwoBoard_CommunicationSlave_IT

PUYA — I2C 总线

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

PUYA — I2C 总线

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

什么是 I2C 总线?

I2C 只需两根线（SCL+SDA）就能连接多个设备。标准速率 100Kbps，快速模式 400Kbps。每个设备有唯一地址。

示例列表

I2C 主机 DMA 通信 — I2C_TwoBoard_CommunicationMaster_DMA
I2C 主机 DMA 通信 (内存地址) — I2C_TwoBoard_CommunicationMaster_DMA_MEM
I2C 主机中断通信 — I2C_TwoBoard_CommunicationMaster_IT
I2C 主机轮询通信 — I2C_TwoBoard_CommunicationMaster_Polling
I2C 从机 DMA 通信 — I2C_TwoBoard_CommunicationSlave_DMA
I2C 从机中断通信 — I2C_TwoBoard_CommunicationSlave_IT

重点推荐：I2C 主机轮询通信已整理为完整教学文档，讲解地址、速率、上拉与轮询收发。

PUYA — I2C 总线

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

PUYA — I2C 总线

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

什么是 I2C 总线?

I2C 只需两根线（SCL+SDA）就能连接多个设备。标准速率 100Kbps，快速模式 400Kbps。每个设备有唯一地址。

示例列表

I2C_TwoBoard_CommunicationMaster_10BitAddr_IT — I2C_TwoBoard_CommunicationMaster_10BitAddr_IT
I2C 主机 DMA 通信 — I2C_TwoBoard_CommunicationMaster_DMA
I2C 主机 DMA 通信 (内存地址) — I2C_TwoBoard_CommunicationMaster_DMA_MEM
I2C_TwoBoard_CommunicationMaster_DualAddr_IT — I2C_TwoBoard_CommunicationMaster_DualAddr_IT
I2C 主机中断通信 — I2C_TwoBoard_CommunicationMaster_IT
I2C 主机轮询通信 — I2C_TwoBoard_CommunicationMaster_Polling
I2C_TwoBoard_CommunicationSlave_10BitAddr_IT — I2C_TwoBoard_CommunicationSlave_10BitAddr_IT
I2C 从机 DMA 通信 — I2C_TwoBoard_CommunicationSlave_DMA
I2C_TwoBoard_CommunicationSlave_DualAddr_IT — I2C_TwoBoard_CommunicationSlave_DualAddr_IT
I2C 从机中断通信 — I2C_TwoBoard_CommunicationSlave_IT

PUYA — I2C 总线

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

PUYA — I2C 总线

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

什么是 I2C 总线?

I2C 只需两根线（SCL+SDA）就能连接多个设备。标准速率 100Kbps，快速模式 400Kbps。每个设备有唯一地址。

示例列表

I2C 主机中断通信 — I2C_TwoBoard_CommunicationMaster_IT
I2C 主机轮询通信 — I2C_TwoBoard_CommunicationMaster_Polling
I2C 从机中断通信 — I2C_TwoBoard_CommunicationSlave_IT

PUYA I2C — I2C 从机 DMA 通信

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

I2C — I2C 从机 DMA 通信

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

功能简介

本示例演示 I2C + DMA 通信。大数据量传输时，DMA 可以大幅降低 CPU 负载。

硬件准备

I2C 从设备（如 EEPROM、传感器模块）
SCL/SDA 线上需要 4.7K 上拉电阻

完整代码

#include "main.h"
#define DATA_LENGTH       15                /* Length of data */
#define I2C_ADDRESS        0xA0             /* Own address 0xA0 */
#define I2C_SPEEDCLOCK   100000             /* Communication speed 100K */
#define I2C_DUTYCYCLE    I2C_DUTYCYCLE_2    /* Duty cycle */

代码讲解

I2C 配置：设置通信速率（标准 100K / 快速 400K / 快速+ 1M）、从机地址、时钟拉伸。

实验现象

主机和从机完成数据收发
校验通过 LED 指示成功

注意事项

I2C 总线需要上拉电阻（一般 4.7K）
从机地址要与设备手册一致（注意 7 位/8 位地址的区别）
写 EEPROM 后需要等待 5ms 以上再读

PUYA I2C — I2C 从机 DMA 通信

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

I2C — I2C 从机 DMA 通信

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

功能简介

本示例演示 I2C + DMA 通信。大数据量传输时，DMA 可以大幅降低 CPU 负载。

硬件准备

I2C 从设备（如 EEPROM、传感器模块）
SCL/SDA 线上需要 4.7K 上拉电阻

完整代码

#include "main.h"
#define DATA_LENGTH       15                /* Length of data */
#define I2C_ADDRESS        0xA0             /* Own address 0xA0 */
#define I2C_SPEEDCLOCK   100000             /* Communication speed 100K */
#define I2C_DUTYCYCLE    I2C_DUTYCYCLE_2    /* Duty cycle */

代码讲解

I2C 配置：设置通信速率（标准 100K / 快速 400K / 快速+ 1M）、从机地址、时钟拉伸。

实验现象

主机和从机完成数据收发
校验通过 LED 指示成功

注意事项

I2C 总线需要上拉电阻（一般 4.7K）
从机地址要与设备手册一致（注意 7 位/8 位地址的区别）
写 EEPROM 后需要等待 5ms 以上再读

PUYA I2C — I2C 从机中断通信

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

I2C — I2C 从机中断通信

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

功能简介

本示例演示 I2C 总线通信。I2C 只需两根线（SCL+SDA）就能连接多个设备，是最常用的低速通信总线。

硬件准备

I2C 从设备（如 EEPROM、传感器模块）
SCL/SDA 线上需要 4.7K 上拉电阻

完整代码

#include "main.h"
#define DATA_LENGTH       15                /* Data length*/
#define I2C_ADDRESS        0xA0             /* Local address 0xA0 */
#define I2C_SPEEDCLOCK   100000             /* Communication speed 100K */
#define I2C_DUTYCYCLE    I2C_DUTYCYCLE_16_9 /* Duty cycle */

代码讲解

I2C 配置：设置通信速率（标准 100K / 快速 400K / 快速+ 1M）、从机地址、时钟拉伸。

实验现象

主机和从机完成数据收发
校验通过 LED 指示成功

注意事项

I2C 总线需要上拉电阻（一般 4.7K）
从机地址要与设备手册一致（注意 7 位/8 位地址的区别）
写 EEPROM 后需要等待 5ms 以上再读

PUYA I2C — I2C 从机中断通信

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

I2C — I2C 从机中断通信

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

功能简介

本示例演示 I2C 总线通信。I2C 只需两根线（SCL+SDA）就能连接多个设备，是最常用的低速通信总线。

硬件准备

I2C 从设备（如 EEPROM、传感器模块）
SCL/SDA 线上需要 4.7K 上拉电阻

完整代码

#include "main.h"
#define DATA_LENGTH       15                /* Length of data */
#define I2C_ADDRESS        0xA0             /* Own address 0xA0 */
#define I2C_SPEEDCLOCK   100000             /* Communication speed 100K */
#define I2C_DUTYCYCLE    I2C_DUTYCYCLE_2    /* Duty cycle */

代码讲解

I2C 配置：设置通信速率（标准 100K / 快速 400K / 快速+ 1M）、从机地址、时钟拉伸。

实验现象

主机和从机完成数据收发
校验通过 LED 指示成功

注意事项

I2C 总线需要上拉电阻（一般 4.7K）
从机地址要与设备手册一致（注意 7 位/8 位地址的区别）
写 EEPROM 后需要等待 5ms 以上再读

PUYA I2C — I2C 从机中断通信

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

I2C — I2C 从机中断通信

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

功能简介

本示例演示 I2C 总线通信。I2C 只需两根线（SCL+SDA）就能连接多个设备，是最常用的低速通信总线。

硬件准备

I2C 从设备（如 EEPROM、传感器模块）
SCL/SDA 线上需要 4.7K 上拉电阻

完整代码

#include "main.h"
#define DATA_LENGTH       15                /* Length of data */
#define I2C_ADDRESS        0xA0             /* Own address 0xA0 */
#define I2C_SPEEDCLOCK   100000             /* Communication speed 100K */
#define I2C_DUTYCYCLE    I2C_DUTYCYCLE_2    /* Duty cycle */

代码讲解

I2C 配置：设置通信速率（标准 100K / 快速 400K / 快速+ 1M）、从机地址、时钟拉伸。

实验现象

主机和从机完成数据收发
校验通过 LED 指示成功

注意事项

I2C 总线需要上拉电阻（一般 4.7K）
从机地址要与设备手册一致（注意 7 位/8 位地址的区别）
写 EEPROM 后需要等待 5ms 以上再读

PUYA I2C — I2C 从机中断通信

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

I2C — I2C 从机中断通信

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

功能简介

本示例演示 I2C 总线通信。I2C 只需两根线（SCL+SDA）就能连接多个设备，是最常用的低速通信总线。

硬件准备

I2C 从设备（如 EEPROM、传感器模块）
SCL/SDA 线上需要 4.7K 上拉电阻

完整代码

#include "main.h"
#define DATA_LENGTH       15                /* Data length*/
#define I2C_ADDRESS        0xA0             /* Local address 0xA0 */
#define I2C_SPEEDCLOCK   100000             /* Communication speed 100K */
#define I2C_DUTYCYCLE    I2C_DUTYCYCLE_16_9 /* Duty cycle */

代码讲解

I2C 配置：设置通信速率（标准 100K / 快速 400K / 快速+ 1M）、从机地址、时钟拉伸。

实验现象

主机和从机完成数据收发
校验通过 LED 指示成功

注意事项

I2C 总线需要上拉电阻（一般 4.7K）
从机地址要与设备手册一致（注意 7 位/8 位地址的区别）
写 EEPROM 后需要等待 5ms 以上再读

PUYA I2C — I2C 主机 DMA 通信

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

I2C — I2C 主机 DMA 通信

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

功能简介

本示例演示 I2C + DMA 通信。大数据量传输时，DMA 可以大幅降低 CPU 负载。

硬件准备

I2C 从设备（如 EEPROM、传感器模块）
SCL/SDA 线上需要 4.7K 上拉电阻

完整代码

#include "main.h"
#define DATA_LENGTH      15                 /* Length of data */
#define I2C_ADDRESS      0xA0               /* Own address 0xA0 */
#define I2C_SPEEDCLOCK   100000             /* Communication speed 100K */
#define I2C_DUTYCYCLE    I2C_DUTYCYCLE_16_9 /* Duty cycle */

代码讲解

I2C 配置：设置通信速率（标准 100K / 快速 400K / 快速+ 1M）、从机地址、时钟拉伸。

实验现象

主机和从机完成数据收发
校验通过 LED 指示成功

注意事项

I2C 总线需要上拉电阻（一般 4.7K）
从机地址要与设备手册一致（注意 7 位/8 位地址的区别）
写 EEPROM 后需要等待 5ms 以上再读

PUYA I2C — I2C 主机 DMA 通信

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

I2C — I2C 主机 DMA 通信

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

功能简介

本示例演示 I2C + DMA 通信。大数据量传输时，DMA 可以大幅降低 CPU 负载。

硬件准备

I2C 从设备（如 EEPROM、传感器模块）
SCL/SDA 线上需要 4.7K 上拉电阻

完整代码

#include "main.h"
#define DATA_LENGTH      15                 /* Length of data */
#define I2C_ADDRESS      0xA0               /* Own address 0xA0 */
#define I2C_SPEEDCLOCK   100000             /* Communication speed 100K */
#define I2C_DUTYCYCLE    I2C_DUTYCYCLE_16_9 /* Duty cycle */

代码讲解

I2C 配置：设置通信速率（标准 100K / 快速 400K / 快速+ 1M）、从机地址、时钟拉伸。

实验现象

主机和从机完成数据收发
校验通过 LED 指示成功

注意事项

I2C 总线需要上拉电阻（一般 4.7K）
从机地址要与设备手册一致（注意 7 位/8 位地址的区别）
写 EEPROM 后需要等待 5ms 以上再读

PUYA I2C — I2C 主机 DMA 通信 (内存地址)

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

I2C — I2C 主机 DMA 通信 (内存地址)

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

功能简介

本示例演示 I2C + DMA 通信。大数据量传输时，DMA 可以大幅降低 CPU 负载。

硬件准备

I2C 从设备（如 EEPROM、传感器模块）
SCL/SDA 线上需要 4.7K 上拉电阻

完整代码

#include "main.h"
#define DATA_LENGTH      15                 /* Length of data */
#define I2C_ADDRESS      0xA0               /* Own address 0xA0 */
#define I2C_SPEEDCLOCK   400000             /* Communication speed 100K */
#define I2C_DUTYCYCLE    I2C_DUTYCYCLE_16_9 /* Duty cycle */

代码讲解

I2C 配置：设置通信速率（标准 100K / 快速 400K / 快速+ 1M）、从机地址、时钟拉伸。

实验现象

主机和从机完成数据收发
校验通过 LED 指示成功

注意事项

I2C 总线需要上拉电阻（一般 4.7K）
从机地址要与设备手册一致（注意 7 位/8 位地址的区别）
写 EEPROM 后需要等待 5ms 以上再读

PUYA I2C — I2C 主机 DMA 通信 (内存地址)

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

I2C — I2C 主机 DMA 通信 (内存地址)

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

功能简介

本示例演示 I2C + DMA 通信。大数据量传输时，DMA 可以大幅降低 CPU 负载。

硬件准备

I2C 从设备（如 EEPROM、传感器模块）
SCL/SDA 线上需要 4.7K 上拉电阻

完整代码

#include "main.h"
#define DATA_LENGTH      15                 /* Length of data */
#define I2C_ADDRESS      0xA0               /* Own address 0xA0 */
#define I2C_SPEEDCLOCK   400000             /* Communication speed 100K */
#define I2C_DUTYCYCLE    I2C_DUTYCYCLE_16_9 /* Duty cycle */

代码讲解

I2C 配置：设置通信速率（标准 100K / 快速 400K / 快速+ 1M）、从机地址、时钟拉伸。

实验现象

主机和从机完成数据收发
校验通过 LED 指示成功

注意事项

I2C 总线需要上拉电阻（一般 4.7K）
从机地址要与设备手册一致（注意 7 位/8 位地址的区别）
写 EEPROM 后需要等待 5ms 以上再读

PUYA I2C — I2C 主机轮询通信

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

I2C — I2C 主机轮询通信

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

功能简介

本示例演示 I2C 轮询方式通信。CPU 等待每个字节传输完成，简单但效率较低。

硬件准备

I2C 从设备（如 EEPROM、传感器模块）
SCL/SDA 线上需要 4.7K 上拉电阻

完整代码

#include "main.h"
#define DATA_LENGTH      15                 /* Data length*/
#define I2C_ADDRESS      0xA0               /* Local address 0xA0 */
#define I2C_SPEEDCLOCK   100000             /* Communication speed 100K */
#define I2C_DUTYCYCLE    I2C_DUTYCYCLE_16_9 /* Duty cycle */

代码讲解

I2C 配置：设置通信速率（标准 100K / 快速 400K / 快速+ 1M）、从机地址、时钟拉伸。

实验现象

主机和从机完成数据收发
校验通过 LED 指示成功

注意事项

I2C 总线需要上拉电阻（一般 4.7K）
从机地址要与设备手册一致（注意 7 位/8 位地址的区别）
写 EEPROM 后需要等待 5ms 以上再读

PUYA I2C — I2C 主机轮询通信

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

I2C — I2C 主机轮询通信

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

功能简介

本示例演示 I2C 轮询方式通信。CPU 等待每个字节传输完成，简单但效率较低。

硬件准备

I2C 从设备（如 EEPROM、传感器模块）
SCL/SDA 线上需要 4.7K 上拉电阻

完整代码

#include "main.h"
#define DATA_LENGTH      15                 /* Length of data */
#define I2C_ADDRESS      0xA0               /* Own address 0xA0 */
#define I2C_SPEEDCLOCK   100000             /* Communication speed 100K */
#define I2C_DUTYCYCLE    I2C_DUTYCYCLE_16_9 /* Duty cycle */

代码讲解

I2C 配置：设置通信速率（标准 100K / 快速 400K / 快速+ 1M）、从机地址、时钟拉伸。

实验现象

主机和从机完成数据收发
校验通过 LED 指示成功

注意事项

I2C 总线需要上拉电阻（一般 4.7K）
从机地址要与设备手册一致（注意 7 位/8 位地址的区别）
写 EEPROM 后需要等待 5ms 以上再读

PUYA I2C — I2C 主机轮询通信

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

I2C — I2C 主机轮询通信

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

功能简介

本示例演示 I2C 轮询方式通信。CPU 等待每个字节传输完成，简单但效率较低。

硬件准备

I2C 从设备（如 EEPROM、传感器模块）
SCL/SDA 线上需要 4.7K 上拉电阻

完整代码

#include "main.h"
#define DATA_LENGTH      15                 /* Data length*/
#define I2C_ADDRESS      0xA0               /* Local address 0xA0 */
#define I2C_SPEEDCLOCK   100000             /* Communication speed 100K */
#define I2C_DUTYCYCLE    I2C_DUTYCYCLE_16_9 /* Duty cycle */

代码讲解

I2C 配置：设置通信速率（标准 100K / 快速 400K / 快速+ 1M）、从机地址、时钟拉伸。

实验现象

主机和从机完成数据收发
校验通过 LED 指示成功

注意事项

I2C 总线需要上拉电阻（一般 4.7K）
从机地址要与设备手册一致（注意 7 位/8 位地址的区别）
写 EEPROM 后需要等待 5ms 以上再读

PUYA I2C — I2C 主机中断通信

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

I2C — I2C 主机中断通信

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

功能简介

本示例演示 I2C 总线通信。I2C 只需两根线（SCL+SDA）就能连接多个设备，是最常用的低速通信总线。

硬件准备

I2C 从设备（如 EEPROM、传感器模块）
SCL/SDA 线上需要 4.7K 上拉电阻

完整代码

#include "main.h"
#define DATA_LENGTH      15                 /* Data length*/
#define I2C_ADDRESS      0xA0               /* Local address 0xA0 */
#define I2C_SPEEDCLOCK   100000             /* Communication speed 100K */
#define I2C_DUTYCYCLE    I2C_DUTYCYCLE_16_9 /* Duty cycle */

代码讲解

I2C 配置：设置通信速率（标准 100K / 快速 400K / 快速+ 1M）、从机地址、时钟拉伸。

实验现象

主机和从机完成数据收发
校验通过 LED 指示成功

注意事项

I2C 总线需要上拉电阻（一般 4.7K）
从机地址要与设备手册一致（注意 7 位/8 位地址的区别）
写 EEPROM 后需要等待 5ms 以上再读

PUYA I2C — I2C 主机中断通信

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

I2C — I2C 主机中断通信

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

功能简介

本示例演示 I2C 总线通信。I2C 只需两根线（SCL+SDA）就能连接多个设备，是最常用的低速通信总线。

硬件准备

I2C 从设备（如 EEPROM、传感器模块）
SCL/SDA 线上需要 4.7K 上拉电阻

完整代码

#include "main.h"
#define DATA_LENGTH      15                 /* Length of data */
#define I2C_ADDRESS      0xA0               /* Own address 0xA0 */
#define I2C_SPEEDCLOCK   100000             /* Communication speed 100K */
#define I2C_DUTYCYCLE    I2C_DUTYCYCLE_16_9 /* Duty cycle */

代码讲解

I2C 配置：设置通信速率（标准 100K / 快速 400K / 快速+ 1M）、从机地址、时钟拉伸。

实验现象

主机和从机完成数据收发
校验通过 LED 指示成功

注意事项

I2C 总线需要上拉电阻（一般 4.7K）
从机地址要与设备手册一致（注意 7 位/8 位地址的区别）
写 EEPROM 后需要等待 5ms 以上再读

PUYA I2C — I2C 主机中断通信

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

I2C — I2C 主机中断通信

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

功能简介

本示例演示 I2C 总线通信。I2C 只需两根线（SCL+SDA）就能连接多个设备，是最常用的低速通信总线。

硬件准备

I2C 从设备（如 EEPROM、传感器模块）
SCL/SDA 线上需要 4.7K 上拉电阻

完整代码

#include "main.h"
#define DATA_LENGTH      15                 /* Length of data */
#define I2C_ADDRESS      0xA0               /* Own address 0xA0 */
#define I2C_SPEEDCLOCK   100000             /* Communication speed 100K */
#define I2C_DUTYCYCLE    I2C_DUTYCYCLE_16_9 /* Duty cycle */

代码讲解

I2C 配置：设置通信速率（标准 100K / 快速 400K / 快速+ 1M）、从机地址、时钟拉伸。

实验现象

主机和从机完成数据收发
校验通过 LED 指示成功

注意事项

I2C 总线需要上拉电阻（一般 4.7K）
从机地址要与设备手册一致（注意 7 位/8 位地址的区别）
写 EEPROM 后需要等待 5ms 以上再读

PUYA I2C — I2C 主机中断通信

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

I2C — I2C 主机中断通信

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

功能简介

本示例演示 I2C 总线通信。I2C 只需两根线（SCL+SDA）就能连接多个设备，是最常用的低速通信总线。

硬件准备

I2C 从设备（如 EEPROM、传感器模块）
SCL/SDA 线上需要 4.7K 上拉电阻

完整代码

#include "main.h"
#define DATA_LENGTH      15                 /* Data length*/
#define I2C_ADDRESS      0xA0               /* Local address 0xA0 */
#define I2C_SPEEDCLOCK   100000             /* Communication speed 100K */
#define I2C_DUTYCYCLE    I2C_DUTYCYCLE_16_9 /* Duty cycle */

代码讲解

I2C 配置：设置通信速率（标准 100K / 快速 400K / 快速+ 1M）、从机地址、时钟拉伸。

实验现象

主机和从机完成数据收发
校验通过 LED 指示成功

注意事项

I2C 总线需要上拉电阻（一般 4.7K）
从机地址要与设备手册一致（注意 7 位/8 位地址的区别）
写 EEPROM 后需要等待 5ms 以上再读

PUYA I2C — I2C_TwoBoard_CommunicationMaster_10BitAddr_IT

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

I2C — I2C_TwoBoard_CommunicationMaster_10BitAddr_IT

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

功能简介

本示例演示 I2C 总线通信。I2C 只需两根线（SCL+SDA）就能连接多个设备，是最常用的低速通信总线。

硬件准备

I2C 从设备（如 EEPROM、传感器模块）
SCL/SDA 线上需要 4.7K 上拉电阻

完整代码

#include "main.h"
#define DATA_LENGTH      15                 /* Length of data */
#define I2C_ADDRESS      0xA0               /* Own address 0xA0 */
#define I2C_SPEEDCLOCK   100000             /* Communication speed 100K */
#define I2C_DUTYCYCLE    I2C_DUTYCYCLE_16_9 /* Duty cycle */

代码讲解

I2C 配置：设置通信速率（标准 100K / 快速 400K / 快速+ 1M）、从机地址、时钟拉伸。

实验现象

主机和从机完成数据收发
校验通过 LED 指示成功

注意事项

I2C 总线需要上拉电阻（一般 4.7K）
从机地址要与设备手册一致（注意 7 位/8 位地址的区别）
写 EEPROM 后需要等待 5ms 以上再读

PUYA I2C — I2C_TwoBoard_CommunicationMaster_DualAddr_IT

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

I2C — I2C_TwoBoard_CommunicationMaster_DualAddr_IT

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

功能简介

本示例演示 I2C 总线通信。I2C 只需两根线（SCL+SDA）就能连接多个设备，是最常用的低速通信总线。

硬件准备

I2C 从设备（如 EEPROM、传感器模块）
SCL/SDA 线上需要 4.7K 上拉电阻

完整代码

#include "main.h"
#define DATA_LENGTH         15                 /* Length of data */
#define I2C_ADDRESS         0xA0               /* Own address 0xA0 */
#define I2C_ADDRESS_SECOND  0xA2               /* Local second address 0xA2 */
#define I2C_SPEEDCLOCK   100000             /* Communication speed 100K */
#define I2C_DUTYCYCLE    I2C_DUTYCYCLE_16_9 /* Duty cycle */

代码讲解

I2C 配置：设置通信速率（标准 100K / 快速 400K / 快速+ 1M）、从机地址、时钟拉伸。

实验现象

主机和从机完成数据收发
校验通过 LED 指示成功

注意事项

I2C 总线需要上拉电阻（一般 4.7K）
从机地址要与设备手册一致（注意 7 位/8 位地址的区别）
写 EEPROM 后需要等待 5ms 以上再读

PUYA I2C — I2C_TwoBoard_CommunicationSlave_10BitAddr_IT

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

I2C — I2C_TwoBoard_CommunicationSlave_10BitAddr_IT

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

功能简介

本示例演示 I2C 总线通信。I2C 只需两根线（SCL+SDA）就能连接多个设备，是最常用的低速通信总线。

硬件准备

I2C 从设备（如 EEPROM、传感器模块）
SCL/SDA 线上需要 4.7K 上拉电阻

完整代码

#include "main.h"
#define DATA_LENGTH       15                /* Length of data */
#define I2C_ADDRESS        0xA0             /* Own address 0xA0 */
#define I2C_SPEEDCLOCK   100000             /* Communication speed 100K */
#define I2C_DUTYCYCLE    I2C_DUTYCYCLE_2    /* Duty cycle */

代码讲解

I2C 配置：设置通信速率（标准 100K / 快速 400K / 快速+ 1M）、从机地址、时钟拉伸。

实验现象

主机和从机完成数据收发
校验通过 LED 指示成功

注意事项

I2C 总线需要上拉电阻（一般 4.7K）
从机地址要与设备手册一致（注意 7 位/8 位地址的区别）
写 EEPROM 后需要等待 5ms 以上再读

PUYA I2C — I2C_TwoBoard_CommunicationSlave_DualAddr_IT

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

I2C — I2C_TwoBoard_CommunicationSlave_DualAddr_IT

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

功能简介

本示例演示 I2C 总线通信。I2C 只需两根线（SCL+SDA）就能连接多个设备，是最常用的低速通信总线。

硬件准备

I2C 从设备（如 EEPROM、传感器模块）
SCL/SDA 线上需要 4.7K 上拉电阻

完整代码

#include "main.h"
#define DATA_LENGTH         15               /* Length of data */
#define I2C_ADDRESS         0xA0             /* Own address 0xA0 */
#define I2C_ADDRESS_SECOND  0xA2             /* Local second address 0xA2 */
#define I2C_SPEEDCLOCK   100000           /* Communication speed 100K */
#define I2C_DUTYCYCLE    I2C_DUTYCYCLE_2  /* Duty cycle */

代码讲解

I2C 配置：设置通信速率（标准 100K / 快速 400K / 快速+ 1M）、从机地址、时钟拉伸。

实验现象

主机和从机完成数据收发
校验通过 LED 指示成功

注意事项

I2C 总线需要上拉电阻（一般 4.7K）
从机地址要与设备手册一致（注意 7 位/8 位地址的区别）
写 EEPROM 后需要等待 5ms 以上再读

PUYA I2C — 主机轮询通信（LL 库）

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

I2C — 主机轮询通信（LL 库）

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

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

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

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

功能简介

本示例演示 I2C 主机（Master）轮询模式：按键后，主机先向从机地址 0xA0 发送 15 字节，再从中机读回 15 字节（对端跑 Slave 示例做回环），最后比对收发数据——一致则点亮 LED，不一致则 LED 闪烁报错。

与 HAL 版（HAL_I2C_Master_Transmit / HAL_I2C_Master_Receive 一行搞定）相比，LL 版把 I2C 的完整状态机摊开在你面前：起始条件 → 地址 → 数据 → 停止条件，每一步都靠轮询标志位（SB/ADDR/TXE/BTF/RXNE）推进。代码长，但能让你真正搞懂 I2C“为什么这么写”。

硬件准备

两块 PY32F030 开发板（一块作主、一块作从）
主从板 SCL(PA9) 与 SDA(PA10) 交叉相连，并各自接上拉电阻（示例里已配置内部上拉）
主机板载按键（KEY）、绿 LED
串口/LED 用于判断结果

完整代码

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

#define I2C_ADDRESS        0xA0     /* 从机地址 */
#define I2C_SPEEDCLOCK     100000   /* 100K 标准速率 */
#define I2C_STATE_READY    0
#define I2C_STATE_BUSY_TX  1
#define I2C_STATE_BUSY_RX  2

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

uint8_t         *pBuffPtr  = NULL;
__IO uint16_t   XferCount  = 0;
__IO uint32_t   Devaddress = 0;
__IO uint32_t   State      = I2C_STATE_READY;

static void APP_SystemClockConfig(void);
static void APP_ConfigI2cMaster(void);
static void APP_MasterTransmit(uint16_t DevAddress, uint8_t *pData, uint16_t Size);
static void APP_MasterReceive(uint16_t DevAddress, uint8_t *pData, uint16_t Size);
static void APP_CheckEndOfTransfer(void);
static uint8_t APP_Buffercmp8(uint8_t* pBuffer1, uint8_t* pBuffer2, uint8_t BufferLength);
static void APP_LedBlinking(void);

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

  APP_ConfigI2cMaster();

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

  APP_MasterTransmit(I2C_ADDRESS, (uint8_t *)aTxBuffer, sizeof(aTxBuffer));
  while (State != I2C_STATE_READY);           /* 等发送完 */
  APP_MasterReceive(I2C_ADDRESS, (uint8_t *)aRxBuffer, sizeof(aRxBuffer));
  while (State != I2C_STATE_READY);           /* 等接收完 */

  APP_CheckEndOfTransfer();                   /* 比对结果 */
  while (1) {}
}

/**
  * @brief  I2C 主机 GPIO + 外设配置
  */
static void APP_ConfigI2cMaster(void)
{
  LL_IOP_GRP1_EnableClock(LL_IOP_GRP1_PERIPH_GPIOA);
  LL_APB1_GRP1_EnableClock(LL_APB1_GRP1_PERIPH_I2C1);

  /* SCL=PA9, SDA=PA10：复用、开漏、上拉、AF6 */
  LL_GPIO_InitTypeDef GPIO_InitStruct = {0};
  GPIO_InitStruct.Pin        = LL_GPIO_PIN_9;
  GPIO_InitStruct.Mode       = LL_GPIO_MODE_ALTERNATE;
  GPIO_InitStruct.Speed      = LL_GPIO_SPEED_FREQ_HIGH;
  GPIO_InitStruct.OutputType = LL_GPIO_OUTPUT_OPENDRAIN;   /* I2C 必须开漏 */
  GPIO_InitStruct.Pull       = LL_GPIO_PULL_UP;
  GPIO_InitStruct.Alternate  = LL_GPIO_AF_6;
  LL_GPIO_Init(GPIOA, &GPIO_InitStruct);

  GPIO_InitStruct.Pin = LL_GPIO_PIN_10;
  LL_GPIO_Init(GPIOA, &GPIO_InitStruct);

  /* 复位 I2C 外设 */
  LL_APB1_GRP1_ForceReset(LL_APB1_GRP1_PERIPH_I2C1);
  LL_APB1_GRP1_ReleaseReset(LL_APB1_GRP1_PERIPH_I2C1);

  LL_I2C_InitTypeDef I2C_InitStruct = {0};
  I2C_InitStruct.ClockSpeed      = I2C_SPEEDCLOCK;
  I2C_InitStruct.DutyCycle       = LL_I2C_DUTYCYCLE_16_9;
  I2C_InitStruct.OwnAddress1     = I2C_ADDRESS;
  I2C_InitStruct.TypeAcknowledge = LL_I2C_NACK;
  LL_I2C_Init(I2C1, &I2C_InitStruct);
}

/**
  * @brief  LL 主机发送：起始→地址→数据→停止，全程轮询标志
  */
static void APP_MasterTransmit(uint16_t DevAddress, uint8_t *pData, uint16_t Size)
{
  pBuffPtr = pData; XferCount = Size; Devaddress = DevAddress;
  State = I2C_STATE_BUSY_TX;

  LL_I2C_GenerateStartCondition(I2C1);
  while (LL_I2C_IsActiveFlag_SB(I2C1) != 1);           /* 等起始条件发送完 */

  LL_I2C_TransmitData8(I2C1, (Devaddress & (uint8_t)(~0x01)));  /* 发写地址(末位0) */
  while (LL_I2C_IsActiveFlag_ADDR(I2C1) != 1);
  LL_I2C_ClearFlag_ADDR(I2C1);                          /* 清地址标志 */

  while (XferCount > 0)
  {
    while (LL_I2C_IsActiveFlag_TXE(I2C1) != 1);         /* 等发送寄存器空 */
    LL_I2C_TransmitData8(I2C1, *pBuffPtr);              /* 发一字节 */
    pBuffPtr++; XferCount--;
    while (LL_I2C_IsActiveFlag_BTF(I2C1) != 1);         /* 等字节发完(BTF) */
  }

  LL_I2C_GenerateStopCondition(I2C1);                   /* 发停止条件 */
  State = I2C_STATE_READY;
}

/**
  * @brief  LL 主机接收：起始→地址(读)→接收 N 字节→停止
  */
static void APP_MasterReceive(uint16_t DevAddress, uint8_t *pData, uint16_t Size)
{
  pBuffPtr = pData; XferCount = Size; Devaddress = DevAddress;
  State = I2C_STATE_BUSY_RX;

  LL_I2C_AcknowledgeNextData(I2C1, LL_I2C_ACK);        /* 先允许 ACK */
  LL_I2C_GenerateStartCondition(I2C1);
  while (LL_I2C_IsActiveFlag_SB(I2C1) != 1);
  LL_I2C_TransmitData8(I2C1, (Devaddress | 0x1));      /* 发读地址(末位1) */
  while (LL_I2C_IsActiveFlag_ADDR(I2C1) != 1);
  LL_I2C_ClearFlag_ADDR(I2C1);

  while (XferCount > 0)
  {
    while (LL_I2C_IsActiveFlag_RXNE(I2C1) != 1);        /* 等收到一字节 */
    *pBuffPtr = LL_I2C_ReceiveData8(I2C1);              /* 读一字节 */
    pBuffPtr++; XferCount--;
  }
  State = I2C_STATE_READY;
}

/* APP_CheckEndOfTransfer / APP_Buffercmp8 / APP_LedBlinking / 时钟与错误处理
   与前述示例同构，略 */

代码分段讲解

1. 开漏 + 上拉：I2C 物理层铁律

I2C 总线靠“线与”工作，SCL/SDA 必须开漏（LL_GPIO_OUTPUT_OPENDRAIN）+ 外部/内部上拉。示例用内部上拉（LL_GPIO_PULL_UP）。HAL 版在 HAL_I2C_Init 里通过 I2C_HandleTypeDef 同样隐含了这些设置，但 LL 让你看得一清二楚。

2. 发送状态机（核心）

LL 的发送就是“手搓 I2C 协议帧”：

LL_I2C_GenerateStartCondition() 拉出 START；
等 SB 标志 → 写从机地址（写=地址&0xFE）；
等 ADDR 标志并清除 → 进入数据传输；
每字节等 TXE（发送寄存器空）写数据，再等 BTF（字节传输完）；
最后 LL_I2C_GenerateStopCondition() 发 STOP。

对比 HAL：HAL_I2C_Master_Transmit() 把以上 5 步全藏在库里，你只传“地址+缓冲区+长度”。

3. 接收状态机

接收时地址末位置 1（读=地址|0x01），之后轮询 RXNE 逐字节读取。示例为简化只演示了“固定长度、一直 ACK”的情形；HAL 内部还处理了“最后一字节发 NACK + STOP”的时序细节（源码里那些 XferCount<=3 的分支就是干这个的）。

4. 没有超时！

注意这些 while(标志 != 1); 都是死等。真实总线若从机无响应（地址错、没接上拉、线断），程序会卡死。真实项目务必加超时或改用中断（I2C_TwoBoard_CommunicationMaster_IT_Init）。

实验现象

主从两块板 SCL/SDA 连接好，从机先跑 Slave 示例。
主机按下 KEY，先向 0xA0 发 15 字节。
主机再读回 15 字节，与发送缓冲比对。
一致 → 绿 LED 常亮；不一致 → 绿 LED 闪烁。

常见问题

卡在等 ADDR / 一直不进数据？
- 最常见：从机地址不对、SCL/SDA 没接上拉、主从没共地。
- 确认从机确实在跑对应的 Slave 示例并监听 0xA0。
死等卡死？
- LL 轮询无超时。用逻辑分析仪看波形，确认 START/地址是否真的出现在总线上。
想用中断而不是轮询？
- 参考 I2C_TwoBoard_CommunicationMaster_IT_Init，用 LL_I2C_EnableIT_xxx + 回调处理。

小结

LL 的 I2C 主机 = 手搓协议帧：START → 地址 → 数据 → STOP，每步轮询标志。
相比 HAL 的“一行收发”，LL 代码长但完全透明，没有隐藏时序。
物理层（开漏+上拉）和“无超时死等”是两个最需要警惕的点。

拓展应用

把轮询改成中断/IT 版本，避免阻塞主循环。
接入真实传感器（如 EEPROM、温湿度芯片），把 0xA0 换成器件真实地址。
用 DMA 搬运长数据（参考 I2C_TwoBoard_CommunicationMaster_DMA_Init）。
增加超时退出，提升总线异常时的鲁棒性。

AT32 I2C — 读写 EEPROM（最常用的 I2C 从设备）

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

I2C — 读写 EEPROM

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

这个实验是干嘛的？

EEPROM（Electrically Erasable Programmable Read-Only Memory）是一种掉电不丢失的存储芯片。它不像 Flash 那样需要擦除整块扇区，可以逐字节读写，非常适合存储配置参数、校准数据、用户设置等小量关键数据。

AT24C02 是最经典的 EEPROM 芯片，容量 256 字节，I2C 接口，只要 2 根线就能通信。

本实验做的事情：

准备 3 组不同的测试数据
分别用轮询、中断、DMA 三种方式写入 EEPROM
读回数据并比对
三种方式都成功 → LED 亮

硬件准备

你需要一个 AT24C02 EEPROM 模块（淘宝 2~3 块）：

开发板            AT24C02 模块
  PB10 (SCL) ──→  SCL
  PB11 (SDA) ←──→ SDA
  3.3V       ──→  VCC
  GND        ──→  GND

重要：

I2C 总线需要上拉电阻（一般 4.7KΩ）
大多数模块已经焊好了上拉电阻，不用你加
如果自己搭电路，SCL 和 SDA 各接一个 4.7K 上拉到 VCC

I2C 基础知识

I2C 只需要 2 根线就能连接多个设备：

信号	全称	说明
SCL	Serial Clock	时钟信号，主机产生
SDA	Serial Data	数据信号，双向

I2C 的核心概念

1. 主从模式

主机（Master）：发起通信，产生时钟
从机（Slave）：被动响应，每个从机有唯一地址

2. 7 位地址

每个 I2C 设备有一个 7 位地址（如 AT24C02 的地址是 0x50）
一根总线上可以挂多个设备，靠地址区分

3. 读写操作

写操作：主机发送 [从机地址+W] + [数据]
读操作：主机发送 [从机地址+R]，然后从机返回数据

I2C vs SPI 对比

特性	I2C	SPI
线数	2 根（SCL+SDA）	4 根（SCK+MOSI+MISO+CS）
速度	100K/400K/1M	几十 MHz
多设备	地址区分，同一总线挂多个	每个设备一根 CS 线
全双工	否（半双工）	是
适用场景	低速传感器、EEPROM	高速 Flash、LCD

完整代码

#include "at32f403a_407_board.h"
#include "at32f403a_407_clock.h"
#include "eeprom.h"

/* ===== I2C 配置参数 ===== */
#define I2C_TIMEOUT    0xFFFFFFFF
#define I2Cx_SPEED     100000       // 100KHz 标准模式
#define I2Cx_ADDRESS   0xA0         // EEPROM 地址（7位地址左移1位）
#define I2Cx_PORT      I2C2
#define I2Cx_SCL_PIN   GPIO_PINS_10 // PB10 = SCL
#define I2Cx_SDA_PIN   GPIO_PINS_11 // PB11 = SDA
#define BUF_SIZE       12

/* 3 组测试数据 */
uint8_t tx_buf1[BUF_SIZE] = {0x01, 0x02, 0x03, 0x04, 0x05, 0x06, 0x07, 0x08, 0x09, 0x0A, 0x0B, 0x0C};
uint8_t tx_buf2[BUF_SIZE] = {0x10, 0x20, 0x30, 0x40, 0x50, 0x60, 0x70, 0x80, 0x90, 0xA0, 0xB0, 0xC0};
uint8_t tx_buf3[BUF_SIZE] = {0x11, 0x22, 0x33, 0x44, 0x55, 0x66, 0x77, 0x88, 0x99, 0xAA, 0xBB, 0xCC};
uint8_t rx_buf1[BUF_SIZE] = {0};
uint8_t rx_buf2[BUF_SIZE] = {0};
uint8_t rx_buf3[BUF_SIZE] = {0};

i2c_handle_type hi2cx;

/* 缓冲区比对 */
uint32_t buffer_compare(uint8_t* buf1, uint8_t* buf2, uint32_t len)
{
  for(uint32_t i = 0; i < len; i++)
  {
    if(buf1[i] != buf2[i]) return 1;
  }
  return 0;
}

/* 错误处理：LED 快闪 */
void error_handler(uint32_t error_code)
{
  while(1)
  {
    at32_led_toggle(LED2);
    delay_ms(500);
  }
}

/* I2C 底层初始化（GPIO + 中断 + DMA） */
void i2c_lowlevel_init(i2c_handle_type* hi2c)
{
  gpio_init_type gpio_initstructure;

  /* 使能时钟 */
  crm_periph_clock_enable(CRM_I2C2_PERIPH_CLOCK, TRUE);
  crm_periph_clock_enable(CRM_GPIOB_PERIPH_CLOCK, TRUE);

  /* GPIO 配置：开漏输出，复用功能 */
  gpio_initstructure.gpio_out_type = GPIO_OUTPUT_OPEN_DRAIN;
  gpio_initstructure.gpio_pull = GPIO_PULL_NONE;
  gpio_initstructure.gpio_mode = GPIO_MODE_MUX;
  gpio_initstructure.gpio_drive_strength = GPIO_DRIVE_STRENGTH_MODERATE;

  gpio_initstructure.gpio_pins = I2Cx_SCL_PIN;
  gpio_init(GPIOB, &gpio_initstructure);

  gpio_initstructure.gpio_pins = I2Cx_SDA_PIN;
  gpio_init(GPIOB, &gpio_initstructure);

  /* 中断配置 */
  nvic_irq_enable(I2C2_EVT_IRQn, 0, 0);
  nvic_irq_enable(I2C2_ERR_IRQn, 0, 0);
  nvic_irq_enable(DMA1_Channel4_IRQn, 0, 0);
  nvic_irq_enable(DMA1_Channel5_IRQn, 0, 0);

  /* DMA 配置 */
  crm_periph_clock_enable(CRM_DMA1_PERIPH_CLOCK, TRUE);
  hi2c->dma_tx_channel = DMA1_CHANNEL4;
  hi2c->dma_rx_channel = DMA1_CHANNEL5;

  /* I2C 初始化：100KHz，7位地址 */
  i2c_init(hi2c->i2cx, I2C_FSMODE_DUTY_2_1, I2Cx_SPEED);
  i2c_own_address1_set(hi2c->i2cx, I2C_ADDRESS_MODE_7BIT, I2Cx_ADDRESS);
}

int main(void)
{
  i2c_status_type i2c_status;

  nvic_priority_group_config(NVIC_PRIORITY_GROUP_4);
  system_clock_config();
  at32_board_init();

  hi2cx.i2cx = I2Cx_PORT;
  i2c_config(&hi2cx);  // 调用底层初始化

  while(1)
  {
    /* 等待按键按下 */
    while(at32_button_press() != USER_BUTTON) {}

    /* ===== 方式一：轮询模式写入 ===== */
    eeprom_write_buffer(&hi2cx, EE_MODE_POLL, I2C_MEM_ADDR_WIDIH_8,
                        I2Cx_ADDRESS, 0x00, tx_buf1, BUF_SIZE, I2C_TIMEOUT);
    delay_ms(1);  // EEPROM 写入需要时间
    eeprom_read_buffer(&hi2cx, EE_MODE_POLL, I2C_MEM_ADDR_WIDIH_8,
                       I2Cx_ADDRESS, 0x00, rx_buf1, BUF_SIZE, I2C_TIMEOUT);
    delay_ms(5);

    /* ===== 方式二：中断模式写入 ===== */
    eeprom_write_buffer(&hi2cx, EE_MODE_INT, I2C_MEM_ADDR_WIDIH_8,
                        I2Cx_ADDRESS, 0x00, tx_buf2, BUF_SIZE, I2C_TIMEOUT);
    delay_ms(1);
    eeprom_read_buffer(&hi2cx, EE_MODE_INT, I2C_MEM_ADDR_WIDIH_8,
                       I2Cx_ADDRESS, 0x00, rx_buf2, BUF_SIZE, I2C_TIMEOUT);
    delay_ms(5);

    /* ===== 方式三：DMA 模式写入 ===== */
    eeprom_write_buffer(&hi2cx, EE_MODE_DMA, I2C_MEM_ADDR_WIDIH_8,
                        I2Cx_ADDRESS, 0x00, tx_buf3, BUF_SIZE, I2C_TIMEOUT);
    delay_ms(1);
    eeprom_read_buffer(&hi2cx, EE_MODE_DMA, I2C_MEM_ADDR_WIDIH_8,
                       I2Cx_ADDRESS, 0x00, rx_buf3, BUF_SIZE, I2C_TIMEOUT);
    delay_ms(5);

    /* 验证三组数据 */
    if(buffer_compare(tx_buf1, rx_buf1, BUF_SIZE) == 0 &&
       buffer_compare(tx_buf2, rx_buf2, BUF_SIZE) == 0 &&
       buffer_compare(tx_buf3, rx_buf3, BUF_SIZE) == 0)
    {
      at32_led_on(LED3);  // 全部成功
    }
    else
    {
      error_handler(i2c_status);  // 失败，LED 快闪
    }
  }
}

代码分段讲解

1. I2C 地址

`1`	`#define I2Cx_ADDRESS 0xA0`

AT24C02 的 7 位地址是 0x50，左移 1 位变成 0xA0。为什么？

I2C 传输时，地址后面跟一个读写位：

写操作：0x50 << 1 | 0 = 0xA0
读操作：0x50 << 1 | 1 = 0xA1

2. GPIO 配置

`1`	`gpio_initstructure.gpio_out_type = GPIO_OUTPUT_OPEN_DRAIN;`

I2C 必须用开漏输出！ 为什么？

I2C 总线上有多个设备，任何设备都可以拉低 SDA/SCL
开漏模式：只能拉低，不能主动拉高（靠上拉电阻拉高）
如果用推挽输出，两个设备同时输出不同电平会短路！

3. 三种传输模式

模式	原理	优点	缺点
轮询	CPU 不断检查标志位	简单直接	占用 CPU
中断	传输完成触发中断	CPU 可以做其他事	需要中断服务函数
DMA	DMA 自动搬运数据	CPU 完全不参与	配置复杂

4. 写入后延时

`1`	`delay_ms(1); // EEPROM 写入需要时间`

EEPROM 写入是一个内部编程过程，需要几毫秒。在编程期间，EEPROM 不会应答（NACK），主机必须等待。

实验现象

按下 USER 按键
三种模式依次写入并读回
LED3 亮起 → 三种模式全部成功
LED2 快闪 → 有失败，检查接线

常见问题

Q: I2C 通信超时？

检查上拉电阻（4.7KΩ）
检查地址是否正确（7 位 vs 8 位地址的区别）
检查 SCL/SDA 是否接反

Q: 写入后读出来不对？

EEPROM 写入需要时间，写入后至少等 5ms 再读
检查 EEPROM 地址引脚（A0/A1/A2）是否与代码一致

Q: 7 位地址和 8 位地址的区别？

7 位地址：0x50（芯片手册上的地址）
8 位地址：0xA0（左移 1 位，包含读写位）
不同库函数可能要求不同格式，注意区分

小结

概念	说明
I2C	2 线制低速通信总线
EEPROM	掉电不丢失，逐字节读写
开漏输出	I2C 必须用，避免短路
上拉电阻	4.7KΩ，必须有
7 位地址	芯片手册上的地址
写入延时	EEPROM 编程需要几毫秒

学了 I2C 能做什么？

I2C 是连接"低速外设"的万能总线，几乎所有传感器都支持 I2C：

传感器

项目	原理	难度
温湿度检测	SHT30/DHT20 + I2C → 温湿度数据	⭐⭐
气压检测	BMP280 + I2C → 气压/海拔	⭐⭐
光照检测	BH1750 + I2C → 光照强度	⭐
加速度/陀螺仪	MPU6050 + I2C → 6 轴姿态	⭐⭐⭐
RTC 时钟	DS3231 + I2C → 精确时间	⭐⭐
磁场检测	QMC5883L + I2C → 电子罗盘	⭐⭐⭐
触摸检测	TTP223 电容触摸 + I2C	⭐⭐

存储与显示

项目	原理	难度
配置参数存储	AT24C02 + I2C → 存校准数据	⭐
OLED 显示	SSD1306 + I2C → 0.96 寸 OLED	⭐⭐
LCD 显示	I2C 接口的字符 LCD	⭐⭐

实际应用场景

气象站：I2C 温湿度 + 气压 + 光照 → 环境监测
平衡车：I2C MPU6050 → 姿态检测 + PID 控制
智能手表：I2C 心率 + 加速度 + RTC → 健康监测
工业仪表：I2C ADC（ADS1115）→ 高精度电压测量

核心思路：I2C 的核心优势是省线。2 根线就能挂 128 个设备。传感器、EEPROM、RTC、OLED……几乎所有低速外设都用 I2C。掌握了 I2C，你就有了连接整个传感器世界的能力。

下一步：学会了 I2C，可以学 TIM PWM 输出，用定时器生成 PWM 信号控制 LED 亮度、电机转速。