关于MPU6050读取传感器原始数据问题

liaohuguang

问题描述有点长，我已经献上我的所有币，希望能有大佬解决，谢谢
目的：使用中国移动的M5311的硬件I2C接口和MPU6050通信，将获得的运动数据发送到串口调试助手
问题：现在问题是：可以读出除了加速度数据寄存器（Accelerometer Measurements）和温度数据寄存器（Temperature Measurement）还有角速度数据寄存器（Gyroscope Measurements）之外的全部寄存器的数据，也就是说，除了这几个寄存器的数据不能通过I2C总线读取，其他的MPU6050寄存器都可以读取，当然也都可以写入，我使用能成功读取其他寄存器数据的函数去读这三个数据寄存器的值，得到的全都是0。下面是我的代码

1. #include"mpu6050.h"
   
2. 
   
3. 
   
4. 
   
5. //下面为移植程序，移植自正点原子的ATK-MPU6050资料
   
6. 
   
7. 
   
8. 
   
9. //从串口上传数据给匿名四轴上位机
   
10. void uart_niming_report(u8 fun, u8 *data, u8 len)
    
11. {
    
12.     u8 send_buf[32];
    
13.     u8 i;
    
14.     if(len>28) return;
    
15.     send_buf[len+3] = 0;
    
16.     send_buf[0] = 0x88;
    
17.     send_buf[1] = fun;
    
18.     send_buf[2] = len;
    
19.     for(i=0;i<len;i++) send_buf[3+i] = data[i];
    
20.     for(i=0;i<len+3;i++) send_buf[len+3] += send_buf[i];
    
21.     opencpu_uart_send(HAL_UART_1,send_buf,len+4);
    
22. }
    
23. 
    
24. //发送加速度和陀螺仪原始数据
    
25. void mpu6050_send_data(short aacx, short aacy, short aacz, short gyrox, short gyroy, short gyroz)
    
26. {
    
27.     u8 tbuf[12];
    
28.     tbuf[0] = (aacx>>8)&0xff;
    
29.     tbuf[1] = aacx&0xff;
    
30.     tbuf[2] = (aacy>>8)&0xff;
    
31.     tbuf[3] = aacy&0xff;
    
32.     tbuf[4] = (aacz>>8)&0xff;
    
33.     tbuf[5] = aacz&0xff;
    
34.     tbuf[6] = (gyrox>>8)&0xff;
    
35.     tbuf[7] = gyrox&0xff;
    
36.     tbuf[8] = (gyroy>>8)&0xff;
    
37.     tbuf[9] = gyroy&0xff;
    
38.     tbuf[10] = (gyroz>>8)&0xff;
    
39.     tbuf[11] = gyroz&0xff;
    
40.     // opencpu_printf(tbuf);
    
41.     uart_niming_report(0xa1,tbuf,12);
    
42. }
    
43. 
    
44. u8 mpu_init(void)
    
45. {
    
46.     u8 res, ack_flag, reg_flag;
    
47.     opencpu_i2c_init();
    
48.     opencpu_printf("1");
    
49.     opencpu_i2c_set_freq(HAL_I2C_FREQUENCY_50K);
    
50.     opencpu_printf("2");
    
51.     ack_flag = mpu_write_byte(MPU_PWR_MGMT1_REG,0x80);
    
52.     opencpu_printf("3");
    
53.     vTaskDelay(10);  
    
54.     reg_flag = mpu_read_byte(MPU_PWR_MGMT1_REG);
    
55.     opencpu_uart_send(HAL_UART_1, &#174;_flag, 1);
    
56.     opencpu_uart_send(HAL_UART_1,&ack_flag,1);
    
57.     ack_flag = mpu_write_byte(MPU_PWR_MGMT1_REG, 0x00);
    
58.     opencpu_uart_send(HAL_UART_1,&ack_flag,1);
    
59.     opencpu_printf("4");
    
60.     ack_flag = mpu_set_gyro_fsr(3);
    
61.     opencpu_uart_send(HAL_UART_1, &ack_flag, 1);
    
62.     opencpu_printf("5");
    
63.     mpu_set_accel_fsr(1);
    
64.     opencpu_printf("6");
    
65.     mpu_set_rate(50);
    
66.     opencpu_printf("7");
    
67.     mpu_write_byte(MPU_INT_EN_REG, 0x00);
    
68.     opencpu_printf("8");
    
69.     mpu_write_byte(MPU_USER_CTRL_REG, 0x00);
    
70.     opencpu_printf("9");
    
71.     mpu_write_byte(MPU_FIFO_EN_REG, 0x80);
    
72.     reg_flag = mpu_read_byte(MPU_FIFO_EN_REG);
    
73.     opencpu_uart_send(HAL_UART_1, &#174;_flag, 1);
    
74.     opencpu_printf("10");
    
75.     res = mpu_read_byte(MPU_DEVICE_ID_REG);
    
76.     opencpu_printf("11");
    
77.     if(res == MPU_ADDR)
    
78.     {
    
79.         opencpu_printf("12");
    
80.         opencpu_uart_send(HAL_UART_1, &res, 1);
    
81.         mpu_write_byte(MPU_PWR_MGMT1_REG, 0x01);
    
82.         reg_flag = mpu_read_byte(MPU_PWR_MGMT1_REG);
    
83.         opencpu_uart_send(HAL_UART_1, &#174;_flag, 1);
    
84.         mpu_write_byte(MPU_PWR_MGMT2_REG, 0x00);
    
85.         mpu_set_rate(50);
    
86.     }
    
87.     else return 1;
    
88.     return 0;
    
89. }
    
90. 
    
91. u8 mpu_write_byte(u8 reg,u8 data)
    
92. {
    
93.     // opencpu_i2c_init();
    
94.     // reg = (reg << 1)|0;
    
95.     u8 buf[2] = {reg,data};
    
96.     u8 ack_flag;
    
97.     ack_flag = opencpu_i2c_write(MPU_ADDR, buf, 2);
    
98.     return ack_flag;
    
99. 
    
100. //     int ack_flag;
     
101. //     if(ack_flag = opencpu_i2c_write(MPU_ADDR, &#174;, 1))
     
102. //     {
     
103. //         opencpu_i2c_deinit();
     
104. //         return 1;
     
105. //     }
     
106. //     opencpu
     
107. }
     
108. 
     
109. u8 mpu_read_byte(u8 reg)
     
110. {
     
111.     u8 res;
     
112.     opencpu_i2c_write_read(MPU_ADDR, reg, &res, 1);
     
113.     return res;
     
114. }
     
115. 
     
116. u8 mpu_read_len(u8 reg, u8 len, u8 *buf)
     
117. {
     
118.     u8 i;
     
119.     for(i=0;i<len;i++)
     
120.     {
     
121.         *(buf+i) = mpu_read_byte(reg+i);
     
122.     }
     
123.     return 0;
     
124. }
     
125. 
     
126. u8 mpu_write_len(u8 addr, u8 reg, u8 len, u8 *buf)
     
127. {
     
128.     u8 i;
     
129.     u8 ack_flag;
     
130.     u8 *new_buf;
     
131.     new_buf = (u8*)malloc(sizeof(u8)*(len+1));
     
132.     for(i=0; i<len; i++)
     
133.     {
     
134.         new_buf[len-i] = buf[len-1-i];
     
135.     }
     
136.     new_buf[0] = reg;
     
137.     ack_flag = opencpu_i2c_write(addr, new_buf, len+1);
     
138.     return ack_flag;
     
139. }
     
140. 
     
141. u8 mpu_get_accelerometer(short *ax, short *ay, short *az)
     
142. {
     
143.     u8 buf[6], res;
     
144.     res = mpu_read_len(MPU_ACCEL_XOUTH_REG, 6, buf);
     
145.     opencpu_printf("a");
     
146.     if(res==0)
     
147.     {
     
148.         opencpu_printf("b");
     
149.         *ax = ((u16_t)buf[0]<<8)|buf[1];
     
150.         *ay = ((u16_t)buf[2]<<8)|buf[3];
     
151.         *az = ((u16_t)buf[4]<<8)|buf[5];
     
152.         opencpu_uart_send(HAL_UART_1, ax, 2);
     
153.     }
     
154.     return res;
     
155. }
     
156. 
     
157. u8 mpu_get_gyroscope(short *gx,short *gy,short *gz)
     
158. {
     
159.     u8 buf[6],res;  
     
160.         res = mpu_read_len(MPU_GYRO_XOUTH_REG,6,buf);
     
161.     opencpu_printf("c");
     
162.         if(res==0)
     
163.         {
     
164.         opencpu_printf("d");
     
165.                 *gx=((u16_t)buf[0]<<8)|buf[1];  
     
166.                 *gy=((u16_t)buf[2]<<8)|buf[3];  
     
167.                 *gz=((u16_t)buf[4]<<8)|buf[5];
     
168.         opencpu_uart_send(HAL_UART_1, gx, 2);
     
169.         }        
     
170.     return res;
     
171. }
     
172. 
     
173. short mpu_get_temperature(void)
     
174. {
     
175.     u8 buf[2];
     
176.     short raw;
     
177.         float temp;
     
178.         mpu_read_len(MPU_TEMP_OUTH_REG,2,buf);
     
179.     raw=((u16_t)buf[0]<<8)|buf[1];  
     
180.     temp=36.53+((double)raw)/340;  
     
181.     return temp*100;
     
182. }
     
183. 
     
184. u8 mpu_set_lpf(u16_t lpf)
     
185. {
     
186.         u8 data=0;
     
187.         if(lpf>=188)data=1;
     
188.         else if(lpf>=98)data=2;
     
189.         else if(lpf>=42)data=3;
     
190.         else if(lpf>=20)data=4;
     
191.         else if(lpf>=10)data=5;
     
192.         else data=6;
     
193.         return mpu_write_byte(MPU_CFG_REG,data);//设置数字低通滤波器
     
194. }
     
195. 
     
196. u8 mpu_set_rate(u16_t rate)
     
197. {
     
198.         u8 data, reg_flag;
     
199.         if(rate>1000)rate=1000;
     
200.         if(rate<4)rate=4;
     
201.         data=1000/rate-1;
     
202.         data=mpu_write_byte(MPU_SAMPLE_RATE_REG,data);        //设置数字低通滤波器
     
203.     reg_flag = mpu_read_byte(MPU_SAMPLE_RATE_REG);
     
204.     opencpu_uart_send(HAL_UART_1, &#174;_flag, 1);
     
205.         return mpu_set_lpf(rate/2);        //自动设置lpf为采样率的一半
     
206. }
     
207. 
     
208. u8 mpu_set_accel_fsr(u8 fsr)
     
209. {
     
210.     u8 reg_flag;
     
211.         mpu_write_byte(MPU_ACCEL_CFG_REG,fsr<<3);//设置加速度传感器满量程范围
     
212.     reg_flag = mpu_read_byte(MPU_ACCEL_CFG_REG);
     
213.     opencpu_uart_send(HAL_UART_1, reg_flag, 1);
     
214.     return 0;
     
215. }
     
216. 
     
217. u8 mpu_set_gyro_fsr(u8 fsr)
     
218. {
     
219.     u8 reg_flag;
     
220.         mpu_write_byte(MPU_GYRO_CFG_REG,fsr<<3);//设置陀螺仪满量程范围
     
221.     reg_flag = mpu_read_byte(MPU_GYRO_CFG_REG);
     
222.     opencpu_uart_send(HAL_UART_1, &#174;_flag, 1);
     
223.     return 0;
     
224. }
     
225. 
     

复制代码

然后是我的main.c 函数

1. short aacx, aacy, aacz;
   
2.         short gyrox, gyroy, gyroz;
   
3.         short temp, init_flag;
   
4.         custom_uart_init();
   
5.         init_flag = mpu_init();
   
6.         opencpu_uart_send(HAL_UART_1, &init_flag, 1);
   
7.         opencpu_printf("4");
   
8.         while(1)
   
9.         {
   
10.                 opencpu_printf("5");
    
11.                 temp = mpu_read_byte(MPU_ACCEL_XOUTH_REG);
    
12.                 opencpu_uart_send(HAL_UART_1, &temp, 1);
    
13.                 temp = mpu_read_byte(MPU_ACCEL_XOUTL_REG);
    
14.                 opencpu_uart_send(HAL_UART_1, &temp, 1);
    
15.                 temp = mpu_read_byte(MPU_ACCEL_YOUTH_REG);
    
16.                 opencpu_uart_send(HAL_UART_1, &temp, 1);
    
17.                 temp = mpu_read_byte(MPU_ACCEL_YOUTL_REG);
    
18.                 opencpu_uart_send(HAL_UART_1, &temp, 1);
    
19.                 temp = mpu_read_byte(MPU_ACCEL_ZOUTH_REG);
    
20.                 opencpu_uart_send(HAL_UART_1, &temp, 1);
    
21.                 temp = mpu_read_byte(MPU_ACCEL_ZOUTL_REG);
    
22.                 opencpu_uart_send(HAL_UART_1, &temp, 1);
    
23.                 temp = mpu_read_byte(MPU_TEMP_OUTH_REG);
    
24.                 opencpu_uart_send(HAL_UART_1, &temp, 1);
    
25.                 temp = mpu_read_byte(MPU_TEMP_OUTL_REG);
    
26.                 opencpu_uart_send(HAL_UART_1, &temp, 1);
    
27.                 vTaskDelay(200);
    
28. }

复制代码

说明：上面的<opencpu_printf>函数和<opencpu_uart_send>函数都是通过串口向上位机传递数据，实际上是我通过串口数据调试我的程序，现在测试的结果如下

1. [17:22:46.386]收←◆31 32 33
   
2. [17:22:46.480]收←◆00 00 00 34 18 00 35 08 36 13 37 38 39 80 31 30 31 31 31 32 68 01 13 00 34 35 00 00 00 00 00 00 00 00

复制代码

上面的输出中31 32 33是调用<mpu_init>函数时opencpu_printf打印的；
然后延时了100ms   <vTaskDelay(10)>
接下来的00 00 00可以不用管，34是打印的"4"
18是调用了<mpu_set_gyro_fsr>时获取的陀螺仪设置寄存器的值，也就是如下所示

1. u8 mpu_set_gyro_fsr(u8 fsr)
   
2. {
   
3.     u8 reg_flag;
   
4.         mpu_write_byte(MPU_GYRO_CFG_REG,fsr<<3);//设置陀螺仪满量程范围
   
5.     reg_flag = mpu_read_byte(MPU_GYRO_CFG_REG);
   
6.     opencpu_uart_send(HAL_UART_1, &reg_flag, 1);
   
7.     return 0;
   
8. }
   

复制代码

通过<mpu_read_byte>读取陀螺仪设置寄存器获取它的值，可以打印出18，证明写入设置和读取是成功的
到这一步其实可以证明我的<mpu_read_byte>函数，和<mpu_write_byte>函数都是没有问题的，可以通过I2C写入和读取
但是

1. 34 35 00 00 00 00 00 00 00 00

复制代码

到最后这几位，就到了main函数，可以看出，串口先打印了“4”，“5”，然后通过<mpu_read_byte>获取加速度数据寄存器的值，发现全部都为0。
当然，在获取值的时候我在不停让传感器运动，但是输出的全都是00，没有任何变化。
如果我的<mpu_read_byte>可以读取其他寄存器的值，按理来说应该也可以读取加速度数据寄存器的值，但是读不出来，我也很困扰。
设置寄存器的初始化都是移植自正点原子的程序，应该没什么问题。先在不知道问题出在哪。如果能解决，十分感谢

正点原子

帮顶