• I2C的硬件实现

    因为I2C是同步的，所以相对来说I2C更好用软件来实现，硬件却相对来说没这么好，但是硬件I2C通信也是有其优点的

    我们是通过软件写入控制寄存器CR和数据寄存器DR，读取状态寄存器SR来了解外设电路当前处于什么状态，来实现I2C通信的，而我们通过STM32的库函数来实现配置这些寄存器，这些操作就变得更简单了；有了I2C硬件外设的存在，硬件自动实现时序，就可以减轻CPU的负担，节省软件资源，由硬件来做这件事，可以更加专注，时序生成的性能、效率也会更高，这就是I2C外设存在的意义。

    I2C外设简介

    • STM32 内部集成了硬件 I2C 收发电路，可以由硬件自动执行时钟生成、起始终止条件生成、应答位收发、数据收发等功能，减轻 CPU 的负担
    • 支持多主机模型
    • 支持 7 位 /10 位地址模式
    • 支持不同的通讯速度，标准速度 ( 高达 100 kHz) ，快速 ( 高达 400 kHz)
    • 支持 DMA
    • 兼容 SMBus 协议
    • STM32F103C8T6 硬件 I2C 资源： I2C1 、 I2C2
    （硬件I2C的资源是有限的，这也是硬件和软件的区别）

    多主机模型：

    1、固定多主机：固定多台机器为主机，只有其中一台主机才可以通过主线控制所有从机，当多个主机控制主线时，会出现主线冲突，这个时候就会进行总线总裁，仲裁失败的一方会让出总线控制权；

    2、可变多主机：默认情况下，全部机器都是从机，当某台机器需要控制权时，就会跳出来变成主机，控制主线，多个从机跳出来时，就会进行总线仲裁，仲裁成功的获得总线控制权。STM32的I2C就是可变多主机的模型

    I2C框图

    引脚定义

     

    I2C基本结构

    发送：移位寄存器中的数据由高位到低位先移出去，移8次就可以移一个字节，有高位到低位依次放到SDA线上；

    接收：数据从GPIO口从右边依次移进来，最终移8次，一个字节就接收完成了。

    配置问题：两个GPIO口都需要配置成复用开漏输出模式，复用——GPIO的状态是交由片上外设来控制的，开漏输出——I2C协议要求的端口配置（在这个模式下依然可以通过GPIO口进行输入）

    主机发送

    EV-标志位（多个事件发生的标志位）

    对应数据手册24.6.7

    EV5：（不需要手动清除的） 

     主机接收

     代码实操

     硬件IIC的缺点就是引脚固定

    相关函数介绍

    1. //老朋友
    2. void I2C_DeInit(I2C_TypeDef* I2Cx);
    3. void I2C_Init(I2C_TypeDef* I2Cx, I2C_InitTypeDef* I2C_InitStruct);
    4. void I2C_StructInit(I2C_InitTypeDef* I2C_InitStruct);
    5. void I2C_Cmd(I2C_TypeDef* I2Cx, FunctionalState NewState);
    1. //生成起始条件
    2. void I2C_GenerateSTART(I2C_TypeDef* I2Cx, FunctionalState NewState);
    3. //生成结束条件
    4. void I2C_GenerateSTOP(I2C_TypeDef* I2Cx, FunctionalState NewState);

     生成起始条件的函数——通过配置IIC中的CR1寄存器的值来决定是否生成起始条件

    想要更深入了解I2C还是得需要阅读数据手册 

    可以看到这是配置ACK应答使能的函数 

    1. //接收应答
    2. void I2C_AcknowledgeConfig(I2C_TypeDef* I2Cx, FunctionalState NewState);

     

     接收数据

    void I2C_SendData(I2C_TypeDef* I2Cx, uint8_t Data);

    查看其函数定义可以发现是配置DR数据寄存器的

     

    1. //接收数据——读取DR寄存器
    2. uint8_t I2C_ReceiveData(I2C_TypeDef* I2Cx);
    1. //发送七位地址
    2. void I2C_Send7bitAddress(I2C_TypeDef* I2Cx, uint8_t Address, uint8_t I2C_Direction);

    这个函数还可以通过参数判断是接收还是发送模式来写入最低位（R/W）当然也可以自己通过SendData来操作 

     I2C状态监控函数

    这是库函数给我们设计的多种监控状态方案

    1、基本状态监控

    同时判断一个或者多个标志位，来确定正处于哪一个状态

    ErrorStatus I2C_CheckEvent(I2C_TypeDef* I2Cx, uint32_t I2C_EVENT);

    2、高级状态监控（不需要掌握）

    实际上并不高级

    3、基于状态标志位的监控

    可以判断某一个标志位是否置1

    FlagStatus I2C_GetFlagStatus(I2C_TypeDef* I2Cx, uint32_t I2C_FLAG);

    1. void I2C_ClearFlag(I2C_TypeDef* I2Cx, uint32_t I2C_FLAG);
    2. ITStatus I2C_GetITStatus(I2C_TypeDef* I2Cx, uint32_t I2C_IT);
    3. void I2C_ClearITPendingBit(I2C_TypeDef* I2Cx, uint32_t I2C_IT);

     实现流程

    我们这节内容和上一节的软件读取IIC类似，所以复制上一个过程文件，把工程中有关IIC的代码删去

    第一步：配置IIC外设

    A、开启IIC外设的时钟和对应GPIO口的时钟
    B、配置GPIO口为复用开漏模式
    1.     RCC_APB1PeriphClockCmd(RCC_APB1Periph_I2C2, ENABLE);
    2. 	RCC_APB2PeriphClockCmd(RCC_APB2Periph_GPIOB, ENABLE);
    3. 	
    4. 	GPIO_InitTypeDef GPIO_InitStructure;
    5. 	GPIO_InitStructure.GPIO_Mode = GPIO_Mode_AF_OD;
    6. 	GPIO_InitStructure.GPIO_Pin = GPIO_Pin_10 | GPIO_Pin_11;
    7. 	GPIO_InitStructure.GPIO_Speed = GPIO_Speed_50MHz;
    8. 	GPIO_Init(GPIOB, &GPIO_InitStructure);
    C、通过结构体配置相关参数

    特别说明：为什么要设置一个控制占空比的结构体成员呢？

    占空比的设置是为了快速传输而设置的

    50kHz的情况下

    400kHz的情况下

    因为时钟信号是强下拉，弱上拉，这就会导致在产生下降沿的时候速度非常快，而产生上升沿的时候电平却变化得比较慢，是慢慢回弹回去的（类似于弹簧模型，强下拉就像强行把弹簧按下去，而弱上拉却是弹簧自己慢慢弹上去）

    数据变化需要一定时间来产生波形，由其是上升沿，变化比较慢，而数据的采集却会很快（在上升沿时采集SDA上的电平）所以我们需要给产生波形多一点时间，即让SCL时钟信号的低电平时间（写入时间）变得更长一点，所以采取设置其占空比来实现该目的

    D、开关使能

    整体：

    1. void HI2C_Init(void)
    2. {
    3. 	RCC_APB1PeriphClockCmd(RCC_APB1Periph_I2C2, ENABLE);
    4. 	RCC_APB2PeriphClockCmd(RCC_APB2Periph_GPIOB, ENABLE);
    5. 	
    6. 	GPIO_InitTypeDef GPIO_InitStructure;
    7. 	GPIO_InitStructure.GPIO_Mode = GPIO_Mode_AF_OD;
    8. 	GPIO_InitStructure.GPIO_Pin = GPIO_Pin_10 | GPIO_Pin_11;
    9. 	GPIO_InitStructure.GPIO_Speed = GPIO_Speed_50MHz;
    10. 	GPIO_Init(GPIOB, &GPIO_InitStructure);
    11. 	
    12. 	I2C_InitTypeDef I2C_InitStructure;
    13. 	//I2C模式
    14. 	I2C_InitStructure.I2C_Mode = I2C_Mode_I2C;
    15. 	//I2C时钟速度-0~100KHZ(标准速度) 100KHz~400KHz(快速)
    16. 	I2C_InitStructure.I2C_ClockSpeed = 50000;
    17. 	//时钟占空比-标准速度(只能为1:1) 快速模式下可以为16:9或者2:1
    18. 	I2C_InitStructure.I2C_DutyCycle = I2C_DutyCycle_2;	
    19. 	//应答位(默认为Enable)
    20. 	I2C_InitStructure.I2C_Ack = I2C_Ack_Enable;
    21. 	//Stm32作为从机的地址位数
    22. 	I2C_InitStructure.I2C_AcknowledgedAddress = I2C_AcknowledgedAddress_7bit;
    23. 	//给STM32指定一个从机地址
    24. 	I2C_InitStructure.I2C_OwnAddress1 = 0x00;
    25. 	I2C_Init(I2C2, &I2C_InitStructure);
    26. 	
    27. 	I2C_Cmd(I2C2, ENABLE);
    28. }

    第二步：实现指定地址写的时序

    对照之前写的I2C的软件实现即可

    需要注意的是软件I2C的这些函数内部都添加了Delay函数来等待数据的接收完成，是一种阻塞式的流程，也就是上一个函数完成后，数据肯定已经完成接收或者发送了，但是硬件I2C函数不一样，都不是阻塞式的，函数结束后是将对应的标志位置1，所以要确保数据完整，就必须在函数后加上判断相应标志位的函数，如下图所示

    举个栗子：在发送完起始位后需要判断EV5事件，这样我们就需要用上之前的监控函数了

    ErrorStatus I2C_CheckEvent(I2C_TypeDef* I2Cx, uint32_t I2C_EVENT);

    第二个参数： 

    返回值 

    所以要判断是否完成就需要套用一个while循环

    1.     //对照上面的软件I2C协议写
    2. 	I2C_GenerateSTART(I2C2, ENABLE);
    3. 	//EV5事件的检测
    4. 	while (I2C_CheckEvent(I2C2, I2C_EVENT_MASTER_MODE_SELECT) != SUCCESS);

    总体

    1. void MPU6050_WriteReg(uint8_t RegAddress, uint8_t Data)
    2. {
    3. //	MyI2C_Start();
    4. //	MyI2C_SendByte(MPU6050_ADDRESS);
    5. //	//可以验证是否收到数据，具体怎么处理就不加上了
    6. //	MyI2C_ReceiveAck();
    7. //	//发送寄存器的地址
    8. //	MyI2C_SendByte(RegAddress);
    9. //	MyI2C_ReceiveAck();
    10. //	//接收一个字节
    11. //	MyI2C_SendByte(Data);
    12. //	MyI2C_ReceiveAck();
    13. //	MyI2C_Stop();
    14. 	
    15. 	//对照上面的软件I2C协议写
    16. 	I2C_GenerateSTART(I2C2, ENABLE);
    17. 	//EV5事件的检测
    18. 	while (I2C_CheckEvent(I2C2, I2C_EVENT_MASTER_MODE_SELECT) != SUCCESS);
    19. 	
    20. 	//发送从机地址(注意这个地址不包含读写位)
    21. 	//发送地址函数中已经自带了接收应答的过程，则不用再调用函数来应答了
    22. 	//同样的，如果发送错误，硬件会通过置标志位或者中断来提醒我们
    23. 	I2C_Send7bitAddress(I2C2, MPU6050_ADDRESS, I2C_Direction_Transmitter);
    24. 	while (I2C_CheckEvent(I2C2, I2C_EVENT_MASTER_TRANSMITTER_MODE_SELECTED) != SUCCESS);
    25. 	
    26. 	I2C_SendData(I2C2, RegAddress);
    27. 	while (I2C_CheckEvent(I2C2, I2C_EVENT_MASTER_BYTE_TRANSMITTING) != SUCCESS);
    28.  
    29. 	I2C_SendData(I2C2, Data);
    30. 	while (I2C_CheckEvent(I2C2, I2C_EVENT_MASTER_BYTE_TRANSMITTED) != SUCCESS);
    31. 	
    32. 	I2C_GenerateSTOP(I2C2, ENABLE);
    33. }

    第三步：实现指定地址读的时序

     注意：在接收最后一个字节前，必须要提前把ACK置0和设置STOP请求（STOP不会打断字节的接收），如果只接收一个字节，就可以直接在接收数据1之前就把ACK置0和发送STOP请求。

    1. //指定地址读
    2. uint8_t MPU6050_ReadtheReg(uint8_t RegAddress)
    3. {
    4. 	uint8_t Data;
    5. //	MyI2C_Start();
    6. //	MyI2C_SendByte(MPU6050_ADDRESS);
    7. //	MyI2C_ReceiveAck();
    8. //	MyI2C_SendByte(RegAddress);
    9. //	MyI2C_ReceiveAck();
    10. //	
    11. //	MyI2C_Start();
    12. //	MyI2C_SendByte(MPU6050_ADDRESS | 0x01);
    13. //	MyI2C_ReceiveAck();
    14. //	Data = MyI2C_ReceiveByte();
    15. //	//发送主机应答，已经接收到数据了
    16. //	MyI2C_SendAck(1);
    17. //	MyI2C_Stop();
    18. 	
    19. 	//与发送一个字节的前半部分一样
    20. 	I2C_GenerateSTART(I2C2, ENABLE);
    21. 	while (I2C_CheckEvent(I2C2, I2C_EVENT_MASTER_MODE_SELECT) != SUCCESS);
    22. 	
    23. 	I2C_Send7bitAddress(I2C2, MPU6050_ADDRESS, I2C_Direction_Transmitter);
    24. 	while (I2C_CheckEvent(I2C2, I2C_EVENT_MASTER_TRANSMITTER_MODE_SELECTED) != SUCCESS);
    25. 	
    26. 	I2C_SendData(I2C2, RegAddress);
    27. 	//注意这里不是硬抄，检测的标志位改为了ED结尾(其实ing还是ED结尾都没有区别
    28. 	//都会等到发送数据完全结束后才会进行下一步操作
    29. 	while (I2C_CheckEvent(I2C2, I2C_EVENT_MASTER_BYTE_TRANSMITTED) != SUCCESS);
    30. 	
    31. 	//开始接收字节
    32. 	I2C_GenerateSTART(I2C2, ENABLE);
    33. 	while (I2C_CheckEvent(I2C2, I2C_EVENT_MASTER_MODE_SELECT) != SUCCESS);
    34. 	
    35. 	//发送寄存器地址
    36. 	I2C_Send7bitAddress(I2C2, MPU6050_ADDRESS, I2C_Direction_Receiver);
    37. 	while (I2C_CheckEvent(I2C2, I2C_EVENT_MASTER_RECEIVER_MODE_SELECTED) != SUCCESS);
    38. 	
    39. 	//提前ACK置0和发送STOP请求
    40. 	I2C_AcknowledgeConfig(I2C2, DISABLE);
    41. 	I2C_GenerateSTOP(I2C2, ENABLE);
    42. 	
    43. 	
    44. 	while (I2C_CheckEvent(I2C2, I2C_EVENT_MASTER_BYTE_RECEIVED) != SUCCESS);
    45. 	Data = I2C_ReceiveData(I2C2);
    46. 	
    47. 	I2C_AcknowledgeConfig(I2C2, ENABLE);
    48. 	
    49. 	return Data;
    50. }

     整体：记得在初始化函数中引用HI2C的初始化函数

    1. #include "stm32f10x.h"                  // Device header
    2. #include "MPU6050_Reg.h"
    3. #include "Hard-I2C.h"
    4.  
    5. #define MPU6050_ADDRESS		0xD0
    6. //指定地址写
    7. void MPU6050_WriteReg(uint8_t RegAddress, uint8_t Data)
    8. {
    9. //	MyI2C_Start();
    10. //	MyI2C_SendByte(MPU6050_ADDRESS);
    11. //	//可以验证是否收到数据，具体怎么处理就不加上了
    12. //	MyI2C_ReceiveAck();
    13. //	//发送寄存器的地址
    14. //	MyI2C_SendByte(RegAddress);
    15. //	MyI2C_ReceiveAck();
    16. //	//接收一个字节
    17. //	MyI2C_SendByte(Data);
    18. //	MyI2C_ReceiveAck();
    19. //	MyI2C_Stop();
    20. 	
    21. 	//对照上面的软件I2C协议写
    22. 	I2C_GenerateSTART(I2C2, ENABLE);
    23. 	//EV5事件的检测
    24. 	while (I2C_CheckEvent(I2C2, I2C_EVENT_MASTER_MODE_SELECT) != SUCCESS);
    25. 	
    26. 	//发送从机地址(注意这个地址不包含读写位)
    27. 	//发送地址函数中已经自带了接收应答的过程，则不用再调用函数来应答了
    28. 	//同样的，如果发送错误，硬件会通过置标志位或者中断来提醒我们
    29. 	I2C_Send7bitAddress(I2C2, MPU6050_ADDRESS, I2C_Direction_Transmitter);
    30. 	while (I2C_CheckEvent(I2C2, I2C_EVENT_MASTER_TRANSMITTER_MODE_SELECTED) != SUCCESS);
    31. 	
    32. 	I2C_SendData(I2C2, RegAddress);
    33. 	while (I2C_CheckEvent(I2C2, I2C_EVENT_MASTER_BYTE_TRANSMITTING) != SUCCESS);
    34.  
    35. 	I2C_SendData(I2C2, Data);
    36. 	while (I2C_CheckEvent(I2C2, I2C_EVENT_MASTER_BYTE_TRANSMITTED) != SUCCESS);
    37. 	
    38. 	I2C_GenerateSTOP(I2C2, ENABLE);
    39. }
    40.  
    41. //指定地址读
    42. uint8_t MPU6050_ReadtheReg(uint8_t RegAddress)
    43. {
    44. 	uint8_t Data;
    45. //	MyI2C_Start();
    46. //	MyI2C_SendByte(MPU6050_ADDRESS);
    47. //	MyI2C_ReceiveAck();
    48. //	MyI2C_SendByte(RegAddress);
    49. //	MyI2C_ReceiveAck();
    50. //	
    51. //	MyI2C_Start();
    52. //	MyI2C_SendByte(MPU6050_ADDRESS | 0x01);
    53. //	MyI2C_ReceiveAck();
    54. //	Data = MyI2C_ReceiveByte();
    55. //	//发送主机应答，已经接收到数据了
    56. //	MyI2C_SendAck(1);
    57. //	MyI2C_Stop();
    58. 	
    59. 	//与发送一个字节的前半部分一样
    60. 	I2C_GenerateSTART(I2C2, ENABLE);
    61. 	while (I2C_CheckEvent(I2C2, I2C_EVENT_MASTER_MODE_SELECT) != SUCCESS);
    62. 	
    63. 	I2C_Send7bitAddress(I2C2, MPU6050_ADDRESS, I2C_Direction_Transmitter);
    64. 	while (I2C_CheckEvent(I2C2, I2C_EVENT_MASTER_TRANSMITTER_MODE_SELECTED) != SUCCESS);
    65. 	
    66. 	I2C_SendData(I2C2, RegAddress);
    67. 	//注意这里不是硬抄，检测的标志位改为了ED结尾(其实ing还是ED结尾都没有区别
    68. 	//都会等到发送数据完全结束后才会进行下一步操作
    69. 	while (I2C_CheckEvent(I2C2, I2C_EVENT_MASTER_BYTE_TRANSMITTED) != SUCCESS);
    70. 	
    71. 	//开始接收字节
    72. 	I2C_GenerateSTART(I2C2, ENABLE);
    73. 	while (I2C_CheckEvent(I2C2, I2C_EVENT_MASTER_MODE_SELECT) != SUCCESS);
    74. 	
    75. 	//发送寄存器地址
    76. 	I2C_Send7bitAddress(I2C2, MPU6050_ADDRESS, I2C_Direction_Receiver);
    77. 	while (I2C_CheckEvent(I2C2, I2C_EVENT_MASTER_RECEIVER_MODE_SELECTED) != SUCCESS);
    78. 	
    79. 	//提前ACK置0和发送STOP请求
    80. 	I2C_AcknowledgeConfig(I2C2, DISABLE);
    81. 	I2C_GenerateSTOP(I2C2, ENABLE);
    82. 	
    83. 	
    84. 	while (I2C_CheckEvent(I2C2, I2C_EVENT_MASTER_BYTE_RECEIVED) != SUCCESS);
    85. 	Data = I2C_ReceiveData(I2C2);
    86. 	
    87. 	I2C_AcknowledgeConfig(I2C2, ENABLE);
    88. 	
    89. 	return Data;
    90. }
    91.  
    92. void MPU6050_Init(void)
    93. {
    94. 	HI2C_Init();
    95. 	//电源管理寄存器1
    96. 	//设备复位 	睡眠模式	循环模式	无关位	温度传感器失能	选择时钟(后三位)
    97. 	//0(不复位) 0(解除睡眠)	0(不需要)	0		0(不失能)		000(内部时钟)(或者001-陀螺仪时钟)
    98. 	MPU6050_WriteReg(MPU6050_PWR_MGMT_1, 0x01);
    99. 	
    100. 	//电源管理寄存器2
    101. 	//循环模式唤醒频率(不需要-00)
    102. 	//后6位每个轴的待机位-(000000-不待机)
    103. 	MPU6050_WriteReg(MPU6050_PWR_MGMT_2, 0x00);
    104. 	
    105. 	//采样率分频(值越小，数据输出越快)(采样分频为10)
    106. 	MPU6050_WriteReg(MPU6050_SMPLRT_DIV, 0x09);
    107. 	
    108. 	//配置寄存器
    109. 	//外部同步-000000 数字低通滤波-110
    110. 	MPU6050_WriteReg(MPU6050_CONFIG, 0x06);
    111. 	
    112. 	//陀螺仪配置寄存器
    113. 	//自测使能-000	满量程选择-11	无关位-000
    114. 	MPU6050_WriteReg(MPU6050_GYRO_CONFIG, 0x18);
    115. 	
    116. 	//加速度计配置寄存器
    117. 	//自测使能-000	满量程选择-11	高通滤波器-000
    118. 	MPU6050_WriteReg(MPU6050_ACCEL_CONFIG, 0x18);
    119. }
    120.  
    121. //读取寄存器
    122. void MPU6050_GetData(int16_t *AccX, int16_t *AccY, int16_t *AccZ,
    123. 						int16_t *GyroX, int16_t *GyroY, int16_t *GyroZ)
    124. {
    125. 	int16_t DataH, DataL;
    126. 	
    127. 	DataH = MPU6050_ReadtheReg(MPU6050_ACCEL_XOUT_H);
    128. 	DataL = MPU6050_ReadtheReg(MPU6050_ACCEL_XOUT_L);
    129. 	*AccX = (DataH << 8) | DataL;
    130. 	
    131. 	DataH = MPU6050_ReadtheReg(MPU6050_ACCEL_YOUT_H);
    132. 	DataL = MPU6050_ReadtheReg(MPU6050_ACCEL_YOUT_L);
    133. 	*AccY = (DataH << 8) | DataL;
    134. 	
    135. 	DataH = MPU6050_ReadtheReg(MPU6050_ACCEL_ZOUT_H);
    136. 	DataL = MPU6050_ReadtheReg(MPU6050_ACCEL_ZOUT_L);
    137. 	*AccZ = (DataH << 8) | DataL;
    138. 	
    139. 	DataH = MPU6050_ReadtheReg(MPU6050_GYRO_XOUT_H);
    140. 	DataL = MPU6050_ReadtheReg(MPU6050_GYRO_XOUT_L);
    141. 	*GyroX = (DataH << 8) | DataL;
    142. 	
    143. 	DataH = MPU6050_ReadtheReg(MPU6050_GYRO_YOUT_H);
    144. 	DataL = MPU6050_ReadtheReg(MPU6050_GYRO_YOUT_L);
    145. 	*GyroY = (DataH << 8) | DataL;
    146. 	
    147. 	DataH = MPU6050_ReadtheReg(MPU6050_GYRO_ZOUT_H);
    148. 	DataL = MPU6050_ReadtheReg(MPU6050_GYRO_ZOUT_L);
    149. 	*GyroZ = (DataH << 8) | DataL;
    150. }
    151.  
    152. uint8_t MPU6050_GetID(void)
    153. {
    154. 	return MPU6050_ReadtheReg(MPU6050_WHO_AM_I);
    155. }

    其他的没改变

    主函数

    1. #include "stm32f10x.h"                  // Device header
    2. #include "Delay.h"
    3. #include "OLED.h"
    4. #include "MPU6050.h"
    5.  
    6. uint8_t ID;
    7. int16_t AX, AY, AZ, GX, GY, GZ;
    8.  
    9. int main(void)
    10. {
    11. 	OLED_Init();
    12. 	MPU6050_Init();
    13. 	OLED_ShowString(1, 1, "ID:");
    14. 	ID = MPU6050_GetID();
    15. 	OLED_ShowHexNum(1, 4, ID, 2);
    16. 	
    17. 	while(1)
    18. 	{
    19. 		MPU6050_GetData(&AX, &AY, &AZ, &GX, &GY, &GZ);
    20. 		OLED_ShowSignedNum(2, 1, AX, 5);
    21. 		OLED_ShowSignedNum(3, 1, AY, 5);
    22. 		OLED_ShowSignedNum(4, 1, AZ, 5);
    23. 		OLED_ShowSignedNum(2, 8, GX, 5);
    24. 		OLED_ShowSignedNum(3, 8, GY, 5);
    25. 		OLED_ShowSignedNum(4, 8, GZ, 5);
    26. 	}
    27. }

    这样就可以实现相关功能了

    优化：

    我们是用死循环来等待标志位结束的，但凡有一个没结束都会导致整个函数停止

    我们可以封装一个函数来实现计时功能，计数指定时间后退出函数

    可以防止卡死错误

    1. void MPU6050_WaitEvent(I2C_TypeDef* I2Cx, uint32_t I2C_EVENT)
    2. {
    3. 	uint32_t Timeout;
    4. 	Timeout = 10000;
    5. 	while (I2C_CheckEvent(I2Cx, I2C_EVENT) != SUCCESS)
    6. 	{
    7. 		Timeout --;
    8. 		if (Timeout == 0)
    9. 		{
    10. 			break;
    11. 		}
    12. 	}
    13. }

    把函数中的每个while循环改为此函数即可

  • 相关阅读:
    《七月集训》第二十八日——动态规划
    android 自定义View 视差动画
    react中类组件的相关问题及优化
    拼图小游戏
    SQL Server基础指令（创建与检索）
    【无标题】
    2023全新小程序广告流量主奖励发放系统源码 流量变现系统
    nginx升级
    C语言函数
    数据结构（1）线性结构——数组、链表、堆栈、队列（介绍和JAVA代码实现）
  • 原文地址：https://blog.csdn.net/m0_74460550/article/details/133758478