STM8S硬件I2C读写EEPROM：从软件模拟到产品级驱动实践

简介：面向STM8S系列嵌入式开发者的I2C读写EEPROM硬件例程包，针对数据存储中常见的24C02、24C04等EEPROM读写需求，提供一套可直接在IAR环境下编译运行的完整工程。代码基于STM8S的硬件I2C外设实现，不依赖软件模拟时序，通信实时性更好，适合有一定C语言基础和STM8S外设开发经验、希望快速掌握硬件I2C用法的开发者。压缩包共68个文件，以31个C源文件和32个头文件为主体，涵盖STM8S标准外设库、I2C底层驱动以及定时器、串口等BSP模块，并附带IAR工程文件（ewp、eww、ewd）、一份清理编译产物的批处理脚本和ReadMe说明，整体包体约216KB，目录按应用层、板级驱动和标准库分层，职责清晰；目前已有398人学习下载。借助该例程，开发者可以快速理解硬件I2C的初始化、主从收发、起始/停止条件生成、中断与错误处理机制，并参考其中I2C读写接口设计，将相关函数迁移到实际项目中，减少底层调试时间；对于正在学习STM8S外设驱动，或需要快速完成EEPROM数据存储功能的学生与工程师，这是可直接借鉴的工程级参考代码。

1. STM8S 硬件 I2C 读写 EEPROM：为什么软件 I2C 用得好好的也要换掉

用 STM8S 做小家电和工控板时，参数掉电保存基本绕不开 EEPROM。很多人习惯用 GPIO 模拟 I2C 时序，逻辑虽然简单，可一想到这里就发怵：CPU 被位翻转死死占住，中断一多时序就乱，读写频率一高就丢数据。这个工程就是一套基于 STM8S 硬件 I2C 外设的 EEPROM 读写方案，包含完整工程结构和可直接编译的驱动代码，把 I2C 这块“麻烦事”从业务逻辑里剥离出来。适合刚从软件模拟 I2C 换过来的开发者，也适合所有想把参数存储这件事做稳、做快、做到产品级的 STM8S 用户。

2. I2C 外设架构与工程结构：不摸清寄存器状态机，调试就是瞎猜

2.1 硬件 I2C 和软件 I2C 的本质差别

先交代一个容易忽略的事实：STM8S 的硬件 I2C 外设是一个独立的状态机。软件 I2C 里，SDA 和 SCL 的每个电平翻转都是 CPU 执行的指令；硬件 I2C 则是由外设自己按状态机产生时序，CPU 只需要在关键节点检查事件标志、准备数据。这个差别的直接后果是：代码里不再需要 delay_us 来回折腾，但你必须按外设的状态转移去写逻辑，否则会产生软件 I2C 完全没有的奇怪问题。

比如，硬件 I2C 在发送地址之后，产生的事件标志是 ADDR；发送数据之后，要等待 TXE 和 BTF。很多初学在软件 I2C 里形成的“先将 SCL 拉低，再移位”的思维惯性，迁移到硬件 I2C 上就会变成不看标志干等循环，最终超时退出。所以理解外设的寄存器状态，比记住一两个 API 重要得多。

下面用一个表格把几个核心寄存器的作用先列出来，后面写代码时心里有数。

这个表格在代码分析时很有用。实际上调 I2C 时，示波器看波形是辅助，最终定位问题靠的还是这些标志位的时序。你可以把 SR1 当成“外设现在做了什么”的实时清单，把 CR2 当成“接下来要做什么”的控制入口，两者对照着读，状态机自然就清晰了。

2.2 工程目录：一份能直接打开的 STM8S 基础工程

这个资源解压后是一个完整的集成开发环境工程。按常见做法，它把代码分成两层：底层是i2c_drv.c/h，负责外设寄存器的读写和基本发送接收原语；上层是eeprom_drv.c/h，负责按 EEPROM 芯片的时序拼装写入和读取指令。main.c 里只放了一个测试函数，用来验证读写结果。

STM8S-I2C-EEPROM/ ├── inc/ │ ├── main.h │ ├── stm8s.h // 芯片寄存器定义 │ ├── i2c_drv.h │ └── eeprom_drv.h ├── src/ │ ├── main.c │ ├── stm8s_it.c │ ├── i2c_drv.c │ └── eeprom_drv.c ├── project.ewp // 工程文件（EWARM 或 STVD） └── stm8s_conf.h

这里stm8s_conf.h是标准外设库的配置头，用来裁剪用到的外设模块。如果用的是寄存器版分享包，则没有stm8s_conf.h，而是直接操作寄存器。无论哪种，i2c_drv.c和eeprom_drv.c的接口都可以保持同一套，方便移植。

main.c 里的测试流程通常就是这样一段：

// main.c 中的功能验证流程 void main(void) { uint8_t write_buf[8] = {1, 2, 3, 4, 5, 6, 7, 8}; uint8_t read_buf[8] = {0}; CLK_Config(); GPIO_Config(); I2C_Config(); EEPROM_Write(0x0000, write_buf, 8); // 从地址 0 写 8 字节 DelayMs(10); // 等待内部写周期 EEPROM_Read(0x0000, read_buf, 8); // 读回 8 字节 while (1); }

这里EEPROM_Write和EEPROM_Read是高一层驱动，它们内部会调用I2C_Start、I2C_SendByte、I2C_Stop这些原语。看这个流程就明白，上层根本不关心 SCL 怎么翻转，它只问“起始信号发了吗”“字节发完了吗”“设备 ACK 了吗”。这就是硬件外设带来的模块化收益。

2.3 硬件连接：两条线上拉电阻决定了通信的“下限”

STM8S 的 I2C 引脚是开漏输出，必须外接上拉电阻才能输出高电平。常见做法是在 3.3V 供电下选 4.7kΩ 上拉到 VCC，如果总线速度快到 400kHz，则换成 2.2kΩ。上拉电阻太大，上升沿变缓，高速时容易误判电平；太小，则灌电流增大，引脚可能受不了。

如果你把 EEPROM 供电和 MCU 分开，还要注意电平匹配。比如 EEPROM 用 5V，MCU 的 I2C 引脚耐压不行就可能烧引脚；稳妥的方案是全部统一到 3.3V，或者在 SCL/SDA 上串 300Ω 电阻限流。这个工程默认按 3.3V 供电设计，你拿到手先确认一下自己板子的电平，避免跑起来后信号很奇怪。

GPIO 配置一般长这样：

void GPIO_Config(void) { GPIO_Init(GPIOB, GPIO_PIN_4 | GPIO_PIN_5, GPIO_MODE_OUT_OD_HIZ_FAST); }

OD_HIZ_FAST是开漏输出、高阻状态、快速翻转模式，这是 I2C 引脚的典型配置。开漏和高阻缺一不可：开漏保证外设能主动拉低，高阻保证外部上拉能将电平拉高。如果误配成推挽输出，两个设备一个拉低一个拉高，轻则通信失败，重则发热损伤引脚。这块内容虽然不算代码，但如果你想抄作业，建议先按这个连接图检查过一遍再上电。

2.4 为什么用 7 位设备地址而不是 10 位

STM8S 的 I2C 外设同时支持 7 位和 10 位地址模式，这个工程默认用 7 位。原因很简单：绝大多数 EEPROM 从机只支持 7 位地址，10 位模式在普通 8 引脚存储芯片上根本没有用。7 位模式下，发送的地址字节是“设备地址左移 1 位再拼上读写标志”。

比如设备地址是 0x50（7 位），写操作就发 0xA0，读操作就发 0xA1。很多新手一开始把 0xA0 当成设备地址本身，等看到读操作要发 0xA1 就糊涂了。实际上这只是同一个 7 位地址在不同方向上的编码。后面代码里的 0xA0 和 0xA1 就是这么来的，别被它绕晕。

3. 核心代码拆解：一次 I2C 读写从起始到停止的完整链路

3.1 I2C 初始化：时钟、GPIO 和外设使能的顺序

初始化顺序是个细节活。正确顺序是：先开外设时钟，再配 GPIO，接着复位 I2C 外设，然后配置参数，最后使能。

void I2C_Config(void) { CLK_PeripheralClockConfig(CLK_PERIPHERAL_I2C, ENABLE); // 打开 I2C 时钟 GPIO_Init(GPIOB, GPIO_PIN_4 | GPIO_PIN_5, GPIO_MODE_OUT_OD_HIZ_FAST); I2C_DeInit(); // 恢复默认，避免上次状态残留 I2C_Init(100000, I2C_DUTYCYCLE_2, I2C_ACK_CURR, I2C_ADDMODE_7BIT, 0x30); I2C_Cmd(ENABLE); }

逐行说明：I2C_DeInit()会把外设寄存器恢复成复位值，这一步不可省。之前遇到过开电后状态机残留导致死等卡死，加这一行就好了。I2C_Init第一个参数 100000 是通信速率，单位是 Hz，也就是标准 100kHz；I2C_DUTYCYCLE_2是占空比模式，高速模式才需要调，100kHz 保持默认即可；I2C_ACK_CURR表示当前字节传输后自动回 ACK；I2C_ADDMODE_7BIT选 7 位地址；最后一个 0x30 是芯片自身的从机地址，主模式下不参与通信，但标准库要求填一个值，别用 0x00 就行。

使能之后还可以加一句：

I2C_Cmd(ENABLE);

这里有个玄学：有些代码把它放在I2C_Init之前也能跑，但手册里明确要求先配置后使能。你要是遇到初始化后波形乱，先看看是不是把顺序写反了。

3.2 起始信号、发送字节与停止信号的原语实现

这一层是驱动的心脏。代码不多，但每个标志位的含义都要清楚。

// 产生起始信号 void I2C_Start(void) { I2C_GenerateSTART(ENABLE); while (I2C_GetFlagStatus(I2C_FLAG_SB) == RESET); // 等起始信号建立 } // 发送一个字节 uint8_t I2C_SendByte(uint8_t data) { uint8_t timeout = 200; I2C_SendData(data); while (I2C_GetFlagStatus(I2C_FLAG_TXE) == RESET && --timeout); if (timeout == 0) return 1; while (I2C_GetFlagStatus(I2C_FLAG_BTF) == RESET && --timeout); if (timeout == 0) return 1; return 0; } // 产生停止信号 void I2C_Stop(void) { I2C_GenerateSTOP(ENABLE); }

先看I2C_Start：调用I2C_GenerateSTART(ENABLE)后，外设会自己在 SCL 和 SDA 上产生起始时序，CPU 只需要等 SB 标志置位。SB 是“起始位已建立”的信号，它一旦置位，说明总线上已经出了起始条件，这时候往数据寄存器写地址就不会被总线仲裁打断。

再看I2C_SendByte：写入数据后，TXE 先置位，表示数据从 CPU 搬到了外设的数据寄存器；但这时数据还没完全移位出去，紧接着要等 BTF。BTF 表示“字节发送结束”，也就是移位寄存器已经空掉，数据真正从 SDA 线上发出去了。有些库函数只查 TXE，不查 BTF，结果就是快速连续发两个字节时，第二个字节可能覆盖第一个字节的尾巴，低速时看不出来，一上 400kHz 就丢数据。

返回值的 0 表示成功，1 表示超时。超时值 200 是经验值：按照 100kHz 算，一个字节 10 个 bit，大约 100us，200 次 while 循环肯定超过一个字节的时间了。你要是改到 1MHz 总线，可以把超时改小，但保留超时机制本身比纠结具体数值重要得多。没有超时的等标志代码，一旦 SDA 被设备拉死，整个系统就只能靠看门狗救。

I2C_Stop就一行，不解释了。但要注意：停止信号后总线会短暂处于空闲状态，不能立刻发下一次起始，有些芯片手册会要求一个最小空闲时间，实际代码在 Stop 后加个DelayUs(5)更稳。

3.3 读 EEPROM：主读模式下的序列与应答处理

EEPROM 读操作分两种：随机读和顺序读。随机读要先发一个伪写序列把内部地址灌进去，然后重新发起始，再发设备地址+读位。顺序读就是连续读多个字节，最后一个字节前要回非应答。

uint8_t EEPROM_ReadByte(uint16_t addr, uint8_t* data) { I2C_Start(); if (I2C_SendByte(0xA0)) return 1; // 设备地址，写 if (I2C_SendByte(addr >> 8)) return 1; // 地址高字节 if (I2C_SendByte(addr & 0xFF)) return 1; // 地址低字节 I2C_Start(); // 重复起始 if (I2C_SendByte(0xA0 | 0x01)) return 1; // 设备地址，读 *data = I2C_ReceiveData(); I2C_SendAck(DISABLE); // 最后一个字节回非应答 I2C_Stop(); return 0; }

这里 0xA0 不是凭空来的：常见 8 引脚 EEPROM 的地址引脚 A0/A1/A2 接地时，7 位设备地址是 0x50，左移一位后加上写标志就是 0xA0。如果你的板子把地址引脚拉高了，这个值就要改成 0xA2、0xA4 之类。所以别把它当成固定魔数，读一下原理图上 A0/A1/A2 的连接才是正经事。

重复起始（Repeated START）是 I2C 协议里一个特殊状态：在没发停止信号的情况下，再次发起起始条件。很多从机要求随机读必须用重复起始，不能先停止再起始。如果先停止，EEPROM 可能会认为一次通信结束，内部指针状态被重置，读出来的地址就乱了。用I2C_Start()直接发第二次起始即可，硬件外设会自动处理时序，不需要手动清标志。

3.4 写 EEPROM：页写边界与内部写周期

EEPROM 写入是按页的，常见页大小有 8 字节或 16 字节。如果你写的数据跨页了，硬件会从页首地址重新开始写，直接覆盖前面写的内容，这就是经典的“页回卷”问题。

void EEPROM_PageWrite(uint16_t addr, uint8_t* buf, uint8_t len) { I2C_Start(); I2C_SendByte(0xA0); I2C_SendByte(addr >> 8); I2C_SendByte(addr & 0xFF); while (len--) I2C_SendByte(*buf++); I2C_Stop(); DelayMs(5); // 等待内部写周期完成 }

这个函数只处理“同一页内”的写入。下一页地址的起止计算要放在上层做：比如页大小 16，当前地址 0x000C，要写 10 个字节，前 4 字节填到 0x000F，剩下 6 字节必须从 0x0010 开始写，否则就会把 0x0000 处的数据覆盖掉。

DelayMs(5)是固定等待写周期。这种做法的缺点是白白等 5ms，而且如果实际写周期只有 2ms，你就多浪费了 3ms。更高级的做法是轮询 ACK：发一个伪写地址，看设备是否回 ACK，回了就代表内部写周期结束。这个技巧在后面的封装里会体现，但现在先明白固定延时也是一种有效手段。

4. 避坑指南：STM8S I2C 硬件外设最容易翻车的 5 个细节

4.1 现象：上电后第一次读写就卡死在 while 循环里，原因：外设没先复位

上电后直接调用 I2C_Init 然后立刻收发，程序死在等待 SB 标志的循环里。这就是硬件外设上电状态不确定造成的，尤其是上一跑系统刚复位，I2C 引脚上还有残余电平，外设的状态机可能处于中间状态。

解决：初始化时先I2C_DeInit()，让外设回出厂状态，再配置参数。这个函数会清掉所有标志、关掉中断、复位状态机。从那次以后，我无论用哪个型号的 STM8S，I2C 初始化第一行永远是 DeInit，没再犯过这个病。

4.2 现象：发送数据后等待 BTF 永远超时，原因：中断配置和轮询逻辑打架

如果同时开了 TXE 中断，又在主循环里轮询 BTF，会发生“中断把 TXE 清了，轮询逻辑到 BTF 时已经错过了条件”的诡异现象。表现为发送函数有时成功有时超时，时序上完全随机。

解决：轮询模式就全用轮询，中断模式就全用中断，别混用。如果开了 TXE 中断，那么在中断服务函数里处理完数据，主循环里就别再查 TXE。如果一定要混用，至少保证中断里的操作不改变主循环等待的标志。

4.3 现象：写完数据马上读取，返回全 0xFF，原因：EEPROM 内部写周期没结束

EEPROM 在写操作完成后，内部还需要几毫秒做擦写。这个期间设备不响应任何读写指令，此时如果你发读操作，总线上的数据可能是随机值，最常见的就是读到 0xFF。不少新手以为代码写错了，其实只是没等写周期结束。

解决：最简单的方法是写完固定延时 5ms。但更好的办法是 ACK 轮询：连续往设备写地址方向发字节，直到设备回 ACK，表示写周期完毕。这个方式省时间，而且适应不同芯片的写周期差异。我相信正规项目里基本都用轮询，固定延时只适合刚验证功能时用。

4.4 现象：示波器上看 SCL 上升沿像圆角，通信速率不达标，原因：上拉电阻过大

双绞线上挂了好几片设备，总线电容大，如果还用 10kΩ 上拉，SCL 的上升沿会变得很缓。那时序上表现为波形不是直角而是圆弧，设备就可能把高电平误判成低电平，通信随机失败。

解决：用示波器实测 SCL 上升沿，如果超过 1us，就把上拉电阻降到 2.2kΩ，或者减少总线负载。按经验，100kHz 下常见的 4.7kΩ 够用；如果你挂的设备超过两片，建议直接 2.2kΩ，留出余量。

4.5 现象：把模拟 I2C 代码直接搬到硬件 I2C，结果死锁，原因：两种方式完全不一样

模拟 I2C 的代码里大量出现GPIO_WriteBit(SCL, LOW)、GPIO_WriteBit(SDA, HIGH)这样的翻转。放到硬件 I2C 里，这些引脚已经被外设接管，你再用 GPIO 寄存器去控制它们，相当于跟外设抢方向盘，轻则时序错乱，重则总线死锁。

解决：彻底删除手动翻转 SCL/SDA 的代码，对外设通信只通过 I2C_GenerateSTART、I2C_SendData、I2C_GenerateSTOP 这些库函数操作。实在需要手动控制引脚时，先把 I2C 外设失能再说。这个坑在模拟转硬件时特别容易踩，因为移植时总想保留原有结构。

5. 把驱动封装成产品级：从单字节读写到结构体存取

5.1 用结构体管住设备参数：总线地址、页尺寸、写延时

单字节读写函数能跑通，但离产品化还差一步：把设备参数从魔数变成配置结构体。这样换容量、换引脚、换页大小都不用改核心驱动逻辑。

typedef struct { uint16_t dev_addr; // 设备写地址基址 uint16_t page_size; // 页大小 uint8_t addr_len; // 内部地址字节数 uint16_t total_size; // 总容量 } EEPROM_Cfg_t; const EEPROM_Cfg_t EEPROM_25x02 = {0xA0, 8, 2, 2048}; const EEPROM_Cfg_t EEPROM_25x16 = {0xA0, 16, 2, 16384};

这个结构体把设备和驱动解耦。dev_addr是写操作地址基址，读操作在这个基础上或 0x01。page_size是页大小，直接影响跨页写逻辑。addr_len表示内部地址寄存器是 1 字节还是 2 字节，容量大于 256 字节的 EEPROM 基本都是 2 字节地址，这也是很多初学者容易漏的地方。

5.2 封装统一接口：写地址自动跨页拆分

有了配置结构体，上层接口可以统一成“给起始地址和数据长度，自动处理页边界”的样子：

uint8_t EEPROM_Write(uint16_t addr, uint8_t* buf, uint16_t len) { while (len) { // 计算当前地址到页面末尾的剩余空间 uint16_t page_remain = EEPROM_CFG.page_size - (addr % EEPROM_CFG.page_size); uint16_t chunk = (len < page_remain) ? len : page_remain; EEPROM_PageWrite(addr, buf, chunk); addr += chunk; buf += chunk; len -= chunk; // 等待写周期，用 ACK 轮询可以替代固定延时 DelayMs(5); } return 0; }

这段代码的核心是page_remain的计算：它先算出当前地址离页末尾还有多少空间，然后每次只写这么长，写满一页就停，下一轮循环自动把地址移到下一页开头。这样无论传入多长数据，都不会发生页回卷。

返回 0 表示全部写完。如果中途某个页面写失败，可以把它改成像I2C_SendByte那样的错误码，具体到哪一页失败。这个方法比单个字节循环写快得多，页写一次最多可以传十几个字节，效率差距在批量保存参数时就体现出来了。

5.3 把数据组织成结构体，掉电保存不用再逐个字节搬

产品里经常要存系统参数、校准值、运行状态。如果每次保存都写几十个字节太麻烦，常见做法是定义结构体，一次性写入整块内存。这个工程里给出了一个典型示例：

typedef struct { uint8_t version; uint16_t threshold; int16_t offset; uint32_t crc; } SysParams_t; SysParams_t g_params; void Params_Save(void) { EEPROM_Write(0x0100, (uint8_t*)&g_params, sizeof(g_params)); } void Params_Load(void) { EEPROM_Read(0x0100, (uint8_t*)&g_params, sizeof(g_params)); }

这里有一个必须注意的坑：C 语言结构体存在内存对齐，编译器为了访问效率，会在成员之间塞入填充字节。如果直接强转存储，存进去的字节数和你在内存里看到的不一样。不同编译器、不同优化等级下填充策略还可能不同，这会导致同样的代码，在 A 工程上正常，在 B 工程上数据错位。

解决方法是给结构体加上紧凑打包属性。在 STM8S 的编译器里一般这样写：

typedef struct { uint8_t version; uint16_t threshold; int16_t offset; uint32_t crc; } __attribute__((packed)) SysParams_t;

或者用无对齐的数组方案：自己定义序列化和反序列化函数，把每个成员按固定偏移填进一个uint8_t数组。两种都行，我更推荐后者，因为不依赖编译器特性，隐患更少。

5.4 用 ACK 轮询替代固定延时，把写周期从 5ms 压缩到实际值

前面提过固定延时浪费了不少时间。借用总线特性，EEPROM 在内部写周期内不会 ACK 任何地址，所以我们可以用“试图重写地址”来探测写周期结束：

void EEPROM_WaitWriteDone(void) { I2C_Start(); I2C_SendByte(EEPROM_CFG.dev_addr); // 发一个伪写地址 while (I2C_GetFlagStatus(I2C_FLAG_AF) == RESET); // 等 ACK 失败？ // 如果 AF 置位，说明设备还没就绪；清 AF 后再试 I2C_Stop(); DelayUs(100); }

这段代码我简化了逻辑，但思路是对的：不断重发设备地址，直到收到 ACK。收到 ACK 就说明内部写周期结束，可以继续下次读写了。实际实现要处理 AF 标志的清除和超时，但收益很明显：写周期短的时候能省下好几毫秒，批量保存 4KB 数据时差距非常大。

6. 二次开发技巧：从固定地址到总线扫描与磨损均衡

开发自己的应用时，第一步别急着写业务逻辑，先做一个 I2C 总线扫描函数。它能在 30 秒内确认总线上有哪些设备、设备地址分别是多少，省去对着原理图猜地址的时间。

最简单的扫描逻辑就是遍历 0x00 到 0x7F 地址，每个地址发一个写起始，看有没有 ACK：

uint8_t I2C_Scan(uint8_t start, uint8_t end) { for (uint8_t addr = start; addr <= end; addr++) { I2C_Start(); I2C_SendByte((addr << 1) | 0); // 写方向 if (I2C_GetFlagStatus(I2C_FLAG_AF) == RESET) { // 收到 ACK，说明该地址有设备 Printf("Found device at 0x%02X\r\n", addr); } I2C_Stop(); } return 0; }

注意这里I2C_SendByte内部已经做了超时，扫描过程中即使某地址没有设备也不会卡死。遇到 AF 标志要手动清一次，否则后续判断会错乱。扫描完再开始配置业务逻辑，心里就有底了。

另一个改造方向是磨损均衡。EEPROM 写寿命通常十万次级别，如果你频繁保存参数，固定地址很容易写坏。常见做法是循环使用多个分区：结构体区、数据区、备份区，每次写入都切换地址，磨损分散到多个扇区。这个工程目前是固定地址方案，你可以在二次开发时加入一个简单的计数器来决定下一次写到哪个分区。这个技巧对于数据记录类产品特别实用。

从那以后，我每次换新板子，第一件事就是先把扫描函数跑一遍，确认总线上只有自己挂的设备，再进正式流程。那次因为偷懒跳过这步，结果两个存储芯片的地址引脚焊反，查了两个多小时才发现，白折腾了一晚上。希望帮到你。

本文还有配套的精品资源，点击获取