Works with 8g
Fork of MMA8452 by
MMA8452.cpp@4:27aa3cd43234, 2013-10-16 (annotated)
- Committer:
- nherriot
- Date:
- Wed Oct 16 16:26:26 2013 +0000
- Revision:
- 4:27aa3cd43234
- Parent:
- 3:ffb0b1650ca2
- Child:
- 5:b3d0abd97e55
simplification on several methods.
Who changed what in which revision?
User | Revision | Line number | New 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 | |
nherriot | 0:bcf2aa85d7f9 | 23 | |
nherriot | 0:bcf2aa85d7f9 | 24 | |
nherriot | 0:bcf2aa85d7f9 | 25 | |
nherriot | 0:bcf2aa85d7f9 | 26 | |
nherriot | 0:bcf2aa85d7f9 | 27 | // Connect module at I2C address using I2C port pins sda and scl |
nherriot | 1:ef026bf28798 | 28 | Accelerometer_MMA8452::Accelerometer_MMA8452(PinName sda, PinName scl,int frequency) : m_i2c(sda, scl) , m_frequency(frequency) |
nherriot | 0:bcf2aa85d7f9 | 29 | { |
nherriot | 0:bcf2aa85d7f9 | 30 | //m_i2c.frequency(m_frequency); |
nherriot | 0:bcf2aa85d7f9 | 31 | } |
nherriot | 0:bcf2aa85d7f9 | 32 | |
nherriot | 0:bcf2aa85d7f9 | 33 | |
nherriot | 0:bcf2aa85d7f9 | 34 | // Destroys instance |
nherriot | 0:bcf2aa85d7f9 | 35 | Accelerometer_MMA8452::~Accelerometer_MMA8452() |
nherriot | 0:bcf2aa85d7f9 | 36 | { |
nherriot | 0:bcf2aa85d7f9 | 37 | |
nherriot | 0:bcf2aa85d7f9 | 38 | } |
nherriot | 0:bcf2aa85d7f9 | 39 | |
nherriot | 0:bcf2aa85d7f9 | 40 | // Setting the control register bit 1 to true to activate the MMA8452 |
nherriot | 0:bcf2aa85d7f9 | 41 | int Accelerometer_MMA8452::activate() |
nherriot | 0:bcf2aa85d7f9 | 42 | { |
nherriot | 1:ef026bf28798 | 43 | char mcu_address = (MMA8452_ADDRESS<<1); |
nherriot | 0:bcf2aa85d7f9 | 44 | char init[2]; |
nherriot | 0:bcf2aa85d7f9 | 45 | init[0] = CTRL_REG_1; // control register 1 |
nherriot | 3:ffb0b1650ca2 | 46 | init[1] = ACTIVE; // set to active |
nherriot | 3:ffb0b1650ca2 | 47 | |
nherriot | 3:ffb0b1650ca2 | 48 | if(m_i2c.write(mcu_address,init,2) == 0) |
nherriot | 3:ffb0b1650ca2 | 49 | { |
nherriot | 3:ffb0b1650ca2 | 50 | return 0; // return 0 to indicate success |
nherriot | 3:ffb0b1650ca2 | 51 | } |
nherriot | 3:ffb0b1650ca2 | 52 | else |
nherriot | 3:ffb0b1650ca2 | 53 | { |
nherriot | 3:ffb0b1650ca2 | 54 | return 1; // crumbs it failed!!! |
nherriot | 3:ffb0b1650ca2 | 55 | } |
nherriot | 3:ffb0b1650ca2 | 56 | |
nherriot | 3:ffb0b1650ca2 | 57 | } |
nherriot | 3:ffb0b1650ca2 | 58 | |
nherriot | 3:ffb0b1650ca2 | 59 | |
nherriot | 3:ffb0b1650ca2 | 60 | // Setting the control register bit 1 to true to activate the MMA8452 |
nherriot | 3:ffb0b1650ca2 | 61 | int Accelerometer_MMA8452::standby() |
nherriot | 3:ffb0b1650ca2 | 62 | { |
nherriot | 3:ffb0b1650ca2 | 63 | char mcu_address = (MMA8452_ADDRESS<<1); |
nherriot | 3:ffb0b1650ca2 | 64 | char init[2]; |
nherriot | 3:ffb0b1650ca2 | 65 | init[0] = CTRL_REG_1; // control register 1 |
nherriot | 3:ffb0b1650ca2 | 66 | init[1] = STANDBY; // set to standby |
nherriot | 1:ef026bf28798 | 67 | |
nherriot | 0:bcf2aa85d7f9 | 68 | if(m_i2c.write(mcu_address,init,2) == 0) |
nherriot | 0:bcf2aa85d7f9 | 69 | { |
nherriot | 0:bcf2aa85d7f9 | 70 | // pc.printf("The initialisation worked"); |
nherriot | 1:ef026bf28798 | 71 | return 0; // return 0 to indicate success |
nherriot | 0:bcf2aa85d7f9 | 72 | } |
nherriot | 0:bcf2aa85d7f9 | 73 | else |
nherriot | 0:bcf2aa85d7f9 | 74 | { |
nherriot | 0:bcf2aa85d7f9 | 75 | // pc.printf("The initialisation failed"); |
nherriot | 1:ef026bf28798 | 76 | return 1; // crumbs it failed!!! |
nherriot | 0:bcf2aa85d7f9 | 77 | } |
nherriot | 0:bcf2aa85d7f9 | 78 | |
nherriot | 0:bcf2aa85d7f9 | 79 | } |
nherriot | 0:bcf2aa85d7f9 | 80 | |
nherriot | 0:bcf2aa85d7f9 | 81 | |
nherriot | 3:ffb0b1650ca2 | 82 | |
nherriot | 0:bcf2aa85d7f9 | 83 | // Device initialization |
nherriot | 0:bcf2aa85d7f9 | 84 | void Accelerometer_MMA8452::init() |
nherriot | 0:bcf2aa85d7f9 | 85 | { |
nherriot | 0:bcf2aa85d7f9 | 86 | |
nherriot | 0:bcf2aa85d7f9 | 87 | write_reg(INTSU_STATUS, 0x10); // automatic interrupt after every measurement |
nherriot | 0:bcf2aa85d7f9 | 88 | write_reg(SR_STATUS, 0x00); // 120 Samples/Second |
nherriot | 0:bcf2aa85d7f9 | 89 | write_reg(MODE_STATUS, 0x01); // Active Mode |
nherriot | 0:bcf2aa85d7f9 | 90 | |
nherriot | 0:bcf2aa85d7f9 | 91 | } |
nherriot | 0:bcf2aa85d7f9 | 92 | |
nherriot | 3:ffb0b1650ca2 | 93 | // Get real time status of device - it can be STANDBY, WAKE or SLEEP |
nherriot | 3:ffb0b1650ca2 | 94 | int Accelerometer_MMA8452::get_SystemMode(int& deviceSystemMode) |
nherriot | 3:ffb0b1650ca2 | 95 | { |
nherriot | 3:ffb0b1650ca2 | 96 | char mcu_address = (MMA8452_ADDRESS<<1); |
nherriot | 3:ffb0b1650ca2 | 97 | m_i2c.start(); |
nherriot | 3:ffb0b1650ca2 | 98 | 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 | 99 | { |
nherriot | 3:ffb0b1650ca2 | 100 | return 1; // we failed to write the mcu address on the bus to initiate dialogue |
nherriot | 3:ffb0b1650ca2 | 101 | } |
nherriot | 3:ffb0b1650ca2 | 102 | if( m_i2c.write( SYSMOD) == 0) |
nherriot | 3:ffb0b1650ca2 | 103 | { |
nherriot | 3:ffb0b1650ca2 | 104 | return 1; // we failed to write 'status' to the chip |
nherriot | 3:ffb0b1650ca2 | 105 | } |
nherriot | 3:ffb0b1650ca2 | 106 | m_i2c.start(); |
nherriot | 3:ffb0b1650ca2 | 107 | 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 | 108 | { |
nherriot | 3:ffb0b1650ca2 | 109 | 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 | 110 | } |
nherriot | 3:ffb0b1650ca2 | 111 | deviceSystemMode = m_i2c.read(0); |
nherriot | 3:ffb0b1650ca2 | 112 | m_i2c.stop(); |
nherriot | 3:ffb0b1650ca2 | 113 | return 0; |
nherriot | 3:ffb0b1650ca2 | 114 | |
nherriot | 3:ffb0b1650ca2 | 115 | |
nherriot | 3:ffb0b1650ca2 | 116 | } |
nherriot | 3:ffb0b1650ca2 | 117 | |
nherriot | 3:ffb0b1650ca2 | 118 | |
nherriot | 3:ffb0b1650ca2 | 119 | |
nherriot | 3:ffb0b1650ca2 | 120 | // Get real time status of device - it can be STANDBY, WAKE or SLEEP |
nherriot | 3:ffb0b1650ca2 | 121 | int Accelerometer_MMA8452::get_Status(int& deviceStatus) |
nherriot | 3:ffb0b1650ca2 | 122 | { |
nherriot | 3:ffb0b1650ca2 | 123 | char mcu_address = (MMA8452_ADDRESS<<1); |
nherriot | 3:ffb0b1650ca2 | 124 | m_i2c.start(); |
nherriot | 3:ffb0b1650ca2 | 125 | 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 | 126 | { |
nherriot | 3:ffb0b1650ca2 | 127 | return 1; // we failed to write the mcu address on the bus to initiate dialogue |
nherriot | 3:ffb0b1650ca2 | 128 | } |
nherriot | 3:ffb0b1650ca2 | 129 | if( m_i2c.write( STATUS) == 0) |
nherriot | 3:ffb0b1650ca2 | 130 | { |
nherriot | 3:ffb0b1650ca2 | 131 | return 1; // we failed to write 'status' to the chip |
nherriot | 3:ffb0b1650ca2 | 132 | } |
nherriot | 3:ffb0b1650ca2 | 133 | m_i2c.start(); |
nherriot | 3:ffb0b1650ca2 | 134 | 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 | 135 | { |
nherriot | 3:ffb0b1650ca2 | 136 | 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 | 137 | } |
nherriot | 3:ffb0b1650ca2 | 138 | deviceStatus = m_i2c.read(0); |
nherriot | 3:ffb0b1650ca2 | 139 | m_i2c.stop(); |
nherriot | 3:ffb0b1650ca2 | 140 | return 0; |
nherriot | 3:ffb0b1650ca2 | 141 | |
nherriot | 3:ffb0b1650ca2 | 142 | |
nherriot | 3:ffb0b1650ca2 | 143 | } |
nherriot | 3:ffb0b1650ca2 | 144 | |
nherriot | 0:bcf2aa85d7f9 | 145 | |
nherriot | 1:ef026bf28798 | 146 | // Get device ID |
nherriot | 2:66db0f91b215 | 147 | int Accelerometer_MMA8452::get_DeviceID(int& deviceID) |
nherriot | 1:ef026bf28798 | 148 | { |
nherriot | 1:ef026bf28798 | 149 | char mcu_address = (MMA8452_ADDRESS<<1); |
nherriot | 1:ef026bf28798 | 150 | m_i2c.start(); |
nherriot | 3:ffb0b1650ca2 | 151 | if( m_i2c.write( mcu_address & 0xFE) == 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(); |
nherriot | 3:ffb0b1650ca2 | 160 | 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 | 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 | |
nherriot | 3:ffb0b1650ca2 | 196 | |
nherriot | 3:ffb0b1650ca2 | 197 | // Reads x data. This method reads two registers containing the x-axis values from the accelerometer. |
nherriot | 3:ffb0b1650ca2 | 198 | // It takes a 2 byte char array and copies the register values into the buffer. If it fails the char array |
nherriot | 3:ffb0b1650ca2 | 199 | // is set to '0'. It returns '0' success '1' fail. This method does nothing to the registers - just returns |
nherriot | 3:ffb0b1650ca2 | 200 | // the raw data. |
nherriot | 3:ffb0b1650ca2 | 201 | //int Accelerometer_MMA8452::read_x(int& xaxisLSB) |
nherriot | 3:ffb0b1650ca2 | 202 | int Accelerometer_MMA8452::read_x_raw(char *xaxis) |
nherriot | 3:ffb0b1650ca2 | 203 | { |
nherriot | 3:ffb0b1650ca2 | 204 | char mcu_address = (MMA8452_ADDRESS<<1); // this is the slave address on the bus we want data from |
nherriot | 3:ffb0b1650ca2 | 205 | char xaxis_buffer[2]; // this will contain data from that register |
nherriot | 3:ffb0b1650ca2 | 206 | char xaxis_register[1]; |
nherriot | 3:ffb0b1650ca2 | 207 | xaxis_register[0] = OUT_X_MSB; // this is the register we want to get data from |
nherriot | 3:ffb0b1650ca2 | 208 | //signed short s = 0; |
nherriot | 0:bcf2aa85d7f9 | 209 | |
nherriot | 3:ffb0b1650ca2 | 210 | if(m_i2c.write(mcu_address,xaxis_register,1) == 0) |
nherriot | 3:ffb0b1650ca2 | 211 | { |
nherriot | 3:ffb0b1650ca2 | 212 | if(m_i2c.read(mcu_address,xaxis_buffer,2) == 0) |
nherriot | 3:ffb0b1650ca2 | 213 | { |
nherriot | 3:ffb0b1650ca2 | 214 | //strcpy(xaxis, xaxis_buffer); |
nherriot | 3:ffb0b1650ca2 | 215 | memcpy(xaxis, xaxis_buffer, 2); |
nherriot | 3:ffb0b1650ca2 | 216 | //xaxis[0] = 0x00; // make sure the array is set to zero |
nherriot | 3:ffb0b1650ca2 | 217 | //xaxis[1] = 0x00; |
nherriot | 3:ffb0b1650ca2 | 218 | //s = *reinterpret_cast<short*>(&xaxis); |
nherriot | 3:ffb0b1650ca2 | 219 | return 0; // great we got the two octets |
nherriot | 3:ffb0b1650ca2 | 220 | } |
nherriot | 3:ffb0b1650ca2 | 221 | else |
nherriot | 3:ffb0b1650ca2 | 222 | { |
nherriot | 3:ffb0b1650ca2 | 223 | xaxis[0] = 0x00; // make sure the array is set to zero |
nherriot | 3:ffb0b1650ca2 | 224 | xaxis[1] = 0x00; |
nherriot | 3:ffb0b1650ca2 | 225 | return 1; // failed to read the 12 bit x value |
nherriot | 3:ffb0b1650ca2 | 226 | } |
nherriot | 3:ffb0b1650ca2 | 227 | } |
nherriot | 3:ffb0b1650ca2 | 228 | else |
nherriot | 3:ffb0b1650ca2 | 229 | { |
nherriot | 3:ffb0b1650ca2 | 230 | xaxis[0] = 0x00; // make sure the array is set to zero |
nherriot | 3:ffb0b1650ca2 | 231 | xaxis[1] = 0x00; |
nherriot | 3:ffb0b1650ca2 | 232 | return 1; // failed to write and request the OUT_X_MSB bit |
nherriot | 3:ffb0b1650ca2 | 233 | } |
nherriot | 0:bcf2aa85d7f9 | 234 | } |
nherriot | 0:bcf2aa85d7f9 | 235 | |
nherriot | 0:bcf2aa85d7f9 | 236 | |
nherriot | 3:ffb0b1650ca2 | 237 | // Reads y data. This method reads two registers containing the x-axis values from the accelerometer. |
nherriot | 3:ffb0b1650ca2 | 238 | // It takes a 2 byte char array and copies the register values into the buffer. If it fails the char array |
nherriot | 3:ffb0b1650ca2 | 239 | // is set to '0'. It returns '0' success '1' fail. This method does nothing to the registers - just returns |
nherriot | 3:ffb0b1650ca2 | 240 | // the raw data. |
nherriot | 3:ffb0b1650ca2 | 241 | |
nherriot | 3:ffb0b1650ca2 | 242 | int Accelerometer_MMA8452::read_y_raw(char *yaxis) |
nherriot | 0:bcf2aa85d7f9 | 243 | { |
nherriot | 3:ffb0b1650ca2 | 244 | char mcu_address = (MMA8452_ADDRESS<<1); // this is the slave address on the bus we want data from |
nherriot | 3:ffb0b1650ca2 | 245 | char yaxis_buffer[2]; // this will contain data from that register |
nherriot | 3:ffb0b1650ca2 | 246 | char yaxis_register[1]; |
nherriot | 3:ffb0b1650ca2 | 247 | yaxis_register[0] = OUT_Y_MSB; // this is the register we want to get data from |
nherriot | 3:ffb0b1650ca2 | 248 | //signed short s = 0; |
nherriot | 3:ffb0b1650ca2 | 249 | |
nherriot | 3:ffb0b1650ca2 | 250 | if(m_i2c.write(mcu_address,yaxis_register,1) == 0) |
nherriot | 3:ffb0b1650ca2 | 251 | { |
nherriot | 3:ffb0b1650ca2 | 252 | if(m_i2c.read(mcu_address,yaxis_buffer,2) == 0) |
nherriot | 3:ffb0b1650ca2 | 253 | { |
nherriot | 3:ffb0b1650ca2 | 254 | //strcpy(yaxis, yaxis_buffer); |
nherriot | 3:ffb0b1650ca2 | 255 | memcpy(yaxis, yaxis_buffer, 2); |
nherriot | 3:ffb0b1650ca2 | 256 | //yaxis[0] = 0x00; // make sure the array is set to zero |
nherriot | 3:ffb0b1650ca2 | 257 | //yaxis[1] = 0x00; |
nherriot | 3:ffb0b1650ca2 | 258 | //s = *reinterpret_cast<short*>(&xaxis); |
nherriot | 3:ffb0b1650ca2 | 259 | return 0; // great we got the two octets |
nherriot | 3:ffb0b1650ca2 | 260 | } |
nherriot | 3:ffb0b1650ca2 | 261 | else |
nherriot | 3:ffb0b1650ca2 | 262 | { |
nherriot | 3:ffb0b1650ca2 | 263 | yaxis[0] = 0x00; // make sure the array is set to zero |
nherriot | 3:ffb0b1650ca2 | 264 | yaxis[1] = 0x00; |
nherriot | 3:ffb0b1650ca2 | 265 | return 1; // failed to read the 12 bit y value |
nherriot | 3:ffb0b1650ca2 | 266 | } |
nherriot | 3:ffb0b1650ca2 | 267 | } |
nherriot | 3:ffb0b1650ca2 | 268 | else |
nherriot | 3:ffb0b1650ca2 | 269 | { |
nherriot | 3:ffb0b1650ca2 | 270 | yaxis[0] = 0x00; // make sure the array is set to zero |
nherriot | 3:ffb0b1650ca2 | 271 | yaxis[1] = 0x00; |
nherriot | 3:ffb0b1650ca2 | 272 | return 1; // failed to write and request the OUT_Y_MSB bit |
nherriot | 3:ffb0b1650ca2 | 273 | } |
nherriot | 3:ffb0b1650ca2 | 274 | } |
nherriot | 3:ffb0b1650ca2 | 275 | |
nherriot | 0:bcf2aa85d7f9 | 276 | |
nherriot | 3:ffb0b1650ca2 | 277 | |
nherriot | 3:ffb0b1650ca2 | 278 | // Reads z data. This method reads two registers containing the x-axis values from the accelerometer. |
nherriot | 3:ffb0b1650ca2 | 279 | // It takes a 2 byte char array and copies the register values into the buffer. If it fails the char array |
nherriot | 3:ffb0b1650ca2 | 280 | // is set to '0'. It returns '0' success '1' fail. This method does nothing to the registers - just returns |
nherriot | 3:ffb0b1650ca2 | 281 | // the raw data. |
nherriot | 3:ffb0b1650ca2 | 282 | |
nherriot | 3:ffb0b1650ca2 | 283 | int Accelerometer_MMA8452::read_z_raw(char *zaxis) |
nherriot | 3:ffb0b1650ca2 | 284 | { |
nherriot | 3:ffb0b1650ca2 | 285 | char mcu_address = (MMA8452_ADDRESS<<1); // this is the slave address on the bus we want data from |
nherriot | 3:ffb0b1650ca2 | 286 | char zaxis_buffer[2]; // this will contain data from that register |
nherriot | 3:ffb0b1650ca2 | 287 | char zaxis_register[1]; |
nherriot | 3:ffb0b1650ca2 | 288 | zaxis_register[0] = OUT_Z_MSB; // this is the register we want to get data from |
nherriot | 3:ffb0b1650ca2 | 289 | //signed short s = 0; |
nherriot | 0:bcf2aa85d7f9 | 290 | |
nherriot | 3:ffb0b1650ca2 | 291 | if(m_i2c.write(mcu_address,zaxis_register,1) == 0) |
nherriot | 3:ffb0b1650ca2 | 292 | { |
nherriot | 4:27aa3cd43234 | 293 | //if(m_i2c.read(mcu_address,zaxis_buffer,2) == 0) |
nherriot | 4:27aa3cd43234 | 294 | if(m_i2c.read(mcu_address,zaxis,2) == 0) |
nherriot | 3:ffb0b1650ca2 | 295 | { |
nherriot | 3:ffb0b1650ca2 | 296 | //strcpy(yaxis, yaxis_buffer); |
nherriot | 4:27aa3cd43234 | 297 | //memcpy(zaxis, zaxis_buffer, 2); |
nherriot | 3:ffb0b1650ca2 | 298 | //yaxis[0] = 0x00; // make sure the array is set to zero |
nherriot | 3:ffb0b1650ca2 | 299 | //yaxis[1] = 0x00; |
nherriot | 3:ffb0b1650ca2 | 300 | //s = *reinterpret_cast<short*>(&xaxis); |
nherriot | 3:ffb0b1650ca2 | 301 | return 0; // great we got the two octets |
nherriot | 3:ffb0b1650ca2 | 302 | } |
nherriot | 3:ffb0b1650ca2 | 303 | else |
nherriot | 3:ffb0b1650ca2 | 304 | { |
nherriot | 3:ffb0b1650ca2 | 305 | zaxis[0] = 0x00; // make sure the array is set to zero |
nherriot | 3:ffb0b1650ca2 | 306 | zaxis[1] = 0x00; |
nherriot | 3:ffb0b1650ca2 | 307 | return 1; // failed to read the 12 bit y value |
nherriot | 3:ffb0b1650ca2 | 308 | } |
nherriot | 3:ffb0b1650ca2 | 309 | } |
nherriot | 3:ffb0b1650ca2 | 310 | else |
nherriot | 3:ffb0b1650ca2 | 311 | { |
nherriot | 3:ffb0b1650ca2 | 312 | zaxis[0] = 0x00; // make sure the array is set to zero |
nherriot | 3:ffb0b1650ca2 | 313 | zaxis[1] = 0x00; |
nherriot | 3:ffb0b1650ca2 | 314 | return 1; // failed to write and request the OUT_Y_MSB bit |
nherriot | 3:ffb0b1650ca2 | 315 | } |
nherriot | 3:ffb0b1650ca2 | 316 | } |
nherriot | 0:bcf2aa85d7f9 | 317 | |
nherriot | 0:bcf2aa85d7f9 | 318 | |
nherriot | 0:bcf2aa85d7f9 | 319 | |
nherriot | 0:bcf2aa85d7f9 | 320 | // Reads y data |
nherriot | 0:bcf2aa85d7f9 | 321 | int Accelerometer_MMA8452::read_y() |
nherriot | 0:bcf2aa85d7f9 | 322 | { |
nherriot | 1:ef026bf28798 | 323 | char mcu_address = (MMA8452_ADDRESS <<1); |
nherriot | 0:bcf2aa85d7f9 | 324 | |
nherriot | 0:bcf2aa85d7f9 | 325 | m_i2c.start(); // Start |
nherriot | 0:bcf2aa85d7f9 | 326 | m_i2c.write(mcu_address); // A write to device 0x98 |
nherriot | 0:bcf2aa85d7f9 | 327 | m_i2c.write(OUT_Y_MSB); // Register to read |
nherriot | 0:bcf2aa85d7f9 | 328 | m_i2c.start(); |
nherriot | 0:bcf2aa85d7f9 | 329 | m_i2c.write(mcu_address); // Read from device 0x99 |
nherriot | 1:ef026bf28798 | 330 | int y = m_i2c.read(0); // Read the data |
nherriot | 0:bcf2aa85d7f9 | 331 | m_i2c.stop(); |
nherriot | 0:bcf2aa85d7f9 | 332 | |
nherriot | 1:ef026bf28798 | 333 | return y; |
nherriot | 0:bcf2aa85d7f9 | 334 | |
nherriot | 0:bcf2aa85d7f9 | 335 | } |
nherriot | 0:bcf2aa85d7f9 | 336 | |
nherriot | 0:bcf2aa85d7f9 | 337 | |
nherriot | 0:bcf2aa85d7f9 | 338 | // Reads z data |
nherriot | 0:bcf2aa85d7f9 | 339 | int Accelerometer_MMA8452::read_z() |
nherriot | 0:bcf2aa85d7f9 | 340 | { |
nherriot | 1:ef026bf28798 | 341 | char mcu_address = (MMA8452_ADDRESS <<1); |
nherriot | 0:bcf2aa85d7f9 | 342 | |
nherriot | 0:bcf2aa85d7f9 | 343 | m_i2c.start(); // Start |
nherriot | 0:bcf2aa85d7f9 | 344 | m_i2c.write(mcu_address); // A write to device 0x98 |
nherriot | 0:bcf2aa85d7f9 | 345 | m_i2c.write(OUT_Z_MSB); // Register to read |
nherriot | 0:bcf2aa85d7f9 | 346 | m_i2c.start(); |
nherriot | 0:bcf2aa85d7f9 | 347 | m_i2c.write(mcu_address); // Read from device 0x99 |
nherriot | 1:ef026bf28798 | 348 | int z = m_i2c.read(0); // Read the data |
nherriot | 0:bcf2aa85d7f9 | 349 | m_i2c.stop(); |
nherriot | 0:bcf2aa85d7f9 | 350 | |
nherriot | 1:ef026bf28798 | 351 | return z; |
nherriot | 0:bcf2aa85d7f9 | 352 | |
nherriot | 0:bcf2aa85d7f9 | 353 | } |
nherriot | 0:bcf2aa85d7f9 | 354 | |
nherriot | 0:bcf2aa85d7f9 | 355 | |
nherriot | 0:bcf2aa85d7f9 | 356 | // Reads xyz |
nherriot | 1:ef026bf28798 | 357 | int Accelerometer_MMA8452::read_xyz(char *x, char *y, char *z) |
nherriot | 1:ef026bf28798 | 358 | { |
nherriot | 1:ef026bf28798 | 359 | |
nherriot | 1:ef026bf28798 | 360 | |
nherriot | 1:ef026bf28798 | 361 | char mcu_address = (MMA8452_ADDRESS <<1); |
nherriot | 1:ef026bf28798 | 362 | char register_buffer[6] ={0,0,0,0,0,0}; |
nherriot | 1:ef026bf28798 | 363 | const char Addr_X = OUT_X_MSB; |
nherriot | 1:ef026bf28798 | 364 | m_i2c.write(mcu_address); // A write to device 0x98 |
nherriot | 1:ef026bf28798 | 365 | m_i2c.write(MMA8452_ADDRESS, &Addr_X, 1); // Pointer to the OUT_X_MSB register |
nherriot | 1:ef026bf28798 | 366 | |
nherriot | 1:ef026bf28798 | 367 | if(m_i2c.write(mcu_address,&Addr_X,1) == 0) |
nherriot | 1:ef026bf28798 | 368 | { |
nherriot | 1:ef026bf28798 | 369 | if(m_i2c.read(mcu_address,register_buffer,6) == 0) |
nherriot | 1:ef026bf28798 | 370 | { |
nherriot | 1:ef026bf28798 | 371 | *x = register_buffer[1]; |
nherriot | 1:ef026bf28798 | 372 | *y = register_buffer[3]; |
nherriot | 1:ef026bf28798 | 373 | *z = register_buffer[5]; |
nherriot | 1:ef026bf28798 | 374 | return 0; // yahoooooo |
nherriot | 1:ef026bf28798 | 375 | } |
nherriot | 1:ef026bf28798 | 376 | else |
nherriot | 1:ef026bf28798 | 377 | { |
nherriot | 1:ef026bf28798 | 378 | return 1; // failed oh nooo! |
nherriot | 1:ef026bf28798 | 379 | } |
nherriot | 1:ef026bf28798 | 380 | } |
nherriot | 1:ef026bf28798 | 381 | else |
nherriot | 1:ef026bf28798 | 382 | { |
nherriot | 1:ef026bf28798 | 383 | return 1; // failed oh nooo! |
nherriot | 1:ef026bf28798 | 384 | } |
nherriot | 0:bcf2aa85d7f9 | 385 | |
nherriot | 1:ef026bf28798 | 386 | } |
nherriot | 0:bcf2aa85d7f9 | 387 | |
nherriot | 0:bcf2aa85d7f9 | 388 | // Write register (The device must be placed in Standby Mode to change the value of the registers) |
nherriot | 0:bcf2aa85d7f9 | 389 | void Accelerometer_MMA8452::write_reg(char addr, char data) |
nherriot | 0:bcf2aa85d7f9 | 390 | { |
nherriot | 0:bcf2aa85d7f9 | 391 | |
nherriot | 0:bcf2aa85d7f9 | 392 | char cmd[2] = {0, 0}; |
nherriot | 0:bcf2aa85d7f9 | 393 | |
nherriot | 0:bcf2aa85d7f9 | 394 | cmd[0] = MODE_STATUS; |
nherriot | 0:bcf2aa85d7f9 | 395 | cmd[1] = 0x00; // Standby Mode on |
nherriot | 0:bcf2aa85d7f9 | 396 | m_i2c.write(MMA8452_ADDRESS, cmd, 2); |
nherriot | 0:bcf2aa85d7f9 | 397 | |
nherriot | 0:bcf2aa85d7f9 | 398 | cmd[0] = addr; |
nherriot | 0:bcf2aa85d7f9 | 399 | cmd[1] = data; // New value of the register |
nherriot | 0:bcf2aa85d7f9 | 400 | m_i2c.write(MMA8452_ADDRESS, cmd, 2); |
nherriot | 0:bcf2aa85d7f9 | 401 | |
nherriot | 0:bcf2aa85d7f9 | 402 | cmd[0] = MODE_STATUS; |
nherriot | 0:bcf2aa85d7f9 | 403 | cmd[1] = 0x01; // Active Mode on |
nherriot | 0:bcf2aa85d7f9 | 404 | m_i2c.write(MMA8452_ADDRESS, cmd, 2); |
nherriot | 0:bcf2aa85d7f9 | 405 | |
nherriot | 0:bcf2aa85d7f9 | 406 | } |
nherriot | 0:bcf2aa85d7f9 | 407 | |
nherriot | 0:bcf2aa85d7f9 | 408 | |
nherriot | 0:bcf2aa85d7f9 | 409 | |
nherriot | 0:bcf2aa85d7f9 | 410 | // Read from specified MMA7660FC register |
nherriot | 0:bcf2aa85d7f9 | 411 | char Accelerometer_MMA8452::read_reg(char addr) |
nherriot | 0:bcf2aa85d7f9 | 412 | { |
nherriot | 0:bcf2aa85d7f9 | 413 | |
nherriot | 0:bcf2aa85d7f9 | 414 | m_i2c.start(); // Start |
nherriot | 0:bcf2aa85d7f9 | 415 | m_i2c.write(0x98); // A write to device 0x98 |
nherriot | 0:bcf2aa85d7f9 | 416 | m_i2c.write(addr); // Register to read |
nherriot | 0:bcf2aa85d7f9 | 417 | m_i2c.start(); |
nherriot | 0:bcf2aa85d7f9 | 418 | m_i2c.write(0x99); // Read from device 0x99 |
nherriot | 0:bcf2aa85d7f9 | 419 | char c = m_i2c.read(0); // Read the data |
nherriot | 0:bcf2aa85d7f9 | 420 | m_i2c.stop(); |
nherriot | 0:bcf2aa85d7f9 | 421 | |
nherriot | 0:bcf2aa85d7f9 | 422 | return c; |
nherriot | 0:bcf2aa85d7f9 | 423 | |
nherriot | 0:bcf2aa85d7f9 | 424 | } |
nherriot | 0:bcf2aa85d7f9 | 425 | |
nherriot | 0:bcf2aa85d7f9 | 426 | |
nherriot | 0:bcf2aa85d7f9 | 427 | |
nherriot | 0:bcf2aa85d7f9 | 428 | |
nherriot | 0:bcf2aa85d7f9 | 429 | |
nherriot | 0:bcf2aa85d7f9 | 430 |