ECE_4180_Project / Mbed 2 deprecated Farkle_main

Important changes to repositories hosted on mbed.com

Mbed hosted mercurial repositories are deprecated and are due to be permanently deleted in July 2026.

To keep a copy of this software download the repository Zip archive or clone locally using Mercurial.

It is also possible to export all your personal repositories from the account settings page.

Dependencies:   4DGL-uLCD-SE PinDetect mbed

MMA8452.cpp@0:09b7e6aa75a9, 2021-11-30 (annotated)

Committer:
jwalker366
Date:
Tue Nov 30 18:58:54 2021 +0000
Revision:
0:09b7e6aa75a9
for sub;

Who changed what in which revision?

UserRevisionLine numberNew contents of line
jwalker366 0:09b7e6aa75a9 1 // Authors: Ashley Mills, Nicholas Herriot
jwalker366 0:09b7e6aa75a9 2 /* Copyright (c) 2013 Vodafone, MIT License
jwalker366 0:09b7e6aa75a9 3 *
jwalker366 0:09b7e6aa75a9 4 * Permission is hereby granted, free of charge, to any person obtaining a copy of this software
jwalker366 0:09b7e6aa75a9 5 * and associated documentation files (the "Software"), to deal in the Software without restriction,
jwalker366 0:09b7e6aa75a9 6 * including without limitation the rights to use, copy, modify, merge, publish, distribute,
jwalker366 0:09b7e6aa75a9 7 * sublicense, and/or sell copies of the Software, and to permit persons to whom the Software is
jwalker366 0:09b7e6aa75a9 8 * furnished to do so, subject to the following conditions:
jwalker366 0:09b7e6aa75a9 9 *
jwalker366 0:09b7e6aa75a9 10 * The above copyright notice and this permission notice shall be included in all copies or
jwalker366 0:09b7e6aa75a9 11 * substantial portions of the Software.
jwalker366 0:09b7e6aa75a9 12 *
jwalker366 0:09b7e6aa75a9 13 * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR IMPLIED, INCLUDING
jwalker366 0:09b7e6aa75a9 14 * BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
jwalker366 0:09b7e6aa75a9 15 * NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM,
jwalker366 0:09b7e6aa75a9 16 * DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
jwalker366 0:09b7e6aa75a9 17 * OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
jwalker366 0:09b7e6aa75a9 18 */
jwalker366 0:09b7e6aa75a9 19
jwalker366 0:09b7e6aa75a9 20 #include "MMA8452.h"
jwalker366 0:09b7e6aa75a9 21 #include "mbed.h"
jwalker366 0:09b7e6aa75a9 22
jwalker366 0:09b7e6aa75a9 23 #ifdef MMA8452_DEBUG
jwalker366 0:09b7e6aa75a9 24 // you need to define Serial pc(USBTX,USBRX) somewhere for the below line to make sense
jwalker366 0:09b7e6aa75a9 25 extern Serial pc;
jwalker366 0:09b7e6aa75a9 26 #define MMA8452_DBG(...) pc.printf(__VA_ARGS__); pc.printf("\r\n");
jwalker366 0:09b7e6aa75a9 27 #else
jwalker366 0:09b7e6aa75a9 28 #define MMA8452_DBG(...)
jwalker366 0:09b7e6aa75a9 29 #endif
jwalker366 0:09b7e6aa75a9 30
jwalker366 0:09b7e6aa75a9 31 // Connect module at I2C address using I2C port pins sda and scl
jwalker366 0:09b7e6aa75a9 32 MMA8452::MMA8452(PinName sda, PinName scl, int frequency) : _i2c(sda, scl) , _frequency(frequency) {
jwalker366 0:09b7e6aa75a9 33 MMA8452_DBG("Creating MMA8452");
jwalker366 0:09b7e6aa75a9 34
jwalker366 0:09b7e6aa75a9 35 // set I2C frequency
jwalker366 0:09b7e6aa75a9 36 _i2c.frequency(_frequency);
jwalker366 0:09b7e6aa75a9 37
jwalker366 0:09b7e6aa75a9 38 // setup read and write addresses for convenience
jwalker366 0:09b7e6aa75a9 39 _readAddress = MMA8452_ADDRESS | 0x01;
jwalker366 0:09b7e6aa75a9 40 _writeAddress = MMA8452_ADDRESS & 0xFE;
jwalker366 0:09b7e6aa75a9 41
jwalker366 0:09b7e6aa75a9 42 // set some defaults
jwalker366 0:09b7e6aa75a9 43 _bitDepth = BIT_DEPTH_UNKNOWN;
jwalker366 0:09b7e6aa75a9 44 setBitDepth(BIT_DEPTH_12);
jwalker366 0:09b7e6aa75a9 45 _dynamicRange = DYNAMIC_RANGE_UNKNOWN;
jwalker366 0:09b7e6aa75a9 46 setDynamicRange(DYNAMIC_RANGE_2G);
jwalker366 0:09b7e6aa75a9 47
jwalker366 0:09b7e6aa75a9 48 MMA8452_DBG("Done");
jwalker366 0:09b7e6aa75a9 49 }
jwalker366 0:09b7e6aa75a9 50
jwalker366 0:09b7e6aa75a9 51
jwalker366 0:09b7e6aa75a9 52 // Destroys instance
jwalker366 0:09b7e6aa75a9 53 MMA8452::~MMA8452() {}
jwalker366 0:09b7e6aa75a9 54
jwalker366 0:09b7e6aa75a9 55 // Setting the control register bit 1 to true to activate the MMA8452
jwalker366 0:09b7e6aa75a9 56 int MMA8452::activate() {
jwalker366 0:09b7e6aa75a9 57 // perform write and return error code
jwalker366 0:09b7e6aa75a9 58 return logicalORRegister(MMA8452_CTRL_REG_1,MMA8452_ACTIVE_MASK);
jwalker366 0:09b7e6aa75a9 59 }
jwalker366 0:09b7e6aa75a9 60
jwalker366 0:09b7e6aa75a9 61 // Setting the control register bit 1 to 0 to standby the MMA8452
jwalker366 0:09b7e6aa75a9 62 int MMA8452::standby() {
jwalker366 0:09b7e6aa75a9 63 // perform write and return error code
jwalker366 0:09b7e6aa75a9 64 return logicalANDRegister(MMA8452_CTRL_REG_1,MMA8452_STANDBY_MASK);
jwalker366 0:09b7e6aa75a9 65 }
jwalker366 0:09b7e6aa75a9 66
jwalker366 0:09b7e6aa75a9 67 // this reads a register, applies a bitmask with logical AND, sets a value with logical OR,
jwalker366 0:09b7e6aa75a9 68 // and optionally goes into and out of standby at the beginning and end of the function respectively
jwalker366 0:09b7e6aa75a9 69 int MMA8452::maskAndApplyRegister(char reg, char mask, char value, int toggleActivation) {
jwalker366 0:09b7e6aa75a9 70 if(toggleActivation) {
jwalker366 0:09b7e6aa75a9 71 if(standby()) {
jwalker366 0:09b7e6aa75a9 72 return 1;
jwalker366 0:09b7e6aa75a9 73 }
jwalker366 0:09b7e6aa75a9 74 }
jwalker366 0:09b7e6aa75a9 75
jwalker366 0:09b7e6aa75a9 76 // read from register
jwalker366 0:09b7e6aa75a9 77 char oldValue = 0;
jwalker366 0:09b7e6aa75a9 78 if(readRegister(reg,&oldValue)) {
jwalker366 0:09b7e6aa75a9 79 return 1;
jwalker366 0:09b7e6aa75a9 80 }
jwalker366 0:09b7e6aa75a9 81
jwalker366 0:09b7e6aa75a9 82 // apply bitmask
jwalker366 0:09b7e6aa75a9 83 oldValue &= mask;
jwalker366 0:09b7e6aa75a9 84
jwalker366 0:09b7e6aa75a9 85 // set value
jwalker366 0:09b7e6aa75a9 86 oldValue |= value;
jwalker366 0:09b7e6aa75a9 87
jwalker366 0:09b7e6aa75a9 88 // write back to register
jwalker366 0:09b7e6aa75a9 89 if(writeRegister(reg,oldValue)) {
jwalker366 0:09b7e6aa75a9 90 return 1;
jwalker366 0:09b7e6aa75a9 91 }
jwalker366 0:09b7e6aa75a9 92
jwalker366 0:09b7e6aa75a9 93 if(toggleActivation) {
jwalker366 0:09b7e6aa75a9 94 if(activate()) {
jwalker366 0:09b7e6aa75a9 95 return 1;
jwalker366 0:09b7e6aa75a9 96 }
jwalker366 0:09b7e6aa75a9 97 }
jwalker366 0:09b7e6aa75a9 98 return 0;
jwalker366 0:09b7e6aa75a9 99 }
jwalker366 0:09b7e6aa75a9 100
jwalker366 0:09b7e6aa75a9 101 int MMA8452::setDynamicRange(DynamicRange range, int toggleActivation) {
jwalker366 0:09b7e6aa75a9 102 _dynamicRange = range;
jwalker366 0:09b7e6aa75a9 103 return maskAndApplyRegister(
jwalker366 0:09b7e6aa75a9 104 MMA8452_XYZ_DATA_CFG,
jwalker366 0:09b7e6aa75a9 105 MMA8452_DYNAMIC_RANGE_MASK,
jwalker366 0:09b7e6aa75a9 106 range,
jwalker366 0:09b7e6aa75a9 107 toggleActivation
jwalker366 0:09b7e6aa75a9 108 );
jwalker366 0:09b7e6aa75a9 109 }
jwalker366 0:09b7e6aa75a9 110
jwalker366 0:09b7e6aa75a9 111 int MMA8452::setDataRate(DataRateHz dataRate, int toggleActivation) {
jwalker366 0:09b7e6aa75a9 112 return maskAndApplyRegister(
jwalker366 0:09b7e6aa75a9 113 MMA8452_CTRL_REG_1,
jwalker366 0:09b7e6aa75a9 114 MMA8452_DATA_RATE_MASK,
jwalker366 0:09b7e6aa75a9 115 dataRate<<MMA8452_DATA_RATE_MASK_SHIFT,
jwalker366 0:09b7e6aa75a9 116 toggleActivation
jwalker366 0:09b7e6aa75a9 117 );
jwalker366 0:09b7e6aa75a9 118 }
jwalker366 0:09b7e6aa75a9 119
jwalker366 0:09b7e6aa75a9 120 int MMA8452::setBitDepth(BitDepth depth,int toggleActivation) {
jwalker366 0:09b7e6aa75a9 121 _bitDepth = depth;
jwalker366 0:09b7e6aa75a9 122 return maskAndApplyRegister(
jwalker366 0:09b7e6aa75a9 123 MMA8452_CTRL_REG_1,
jwalker366 0:09b7e6aa75a9 124 MMA8452_BIT_DEPTH_MASK,
jwalker366 0:09b7e6aa75a9 125 depth<<MMA8452_BIT_DEPTH_MASK_SHIFT,
jwalker366 0:09b7e6aa75a9 126 toggleActivation
jwalker366 0:09b7e6aa75a9 127 );
jwalker366 0:09b7e6aa75a9 128 }
jwalker366 0:09b7e6aa75a9 129
jwalker366 0:09b7e6aa75a9 130 char MMA8452::getMaskedRegister(int addr, char mask) {
jwalker366 0:09b7e6aa75a9 131 char rval = 0;
jwalker366 0:09b7e6aa75a9 132 if(readRegister(addr,&rval)) {
jwalker366 0:09b7e6aa75a9 133 return 0;
jwalker366 0:09b7e6aa75a9 134 }
jwalker366 0:09b7e6aa75a9 135 return (rval&mask);
jwalker366 0:09b7e6aa75a9 136 }
jwalker366 0:09b7e6aa75a9 137
jwalker366 0:09b7e6aa75a9 138 int MMA8452::isXYZReady() {
jwalker366 0:09b7e6aa75a9 139 return getMaskedRegister(MMA8452_STATUS,MMA8452_STATUS_ZYXDR_MASK)>0;
jwalker366 0:09b7e6aa75a9 140 }
jwalker366 0:09b7e6aa75a9 141
jwalker366 0:09b7e6aa75a9 142 int MMA8452::isXReady() {
jwalker366 0:09b7e6aa75a9 143 return getMaskedRegister(MMA8452_STATUS,MMA8452_STATUS_XDR_MASK)>0;
jwalker366 0:09b7e6aa75a9 144 }
jwalker366 0:09b7e6aa75a9 145
jwalker366 0:09b7e6aa75a9 146 int MMA8452::isYReady() {
jwalker366 0:09b7e6aa75a9 147 return getMaskedRegister(MMA8452_STATUS,MMA8452_STATUS_YDR_MASK)>0;
jwalker366 0:09b7e6aa75a9 148 }
jwalker366 0:09b7e6aa75a9 149
jwalker366 0:09b7e6aa75a9 150 int MMA8452::isZReady() {
jwalker366 0:09b7e6aa75a9 151 return getMaskedRegister(MMA8452_STATUS,MMA8452_STATUS_ZDR_MASK)>0;
jwalker366 0:09b7e6aa75a9 152 }
jwalker366 0:09b7e6aa75a9 153
jwalker366 0:09b7e6aa75a9 154
jwalker366 0:09b7e6aa75a9 155 int MMA8452::getDeviceID(char *dst) {
jwalker366 0:09b7e6aa75a9 156 return readRegister(MMA8452_WHO_AM_I,dst);
jwalker366 0:09b7e6aa75a9 157 }
jwalker366 0:09b7e6aa75a9 158
jwalker366 0:09b7e6aa75a9 159 int MMA8452::getStatus(char* dst) {
jwalker366 0:09b7e6aa75a9 160 return readRegister(MMA8452_STATUS,dst);
jwalker366 0:09b7e6aa75a9 161 }
jwalker366 0:09b7e6aa75a9 162
jwalker366 0:09b7e6aa75a9 163 MMA8452::DynamicRange MMA8452::getDynamicRange() {
jwalker366 0:09b7e6aa75a9 164 char rval = 0;
jwalker366 0:09b7e6aa75a9 165 if(readRegister(MMA8452_XYZ_DATA_CFG,&rval)) {
jwalker366 0:09b7e6aa75a9 166 return MMA8452::DYNAMIC_RANGE_UNKNOWN;
jwalker366 0:09b7e6aa75a9 167 }
jwalker366 0:09b7e6aa75a9 168 rval &= (MMA8452_DYNAMIC_RANGE_MASK^0xFF);
jwalker366 0:09b7e6aa75a9 169 return (MMA8452::DynamicRange)rval;
jwalker366 0:09b7e6aa75a9 170 }
jwalker366 0:09b7e6aa75a9 171
jwalker366 0:09b7e6aa75a9 172 MMA8452::DataRateHz MMA8452::getDataRate() {
jwalker366 0:09b7e6aa75a9 173 char rval = 0;
jwalker366 0:09b7e6aa75a9 174 if(readRegister(MMA8452_CTRL_REG_1,&rval)) {
jwalker366 0:09b7e6aa75a9 175 return MMA8452::RATE_UNKNOWN;
jwalker366 0:09b7e6aa75a9 176 }
jwalker366 0:09b7e6aa75a9 177 // logical AND with inverse of mask
jwalker366 0:09b7e6aa75a9 178 rval = rval&(MMA8452_DATA_RATE_MASK^0xFF);
jwalker366 0:09b7e6aa75a9 179 // shift back into position
jwalker366 0:09b7e6aa75a9 180 rval >>= MMA8452_DATA_RATE_MASK_SHIFT;
jwalker366 0:09b7e6aa75a9 181 return (MMA8452::DataRateHz)rval;
jwalker366 0:09b7e6aa75a9 182 }
jwalker366 0:09b7e6aa75a9 183
jwalker366 0:09b7e6aa75a9 184 // Reads xyz
jwalker366 0:09b7e6aa75a9 185 int MMA8452::readXYZRaw(char *dst) {
jwalker366 0:09b7e6aa75a9 186 if(_bitDepth==BIT_DEPTH_UNKNOWN) {
jwalker366 0:09b7e6aa75a9 187 return 1;
jwalker366 0:09b7e6aa75a9 188 }
jwalker366 0:09b7e6aa75a9 189 int readLen = 3;
jwalker366 0:09b7e6aa75a9 190 if(_bitDepth==BIT_DEPTH_12) {
jwalker366 0:09b7e6aa75a9 191 readLen = 6;
jwalker366 0:09b7e6aa75a9 192 }
jwalker366 0:09b7e6aa75a9 193 return readRegister(MMA8452_OUT_X_MSB,dst,readLen);
jwalker366 0:09b7e6aa75a9 194 }
jwalker366 0:09b7e6aa75a9 195
jwalker366 0:09b7e6aa75a9 196 int MMA8452::readXRaw(char *dst) {
jwalker366 0:09b7e6aa75a9 197 if(_bitDepth==BIT_DEPTH_UNKNOWN) {
jwalker366 0:09b7e6aa75a9 198 return 1;
jwalker366 0:09b7e6aa75a9 199 }
jwalker366 0:09b7e6aa75a9 200 int readLen = 1;
jwalker366 0:09b7e6aa75a9 201 if(_bitDepth==BIT_DEPTH_12) {
jwalker366 0:09b7e6aa75a9 202 readLen = 2;
jwalker366 0:09b7e6aa75a9 203 }
jwalker366 0:09b7e6aa75a9 204 return readRegister(MMA8452_OUT_X_MSB,dst,readLen);
jwalker366 0:09b7e6aa75a9 205 }
jwalker366 0:09b7e6aa75a9 206
jwalker366 0:09b7e6aa75a9 207 int MMA8452::readYRaw(char *dst) {
jwalker366 0:09b7e6aa75a9 208 if(_bitDepth==BIT_DEPTH_UNKNOWN) {
jwalker366 0:09b7e6aa75a9 209 return 1;
jwalker366 0:09b7e6aa75a9 210 }
jwalker366 0:09b7e6aa75a9 211 int readLen = 1;
jwalker366 0:09b7e6aa75a9 212 if(_bitDepth==BIT_DEPTH_12) {
jwalker366 0:09b7e6aa75a9 213 readLen = 2;
jwalker366 0:09b7e6aa75a9 214 }
jwalker366 0:09b7e6aa75a9 215 return readRegister(MMA8452_OUT_Y_MSB,dst,readLen);
jwalker366 0:09b7e6aa75a9 216 }
jwalker366 0:09b7e6aa75a9 217
jwalker366 0:09b7e6aa75a9 218 int MMA8452::readZRaw(char *dst) {
jwalker366 0:09b7e6aa75a9 219 if(_bitDepth==BIT_DEPTH_UNKNOWN) {
jwalker366 0:09b7e6aa75a9 220 return 1;
jwalker366 0:09b7e6aa75a9 221 }
jwalker366 0:09b7e6aa75a9 222 int readLen = 1;
jwalker366 0:09b7e6aa75a9 223 if(_bitDepth==BIT_DEPTH_12) {
jwalker366 0:09b7e6aa75a9 224 readLen = 2;
jwalker366 0:09b7e6aa75a9 225 }
jwalker366 0:09b7e6aa75a9 226 return readRegister(MMA8452_OUT_Z_MSB,dst,readLen);
jwalker366 0:09b7e6aa75a9 227 }
jwalker366 0:09b7e6aa75a9 228
jwalker366 0:09b7e6aa75a9 229 int MMA8452::readXYZCounts(int *x, int *y, int *z) {
jwalker366 0:09b7e6aa75a9 230 char buf[6];
jwalker366 0:09b7e6aa75a9 231 if(readXYZRaw((char*)&buf)) {
jwalker366 0:09b7e6aa75a9 232 return 1;
jwalker366 0:09b7e6aa75a9 233 }
jwalker366 0:09b7e6aa75a9 234 if(_bitDepth==BIT_DEPTH_12) {
jwalker366 0:09b7e6aa75a9 235 *x = twelveBitToSigned(&buf[0]);
jwalker366 0:09b7e6aa75a9 236 *y = twelveBitToSigned(&buf[2]);
jwalker366 0:09b7e6aa75a9 237 *z = twelveBitToSigned(&buf[4]);
jwalker366 0:09b7e6aa75a9 238 } else {
jwalker366 0:09b7e6aa75a9 239 *x = eightBitToSigned(&buf[0]);
jwalker366 0:09b7e6aa75a9 240 *y = eightBitToSigned(&buf[1]);
jwalker366 0:09b7e6aa75a9 241 *z = eightBitToSigned(&buf[2]);
jwalker366 0:09b7e6aa75a9 242 }
jwalker366 0:09b7e6aa75a9 243
jwalker366 0:09b7e6aa75a9 244 return 0;
jwalker366 0:09b7e6aa75a9 245 }
jwalker366 0:09b7e6aa75a9 246
jwalker366 0:09b7e6aa75a9 247 int MMA8452::readXCount(int *x) {
jwalker366 0:09b7e6aa75a9 248 char buf[2];
jwalker366 0:09b7e6aa75a9 249 if(readXRaw((char*)&buf)) {
jwalker366 0:09b7e6aa75a9 250 return 1;
jwalker366 0:09b7e6aa75a9 251 }
jwalker366 0:09b7e6aa75a9 252 if(_bitDepth==BIT_DEPTH_12) {
jwalker366 0:09b7e6aa75a9 253 *x = twelveBitToSigned(&buf[0]);
jwalker366 0:09b7e6aa75a9 254 } else {
jwalker366 0:09b7e6aa75a9 255 *x = eightBitToSigned(&buf[0]);
jwalker366 0:09b7e6aa75a9 256 }
jwalker366 0:09b7e6aa75a9 257 return 0;
jwalker366 0:09b7e6aa75a9 258 }
jwalker366 0:09b7e6aa75a9 259
jwalker366 0:09b7e6aa75a9 260 int MMA8452::readYCount(int *y) {
jwalker366 0:09b7e6aa75a9 261 char buf[2];
jwalker366 0:09b7e6aa75a9 262 if(readYRaw((char*)&buf)) {
jwalker366 0:09b7e6aa75a9 263 return 1;
jwalker366 0:09b7e6aa75a9 264 }
jwalker366 0:09b7e6aa75a9 265 if(_bitDepth==BIT_DEPTH_12) {
jwalker366 0:09b7e6aa75a9 266 *y = twelveBitToSigned(&buf[0]);
jwalker366 0:09b7e6aa75a9 267 } else {
jwalker366 0:09b7e6aa75a9 268 *y = eightBitToSigned(&buf[0]);
jwalker366 0:09b7e6aa75a9 269 }
jwalker366 0:09b7e6aa75a9 270 return 0;
jwalker366 0:09b7e6aa75a9 271 }
jwalker366 0:09b7e6aa75a9 272
jwalker366 0:09b7e6aa75a9 273 int MMA8452::readZCount(int *z) {
jwalker366 0:09b7e6aa75a9 274 char buf[2];
jwalker366 0:09b7e6aa75a9 275 if(readZRaw((char*)&buf)) {
jwalker366 0:09b7e6aa75a9 276 return 1;
jwalker366 0:09b7e6aa75a9 277 }
jwalker366 0:09b7e6aa75a9 278 if(_bitDepth==BIT_DEPTH_12) {
jwalker366 0:09b7e6aa75a9 279 *z = twelveBitToSigned(&buf[0]);
jwalker366 0:09b7e6aa75a9 280 } else {
jwalker366 0:09b7e6aa75a9 281 *z = eightBitToSigned(&buf[0]);
jwalker366 0:09b7e6aa75a9 282 }
jwalker366 0:09b7e6aa75a9 283 return 0;
jwalker366 0:09b7e6aa75a9 284 }
jwalker366 0:09b7e6aa75a9 285
jwalker366 0:09b7e6aa75a9 286 double MMA8452::convertCountToGravity(int count, int countsPerG) {
jwalker366 0:09b7e6aa75a9 287 return (double)count/(double)countsPerG;
jwalker366 0:09b7e6aa75a9 288 }
jwalker366 0:09b7e6aa75a9 289
jwalker366 0:09b7e6aa75a9 290 int MMA8452::getCountsPerG() {
jwalker366 0:09b7e6aa75a9 291 // assume starting with DYNAMIC_RANGE_2G and BIT_DEPTH_12
jwalker366 0:09b7e6aa75a9 292 int countsPerG = 1024;
jwalker366 0:09b7e6aa75a9 293 if(_bitDepth==BIT_DEPTH_8) {
jwalker366 0:09b7e6aa75a9 294 countsPerG = 64;
jwalker366 0:09b7e6aa75a9 295 }
jwalker366 0:09b7e6aa75a9 296 switch(_dynamicRange) {
jwalker366 0:09b7e6aa75a9 297 case DYNAMIC_RANGE_4G:
jwalker366 0:09b7e6aa75a9 298 countsPerG /= 2;
jwalker366 0:09b7e6aa75a9 299 break;
jwalker366 0:09b7e6aa75a9 300 case DYNAMIC_RANGE_8G:
jwalker366 0:09b7e6aa75a9 301 countsPerG /= 4;
jwalker366 0:09b7e6aa75a9 302 break;
jwalker366 0:09b7e6aa75a9 303 }
jwalker366 0:09b7e6aa75a9 304 return countsPerG;
jwalker366 0:09b7e6aa75a9 305 }
jwalker366 0:09b7e6aa75a9 306
jwalker366 0:09b7e6aa75a9 307 int MMA8452::readXYZGravity(double *x, double *y, double *z) {
jwalker366 0:09b7e6aa75a9 308 int xCount = 0, yCount = 0, zCount = 0;
jwalker366 0:09b7e6aa75a9 309 if(readXYZCounts(&xCount,&yCount,&zCount)) {
jwalker366 0:09b7e6aa75a9 310 return 1;
jwalker366 0:09b7e6aa75a9 311 }
jwalker366 0:09b7e6aa75a9 312 int countsPerG = getCountsPerG();
jwalker366 0:09b7e6aa75a9 313
jwalker366 0:09b7e6aa75a9 314 *x = convertCountToGravity(xCount,countsPerG);
jwalker366 0:09b7e6aa75a9 315 *y = convertCountToGravity(yCount,countsPerG);
jwalker366 0:09b7e6aa75a9 316 *z = convertCountToGravity(zCount,countsPerG);
jwalker366 0:09b7e6aa75a9 317 return 0;
jwalker366 0:09b7e6aa75a9 318 }
jwalker366 0:09b7e6aa75a9 319
jwalker366 0:09b7e6aa75a9 320 int MMA8452::readXGravity(double *x) {
jwalker366 0:09b7e6aa75a9 321 int xCount = 0;
jwalker366 0:09b7e6aa75a9 322 if(readXCount(&xCount)) {
jwalker366 0:09b7e6aa75a9 323 return 1;
jwalker366 0:09b7e6aa75a9 324 }
jwalker366 0:09b7e6aa75a9 325 int countsPerG = getCountsPerG();
jwalker366 0:09b7e6aa75a9 326
jwalker366 0:09b7e6aa75a9 327 *x = convertCountToGravity(xCount,countsPerG);
jwalker366 0:09b7e6aa75a9 328 return 0;
jwalker366 0:09b7e6aa75a9 329 }
jwalker366 0:09b7e6aa75a9 330
jwalker366 0:09b7e6aa75a9 331 int MMA8452::readYGravity(double *y) {
jwalker366 0:09b7e6aa75a9 332 int yCount = 0;
jwalker366 0:09b7e6aa75a9 333 if(readYCount(&yCount)) {
jwalker366 0:09b7e6aa75a9 334 return 1;
jwalker366 0:09b7e6aa75a9 335 }
jwalker366 0:09b7e6aa75a9 336 int countsPerG = getCountsPerG();
jwalker366 0:09b7e6aa75a9 337
jwalker366 0:09b7e6aa75a9 338 *y = convertCountToGravity(yCount,countsPerG);
jwalker366 0:09b7e6aa75a9 339 return 0;
jwalker366 0:09b7e6aa75a9 340 }
jwalker366 0:09b7e6aa75a9 341
jwalker366 0:09b7e6aa75a9 342 int MMA8452::readZGravity(double *z) {
jwalker366 0:09b7e6aa75a9 343 int zCount = 0;
jwalker366 0:09b7e6aa75a9 344 if(readZCount(&zCount)) {
jwalker366 0:09b7e6aa75a9 345 return 1;
jwalker366 0:09b7e6aa75a9 346 }
jwalker366 0:09b7e6aa75a9 347 int countsPerG = getCountsPerG();
jwalker366 0:09b7e6aa75a9 348
jwalker366 0:09b7e6aa75a9 349 *z = convertCountToGravity(zCount,countsPerG);
jwalker366 0:09b7e6aa75a9 350 return 0;
jwalker366 0:09b7e6aa75a9 351 }
jwalker366 0:09b7e6aa75a9 352
jwalker366 0:09b7e6aa75a9 353 // apply an AND mask to a register. read register value, apply mask, write it back
jwalker366 0:09b7e6aa75a9 354 int MMA8452::logicalANDRegister(char addr, char mask) {
jwalker366 0:09b7e6aa75a9 355 char value = 0;
jwalker366 0:09b7e6aa75a9 356 // read register value
jwalker366 0:09b7e6aa75a9 357 if(readRegister(addr,&value)) {
jwalker366 0:09b7e6aa75a9 358 return 0;
jwalker366 0:09b7e6aa75a9 359 }
jwalker366 0:09b7e6aa75a9 360 // apply mask
jwalker366 0:09b7e6aa75a9 361 value &= mask;
jwalker366 0:09b7e6aa75a9 362 return writeRegister(addr,value);
jwalker366 0:09b7e6aa75a9 363 }
jwalker366 0:09b7e6aa75a9 364
jwalker366 0:09b7e6aa75a9 365
jwalker366 0:09b7e6aa75a9 366 // apply an OR mask to a register. read register value, apply mask, write it back
jwalker366 0:09b7e6aa75a9 367 int MMA8452::logicalORRegister(char addr, char mask) {
jwalker366 0:09b7e6aa75a9 368 char value = 0;
jwalker366 0:09b7e6aa75a9 369 // read register value
jwalker366 0:09b7e6aa75a9 370 if(readRegister(addr,&value)) {
jwalker366 0:09b7e6aa75a9 371 return 0;
jwalker366 0:09b7e6aa75a9 372 }
jwalker366 0:09b7e6aa75a9 373 // apply mask
jwalker366 0:09b7e6aa75a9 374 value |= mask;
jwalker366 0:09b7e6aa75a9 375 return writeRegister(addr,value);
jwalker366 0:09b7e6aa75a9 376 }
jwalker366 0:09b7e6aa75a9 377
jwalker366 0:09b7e6aa75a9 378 // apply an OR mask to a register. read register value, apply mask, write it back
jwalker366 0:09b7e6aa75a9 379 int MMA8452::logicalXORRegister(char addr, char mask) {
jwalker366 0:09b7e6aa75a9 380 char value = 0;
jwalker366 0:09b7e6aa75a9 381 // read register value
jwalker366 0:09b7e6aa75a9 382 if(readRegister(addr,&value)) {
jwalker366 0:09b7e6aa75a9 383 return 0;
jwalker366 0:09b7e6aa75a9 384 }
jwalker366 0:09b7e6aa75a9 385 // apply mask
jwalker366 0:09b7e6aa75a9 386 value ^= mask;
jwalker366 0:09b7e6aa75a9 387 return writeRegister(addr,value);
jwalker366 0:09b7e6aa75a9 388 }
jwalker366 0:09b7e6aa75a9 389
jwalker366 0:09b7e6aa75a9 390 // Write register (The device must be placed in Standby Mode to change the value of the registers)
jwalker366 0:09b7e6aa75a9 391 int MMA8452::writeRegister(char addr, char data) {
jwalker366 0:09b7e6aa75a9 392 // what this actually does is the following
jwalker366 0:09b7e6aa75a9 393 // 1. tell I2C bus to start transaction
jwalker366 0:09b7e6aa75a9 394 // 2. tell slave we want to write (slave address & write flag)
jwalker366 0:09b7e6aa75a9 395 // 3. send the write address
jwalker366 0:09b7e6aa75a9 396 // 4. send the data to write
jwalker366 0:09b7e6aa75a9 397 // 5. tell I2C bus to end transaction
jwalker366 0:09b7e6aa75a9 398
jwalker366 0:09b7e6aa75a9 399 // we can wrap this up in the I2C library write function
jwalker366 0:09b7e6aa75a9 400 char buf[2] = {0,0};
jwalker366 0:09b7e6aa75a9 401 buf[0] = addr;
jwalker366 0:09b7e6aa75a9 402 buf[1] = data;
jwalker366 0:09b7e6aa75a9 403 return _i2c.write(MMA8452_ADDRESS, buf,2);
jwalker366 0:09b7e6aa75a9 404 // note, could also do return writeRegister(addr,&data,1);
jwalker366 0:09b7e6aa75a9 405 }
jwalker366 0:09b7e6aa75a9 406
jwalker366 0:09b7e6aa75a9 407 int MMA8452::eightBitToSigned(char *buf) {
jwalker366 0:09b7e6aa75a9 408 return (int8_t)*buf;
jwalker366 0:09b7e6aa75a9 409 }
jwalker366 0:09b7e6aa75a9 410
jwalker366 0:09b7e6aa75a9 411 int MMA8452::twelveBitToSigned(char *buf) {
jwalker366 0:09b7e6aa75a9 412 // cheat by using the int16_t internal type
jwalker366 0:09b7e6aa75a9 413 // all we need to do is convert to little-endian format and shift right
jwalker366 0:09b7e6aa75a9 414 int16_t x = 0;
jwalker366 0:09b7e6aa75a9 415 ((char*)&x)[1] = buf[0];
jwalker366 0:09b7e6aa75a9 416 ((char*)&x)[0] = buf[1];
jwalker366 0:09b7e6aa75a9 417 // note this only works because the below is an arithmetic right shift
jwalker366 0:09b7e6aa75a9 418 return x>>4;
jwalker366 0:09b7e6aa75a9 419 }
jwalker366 0:09b7e6aa75a9 420
jwalker366 0:09b7e6aa75a9 421 int MMA8452::writeRegister(char addr, char *data, int nbytes) {
jwalker366 0:09b7e6aa75a9 422 // writing multiple bytes is a little bit annoying because
jwalker366 0:09b7e6aa75a9 423 // the I2C library doesn't support sending the address separately
jwalker366 0:09b7e6aa75a9 424 // so we just do it manually
jwalker366 0:09b7e6aa75a9 425
jwalker366 0:09b7e6aa75a9 426 // 1. tell I2C bus to start transaction
jwalker366 0:09b7e6aa75a9 427 _i2c.start();
jwalker366 0:09b7e6aa75a9 428 // 2. tell slave we want to write (slave address & write flag)
jwalker366 0:09b7e6aa75a9 429 if(_i2c.write(_writeAddress)!=1) {
jwalker366 0:09b7e6aa75a9 430 return 1;
jwalker366 0:09b7e6aa75a9 431 }
jwalker366 0:09b7e6aa75a9 432 // 3. send the write address
jwalker366 0:09b7e6aa75a9 433 if(_i2c.write(addr)!=1) {
jwalker366 0:09b7e6aa75a9 434 return 1;
jwalker366 0:09b7e6aa75a9 435 }
jwalker366 0:09b7e6aa75a9 436 // 4. send the data to write
jwalker366 0:09b7e6aa75a9 437 for(int i=0; i<nbytes; i++) {
jwalker366 0:09b7e6aa75a9 438 if(_i2c.write(data[i])!=1) {
jwalker366 0:09b7e6aa75a9 439 return 1;
jwalker366 0:09b7e6aa75a9 440 }
jwalker366 0:09b7e6aa75a9 441 }
jwalker366 0:09b7e6aa75a9 442 // 5. tell I2C bus to end transaction
jwalker366 0:09b7e6aa75a9 443 _i2c.stop();
jwalker366 0:09b7e6aa75a9 444 return 0;
jwalker366 0:09b7e6aa75a9 445 }
jwalker366 0:09b7e6aa75a9 446
jwalker366 0:09b7e6aa75a9 447 int MMA8452::readRegister(char addr, char *dst, int nbytes) {
jwalker366 0:09b7e6aa75a9 448 // this is a bit odd, but basically proceeds like this
jwalker366 0:09b7e6aa75a9 449 // 1. Send a start command
jwalker366 0:09b7e6aa75a9 450 // 2. Tell the slave we want to write (slave address & write flag)
jwalker366 0:09b7e6aa75a9 451 // 3. Send the address of the register (addr)
jwalker366 0:09b7e6aa75a9 452 // 4. Send another start command to delineate read portion
jwalker366 0:09b7e6aa75a9 453 // 5. Tell the slave we want to read (slave address & read flag)
jwalker366 0:09b7e6aa75a9 454 // 6. Read the register value bytes
jwalker366 0:09b7e6aa75a9 455 // 7. Send a stop command
jwalker366 0:09b7e6aa75a9 456
jwalker366 0:09b7e6aa75a9 457 // we can wrap this process in the I2C library read and write commands
jwalker366 0:09b7e6aa75a9 458 if(_i2c.write(MMA8452_ADDRESS,&addr,1,true)) {
jwalker366 0:09b7e6aa75a9 459 return 1;
jwalker366 0:09b7e6aa75a9 460 }
jwalker366 0:09b7e6aa75a9 461 return _i2c.read(MMA8452_ADDRESS,dst,nbytes);
jwalker366 0:09b7e6aa75a9 462 }
jwalker366 0:09b7e6aa75a9 463
jwalker366 0:09b7e6aa75a9 464 // most registers are 1 byte, so here is a convenience function
jwalker366 0:09b7e6aa75a9 465 int MMA8452::readRegister(char addr, char *dst) {
jwalker366 0:09b7e6aa75a9 466 return readRegister(addr,dst,1);
jwalker366 0:09b7e6aa75a9 467 }
jwalker366 0:09b7e6aa75a9 468
jwalker366 0:09b7e6aa75a9 469 MMA8452::BitDepth MMA8452::getBitDepth() {
jwalker366 0:09b7e6aa75a9 470 return _bitDepth;
jwalker366 0:09b7e6aa75a9 471 }
jwalker366 0:09b7e6aa75a9 472
jwalker366 0:09b7e6aa75a9 473 #ifdef MMA8452_DEBUG
jwalker366 0:09b7e6aa75a9 474 void MMA8452::debugRegister(char reg) {
jwalker366 0:09b7e6aa75a9 475 // get register value
jwalker366 0:09b7e6aa75a9 476 char v = 0;
jwalker366 0:09b7e6aa75a9 477 if(readRegister(reg,&v)) {
jwalker366 0:09b7e6aa75a9 478 MMA8452_DBG("Error reading specified register");
jwalker366 0:09b7e6aa75a9 479 return;
jwalker366 0:09b7e6aa75a9 480 }
jwalker366 0:09b7e6aa75a9 481 // print out details
jwalker366 0:09b7e6aa75a9 482 switch(reg) {
jwalker366 0:09b7e6aa75a9 483 case MMA8452_CTRL_REG_1:
jwalker366 0:09b7e6aa75a9 484 MMA8452_DBG("CTRL_REG_1 has value: 0x%x",v);
jwalker366 0:09b7e6aa75a9 485 MMA8452_DBG(" 7 ALSP_RATE_1: %d",(v&0x80)>>7);
jwalker366 0:09b7e6aa75a9 486 MMA8452_DBG(" 6 ALSP_RATE_0: %d",(v&0x40)>>6);
jwalker366 0:09b7e6aa75a9 487 MMA8452_DBG(" 5 DR2: %d", (v&0x20)>>5);
jwalker366 0:09b7e6aa75a9 488 MMA8452_DBG(" 4 DR1: %d", (v&0x10)>>4);
jwalker366 0:09b7e6aa75a9 489 MMA8452_DBG(" 3 DR0: %d", (v&0x08)>>3);
jwalker366 0:09b7e6aa75a9 490 MMA8452_DBG(" 2 LNOISE: %d", (v&0x04)>>2);
jwalker366 0:09b7e6aa75a9 491 MMA8452_DBG(" 1 FREAD: %d", (v&0x02)>>1);
jwalker366 0:09b7e6aa75a9 492 MMA8452_DBG(" 0 ACTIVE: %d", (v&0x01));
jwalker366 0:09b7e6aa75a9 493 break;
jwalker366 0:09b7e6aa75a9 494
jwalker366 0:09b7e6aa75a9 495 case MMA8452_XYZ_DATA_CFG:
jwalker366 0:09b7e6aa75a9 496 MMA8452_DBG("XYZ_DATA_CFG has value: 0x%x",v);
jwalker366 0:09b7e6aa75a9 497 MMA8452_DBG(" 7 Unused: %d", (v&0x80)>>7);
jwalker366 0:09b7e6aa75a9 498 MMA8452_DBG(" 6 0: %d", (v&0x40)>>6);
jwalker366 0:09b7e6aa75a9 499 MMA8452_DBG(" 5 0: %d", (v&0x20)>>5);
jwalker366 0:09b7e6aa75a9 500 MMA8452_DBG(" 4 HPF_Out: %d",(v&0x10)>>4);
jwalker366 0:09b7e6aa75a9 501 MMA8452_DBG(" 3 0: %d", (v&0x08)>>3);
jwalker366 0:09b7e6aa75a9 502 MMA8452_DBG(" 2 0: %d", (v&0x04)>>2);
jwalker366 0:09b7e6aa75a9 503 MMA8452_DBG(" 1 FS1: %d", (v&0x02)>>1);
jwalker366 0:09b7e6aa75a9 504 MMA8452_DBG(" 0 FS0: %d", (v&0x01));
jwalker366 0:09b7e6aa75a9 505 switch(v&0x03) {
jwalker366 0:09b7e6aa75a9 506 case 0:
jwalker366 0:09b7e6aa75a9 507 MMA8452_DBG("Dynamic range: 2G");
jwalker366 0:09b7e6aa75a9 508 break;
jwalker366 0:09b7e6aa75a9 509 case 1:
jwalker366 0:09b7e6aa75a9 510 MMA8452_DBG("Dynamic range: 4G");
jwalker366 0:09b7e6aa75a9 511 break;
jwalker366 0:09b7e6aa75a9 512 case 2:
jwalker366 0:09b7e6aa75a9 513 MMA8452_DBG("Dynamic range: 8G");
jwalker366 0:09b7e6aa75a9 514 break;
jwalker366 0:09b7e6aa75a9 515 default:
jwalker366 0:09b7e6aa75a9 516 MMA8452_DBG("Unknown dynamic range");
jwalker366 0:09b7e6aa75a9 517 break;
jwalker366 0:09b7e6aa75a9 518 }
jwalker366 0:09b7e6aa75a9 519 break;
jwalker366 0:09b7e6aa75a9 520
jwalker366 0:09b7e6aa75a9 521 case MMA8452_STATUS:
jwalker366 0:09b7e6aa75a9 522 MMA8452_DBG("STATUS has value: 0x%x",v);
jwalker366 0:09b7e6aa75a9 523 MMA8452_DBG(" 7 ZYXOW: %d",(v&0x80)>>7);
jwalker366 0:09b7e6aa75a9 524 MMA8452_DBG(" 6 ZOW: %d", (v&0x40)>>6);
jwalker366 0:09b7e6aa75a9 525 MMA8452_DBG(" 5 YOW: %d", (v&0x20)>>5);
jwalker366 0:09b7e6aa75a9 526 MMA8452_DBG(" 4 XOW: %d", (v&0x10)>>4);
jwalker366 0:09b7e6aa75a9 527 MMA8452_DBG(" 3 ZYXDR: %d",(v&0x08)>>3);
jwalker366 0:09b7e6aa75a9 528 MMA8452_DBG(" 2 ZDR: %d", (v&0x04)>>2);
jwalker366 0:09b7e6aa75a9 529 MMA8452_DBG(" 1 YDR: %d", (v&0x02)>>1);
jwalker366 0:09b7e6aa75a9 530 MMA8452_DBG(" 0 XDR: %d", (v&0x01));
jwalker366 0:09b7e6aa75a9 531 break;
jwalker366 0:09b7e6aa75a9 532
jwalker366 0:09b7e6aa75a9 533 default:
jwalker366 0:09b7e6aa75a9 534 MMA8452_DBG("Unknown register address: 0x%x",reg);
jwalker366 0:09b7e6aa75a9 535 break;
jwalker366 0:09b7e6aa75a9 536 }
jwalker366 0:09b7e6aa75a9 537 }
jwalker366 0:09b7e6aa75a9 538 #endif