arduino中用IIC读取MMA8452三轴加速度模块数据

1. http://www.geek-workshop.com/thread-898-1-1.html
   
2. /*
   
3. MMA8452Q Basic Example Code
   
4. Nathan Seidle
   
5. SparkFun Electronics
   
6. November 5, 2012
   
7. 
   
8. License: This code is public domain but you buy me a beer if you use this and we meet someday (Beerware license).
   
9. 
   
10. This example code shows how to read the X/Y/Z accelerations and basic functions of the MMA5842. It leaves out
    
11. all the neat features this IC is capable of (tap, orientation, and inerrupts) and just displays X/Y/Z. See
    
12. the advanced example code to see more features.
    
13. 
    
14. Hardware setup:
    
15. MMA8452 Breakout ------------ Arduino
    
16. 3.3V --------------------- 3.3V
    
17. SDA -------^^(330)^^------- A4
    
18. SCL -------^^(330)^^------- A5
    
19. GND ---------------------- GND
    
20. 
    
21. The MMA8452 is 3.3V so we recommend using 330 or 1k resistors between a 5V Arduino and the MMA8452 breakout.
    
22. 
    
23. The MMA8452 has built in pull-up resistors for I2C so you do not need additional pull-ups.
    
24. */
    
25. 
    
26. #include <Wire.h> // Used for I2C
    
27. 
    
28. // The SparkFun breakout board defaults to 1, set to 0 if SA0 jumper on the bottom of the board is set
    
29. #define MMA8452_ADDRESS 0x1D  // 0x1D if SA0 is high, 0x1C if low
    
30. 
    
31. //Define a few of the registers that we will be accessing on the MMA8452
    
32. #define OUT_X_MSB 0x01
    
33. #define XYZ_DATA_CFG  0x0E
    
34. #define WHO_AM_I   0x0D
    
35. #define CTRL_REG1  0x2A
    
36. 
    
37. #define GSCALE 2 // Sets full-scale range to +/-2, 4, or 8g. Used to calc real g values.
    
38. 
    
39. void setup()
    
40. {
    
41.   Serial.begin(9600);
    
42.   Serial.println("MMA8452 Basic Example");
    
43. 
    
44.   Wire.begin(); //Join the bus as a master
    
45. 
    
46.   initMMA8452(); //Test and intialize the MMA8452
    
47. }
    
48. 
    
49. void loop()
    
50. {  
    
51.   int accelCount[3];  // Stores the 12-bit signed value
    
52.   readAccelData(accelCount);  // Read the x/y/z adc values
    
53. 
    
54.   // Now we'll calculate the accleration value into actual g's
    
55.   float accelG[3];  // Stores the real accel value in g's
    
56.   for (int i = 0 ; i < 3 ; i++)
    
57.   {
    
58.     accelG[i] = (float) accelCount[i] / ((1<<12)/(2*GSCALE));  // get actual g value, this depends on scale being set
    
59.   }
    
60. 
    
61.   // Print out values
    
62.   for (int i = 0 ; i < 3 ; i++)
    
63.   {
    
64.     Serial.print(accelG[i], 4);  // Print g values
    
65.     Serial.print("\t");  // tabs in between axes
    
66.   }
    
67.   Serial.println();
    
68. 
    
69.   delay(10);  // Delay here for visibility
    
70. }
    
71. 
    
72. void readAccelData(int *destination)
    
73. {
    
74.   byte rawData[6];  // x/y/z accel register data stored here
    
75. 
    
76.   readRegisters(OUT_X_MSB, 6, rawData);  // Read the six raw data registers into data array
    
77. 
    
78.   // Loop to calculate 12-bit ADC and g value for each axis
    
79.   for(int i = 0; i < 3 ; i++)
    
80.   {
    
81.     int gCount = (rawData[i*2] << 8) | rawData[(i*2)+1];  //Combine the two 8 bit registers into one 12-bit number
    
82.     gCount >>= 4; //The registers are left align, here we right align the 12-bit integer
    
83. 
    
84.     // If the number is negative, we have to make it so manually (no 12-bit data type)
    
85.     if (rawData[i*2] > 0x7F)
    
86.     {  
    
87.       gCount = ~gCount + 1;
    
88.       gCount *= -1;  // Transform into negative 2's complement #
    
89.     }
    
90. 
    
91.     destination[i] = gCount; //Record this gCount into the 3 int array
    
92.   }
    
93. }
    
94. 
    
95. // Initialize the MMA8452 registers
    
96. // See the many application notes for more info on setting all of these registers:
    
97. // http://www.freescale.com/webapp/sps/site/prod_summary.jsp?code=MMA8452Q
    
98. void initMMA8452()
    
99. {
    
100.   byte c = readRegister(WHO_AM_I);  // Read WHO_AM_I register
     
101.   if (c == 0x2A) // WHO_AM_I should always be 0x2A
     
102.   {  
     
103.     Serial.println("MMA8452Q is online...");
     
104.   }
     
105.   else
     
106.   {
     
107.     Serial.print("Could not connect to MMA8452Q: 0x");
     
108.     Serial.println(c, HEX);
     
109.     while(1) ; // Loop forever if communication doesn't happen
     
110.   }
     
111. 
     
112.   MMA8452Standby();  // Must be in standby to change registers
     
113. 
     
114.   // Set up the full scale range to 2, 4, or 8g.
     
115.   byte fsr = GSCALE;
     
116.   if(fsr > 8) fsr = 8; //Easy error check
     
117.   fsr >>= 2; // Neat trick, see page 22. 00 = 2G, 01 = 4A, 10 = 8G
     
118.   writeRegister(XYZ_DATA_CFG, fsr);
     
119. 
     
120.   //The default data rate is 800Hz and we don't modify it in this example code
     
121. 
     
122.   MMA8452Active();  // Set to active to start reading
     
123. }
     
124. 
     
125. // Sets the MMA8452 to standby mode. It must be in standby to change most register settings
     
126. void MMA8452Standby()
     
127. {
     
128.   byte c = readRegister(CTRL_REG1);
     
129.   writeRegister(CTRL_REG1, c & ~(0x01)); //Clear the active bit to go into standby
     
130. }
     
131. 
     
132. // Sets the MMA8452 to active mode. Needs to be in this mode to output data
     
133. void MMA8452Active()
     
134. {
     
135.   byte c = readRegister(CTRL_REG1);
     
136.   writeRegister(CTRL_REG1, c | 0x01); //Set the active bit to begin detection
     
137. }
     
138. 
     
139. // Read bytesToRead sequentially, starting at addressToRead into the dest byte array
     
140. void readRegisters(byte addressToRead, int bytesToRead, byte * dest)
     
141. {
     
142.   Wire.beginTransmission(MMA8452_ADDRESS);
     
143.   Wire.write(addressToRead);
     
144.   Wire.endTransmission(false); //endTransmission but keep the connection active
     
145. 
     
146.   Wire.requestFrom(MMA8452_ADDRESS, bytesToRead); //Ask for bytes, once done, bus is released by default
     
147. 
     
148.   while(Wire.available() < bytesToRead); //Hang out until we get the # of bytes we expect
     
149. 
     
150.   for(int x = 0 ; x < bytesToRead ; x++)
     
151.     dest[x] = Wire.read();   
     
152. }
     
153. 
     
154. // Read a single byte from addressToRead and return it as a byte
     
155. byte readRegister(byte addressToRead)
     
156. {
     
157.   Wire.beginTransmission(MMA8452_ADDRESS);
     
158.   Wire.write(addressToRead);
     
159.   Wire.endTransmission(false); //endTransmission but keep the connection active
     
160. 
     
161.   Wire.requestFrom(MMA8452_ADDRESS, 1); //Ask for 1 byte, once done, bus is released by default
     
162. 
     
163.   while(!Wire.available()) ; //Wait for the data to come back
     
164.   return Wire.read(); //Return this one byte
     
165. }
     
166. 
     
167. // Writes a single byte (dataToWrite) into addressToWrite
     
168. void writeRegister(byte addressToWrite, byte dataToWrite)
     
169. {
     
170.   Wire.beginTransmission(MMA8452_ADDRESS);
     
171.   Wire.write(addressToWrite);
     
172.   Wire.write(dataToWrite);
     
173.   Wire.endTransmission(); //Stop transmitting
     
174. }