【DFR0004/RoMeo控制器试用】KX224 加速度传感器 I2C 测试

andeyqi

RoMeo 开发板上是支持I2C 功能的，原理图上有三个I2C外设接口，手头正好I2C 接口的KX224 加速度传感器，接上去验证下I2C 功能。

关于RoMeo 开发板的I2C 接口使用说明可以参照如下链接说明在此就不做介绍了，接口封装的还是比较简洁的，了解I2C协议应该就理解起来也比较容易。

https://wiki.dfrobot.com.cn/_SKU_DFR0004_RoMeo%E6%8E%A7%E5%88%B6%E5%99%A8V1.0_%E5%85%BC%E5%AE%B9Arduino

以下是代码是实现初始化的时候设置加速度传感器的配置寄存器之后每500ms去赌气寄存器信息。

1. /*
   
2.   DigitalReadSerial
   
3. 
   
4.   Reads a digital input on pin 2, prints the result to the Serial Monitor
   
5. 
   
6.   This example code is in the public domain.
   
7. 
   
8.   https://www.arduino.cc/en/Tutorial/BuiltInExamples/DigitalReadSerial
   
9. */
   
10. #include <Wire.h>
    
11. 
    
12. #define KX224_DEVICE_ADDRESS_1E   (0x1E)    // 7bit Addrss
    
13. #define KX224_DEVICE_ADDRESS_1F   (0x1F)    // 7bit Address
    
14. #define KX224_WAI_VAL             (0x2B)
    
15. 
    
16. #define KX224_XOUT_L              (0x06)
    
17. #define KX224_WHO_AM_I            (0x0F)
    
18. #define KX224_CNTL1               (0x18)
    
19. #define KX224_ODCNTL              (0x1B)
    
20. 
    
21. #define KX224_CNTL1_TPE           (1 << 0)
    
22. #define KX224_CNTL1_WUFE          (1 << 1)
    
23. #define KX224_CNTL1_TDTE          (1 << 2)
    
24. #define KX224_CNTL1_GSELMASK      (0x18)
    
25. #define KX224_CNTL1_GSEL_8G       (0x00)
    
26. #define KX224_CNTL1_GSEL_16G      (0x08)
    
27. #define KX224_CNTL1_GSEL_32G      (0x10)
    
28. #define KX224_CNTL1_DRDYE         (1 << 5)
    
29. #define KX224_CNTL1_RES           (1 << 6)
    
30. #define KX224_CNTL1_PC1           (1 << 7)
    
31. 
    
32. #define KX224_ODCNTL_OSA_50HZ     (2)
    
33. #define KX224_ODCNTL_LPRO         (1 << 6)
    
34. #define KX224_IIR_BYPASS          (1 << 7)
    
35. 
    
36. #define KX224_CNTL1_VAL           (KX224_CNTL1_RES | KX224_CNTL1_GSEL_8G)
    
37. #define KX224_ODCNTL_VAL          (KX224_ODCNTL_OSA_50HZ)
    
38. 
    
39. unsigned short _g_sens = 4096;
    
40. 
    
41. 
    
42. 
    
43. byte kx224_read(unsigned char memory_address, unsigned char *data, int size)
    
44. {
    
45.   byte rc;
    
46.   unsigned char cnt;
    
47. 
    
48.   Wire.beginTransmission(KX224_DEVICE_ADDRESS_1E);
    
49.   Wire.write(memory_address);
    
50.   rc = Wire.endTransmission(false);
    
51.   if (rc != 0) {
    
52.     return (rc);
    
53.   }
    
54. 
    
55.   Wire.requestFrom(KX224_DEVICE_ADDRESS_1E, size, true);
    
56.   cnt = 0;
    
57.   while(Wire.available()) {
    
58.     data[cnt] = Wire.read();
    
59.     cnt++;
    
60.   }
    
61. 
    
62.   return (0);
    
63. }
    
64. 
    
65. byte kx224_write(unsigned char memory_address, unsigned char *data, unsigned char size)
    
66. {
    
67.   byte rc;
    
68. 
    
69.   Wire.beginTransmission(KX224_DEVICE_ADDRESS_1E);
    
70.   Wire.write(memory_address);
    
71.   Wire.write(data, size);
    
72.   rc = Wire.endTransmission(true);
    
73.   return (rc);
    
74. }
    
75. 
    
76. byte kx224_get_rawval(unsigned char *data)
    
77. {
    
78.   byte rc;
    
79. 
    
80.   rc = kx224_read(KX224_XOUT_L, data, 6);
    
81.   if (rc != 0) {
    
82.     Serial.println(F("Can't get KX224 accel value"));
    
83.   }
    
84. 
    
85.   return (rc);
    
86. }
    
87. 
    
88. byte kx224_get_val(float *data)
    
89. {
    
90.   byte rc;
    
91.   unsigned char val[6];
    
92.   signed short acc[3];
    
93. 
    
94.   rc = kx224_get_rawval(val);
    
95.   if (rc != 0) {
    
96.     return (rc);
    
97.   }
    
98. 
    
99.   acc[0] = ((signed short)val[1] << 8) | (val[0]);
    
100.   acc[1] = ((signed short)val[3] << 8) | (val[2]);
     
101.   acc[2] = ((signed short)val[5] << 8) | (val[4]);
     
102. 
     
103.   // Convert LSB to g
     
104.   data[0] = (float)acc[0] / _g_sens;
     
105.   data[1] = (float)acc[1] / _g_sens;
     
106.   data[2] = (float)acc[2] / _g_sens;
     
107. 
     
108.   return (rc);  
     
109. }
     
110. 
     
111. 
     
112. // the setup routine runs once when you press reset:
     
113. void setup() {
     
114.   unsigned char reg = 0;
     
115.   unsigned char rc = 0;
     
116.   unsigned char gsel;
     
117. 
     
118.   // initialize serial communication at 9600 bits per second:
     
119.   Serial.begin(115200);
     
120.   Wire.begin();
     
121.   rc = kx224_read(KX224_WHO_AM_I, ?, sizeof(reg));
     
122.   if (rc != 0) {
     
123.     Serial.println(F("Can't access KX224"));
     
124.     Serial.println(rc);
     
125.   }
     
126.   Serial.print(F("KX224_WHO_AMI Register Value = 0x"));
     
127.   Serial.println(reg, HEX);
     
128. 
     
129.   if (reg != KX224_WAI_VAL) {
     
130.     Serial.println(F("Can't find KX224"));
     
131.     return;
     
132.   }
     
133. 
     
134.   reg = KX224_ODCNTL_VAL;
     
135.   rc = kx224_write(KX224_ODCNTL, ?, sizeof(reg));
     
136.   if (rc != 0) {
     
137.     Serial.println("Can't write KX224 ODCNTL register");
     
138.     return;
     
139.   }
     
140. 
     
141.   rc = kx224_read(KX224_CNTL1, ?, sizeof(reg));
     
142.   if (rc != 0) {
     
143.     Serial.println(F("Can't read KX224 CNTL1 register"));
     
144.     return;
     
145.   }
     
146. 
     
147.   gsel = reg & KX224_CNTL1_GSELMASK;
     
148. 
     
149.   reg |= KX224_CNTL1_PC1;
     
150.   rc = kx224_write(KX224_CNTL1, ?, sizeof(reg));
     
151.   if (rc != 0) {
     
152.     Serial.println(F("Can't write KX224 CNTL1 register at second"));
     
153.     return;
     
154.   }
     
155.   switch(gsel) {
     
156.     case KX224_CNTL1_GSEL_8G :
     
157.       // (Equivalent counts) / (Range) = (32768 / 8)
     
158.       _g_sens = 4096;
     
159.     break;
     
160. 
     
161.     case KX224_CNTL1_GSEL_16G :
     
162.       // (Equivalent counts) / (Range) = (32768 / 16)
     
163.       _g_sens = 2048;
     
164.     break;
     
165. 
     
166.     case KX224_CNTL1_GSEL_32G :
     
167.       // (Equivalent counts) / (Range) = (32768 / 32)
     
168.       _g_sens = 1024;
     
169.     break;
     
170. 
     
171.     default:
     
172.     break;
     
173.   }
     
174. }
     
175. 
     
176. // the loop routine runs over and over again forever:
     
177. void loop() {
     
178.   byte rc;
     
179.   float acc[3];
     
180. 
     
181.   rc = kx224_get_val(acc);
     
182.   if (rc == 0) {
     
183.     Serial.write("KX224 (X) = ");
     
184.     Serial.print(acc[0]);
     
185.     Serial.println(" [g]");
     
186.     Serial.write("KX224 (Y) = ");
     
187.     Serial.print(acc[1]);
     
188.     Serial.println(" [g]");
     
189.     Serial.write("KX224 (Z) = ");
     
190.     Serial.print(acc[2]);
     
191.     Serial.println(" [g]");
     
192.     Serial.println();
     
193.   }
     
194. 
     
195.   delay(500);
     
196. }
     

复制代码

以下是测试数据翻转传感器可以读取到传感器的信息根据状态在变化。

==================资料分割线==================

KX224-1053-Specifications-Rev-2.0.pdf (2.47 MB, 下载次数: 1)

2022-10-3 14:54 上传

点击文件名下载附件

RoMeo V1.1 sch.pdf (72.54 KB, 下载次数: 1)

2022-10-3 15:06 上传

点击文件名下载附件

dfrobot_duino_driver.zip (633.88 KB, 下载次数: 1)

2022-10-3 15:06 上传

点击文件名下载附件