Ana Sayfa Keşfet Yardım
Giriş Yap
kekezack
/
Obsidian-Knowledge-Base
1
0
Çatalla 0
Dosyalar Sorunlar 0 Değişiklik İstekleri 0 Wiki
Ağaç: 7095b111ef
Dallar Biçim İmleri
Obsidian-Knowle...
/
X-Knowledge-Base
/
raw
/
Joplin
/
嵌入式+Linux
/
STM32学习笔记
/
07-I2C通信与EEPROM 24C02.md

07-I2C通信与EEPROM 24C02.md 11 KB
Geçmiş Ham

tags: [source-summary] type: source source: "尚硅谷嵌入式技术之STM32单片机（基础篇）V1.0.2 — 第9章：I2C通信 + 配套代码13~15" author: "尚硅谷研究院" date: 2026-07-15

created: 2026-07-15

I2C通信与EEPROM 24C02

用生活理解：I2C 就像教室里的传纸条游戏——SCL 是老师拍手的节奏（时钟线），SDA 是传的纸条（数据线）。老师每拍一次手（时钟周期），大家就传递一位。每个同学有唯一的学号（设备地址 7 位），老师喊学号时对应同学才回答。STOP 条件就像下课铃——老师拍手节奏变了，表示传纸条结束。

I2C 协议基础

I2C（Inter-Integrated Circuit，读作 I-squared-C）是一种同步、半双工、多主从的串行通信总线，由 Philips 公司（现 NXP）发明。

特性 说明
线数 SCL（时钟）+ SDA（数据）两根线
模式 半双工（同一时刻只能单向传输）
速率 标准 100Kbps / 快速 400Kbps / 高速 3.4MHz
主从 多主多从（通过仲裁解决冲突）
地址 7 位地址（最多 127 个设备）或 10 位地址
上拉电阻 两根线都需要外部上拉电阻（4.7KΩ 典型）

参考：参考手册 §16（I2C 寄存器描述） 参考：NXP I2C 总线规范（UM10204）

I2C 时序协议详解

空闲状态

SCL 和 SDA 都是高电平（由上拉电阻拉高）。

起始条件（Start Condition）

SCL 为高电平时，SDA 从高电平切换到低电平

代码实现：

SCL_HIGH;       // SCL = 1
SDA_HIGH;       // SDA = 1
I2C_DELAY;      // 等待（数据建立时间）
SDA_LOW;        // SDA = 0 → 起始条件（在 SCL 高电平时 SDA 变低）
I2C_DELAY;      // 等待（保持时间）

停止条件（Stop Condition）

SCL 为高电平时，SDA 从低电平切换到高电平

代码实现：

SCL_LOW;        // SCL = 0（准备）
SDA_LOW;        // SDA = 0
SCL_HIGH;       // SCL = 1
I2C_DELAY;
SDA_HIGH;       // SDA = 0 → 1 → 终止条件（在 SCL 高电平时 SDA 变高）
I2C_DELAY;

数据字节传输

每个字节 8 位，MSB（最高位）先发。SCL 低电平时允许 SDA 变化，SCL 高电平时 SDA 必须稳定（接收方采集数据）。

SCL:  ████░░░░████░░░░████░░░░....████░░░░██
SDA:  ██░░██░░██░░██░░        ██░░██░░
        ↑MSB                    ↑LSB
       SCL低时SDA可以变     SCL高时采集

应答（ACK/NACK）

每个字节后，接收方在第 9 个 SCL 周期控制 SDA：

  • ACK：SDA 拉低（表示"收到，继续"）

  • NACK：SDA 释放（高电平，表示"收完"或"不再接收"）

    主机发送8位数据后:
主机释放SDA → 从机在第9个SCL脉冲拉低SDA → 应答(ACK)

I2C 完整通信流程

主机写数据到从机：

START + 7位从机地址 + R/W(0=写) + ACK + 数据1 + ACK + 数据2 + ACK + ... + STOP

主机从从机读数据：

START + 7位从机地址 + R/W(1=读) + ACK + 从机发数据1 + 主机ACK + ... + 从机发数据N + 主机NACK + STOP

组合格式（先写地址再读）：

START + 从机地址(W) + ACK + 寄存器地址 + ACK + RESTART + 从机地址(R) + ACK + 数据 + NACK + STOP

I2C 硬件电路设计

VCC(3.3V)           VCC(3.3V)
  ├── Rpu(4.7KΩ)     ├── Rpu(4.7KΩ)
  │                  │
  ├──── SCL ─────────┤
  │   PB10           │  24C02 SCL
  ├──── SDA ─────────┤
  │   PB11           │  24C02 SDA
  │                  │
  GND ────────────── GND

I2C 总线需要外部上拉电阻（典型值 4.7KΩ），因为 I2C 引脚使用开漏输出：

  • 输出低电平：N-MOS 导通，拉低总线
  • 输出高电平：N-MOS 截止，靠上拉电阻拉高（开漏原理）
  • 这种设计允许多个设备"线与"（任意设备可拉低总线）

参考：开发板原理图 I2C 接口部分（24C02 电路） 参考：参考手册 §16（I2C 寄存器）

24C02 EEPROM 详解

24C02 是一个 2Kbit（256 字节） 的 I2C 串行 EEPROM。

参数 值
容量 256 字节（2Kbit）
页大小 8 字节（一次页写最多 8 字节）
写周期 5ms（内部擦写时间，期间不响应）
I2C 地址 0xA0（写）/ 0xA1（读）
地址引脚 A0/A1/A2（可配置，最多 8 个同型号设备共用总线）
工作电压 1.8V~5.5V
接口 I2C（标准/快速模式）

地址计算：

设备地址 = 1010 + A2 + A1 + A0 + R/W
           [7:4]  [3]  [2]  [1]  [0]
               1010  0    0    0   0/1

写地址 = 1010 0000 = 0xA0
读地址 = 1010 0001 = 0xA1

页写注意事项：24C02 的页大小为 8 字节，一次页写操作只能在同一页内。如果尝试跨页写入（如从地址 0x07 开始写 3 字节），地址会自动卷回到页开头（地址 0x00），覆盖已有数据。跨页时必须手动分页写入。

实验：软件模拟 I2C 读写 24C02

软件设计（寄存器版 — 软件模拟 I2C）

项目路径：stm32_base/13_i2c_software_register

文件：stm32_base/13_i2c_software_register/Hardware/I2C/i2c.h

#ifndef __I2C_H
#define __I2C_H

#include "stm32f10x.h"
#include "usart.h"
#include "delay.h"

// PB10=SCL, PB11=SDA
#define SCL_HIGH (GPIOB->ODR |= GPIO_ODR_ODR10)
#define SCL_LOW  (GPIOB->ODR &= ~GPIO_ODR_ODR10)
#define SDA_HIGH (GPIOB->ODR |= GPIO_ODR_ODR11)
#define SDA_LOW  (GPIOB->ODR &= ~GPIO_ODR_ODR11)
#define READ_SDA (GPIOB->IDR & GPIO_IDR_IDR11)

#define ACK  0
#define NACK 1
#define I2C_DELAY Delay_us(10)

void I2C_Init(void);
void I2C_Start(void);
void I2C_Stop(void);
void I2C_Ack(void);
void I2C_NAck(void);
uint8_t I2C_Wait4Ack(void);
void I2C_SendByte(uint8_t byte);
uint8_t I2C_ReadByte(void);

#endif

文件：stm32_base/13_i2c_software_register/Hardware/I2C/i2c.c

#include "i2c.h"

void I2C_Init(void)
{
    RCC->APB2ENR |= RCC_APB2ENR_IOPBEN;
    GPIOB->CRH |= (GPIO_CRH_MODE10 | GPIO_CRH_MODE11);
    GPIOB->CRH &= ~(GPIO_CRH_CNF10_1 | GPIO_CRH_CNF11_1);
    GPIOB->CRH |= (GPIO_CRH_CNF10_0 | GPIO_CRH_CNF11_0);
}

void I2C_Start(void)
{
    SCL_HIGH;
    SDA_HIGH;
    I2C_DELAY;
    SDA_LOW;
    I2C_DELAY;
}

void I2C_Stop(void)
{
    SCL_HIGH;
    SDA_LOW;
    I2C_DELAY;
    SDA_HIGH;
    I2C_DELAY;
}

void I2C_Ack(void)
{
    SDA_HIGH;
    SCL_LOW;
    I2C_DELAY;
    SDA_LOW;
    I2C_DELAY;
    SCL_HIGH;
    I2C_DELAY;
    SCL_LOW;
    I2C_DELAY;
    SDA_HIGH;
    I2C_DELAY;
}

void I2C_NAck(void)
{
    SDA_HIGH;
    SCL_LOW;
    I2C_DELAY;
    SCL_HIGH;
    I2C_DELAY;
    SCL_LOW;
    I2C_DELAY;
}

uint8_t I2C_Wait4Ack(void)
{
    SDA_HIGH;
    SCL_LOW;
    I2C_DELAY;
    SCL_HIGH;
    I2C_DELAY;
    uint8_t ack = READ_SDA;
    SCL_LOW;
    I2C_DELAY;
    return ack ? NACK : ACK;
}

void I2C_SendByte(uint8_t byte)
{
    for (uint8_t i = 0; i < 8; i++)
    {
        SCL_LOW;
        I2C_DELAY;
        if (byte & 0x80)
            SDA_HIGH;
        else
            SDA_LOW;
        I2C_DELAY;
        SCL_HIGH;
        I2C_DELAY;
        SCL_LOW;
        I2C_DELAY;
        byte <<= 1;
    }
}

uint8_t I2C_ReadByte(void)
{
    uint8_t data = 0;
    for (uint8_t i = 0; i < 8; i++)
    {
        SDA_HIGH;
        SCL_LOW;
        I2C_DELAY;
        SCL_HIGH;
        I2C_DELAY;
        data <<= 1;
        if (READ_SDA)
            data |= 0x01;
        SCL_LOW;
        I2C_DELAY;
    }
    return data;
}

文件：stm32_base/13_i2c_software_register/User/main.c

#include "usart.h"
#include "m24c02.h"
#include <string.h>

int main(void)
{
    USART_Init();
    M24C02_Init();

    printf("尚硅谷 I2C 软件模拟实验...\n");

    M24C02_WriteByte(0x00, 'a');
    M24C02_WriteByte(0x01, 'b');
    M24C02_WriteByte(0x02, 'c');

    uint8_t byte1 = M24C02_ReadByte(0x00);
    uint8_t byte2 = M24C02_ReadByte(0x01);
    uint8_t byte3 = M24C02_ReadByte(0x02);

    printf("%c\n%c\n%c\n", byte1, byte2, byte3);

    M24C02_WriteBytes(0x00, "123456", 6);

    uint8_t buff[50] = {0};
    M24C02_ReadBytes(0x00, buff, 6);
    printf("%s\n", buff);

    memset(buff, 0, sizeof(buff));

    M24C02_WriteBytes(0x05, "1234567890abcdefghijk", 21);
    M24C02_ReadBytes(0x00, buff, 21);
    printf("%s\n", buff);

    while (1) {}
}

软件设计（HAL 库版 — 硬件 I2C）

HAL 库使用结构体 I2C_HandleTypeDef 管理 I2C 外设，CubeMX 图形化配置后调用函数读写 EEPROM。

// HAL 库 I2C 写 24C02（Mem_Write 自动处理 START+地址+数据+STOP）
uint8_t data = 0x55;
HAL_I2C_Mem_Write(&hi2c1, 0xA0, 0x00, I2C_MEMADD_SIZE_8BIT, &data, 1, 100);
// 参数: hi2c句柄, 设备地址(7位+写), 存储器地址, 地址宽度, 数据指针, 数据长度, 超时ms

// 等待页写入完成（超时重试或轮询 ACK）
HAL_Delay(10);

// HAL 库 I2C 读 24C02
uint8_t read_val;
HAL_I2C_Mem_Read(&hi2c1, 0xA0, 0x00, I2C_MEMADD_SIZE_8BIT, &read_val, 1, 100);
// 自动处理: START+写地址+寄存器地址+RESTART+读地址+数据+NACK+STOP

printf("HAL I2C Read: 0x%02X\r\n", read_val);

核心函数速查表

I2C 操作 软件模拟 HAL 库
初始化 I2C_Init() HAL_I2C_Init()
写 EEPROM I2C_Start/SendByte/Stop 组合 HAL_I2C_Mem_Write(addr, mem_addr, data, len, timeout)
读 EEPROM Start+写地址+寄存器地址+RESTART+读地址+数据+NACK+Stop HAL_I2C_Mem_Read(addr, mem_addr, data, len, timeout)
发送字节 I2C_SendByte(byte) —（底层封装在 HAL 中）
读取字节 I2C_ReadByte() —（底层封装在 HAL 中）
等待应答 I2C_Wait4Ack() —（自动处理）
发应答/非应答 I2C_Ack() / I2C_NAck() —（自动处理）

常见问题与避坑

  1. I2C 总线卡死（SDA 一直被拉低） → 从机异常，连续发 9~18 个 SCL 脉冲让从机释放 SDA，然后发 STOP
  2. NACK 持续（从机不应答） → 检查设备地址（7 位+读写位是否正确）、上拉电阻是否焊接、SCL 频率是否太高
  3. 24C02 写入后读回不对 → 页写跨页溢出（每页 8 字节，跨页自动卷回！），需分页写入或逐字节写
  4. 写操作后需等待 → 24C02 需要约 5ms 内部写周期，在此期间不响应任何 I2C 操作
  5. 组合格式（先写后读） → 中间的 RESTART 不是 STOP+START，必须用 I2C_Start() 但不先发 I2C_Stop()
  6. 延时偏短导致时序异常 → I2C_DELAY 不够时增加（10us→20us），标准模式至少 5us 半周期