Driving
Dependencies: FSR LIS3DH USBDevice mbed
Fork of MMA8452_Demo by
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?
User | Revision | Line number | New 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 | } |