代码:

1. init(void)
   
2. {
   
3.   byte rc;
   
4.   unsigned char reg;
   
5.   unsigned char gsel;
   
6. 
   
7.   rc = read(KX224_WHO_AM_I, ®, sizeof(reg));
   
8.   if (rc != 0) {
   
9.     Serial.println(F("Can't access KX224"));
   
10.     return (rc);
    
11.   }
    
12.   Serial.print(F("KX224_WHO_AMI Register Value = 0x"));
    
13.   Serial.println(reg, HEX);
    
14.   
    
15.   if (reg != KX224_WAI_VAL) {
    
16.     Serial.println(F("Can't find KX224"));
    
17.     return (rc);
    
18.   }
    
19. 
    
20.   reg = KX224_CNTL1_VAL;
    
21.   rc = write(KX224_CNTL1, ®, sizeof(reg));
    
22.   if (rc != 0) {
    
23.     Serial.println("Can't write KX224 CNTL1 register at first");
    
24.     return (rc);
    
25.   }
    
26. 
    
27.   reg = KX224_ODCNTL_VAL;
    
28.   rc = write(KX224_ODCNTL, ®, sizeof(reg));
    
29.   if (rc != 0) {
    
30.     Serial.println("Can't write KX224 ODCNTL register");
    
31.     return (rc);
    
32.   }
    
33. 
    
34.   rc = read(KX224_CNTL1, ®, sizeof(reg));
    
35.   if (rc != 0) {
    
36.     Serial.println(F("Can't read KX224 CNTL1 register"));
    
37.     return (rc);
    
38.   }
    
39.   gsel = reg & KX224_CNTL1_GSELMASK;
    
40. 
    
41.   reg |= KX224_CNTL1_PC1;
    
42.   rc = write(KX224_CNTL1, ®, sizeof(reg));
    
43.   if (rc != 0) {
    
44.     Serial.println(F("Can't write KX224 CNTL1 register at second"));
    
45.     return (rc);
    
46.   }
    
47.   
    
48.   switch(gsel) {
    
49.     case KX224_CNTL1_GSEL_8G :
    
50.       // (Equivalent counts) / (Range) = (32768 / 8)
    
51.       _g_sens = 4096;
    
52.     break;
    
53. 
    
54.     case KX224_CNTL1_GSEL_16G :
    
55.       // (Equivalent counts) / (Range) = (32768 / 16)
    
56.       _g_sens = 2048;
    
57.     break;
    
58. 
    
59.     case KX224_CNTL1_GSEL_32G :
    
60.       // (Equivalent counts) / (Range) = (32768 / 32)
    
61.       _g_sens = 1024;
    
62.     break;
    
63. 
    
64.     default:
    
65.     break;
    
66.   }
    
67.   return (rc);
    
68. }

代码:

1. byte KX224::get_rawval(unsigned char *data)
   
2. {
   
3.   byte rc;
   
4. 
   
5.   rc = read(KX224_XOUT_L, data, 6);
   
6.   if (rc != 0) {
   
7.     Serial.println(F("Can't get KX224 accel value"));
   
8.   }
   
9. 
   
10.   return (rc);
    
11. }
    
12. 
    
13. byte KX224::get_val(float *data)
    
14. {
    
15.   byte rc;
    
16.   unsigned char val[6];
    
17.   signed short acc[3];
    
18. 
    
19.   rc = get_rawval(val);
    
20.   if (rc != 0) {
    
21.     return (rc);
    
22.   }
    
23. 
    
24.   acc[0] = ((signed short)val[1] << 8) | (val[0]);
    
25.   acc[1] = ((signed short)val[3] << 8) | (val[2]);
    
26.   acc[2] = ((signed short)val[5] << 8) | (val[4]);
    
27. 
    
28.   // Convert LSB to g
    
29.   data[0] = (float)acc[0] / _g_sens;
    
30.   data[1] = (float)acc[1] / _g_sens;
    
31.   data[2] = (float)acc[2] / _g_sens;
    
32. 
    
33.   return (rc);  
    
34. }