yanay nevela / MMA8452

Works with 8g

Fork of MMA8452 by Ashley Mills

MMA8452.cpp@8:89272163f395, 2013-10-17 (annotated)

Committer:
ashleymills
Date:
Thu Oct 17 10:08:51 2013 +0000
Revision:
8:89272163f395
Parent:
7:8aa5123d403f
Parent:
6:f6bde04bf8be
Child:
9:dfb0f6a7a455
made some simplifications

Who changed what in which revision?

UserRevisionLine numberNew contents of line
nherriot 0:bcf2aa85d7f9 1 // Author: Nicholas Herriot
nherriot 0:bcf2aa85d7f9 2 /* Copyright (c) 2013 Vodafone, MIT License
nherriot 0:bcf2aa85d7f9 3 *
nherriot 0:bcf2aa85d7f9 4 * Permission is hereby granted, free of charge, to any person obtaining a copy of this software
nherriot 0:bcf2aa85d7f9 5 * and associated documentation files (the "Software"), to deal in the Software without restriction,
nherriot 0:bcf2aa85d7f9 6 * including without limitation the rights to use, copy, modify, merge, publish, distribute,
nherriot 0:bcf2aa85d7f9 7 * sublicense, and/or sell copies of the Software, and to permit persons to whom the Software is
nherriot 0:bcf2aa85d7f9 8 * furnished to do so, subject to the following conditions:
nherriot 0:bcf2aa85d7f9 9 *
nherriot 0:bcf2aa85d7f9 10 * The above copyright notice and this permission notice shall be included in all copies or
nherriot 0:bcf2aa85d7f9 11 * substantial portions of the Software.
nherriot 0:bcf2aa85d7f9 12 *
nherriot 0:bcf2aa85d7f9 13 * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR IMPLIED, INCLUDING
nherriot 0:bcf2aa85d7f9 14 * BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
nherriot 0:bcf2aa85d7f9 15 * NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM,
nherriot 0:bcf2aa85d7f9 16 * DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
nherriot 0:bcf2aa85d7f9 17 * OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
nherriot 0:bcf2aa85d7f9 18 */
nherriot 0:bcf2aa85d7f9 19
nherriot 0:bcf2aa85d7f9 20 # include "MMA8452.h"
nherriot 0:bcf2aa85d7f9 21
nherriot 0:bcf2aa85d7f9 22 // Connect module at I2C address using I2C port pins sda and scl
nherriot 1:ef026bf28798 23 Accelerometer_MMA8452::Accelerometer_MMA8452(PinName sda, PinName scl,int frequency) : m_i2c(sda, scl) , m_frequency(frequency)
nherriot 0:bcf2aa85d7f9 24 {
nherriot 0:bcf2aa85d7f9 25 //m_i2c.frequency(m_frequency);
ashleymills 6:f6bde04bf8be 26
ashleymills 6:f6bde04bf8be 27 // setup read and write addresses to avoid duplication
ashleymills 6:f6bde04bf8be 28 _readAddress = (MMA8452_ADDRESS<<1) | 0x01;
ashleymills 6:f6bde04bf8be 29 _writeAddress = (MMA8452_ADDRESS<<1) & 0xFE;
nherriot 0:bcf2aa85d7f9 30 }
nherriot 0:bcf2aa85d7f9 31
nherriot 0:bcf2aa85d7f9 32
nherriot 0:bcf2aa85d7f9 33 // Destroys instance
ashleymills 6:f6bde04bf8be 34 Accelerometer_MMA8452::~Accelerometer_MMA8452()
nherriot 0:bcf2aa85d7f9 35 {
nherriot 0:bcf2aa85d7f9 36
nherriot 0:bcf2aa85d7f9 37 }
nherriot 0:bcf2aa85d7f9 38
nherriot 0:bcf2aa85d7f9 39 // Setting the control register bit 1 to true to activate the MMA8452
nherriot 0:bcf2aa85d7f9 40 int Accelerometer_MMA8452::activate()
nherriot 0:bcf2aa85d7f9 41 {
ashleymills 6:f6bde04bf8be 42 // set control register 1 to active
ashleymills 6:f6bde04bf8be 43 char init[2] = {CTRL_REG_1,ACTIVE};
nherriot 3:ffb0b1650ca2 44
ashleymills 6:f6bde04bf8be 45 // perform write and return error code
ashleymills 6:f6bde04bf8be 46 return m_i2c.write(_writeAddress,init,2);
nherriot 3:ffb0b1650ca2 47 }
nherriot 3:ffb0b1650ca2 48
nherriot 3:ffb0b1650ca2 49
nherriot 5:b3d0abd97e55 50 // Get 'Fast Read Mode' called F_READ. If bit 1 is set '1' then F_READ is active. Fast read will skip LSB when reading xyz
nherriot 5:b3d0abd97e55 51 // resisters from 0x01 to 0x06. When F_READ is '0' then all 6 registers will be read.
nherriot 5:b3d0abd97e55 52
ashleymills 6:f6bde04bf8be 53 int Accelerometer_MMA8452::get_CTRL_Reg1(int* CTRL_Reg)
nherriot 5:b3d0abd97e55 54 {
nherriot 5:b3d0abd97e55 55 m_i2c.start();
ashleymills 6:f6bde04bf8be 56 if( m_i2c.write(_writeAddress) == 0)
nherriot 5:b3d0abd97e55 57 {
ashleymills 8:89272163f395 58 return 1; // we failed to write the mcu address on the bus to initiate dialogue
nherriot 5:b3d0abd97e55 59 }
nherriot 5:b3d0abd97e55 60 if( m_i2c.write( CTRL_REG_1) == 0)
nherriot 5:b3d0abd97e55 61 {
nherriot 5:b3d0abd97e55 62 return 1; // we failed to write 'status' to the chip
nherriot 5:b3d0abd97e55 63 }
nherriot 5:b3d0abd97e55 64 m_i2c.start();
ashleymills 8:89272163f395 65 if( m_i2c.write(_readAddress) == 0) // this is asking to read the slave mcu address - even though it's a 'write' method!!! Crap API...
nherriot 5:b3d0abd97e55 66 {
nherriot 5:b3d0abd97e55 67 return 1; // we failed to request a read from that mcu - this really is just writing the mcu vaule on the bus
nherriot 5:b3d0abd97e55 68 }
ashleymills 6:f6bde04bf8be 69 *CTRL_Reg = m_i2c.read(0);
nherriot 5:b3d0abd97e55 70 m_i2c.stop();
nherriot 5:b3d0abd97e55 71 return 0;
nherriot 5:b3d0abd97e55 72 }
nherriot 5:b3d0abd97e55 73
nherriot 3:ffb0b1650ca2 74 // Setting the control register bit 1 to true to activate the MMA8452
nherriot 3:ffb0b1650ca2 75 int Accelerometer_MMA8452::standby()
nherriot 3:ffb0b1650ca2 76 {
ashleymills 8:89272163f395 77 // set control register 1 to standby
ashleymills 8:89272163f395 78 char init[2] = {CTRL_REG_1,STANDBY};
nherriot 1:ef026bf28798 79
ashleymills 8:89272163f395 80 // write to the register and return the error code
ashleymills 8:89272163f395 81 return m_i2c.write(_writeAddress,init,2);
nherriot 0:bcf2aa85d7f9 82 }
nherriot 0:bcf2aa85d7f9 83
nherriot 0:bcf2aa85d7f9 84
nherriot 3:ffb0b1650ca2 85
nherriot 0:bcf2aa85d7f9 86 // Device initialization
nherriot 0:bcf2aa85d7f9 87 void Accelerometer_MMA8452::init()
nherriot 0:bcf2aa85d7f9 88 {
nherriot 0:bcf2aa85d7f9 89
nherriot 0:bcf2aa85d7f9 90 write_reg(INTSU_STATUS, 0x10); // automatic interrupt after every measurement
nherriot 0:bcf2aa85d7f9 91 write_reg(SR_STATUS, 0x00); // 120 Samples/Second
nherriot 0:bcf2aa85d7f9 92 write_reg(MODE_STATUS, 0x01); // Active Mode
nherriot 0:bcf2aa85d7f9 93
nherriot 0:bcf2aa85d7f9 94 }
nherriot 0:bcf2aa85d7f9 95
nherriot 3:ffb0b1650ca2 96 // Get real time status of device - it can be STANDBY, WAKE or SLEEP
nherriot 3:ffb0b1650ca2 97 int Accelerometer_MMA8452::get_SystemMode(int& deviceSystemMode)
nherriot 3:ffb0b1650ca2 98 {
nherriot 3:ffb0b1650ca2 99 m_i2c.start();
ashleymills 8:89272163f395 100 if( m_i2c.write(_writeAddress) == 0)
nherriot 3:ffb0b1650ca2 101 {
nherriot 3:ffb0b1650ca2 102 return 1; // we failed to write the mcu address on the bus to initiate dialogue
nherriot 3:ffb0b1650ca2 103 }
nherriot 3:ffb0b1650ca2 104 if( m_i2c.write( SYSMOD) == 0)
nherriot 3:ffb0b1650ca2 105 {
nherriot 3:ffb0b1650ca2 106 return 1; // we failed to write 'status' to the chip
nherriot 3:ffb0b1650ca2 107 }
nherriot 3:ffb0b1650ca2 108 m_i2c.start();
ashleymills 8:89272163f395 109 if( m_i2c.write(_readAddress) == 0) // this is asking to read the slave mcu address - even though it's a 'write' method!!! Crap API...
nherriot 3:ffb0b1650ca2 110 {
nherriot 3:ffb0b1650ca2 111 return 1; // we failed to request a read from that mcu - this really is just writing the mcu vaule on the bus
nherriot 3:ffb0b1650ca2 112 }
nherriot 3:ffb0b1650ca2 113 deviceSystemMode = m_i2c.read(0);
nherriot 3:ffb0b1650ca2 114 m_i2c.stop();
nherriot 3:ffb0b1650ca2 115 return 0;
nherriot 3:ffb0b1650ca2 116
nherriot 3:ffb0b1650ca2 117
nherriot 3:ffb0b1650ca2 118 }
nherriot 3:ffb0b1650ca2 119
nherriot 3:ffb0b1650ca2 120
nherriot 3:ffb0b1650ca2 121
nherriot 3:ffb0b1650ca2 122 // Get real time status of device - it can be STANDBY, WAKE or SLEEP
nherriot 3:ffb0b1650ca2 123 int Accelerometer_MMA8452::get_Status(int& deviceStatus)
nherriot 3:ffb0b1650ca2 124 {
nherriot 3:ffb0b1650ca2 125 m_i2c.start();
ashleymills 8:89272163f395 126 if( m_i2c.write(_writeAddress) == 0) // tell the bus this is a write
nherriot 3:ffb0b1650ca2 127 {
nherriot 3:ffb0b1650ca2 128 return 1; // we failed to write the mcu address on the bus to initiate dialogue
nherriot 3:ffb0b1650ca2 129 }
ashleymills 8:89272163f395 130 if( m_i2c.write(STATUS) == 0)
nherriot 3:ffb0b1650ca2 131 {
nherriot 3:ffb0b1650ca2 132 return 1; // we failed to write 'status' to the chip
nherriot 3:ffb0b1650ca2 133 }
nherriot 3:ffb0b1650ca2 134 m_i2c.start();
ashleymills 8:89272163f395 135 if( m_i2c.write(_readAddress) == 0) // this is asking to read the slave mcu address - even though it's a 'write' method!!! Crap API...
nherriot 3:ffb0b1650ca2 136 {
nherriot 3:ffb0b1650ca2 137 return 1; // we failed to request a read from that mcu - this really is just writing the mcu vaule on the bus
nherriot 3:ffb0b1650ca2 138 }
nherriot 3:ffb0b1650ca2 139 deviceStatus = m_i2c.read(0);
nherriot 3:ffb0b1650ca2 140 m_i2c.stop();
nherriot 3:ffb0b1650ca2 141 return 0;
nherriot 3:ffb0b1650ca2 142
nherriot 3:ffb0b1650ca2 143
nherriot 3:ffb0b1650ca2 144 }
nherriot 3:ffb0b1650ca2 145
nherriot 0:bcf2aa85d7f9 146
nherriot 1:ef026bf28798 147 // Get device ID
nherriot 2:66db0f91b215 148 int Accelerometer_MMA8452::get_DeviceID(int& deviceID)
nherriot 1:ef026bf28798 149 {
nherriot 1:ef026bf28798 150 m_i2c.start();
ashleymills 8:89272163f395 151 if( m_i2c.write(_writeAddress) == 0) // just good practice to force bit 1 to a '0' by ANDing with 0xFE
nherriot 1:ef026bf28798 152 {
nherriot 3:ffb0b1650ca2 153 return 1; // we failed to write the mcu address on the bus to initiate dialogue
nherriot 1:ef026bf28798 154 }
nherriot 1:ef026bf28798 155 if( m_i2c.write( WHO_AM_I) == 0)
nherriot 1:ef026bf28798 156 {
nherriot 3:ffb0b1650ca2 157 return 1; // we failed to write 'who am i' to the chip
nherriot 1:ef026bf28798 158 }
nherriot 1:ef026bf28798 159 m_i2c.start();
ashleymills 8:89272163f395 160 if( m_i2c.write(_readAddress) == 0) // this is asking to read the slave mcu address - even though it's a 'write' method!!! Crap API...
nherriot 1:ef026bf28798 161 {
nherriot 3:ffb0b1650ca2 162 return 1; // we failed to request a read from that mcu - this really is just writing the mcu vaule on the bus
nherriot 1:ef026bf28798 163 }
nherriot 2:66db0f91b215 164 deviceID = m_i2c.read(0);
nherriot 1:ef026bf28798 165 m_i2c.stop();
nherriot 1:ef026bf28798 166 return 0;
nherriot 1:ef026bf28798 167
nherriot 1:ef026bf28798 168 }
nherriot 1:ef026bf28798 169
nherriot 1:ef026bf28798 170
nherriot 3:ffb0b1650ca2 171 /*
nherriot 3:ffb0b1650ca2 172 // Reads x data
nherriot 3:ffb0b1650ca2 173 int Accelerometer_MMA8452::read_x(int& xaxisLSB)
nherriot 0:bcf2aa85d7f9 174 {
nherriot 3:ffb0b1650ca2 175 char mcu_address = (MMA8452_ADDRESS<<1);
nherriot 3:ffb0b1650ca2 176 m_i2c.start();
nherriot 3:ffb0b1650ca2 177 if( m_i2c.write( mcu_address & 0xFE) == 0) // just good practice to force bit 1 to a '0' by ANDing with 0xFE
nherriot 3:ffb0b1650ca2 178 {
nherriot 3:ffb0b1650ca2 179 return 1; // we failed to write the mcu address on the bus to initiate dialogue
nherriot 3:ffb0b1650ca2 180 }
nherriot 3:ffb0b1650ca2 181 if( m_i2c.write( OUT_X_MSB) == 0)
nherriot 3:ffb0b1650ca2 182 {
nherriot 3:ffb0b1650ca2 183 return 1; // we failed to write 'X axis LSB' to the chip
nherriot 3:ffb0b1650ca2 184 }
nherriot 3:ffb0b1650ca2 185 m_i2c.start();
nherriot 3:ffb0b1650ca2 186 if( m_i2c.write( mcu_address | 0x01) == 0) // this is asking to read the slave mcu address - even though it's a 'write' method!!! Crap API...
nherriot 3:ffb0b1650ca2 187 {
nherriot 3:ffb0b1650ca2 188 return 1; // we failed to request a read from that mcu - this really is just writing the mcu vaule on the bus
nherriot 3:ffb0b1650ca2 189 }
nherriot 3:ffb0b1650ca2 190 xaxisLSB = m_i2c.read(0);
nherriot 3:ffb0b1650ca2 191 m_i2c.stop();
nherriot 3:ffb0b1650ca2 192 return 0;
nherriot 3:ffb0b1650ca2 193 }
nherriot 3:ffb0b1650ca2 194 */
nherriot 0:bcf2aa85d7f9 195
ashleymills 8:89272163f395 196 int Accelerometer_MMA8452::read_raw(char src, char *dst, int len) {
ashleymills 8:89272163f395 197 // this is the register we want to get data from
ashleymills 8:89272163f395 198 char register_address[1];
ashleymills 8:89272163f395 199 register_address[0] = src;
ashleymills 8:89272163f395 200
ashleymills 8:89272163f395 201 if(m_i2c.write(_writeAddress,register_address,1,true) == 0)
ashleymills 8:89272163f395 202 {
ashleymills 8:89272163f395 203 if(m_i2c.read(_readAddress,dst,len)==0)
ashleymills 8:89272163f395 204 {
ashleymills 8:89272163f395 205 return 0;
ashleymills 8:89272163f395 206 }
ashleymills 8:89272163f395 207 }
ashleymills 8:89272163f395 208
ashleymills 8:89272163f395 209 // failure case, zero array and return error
ashleymills 8:89272163f395 210 for(int i=0; i<len; i++) {
ashleymills 8:89272163f395 211 dst[i] = 0x00;
ashleymills 8:89272163f395 212 }
ashleymills 8:89272163f395 213 return 1;
ashleymills 8:89272163f395 214 }
nherriot 3:ffb0b1650ca2 215
nherriot 3:ffb0b1650ca2 216 // Reads x data. This method reads two registers containing the x-axis values from the accelerometer.
nherriot 3:ffb0b1650ca2 217 // It takes a 2 byte char array and copies the register values into the buffer. If it fails the char array
nherriot 3:ffb0b1650ca2 218 // is set to '0'. It returns '0' success '1' fail. This method does nothing to the registers - just returns
nherriot 3:ffb0b1650ca2 219 // the raw data.
nherriot 3:ffb0b1650ca2 220 //int Accelerometer_MMA8452::read_x(int& xaxisLSB)
nherriot 3:ffb0b1650ca2 221 int Accelerometer_MMA8452::read_x_raw(char *xaxis)
ashleymills 8:89272163f395 222 {
ashleymills 8:89272163f395 223 // this is the register we want to get data from
ashleymills 8:89272163f395 224 char xaxis_register[1] = {OUT_X_MSB};
nherriot 3:ffb0b1650ca2 225 //signed short s = 0;
nherriot 0:bcf2aa85d7f9 226
ashleymills 8:89272163f395 227 if(m_i2c.write(_writeAddress,xaxis_register,1,true) == 0)
nherriot 3:ffb0b1650ca2 228 {
ashleymills 8:89272163f395 229 if(m_i2c.read(_readAddress,xaxis,2)==0)
nherriot 3:ffb0b1650ca2 230 {
ashleymills 8:89272163f395 231 return 0;
nherriot 3:ffb0b1650ca2 232 }
nherriot 3:ffb0b1650ca2 233 }
ashleymills 8:89272163f395 234
ashleymills 8:89272163f395 235 // failure case
ashleymills 8:89272163f395 236 xaxis[0] = 0x00; // make sure the array is set to zero
ashleymills 8:89272163f395 237 xaxis[1] = 0x00;
ashleymills 8:89272163f395 238 return 1; // failed to write and request the OUT_X_MSB bit
nherriot 0:bcf2aa85d7f9 239 }
nherriot 0:bcf2aa85d7f9 240
nherriot 0:bcf2aa85d7f9 241
nherriot 3:ffb0b1650ca2 242 // Reads y data. This method reads two registers containing the x-axis values from the accelerometer.
nherriot 3:ffb0b1650ca2 243 // It takes a 2 byte char array and copies the register values into the buffer. If it fails the char array
nherriot 3:ffb0b1650ca2 244 // is set to '0'. It returns '0' success '1' fail. This method does nothing to the registers - just returns
nherriot 3:ffb0b1650ca2 245 // the raw data.
nherriot 3:ffb0b1650ca2 246
ashleymills 8:89272163f395 247 int Accelerometer_MMA8452::read_y_raw(char *yaxis) {
ashleymills 8:89272163f395 248 return read_raw(OUT_Y_MSB,yaxis,2);
nherriot 3:ffb0b1650ca2 249 }
nherriot 3:ffb0b1650ca2 250
nherriot 0:bcf2aa85d7f9 251
nherriot 3:ffb0b1650ca2 252
nherriot 3:ffb0b1650ca2 253 // Reads z data. This method reads two registers containing the x-axis values from the accelerometer.
nherriot 3:ffb0b1650ca2 254 // It takes a 2 byte char array and copies the register values into the buffer. If it fails the char array
nherriot 3:ffb0b1650ca2 255 // is set to '0'. It returns '0' success '1' fail. This method does nothing to the registers - just returns
nherriot 3:ffb0b1650ca2 256 // the raw data.
nherriot 3:ffb0b1650ca2 257
nherriot 3:ffb0b1650ca2 258 int Accelerometer_MMA8452::read_z_raw(char *zaxis)
nherriot 3:ffb0b1650ca2 259 {
ashleymills 8:89272163f395 260 return read_raw(OUT_Z_MSB,zaxis,2);
nherriot 3:ffb0b1650ca2 261 }
nherriot 0:bcf2aa85d7f9 262
nherriot 0:bcf2aa85d7f9 263
nherriot 0:bcf2aa85d7f9 264
nherriot 0:bcf2aa85d7f9 265 // Reads y data
nherriot 0:bcf2aa85d7f9 266 int Accelerometer_MMA8452::read_y()
nherriot 0:bcf2aa85d7f9 267 {
nherriot 1:ef026bf28798 268 char mcu_address = (MMA8452_ADDRESS <<1);
nherriot 0:bcf2aa85d7f9 269
nherriot 0:bcf2aa85d7f9 270 m_i2c.start(); // Start
nherriot 0:bcf2aa85d7f9 271 m_i2c.write(mcu_address); // A write to device 0x98
nherriot 0:bcf2aa85d7f9 272 m_i2c.write(OUT_Y_MSB); // Register to read
nherriot 0:bcf2aa85d7f9 273 m_i2c.start();
nherriot 0:bcf2aa85d7f9 274 m_i2c.write(mcu_address); // Read from device 0x99
nherriot 1:ef026bf28798 275 int y = m_i2c.read(0); // Read the data
nherriot 0:bcf2aa85d7f9 276 m_i2c.stop();
nherriot 0:bcf2aa85d7f9 277
nherriot 1:ef026bf28798 278 return y;
nherriot 0:bcf2aa85d7f9 279
nherriot 0:bcf2aa85d7f9 280 }
nherriot 0:bcf2aa85d7f9 281
nherriot 0:bcf2aa85d7f9 282
nherriot 0:bcf2aa85d7f9 283 // Reads z data
nherriot 0:bcf2aa85d7f9 284 int Accelerometer_MMA8452::read_z()
nherriot 0:bcf2aa85d7f9 285 {
nherriot 1:ef026bf28798 286 char mcu_address = (MMA8452_ADDRESS <<1);
nherriot 0:bcf2aa85d7f9 287
nherriot 0:bcf2aa85d7f9 288 m_i2c.start(); // Start
nherriot 0:bcf2aa85d7f9 289 m_i2c.write(mcu_address); // A write to device 0x98
nherriot 0:bcf2aa85d7f9 290 m_i2c.write(OUT_Z_MSB); // Register to read
nherriot 0:bcf2aa85d7f9 291 m_i2c.start();
nherriot 0:bcf2aa85d7f9 292 m_i2c.write(mcu_address); // Read from device 0x99
nherriot 1:ef026bf28798 293 int z = m_i2c.read(0); // Read the data
nherriot 0:bcf2aa85d7f9 294 m_i2c.stop();
nherriot 0:bcf2aa85d7f9 295
nherriot 1:ef026bf28798 296 return z;
nherriot 0:bcf2aa85d7f9 297
nherriot 0:bcf2aa85d7f9 298 }
nherriot 0:bcf2aa85d7f9 299
nherriot 0:bcf2aa85d7f9 300
nherriot 0:bcf2aa85d7f9 301 // Reads xyz
nherriot 1:ef026bf28798 302 int Accelerometer_MMA8452::read_xyz(char *x, char *y, char *z)
nherriot 1:ef026bf28798 303 {
nherriot 1:ef026bf28798 304
nherriot 1:ef026bf28798 305
nherriot 1:ef026bf28798 306 char mcu_address = (MMA8452_ADDRESS <<1);
nherriot 1:ef026bf28798 307 char register_buffer[6] ={0,0,0,0,0,0};
nherriot 1:ef026bf28798 308 const char Addr_X = OUT_X_MSB;
nherriot 1:ef026bf28798 309 m_i2c.write(mcu_address); // A write to device 0x98
nherriot 1:ef026bf28798 310 m_i2c.write(MMA8452_ADDRESS, &Addr_X, 1); // Pointer to the OUT_X_MSB register
nherriot 1:ef026bf28798 311
nherriot 1:ef026bf28798 312 if(m_i2c.write(mcu_address,&Addr_X,1) == 0)
nherriot 1:ef026bf28798 313 {
nherriot 1:ef026bf28798 314 if(m_i2c.read(mcu_address,register_buffer,6) == 0)
nherriot 1:ef026bf28798 315 {
nherriot 1:ef026bf28798 316 *x = register_buffer[1];
nherriot 1:ef026bf28798 317 *y = register_buffer[3];
nherriot 1:ef026bf28798 318 *z = register_buffer[5];
nherriot 1:ef026bf28798 319 return 0; // yahoooooo
nherriot 1:ef026bf28798 320 }
nherriot 1:ef026bf28798 321 else
nherriot 1:ef026bf28798 322 {
nherriot 1:ef026bf28798 323 return 1; // failed oh nooo!
nherriot 1:ef026bf28798 324 }
nherriot 1:ef026bf28798 325 }
nherriot 1:ef026bf28798 326 else
nherriot 1:ef026bf28798 327 {
nherriot 1:ef026bf28798 328 return 1; // failed oh nooo!
nherriot 1:ef026bf28798 329 }
nherriot 0:bcf2aa85d7f9 330
nherriot 1:ef026bf28798 331 }
nherriot 0:bcf2aa85d7f9 332
nherriot 0:bcf2aa85d7f9 333 // Write register (The device must be placed in Standby Mode to change the value of the registers)
nherriot 0:bcf2aa85d7f9 334 void Accelerometer_MMA8452::write_reg(char addr, char data)
nherriot 0:bcf2aa85d7f9 335 {
nherriot 0:bcf2aa85d7f9 336
nherriot 0:bcf2aa85d7f9 337 char cmd[2] = {0, 0};
nherriot 0:bcf2aa85d7f9 338
nherriot 0:bcf2aa85d7f9 339 cmd[0] = MODE_STATUS;
nherriot 0:bcf2aa85d7f9 340 cmd[1] = 0x00; // Standby Mode on
nherriot 0:bcf2aa85d7f9 341 m_i2c.write(MMA8452_ADDRESS, cmd, 2);
nherriot 0:bcf2aa85d7f9 342
nherriot 0:bcf2aa85d7f9 343 cmd[0] = addr;
nherriot 0:bcf2aa85d7f9 344 cmd[1] = data; // New value of the register
nherriot 0:bcf2aa85d7f9 345 m_i2c.write(MMA8452_ADDRESS, cmd, 2);
nherriot 0:bcf2aa85d7f9 346
nherriot 0:bcf2aa85d7f9 347 cmd[0] = MODE_STATUS;
nherriot 0:bcf2aa85d7f9 348 cmd[1] = 0x01; // Active Mode on
nherriot 0:bcf2aa85d7f9 349 m_i2c.write(MMA8452_ADDRESS, cmd, 2);
nherriot 0:bcf2aa85d7f9 350
nherriot 0:bcf2aa85d7f9 351 }
nherriot 0:bcf2aa85d7f9 352
nherriot 0:bcf2aa85d7f9 353
nherriot 0:bcf2aa85d7f9 354
nherriot 0:bcf2aa85d7f9 355 // Read from specified MMA7660FC register
nherriot 0:bcf2aa85d7f9 356 char Accelerometer_MMA8452::read_reg(char addr)
nherriot 0:bcf2aa85d7f9 357 {
nherriot 0:bcf2aa85d7f9 358
ashleymills 8:89272163f395 359 m_i2c.start();
ashleymills 8:89272163f395 360 if( m_i2c.write(_writeAddress) == 0)
ashleymills 8:89272163f395 361 {
ashleymills 8:89272163f395 362 return 1; // we failed to write the mcu address on the bus to initiate dialogue
ashleymills 8:89272163f395 363 }
ashleymills 8:89272163f395 364 if( m_i2c.write( addr) == 0)
ashleymills 8:89272163f395 365 {
ashleymills 8:89272163f395 366 return 1; // we failed to write 'status' to the chip
ashleymills 8:89272163f395 367 }
ashleymills 8:89272163f395 368 m_i2c.start();
ashleymills 8:89272163f395 369 if( m_i2c.write(_readAddress) == 0) // this is asking to read the slave mcu address - even though it's a 'write' method!!! Crap API...
ashleymills 8:89272163f395 370 {
ashleymills 8:89272163f395 371 return 1; // we failed to request a read from that mcu - this really is just writing the mcu vaule on the bus
ashleymills 8:89272163f395 372 }
ashleymills 8:89272163f395 373 char c = m_i2c.read(0);
ashleymills 8:89272163f395 374 m_i2c.stop();
nherriot 0:bcf2aa85d7f9 375
nherriot 0:bcf2aa85d7f9 376 return c;
nherriot 0:bcf2aa85d7f9 377
nherriot 0:bcf2aa85d7f9 378 }
nherriot 0:bcf2aa85d7f9 379
nherriot 0:bcf2aa85d7f9 380
nherriot 0:bcf2aa85d7f9 381
nherriot 0:bcf2aa85d7f9 382
nherriot 0:bcf2aa85d7f9 383
nherriot 0:bcf2aa85d7f9 384