STM32实战：基于STM32F103的I2C通信（AT24Cxx EEPROM读写）

原创 于 2026-04-25 01:00:00 发布 · 230 阅读 · 3 ·
CC 4.0 BY-SA版权
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
文章标签：

#stm32 #嵌入式硬件 #单片机

文章目录

一、前言

1.1 技术背景

在嵌入式系统中，经常需要保存一些掉电不丢失的配置参数、校准数据或用户设置。EEPROM（Electrically Erasable Programmable Read-Only Memory）是理想的非易失性存储方案，相比Flash具有以下优势：

  • 字节级擦写：无需整页/扇区擦除，可直接改写单个字节
  • 长寿命：擦写次数可达100万次
  • 低功耗：待机电流仅1-2μA
  • 高可靠性：数据保存期长达100年
  • 简单易用：I2C接口，只需2根线

AT24C系列是Atmel（现Microchip）公司的I2C接口EEPROM，容量从128字节到512Kbit不等，广泛应用于：

  • 系统参数存储
  • 用户配置保存
  • 校准数据存储
  • 运行日志记录

1.2 本文目标

通过本教程，你将掌握：

  • I2C通信协议原理和时序
  • STM32F103的I2C外设配置
  • AT24C02/04/08/16/32/64/128系列EEPROM操作
  • 分页写入和随机读取
  • 写保护和地址寻址

适合读者：

  • 需要存储配置参数的嵌入式开发者
  • 学习I2C通信协议的初学者
  • 需要实现数据持久化的项目开发者

1.3 技术栈

组件型号/版本说明
主控芯片STM32F103C8T6ARM Cortex-M3
EEPROMAT24C02/04/08/162Kbit~16Kbit I2C EEPROM
开发环境Keil MDK 5嵌入式开发IDE
通信协议I2C串行总线接口

二、环境准备

2.1 硬件准备

核心硬件清单：

  • STM32F103C8T6最小系统板 × 1
  • AT24C02/04/08/16模块 × 1
  • USB转TTL模块 × 1
  • 上拉电阻4.7KΩ × 2（部分模块已集成）
  • 杜邦线若干

硬件连接图：

STM32F103C8T6          AT24C02
┌─────────────┐        ┌─────────────┐
│             │        │             │
│  PB6(SCL) ──┼────────┼────> SCL    │
│  PB7(SDA) ──┼────────┼────> SDA    │
│  3.3V     ──┼────────┼────  VCC    │
│  GND      ──┼────────┼────  GND    │
│             │        │             │
└─────────────┘        └─────────────┘

上拉电阻连接（如模块未集成）：
3.3V ──[4.7KΩ]── SCL
3.3V ──[4.7KΩ]── SDA

AT24C02引脚定义：

引脚名称功能
1A0地址选择位0
2A1地址选择位1
3A2地址选择位2
4GND地
5SDA串行数据
6SCL串行时钟
7WP写保护（高电平有效）
8VCC电源（2.5-5.5V）

地址引脚配置：

  • A0、A1、A2接地或接VCC，用于设置设备地址
  • 最多可连接8个AT24Cxx器件在同一I2C总线上

2.2 AT24Cxx存储结构

容量对照表：

型号容量字节数页大小页数地址字节
AT24C011Kbit1288161
AT24C022Kbit2568321
AT24C044Kbit51216321
AT24C088Kbit102416641
AT24C1616Kbit2048161281
AT24C3232Kbit4096321282
AT24C6464Kbit8192322562
AT24C128128Kbit16384642562

重要特性：

  • 最小写入单位：页
  • 页内地址自动递增
  • 跨页写入需要分多次操作
  • 写入周期：最大5ms

三、I2C通信协议

3.1 I2C基本原理

I2C（Inter-Integrated Circuit）是一种同步串行通信协议，特点：

  • 两线制：SDA（数据线）、SCL（时钟线）
  • 多主多从：支持一主多从或多主模式
  • 地址寻址：7位或10位设备地址
  • 应答机制：每字节传输后接收方应答
  • 开漏输出：需外接上拉电阻

I2C时序：

起始条件(S)和停止条件(P)：

    SCL ──┐     ┌─────┐     ┌─────┐     ┌──
          └─────┘     └─────┘     └─────┘
    SDA ──┐  ┌────────────────────────────────
          └──┘
          ↑
        起始条件：SCL高时，SDA从高变低

    SCL ──┐     ┌─────┐     ┌─────┐     ┌──
          └─────┘     └─────┘     └─────┘
    SDA ────────────────────────────┐  ┌───
                                    └──┘
                                     ↑
                                   停止条件：SCL高时，SDA从低变高

数据传输时序：

    SCL ──┐  ┌──┐  ┌──┐  ┌──┐  ┌──┐  ┌──┐  ┌──┐  ┌──┐  ┌──┐  ┌──
          └──┘  └──┘  └──┘  └──┘  └──┘  └──┘  └──┘  └──┘  └──┘
              ↑     ↑     ↑     ↑     ↑     ↑     ↑     ↑
            采样  采样  采样  采样  采样  采样  采样  采样
            (上升沿)

    SDA ───┐     ┌─────┐     ┌───────────┐     ┌─────┐
           └─────┘     └─────┘           └─────┘     └────
           D7    D6    D5    D4    D3    D2    D1    D0    ACK

3.2 I2C通信流程

写操作（单字节）：

主机发送：
┌─────┬─────────┬─────────┬─────────┬─────────┬─────┐
│  S  │ 设备地址 │   ACK   │ 内存地址 │   ACK   │ 数据 │
│     │  (写)   │  (从机) │         │  (从机) │     │
└─────┴─────────┴─────────┴─────────┴─────────┴─────┘

设备地址格式（7位）：
┌─────┬─────┬─────┬─────┬─────┬─────┬─────┬─────┐
│ A6  │ A5  │ A4  │ A3  │ A2  │ A1  │ A0  │ R/W │
└─────┴─────┴─────┴─────┴─────┴─────┴─────┴─────┘
│        固定部分       │  地址引脚 │  0=写  │
│    (1010 for EEPROM)  │  (A2A1A0)│  1=读  │

读操作（随机读取）：

主机发送：
┌─────┬─────────┬─────────┬─────────┬─────┐
│  S  │ 设备地址 │   ACK   │ 内存地址 │  ACK │
│     │  (写)   │  (从机) │         │      │
└─────┴─────────┴─────────┴─────────┴─────┘

重复起始：
┌─────┬─────────┬─────────┬─────────┬─────┐
│ Sr  │ 设备地址 │   ACK   │   数据   │ ACK │
│     │  (读)   │  (从机) │  (从机)  │(主机)│
└─────┴─────────┴─────────┴─────────┴─────┘

四、驱动程序实现

4.1 I2C外设初始化

📄 创建文件：i2c_eeprom.c

/**
 * @file i2c_eeprom.c
 * @brief AT24Cxx I2C EEPROM驱动程序
 * 
 * 功能：
 * - I2C1初始化（标准模式100KHz）
 * - AT24Cxx基本操作（字节读写、页写入）
 * - 多型号支持（AT24C02~AT24C128）
 * - 写保护和等待处理
 */

#include "i2c_eeprom.h"
#include "stm32f10x.h"
#include <string.h>

/* EEPROM设备地址基址（A2A1A0=000） */
#define EEPROM_BASE_ADDR    0xA0

/* 超时时间 */
#define I2C_TIMEOUT_MS      100
#define EEPROM_WRITE_DELAY_MS   6   // 写入周期最大5ms

/* 当前EEPROM型号参数 */
static uint16_t eeprom_page_size = 8;       // 页大小
static uint16_t eeprom_total_size = 256;    // 总字节数
static uint8_t eeprom_addr_bytes = 1;       // 地址字节数

/**
 * @brief 初始化I2C1
 * 
 * 配置参数：
 * - 时钟频率：100KHz（标准模式）
 * - 占空比：2:1
 * - 应答使能：开启
 * - 7位地址模式
 */
void I2C_EEPROM_Init(void)
{
    GPIO_InitTypeDef GPIO_InitStruct;
    I2C_InitTypeDef I2C_InitStruct;
    
    /* 1. 使能时钟 */
    RCC_APB2PeriphClockCmd(RCC_APB2Periph_GPIOB, ENABLE);
    RCC_APB1PeriphClockCmd(RCC_APB1Periph_I2C1, ENABLE);
    
    /* 2. 配置GPIO */
    // PB6 - SCL (复用开漏)
    GPIO_InitStruct.GPIO_Pin = GPIO_Pin_6;
    GPIO_InitStruct.GPIO_Mode = GPIO_Mode_AF_OD;
    GPIO_InitStruct.GPIO_Speed = GPIO_Speed_50MHz;
    GPIO_Init(GPIOB, &GPIO_InitStruct);
    
    // PB7 - SDA (复用开漏)
    GPIO_InitStruct.GPIO_Pin = GPIO_Pin_7;
    GPIO_Init(GPIOB, &GPIO_InitStruct);
    
    /* 3. 配置I2C */
    I2C_InitStruct.I2C_ClockSpeed = 100000;     // 100KHz
    I2C_InitStruct.I2C_Mode = I2C_Mode_I2C;
    I2C_InitStruct.I2C_DutyCycle = I2C_DutyCycle_2;
    I2C_InitStruct.I2C_OwnAddress1 = 0x00;      // 主机模式
    I2C_InitStruct.I2C_Ack = I2C_Ack_Enable;
    I2C_InitStruct.I2C_AcknowledgedAddress = I2C_AcknowledgedAddress_7bit;
    I2C_Init(I2C1, &I2C_InitStruct);
    
    /* 4. 使能I2C */
    I2C_Cmd(I2C1, ENABLE);
}

/**
 * @brief 设置EEPROM型号
 * @param type EEPROM型号
 */
void EEPROM_SetType(EEPROM_Type type)
{
    switch (type) {
        case EEPROM_AT24C01:
            eeprom_page_size = 8;
            eeprom_total_size = 128;
            eeprom_addr_bytes = 1;
            break;
        case EEPROM_AT24C02:
            eeprom_page_size = 8;
            eeprom_total_size = 256;
            eeprom_addr_bytes = 1;
            break;
        case EEPROM_AT24C04:
            eeprom_page_size = 16;
            eeprom_total_size = 512;
            eeprom_addr_bytes = 1;
            break;
        case EEPROM_AT24C08:
            eeprom_page_size = 16;
            eeprom_total_size = 1024;
            eeprom_addr_bytes = 1;
            break;
        case EEPROM_AT24C16:
            eeprom_page_size = 16;
            eeprom_total_size = 2048;
            eeprom_addr_bytes = 1;
            break;
        case EEPROM_AT24C32:
            eeprom_page_size = 32;
            eeprom_total_size = 4096;
            eeprom_addr_bytes = 2;
            break;
        case EEPROM_AT24C64:
            eeprom_page_size = 32;
            eeprom_total_size = 8192;
            eeprom_addr_bytes = 2;
            break;
        case EEPROM_AT24C128:
            eeprom_page_size = 64;
            eeprom_total_size = 16384;
            eeprom_addr_bytes = 2;
            break;
        default:
            eeprom_page_size = 8;
            eeprom_total_size = 256;
            eeprom_addr_bytes = 1;
            break;
    }
}

/**
 * @brief 等待I2C事件
 * @param event 等待的事件
 * @param timeout 超时时间
 * @return 0=成功，1=超时
 */
static uint8_t I2C_WaitEvent(uint32_t event, uint32_t timeout)
{
    uint32_t start = GetSysTick();
    while (!I2C_CheckEvent(I2C1, event)) {
        if ((GetSysTick() - start) > timeout) {
            return 1;
        }
    }
    return 0;
}

/**
 * @brief 发送起始条件
 * @return 0=成功，1=失败
 */
static uint8_t I2C_Start(void)
{
    I2C_GenerateSTART(I2C1, ENABLE);
    if (I2C_WaitEvent(I2C_EVENT_MASTER_MODE_SELECT, I2C_TIMEOUT_MS)) {
        return 1;
    }
    return 0;
}

/**
 * @brief 发送停止条件
 */
static void I2C_Stop(void)
{
    I2C_GenerateSTOP(I2C1, ENABLE);
}

/**
 * @brief 发送设备地址
 * @param addr 设备地址
 * @param direction 传输方向（I2C_Direction_Transmitter/Receiver）
 * @return 0=成功，1=失败
 */
static uint8_t I2C_SendAddress(uint8_t addr, uint8_t direction)
{
    I2C_Send7bitAddress(I2C1, addr, direction);
    
    if (direction == I2C_Direction_Transmitter) {
        if (I2C_WaitEvent(I2C_EVENT_MASTER_TRANSMITTER_MODE_SELECTED, I2C_TIMEOUT_MS)) {
            return 1;
        }
    } else {
        if (I2C_WaitEvent(I2C_EVENT_MASTER_RECEIVER_MODE_SELECTED, I2C_TIMEOUT_MS)) {
            return 1;
        }
    }
    return 0;
}

/**
 * @brief 发送数据
 * @param data 数据
 * @return 0=成功，1=失败
 */
static uint8_t I2C_SendData(uint8_t data)
{
    I2C_SendData(I2C1, data);
    if (I2C_WaitEvent(I2C_EVENT_MASTER_BYTE_TRANSMITTED, I2C_TIMEOUT_MS)) {
        return 1;
    }
    return 0;
}

/**
 * @brief 接收数据
 * @param ack 是否发送ACK（1=ACK，0=NACK）
 * @return 接收到的数据
 */
static uint8_t I2C_ReceiveData(uint8_t ack)
{
    if (ack) {
        I2C_AcknowledgeConfig(I2C1, ENABLE);
    } else {
        I2C_AcknowledgeConfig(I2C1, DISABLE);
    }
    
    while (I2C_GetFlagStatus(I2C1, I2C_FLAG_RXNE) == RESET);
    return I2C_ReceiveData(I2C1);
}

/**
 * @brief 等待EEPROM写入完成
 * @param device_addr 设备地址
 * @return 0=成功，1=超时
 */
static uint8_t EEPROM_WaitWriteComplete(uint8_t device_addr)
{
    uint32_t start = GetSysTick();
    
    while ((GetSysTick() - start) < EEPROM_WRITE_DELAY_MS) {
        // 尝试发送起始条件+设备地址
        if (I2C_Start() == 0) {
            I2C_Send7bitAddress(I2C1, device_addr, I2C_Direction_Transmitter);
            
            // 等待ACK或超时
            uint32_t ack_start = GetSysTick();
            while ((GetSysTick() - ack_start) < 10) {
                if (I2C_CheckEvent(I2C_EVENT_MASTER_TRANSMITTER_MODE_SELECTED)) {
                    I2C_Stop();
                    return 0;  // 写入完成
                }
                if (I2C_GetFlagStatus(I2C1, I2C_FLAG_AF)) {
                    I2C_ClearFlag(I2C1, I2C_FLAG_AF);
                    break;  // 未响应，继续等待
                }
            }
            I2C_Stop();
        }
    }
    
    return 1;  // 超时
}

/**
 * @brief 计算设备地址
 * @param mem_addr 内存地址
 * @return 设备地址（含块选择位）
 */
static uint8_t EEPROM_GetDeviceAddr(uint16_t mem_addr)
{
    uint8_t addr = EEPROM_BASE_ADDR;
    
    // 对于AT24C04/08/16，使用地址位作为块选择
    if (eeprom_total_size > 256 && eeprom_total_size <= 2048) {
        // AT24C04: A8位用于块选择
        // AT24C08: A8,A9位用于块选择
        // AT24C16: A8,A9,A10位用于块选择
        addr |= ((mem_addr >> 8) & 0x07) << 1;
    }
    
    return addr;
}

/**
 * @brief 写入一个字节
 * @param addr 内存地址
 * @param data 数据
 * @return 0=成功，1=失败
 */
uint8_t EEPROM_WriteByte(uint16_t addr, uint8_t data)
{
    uint8_t device_addr = EEPROM_GetDeviceAddr(addr);
    
    // 起始条件
    if (I2C_Start()) return 1;
    
    // 发送设备地址（写）
    if (I2C_SendAddress(device_addr, I2C_Direction_Transmitter)) {
        I2C_Stop();
        return 1;
    }
    
    // 发送内存地址
    if (eeprom_addr_bytes == 2) {
        if (I2C_SendData((addr >> 8) & 0xFF)) {
            I2C_Stop();
            return 1;
        }
    }
    if (I2C_SendData(addr & 0xFF)) {
        I2C_Stop();
        return 1;
    }
    
    // 发送数据
    if (I2C_SendData(data)) {
        I2C_Stop();
        return 1;
    }
    
    // 停止条件
    I2C_Stop();
    
    // 等待写入完成
    return EEPROM_WaitWriteComplete(device_addr);
}

/**
 * @brief 读取一个字节
 * @param addr 内存地址
 * @return 读取的数据
 */
uint8_t EEPROM_ReadByte(uint16_t addr)
{
    uint8_t device_addr = EEPROM_GetDeviceAddr(addr);
    uint8_t data;
    
    // 第一步：发送内存地址（写模式）
    if (I2C_Start()) return 0xFF;
    if (I2C_SendAddress(device_addr, I2C_Direction_Transmitter)) {
        I2C_Stop();
        return 0xFF;
    }
    
    // 发送内存地址
    if (eeprom_addr_bytes == 2) {
        if (I2C_SendData((addr >> 8) & 0xFF)) {
            I2C_Stop();
            return 0xFF;
        }
    }
    if (I2C_SendData(addr & 0xFF)) {
        I2C_Stop();
        return 0xFF;
    }
    
    // 第二步：重复起始，读数据
    if (I2C_Start()) {
        I2C_Stop();
        return 0xFF;
    }
    if (I2C_SendAddress(device_addr, I2C_Direction_Receiver)) {
        I2C_Stop();
        return 0xFF;
    }
    
    // 读取数据（NACK）
    data = I2C_ReceiveData(0);
    
    // 停止条件
    I2C_Stop();
    
    return data;
}

/**
 * @brief 页写入
 * @param addr 起始地址（必须页对齐）
 * @param data 数据指针
 * @param len 数据长度（不能超过页大小）
 * @return 0=成功，1=失败
 */
uint8_t EEPROM_PageWrite(uint16_t addr, const uint8_t *data, uint8_t len)
{
    uint8_t device_addr = EEPROM_GetDeviceAddr(addr);
    
    // 检查参数
    if (len == 0 || len > eeprom_page_size) {
        return 1;
    }
    
    // 起始条件
    if (I2C_Start()) return 1;
    
    // 发送设备地址（写）
    if (I2C_SendAddress(device_addr, I2C_Direction_Transmitter)) {
        I2C_Stop();
        return 1;
    }
    
    // 发送内存地址
    if (eeprom_addr_bytes == 2) {
        if (I2C_SendData((addr >> 8) & 0xFF)) {
            I2C_Stop();
            return 1;
        }
    }
    if (I2C_SendData(addr & 0xFF)) {
        I2C_Stop();
        return 1;
    }
    
    // 发送数据
    for (uint8_t i = 0; i < len; i++) {
        if (I2C_SendData(data[i])) {
            I2C_Stop();
            return 1;
        }
    }
    
    // 停止条件
    I2C_Stop();
    
    // 等待写入完成
    return EEPROM_WaitWriteComplete(device_addr);
}

/**
 * @brief 连续写入（自动分页）
 * @param addr 起始地址
 * @param data 数据指针
 * @param len 数据长度
 * @return 0=成功，1=失败
 */
uint8_t EEPROM_WriteData(uint16_t addr, const uint8_t *data, uint16_t len)
{
    uint16_t page_addr;
    uint16_t page_offset;
    uint16_t write_len;
    
    while (len > 0) {
        // 计算当前页地址和偏移
        page_addr = addr & ~(eeprom_page_size - 1);
        page_offset = addr & (eeprom_page_size - 1);
        
        // 计算本次可写入的长度
        write_len = eeprom_page_size - page_offset;
        if (write_len > len) {
            write_len = len;
        }
        
        // 页写入
        if (EEPROM_PageWrite(page_addr, data, write_len) != 0) {
            return 1;
        }
        
        addr += write_len;
        data += write_len;
        len -= write_len;
    }
    
    return 0;
}

/**
 * @brief 连续读取
 * @param addr 起始地址
 * @param buffer 数据缓冲区
 * @param len 读取长度
 */
void EEPROM_ReadData(uint16_t addr, uint8_t *buffer, uint16_t len)
{
    uint8_t device_addr = EEPROM_GetDeviceAddr(addr);
    
    if (len == 0) return;
    
    // 第一步：发送内存地址（写模式）
    I2C_Start();
    I2C_SendAddress(device_addr, I2C_Direction_Transmitter);
    
    // 发送内存地址
    if (eeprom_addr_bytes == 2) {
        I2C_SendData((addr >> 8) & 0xFF);
    }
    I2C_SendData(addr & 0xFF);
    
    // 第二步：重复起始，读数据
    I2C_Start();
    I2C_SendAddress(device_addr, I2C_Direction_Receiver);
    
    // 读取数据
    for (uint16_t i = 0; i < len; i++) {
        if (i < len - 1) {
            buffer[i] = I2C_ReceiveData(1);  // 发送ACK
        } else {
            buffer[i] = I2C_ReceiveData(0);  // 最后一个字节发送NACK
        }
    }
    
    // 停止条件
    I2C_Stop();
}

📄 创建文件：i2c_eeprom.h

/**
 * @file i2c_eeprom.h
 * @brief AT24Cxx EEPROM驱动头文件
 */

#ifndef __I2C_EEPROM_H
#define __I2C_EEPROM_H

#include <stdint.h>

/* EEPROM型号枚举 */
typedef enum {
    EEPROM_AT24C01 = 0,
    EEPROM_AT24C02,
    EEPROM_AT24C04,
    EEPROM_AT24C08,
    EEPROM_AT24C16,
    EEPROM_AT24C32,
    EEPROM_AT24C64,
    EEPROM_AT24C128
} EEPROM_Type;

/* 函数声明 */
void I2C_EEPROM_Init(void);
void EEPROM_SetType(EEPROM_Type type);
uint8_t EEPROM_WriteByte(uint16_t addr, uint8_t data);
uint8_t EEPROM_ReadByte(uint16_t addr);
uint8_t EEPROM_PageWrite(uint16_t addr, const uint8_t *data, uint8_t len);
uint8_t EEPROM_WriteData(uint16_t addr, const uint8_t *data, uint16_t len);
void EEPROM_ReadData(uint16_t addr, uint8_t *buffer, uint16_t len);

#endif /* __I2C_EEPROM_H */

4.2 主程序

📄 创建文件：main.c

/**
 * @file main.c
 * @brief I2C EEPROM测试主程序
 */

#include "stm32f10x.h"
#include "i2c_eeprom.h"
#include "usart1.h"
#include <stdio.h>
#include <string.h>

static volatile uint32_t sys_tick = 0;

void SysTick_Handler(void)
{
    sys_tick++;
}

uint32_t GetSysTick(void)
{
    return sys_tick;
}

void Delay_ms(uint32_t ms)
{
    uint32_t start = GetSysTick();
    while ((GetSysTick() - start) < ms);
}

void Test_WriteRead(void)
{
    uint8_t write_data[] = {0x11, 0x22, 0x33, 0x44, 0x55, 0x66, 0x77, 0x88};
    uint8_t read_data[8];
    
    printf("\r\n=== EEPROM读写测试 ===\r\n");
    
    // 写入数据
    printf("写入数据: ");
    for (int i = 0; i < 8; i++) {
        printf("%02X ", write_data[i]);
    }
    printf("\r\n");
    
    if (EEPROM_WriteData(0, write_data, 8) == 0) {
        printf("写入成功\r\n");
    } else {
        printf("写入失败\r\n");
        return;
    }
    
    Delay_ms(10);
    
    // 读取数据
    EEPROM_ReadData(0, read_data, 8);
    
    printf("读取数据: ");
    for (int i = 0; i < 8; i++) {
        printf("%02X ", read_data[i]);
    }
    printf("\r\n");
    
    // 校验
    if (memcmp(write_data, read_data, 8) == 0) {
        printf("校验通过!\r\n");
    } else {
        printf("校验失败!\r\n");
    }
}

void ShowMenu(void)
{
    printf("\r\n");
    printf("========== I2C EEPROM 测试菜单 ==========\r\n");
    printf("1. 读写测试\r\n");
    printf("2. 页写入测试\r\n");
    printf("3. 连续写入测试\r\n");
    printf("0. 清屏\r\n");
    printf("=========================================\r\n");
    printf("请输入选项: ");
}

int main(void)
{
    char cmd;
    
    SystemInit();
    SysTick_Config(SystemCoreClock / 1000);
    USART1_Init();
    I2C_EEPROM_Init();
    EEPROM_SetType(EEPROM_AT24C02);
    
    printf("\r\n");
    printf("====================================\r\n");
    printf("    AT24C02 I2C EEPROM 测试程序\r\n");
    printf("====================================\r\n");
    
    ShowMenu();
    
    while (1) {
        if (USART1_GetRxDataLength() > 0) {
            if (USART1_ReadData((uint8_t *)&cmd, 1) > 0) {
                switch (cmd) {
                    case '1':
                        Test_WriteRead();
                        break;
                    case '2':
                        printf("页写入测试...\r\n");
                        break;
                    case '3':
                        printf("连续写入测试...\r\n");
                        break;
                    case '0':
                        for (int i = 0; i < 50; i++) printf("\r\n");
                        break;
                    default:
                        printf("无效选项\r\n");
                        break;
                }
                ShowMenu();
            }
        }
    }
}

五、测试与验证

5.1 硬件测试

  • 测量SDA和SCL电压：空闲时高电平（3.3V）
  • 检查上拉电阻：4.7KΩ
  • 使用示波器观察I2C波形

5.2 软件测试

测试项目：

  1. 单字节读写
  2. 页写入（8字节）
  3. 跨页写入
  4. 连续读写
  5. 写入寿命测试

六、故障排查

问题原因解决方案
无ACK地址错误检查A0A1A2引脚配置
数据错误时序问题降低I2C速度
写入失败写保护检查WP引脚
读取全FF未写入先执行写入操作

七、总结

7.1 核心知识点

  1. I2C通信协议和时序
  2. AT24Cxx存储结构和寻址
  3. 分页写入和跨页处理
  4. STM32 I2C外设配置

7.2 应用场景

  • 系统参数存储
  • 用户配置保存
  • 校准数据存储
  • 运行日志记录
【STM32实用例程】硬件IIC(I2C)+EEPROM(AT24Cxx多型号芯片)通用代码（附带芯片手册）
09-20
配套理论讲解：【STM32学习笔记】硬件I2C读写EEPROM(AT24C02)的工作时序和编程指南 http://t.csdn.cn/mB6q9 1、【完整例程】基于STM32F103ZET6编写，通过按键控制数据的写入和读取，并通过串口打印读取到的数据； 2、【一码全包】针对AT24CXX系列芯片编写了通用代码，只需在头文件中更改相关宏定义即可改变芯片型号(支持AT24C01、AT24C02、AT24C04、AT24C08、AT24C16) 3、【单字节读写模式】针对AT24CXX芯片的（RandomRead&BYTEWrite）指定地址的单字节读写模式，编写了相关函数，包括单字节读写、多字节读写、u16和u32型数据的读写函数； 4、【按页连续读写模式】针对AT24CXX芯片的（SequentialRead&PageWrite）指定地址的连续读写模式，编写了以页(Page)为单位的多字节连续读写函数，具体还分为只在当前页操作和可跨页操作两种类型，通过这一部分的学习可深入了解AT24CXX系列芯片的内部存储单元结构和寻址方式，理解“页Page”的概念。
【STM32实用例程】软件IIC(I2C)+EEPROM(AT24Cxx多型号芯片)通用代码（附带芯片手册）
09-15
1、【完整例程】基于STM32F103ZET6编写，通过按键控制数据的写入和读取，并通过串口打印读取到的数据； 2、【透彻理解IIC时序】超详细的软件IIC实现代码（带详细注释），初学者可以详细了解IIC协议；重点标注了每个延时函数的作用，便于透彻的理解IIC时序。 3、【一码全包】针对AT24CXX系列芯片编写了通用代码，只需在头文件中更改相关宏定义即可改变芯片型号(支持AT24C01、AT24C02、AT24C04、AT24C08、AT24C16) 4、【单字节读写模式】针对AT24CXX芯片的（RandomRead&BYTEWrite）指定地址的单字节读写模式，编写了相关函数，包括单字节读写、多字节读写、u16和u32型数据的读写函数； 5、【按页连续读写模式】针对AT24CXX芯片的（SequentialRead&PageWrite）指定地址的连续读写模式，编写了以页(Page)为单位的多字节连续读写函数，具体还分为只在当前页操作和可跨页操作两种类型，通过这一部分的学习可深入了解AT24CXX系列芯片的内部存储单元结构和寻址方式，理解“页Page”的概念。
STM32基于HAL工程硬件I2C读取AT24Cxx数据
perseverance51博客
04-02 2155
STM32基于STM32-HAL工程硬件I2C读取AT24Cxx数据
[STM32] I2C通信协议实战：从零驱动24C02 EEPROM
www00的博客
02-13 159
本文详细介绍了STM32通过I2C通信协议驱动24C02 EEPROM的实战教程，涵盖I2C协议基础、硬件连接配置、时序模拟、应答机制及读写操作。重点解析了软件模拟I2C的时序控制和常见调试技巧，帮助开发者高效实现可靠的数据存储与通信。
STM32下I2C协议读写EEPROM实战示例
weixin_28872035的博客
01-15 1036
通过STM32实现I2C协议与EEPROM的通信，详细讲解I2C协议时序、地址配置及数据读写流程，结合实际代码演示操作步骤，帮助掌握i2c协议在嵌入式系统中的典型应用。
STM32基于HAL工程硬件I2C读写AT24C02/04/08数据
perseverance51博客
04-02 2095
STM32基于STM32-HAL工程硬件I2C读写AT24C02/04/08数据
STM32调试常见问题：I2C读写EEPROM失败代码排查
weixin_32535825的博客
01-14 1070
实际调试STM32时，I2C读写EEPROM常因时序配置错误或地址 mismatch 导致失败。通过分析i2c读写eeprom代码中的起始信号、应答机制和延时控制，能快速定位问题。掌握这些细节可显著提升调试效率。
图解说明STM32硬件I2C模块读写EEPROM流程与代码
weixin_34374684的博客
01-06 338
深入解析STM32硬件I2C模块如何实现对EEPROM的读写操作，结合时序图和实际代码演示i2c读写eeprom代码的编写要点，帮助开发者快速掌握稳定可靠的通信实现方法。
STM32使用硬件I2C读写AT24C02 EEPROM（二）
u013050118的专栏
10-26 1043
使用stm32 硬件i2c读写at24c02 芯片需要注意延时否则会锁死和多字节读写的限制，谨慎处理读写操作中的细节，可以有效解决通信中遇到的问题，确保数据的可靠存储和读取。
STM32 CubeMX配置I2C读写EEPROM代码指南
weixin_42589700的博客
12-27 471
手把手教你使用STM32 CubeMX生成I2C读写EEPROM代码，涵盖初始化配置、函数调用与调试技巧，轻松实现数据存储与读取，提升嵌入式开发效率。
STM32读写AT24CXX全系列EEPROM驱动教程
weixin_47017612的博客
08-06 1856
AT24CXX通用单片机驱动，全型号测试通过，可移植性强！
STM32F103 I2C Flash读写程序_STM32F103_at24cxx_
09-29
采用STM32F103系列单片机读写AT24CXX系列IIC存储芯片。
使用STM32F103C8T6实现EEPROM（使用AT24C01~AT24C256芯片均可），已经过实物测试
07-18
包含IIC底层驱动代码，AT24CXX初始化代码，单个写入、单个读取函数，连续写入、连续读取函数注释清晰，简单易懂
STM32 DMA程序（标准外设库版本）
leo__520的博客
04-23 242
基于STM32标准外设库的完整DMA程序，包含内存到内存、外设到内存、内存到外设的DMA传输实现。
STM32实战：基于STM32F103的智能饮水机温度控制
LCG元的博客
04-21 506
本文介绍了一个基于STM32F103的智能饮水机控制系统设计方案。系统采用DS18B20温度传感器实现精准温控，通过PID算法调节继电器和可控硅控制加热功率，具备多档温度设定（25℃/45℃/85℃/100℃）、水位检测、防干烧保护等功能。硬件配置包括STM32主控、TFT彩屏、触摸按键、旋转编码器等模块，支持节能模式和安全保护。系统适用于家庭、办公等多种场景，可满足泡奶、冲茶等不同需求。开发涉及温度传感器驱动、PID控制算法、GUI界面设计等关键技术，提供完整的硬件连接方案和软件实现框架。
STM32 控制 3 个步进电机方案
jghhh01的博客
04-22 233
STM32 控制 3 个步进电机方案，适用于 STM32F1 / F4 / G0 / L4（HAL 库），支持 独立速度 / 启停 / 加减速。
单片机启动流程以STM32举例
wxr2268715051的博客
04-21 710
0x00000000~0x0007FFFF这段空间属于重映射区，根据BOOT的不同选择映射到不同的内存区域。假设我们现在选择了主flash模式，内存映射到0x08000000开始执行，首先进行的就是读取加载向量表。从 0x00000000 （已经被映射为0x08000000）读出一个值 → 放进 MSP（主栈指针）如果启用RTOS，之前步骤都不变，在main函数当中才进行RTOS的初始化。MSP 指向主栈的栈顶，在 SRAM 的高地址处。把“未初始化的全局/静态变量”在 RAM的。最后进入 main()
瑞萨 FSP 和 STM32 HAL 库的启动流程核心差异
04-21 178
文章摘要（149字）： 瑞萨FSP与STM32 HAL库的启动流程差异主要体现在实现载体（FSP以C为主整合全流程，STM32依赖汇编）、设计理念（FSP一站式配置vs HAL库分层松耦合）和CMSIS适配（FSP基于新版CMSIS-Core）。核心差异包括：1）中断向量表实现（FSP用C定义，STM32需汇编）；2）复位处理（FSP通过C函数整合栈/时钟初始化，STM32需手动调用HAL_Init()）；3）开发体验（FSP工具链自动生成代码，STM32需手动修改汇编/C文件）。FSP降低启动门槛但需遵循
STM32 上实现 Modbus-RTU
foundbug999的博客
04-21 251
STM32 上实现 Modbus-RTU ，最稳妥的是“裸机驱动 + 状态机”（资源小、实时性强）。
STM32 定时器程序（标准外设库版本）
最新发布
fengfuyao985的博客
04-23 231
STM32定时器程序，包含基本定时、PWM输出、输入捕获、编码器接口和高级定时器应用。
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包

打赏作者

LCG元

你的鼓励将是我创作的最大动力！

¥1 ¥2 ¥4 ¥6 ¥10 ¥20
扫码支付：¥1
获取中
扫码支付

您的余额不足，请更换扫码支付或充值

打赏作者

实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值