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

已于 2024-05-23 15:15:04 修改
阅读量1.2k 收藏 16
点赞数 27
分类专栏： STM32 文章标签： stm32 单片机 嵌入式硬件 c++ 架构 开源 I2C
于 2024-05-12 20:09:38 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/m0_52566365/article/details/138764822
版权

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

前言

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

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

I2C软件实现

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

硬件电路的设计

硬件连接图如下：

整体架构

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

如下：

  • 在配置成推挽输出模式下，可以直接读输入寄存器从而获取引脚状态。但推挽输出配置外接电阻是没有任何意义的，因为输出0或输出1完全由IO决定。可以说只要IO口是推挽输出的状态那么SDA线的控制权就不可能移交给从机。想要放弃对SDA的控制就必须将IO口配置成输出的模式。甚至在极端情况下，在主输出1从输出0会造成短路。

  • 在配置成开漏输出模式下，也可以直接读输入寄存器从而获取引脚状态，通过置输出寄存器为1这样引脚处于高阻态（引脚悬空）主机可以方便的释放SDA的控制权。不需要像推挽输出那样配置成输入模式。通过读取输入寄存器，可以方便的接收数据。主机、外设引脚都处于开漏模式，需要输出0就向输出寄存器写0，将引脚拉低；需要输出1就向输出寄存器写1将引脚断开，让上拉电阻提供一个弱上拉。并且也不存在短路的风险，即使在主输出1从输出0的情况下，因为高电平是上拉电阻提供，中间怎么都会存在电阻。

所以一因为推挽输出输出的是强高低电平，在同一时刻，主机上拉输出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的控制权。多次写入的数按最开始的寄存器地址依次排列。主机发送停止位代表传输周期结束。

  1. 主机发送起始位

  2. 主机发送写设备地址

  3. 主机获取从机的ack

  4. 主机发送寄存器地址

  5. 主机获取从机的ack

  6. 主机发送待写数据

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

  8. 主机发送停止位

注意1： I2C是高位先行。

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

I2C一个Byte的读取

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

直接（顺序）读：

  1. 主机发送起始位

  2. 主机发送读设备地址

  3. 主机获取从机的ack

  4. 主机读取从机发来的数据

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

  6. 主机送停止位

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

随机读：

  1. 主机发送起始位

  2. 主机发送写设备地址

  3. 主机获取从机的ack

  4. 主机发送寄存器地址

  5. 主机获取从机的ack

  6. 主机发送起始位（ Restart

  7. 主机发送读设备地址

  8. 主机获取从机的ack

  9. 主机读取从机发来的数据

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

  11. 主机送停止位

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

软件实现核心代码

需要另外注意的是，如果要对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!!!\r\n");
	}

	// 再将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!!!\r\n");
	}

	// 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("\r\n");
	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!\r\n");
	}
	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!\r\n");
	}
}

I2C硬件实现

导航

图242 I2C框图：

I2C

实现细节

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

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

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

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

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

SimpleI2C

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

写流程：

  1. 发送起始位。

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

  3. 发送写设备地址。

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

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

  6. 发送寄存器地址。

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

  8. 发送待写数据。

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

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

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

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

HardwareWrite

读流程：

  1. 发送起始位。

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

  3. 发送写设备地址。

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

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

  6. 发送寄存器地址。

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

  8. 发送起始位。

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

  10. 发送读设备地址。

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

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

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

  14. 接收从机发来的数据。

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

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

HardwareRead

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

I2C_CR1

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

I2C_SR1_1

I2C_SR1_2

I2C_SR1_3

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

I2C_SR2

库函数实现代码

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

AFIO

GPIO_Cfg

Hadrware.

在写硬件实现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的问题提供解决方案的作者，原帖如下：https://blog.csdn.net/jatamatadada/article/details/40860619

本章完结

LunarCod
关注
  • 27
    点赞
  • 踩
  • 16
    收藏
    觉得还不错? 一键收藏
  • 2
    评论
专栏目录
STM32软件模拟I2C从机的例程代码
05-03
STM32软件模拟I2C从机的实现方法，使用GPIO来模拟I2C从机通信，对于GPIO可以配置边沿中断的MCU来说，也可参照该例程代码来实现软件模拟I2C从机。本例程代码对应的说明文章可以关注”固件工人“微信公众号，搜索《STM...
STM32F103硬件I2C主机收发数据，亲测可用
08-15
STM32F103硬件I2C主机轮询收发数据，经过在开发板STM32F103C8T6中测试，并使用串口打印接收和发送的数据，数据正确且能连续接收和发送数据。使用的是标准库实现的I2C1总线通信，适合初学者；但是前提是需要熟悉I2C...
I2C协议
lzy13785490347的博客
06-05 3534
广播完地址，接收到应答信号后， 从机开始向主机返回数据(DATA)，数据包大小也为 8 位，从机每发送完一个数据，都会等待主机的应答信号(ACK)，重复这个过程，可以返回 N 个数据，这个 N 也没有大小限制。广播完地址，接收到应答信号后， 主机开始正式向从机传输数据(DATA)，数据包的大小为 8 位，主机每发送完一个字节数据，都要等待从机的应答信号(ACK)，重复这个过程，可以向从机传输 N 个数据，这个 N 没有大小限制。该位为 0 时，主机向从机写数据，该位为 1 时，则相反，即主机由从机读数据。
【I2C（IIC）通信协议的详细介绍】
深耕嵌入式领用多年， 致力于分享嵌入式领域技术!
05-24 6703
I2C（IIC）通信协议的详细介绍
树莓派 I2C通信，控制多个I2C从设备
qq_22073113的博客
06-10 6070
树莓派I2C接口，控制多个子设备
IIC学习笔记（一）
zoey424的博客
05-05 909
IIC学习笔记
I2C总线基础知识及操作详解
kvts99的博客
03-21 3654
详细讲解I2C总线的基础知识与其具体的操作步骤
stm32f103 i2c硬件从机
07-02
stm32f103 硬件i2c 从机配置 目前在使用
关于STM32的I2C硬件DMA实现
07-31
网上看到很多说STM32的I2C很难用，但我觉得还是理解上的问题，STM32的I2C确实很复杂，但只要基础牢靠，并没有想象中的那么困难。
STM32F407VET6硬件I2C实现读取，写MPU6050传感器数据（CUBEIDE工程）
06-09
SMBus (System Management Bus,系统管理总线)， 为系统和电源管理这样的任务提供了一条控制总线，SMBus与I2C总线之间在时序特性上存在一些差别 修改速度为50000 写操作与读操作函数实现 /** * @brief Manages ...
【STM32】入门（六）：I2C协议
郭老二
08-08 1491
I2C协议入门介绍
IIC总线上挂载多个从机的程序实现
qq_21291397的博客
07-01 2万+
文章目录IIC总线上挂在多个从机的程序实现IIC简介：1、项目的硬件参考电路：2、程序实现： IIC总线上挂在多个从机的程序实现 IIC简介： 1、I2C总线具有两根双向信号线，一根是数据线SDA，另一根是时钟线SCL 2、IIC总线上可以挂很多设备：多个主设备，多个从设备（外围 设备）。 3、多主机会产生总线裁决问题。当多个主机同时想占用总线时，企图启动总线传输数据，就叫做总线竞争。I2C通过总线仲裁，以决定哪台主机控制总线 在一般的项目中，一般不会涉及到IIC总线上挂载多主机多从机的情况。但挂载单个主
I2C协议靠这16张图彻底搞懂
jfl558604的博客
02-25 582
本文主要介绍I2C的入门基础知识，从I2C协议的硬件层，协议层进行了简单介绍；作者能力有限，难免存在错误和纰漏，请大佬不吝赐教。作者：小麦大叔来源：CSDN原文：https://great.blog.csdn.net/article/details/109188507版权声明：本文为作者原创文章，转载请附上博文链接！CSDN,CNBLOG博客文章一键转载插件。
如何在I2C通信中同时和多个从机通信
我的blog屋
11-04 1万+
对于不同地址的模块就不用多说了，直接分别对其地址进行通信即可。那么若拿到相同地址的模块，或者直接是相同的多个模块怎么办呢？ 方法一：（内置了两种地址的模块） 对于内置了两种地址的模块，可以通过对某个引脚置高或置低来选择其中一个地址，现假设置高为A，置低为B。 假设你有三个模块要同时通信，首先将模块1置高，模块2、模块3的地址选择口置低，这样仅有模块1在地址A，然后对地址A进行通信即可防止其他模块干扰。接下来将模块1置低，模块2置高，即可对模块2通信。循环下去即可实现同时对三个模块通信。 方法二：（具有使能端
一文搞懂I2C通信总线
热门推荐
不脱发的程序猿
03-27 9万+
本来不打算写这篇文章，因为网上关于I2C总线通信的资料很多很全。但是最近刚换工作，主要做驱动开发，第一个驱动就是I2C通信，想了想还是结合网上的资料再整理下思路，方便今后的查阅和温习。
STM32硬件I2C双机通信
wuyanboplus的博客
09-15 7661
在本次实验中需要用到两块STM32单片机，其中一块的I2C1做主机，另一块的I2C2做从机，分别进行I2C1写I2C2实验、I2C1读I2C2实验，两次实验I2C1均为主机。
I2C协议原理讲解
m0_57396609的博客
10-02 2056
一、物理层： 1.I2C通讯设备之间的常用连接方式： 2.特点： (1) 它是一个支持设备的总线。“总线”指多个设备共用的信号线。在一个I2C通讯总线中， 可连接多个I2C通讯设备，支持多个通讯主机及多个通讯从机。 (2) 一个I2C总线只使用两条总线线路，一条双向串行数据线(SDA) ， 一条串行时钟线 (SCL)。数据线即用来表示数据，时钟线用于数据收发同步。 (3) 每个连接到总线的设备都有一个独立的地址， 主机可以利用这个地址进行不同设备之间的访问。 (4) 总线通过上拉电阻接到电源。当I2C设备
树莓派3B+ I2C总线挂接多个设备
wxtcstt的专栏
08-09 8064
树莓派3B+ I2C接口的使用 1 开启树莓派i2c 再Raspberry Pi Configuration 的Interfaces 下I2C 选择enable 即可 2 将I2C 设备连接到树莓派 如下图： 3 代开console 输入 i2cdetect -y 1 ,注意此处...
stm32cubemx入门教程
最新发布
12-22
STM32CubeMX是ST公司推出的一款用于STM32微控制器的图形化配置工具，可以帮助开发者快速生成初始化代码和配置工程。下面是一个简单的STM32CubeMX入门教程： 第一步，下载安装STM32CubeMX软件并打开。软件的界面分为左侧的器件树、中间的配置区域和右侧的信息区域。 第二步，选择要使用的STM32微控制器型号。在器件树中找到对应的型号，然后双击打开。在弹出的窗口中，可以选择使用的时钟源、外设以及引脚配置等。 第三步，配置时钟源。在配置区域中，选择时钟配置选项，根据需求配置对应的时钟来源频率、系统时钟频率、总线时钟频率等参数。 第四步，配置外设。在配置区域中，选择外设配置选项，根据需求配置对应的外设，比如UART、SPI、I2C等。 第五步，配置引脚。在配置区域中，选择引脚配置选项，可以通过拖拽的方式配置引脚的功能。 第六步，生成代码。完成以上配置后，点击“生成代码”按钮，选择要生成的工程类型和IDE，生成初始化代码和配置工程。 通过以上简单的步骤，就可以快速入门使用STM32CubeMX进行微控制器的配置和工程生成。对于想要深入学习的开发者，建议进一步深入学习STM32CubeMX的高级功能和使用方法，以更好地应用于实际的项目开发中。

“相关推荐”对你有帮助么？

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论 2
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

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

余额充值