STM32江科大----IIC

声明：本人跟随b站江科大学习，本文章是观看完视频后的一些个人总结和经验分享，也同时为了方便日后的复习，如果有错误请各位大佬指出，如果对你有帮助可以点个赞小小鼓励一下，本文章建议共同原视频使用❤️
    如果你也正在学习STM32可以订阅本专栏，后续将不定期更新( ˘ ³˘)❤️
如有侵权，请私信接洽删除

  

---

  

---

前言

• 弄清IIC时序结构以及硬件要求
  
• MPU6050的基本参数和大概使用方法
  
• 一般情况下软件实现iic比硬件更为常用，但是硬件也有其上风，比如：可节流软件资源，可实现完整的多主机通讯模型，时序波形规整，通讯速率快，一般用于对性能指标要求高，软件iic则更为灵活，比如iic总线理论上可无限开辟，而硬件iic外设有限
  

理论部分

有关IIC理论部分

有关iic的理论知识可以看一下我的这篇文章iic的时序结构，就不做多余赘述了，个人觉得up在32里面讲iic比51清楚，有兴趣的小伙伴还是建议看一下32的iic原视频
MPU6050

参数和简介

• 理论上陀螺仪传感器是可以直接丈量处具体角度的，但这里只能丈量出角加速度，最后的角度的话必要另外计算，比如对角速度积分
  
• 加速度计具有静态稳固性，不具有动态稳固性，内部工作原理其实就是F=ma，m在里面为一个已知小球重量，用雷同于弹簧测力计的东西丈量出小球对一个面的压力，用压力除以m，就是该面方向上的加速度
  
• 陀螺仪计具有动态稳固性，不具有静态稳固性，因为静止时角速度值会因为噪声而无法完全归零，颠末积分的不断累积，这个小噪声就会导致积分会产生一个角度的缓慢漂移，最后就不准确
  

• 16位的ADC就是2^16=65536，但是由于加速度计和陀螺仪计都是存在方向的，以是就平分65536，一半为正值，一半为负值
  
• 不同量程的选择，丈量范围也会变化，量程越大丈量范围越大，但是分辨率会变低
  
• 从机地址有两种表示方法，一种是将7位作为从机地址，那么110 1000就是0x68，那么要加上读写位就是0x68 | 读写位，也可以表示为11010000，那么就是加上读写位表示从机地址，也就是0xD0，那么0xD0就是写地址，0xD1就是读地址
  

硬件电路

• XCL和XDA用于扩展装备，比方气压计等等
  
• AD0用于配置从机地址最低位，也就是第8位，默认是0
  
• 若使用停止，则停止可引起INT电平跳变
  

内部框图

IIC通讯外设

IIC外设简介

• 10位地址模式：也就是前五位必须是11110作为10位寻址标志位，然后第一个字节有7个地址位和一位读写位，第二个字节有8个地址位，那么第一个字节的7个地址位中的前五位为标志位，后两位和第二个字节的8位为地址位，总共10位就是1024种情况
  
• SMBus是系统管理总线，主要用于电源管理系统，相识即可
  

IIC框图

主要分为SDA和SCL两个部分，SDA主要与DR和数据移位寄存器有关，其过程雷同于串口，SCL主要和CCR，CR，SR有关，其余部分相识即可
IIC基本结构（一主多从）

• 由于高位先行，以是移位寄存器是向左移位，主要通讯过程还是看移位寄存器和DR的共同，一个SCL时钟移位一次，移位8次可将一个字节放在SDA线上，大概流程就是，先将数据写入DR,当移位寄存器是空的时候，就转到移位寄存器然后发送(对应背面时序的数据寄存器空和移位寄存器空)
  
• GPIO口都要配置成复用开漏输出模式，因为使用的是片上外设
  

时序—主机发送

• EVx（Event x）即变乱x，使用变乱来表示相当于一个大的标志位包罗多个小标志位，有专门的函数来读取这个大标志位，也就是配置CR会产生多个不同标志位组合形成了EVx这个大标志位
  

时序—主机接受

软件和硬件的波形对比（上为软件，下为硬件）

大概的区别：

• 软件波形不规整，SCL高电平占空比不一致,硬件则十分规整
  
• 软件中SDA在SCL拉低SCL变更数据时存在较大延时，硬件则延时很小，基本上在SCL拉低的瞬间就立马变更SDA
  
• 图中RA应答结束时，硬件产生了一个小尖峰，而软件则产生一个峰值延伸，这是在RA结束时,从机立马就开释了SDA将SDA操纵权归还主机,让主机预备发送下一个数据0，但是这里软件主机延伸了一会才拉低SDA，将0放在SDA线上，硬件则是主机立马就拉低SDA，以是没有产生那个峰值延伸而是产生一个尖峰
  

代码部分

软件模仿iic

软件模仿说明确了就是实当代码模仿时序结构，到达发送字节的效果，和以前51里面的写法基本相同
MyI2C.c

1. #include "stm32f10x.h"                  // Device header
2. #include "Delay.h"
4. /*引脚配置层*/
6. /**
7.   * 函    数：I2C写SCL引脚电平
8.   * 参    数：BitValue 协议层传入的当前需要写入SCL的电平，范围0~1
9.   * 返 回 值：无
10.   * 注意事项：此函数需要用户实现内容，当BitValue为0时，需要置SCL为低电平，当BitValue为1时，需要置SCL为高电平
11.   */
12. void MyI2C_W_SCL(uint8_t BitValue)
13. {
14.         GPIO_WriteBit(GPIOB, GPIO_Pin_10, (BitAction)BitValue);                //根据BitValue，设置SCL引脚的电平
15.         Delay_us(10);                                                                                                //延时10us，防止时序频率超过要求
16. }
18. /**
19.   * 函    数：I2C写SDA引脚电平
20.   * 参    数：BitValue 协议层传入的当前需要写入SDA的电平，范围0~1
21.   * 返 回 值：无
22.   * 注意事项：此函数需要用户实现内容，当BitValue为0时，需要置SDA为低电平，当BitValue为1时，需要置SDA为高电平
23.   */
24. void MyI2C_W_SDA(uint8_t BitValue)
25. {
26.         GPIO_WriteBit(GPIOB, GPIO_Pin_11, (BitAction)BitValue);                //根据BitValue，设置SDA引脚的电平，BitValue要实现非0即1的特性
27.         Delay_us(10);                                                                                                //延时10us，防止时序频率超过要求
28. }
30. /**
31.   * 函    数：I2C读SDA引脚电平
32.   * 参    数：无
33.   * 返 回 值：协议层需要得到的当前SDA的电平，范围0~1
34.   * 注意事项：此函数需要用户实现内容，当前SDA为低电平时，返回0，当前SDA为高电平时，返回1
35.   */
36. uint8_t MyI2C_R_SDA(void)
37. {
38.         uint8_t BitValue;
39.         BitValue = GPIO_ReadInputDataBit(GPIOB, GPIO_Pin_11);                //读取SDA电平
40.         Delay_us(10);                                                                                                //延时10us，防止时序频率超过要求
41.         return BitValue;                                                                                        //返回SDA电平
42. }
44. /**
45.   * 函    数：I2C初始化
46.   * 参    数：无
47.   * 返 回 值：无
48.   * 注意事项：此函数需要用户实现内容，实现SCL和SDA引脚的初始化
49.   */
50. void MyI2C_Init(void)
51. {
52.         /*开启时钟*/
53.         RCC_APB2PeriphClockCmd(RCC_APB2Periph_GPIOB, ENABLE);        //开启GPIOB的时钟
54.        
55.         /*GPIO初始化*/
56.         GPIO_InitTypeDef GPIO_InitStructure;
57.         GPIO_InitStructure.GPIO_Mode = GPIO_Mode_Out_OD;
58.         GPIO_InitStructure.GPIO_Pin = GPIO_Pin_10 | GPIO_Pin_11;
59.         GPIO_InitStructure.GPIO_Speed = GPIO_Speed_50MHz;
60.         GPIO_Init(GPIOB, &GPIO_InitStructure);                                        //将PB10和PB11引脚初始化为开漏输出
61.        
62.         /*设置默认电平*/
63.         GPIO_SetBits(GPIOB, GPIO_Pin_10 | GPIO_Pin_11);                        //设置PB10和PB11引脚初始化后默认为高电平（释放总线状态）
64. }
66. /*协议层*/
68. /**
69.   * 函    数：I2C起始
70.   * 参    数：无
71.   * 返 回 值：无
72.   */
73. void MyI2C_Start(void)
74. {
75.         MyI2C_W_SDA(1);                                                        //释放SDA，确保SDA为高电平
76.                                                                                         //其实先释放SCL也可以，但是若SCL还被未释放在高电平时，
77.                                                                                         //此时SDA被释放，根据停止的时序结构就会产生一个停止信号
78.         MyI2C_W_SCL(1);                                                        //释放SCL，确保SCL为高电平
79.         MyI2C_W_SDA(0);                                                        //在SCL高电平期间，拉低SDA，产生起始信号
80.         MyI2C_W_SCL(0);                                                        //起始后把SCL也拉低，即为了占用总线，也为了方便总线时序的拼接
81. }
83. /**
84.   * 函    数：I2C终止
85.   * 参    数：无
86.   * 返 回 值：无
87.   */
88. void MyI2C_Stop(void)
89. {
90.         MyI2C_W_SDA(0);                                                        //拉低SDA，确保SDA为低电平
91.         MyI2C_W_SCL(1);                                                        //释放SCL，使SCL呈现高电平
92.         MyI2C_W_SDA(1);                                                        //在SCL高电平期间，释放SDA，产生终止信号
93. }
95. /**
96.   * 函    数：I2C发送一个字节
97.   * 参    数：Byte 要发送的一个字节数据，范围：0x00~0xFF
98.   * 返 回 值：无
99.   */
100. void MyI2C_SendByte(uint8_t Byte)
101. {
102.         uint8_t i;
103.         for (i = 0; i < 8; i ++)                                //循环8次，主机依次发送数据的每一位
104.         {
105.                 /*两个!可以对数据进行两次逻辑取反，作用是把非0值统一转换为1，即：!!(0) = 0，!!(非0) = 1*/
106.                 MyI2C_W_SDA(!!(Byte & (0x80 >> i)));//使用掩码的方式取出Byte的指定一位数据并写入到SDA线
107.                 MyI2C_W_SCL(1);                                                //释放SCL，从机在SCL高电平期间读取SDA
108.                 MyI2C_W_SCL(0);                                                //拉低SCL，主机开始发送下一位数据
109.         }
110. }
112. /**
113.   * 函    数：I2C接收一个字节
114.   * 参    数：无
115.   * 返 回 值：接收到的一个字节数据，范围：0x00~0xFF
116.   */
117. uint8_t MyI2C_ReceiveByte(void)
118. {
119.         uint8_t i, Byte = 0x00;                                        //定义接收的数据，并赋初值0x00，此处必须赋初值0x00，后面会用到
120.         MyI2C_W_SDA(1);                                                        //接收前，主机先确保释放SDA，避免干扰从机的数据发送
121.         for (i = 0; i < 8; i ++)                                //循环8次，主机依次接收数据的每一位
122.         {
123.                 MyI2C_W_SCL(1);                                                //释放SCL，主机机在SCL高电平期间读取SDA
124.                 if (MyI2C_R_SDA()){Byte |= (0x80 >> i);}        //读取SDA数据，并存储到Byte变量
125.                                                                                                         //当SDA为1时，置变量指定位为1，当SDA为0时，不做处理，指定位为默认的初值0
126.                 MyI2C_W_SCL(0);                                                //拉低SCL，从机在SCL低电平期间写入SDA
127.         }
128.         return Byte;                                                        //返回接收到的一个字节数据
129. }
131. /**
132.   * 函    数：I2C发送应答位
133.   * 参    数：Byte 要发送的应答位，范围：0~1，0表示应答，1表示非应答
134.   * 返 回 值：无
135.   */
136. void MyI2C_SendAck(uint8_t AckBit)
137. {
138.         MyI2C_W_SDA(AckBit);                                        //主机把应答位数据放到SDA线
139.         MyI2C_W_SCL(1);                                                        //释放SCL，从机在SCL高电平期间，读取应答位
140.         MyI2C_W_SCL(0);                                                        //拉低SCL，开始下一个时序模块
141. }
143. /**
144.   * 函    数：I2C接收应答位
145.   * 参    数：无
146.   * 返 回 值：接收到的应答位，范围：0~1，0表示应答，1表示非应答
147.   */
148. uint8_t MyI2C_ReceiveAck(void)
149. {
150.         uint8_t AckBit;                                                        //定义应答位变量
151.         MyI2C_W_SDA(1);                                                        //接收前，主机先确保释放SDA，避免干扰从机的数据发送
152.         MyI2C_W_SCL(1);                                                        //释放SCL，主机机在SCL高电平期间读取SDA
153.         AckBit = MyI2C_R_SDA();                                        //将应答位存储到变量里
154.         MyI2C_W_SCL(0);                                                        //拉低SCL，开始下一个时序模块
155.         return AckBit;                                                        //返回定义应答位变量
156. }

复制代码

MyI2C.h

1. #ifndef __MYI2C_H
2. #define __MYI2C_H
4. void MyI2C_Init(void);
5. void MyI2C_Start(void);
6. void MyI2C_Stop(void);
7. void MyI2C_SendByte(uint8_t Byte);
8. uint8_t MyI2C_ReceiveByte(void);
9. void MyI2C_SendAck(uint8_t AckBit);
10. uint8_t MyI2C_ReceiveAck(void);
12. #endif

复制代码

MPU6050.c

1. #include "stm32f10x.h"                  // Device header
2. #include "MyI2C.h"
3. #include "MPU6050_Reg.h"
5. #define MPU6050_ADDRESS                0xD0                //MPU6050的I2C从机地址
7. /**
8.   * 函    数：MPU6050写寄存器
9.   * 参    数：RegAddress 寄存器地址，范围：参考MPU6050手册的寄存器描述
10.   * 参    数：Data 要写入寄存器的数据，范围：0x00~0xFF
11.   * 返 回 值：无
12.   */
13. void MPU6050_WriteReg(uint8_t RegAddress, uint8_t Data)
14. {
15.         MyI2C_Start();                                                //I2C起始
16.         MyI2C_SendByte(MPU6050_ADDRESS);        //发送从机地址，读写位为0，表示即将写入
17.         MyI2C_ReceiveAck();                                        //接收应答
18.         MyI2C_SendByte(RegAddress);                        //发送寄存器地址
19.         MyI2C_ReceiveAck();                                        //接收应答
20.         MyI2C_SendByte(Data);                                //发送要写入寄存器的数据
21.         MyI2C_ReceiveAck();                                        //接收应答
22.         MyI2C_Stop();                                                //I2C终止
23. }
25. /**
26.   * 函    数：MPU6050读寄存器
27.   * 参    数：RegAddress 寄存器地址，范围：参考MPU6050手册的寄存器描述
28.   * 返 回 值：读取寄存器的数据，范围：0x00~0xFF
29.   */
30. uint8_t MPU6050_ReadReg(uint8_t RegAddress)
31. {
32.         uint8_t Data;
33.        
34.         MyI2C_Start();                                                //I2C起始
35.         MyI2C_SendByte(MPU6050_ADDRESS);        //发送从机地址，读写位为0，表示即将写入
36.         MyI2C_ReceiveAck();                                        //接收应答
37.         MyI2C_SendByte(RegAddress);                        //发送寄存器地址
38.         MyI2C_ReceiveAck();                                        //接收应答
39.        
40.         MyI2C_Start();                                                //I2C重复起始
41.         MyI2C_SendByte(MPU6050_ADDRESS | 0x01);        //发送从机地址，读写位为1，表示即将读取
42.         MyI2C_ReceiveAck();                                        //接收应答
43.         Data = MyI2C_ReceiveByte();                        //接收指定寄存器的数据
44.         MyI2C_SendAck(1);                                        //发送应答，给从机非应答，终止从机的数据输出
45.         MyI2C_Stop();                                                //I2C终止
46.        
47.         return Data;
48. }
50. /**
51.   * 函    数：MPU6050初始化
52.   * 参    数：无
53.   * 返 回 值：无
54.   */
55. void MPU6050_Init(void)
56. {
57.         MyI2C_Init();                                                                        //先初始化底层的I2C
58.        
59.         /*MPU6050寄存器初始化，需要对照MPU6050手册的寄存器描述配置，此处仅配置了部分重要的寄存器*/
60.         MPU6050_WriteReg(MPU6050_PWR_MGMT_1, 0x01);                //电源管理寄存器1，取消睡眠模式，选择时钟源为X轴陀螺仪
61.         MPU6050_WriteReg(MPU6050_PWR_MGMT_2, 0x00);                //电源管理寄存器2，保持默认值0，所有轴均不待机
62.         MPU6050_WriteReg(MPU6050_SMPLRT_DIV, 0x09);                //采样率分频寄存器，配置采样率
63.         MPU6050_WriteReg(MPU6050_CONFIG, 0x06);                        //配置寄存器，配置DLPF
64.         MPU6050_WriteReg(MPU6050_GYRO_CONFIG, 0x18);        //陀螺仪配置寄存器，选择满量程为±2000°/s
65.         MPU6050_WriteReg(MPU6050_ACCEL_CONFIG, 0x18);        //加速度计配置寄存器，选择满量程为±16g
66. }
68. /**
69.   * 函    数：MPU6050获取ID号
70.   * 参    数：无
71.   * 返 回 值：MPU6050的ID号
72.   */
73. uint8_t MPU6050_GetID(void)
74. {
75.         return MPU6050_ReadReg(MPU6050_WHO_AM_I);                //返回WHO_AM_I寄存器的值
76. }
78. /**
79.   * 函    数：MPU6050获取数据
80.   * 参    数：AccX AccY AccZ 加速度计X、Y、Z轴的数据，使用输出参数的形式返回，范围：-32768~32767
81.   * 参    数：GyroX GyroY GyroZ 陀螺仪X、Y、Z轴的数据，使用输出参数的形式返回，范围：-32768~32767
82.   * 返 回 值：无
83.   */
84. void MPU6050_GetData(int16_t *AccX, int16_t *AccY, int16_t *AccZ,
85.                                                 int16_t *GyroX, int16_t *GyroY, int16_t *GyroZ)
86. {
87.         uint8_t DataH, DataL;                                                                //定义数据高8位和低8位的变量
88.        
89.         DataH = MPU6050_ReadReg(MPU6050_ACCEL_XOUT_H);                //读取加速度计X轴的高8位数据
90.         DataL = MPU6050_ReadReg(MPU6050_ACCEL_XOUT_L);                //读取加速度计X轴的低8位数据
91.         *AccX = (DataH << 8) | DataL;                                                //数据拼接，通过输出参数返回
92.        
93.         DataH = MPU6050_ReadReg(MPU6050_ACCEL_YOUT_H);                //读取加速度计Y轴的高8位数据
94.         DataL = MPU6050_ReadReg(MPU6050_ACCEL_YOUT_L);                //读取加速度计Y轴的低8位数据
95.         *AccY = (DataH << 8) | DataL;                                                //数据拼接，通过输出参数返回
96.        
97.         DataH = MPU6050_ReadReg(MPU6050_ACCEL_ZOUT_H);                //读取加速度计Z轴的高8位数据
98.         DataL = MPU6050_ReadReg(MPU6050_ACCEL_ZOUT_L);                //读取加速度计Z轴的低8位数据
99.         *AccZ = (DataH << 8) | DataL;                                                //数据拼接，通过输出参数返回
100.        
101.         DataH = MPU6050_ReadReg(MPU6050_GYRO_XOUT_H);                //读取陀螺仪X轴的高8位数据
102.         DataL = MPU6050_ReadReg(MPU6050_GYRO_XOUT_L);                //读取陀螺仪X轴的低8位数据
103.         *GyroX = (DataH << 8) | DataL;                                                //数据拼接，通过输出参数返回
104.        
105.         DataH = MPU6050_ReadReg(MPU6050_GYRO_YOUT_H);                //读取陀螺仪Y轴的高8位数据
106.         DataL = MPU6050_ReadReg(MPU6050_GYRO_YOUT_L);                //读取陀螺仪Y轴的低8位数据
107.         *GyroY = (DataH << 8) | DataL;                                                //数据拼接，通过输出参数返回
108.        
109.         DataH = MPU6050_ReadReg(MPU6050_GYRO_ZOUT_H);                //读取陀螺仪Z轴的高8位数据
110.         DataL = MPU6050_ReadReg(MPU6050_GYRO_ZOUT_L);                //读取陀螺仪Z轴的低8位数据
111.         *GyroZ = (DataH << 8) | DataL;                                                //数据拼接，通过输出参数返回
112. }

复制代码

MPU6050.h

1. #ifndef __MPU6050_H
2. #define __MPU6050_H
4. void MPU6050_WriteReg(uint8_t RegAddress, uint8_t Data);
5. uint8_t MPU6050_ReadReg(uint8_t RegAddress);
7. void MPU6050_Init(void);
8. uint8_t MPU6050_GetID(void);
9. void MPU6050_GetData(int16_t *AccX, int16_t *AccY, int16_t *AccZ,
10.                                                 int16_t *GyroX, int16_t *GyroY, int16_t *GyroZ);
12. #endif

复制代码

MPU6050_Reg

1. #ifndef __MPU6050_REG_H
2. #define __MPU6050_REG_H
4. #define        MPU6050_SMPLRT_DIV                0x19
5. #define        MPU6050_CONFIG                        0x1A
6. #define        MPU6050_GYRO_CONFIG                0x1B
7. #define        MPU6050_ACCEL_CONFIG        0x1C
9. #define        MPU6050_ACCEL_XOUT_H        0x3B
10. #define        MPU6050_ACCEL_XOUT_L        0x3C
11. #define        MPU6050_ACCEL_YOUT_H        0x3D
12. #define        MPU6050_ACCEL_YOUT_L        0x3E
13. #define        MPU6050_ACCEL_ZOUT_H        0x3F
14. #define        MPU6050_ACCEL_ZOUT_L        0x40
15. #define        MPU6050_TEMP_OUT_H                0x41
16. #define        MPU6050_TEMP_OUT_L                0x42
17. #define        MPU6050_GYRO_XOUT_H                0x43
18. #define        MPU6050_GYRO_XOUT_L                0x44
19. #define        MPU6050_GYRO_YOUT_H                0x45
20. #define        MPU6050_GYRO_YOUT_L                0x46
21. #define        MPU6050_GYRO_ZOUT_H                0x47
22. #define        MPU6050_GYRO_ZOUT_L                0x48
24. #define        MPU6050_PWR_MGMT_1                0x6B
25. #define        MPU6050_PWR_MGMT_2                0x6C
26. #define        MPU6050_WHO_AM_I                0x75
28. #endif

复制代码

main.c

1. #include "stm32f10x.h"                  // Device header
2. #include "Delay.h"
3. #include "OLED.h"
4. #include "MPU6050.h"
6. uint8_t ID;                                                                //定义用于存放ID号的变量
7. int16_t AX, AY, AZ, GX, GY, GZ;                        //定义用于存放各个数据的变量
9. int main(void)
10. {
11.         /*模块初始化*/
12.         OLED_Init();                //OLED初始化
13.         MPU6050_Init();                //MPU6050初始化
14.        
15.         /*显示ID号*/
16.         OLED_ShowString(1, 1, "ID:");                //显示静态字符串
17.         ID = MPU6050_GetID();                                //获取MPU6050的ID号
18.         OLED_ShowHexNum(1, 4, ID, 2);                //OLED显示ID号
19.        
20.         while (1)
21.         {
22.                 MPU6050_GetData(&AX, &AY, &AZ, &GX, &GY, &GZ);                //获取MPU6050的数据
23.                 OLED_ShowSignedNum(2, 1, AX, 5);                                        //OLED显示数据
24.                 OLED_ShowSignedNum(3, 1, AY, 5);
25.                 OLED_ShowSignedNum(4, 1, AZ, 5);
26.                 OLED_ShowSignedNum(2, 8, GX, 5);
27.                 OLED_ShowSignedNum(3, 8, GY, 5);
28.                 OLED_ShowSignedNum(4, 8, GZ, 5);
29.         }
30. }

复制代码

硬件模仿iic

硬件模仿也就是使用写好的库函数控制DR,SR,CR各个寄存器，而电平的翻转由硬件控制，写入CR或者DR就可以控制时序单元的发生，时序单元发生后就可以检查对应的EVx，也就是检查SR，然后等候时序单元的发送完成，然后依次操纵寄存器，等候时序单元发送，云云循环，这是发送部分；接受部分就是写入CR读取DR,产生时序单元，等候变乱和时序单元的完成，云云循环
MPU6050.c

1. #include "stm32f10x.h"                  // Device header
2. #include "MPU6050_Reg.h"
4. #define MPU6050_ADDRESS                0xD0                //MPU6050的I2C从机地址
6. /**
7.   * 函    数：MPU6050等待事件
8.   * 参    数：同I2C_CheckEvent
9.   * 返 回 值：无
10.   */
11. void MPU6050_WaitEvent(I2C_TypeDef* I2Cx, uint32_t I2C_EVENT)
12. {
13.         uint32_t Timeout;
14.         Timeout = 10000;                                                                        //给定超时计数时间
15.         while (I2C_CheckEvent(I2Cx, I2C_EVENT) != SUCCESS)        //循环等待指定事件
16.         {
17.                 Timeout --;                                                                                //等待时，计数值自减
18.                 if (Timeout == 0)                                                                //自减到0后，等待超时
19.                 {
20.                         /*超时的错误处理代码，可以添加到此处*/
21.                         break;                                                                                //跳出等待，不等了
22.                 }
23.         }
24. }
26. /**
27.   * 函    数：MPU6050写寄存器
28.   * 参    数：RegAddress 寄存器地址，范围：参考MPU6050手册的寄存器描述
29.   * 参    数：Data 要写入寄存器的数据，范围：0x00~0xFF
30.   * 返 回 值：无
31.   */
32. void MPU6050_WriteReg(uint8_t RegAddress, uint8_t Data)
33. {
34.         I2C_GenerateSTART(I2C2, ENABLE);                                                                                //硬件I2C生成起始条件
35.         MPU6050_WaitEvent(I2C2, I2C_EVENT_MASTER_MODE_SELECT);                                        //等待EV5
36.        
37.         I2C_Send7bitAddress(I2C2, MPU6050_ADDRESS, I2C_Direction_Transmitter);        //硬件I2C发送从机地址，方向为发送
38.         MPU6050_WaitEvent(I2C2, I2C_EVENT_MASTER_TRANSMITTER_MODE_SELECTED);        //等待EV6
39.        
40.         I2C_SendData(I2C2, RegAddress);                                                                                        //硬件I2C发送寄存器地址
41.         MPU6050_WaitEvent(I2C2, I2C_EVENT_MASTER_BYTE_TRANSMITTING);                        //等待EV8
42.        
43.         I2C_SendData(I2C2, Data);                                                                                                //硬件I2C发送数据
44.         MPU6050_WaitEvent(I2C2, I2C_EVENT_MASTER_BYTE_TRANSMITTED);                                //等待EV8_2
45.        
46.         I2C_GenerateSTOP(I2C2, ENABLE);                                                                                        //硬件I2C生成终止条件
47. }
49. /**
50.   * 函    数：MPU6050读寄存器
51.   * 参    数：RegAddress 寄存器地址，范围：参考MPU6050手册的寄存器描述
52.   * 返 回 值：读取寄存器的数据，范围：0x00~0xFF
53.   */
54. uint8_t MPU6050_ReadReg(uint8_t RegAddress)
55. {
56.         uint8_t Data;
57.        
58.         I2C_GenerateSTART(I2C2, ENABLE);                                                                                //硬件I2C生成起始条件
59.         MPU6050_WaitEvent(I2C2, I2C_EVENT_MASTER_MODE_SELECT);                                        //等待EV5
60.        
61.         I2C_Send7bitAddress(I2C2, MPU6050_ADDRESS, I2C_Direction_Transmitter);        //硬件I2C发送从机地址，方向为发送
62.         MPU6050_WaitEvent(I2C2, I2C_EVENT_MASTER_TRANSMITTER_MODE_SELECTED);        //等待EV6
63.        
64.         I2C_SendData(I2C2, RegAddress);                                                                                        //硬件I2C发送寄存器地址
65.         MPU6050_WaitEvent(I2C2, I2C_EVENT_MASTER_BYTE_TRANSMITTED);                                //等待EV8_2
66.        
67.         I2C_GenerateSTART(I2C2, ENABLE);                                                                                //硬件I2C生成重复起始条件
68.         MPU6050_WaitEvent(I2C2, I2C_EVENT_MASTER_MODE_SELECT);                                        //等待EV5
69.        
70.         I2C_Send7bitAddress(I2C2, MPU6050_ADDRESS, I2C_Direction_Receiver);                //硬件I2C发送从机地址，方向为接收
71.         MPU6050_WaitEvent(I2C2, I2C_EVENT_MASTER_RECEIVER_MODE_SELECTED);                //等待EV6
72.        
73.         I2C_AcknowledgeConfig(I2C2, DISABLE);                                                                        //在接收最后一个字节之前提前将应答失能
74.         I2C_GenerateSTOP(I2C2, ENABLE);                                                                                        //在接收最后一个字节之前提前申请停止条件
75.        
76.         MPU6050_WaitEvent(I2C2, I2C_EVENT_MASTER_BYTE_RECEIVED);                                //等待EV7
77.         Data = I2C_ReceiveData(I2C2);                                                                                        //接收数据寄存器
78.        
79.         I2C_AcknowledgeConfig(I2C2, ENABLE);                                                                        //将应答恢复为使能，为了不影响后续可能产生的读取多字节操作
80.        
81.         return Data;
82. }
84. /**
85.   * 函    数：MPU6050初始化
86.   * 参    数：无
87.   * 返 回 值：无
88.   */
89. void MPU6050_Init(void)
90. {
91.         /*开启时钟*/
92.         RCC_APB1PeriphClockCmd(RCC_APB1Periph_I2C2, ENABLE);                //开启I2C2的时钟
93.         RCC_APB2PeriphClockCmd(RCC_APB2Periph_GPIOB, ENABLE);                //开启GPIOB的时钟
94.        
95.         /*GPIO初始化*/
96.         GPIO_InitTypeDef GPIO_InitStructure;
97.         GPIO_InitStructure.GPIO_Mode = GPIO_Mode_AF_OD;
98.         GPIO_InitStructure.GPIO_Pin = GPIO_Pin_10 | GPIO_Pin_11;
99.         GPIO_InitStructure.GPIO_Speed = GPIO_Speed_50MHz;
100.         GPIO_Init(GPIOB, &GPIO_InitStructure);                                        //将PB10和PB11引脚初始化为复用开漏输出
101.        
102.         /*I2C初始化*/
103.         I2C_InitTypeDef I2C_InitStructure;                                                //定义结构体变量
104.         I2C_InitStructure.I2C_Mode = I2C_Mode_I2C;                                //模式，选择为I2C模式
105.         I2C_InitStructure.I2C_ClockSpeed = 50000;                                //时钟速度，选择为50KHz
106.         I2C_InitStructure.I2C_DutyCycle = I2C_DutyCycle_2;                //时钟占空比，选择Tlow/Thigh = 2
107.         I2C_InitStructure.I2C_Ack = I2C_Ack_Enable;                                //应答，选择使能
108.         I2C_InitStructure.I2C_AcknowledgedAddress = I2C_AcknowledgedAddress_7bit;        //应答地址，选择7位，从机模式下才有效
109.         I2C_InitStructure.I2C_OwnAddress1 = 0x00;                                //自身地址，从机模式下才有效
110.         I2C_Init(I2C2, &I2C_InitStructure);                                                //将结构体变量交给I2C_Init，配置I2C2
111.        
112.         /*I2C使能*/
113.         I2C_Cmd(I2C2, ENABLE);                                                                        //使能I2C2，开始运行
114.        
115.         /*MPU6050寄存器初始化，需要对照MPU6050手册的寄存器描述配置，此处仅配置了部分重要的寄存器*/
116.         MPU6050_WriteReg(MPU6050_PWR_MGMT_1, 0x01);                                //电源管理寄存器1，取消睡眠模式，选择时钟源为X轴陀螺仪
117.         MPU6050_WriteReg(MPU6050_PWR_MGMT_2, 0x00);                                //电源管理寄存器2，保持默认值0，所有轴均不待机
118.         MPU6050_WriteReg(MPU6050_SMPLRT_DIV, 0x09);                                //采样率分频寄存器，配置采样率
119.         MPU6050_WriteReg(MPU6050_CONFIG, 0x06);                                        //配置寄存器，配置DLPF
120.         MPU6050_WriteReg(MPU6050_GYRO_CONFIG, 0x18);                        //陀螺仪配置寄存器，选择满量程为±2000°/s
121.         MPU6050_WriteReg(MPU6050_ACCEL_CONFIG, 0x18);                        //加速度计配置寄存器，选择满量程为±16g
122. }
125. /**
126.   * 函    数：MPU6050获取ID号
127.   * 参    数：无
128.   * 返 回 值：MPU6050的ID号
129.   */
130. uint8_t MPU6050_GetID(void)
131. {
132.         return MPU6050_ReadReg(MPU6050_WHO_AM_I);                //返回WHO_AM_I寄存器的值
133. }
135. /**
136.   * 函    数：MPU6050获取数据
137.   * 参    数：AccX AccY AccZ 加速度计X、Y、Z轴的数据，使用输出参数的形式返回，范围：-32768~32767
138.   * 参    数：GyroX GyroY GyroZ 陀螺仪X、Y、Z轴的数据，使用输出参数的形式返回，范围：-32768~32767
139.   * 返 回 值：无
140.   */
141. void MPU6050_GetData(int16_t *AccX, int16_t *AccY, int16_t *AccZ,
142.                                                 int16_t *GyroX, int16_t *GyroY, int16_t *GyroZ)
143. {
144.         uint8_t DataH, DataL;                                                                //定义数据高8位和低8位的变量
145.        
146.         DataH = MPU6050_ReadReg(MPU6050_ACCEL_XOUT_H);                //读取加速度计X轴的高8位数据
147.         DataL = MPU6050_ReadReg(MPU6050_ACCEL_XOUT_L);                //读取加速度计X轴的低8位数据
148.         *AccX = (DataH << 8) | DataL;                                                //数据拼接，通过输出参数返回
149.        
150.         DataH = MPU6050_ReadReg(MPU6050_ACCEL_YOUT_H);                //读取加速度计Y轴的高8位数据
151.         DataL = MPU6050_ReadReg(MPU6050_ACCEL_YOUT_L);                //读取加速度计Y轴的低8位数据
152.         *AccY = (DataH << 8) | DataL;                                                //数据拼接，通过输出参数返回
153.        
154.         DataH = MPU6050_ReadReg(MPU6050_ACCEL_ZOUT_H);                //读取加速度计Z轴的高8位数据
155.         DataL = MPU6050_ReadReg(MPU6050_ACCEL_ZOUT_L);                //读取加速度计Z轴的低8位数据
156.         *AccZ = (DataH << 8) | DataL;                                                //数据拼接，通过输出参数返回
157.        
158.         DataH = MPU6050_ReadReg(MPU6050_GYRO_XOUT_H);                //读取陀螺仪X轴的高8位数据
159.         DataL = MPU6050_ReadReg(MPU6050_GYRO_XOUT_L);                //读取陀螺仪X轴的低8位数据
160.         *GyroX = (DataH << 8) | DataL;                                                //数据拼接，通过输出参数返回
161.        
162.         DataH = MPU6050_ReadReg(MPU6050_GYRO_YOUT_H);                //读取陀螺仪Y轴的高8位数据
163.         DataL = MPU6050_ReadReg(MPU6050_GYRO_YOUT_L);                //读取陀螺仪Y轴的低8位数据
164.         *GyroY = (DataH << 8) | DataL;                                                //数据拼接，通过输出参数返回
165.        
166.         DataH = MPU6050_ReadReg(MPU6050_GYRO_ZOUT_H);                //读取陀螺仪Z轴的高8位数据
167.         DataL = MPU6050_ReadReg(MPU6050_GYRO_ZOUT_L);                //读取陀螺仪Z轴的低8位数据
168.         *GyroZ = (DataH << 8) | DataL;                                                //数据拼接，通过输出参数返回
169. }

复制代码

MPU6050.h

1. #ifndef __MPU6050_H
2. #define __MPU6050_H
4. void MPU6050_WriteReg(uint8_t RegAddress, uint8_t Data);
5. uint8_t MPU6050_ReadReg(uint8_t RegAddress);
7. void MPU6050_Init(void);
8. uint8_t MPU6050_GetID(void);
9. void MPU6050_GetData(int16_t *AccX, int16_t *AccY, int16_t *AccZ,
10.                                                 int16_t *GyroX, int16_t *GyroY, int16_t *GyroZ);
12. #endif

复制代码

MPU6050_reg.h

1. #ifndef __MPU6050_REG_H
2. #define __MPU6050_REG_H
4. #define        MPU6050_SMPLRT_DIV                0x19
5. #define        MPU6050_CONFIG                        0x1A
6. #define        MPU6050_GYRO_CONFIG                0x1B
7. #define        MPU6050_ACCEL_CONFIG        0x1C
9. #define        MPU6050_ACCEL_XOUT_H        0x3B
10. #define        MPU6050_ACCEL_XOUT_L        0x3C
11. #define        MPU6050_ACCEL_YOUT_H        0x3D
12. #define        MPU6050_ACCEL_YOUT_L        0x3E
13. #define        MPU6050_ACCEL_ZOUT_H        0x3F
14. #define        MPU6050_ACCEL_ZOUT_L        0x40
15. #define        MPU6050_TEMP_OUT_H                0x41
16. #define        MPU6050_TEMP_OUT_L                0x42
17. #define        MPU6050_GYRO_XOUT_H                0x43
18. #define        MPU6050_GYRO_XOUT_L                0x44
19. #define        MPU6050_GYRO_YOUT_H                0x45
20. #define        MPU6050_GYRO_YOUT_L                0x46
21. #define        MPU6050_GYRO_ZOUT_H                0x47
22. #define        MPU6050_GYRO_ZOUT_L                0x48
24. #define        MPU6050_PWR_MGMT_1                0x6B
25. #define        MPU6050_PWR_MGMT_2                0x6C
26. #define        MPU6050_WHO_AM_I                0x75
28. #endif

复制代码

main.c

1. #include "stm32f10x.h"                  // Device header
2. #include "Delay.h"
3. #include "OLED.h"
4. #include "MPU6050.h"
6. uint8_t ID;                                                                //定义用于存放ID号的变量
7. int16_t AX, AY, AZ, GX, GY, GZ;                        //定义用于存放各个数据的变量
9. int main(void)
10. {
11.         /*模块初始化*/
12.         OLED_Init();                //OLED初始化
13.         MPU6050_Init();                //MPU6050初始化
14.        
15.         /*显示ID号*/
16.         OLED_ShowString(1, 1, "ID:");                //显示静态字符串
17.         ID = MPU6050_GetID();                                //获取MPU6050的ID号
18.         OLED_ShowHexNum(1, 4, ID, 2);                //OLED显示ID号
19.        
20.         while (1)
21.         {
22.                 MPU6050_GetData(&AX, &AY, &AZ, &GX, &GY, &GZ);                //获取MPU6050的数据
23.                 OLED_ShowSignedNum(2, 1, AX, 5);                                        //OLED显示数据
24.                 OLED_ShowSignedNum(3, 1, AY, 5);
25.                 OLED_ShowSignedNum(4, 1, AZ, 5);
26.                 OLED_ShowSignedNum(2, 8, GX, 5);
27.                 OLED_ShowSignedNum(3, 8, GY, 5);
28.                 OLED_ShowSignedNum(4, 8, GZ, 5);
29.         }
30. }

复制代码

免责声明：如果侵犯了您的权益，请联系站长，我们会及时删除侵权内容，谢谢合作！更多信息从访问主页：qidao123.com:ToB企服之家，中国第一个企服评测及商务社交产业平台。