main.cpp

00001 #include "mbed.h"
00002 
00003 /*
00004 *************************************************************************************************
00005 MMA7455. Simple test for I2C interface and 10-bit 8g mode . 2g, 4g, 8g, digital triple axis accelerometer
00006 with I2C/SPI interface.
00007 
00008 In Level Detection Mode and pulse detection mode, dynamic range is set automatically to 8g.
00009 Read or Write Low Byte first.
00010 
00011 Wiring:
00012 pin 2, pin 3, pin 5, IADDR0(pin 4), pin 10 and pin 11 tied to ground.
00013 DVdd(pin 1),AVdd(pin 6) and CS(pin 7) tied to 3.3V.
00014 INT1(p8) to mBed's p15(INT1 is not used in this program). INT2(p9) to mBed's p16.
00015 
00016 Author: Lluis Nadal. August 2011.
00017 *************************************************************************************************
00018 */
00019 
00020 I2C i2c(p9, p10); // SDA(p13), SCL(p14). 4.7k pull-up resistors.
00021 
00022 //pin 4 (IADDR0) tied to ground.
00023 const int addr_R = 0x3B; // Address to read:  111011
00024 const int addr_W = 0x3A; // Address to write: 111010
00025 
00026 Serial pc(USBTX, USBRX);
00027 
00028 DigitalOut led1(LED1), led2(LED2), led3(LED3), led4(LED4);
00029 InterruptIn int1(p15); //
00030 InterruptIn int2(p16); //
00031 
00032 int offset[3];
00033 int v[6];
00034 int a;
00035 char msb, lsb;
00036 
00037 
00038 
00039 
00040 void read_8(int n) { // Read 8-bit register
00041     i2c.start();
00042     v[0]=i2c.write(addr_W);
00043     v[1]=i2c.write(n);
00044     i2c.start();
00045     v[2] = i2c.write(addr_R);
00046     v[3]=i2c.read(0);
00047     i2c.stop();
00048 //ACK = v[0]= v[1]= v[2]= 1; NACK = 0. v[3] = value.
00049     pc.printf(" (v[0],v[1],v[2],v[3]) = (%d, %d, %d, %d)\r\n\r\n", v[0],v[1],v[2],v[3]);
00050 }
00051 
00052 
00053 void read(int n) { // Read 10-bit registers n and n+1
00054     i2c.start();
00055     i2c.write(addr_W);
00056     i2c.write(n); // Starting register(L)
00057     i2c.start();
00058     i2c.write(addr_R);
00059     lsb = i2c.read(0);
00060     i2c.stop();
00061 
00062     i2c.start();
00063     i2c.write(addr_W);
00064     i2c.write(n+1); // Next register(H)
00065     i2c.start();
00066     i2c.write(addr_R);
00067     msb = i2c.read(0);
00068     i2c.stop();
00069     pc.printf(" (msb, lsb): (%d, %d)\r\n", msb, lsb);
00070     pc.printf("\r\n");
00071     a = (int)msb;
00072     a = (a << 8) | lsb;
00073     if ((msb >> 1) == 1) a = a -1024; // If negative
00074     pc.printf(" a = %d\r\n\r\n", a);
00075 }
00076 
00077 
00078 void write_8(int reg, int data) { // Write 8-bit data to register
00079     i2c.start();
00080     v[0]=i2c.write(addr_W);
00081     v[1]=i2c.write(reg);
00082     v[2] = i2c.write(data);
00083     i2c.stop();
00084 //ACK = v[0]= v[1]= v[2] = 1; NACK = 0.
00085     // pc.printf(" (v[0],v[1],v[2]) = (%d, %d, %d)\r\n", v[0],v[1],v[2]);
00086     // pc.printf("\r\n");
00087 }
00088 
00089 void write_offset(int reg, int data) { // Write 11-bit data to offset registers L and H
00090     char H, L;
00091     i2c.start();
00092     i2c.write(addr_W);
00093     i2c.write(reg); // Starting register(L)
00094     if (data < 0) data = 2048 + data ; // If negative
00095     pc.printf(" data = %d\r\n", data);
00096     H = (char) ((data & 0xFF00) >> 8);
00097     L = (char) (data & 0x00FF);
00098     i2c.write(L);
00099     i2c.stop();
00100     i2c.start();
00101     i2c.write(addr_W);
00102     i2c.write(reg+1); // Next register(H)
00103     i2c.write(H);
00104     i2c.stop();
00105     pc.printf(" (H, L) = (%d, %d )\r\n\r\n", H, L);
00106 }
00107 
00108 
00109 
00110 
00111 void clr_int() {   // Clear interrupt latch
00112     write_8(0x17, 0x03);
00113     write_8(0x17, 0x00); // Default option
00114 }
00115 
00116 void flash() {
00117     led4 = 0;
00118     pc.printf("Pulse detected!\r\n");
00119     led4 = 1;
00120     wait(1);
00121     led4 = 0;
00122     clr_int(); // Clear interrupt latch
00123 }
00124 
00125 
00126 
00127 
00128 int main() {
00129 
00130     i2c.frequency(100000);
00131 
00132     led1 = 0, led2 = 0, led3 = 0, led4 = 0;
00133     wait(2);
00134 
00135 // Read some 8-bit registers
00136     pc.printf(" Read some registers: \r\n\r\n");
00137 
00138 
00139     pc.printf(" WHOAMI register: ");
00140     read_8(0x0F); // WHOAMI
00141 
00142     pc.printf(" I2C ADDRESS: ");
00143     read_8(0x0D); // I2C ADDRESS
00144 
00145     pc.printf(" MODE CONTROL register: ");
00146     read_8(0x16); // Mode control register
00147 
00148 
00149     // 0x16: Mode[1:0] Control Register:
00150     // 00: Standby Mode
00151     // 01: Measurement Mode
00152     // 10: Level Detection Mode
00153     // 11: Pulse Detection Mode
00154 
00155     // 0x16: GLV[1:0] Control Register:
00156     // 00: 8g
00157     // 10: 4g
00158     // 01: 2g
00159 
00160     pc.printf( "Write to MODE CONTROL register 0x16\r\n\r\n");
00161     // Write: DRPD = 1, GLVL = 00(8g), MODE: 01(Measurement).
00162     write_8(0x16, 0x41);
00163     clr_int(); // Clear interrupt latch
00164 
00165     pc.printf(" MODE CONTROL register updated: ");
00166     read_8(0x16); // MODE CONTROL register is updated
00167 
00168     pc.printf(" Interrupt latch register: ");
00169     read_8(0x17); // Interrupt latch register
00170 
00171     pc.printf(" Status: ");
00172     read_8(0x09); // Status
00173 
00174 // Clear offset registers: 11-bit
00175     pc.printf(" Clear offset registers\r\n\r\n");
00176     write_offset(0x10, 0); // Offset x
00177     write_offset(0x12, 0); // Offset y
00178     write_offset(0x14, 0); // Offset z
00179     wait(0.1);
00180 
00181     // Start autocalibration. Lay device down horizontal and do not move
00182     // Average 4 readings
00183     // Offsets must be multiplied by 2
00184     pc.printf(" Autocalibration: lay device down horizontal and do not move\r\n\r\n");
00185     led1 = 1; // Start autocalibration in 4 seconds
00186     wait(4);
00187     offset[0] = 0, offset[1] = 0, offset[2] = 0;
00188 
00189     for (int i = 0; i < 4; i++) {
00190 
00191         pc.printf(" x: \r\n");
00192         read(0x00);
00193         offset[0] = offset[0]-a;
00194 
00195         pc.printf( "y: \r\n");
00196         read(0x02);
00197         offset[1] = offset[1]-a ;
00198 
00199         pc.printf(" z: \r\n");
00200         read(0x04);
00201         offset[2] = offset[2]-a;
00202         wait(0.2);
00203     }
00204 
00205     led2 = 1; // End autocalibration
00206 
00207     // Offsets must be multiplied by 2 and divided by 4 to calculate the average
00208     offset[0] = offset[0]/2;
00209     offset[1] = offset[1]/2;
00210     offset[2] = offset[2]/2 + 2*64; //Z axis output for 1g must be 64 in 10-bit mode
00211 
00212 
00213     // Write offset registers (11-bit). Offset registers are volatile and are cleared on  power off.
00214     pc.printf(" Write offset registers\r\n\r\n");
00215     write_offset(0x10, offset[0]); // Offset x
00216     write_offset(0x12, offset[1]); // Offset y
00217     write_offset(0x14, offset[2]); // Offset z
00218     wait(0.1);
00219 
00220 
00221 // Read x, y, z with offset correction
00222     pc.printf(" Read x, y, z with offset correction\r\n\r\n");
00223     pc.printf(" x corrected: \r\n");
00224     read(0x00);
00225     pc.printf( "y corrected: \r\n");
00226     read(0x02);
00227     pc.printf(" z corrected: \r\n");
00228     read(0x04);
00229     wait(0.1);
00230 
00231 // Single pulse detection
00232     write_8(0x16, 0x43); // DRPD = 1; GLV = 00(8g), MODE: 11(pulse detection).
00233     write_8(0x19, 0x00);
00234     write_8(0x18, 0x00); // Int2 for pulse detection
00235     write_8(0x1B, 0x20); // Unsigned 7-bit Pulse Treshold set to 2g.
00236     write_8(0x1C, 0x10); // Pulse duration set to 8 ms
00237     int2.rise(&flash); // Attach flash function to int2
00238     pc.printf(" Start pulse detection\r\n\r\n");
00239     led3 = 1; // Start pulse detection
00240 
00241     while (1) {
00242     }
00243 }