STM32快速入门（总线协议之I2C一主多从（软件实现 & 硬件实现））

STM32快速入门（总线协议之I2C一主多从（软件实现 & 硬件实现）） 前言

支持一对多（一主多从）、多对多传输（多主多从），只支持半双工，一般有两根数据线：SCL（Serial Clock Line）、SDA(Serial Data Line)

I2C有两种实现方式：一种是GPIO软件模拟，另一种是直接使用I2C硬件。

I2C软件实现

软件实现I2C的好处就是我们可以任意的选取GPIO口作为SDA、SCL线。

硬件电路的设计

硬件连接图如下：

SDA是数据线，SCL是时钟线。时钟线完全由主机控制。而从机只有对SDA的（短暂）控制权。通常使用I2C通通信，SCL和SDA线上都会接一个上拉电阻，要么是在外设的内部，要么是在外面可以直接通过外设的硬件接线图看到。接下来讨论外接电阻存在的意义。

如下：

所以一因为推挽输出输出的是强高低电平，在同一时刻，主机上拉输出1，某一个从机下拉输出0，这样就造成了短路！！！所以，为了防止这种情况，所有机器的SCL、SDA都被配置成开漏输出，只能输出强低电平0，同时外接一个弱的上拉电阻，以输出弱的高电平，杜绝了短路去危险情况。同时外接上拉电阻 + 开漏输出不需要频繁切换输入输出模式。

所以我们实现的软件I2C也会将SCL、SDA引脚置为开漏输出的模式。

I2C的起始位 & 停止位

起始位和停止位的波形如下：

简述一下，起始位就是在SCL高电平期间将SDA拉低，停止位就是在SCL为高电平期间将SDA拉高。

这样设计的目的和I2C数据位的传输有关，I2C中，一个数据位的传输遵循：在SCL低电平期间，写数据的一方向SDA写1（释放SDA）或者写0（拉低SDA），同时读的一方不允许去读数据（SDA）。在SCL高电平期间，读数据的一方在SDA上进行读数据，同时写的一方不想允许更改数据（SDA）。也就是所谓的‘低电平放，高电平取’原则。

而起始位和停止位恰好违背上面的原则，让通信双方能够很好的辨识出一个通信的周期。

此外，系统空闲时，两根总线都是被弱上拉拉高的高电平状态。至于为什么是弱上拉，我们后面讨论。

首部

紧跟起始位的是：设备地址 + 寄存器地址

对于7位设备地址：

第一个字节必须是：

| 设备地址（7位） | 读写位（1位）|
# 读写位为0代表写，为1代表读。

对于10位设备地址：

前两个字节必须是：

| 1111 0 | 设备地址（2位） | 读写位（1位） | 
| 设备地址（8位） |
# 读写位为0代表写，为1代表读。

本博客主要讨论7位地址的情况。

在写设备地址之后的一个字节是要写的寄存器地址，寄存器地址就是要写的设备的寄存器的物理地址，一般是8位地址。I2C中只有写才有寻址的能力（第二个发送的字节为寄存器地址），读只能顺序去读（不能直接发送寄存器地址）。要想实现随机读，就需要在发送一个‘幽灵’写设备地址后重新发送一个：起始位 + 读设备地址，从而实现了随机读。简单讲随机读就是一种复合模式。也即：随机读 = 随机写 + 直接读。

在帧头传输完毕后，就是正式读写数据的传输。

I2C一个Byte的发送

写遵循低放高取原则，因为是写操作，在传输数据时从机不具备操作SDA的权利，从机的SDA引脚保持高组态，SDA的高低电平由主机决定，主机通过操作SCL控制数据的传输进度。但是当一个Byte位传输完毕，主机会短暂释放SDA等待从机回复一个bit位的ACK，此时从机短暂拥有SDA的控制权。多次写入的数按最开始的寄存器地址依次排列。主机发送停止位代表传输周期结束。

主机发送起始位

主机发送写设备地址

主机获取从机的ack

主机发送寄存器地址

主机获取从机的ack

主机发送待写数据

主机获取从机的ack（重复6~7步可以重复写

主机发送停止位

注意1： I2C是高位先行。

注意2： 连续的写会纯在单页回滚问题，eeprom默认1页是8Byte，写到8的整数倍会导致指针混滚！这点需要注意。

I2C一个Byte的读取

读取同样遵循低放高取原则，因为是读操作，在传输数据时主机不具备操作SDA的权利，主机的SDA引脚保持高组态，SDA的高低电平由从机决定，主机通过操作SCL控制数据的传输进度。但是当一个Byte位接收完毕，从机会短暂释放SDA等待主机回复一个bit位的ACK，此时主机短暂拥有SDA的控制权，当主机回复0（ACK），从机会继续发送数据；当主机回复1（NACK），从机会停止发送数据。一般情况下主机回复NACK后会接着回复一个停止位。

直接（顺序）读：

主机发送起始位

主机发送读设备地址

主机获取从机的ack

主机读取从机发来的数据

主机发送NACK，结束传输（ACK可以回到4，继续读

主机送停止位

顺序读地址只能从从设备的0开始，每次读，从设备的地址指针会自增1。不存在混滚问题。

随机读：

主机发送起始位

主机发送写设备地址

主机获取从机的ack

主机发送寄存器地址

主机获取从机的ack

主机发送起始位（ Restart

主机发送读设备地址

主机获取从机的ack

主机读取从机发来的数据

主机发送NACK，结束传输（ACK可以回到9，继续读

主机送停止位

总结一下读写特点：写可以寻址（寻址从设备的寄存器），读只能顺序读，随机读 = 随机写 + 顺序读。

软件实现核心代码

需要另外注意的是，如果要对EEPROM外设进行读写，在写后不能直接进行读，需要延时至少5ms，给EEPROM一点操作时间，否则直接读出来的数据我测的是一直为0xff！！！

代码如下：

/*
    i2c.h
*/
#define SCL_PORT GPIOB
#define SCL_PIN GPIO_Pin_6
#define SDA_PORT GPIOB
#define SDA_PIN GPIO_Pin_7
// ...
/*
    i2c.c
*/
/**
 * @description: I2C端口GPIO初始化
 * @return {*}
 */
void Lunar_I2CInit(void) {
	GPIO_InitTypeDef GPIOB_Cfg;
	// PA
	RCC_APB2PeriphClockCmd(RCC_APB2Periph_GPIOB, ENABLE);
	// 两个引脚都配置为开漏输出
	GPIOB_Cfg.GPIO_Mode = GPIO_Mode_Out_OD;
	GPIOB_Cfg.GPIO_Pin = GPIO_Pin_6 | GPIO_Pin_7;
	GPIOB_Cfg.GPIO_Speed = GPIO_Speed_50MHz;
	GPIO_Init(GPIOB, &GPIOB_Cfg);
    // 最开始都为释放状态的高电平
	Lunar_SetSCL(Bit_SET);
	Lunar_SetSDA(Bit_SET);
}
/**
 * @description: 控制SCL引脚的电平状态，完全由主机控制
 * @param {uint8_t} BitVal
 * @return {*}
 */
void Lunar_SetSCL(uint8_t BitVal) {
    GPIO_WriteBit(SCL_PORT, SCL_PIN, (BitAction)BitVal);
	// 来一点点延时
	Delay_Us(10);
}
/**
 * @description: 控制SDA引脚的状态，可由主机控制，也可由从机控制
 * @param {uint8_t} BitVal
 * @return {*}
 */
void Lunar_SetSDA(uint8_t BitVal) {
    GPIO_WriteBit(SDA_PORT, SDA_PIN, (BitAction)BitVal);
	// 来一点点延时
	Delay_Us(10);
}
/**
 * @description: 获取SDA电平状态
 * @return {uint8_t}
 */
uint8_t Lunar_GetSDA(void) {
    uint8_t rt = GPIO_ReadInputDataBit(SDA_PORT, SDA_PIN);
	// 来一点点延时
	Delay_Us(10);
    return rt;
}
/*************************************************************************************************/
/**
 * @description: 发送一个起始位
 * @return {void}
 */
void Lunar_Start(void) {
	// 先将SCL、SDA拉高
	Lunar_SetSCL(1);
	Lunar_SetSDA(1);
	if (Lunar_GetSDA() == 0) {
		printf("error slave hold the SDA!!!rn");
	}
	// 再将SDA拉低
	Lunar_SetSDA(0);
	// 再将SCL拉低、准备发送数据
	Lunar_SetSCL(0);
}
/**
 * @description: 发送一个停止位
 * @return {void}
 */
void Lunar_Stop(void) {
	// 确保SDA为0
	Lunar_SetSDA(0);
	// 将SCL拉高
	Lunar_SetSCL(1);
	// 将SDA拉高
	Lunar_SetSDA(1);
	
	if (Lunar_GetSDA() == 0) {
		printf("error slave hold the SDA!!!rn");
	}
	// Lunar_SetSCL(0);
}
/**
 * @description: 写状态下等待从设备ACK的回复
 * @return {uint8_t}：读到ACK还是NACK
 */
uint8_t Lunar_ReadACK(void) {
	uint8_t rt = 0;
	// 释放SDA
	Lunar_SetSDA(1);
	// 拉高SCL
	Lunar_SetSCL(1);
	// 读SDA
	rt = Lunar_GetSDA();
	Lunar_SetSCL(0);
	return rt;
}
/**
 * @description: 读状态下向从设备回复一个ACK
 * @return {*}
 */
void Lunar_WriteACK(void) {
	// SDA置0
	Lunar_SetSDA(0);
	// SCL置1
	Lunar_SetSCL(1);
	// SCL置0
	Lunar_SetSCL(0);
	// 释放SDA拥有权
	Lunar_SetSDA(1);
}
/**
 * @description: 读状态下向从设备回复一个NACK
 * @return {*}
 */
void Lunar_WriteNACK(void) {
	// SDA置1
	Lunar_SetSDA(1);
	// SCL置1
	Lunar_SetSCL(1);
	// SCL置0
	Lunar_SetSCL(0);
	// 释放SDA拥有权
	Lunar_SetSDA(1); // ???
}
/**
 * @description: 读一个Byte
 * @return {uint8_t}：返回读到的Byte
 */
uint8_t Lunar_ReadByte(void) {
	uint8_t rt = 0;
	// 此出主机不应该拥有SDA的控制权！
	Lunar_SetSDA(1);
	for (int i = 0; i < 8; i++) {
		// 先拉高SCL
		Lunar_SetSCL(1);
		// 读SDA
		rt |= Lunar_GetSDA() << (7 - i);
		printf("%d, ", rt);
		// 拉低SCL
		Lunar_SetSCL(0);
	}
		printf("rn");
	return rt;
}
/**
 * @description: 写一个Byte
 * @param {uint8_t} data：要写入的数据
 * @return {*}
 */
void Lunar_WriteByte(uint8_t data) {
	// 此处主机应该拥有SDA的控制权
	for (int i = 0; i < 8; i++) {
		// 写一个bit
		Lunar_SetSDA((data >> (7 - i)) & 1);
		// 拉高SCL
		Lunar_SetSCL(1);
		// 拉低SCL
		Lunar_SetSCL(0);
	}
}
/**
 * @description: 获取指定设备指定寄存器地址的值
 * @param {uint8_t} device_addr：设备地址是7位
 * @param {uint8_t} registry_addr
 * @return {uint8_t}
 */
uint8_t Lunar_GetRegistryByte(uint8_t device_addr, uint8_t registry_addr) {
	uint8_t rt = 0;
	uint8_t tag = 0;
	// 发送起始位
	Lunar_Start();
	// 发送设备地址
	Lunar_WriteByte((device_addr << 1) | 0);	// 写设备地址
	// 获取从机的ack
	tag = tag || Lunar_ReadACK();
	// 发送寄存器地址
	Lunar_WriteByte(registry_addr);
	// 获取从机的ack
	tag = tag || Lunar_ReadACK();
	// Restart
	// 发送起始位
	Lunar_Start();
	// 发送设备地址
	Lunar_WriteByte((device_addr << 1) | 1);	// 读设备地址
	// 获取从机的ack
	tag = tag || Lunar_ReadACK();
	// 读取从机发来的数据
	rt = Lunar_ReadByte();
	// 发送NACK，结束传输
	Lunar_WriteNACK();
	// 发送停止位
	Lunar_Stop();
	if (tag) {
		printf("in Lunar_GetRegistryByte Lunar_ReadACK faild!rn");
	}
	return rt;
}
/**
 * @description: 设置指定设备指定寄存器地址的值
 * @param {uint8_t} device_addr
 * @param {uint8_t} registry_addr
 * @param {uint8_t} data
 * @return {*}
 */
void Lunar_SetRegistryByte(uint8_t device_addr, uint8_t registry_addr, uint8_t data) {
	uint8_t tag = 0;
	// 发送起始位
	Lunar_Start();
	// 发送设备地址
	Lunar_WriteByte((device_addr << 1) | 0);	// 写设备地址
	// 获取从机的ack
	tag = tag || Lunar_ReadACK();
	// 发送寄存器地址
	Lunar_WriteByte(registry_addr);
	// 获取从机的ack
	tag = tag || Lunar_ReadACK();
	// 发送待写数据
	Lunar_WriteByte(data);
	// 获取从机的ack
	tag = tag || Lunar_ReadACK();
	// 发送停止位
	Lunar_Stop();
	if (tag) {
		printf("in Lunar_SetRegistryByte Lunar_ReadACK faild!rn");
	}
}

I2C硬件实现 导航

图242 I2C框图：

实现细节

从图242可以看到，和USART类似，I2C也配备了一组移位寄存器 + 数据寄存器的组合，只不过I2C只有一根数据线，所以只有一组寄存器组合。

对于于比较器和自身地址寄存器，I2C硬件可以在主从两种模式下工作，当作为从模式时，设备就会拥有一个设备地址，自身地址寄存器就是存储该从设备地址的地方，比较器就是完成设备地址匹配的功能。此外，I2C可以通过帧错误校验计算模块完成CRC校验的功能。

然后就是SCL时钟线的时钟控制模块，其作用就是控制SCL线时钟的，具体实现细节我没有去深究，但它的作用肯定是根据I2C规定的协议去控制SCL引脚上的时钟。

最后，左下部分就是一些可以让用户控制的寄存器，这些寄存器的作用都可以在中文手册中查阅。

这里贴一张来自江协科技的I2C简化框图：

使用库函数实现硬件I2C的套路

写流程：

发送起始位。

等待EV5事件，也就是等待BUSY(SCL被拉低) & MSL（处于主模式，在start被发出硬件自动置位） & SB（start被发出） 被置位。

发送写设备地址。

等待EV6（发送）事件，也就是BUSY（SCL被拉低）& MSL（处于主模式，在start被发出硬件自动置位）&& ADDR（设备地址已经发送，并且收到从机的ACK）& TXE（发送寄存器为空） & TRA（发送模式，依据发送设备地址最后一位设置） 被置位。

这里有一个理论上的EV8_1事件，但是库函数没有对应的宏，大体意思就是发送寄存器和发送移位寄存器同时为空。

发送寄存器地址。

等待EV8事件，也就是TRA（发送模式，依据发送设备地址最后一位设置）& BUSY（SCL被拉低） & MSL（处于主模式，在start被发出硬件自动置位） & TXE（发送寄存器为空，收到从机的ACK回复才会置位）被置位。

发送待写数据。

等待EV8_2事件，也就是在EV8事件基础上多了一个BTF标志位，代表发送寄存器和发送移位寄存器都空了，数据线上也没有需要传输的数据了，该发的数据发干净了。

发送停止位，请求停止传输。

重复执行8~9可实现多次写。

这里可以配合中文手册的图理解写的套路：

读流程：

发送起始位。

等待EV5事件，也就是等待BUSY(SCL被拉低) & MSL（处于主模式，在start被发出硬件自动置位） & SB（start被发出） 被置位。

发送写设备地址。

等待EV6（发送）事件，也就是BUSY（SCL被拉低）& MSL（处于主模式，在start被发出硬件自动置位）& ADDR（设备地址已经发送，并且收到从机的ACK）& TXE（发送寄存器为空） & TRA（发送模式，依据发送设备地址最后一位设置） 被置位。

这里有一个理论上的EV8_1事件，但是库函数没有对应的宏，大体意思就是发送寄存器和发送移位寄存器同时为空。起提示作用。

发送寄存器地址。

等待EV8_2事件，也就是TRA（发送模式，依据发送设备地址最后一位设置）& BUSY（SCL被拉低） & MSL（处于主模式，在start被发出硬件自动置位） & TXE（发送寄存器为空，收到从机的ACK回复才会置位）& BTF（数据寄存器和移位寄存器都为空）被置位。

发送起始位。

等待EV5事件，也就是等待BUSY(SCL被拉低) & MSL（处于主模式，在start被发出硬件自动置位） & SB（start被发出） 被置位。

发送读设备地址。

等待EV6（接收）事件，也就是BUSY（SCL被拉低）& MSL（处于主模式，在start被发出硬件自动置位）& ADDR（设备地址已经发送，并且收到从机的ACK） 被置位。

EV6_1 / EV7_1 需要提前设置ack位和停止产生位。如果想继续读数据，就不执行该步，循环执行13~14即可实现多次读。

等待EV7事件，也就是BUSY（SCL被拉低）& MSL（处于主模式，在start被发出硬件自动置位）& RXNE（接收数据寄存器非空）被置位。

接收从机发来的数据。

这里可以配合中文手册的图理解读的套路，手册提供的是直接顺序读的时序，但是前面软件部分说过，需要实现随机读，可以使用‘幽灵’写 + 顺序读的方式实现，上述步骤也正是这样做的。

这里可以配合中文手册的图理解读的套路：

这里提供I2C_CR1寄存器一些相关位的描述，方便读者分析：

这里提供I2C_SR1寄存器一些相关位的描述，方便读者分析：

这里提供I2C_SR2寄存器一些相关位的描述，方便读者分析：

库函数实现代码

在实现硬件I2C时，需要将SCL、SDA所在GPIO的引脚都配置为开漏复用输出的模式，复用是为了将IO口控制权交给片上外设，开漏是为了遵循协议。开漏的具体原因在软件部分也进行过深入探讨，这里就不过多赘述。

在写硬件实现I2C的代码的时候，出现了一个非常奇怪的BUG，在第一次执行Lunar_GetRegistryByte时，程序一直卡在Lunar_GetRegistryByte函数的第一个while循环中，查了半天发现是START位发不出去，因为BUSY一直是被置位（总线被拉低，一直处于通信状态）的状态。然后检测Lunar_I2CInit函数，发现只要一开启I2C1时钟，BUSY就是被置位的状态。经过百度，在I2C被初始化前，使用I2C_SoftwareResetCmd库函数进行一次复位才得以解决。

最后需要注意的是使用I2C_Send7bitAddress函数发送设备地址需要注意提前将地址左移一位，因为I2C_Send7bitAddress函数的实现它是直接在你提供的设备地址末尾置读写位的。

硬件实现核心代码如下：

/**
 * @description: I2C端口GPIO初始化
 * @return {*}
 */
void Lunar_I2CInit(void) {
	GPIO_InitTypeDef GPIOB_Cfg;
	I2C_InitTypeDef I2C1_Cfg;
	// PA
	RCC_APB2PeriphClockCmd(RCC_APB2Periph_GPIOB, ENABLE);
	// 两个引脚都配置为复用开漏输出
	GPIOB_Cfg.GPIO_Mode = GPIO_Mode_AF_OD;
	GPIOB_Cfg.GPIO_Pin = GPIO_Pin_6 | GPIO_Pin_7;
	GPIOB_Cfg.GPIO_Speed = GPIO_Speed_50MHz;
	GPIO_Init(GPIOB, &GPIOB_Cfg);
	// 开启I2C1时钟
	RCC_APB1PeriphClockCmd(RCC_APB1Periph_I2C1, ENABLE);
	I2C1_Cfg.I2C_Ack = I2C_Ack_Enable;									// 默认回复ACK
	I2C1_Cfg.I2C_AcknowledgedAddress = I2C_AcknowledgedAddress_7bit;	// 7bit设备地址
	I2C1_Cfg.I2C_ClockSpeed = 50000;									// 50KHZ
	I2C1_Cfg.I2C_DutyCycle = I2C_DutyCycle_2;							// 该位仅对100KHZ ~ 400KHZ的高速频率有效，我们设置的50KHZ其实不起作用
	I2C1_Cfg.I2C_Mode = I2C_Mode_I2C;
	I2C1_Cfg.I2C_OwnAddress1 = 0x00;									// 随便自定义一个不冲突的主机设备地址
	// 必须使用软件对I2C进行复位，不然，I2C1的BUSY位一直会处于置位的状态！！！
	I2C_SoftwareResetCmd(I2C1, ENABLE);
	I2C_SoftwareResetCmd(I2C1, DISABLE);
	I2C_Init(I2C1, &I2C1_Cfg);
	
	I2C_Cmd(I2C1, ENABLE);	// 使能
	
	// I2C_GenerateSTOP(I2C1, ENABLE);
}
/**
 * @description: 获取指定设备指定寄存器地址的值
 * @param {uint8_t} device_addr：设备地址是7位
 * @param {uint8_t} registry_addr
 * @return {uint8_t}
 */
uint8_t Lunar_GetRegistryByte(uint8_t device_addr, uint8_t registry_addr) {
	uint8_t rt = 0;
	device_addr = device_addr << 1;
	// 发送起始位
	I2C_GenerateSTART(I2C1, ENABLE);
	// 等待EV5事件，
	// 也就是等待BUSY(SCL被拉低) & 
	// MSL（处于主模式，在start被发出硬件自动置位） & 
	// SB（start被发出） 被置位
	while(I2C_CheckEvent(I2C1, I2C_EVENT_MASTER_MODE_SELECT) != SUCCESS);
	// 发送设备地址
	I2C_Send7bitAddress(I2C1, device_addr, I2C_Direction_Transmitter);	// 写设备地址
	// 等待EV6（发送）事件，
	// 也就是BUSY（SCL被拉低）& 
	// MSL（处于主模式，在start被发出硬件自动置位）&
	// ADDR（设备地址已经发送，并且收到从机的ACK）&
	// TXE（发送寄存器为空） & 
	// TRA（发送模式，依据发送设备地址最后一位设置） 被置位。
	while(I2C_CheckEvent(I2C1, I2C_EVENT_MASTER_TRANSMITTER_MODE_SELECTED) != SUCCESS);
	// 这里有一个理论上的EV8_1事件，但是库函数没有对应的宏，大体意思就是发送寄存器和发送移位寄存器同时为空。起提示作用。
	// 发送寄存器地址
	I2C_SendData(I2C1, registry_addr);
	// 等待EV8_2事件，
	// 也就是TRA（发送模式，依据发送设备地址最后一位设置）& 
	// BUSY（SCL被拉低） & 
	// MSL（处于主模式，在start被发出硬件自动置位） & 
	// TXE（发送寄存器为空，收到从机的ACK回复才会置位）& 
	// BTF（数据寄存器和移位寄存器都为空）被置位。
	while(I2C_CheckEvent(I2C1, I2C_EVENT_MASTER_BYTE_TRANSMITTED) != SUCCESS);
	// Restart
	// 发送起始位
	I2C_GenerateSTART(I2C1, ENABLE);
	// 等待EV5事件，
	// 也就是等待BUSY(SCL被拉低) & 
	// MSL（处于主模式，在start被发出硬件自动置位） & 
	// SB（start被发出） 被置位
	while(I2C_CheckEvent(I2C1, I2C_EVENT_MASTER_MODE_SELECT) != SUCCESS);
	// 发送设备地址
	I2C_Send7bitAddress(I2C1, device_addr, I2C_Direction_Receiver);	// 读设备地址
	// 等待EV6（接收）事件，
	// 也就是BUSY（SCL被拉低）& 
	// MSL（处于主模式，在start被发出硬件自动置位）& 
	// ADDR（设备地址已经发送，并且收到从机的ACK） 被置位。
	while(I2C_CheckEvent(I2C1, I2C_EVENT_MASTER_RECEIVER_MODE_SELECTED) != SUCCESS);
	// EV6_1 / EV7_1 需要提前设置ack位和停止产生位。
	I2C_AcknowledgeConfig(I2C1, DISABLE);
	I2C_GenerateSTOP(I2C1, ENABLE);
	// 等待EV7，也就是BUSY（SCL被拉低）& 
	// MSL（处于主模式，在start被发出硬件自动置位）& 
	// RXNE（接收数据寄存器非空）被置位。
	while(I2C_CheckEvent(I2C1, I2C_EVENT_MASTER_BYTE_RECEIVED) != SUCCESS);
	// 接收从机发来的数据
	rt = I2C_ReceiveData(I2C1);
	// 恢复ACK确认
	I2C_AcknowledgeConfig(I2C1, ENABLE);
	return rt;
}
/**
 * @description: 设置指定设备指定寄存器地址的值
 * @param {uint8_t} device_addr
 * @param {uint8_t} registry_addr
 * @param {uint8_t} data
 * @return {*}
 */
void Lunar_SetRegistryByte(uint8_t device_addr, uint8_t registry_addr, uint8_t data) {
	device_addr = device_addr << 1;
	// 发送起始位
	I2C_GenerateSTART(I2C1, ENABLE);
	// 等待EV5事件，
	// 也就是等待BUSY(SCL被拉低) & 
	// MSL（处于主模式，在start被发出硬件自动置位） & 
	// SB（start被发出） 被置位
	while(I2C_CheckEvent(I2C1, I2C_EVENT_MASTER_MODE_SELECT) != SUCCESS);
	// 发送设备地址
	I2C_Send7bitAddress(I2C1, device_addr, I2C_Direction_Transmitter);	// 写设备地址
	// 等待EV6（发送）事件，
	// 也就是BUSY（SCL被拉低）& 
	// MSL（处于主模式，在start被发出硬件自动置位）& 
	// ADDR（设备地址已经发送，并且收到从机的ACK）& 
	// TXE（发送寄存器为空） & 
	// TRA（发送模式，依据发送设备地址最后一位设置） 被置位。
	while(I2C_CheckEvent(I2C1, I2C_EVENT_MASTER_TRANSMITTER_MODE_SELECTED) != SUCCESS);
	// 这里有一个理论上的EV8_1事件，但是库函数没有对应的宏，大体意思就是发送寄存器和发送移位寄存器同时为空。起提示作用
	// 发送寄存器地址
	I2C_SendData(I2C1, registry_addr);
	//  等待EV8事件，
	// 也就是TRA（发送模式，依据发送设备地址最后一位设置）& 
	// BUSY（SCL被拉低） & 
	// MSL（处于主模式，在start被发出硬件自动置位） & 
	// TXE（发送寄存器为空，收到从机的ACK回复才会置位）被置位。
	while(I2C_CheckEvent(I2C1, I2C_EVENT_MASTER_BYTE_TRANSMITTING) != SUCCESS);
	// 发送待写数据
	I2C_SendData(I2C1, data);
	//  等待EV8_2事件，也就是在EV8事件基础上多了一个BTF标志位，代表发送寄存器和发送移位寄存器都空了，数据线上也没有需要传输的数据了，该发的数据发干净了。
	while(I2C_CheckEvent(I2C1, I2C_EVENT_MASTER_BYTE_TRANSMITTED) != SUCCESS);
	// 发送停止位，请求停止传输
	I2C_GenerateSTOP(I2C1, ENABLE);
}

感谢江协科技提供的STM32教学视频。

感谢为STM32 f100ZET6中硬件I2C的问题提供解决方案的作者，原帖如下：

本章完结