Ashley Mills / Mbed 2 deprecated MMA8452_Test

A test program for the MMA8452 accelerometer

Dependencies:   MMA8452 mbed

The test program runs a bunch of tests for the MMA8452 accelerometer.

What is below is not the test program, but an example to whet your appetite about the library.

#include "mbed.h"
#include "MMA8452.h"

int main() {
   Serial pc(USBTX,USBRX);
   pc.baud(115200);
   double x = 0, y = 0, z = 0;

   MMA8452 acc(p28, p27, 40000);
   acc.setBitDepth(MMA8452::BIT_DEPTH_12);
   acc.setDynamicRange(MMA8452::DYNAMIC_RANGE_4G);
   acc.setDataRate(MMA8452::RATE_100);
   
   while(1) {
      if(!acc.isXYZReady()) {
         wait(0.01);
         continue;
      }
      acc.readXYZGravity(&x,&y,&z);
      pc.printf("Gravities: %lf %lf %lf\r\n",x,y,z);
   }
}

An easy way to test that this actually works is to run the loop above and hold the MMA8452 parallel to the ground along the respective axis (and upsidedown in each axis). You will see 1G on the respective axis and 0G on the others.

main.cpp@5:756f9b157319, 2014-03-06 (annotated)

Committer:
ashleymills
Date:
Thu Mar 06 18:07:58 2014 +0000
Revision:
5:756f9b157319
Parent:
3:2a8e59a590db
Child:
6:e3100f66ed6a
Adding independent query tests

Who changed what in which revision?

UserRevisionLine numberNew contents of line
ashleymills 0:0c17274c3b7c 1 #include "mbed.h"
ashleymills 0:0c17274c3b7c 2 #include "MMA8452.h"
ashleymills 0:0c17274c3b7c 3
ashleymills 0:0c17274c3b7c 4 DigitalOut myled(LED1);
ashleymills 0:0c17274c3b7c 5
ashleymills 0:0c17274c3b7c 6 Serial pc(USBTX,USBRX);
ashleymills 0:0c17274c3b7c 7
ashleymills 0:0c17274c3b7c 8 #define LOG(...) pc.printf(__VA_ARGS__); pc.printf("\r\n");
ashleymills 0:0c17274c3b7c 9 #define LOGX(...) pc.printf(__VA_ARGS__);
ashleymills 0:0c17274c3b7c 10
ashleymills 0:0c17274c3b7c 11 void printByte(char b) {
ashleymills 0:0c17274c3b7c 12 LOG("%d%d%d%d%d%d%d%d",
ashleymills 0:0c17274c3b7c 13 (b&0x80)>>7,
ashleymills 0:0c17274c3b7c 14 (b&0x40)>>6,
ashleymills 0:0c17274c3b7c 15 (b&0x20)>>5,
ashleymills 0:0c17274c3b7c 16 (b&0x10)>>4,
ashleymills 0:0c17274c3b7c 17 (b&0x08)>>3,
ashleymills 0:0c17274c3b7c 18 (b&0x04)>>2,
ashleymills 0:0c17274c3b7c 19 (b&0x02)>>1,
ashleymills 0:0c17274c3b7c 20 (b&0x01)
ashleymills 0:0c17274c3b7c 21 );
ashleymills 0:0c17274c3b7c 22 }
ashleymills 0:0c17274c3b7c 23
ashleymills 5:756f9b157319 24 enum SampleType {
ashleymills 5:756f9b157319 25 SAMPLE_RAW=0,
ashleymills 5:756f9b157319 26 SAMPLE_COUNT,
ashleymills 5:756f9b157319 27 SAMPLE_GRAVITY
ashleymills 5:756f9b157319 28 };
ashleymills 5:756f9b157319 29
ashleymills 5:756f9b157319 30 void sampleTypeToString(SampleType t, char *dst) {
ashleymills 5:756f9b157319 31 switch(t) {
ashleymills 5:756f9b157319 32 case SAMPLE_RAW:
ashleymills 5:756f9b157319 33 sprintf(dst,"SAMPLE_RAW");
ashleymills 5:756f9b157319 34 break;
ashleymills 5:756f9b157319 35 case SAMPLE_COUNT:
ashleymills 5:756f9b157319 36 sprintf(dst,"SAMPLE_COUNT");
ashleymills 5:756f9b157319 37 break;
ashleymills 5:756f9b157319 38 case SAMPLE_GRAVITY:
ashleymills 5:756f9b157319 39 sprintf(dst,"SAMPLE_GRAVITY");
ashleymills 5:756f9b157319 40 break;
ashleymills 5:756f9b157319 41 };
ashleymills 5:756f9b157319 42 }
ashleymills 5:756f9b157319 43
ashleymills 5:756f9b157319 44 int testSampleTaking(MMA8452 *acc, int nsamples, SampleType sampleType) {
ashleymills 5:756f9b157319 45 int samples = 0;
ashleymills 5:756f9b157319 46 int bufLen = 6;
ashleymills 5:756f9b157319 47
ashleymills 5:756f9b157319 48 // buffers for multi and single raw sampling
ashleymills 5:756f9b157319 49 char bufferMulti[6];
ashleymills 5:756f9b157319 50 char bufferSingle[6];
ashleymills 5:756f9b157319 51 memset(&bufferMulti,0x00,bufLen);
ashleymills 5:756f9b157319 52 memset(&bufferSingle,0x00,bufLen);
ashleymills 5:756f9b157319 53
ashleymills 5:756f9b157319 54 // variables for multi and single count sampling
ashleymills 5:756f9b157319 55 int xCountM = 0, yCountM = 0, zCountM = 0;
ashleymills 5:756f9b157319 56 int xCountS = 0, yCountS = 0, zCountS = 0;
ashleymills 5:756f9b157319 57
ashleymills 5:756f9b157319 58 // variables for multi and single gravity sampling
ashleymills 5:756f9b157319 59 double xGravityM = 0, yGravityM = 0, zGravityM = 0;
ashleymills 5:756f9b157319 60 double xGravityS = 0, yGravityS = 0, zGravityS = 0;
ashleymills 5:756f9b157319 61
ashleymills 5:756f9b157319 62 // keep track of errors
ashleymills 5:756f9b157319 63 int error = 0;
ashleymills 5:756f9b157319 64 // mismatches between multi and single read calls are inevitable
ashleymills 5:756f9b157319 65 // since the MMA8452 has an internal sampling mechanism which is
ashleymills 5:756f9b157319 66 // not synchronous to this test routine. At low internal sampling
ashleymills 5:756f9b157319 67 // rates, these mismatches should be rare, so keep track to
ashleymills 5:756f9b157319 68 // check that this is sane
ashleymills 5:756f9b157319 69 int mismatchCount = 0;
ashleymills 5:756f9b157319 70
ashleymills 5:756f9b157319 71 // take samples
ashleymills 5:756f9b157319 72 while(samples<nsamples) {
ashleymills 5:756f9b157319 73 // wait for device to be ready
ashleymills 5:756f9b157319 74 if(!acc->isXYZReady()) {
ashleymills 5:756f9b157319 75 wait(0.01);
ashleymills 5:756f9b157319 76 continue;
ashleymills 5:756f9b157319 77 }
ashleymills 5:756f9b157319 78
ashleymills 5:756f9b157319 79 switch(sampleType) {
ashleymills 5:756f9b157319 80 case SAMPLE_RAW:
ashleymills 5:756f9b157319 81 // read raw data via multi and single calls
ashleymills 5:756f9b157319 82 memset(&bufferMulti,0x00,bufLen);
ashleymills 5:756f9b157319 83 memset(&bufferSingle,0x00,bufLen);
ashleymills 5:756f9b157319 84 error = 0;
ashleymills 5:756f9b157319 85 error += acc->readXYZRaw((char*)&bufferMulti);
ashleymills 5:756f9b157319 86 error += acc->readXRaw((char*)&bufferSingle[0]);
ashleymills 5:756f9b157319 87 error += acc->readYRaw((char*)&bufferSingle[2]);
ashleymills 5:756f9b157319 88 error += acc->readZRaw((char*)&bufferSingle[4]);
ashleymills 5:756f9b157319 89 if(error) {
ashleymills 5:756f9b157319 90 LOG("Error reading raw accelerometer data. Fail.");
ashleymills 5:756f9b157319 91 return false;
ashleymills 5:756f9b157319 92 }
ashleymills 5:756f9b157319 93 // compare multi and single samples for equivalence
ashleymills 5:756f9b157319 94 // note that this is bound to fail for high data rates
ashleymills 5:756f9b157319 95 if(acc->getBitDepth()==MMA8452::BIT_DEPTH_12) {
ashleymills 5:756f9b157319 96 if(memcmp(bufferMulti,bufferSingle,bufLen)) {
ashleymills 5:756f9b157319 97 LOG("Multi and single sampling mismatch");
ashleymills 5:756f9b157319 98 LOG("Multi: %x %x %x %x %x %x",
ashleymills 5:756f9b157319 99 bufferMulti[0],bufferMulti[1],
ashleymills 5:756f9b157319 100 bufferMulti[2],bufferMulti[3],
ashleymills 5:756f9b157319 101 bufferMulti[4],bufferMulti[5]
ashleymills 5:756f9b157319 102 );
ashleymills 5:756f9b157319 103 LOG("Single: %x %x %x %x %x %x",
ashleymills 5:756f9b157319 104 bufferSingle[0],bufferSingle[1],
ashleymills 5:756f9b157319 105 bufferSingle[2],bufferSingle[3],
ashleymills 5:756f9b157319 106 bufferSingle[4],bufferSingle[5]
ashleymills 5:756f9b157319 107 );
ashleymills 5:756f9b157319 108 mismatchCount++;
ashleymills 5:756f9b157319 109 }
ashleymills 5:756f9b157319 110 LOG("Sample %d of %d: %x %x %x %x %x %x",
ashleymills 5:756f9b157319 111 samples,nsamples,
ashleymills 5:756f9b157319 112 bufferMulti[0],bufferMulti[1],
ashleymills 5:756f9b157319 113 bufferMulti[2],bufferMulti[3],
ashleymills 5:756f9b157319 114 bufferMulti[4],bufferMulti[5]
ashleymills 5:756f9b157319 115 );
ashleymills 5:756f9b157319 116 } else {
ashleymills 5:756f9b157319 117 if(bufferMulti[0]!=bufferSingle[0]||
ashleymills 5:756f9b157319 118 bufferMulti[1]!=bufferSingle[2]||
ashleymills 5:756f9b157319 119 bufferMulti[2]!=bufferSingle[4]) {
ashleymills 5:756f9b157319 120 LOG("Multi and single sampling mismatch");
ashleymills 5:756f9b157319 121 mismatchCount++;
ashleymills 5:756f9b157319 122 }
ashleymills 5:756f9b157319 123 LOG("Sample %d of %d: %x %x %x",
ashleymills 5:756f9b157319 124 samples,nsamples,
ashleymills 5:756f9b157319 125 bufferMulti[0],bufferMulti[1],bufferMulti[2]
ashleymills 5:756f9b157319 126 );
ashleymills 5:756f9b157319 127 }
ashleymills 5:756f9b157319 128 break;
ashleymills 5:756f9b157319 129 case SAMPLE_COUNT:
ashleymills 5:756f9b157319 130 error = 0;
ashleymills 5:756f9b157319 131 error += acc->readXYZCounts(&xCountM,&yCountM,&zCountM);
ashleymills 5:756f9b157319 132 if(error) {
ashleymills 5:756f9b157319 133 LOG("Error reading signed counts. Fail.");
ashleymills 5:756f9b157319 134 break;
ashleymills 5:756f9b157319 135 }
ashleymills 5:756f9b157319 136 break;
ashleymills 5:756f9b157319 137 case SAMPLE_GRAVITY:
ashleymills 5:756f9b157319 138 error = 0;
ashleymills 5:756f9b157319 139 error += acc->readXYZGravity(&xGravityM,&yGravityM,&zGravityM);
ashleymills 5:756f9b157319 140 if(error) {
ashleymills 5:756f9b157319 141 LOG("Error reading gravities. Fail.");
ashleymills 5:756f9b157319 142 break;
ashleymills 5:756f9b157319 143 }
ashleymills 5:756f9b157319 144 break;
ashleymills 5:756f9b157319 145 }
ashleymills 5:756f9b157319 146 samples++;
ashleymills 5:756f9b157319 147 }
ashleymills 5:756f9b157319 148 LOG("mismatches %d/%d",mismatchCount,nsamples);
ashleymills 5:756f9b157319 149 return true;
ashleymills 5:756f9b157319 150 }
ashleymills 5:756f9b157319 151
ashleymills 5:756f9b157319 152 int sampleMMA8452Raw(MMA8452 *acc, int nsamples) {
ashleymills 0:0c17274c3b7c 153 int samples = 0;
ashleymills 0:0c17274c3b7c 154 int bufLen = 6;
ashleymills 0:0c17274c3b7c 155 char buffer[6];
ashleymills 0:0c17274c3b7c 156 memset(&buffer,0x00,bufLen);
ashleymills 0:0c17274c3b7c 157 while(samples<nsamples) {
ashleymills 0:0c17274c3b7c 158 if(!acc->isXYZReady()) {
ashleymills 0:0c17274c3b7c 159 wait(0.01);
ashleymills 0:0c17274c3b7c 160 continue;
ashleymills 0:0c17274c3b7c 161 }
ashleymills 0:0c17274c3b7c 162 memset(&buffer,0x00,bufLen);
ashleymills 1:e9981919b524 163 acc->readXYZRaw(buffer);
ashleymills 0:0c17274c3b7c 164 LOGX("Sample %d of %d: ",samples,nsamples);
ashleymills 0:0c17274c3b7c 165 for(int i=0; i<bufLen; i++) {
ashleymills 0:0c17274c3b7c 166 LOGX("%.2x ",buffer[i]);
ashleymills 0:0c17274c3b7c 167 }
ashleymills 0:0c17274c3b7c 168 LOG(" ");
ashleymills 0:0c17274c3b7c 169 samples++;
ashleymills 0:0c17274c3b7c 170 }
ashleymills 5:756f9b157319 171 return true;
ashleymills 0:0c17274c3b7c 172 }
ashleymills 0:0c17274c3b7c 173
ashleymills 5:756f9b157319 174 int sampleMMA8452Counts(MMA8452 *acc, int nsamples) {
ashleymills 1:e9981919b524 175 int samples = 0;
ashleymills 1:e9981919b524 176 int bufLen = 6;
ashleymills 1:e9981919b524 177 char buffer[6];
ashleymills 1:e9981919b524 178 int x = 0, y = 0, z = 0;
ashleymills 1:e9981919b524 179 memset(&buffer,0x00,bufLen);
ashleymills 1:e9981919b524 180 while(samples<nsamples) {
ashleymills 1:e9981919b524 181 if(!acc->isXYZReady()) {
ashleymills 1:e9981919b524 182 wait(0.01);
ashleymills 1:e9981919b524 183 continue;
ashleymills 1:e9981919b524 184 }
ashleymills 1:e9981919b524 185 memset(&buffer,0x00,bufLen);
ashleymills 1:e9981919b524 186 if(acc->readXYZCounts(&x,&y,&z)) {
ashleymills 1:e9981919b524 187 LOG("Error reading sample");
ashleymills 1:e9981919b524 188 break;
ashleymills 1:e9981919b524 189 }
ashleymills 1:e9981919b524 190 LOG("Sample %d of %d: %d, %d, %d",samples,nsamples,x,y,z);
ashleymills 1:e9981919b524 191 samples++;
ashleymills 1:e9981919b524 192 }
ashleymills 5:756f9b157319 193 return true;
ashleymills 1:e9981919b524 194 }
ashleymills 1:e9981919b524 195
ashleymills 5:756f9b157319 196 int sampleMMA8452Gravities(MMA8452 *acc, int nsamples) {
ashleymills 1:e9981919b524 197 int samples = 0;
ashleymills 1:e9981919b524 198 int bufLen = 6;
ashleymills 1:e9981919b524 199 char buffer[6];
ashleymills 1:e9981919b524 200 double x = 0, y = 0, z = 0;
ashleymills 1:e9981919b524 201 memset(&buffer,0x00,bufLen);
ashleymills 1:e9981919b524 202 while(samples<nsamples) {
ashleymills 1:e9981919b524 203 if(!acc->isXYZReady()) {
ashleymills 1:e9981919b524 204 wait(0.01);
ashleymills 1:e9981919b524 205 continue;
ashleymills 1:e9981919b524 206 }
ashleymills 1:e9981919b524 207 memset(&buffer,0x00,bufLen);
ashleymills 1:e9981919b524 208 if(acc->readXYZGravity(&x,&y,&z)) {
ashleymills 1:e9981919b524 209 LOG("Error reading sample");
ashleymills 1:e9981919b524 210 break;
ashleymills 1:e9981919b524 211 }
ashleymills 1:e9981919b524 212 LOG("Sample %d of %d: %lf, %lf, %lf",samples,nsamples,x,y,z);
ashleymills 1:e9981919b524 213 samples++;
ashleymills 1:e9981919b524 214 }
ashleymills 5:756f9b157319 215 return true;
ashleymills 5:756f9b157319 216 }
ashleymills 5:756f9b157319 217
ashleymills 5:756f9b157319 218 void bitDepthToString(MMA8452::BitDepth d, char *dst) {
ashleymills 5:756f9b157319 219 switch(d) {
ashleymills 5:756f9b157319 220 case MMA8452::BIT_DEPTH_12:
ashleymills 5:756f9b157319 221 sprintf(dst,"BIT_DEPTH_12");
ashleymills 5:756f9b157319 222 break;
ashleymills 5:756f9b157319 223 case MMA8452::BIT_DEPTH_8:
ashleymills 5:756f9b157319 224 sprintf(dst,"BIT_DEPTH_8");
ashleymills 5:756f9b157319 225 break;
ashleymills 5:756f9b157319 226 }
ashleymills 5:756f9b157319 227 }
ashleymills 5:756f9b157319 228
ashleymills 5:756f9b157319 229 void dynamicRangeToString(MMA8452::DynamicRange r, char *dst) {
ashleymills 5:756f9b157319 230 switch(r) {
ashleymills 5:756f9b157319 231 case MMA8452::DYNAMIC_RANGE_2G:
ashleymills 5:756f9b157319 232 sprintf(dst,"DYNAMIC_RANGE_2G");
ashleymills 5:756f9b157319 233 break;
ashleymills 5:756f9b157319 234 case MMA8452::DYNAMIC_RANGE_4G:
ashleymills 5:756f9b157319 235 sprintf(dst,"DYNAMIC_RANGE_4G");
ashleymills 5:756f9b157319 236 break;
ashleymills 5:756f9b157319 237 case MMA8452::DYNAMIC_RANGE_8G:
ashleymills 5:756f9b157319 238 sprintf(dst,"DYNAMIC_RANGE_8G");
ashleymills 5:756f9b157319 239 break;
ashleymills 5:756f9b157319 240 }
ashleymills 5:756f9b157319 241 }
ashleymills 5:756f9b157319 242
ashleymills 5:756f9b157319 243 void dataRateToString(MMA8452::DataRateHz r, char *dst) {
ashleymills 5:756f9b157319 244 switch(r) {
ashleymills 5:756f9b157319 245 case MMA8452::RATE_800:
ashleymills 5:756f9b157319 246 sprintf(dst,"RATE_800");
ashleymills 5:756f9b157319 247 break;
ashleymills 5:756f9b157319 248 case MMA8452::RATE_400:
ashleymills 5:756f9b157319 249 sprintf(dst,"RATE_400");
ashleymills 5:756f9b157319 250 break;
ashleymills 5:756f9b157319 251 case MMA8452::RATE_200:
ashleymills 5:756f9b157319 252 sprintf(dst,"RATE_200");
ashleymills 5:756f9b157319 253 break;
ashleymills 5:756f9b157319 254 case MMA8452::RATE_100:
ashleymills 5:756f9b157319 255 sprintf(dst,"RATE_100");
ashleymills 5:756f9b157319 256 break;
ashleymills 5:756f9b157319 257 case MMA8452::RATE_50:
ashleymills 5:756f9b157319 258 sprintf(dst,"RATE_50");
ashleymills 5:756f9b157319 259 break;
ashleymills 5:756f9b157319 260 case MMA8452::RATE_12_5:
ashleymills 5:756f9b157319 261 sprintf(dst,"RATE_12_5");
ashleymills 5:756f9b157319 262 break;
ashleymills 5:756f9b157319 263 case MMA8452::RATE_6_25:
ashleymills 5:756f9b157319 264 sprintf(dst,"RATE_6_25");
ashleymills 5:756f9b157319 265 break;
ashleymills 5:756f9b157319 266 case MMA8452::RATE_1_563:
ashleymills 5:756f9b157319 267 sprintf(dst,"RATE_1_563");
ashleymills 5:756f9b157319 268 break;
ashleymills 5:756f9b157319 269 }
ashleymills 1:e9981919b524 270 }
ashleymills 1:e9981919b524 271
ashleymills 0:0c17274c3b7c 272 int test() {
ashleymills 0:0c17274c3b7c 273 MMA8452 acc(p28, p27, 40000);
ashleymills 0:0c17274c3b7c 274
ashleymills 0:0c17274c3b7c 275 acc.debugRegister(MMA8452_CTRL_REG_1);
ashleymills 0:0c17274c3b7c 276
ashleymills 0:0c17274c3b7c 277 LOG("Entering standby");
ashleymills 0:0c17274c3b7c 278 if(acc.standby()) {
ashleymills 0:0c17274c3b7c 279 LOG("Error putting MMA8452 in standby");
ashleymills 0:0c17274c3b7c 280 return false;
ashleymills 0:0c17274c3b7c 281 }
ashleymills 0:0c17274c3b7c 282
ashleymills 0:0c17274c3b7c 283 acc.debugRegister(MMA8452_CTRL_REG_1);
ashleymills 0:0c17274c3b7c 284
ashleymills 0:0c17274c3b7c 285 LOG("Activating MMA8452");
ashleymills 0:0c17274c3b7c 286 if(acc.activate()) {
ashleymills 0:0c17274c3b7c 287 LOG("Error activating MMA8452");
ashleymills 0:0c17274c3b7c 288 return false;
ashleymills 0:0c17274c3b7c 289 }
ashleymills 0:0c17274c3b7c 290
ashleymills 1:e9981919b524 291 char devID = 0;
ashleymills 1:e9981919b524 292 if(acc.getDeviceID(&devID)) {
ashleymills 1:e9981919b524 293 LOG("Error getting device ID");
ashleymills 1:e9981919b524 294 return false;
ashleymills 1:e9981919b524 295 }
ashleymills 1:e9981919b524 296 LOG("DeviceID: 0x%x",devID);
ashleymills 1:e9981919b524 297 if(devID!=0x2a) {
ashleymills 1:e9981919b524 298 LOG("Error, fetched device ID: 0x%x does not match expected 0x2a",devID);
ashleymills 1:e9981919b524 299 return false;
ashleymills 1:e9981919b524 300 } else {
ashleymills 1:e9981919b524 301 LOG("Device ID OK");
ashleymills 1:e9981919b524 302 }
ashleymills 1:e9981919b524 303
ashleymills 0:0c17274c3b7c 304 // test setting dynamic range
ashleymills 0:0c17274c3b7c 305 MMA8452::DynamicRange setRange = MMA8452::DYNAMIC_RANGE_UNKNOWN;
ashleymills 0:0c17274c3b7c 306 MMA8452::DynamicRange readRange = MMA8452::DYNAMIC_RANGE_UNKNOWN;
ashleymills 0:0c17274c3b7c 307 for(int i=0; i<=(int)MMA8452::DYNAMIC_RANGE_8G; i++) {
ashleymills 0:0c17274c3b7c 308 setRange = (MMA8452::DynamicRange)i;
ashleymills 0:0c17274c3b7c 309 if(acc.setDynamicRange(setRange)) {
ashleymills 0:0c17274c3b7c 310 LOG("Error setting dynamic range. Failing.");
ashleymills 0:0c17274c3b7c 311 return false;
ashleymills 0:0c17274c3b7c 312 }
ashleymills 0:0c17274c3b7c 313 readRange = acc.getDynamicRange();
ashleymills 0:0c17274c3b7c 314 if(readRange!=setRange) {
ashleymills 0:0c17274c3b7c 315 LOG("Read dynamic range: 0x%x does not match set: 0x%x",readRange,setRange);
ashleymills 0:0c17274c3b7c 316 return false;
ashleymills 0:0c17274c3b7c 317 }
ashleymills 0:0c17274c3b7c 318 LOG("Success on dynamic range %d",i);
ashleymills 0:0c17274c3b7c 319 }
ashleymills 0:0c17274c3b7c 320
ashleymills 0:0c17274c3b7c 321 // test setting data rate
ashleymills 0:0c17274c3b7c 322 for(int i=0; i<=(int)MMA8452::RATE_1_563; i++) {
ashleymills 0:0c17274c3b7c 323 if(acc.setDataRate((MMA8452::DataRateHz)i)) {
ashleymills 0:0c17274c3b7c 324 LOG("Error setting data rate. Failing.");
ashleymills 0:0c17274c3b7c 325 return false;
ashleymills 0:0c17274c3b7c 326 }
ashleymills 0:0c17274c3b7c 327 if(acc.getDataRate()!=(MMA8452::DataRateHz)i) {
ashleymills 0:0c17274c3b7c 328 LOG("Read data rate: 0x%x does not match set: 0x%x",acc.getDataRate(),(MMA8452::DataRateHz)i);
ashleymills 0:0c17274c3b7c 329 return false;
ashleymills 0:0c17274c3b7c 330 }
ashleymills 0:0c17274c3b7c 331 LOG("Success on data rate %d",i);
ashleymills 0:0c17274c3b7c 332 }
ashleymills 0:0c17274c3b7c 333
ashleymills 5:756f9b157319 334 char depthString[32], rangeString[32], rateString[32], sampleTypeString[32];
ashleymills 5:756f9b157319 335 // draw some samples at each bit depth, rate, and dynamic range
ashleymills 5:756f9b157319 336 for(int depth=0; depth<=(int)MMA8452::BIT_DEPTH_8; depth++) {
ashleymills 5:756f9b157319 337 bitDepthToString((MMA8452::BitDepth)depth,(char*)&depthString);
ashleymills 5:756f9b157319 338 LOG("Setting bit depth to %s",depthString);
ashleymills 5:756f9b157319 339 if(acc.setBitDepth((MMA8452::BitDepth)depth)) {
ashleymills 5:756f9b157319 340 LOG("Error setting bit depth to %s. Fail.",depthString);
ashleymills 5:756f9b157319 341 return false;
ashleymills 5:756f9b157319 342 }
ashleymills 5:756f9b157319 343 for(int range=0; range<=(int)MMA8452::DYNAMIC_RANGE_8G; range++) {
ashleymills 5:756f9b157319 344 dynamicRangeToString((MMA8452::DynamicRange)range,(char*)&rangeString);
ashleymills 5:756f9b157319 345 LOG("Setting dynamic range to %s",rangeString);
ashleymills 5:756f9b157319 346 if(acc.setDynamicRange((MMA8452::DynamicRange)range)) {
ashleymills 5:756f9b157319 347 LOG("Error setting dynamic range to %s. Fail.",rangeString);
ashleymills 5:756f9b157319 348 return false;
ashleymills 5:756f9b157319 349 }
ashleymills 5:756f9b157319 350 for(int rate=0; rate<=(int)MMA8452::RATE_1_563; rate++) {
ashleymills 5:756f9b157319 351 dataRateToString((MMA8452::DataRateHz)rate,(char*)&rateString);
ashleymills 5:756f9b157319 352 LOG("Setting data rate to %s",rateString);
ashleymills 5:756f9b157319 353 if(acc.setDataRate((MMA8452::DataRateHz)rate)) {
ashleymills 5:756f9b157319 354 LOG("Error setting data rate to %s",rateString);
ashleymills 5:756f9b157319 355 return false;
ashleymills 5:756f9b157319 356 }
ashleymills 5:756f9b157319 357 // take samples
ashleymills 5:756f9b157319 358 for(int sampleType=0; sampleType<=(int)SAMPLE_GRAVITY; sampleType++) {
ashleymills 5:756f9b157319 359 sampleTypeToString((SampleType)sampleType,sampleTypeString);
ashleymills 5:756f9b157319 360 LOG("Setting sample type to %s",sampleTypeString);
ashleymills 5:756f9b157319 361 if(testSampleTaking(&acc, 10, (SampleType)sampleType)!=true) {
ashleymills 5:756f9b157319 362 LOG("Sample taking failed for %s, %s, %s, %s",sampleTypeString,depthString,rangeString,rateString);
ashleymills 5:756f9b157319 363 return false;
ashleymills 5:756f9b157319 364 }
ashleymills 5:756f9b157319 365 }
ashleymills 5:756f9b157319 366 }
ashleymills 5:756f9b157319 367 }
ashleymills 5:756f9b157319 368 }
ashleymills 5:756f9b157319 369 return true;
ashleymills 5:756f9b157319 370
ashleymills 0:0c17274c3b7c 371 // set bit depth to 8 and read some values
ashleymills 0:0c17274c3b7c 372 LOG("Sampling at BIT_DEPTH_8");
ashleymills 5:756f9b157319 373 if(acc.setBitDepth(MMA8452::BIT_DEPTH_8)) {
ashleymills 5:756f9b157319 374 LOG("Error setting bit depth. Fail.");
ashleymills 5:756f9b157319 375 return false;
ashleymills 5:756f9b157319 376 }
ashleymills 1:e9981919b524 377 sampleMMA8452Raw(&acc,10);
ashleymills 0:0c17274c3b7c 378
ashleymills 0:0c17274c3b7c 379 // set bit depth to 12 and read some values
ashleymills 0:0c17274c3b7c 380 LOG("Sampling at BIT_DEPTH_12");
ashleymills 0:0c17274c3b7c 381 acc.setDataRate(MMA8452::RATE_100);
ashleymills 0:0c17274c3b7c 382 acc.setBitDepth(MMA8452::BIT_DEPTH_12);
ashleymills 1:e9981919b524 383 sampleMMA8452Raw(&acc,10);
ashleymills 1:e9981919b524 384
ashleymills 1:e9981919b524 385 LOG("Sampling counts");
ashleymills 1:e9981919b524 386 acc.setDynamicRange(MMA8452::DYNAMIC_RANGE_2G);
ashleymills 1:e9981919b524 387 sampleMMA8452Counts(&acc,100);
ashleymills 1:e9981919b524 388
ashleymills 1:e9981919b524 389 LOG("Samping gravities");
ashleymills 2:0630128bdb32 390 acc.setBitDepth(MMA8452::BIT_DEPTH_8);
ashleymills 2:0630128bdb32 391 acc.setDynamicRange(MMA8452::DYNAMIC_RANGE_4G);
ashleymills 2:0630128bdb32 392 sampleMMA8452Gravities(&acc,2000);
ashleymills 0:0c17274c3b7c 393
ashleymills 0:0c17274c3b7c 394 return true;
ashleymills 0:0c17274c3b7c 395 }
ashleymills 0:0c17274c3b7c 396
ashleymills 0:0c17274c3b7c 397 void loop() {
ashleymills 0:0c17274c3b7c 398 while(1) {
ashleymills 0:0c17274c3b7c 399 wait(1);
ashleymills 0:0c17274c3b7c 400 }
ashleymills 0:0c17274c3b7c 401 }
ashleymills 0:0c17274c3b7c 402
ashleymills 1:e9981919b524 403 void u16d(uint16_t n) {
ashleymills 1:e9981919b524 404 int shift = 16;
ashleymills 1:e9981919b524 405 uint16_t mask = 0x8000;
ashleymills 1:e9981919b524 406 while(--shift>=0) {
ashleymills 1:e9981919b524 407 LOGX("%d",(n&mask)>>shift);
ashleymills 1:e9981919b524 408 mask >>= 1;
ashleymills 1:e9981919b524 409 }
ashleymills 1:e9981919b524 410 LOG(" ");
ashleymills 1:e9981919b524 411 }
ashleymills 1:e9981919b524 412
ashleymills 1:e9981919b524 413 int eightBitToSigned(char *buf) {
ashleymills 1:e9981919b524 414 return (int8_t)*buf;
ashleymills 1:e9981919b524 415 }
ashleymills 1:e9981919b524 416
ashleymills 1:e9981919b524 417 int twelveBitToSigned(char *buf) {
ashleymills 1:e9981919b524 418 //LOG("Doing twos complement conversion for 0x%x 0x%x",buf[0],buf[1]);
ashleymills 1:e9981919b524 419
ashleymills 1:e9981919b524 420 // cheat by using the int16_t internal type
ashleymills 1:e9981919b524 421 // all we need to do is convert to little-endian format and shift right
ashleymills 1:e9981919b524 422 int16_t x = 0;
ashleymills 1:e9981919b524 423 ((char*)&x)[1] = buf[0];
ashleymills 1:e9981919b524 424 ((char*)&x)[0] = buf[1];
ashleymills 1:e9981919b524 425 // note this only works because the below is an arithmetic right shift
ashleymills 1:e9981919b524 426 return x>>4;
ashleymills 1:e9981919b524 427
ashleymills 1:e9981919b524 428 // for reference, here is the full conversion, in case you port this somewhere where the above won't work
ashleymills 1:e9981919b524 429 /*
ashleymills 1:e9981919b524 430 uint16_t number = 0x0000;
ashleymills 1:e9981919b524 431 //u16d(number);
ashleymills 1:e9981919b524 432 int negative = false;
ashleymills 1:e9981919b524 433
ashleymills 1:e9981919b524 434 // bit depth 12, is spread over two bytes
ashleymills 1:e9981919b524 435 // put it into a uint16_t for easy manipulation
ashleymills 1:e9981919b524 436 number |= (buf[0]<<8);
ashleymills 1:e9981919b524 437 number |= buf[1];
ashleymills 1:e9981919b524 438
ashleymills 1:e9981919b524 439 // if this is a negative number take the twos complement
ashleymills 1:e9981919b524 440 if(number&0x8000) {
ashleymills 1:e9981919b524 441 negative = true;
ashleymills 1:e9981919b524 442 // flip all bits (doesn't matter about lower 4 bits)
ashleymills 1:e9981919b524 443 number ^= 0xFFFF;
ashleymills 1:e9981919b524 444
ashleymills 1:e9981919b524 445 // add 1 (but do so in a way that deals with overflow and respects our current leftwise shift)
ashleymills 1:e9981919b524 446 number += 0x0010;
ashleymills 1:e9981919b524 447 }
ashleymills 1:e9981919b524 448
ashleymills 1:e9981919b524 449 // shifting down the result by 4 bits gives us the absolute number
ashleymills 1:e9981919b524 450 number >>= 4;
ashleymills 1:e9981919b524 451
ashleymills 1:e9981919b524 452 int result = number;
ashleymills 1:e9981919b524 453 if(negative) {
ashleymills 1:e9981919b524 454 result *= -1;
ashleymills 1:e9981919b524 455 }
ashleymills 1:e9981919b524 456 return result;
ashleymills 1:e9981919b524 457 */
ashleymills 1:e9981919b524 458 }
ashleymills 1:e9981919b524 459
ashleymills 1:e9981919b524 460 int twosCompTest() {
ashleymills 1:e9981919b524 461 // 12 bits of number gives 2048 steps
ashleymills 1:e9981919b524 462 int16_t i = -2047;
ashleymills 1:e9981919b524 463 while(1) {
ashleymills 1:e9981919b524 464 //LOG("number: %d",i);
ashleymills 1:e9981919b524 465 //u16d(number);
ashleymills 1:e9981919b524 466 uint16_t shiftedNumber = i<<4;
ashleymills 1:e9981919b524 467 //LOG("shifted:");
ashleymills 1:e9981919b524 468 //u16d(shiftedNumber);
ashleymills 1:e9981919b524 469 // ARM is little endian whereas 12 bit 2's comp rep is big endian
ashleymills 1:e9981919b524 470 uint16_t flippedNumber = 0x0000;
ashleymills 1:e9981919b524 471 //LOG("switching bytes");
ashleymills 1:e9981919b524 472 //u16d(flippedNumber);
ashleymills 1:e9981919b524 473 ((char*)&flippedNumber)[0] = ((char*)&shiftedNumber)[1];
ashleymills 1:e9981919b524 474
ashleymills 1:e9981919b524 475 //u16d(flippedNumber);
ashleymills 1:e9981919b524 476 ((char*)&flippedNumber)[1] = ((char*)&shiftedNumber)[0];
ashleymills 1:e9981919b524 477
ashleymills 1:e9981919b524 478 //u16d(flippedNumber);
ashleymills 1:e9981919b524 479 int value = twelveBitToSigned((char*)&flippedNumber);
ashleymills 1:e9981919b524 480 //LOG("%d converts to %d",i,value);
ashleymills 1:e9981919b524 481 if(i!=value) {
ashleymills 1:e9981919b524 482 return false;
ashleymills 1:e9981919b524 483 }
ashleymills 1:e9981919b524 484 if(i==2047) {
ashleymills 1:e9981919b524 485 break;
ashleymills 1:e9981919b524 486 }
ashleymills 1:e9981919b524 487 i++;
ashleymills 1:e9981919b524 488 }
ashleymills 1:e9981919b524 489
ashleymills 1:e9981919b524 490 int8_t n = -127;
ashleymills 1:e9981919b524 491 while(1) {
ashleymills 1:e9981919b524 492 int value = eightBitToSigned((char*)&n);
ashleymills 1:e9981919b524 493 //LOG("%d converts to %d",n,value);
ashleymills 1:e9981919b524 494 if(n!=value) {
ashleymills 1:e9981919b524 495 return false;
ashleymills 1:e9981919b524 496 }
ashleymills 1:e9981919b524 497 if(n==127) {
ashleymills 1:e9981919b524 498 break;
ashleymills 1:e9981919b524 499 }
ashleymills 1:e9981919b524 500 n++;
ashleymills 1:e9981919b524 501 }
ashleymills 1:e9981919b524 502
ashleymills 1:e9981919b524 503 return true;
ashleymills 1:e9981919b524 504 }
ashleymills 1:e9981919b524 505
ashleymills 0:0c17274c3b7c 506 int main() {
ashleymills 0:0c17274c3b7c 507 pc.baud(115200);
ashleymills 0:0c17274c3b7c 508 LOG("Begin");
ashleymills 1:e9981919b524 509 if(!twosCompTest()) {
ashleymills 1:e9981919b524 510 LOG("twos comp test failed");
ashleymills 1:e9981919b524 511 loop();
ashleymills 1:e9981919b524 512 }
ashleymills 1:e9981919b524 513 LOG("twos comp test passed");
ashleymills 1:e9981919b524 514 //loop();
ashleymills 0:0c17274c3b7c 515 for(int i=0; i<20; i++) {
ashleymills 0:0c17274c3b7c 516 LOG(" ");
ashleymills 0:0c17274c3b7c 517 }
ashleymills 0:0c17274c3b7c 518 if(!test()) {
ashleymills 0:0c17274c3b7c 519 LOG("FAIL.");
ashleymills 0:0c17274c3b7c 520 loop();
ashleymills 0:0c17274c3b7c 521 }
ashleymills 0:0c17274c3b7c 522 LOG("Tests passed");
ashleymills 0:0c17274c3b7c 523 loop();
ashleymills 0:0c17274c3b7c 524 }