Werte auslesen und in Winkel umrechnen
Dependencies: mbed
MPU6050.cpp@0:d1960beb98fe, 2015-09-30 (annotated)
- Committer:
- Heidl
- Date:
- Wed Sep 30 16:08:36 2015 +0000
- Revision:
- 0:d1960beb98fe
Werte von Beschleunigungssensor auslesen
Who changed what in which revision?
User | Revision | Line number | New contents of line |
---|---|---|---|
Heidl | 0:d1960beb98fe | 1 | //ported from arduino library: https://github.com/jrowberg/i2cdevlib/tree/master/Arduino/MPU6050 |
Heidl | 0:d1960beb98fe | 2 | //written by szymon gaertig (email: szymon@gaertig.com.pl) |
Heidl | 0:d1960beb98fe | 3 | // |
Heidl | 0:d1960beb98fe | 4 | //Changelog: |
Heidl | 0:d1960beb98fe | 5 | //2013-01-08 - first beta release |
Heidl | 0:d1960beb98fe | 6 | |
Heidl | 0:d1960beb98fe | 7 | // I2Cdev library collection - MPU6050 I2C device class |
Heidl | 0:d1960beb98fe | 8 | // Based on InvenSense MPU-6050 register map document rev. 2.0, 5/19/2011 (RM-MPU-6000A-00) |
Heidl | 0:d1960beb98fe | 9 | // 8/24/2011 by Jeff Rowberg <jeff@rowberg.net> |
Heidl | 0:d1960beb98fe | 10 | // Updates should (hopefully) always be available at https://github.com/jrowberg/i2cdevlib |
Heidl | 0:d1960beb98fe | 11 | // |
Heidl | 0:d1960beb98fe | 12 | // Changelog: |
Heidl | 0:d1960beb98fe | 13 | // ... - ongoing debug release |
Heidl | 0:d1960beb98fe | 14 | |
Heidl | 0:d1960beb98fe | 15 | // NOTE: THIS IS ONLY A PARIAL RELEASE. THIS DEVICE CLASS IS CURRENTLY UNDERGOING ACTIVE |
Heidl | 0:d1960beb98fe | 16 | // DEVELOPMENT AND IS STILL MISSING SOME IMPORTANT FEATURES. PLEASE KEEP THIS IN MIND IF |
Heidl | 0:d1960beb98fe | 17 | // YOU DECIDE TO USE THIS PARTICULAR CODE FOR ANYTHING. |
Heidl | 0:d1960beb98fe | 18 | |
Heidl | 0:d1960beb98fe | 19 | /* ============================================ |
Heidl | 0:d1960beb98fe | 20 | I2Cdev device library code is placed under the MIT license |
Heidl | 0:d1960beb98fe | 21 | Copyright (c) 2012 Jeff Rowberg |
Heidl | 0:d1960beb98fe | 22 | |
Heidl | 0:d1960beb98fe | 23 | Permission is hereby granted, free of charge, to any person obtaining a copy |
Heidl | 0:d1960beb98fe | 24 | of this software and associated documentation files (the "Software"), to deal |
Heidl | 0:d1960beb98fe | 25 | in the Software without restriction, including without limitation the rights |
Heidl | 0:d1960beb98fe | 26 | to use, copy, modify, merge, publish, distribute, sublicense, and/or sell |
Heidl | 0:d1960beb98fe | 27 | copies of the Software, and to permit persons to whom the Software is |
Heidl | 0:d1960beb98fe | 28 | furnished to do so, subject to the following conditions: |
Heidl | 0:d1960beb98fe | 29 | |
Heidl | 0:d1960beb98fe | 30 | The above copyright notice and this permission notice shall be included in |
Heidl | 0:d1960beb98fe | 31 | all copies or substantial portions of the Software. |
Heidl | 0:d1960beb98fe | 32 | |
Heidl | 0:d1960beb98fe | 33 | THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR |
Heidl | 0:d1960beb98fe | 34 | IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, |
Heidl | 0:d1960beb98fe | 35 | FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE |
Heidl | 0:d1960beb98fe | 36 | AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER |
Heidl | 0:d1960beb98fe | 37 | LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, |
Heidl | 0:d1960beb98fe | 38 | OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN |
Heidl | 0:d1960beb98fe | 39 | THE SOFTWARE. |
Heidl | 0:d1960beb98fe | 40 | =============================================== |
Heidl | 0:d1960beb98fe | 41 | */ |
Heidl | 0:d1960beb98fe | 42 | |
Heidl | 0:d1960beb98fe | 43 | #include "MPU6050.h" |
Heidl | 0:d1960beb98fe | 44 | |
Heidl | 0:d1960beb98fe | 45 | #define useDebugSerial |
Heidl | 0:d1960beb98fe | 46 | |
Heidl | 0:d1960beb98fe | 47 | //instead of using pgmspace.h |
Heidl | 0:d1960beb98fe | 48 | typedef const unsigned char prog_uchar; |
Heidl | 0:d1960beb98fe | 49 | #define pgm_read_byte_near(x) (*(prog_uchar*)x) |
Heidl | 0:d1960beb98fe | 50 | #define pgm_read_byte(x) (*(prog_uchar*)x) |
Heidl | 0:d1960beb98fe | 51 | |
Heidl | 0:d1960beb98fe | 52 | /** Default constructor, uses default I2C address. |
Heidl | 0:d1960beb98fe | 53 | * @see MPU6050_DEFAULT_ADDRESS |
Heidl | 0:d1960beb98fe | 54 | */ |
Heidl | 0:d1960beb98fe | 55 | MPU6050::MPU6050() : debugSerial(USBTX, USBRX) |
Heidl | 0:d1960beb98fe | 56 | { |
Heidl | 0:d1960beb98fe | 57 | devAddr = MPU6050_DEFAULT_ADDRESS; |
Heidl | 0:d1960beb98fe | 58 | } |
Heidl | 0:d1960beb98fe | 59 | |
Heidl | 0:d1960beb98fe | 60 | /** Specific address constructor. |
Heidl | 0:d1960beb98fe | 61 | * @param address I2C address |
Heidl | 0:d1960beb98fe | 62 | * @see MPU6050_DEFAULT_ADDRESS |
Heidl | 0:d1960beb98fe | 63 | * @see MPU6050_ADDRESS_AD0_LOW |
Heidl | 0:d1960beb98fe | 64 | * @see MPU6050_ADDRESS_AD0_HIGH |
Heidl | 0:d1960beb98fe | 65 | */ |
Heidl | 0:d1960beb98fe | 66 | MPU6050::MPU6050(uint8_t address) : debugSerial(USBTX, USBRX) |
Heidl | 0:d1960beb98fe | 67 | { |
Heidl | 0:d1960beb98fe | 68 | devAddr = address; |
Heidl | 0:d1960beb98fe | 69 | } |
Heidl | 0:d1960beb98fe | 70 | |
Heidl | 0:d1960beb98fe | 71 | |
Heidl | 0:d1960beb98fe | 72 | /** Power on and prepare for general usage. |
Heidl | 0:d1960beb98fe | 73 | * This will activate the device and take it out of sleep mode (which must be done |
Heidl | 0:d1960beb98fe | 74 | * after start-up). This function also sets both the accelerometer and the gyroscope |
Heidl | 0:d1960beb98fe | 75 | * to their most sensitive settings, namely +/- 2g and +/- 250 degrees/sec, and sets |
Heidl | 0:d1960beb98fe | 76 | * the clock source to use the X Gyro for reference, which is slightly better than |
Heidl | 0:d1960beb98fe | 77 | * the default internal clock source. |
Heidl | 0:d1960beb98fe | 78 | */ |
Heidl | 0:d1960beb98fe | 79 | void MPU6050::initialize() |
Heidl | 0:d1960beb98fe | 80 | { |
Heidl | 0:d1960beb98fe | 81 | |
Heidl | 0:d1960beb98fe | 82 | #ifdef useDebugSerial |
Heidl | 0:d1960beb98fe | 83 | //debugSerial.printf("MPU6050::initialize start\n"); |
Heidl | 0:d1960beb98fe | 84 | #endif |
Heidl | 0:d1960beb98fe | 85 | |
Heidl | 0:d1960beb98fe | 86 | setClockSource(MPU6050_CLOCK_PLL_XGYRO); |
Heidl | 0:d1960beb98fe | 87 | setFullScaleGyroRange(MPU6050_GYRO_FS_250); |
Heidl | 0:d1960beb98fe | 88 | setFullScaleAccelRange(MPU6050_ACCEL_FS_2); |
Heidl | 0:d1960beb98fe | 89 | setSleepEnabled(false); // thanks to Jack Elston for pointing this one out! |
Heidl | 0:d1960beb98fe | 90 | |
Heidl | 0:d1960beb98fe | 91 | #ifdef useDebugSerial |
Heidl | 0:d1960beb98fe | 92 | //debugSerial.printf("MPU6050::initialize end\n"); |
Heidl | 0:d1960beb98fe | 93 | #endif |
Heidl | 0:d1960beb98fe | 94 | } |
Heidl | 0:d1960beb98fe | 95 | |
Heidl | 0:d1960beb98fe | 96 | /** Verify the I2C connection. |
Heidl | 0:d1960beb98fe | 97 | * Make sure the device is connected and responds as expected. |
Heidl | 0:d1960beb98fe | 98 | * @return True if connection is valid, false otherwise |
Heidl | 0:d1960beb98fe | 99 | */ |
Heidl | 0:d1960beb98fe | 100 | bool MPU6050::testConnection() |
Heidl | 0:d1960beb98fe | 101 | { |
Heidl | 0:d1960beb98fe | 102 | #ifdef useDebugSerial |
Heidl | 0:d1960beb98fe | 103 | debugSerial.printf("MPU6050::testConnection start\n"); |
Heidl | 0:d1960beb98fe | 104 | #endif |
Heidl | 0:d1960beb98fe | 105 | uint8_t deviceId = getDeviceID(); |
Heidl | 0:d1960beb98fe | 106 | #ifdef useDebugSerial |
Heidl | 0:d1960beb98fe | 107 | debugSerial.printf("DeviceId = %d\n",deviceId); |
Heidl | 0:d1960beb98fe | 108 | #endif |
Heidl | 0:d1960beb98fe | 109 | return deviceId == 0x34; |
Heidl | 0:d1960beb98fe | 110 | } |
Heidl | 0:d1960beb98fe | 111 | |
Heidl | 0:d1960beb98fe | 112 | // AUX_VDDIO register (InvenSense demo code calls this RA_*G_OFFS_TC) |
Heidl | 0:d1960beb98fe | 113 | |
Heidl | 0:d1960beb98fe | 114 | /** Get the auxiliary I2C supply voltage level. |
Heidl | 0:d1960beb98fe | 115 | * When set to 1, the auxiliary I2C bus high logic level is VDD. When cleared to |
Heidl | 0:d1960beb98fe | 116 | * 0, the auxiliary I2C bus high logic level is VLOGIC. This does not apply to |
Heidl | 0:d1960beb98fe | 117 | * the MPU-6000, which does not have a VLOGIC pin. |
Heidl | 0:d1960beb98fe | 118 | * @return I2C supply voltage level (0=VLOGIC, 1=VDD) |
Heidl | 0:d1960beb98fe | 119 | */ |
Heidl | 0:d1960beb98fe | 120 | uint8_t MPU6050::getAuxVDDIOLevel() |
Heidl | 0:d1960beb98fe | 121 | { |
Heidl | 0:d1960beb98fe | 122 | i2Cdev.readBit(devAddr, MPU6050_RA_YG_OFFS_TC, MPU6050_TC_PWR_MODE_BIT, buffer); |
Heidl | 0:d1960beb98fe | 123 | return buffer[0]; |
Heidl | 0:d1960beb98fe | 124 | } |
Heidl | 0:d1960beb98fe | 125 | /** Set the auxiliary I2C supply voltage level. |
Heidl | 0:d1960beb98fe | 126 | * When set to 1, the auxiliary I2C bus high logic level is VDD. When cleared to |
Heidl | 0:d1960beb98fe | 127 | * 0, the auxiliary I2C bus high logic level is VLOGIC. This does not apply to |
Heidl | 0:d1960beb98fe | 128 | * the MPU-6000, which does not have a VLOGIC pin. |
Heidl | 0:d1960beb98fe | 129 | * @param level I2C supply voltage level (0=VLOGIC, 1=VDD) |
Heidl | 0:d1960beb98fe | 130 | */ |
Heidl | 0:d1960beb98fe | 131 | void MPU6050::setAuxVDDIOLevel(uint8_t level) |
Heidl | 0:d1960beb98fe | 132 | { |
Heidl | 0:d1960beb98fe | 133 | i2Cdev.writeBit(devAddr, MPU6050_RA_YG_OFFS_TC, MPU6050_TC_PWR_MODE_BIT, level); |
Heidl | 0:d1960beb98fe | 134 | } |
Heidl | 0:d1960beb98fe | 135 | |
Heidl | 0:d1960beb98fe | 136 | // SMPLRT_DIV register |
Heidl | 0:d1960beb98fe | 137 | |
Heidl | 0:d1960beb98fe | 138 | /** Get gyroscope output rate divider. |
Heidl | 0:d1960beb98fe | 139 | * The sensor register output, FIFO output, DMP sampling, Motion detection, Zero |
Heidl | 0:d1960beb98fe | 140 | * Motion detection, and Free Fall detection are all based on the Sample Rate. |
Heidl | 0:d1960beb98fe | 141 | * The Sample Rate is generated by dividing the gyroscope output rate by |
Heidl | 0:d1960beb98fe | 142 | * SMPLRT_DIV: |
Heidl | 0:d1960beb98fe | 143 | * |
Heidl | 0:d1960beb98fe | 144 | * Sample Rate = Gyroscope Output Rate / (1 + SMPLRT_DIV) |
Heidl | 0:d1960beb98fe | 145 | * |
Heidl | 0:d1960beb98fe | 146 | * where Gyroscope Output Rate = 8kHz when the DLPF is disabled (DLPF_CFG = 0 or |
Heidl | 0:d1960beb98fe | 147 | * 7), and 1kHz when the DLPF is enabled (see Register 26). |
Heidl | 0:d1960beb98fe | 148 | * |
Heidl | 0:d1960beb98fe | 149 | * Note: The accelerometer output rate is 1kHz. This means that for a Sample |
Heidl | 0:d1960beb98fe | 150 | * Rate greater than 1kHz, the same accelerometer sample may be output to the |
Heidl | 0:d1960beb98fe | 151 | * FIFO, DMP, and sensor registers more than once. |
Heidl | 0:d1960beb98fe | 152 | * |
Heidl | 0:d1960beb98fe | 153 | * For a diagram of the gyroscope and accelerometer signal paths, see Section 8 |
Heidl | 0:d1960beb98fe | 154 | * of the MPU-6000/MPU-6050 Product Specification document. |
Heidl | 0:d1960beb98fe | 155 | * |
Heidl | 0:d1960beb98fe | 156 | * @return Current sample rate |
Heidl | 0:d1960beb98fe | 157 | * @see MPU6050_RA_SMPLRT_DIV |
Heidl | 0:d1960beb98fe | 158 | */ |
Heidl | 0:d1960beb98fe | 159 | uint8_t MPU6050::getRate() |
Heidl | 0:d1960beb98fe | 160 | { |
Heidl | 0:d1960beb98fe | 161 | i2Cdev.readByte(devAddr, MPU6050_RA_SMPLRT_DIV, buffer); |
Heidl | 0:d1960beb98fe | 162 | return buffer[0]; |
Heidl | 0:d1960beb98fe | 163 | } |
Heidl | 0:d1960beb98fe | 164 | /** Set gyroscope sample rate divider. |
Heidl | 0:d1960beb98fe | 165 | * @param rate New sample rate divider |
Heidl | 0:d1960beb98fe | 166 | * @see getRate() |
Heidl | 0:d1960beb98fe | 167 | * @see MPU6050_RA_SMPLRT_DIV |
Heidl | 0:d1960beb98fe | 168 | */ |
Heidl | 0:d1960beb98fe | 169 | void MPU6050::setRate(uint8_t rate) |
Heidl | 0:d1960beb98fe | 170 | { |
Heidl | 0:d1960beb98fe | 171 | i2Cdev.writeByte(devAddr, MPU6050_RA_SMPLRT_DIV, rate); |
Heidl | 0:d1960beb98fe | 172 | } |
Heidl | 0:d1960beb98fe | 173 | |
Heidl | 0:d1960beb98fe | 174 | // CONFIG register |
Heidl | 0:d1960beb98fe | 175 | |
Heidl | 0:d1960beb98fe | 176 | /** Get external FSYNC configuration. |
Heidl | 0:d1960beb98fe | 177 | * Configures the external Frame Synchronization (FSYNC) pin sampling. An |
Heidl | 0:d1960beb98fe | 178 | * external signal connected to the FSYNC pin can be sampled by configuring |
Heidl | 0:d1960beb98fe | 179 | * EXT_SYNC_SET. Signal changes to the FSYNC pin are latched so that short |
Heidl | 0:d1960beb98fe | 180 | * strobes may be captured. The latched FSYNC signal will be sampled at the |
Heidl | 0:d1960beb98fe | 181 | * Sampling Rate, as defined in register 25. After sampling, the latch will |
Heidl | 0:d1960beb98fe | 182 | * reset to the current FSYNC signal state. |
Heidl | 0:d1960beb98fe | 183 | * |
Heidl | 0:d1960beb98fe | 184 | * The sampled value will be reported in place of the least significant bit in |
Heidl | 0:d1960beb98fe | 185 | * a sensor data register determined by the value of EXT_SYNC_SET according to |
Heidl | 0:d1960beb98fe | 186 | * the following table. |
Heidl | 0:d1960beb98fe | 187 | * |
Heidl | 0:d1960beb98fe | 188 | * <pre> |
Heidl | 0:d1960beb98fe | 189 | * EXT_SYNC_SET | FSYNC Bit Location |
Heidl | 0:d1960beb98fe | 190 | * -------------+------------------- |
Heidl | 0:d1960beb98fe | 191 | * 0 | Input disabled |
Heidl | 0:d1960beb98fe | 192 | * 1 | TEMP_OUT_L[0] |
Heidl | 0:d1960beb98fe | 193 | * 2 | GYRO_XOUT_L[0] |
Heidl | 0:d1960beb98fe | 194 | * 3 | GYRO_YOUT_L[0] |
Heidl | 0:d1960beb98fe | 195 | * 4 | GYRO_ZOUT_L[0] |
Heidl | 0:d1960beb98fe | 196 | * 5 | ACCEL_XOUT_L[0] |
Heidl | 0:d1960beb98fe | 197 | * 6 | ACCEL_YOUT_L[0] |
Heidl | 0:d1960beb98fe | 198 | * 7 | ACCEL_ZOUT_L[0] |
Heidl | 0:d1960beb98fe | 199 | * </pre> |
Heidl | 0:d1960beb98fe | 200 | * |
Heidl | 0:d1960beb98fe | 201 | * @return FSYNC configuration value |
Heidl | 0:d1960beb98fe | 202 | */ |
Heidl | 0:d1960beb98fe | 203 | uint8_t MPU6050::getExternalFrameSync() |
Heidl | 0:d1960beb98fe | 204 | { |
Heidl | 0:d1960beb98fe | 205 | i2Cdev.readBits(devAddr, MPU6050_RA_CONFIG, MPU6050_CFG_EXT_SYNC_SET_BIT, MPU6050_CFG_EXT_SYNC_SET_LENGTH, buffer); |
Heidl | 0:d1960beb98fe | 206 | return buffer[0]; |
Heidl | 0:d1960beb98fe | 207 | } |
Heidl | 0:d1960beb98fe | 208 | /** Set external FSYNC configuration. |
Heidl | 0:d1960beb98fe | 209 | * @see getExternalFrameSync() |
Heidl | 0:d1960beb98fe | 210 | * @see MPU6050_RA_CONFIG |
Heidl | 0:d1960beb98fe | 211 | * @param sync New FSYNC configuration value |
Heidl | 0:d1960beb98fe | 212 | */ |
Heidl | 0:d1960beb98fe | 213 | void MPU6050::setExternalFrameSync(uint8_t sync) |
Heidl | 0:d1960beb98fe | 214 | { |
Heidl | 0:d1960beb98fe | 215 | i2Cdev.writeBits(devAddr, MPU6050_RA_CONFIG, MPU6050_CFG_EXT_SYNC_SET_BIT, MPU6050_CFG_EXT_SYNC_SET_LENGTH, sync); |
Heidl | 0:d1960beb98fe | 216 | } |
Heidl | 0:d1960beb98fe | 217 | /** Get digital low-pass filter configuration. |
Heidl | 0:d1960beb98fe | 218 | * The DLPF_CFG parameter sets the digital low pass filter configuration. It |
Heidl | 0:d1960beb98fe | 219 | * also determines the internal sampling rate used by the device as shown in |
Heidl | 0:d1960beb98fe | 220 | * the table below. |
Heidl | 0:d1960beb98fe | 221 | * |
Heidl | 0:d1960beb98fe | 222 | * Note: The accelerometer output rate is 1kHz. This means that for a Sample |
Heidl | 0:d1960beb98fe | 223 | * Rate greater than 1kHz, the same accelerometer sample may be output to the |
Heidl | 0:d1960beb98fe | 224 | * FIFO, DMP, and sensor registers more than once. |
Heidl | 0:d1960beb98fe | 225 | * |
Heidl | 0:d1960beb98fe | 226 | * <pre> |
Heidl | 0:d1960beb98fe | 227 | * | ACCELEROMETER | GYROSCOPE |
Heidl | 0:d1960beb98fe | 228 | * DLPF_CFG | Bandwidth | Delay | Bandwidth | Delay | Sample Rate |
Heidl | 0:d1960beb98fe | 229 | * ---------+-----------+--------+-----------+--------+------------- |
Heidl | 0:d1960beb98fe | 230 | * 0 | 260Hz | 0ms | 256Hz | 0.98ms | 8kHz |
Heidl | 0:d1960beb98fe | 231 | * 1 | 184Hz | 2.0ms | 188Hz | 1.9ms | 1kHz |
Heidl | 0:d1960beb98fe | 232 | * 2 | 94Hz | 3.0ms | 98Hz | 2.8ms | 1kHz |
Heidl | 0:d1960beb98fe | 233 | * 3 | 44Hz | 4.9ms | 42Hz | 4.8ms | 1kHz |
Heidl | 0:d1960beb98fe | 234 | * 4 | 21Hz | 8.5ms | 20Hz | 8.3ms | 1kHz |
Heidl | 0:d1960beb98fe | 235 | * 5 | 10Hz | 13.8ms | 10Hz | 13.4ms | 1kHz |
Heidl | 0:d1960beb98fe | 236 | * 6 | 5Hz | 19.0ms | 5Hz | 18.6ms | 1kHz |
Heidl | 0:d1960beb98fe | 237 | * 7 | -- Reserved -- | -- Reserved -- | Reserved |
Heidl | 0:d1960beb98fe | 238 | * </pre> |
Heidl | 0:d1960beb98fe | 239 | * |
Heidl | 0:d1960beb98fe | 240 | * @return DLFP configuration |
Heidl | 0:d1960beb98fe | 241 | * @see MPU6050_RA_CONFIG |
Heidl | 0:d1960beb98fe | 242 | * @see MPU6050_CFG_DLPF_CFG_BIT |
Heidl | 0:d1960beb98fe | 243 | * @see MPU6050_CFG_DLPF_CFG_LENGTH |
Heidl | 0:d1960beb98fe | 244 | */ |
Heidl | 0:d1960beb98fe | 245 | uint8_t MPU6050::getDLPFMode() |
Heidl | 0:d1960beb98fe | 246 | { |
Heidl | 0:d1960beb98fe | 247 | i2Cdev.readBits(devAddr, MPU6050_RA_CONFIG, MPU6050_CFG_DLPF_CFG_BIT, MPU6050_CFG_DLPF_CFG_LENGTH, buffer); |
Heidl | 0:d1960beb98fe | 248 | return buffer[0]; |
Heidl | 0:d1960beb98fe | 249 | } |
Heidl | 0:d1960beb98fe | 250 | /** Set digital low-pass filter configuration. |
Heidl | 0:d1960beb98fe | 251 | * @param mode New DLFP configuration setting |
Heidl | 0:d1960beb98fe | 252 | * @see getDLPFBandwidth() |
Heidl | 0:d1960beb98fe | 253 | * @see MPU6050_DLPF_BW_256 |
Heidl | 0:d1960beb98fe | 254 | * @see MPU6050_RA_CONFIG |
Heidl | 0:d1960beb98fe | 255 | * @see MPU6050_CFG_DLPF_CFG_BIT |
Heidl | 0:d1960beb98fe | 256 | * @see MPU6050_CFG_DLPF_CFG_LENGTH |
Heidl | 0:d1960beb98fe | 257 | */ |
Heidl | 0:d1960beb98fe | 258 | void MPU6050::setDLPFMode(uint8_t mode) |
Heidl | 0:d1960beb98fe | 259 | { |
Heidl | 0:d1960beb98fe | 260 | i2Cdev.writeBits(devAddr, MPU6050_RA_CONFIG, MPU6050_CFG_DLPF_CFG_BIT, MPU6050_CFG_DLPF_CFG_LENGTH, mode); |
Heidl | 0:d1960beb98fe | 261 | } |
Heidl | 0:d1960beb98fe | 262 | |
Heidl | 0:d1960beb98fe | 263 | // GYRO_CONFIG register |
Heidl | 0:d1960beb98fe | 264 | |
Heidl | 0:d1960beb98fe | 265 | /** Get full-scale gyroscope range. |
Heidl | 0:d1960beb98fe | 266 | * The FS_SEL parameter allows setting the full-scale range of the gyro sensors, |
Heidl | 0:d1960beb98fe | 267 | * as described in the table below. |
Heidl | 0:d1960beb98fe | 268 | * |
Heidl | 0:d1960beb98fe | 269 | * <pre> |
Heidl | 0:d1960beb98fe | 270 | * 0 = +/- 250 degrees/sec |
Heidl | 0:d1960beb98fe | 271 | * 1 = +/- 500 degrees/sec |
Heidl | 0:d1960beb98fe | 272 | * 2 = +/- 1000 degrees/sec |
Heidl | 0:d1960beb98fe | 273 | * 3 = +/- 2000 degrees/sec |
Heidl | 0:d1960beb98fe | 274 | * </pre> |
Heidl | 0:d1960beb98fe | 275 | * |
Heidl | 0:d1960beb98fe | 276 | * @return Current full-scale gyroscope range setting |
Heidl | 0:d1960beb98fe | 277 | * @see MPU6050_GYRO_FS_250 |
Heidl | 0:d1960beb98fe | 278 | * @see MPU6050_RA_GYRO_CONFIG |
Heidl | 0:d1960beb98fe | 279 | * @see MPU6050_GCONFIG_FS_SEL_BIT |
Heidl | 0:d1960beb98fe | 280 | * @see MPU6050_GCONFIG_FS_SEL_LENGTH |
Heidl | 0:d1960beb98fe | 281 | */ |
Heidl | 0:d1960beb98fe | 282 | uint8_t MPU6050::getFullScaleGyroRange() |
Heidl | 0:d1960beb98fe | 283 | { |
Heidl | 0:d1960beb98fe | 284 | i2Cdev.readBits(devAddr, MPU6050_RA_GYRO_CONFIG, MPU6050_GCONFIG_FS_SEL_BIT, MPU6050_GCONFIG_FS_SEL_LENGTH, buffer); |
Heidl | 0:d1960beb98fe | 285 | return buffer[0]; |
Heidl | 0:d1960beb98fe | 286 | } |
Heidl | 0:d1960beb98fe | 287 | /** Set full-scale gyroscope range. |
Heidl | 0:d1960beb98fe | 288 | * @param range New full-scale gyroscope range value |
Heidl | 0:d1960beb98fe | 289 | * @see getFullScaleRange() |
Heidl | 0:d1960beb98fe | 290 | * @see MPU6050_GYRO_FS_250 |
Heidl | 0:d1960beb98fe | 291 | * @see MPU6050_RA_GYRO_CONFIG |
Heidl | 0:d1960beb98fe | 292 | * @see MPU6050_GCONFIG_FS_SEL_BIT |
Heidl | 0:d1960beb98fe | 293 | * @see MPU6050_GCONFIG_FS_SEL_LENGTH |
Heidl | 0:d1960beb98fe | 294 | */ |
Heidl | 0:d1960beb98fe | 295 | void MPU6050::setFullScaleGyroRange(uint8_t range) |
Heidl | 0:d1960beb98fe | 296 | { |
Heidl | 0:d1960beb98fe | 297 | i2Cdev.writeBits(devAddr, MPU6050_RA_GYRO_CONFIG, MPU6050_GCONFIG_FS_SEL_BIT, MPU6050_GCONFIG_FS_SEL_LENGTH, range); |
Heidl | 0:d1960beb98fe | 298 | } |
Heidl | 0:d1960beb98fe | 299 | |
Heidl | 0:d1960beb98fe | 300 | // ACCEL_CONFIG register |
Heidl | 0:d1960beb98fe | 301 | |
Heidl | 0:d1960beb98fe | 302 | /** Get self-test enabled setting for accelerometer X axis. |
Heidl | 0:d1960beb98fe | 303 | * @return Self-test enabled value |
Heidl | 0:d1960beb98fe | 304 | * @see MPU6050_RA_ACCEL_CONFIG |
Heidl | 0:d1960beb98fe | 305 | */ |
Heidl | 0:d1960beb98fe | 306 | bool MPU6050::getAccelXSelfTest() |
Heidl | 0:d1960beb98fe | 307 | { |
Heidl | 0:d1960beb98fe | 308 | i2Cdev.readBit(devAddr, MPU6050_RA_ACCEL_CONFIG, MPU6050_ACONFIG_XA_ST_BIT, buffer); |
Heidl | 0:d1960beb98fe | 309 | return buffer[0]; |
Heidl | 0:d1960beb98fe | 310 | } |
Heidl | 0:d1960beb98fe | 311 | /** Get self-test enabled setting for accelerometer X axis. |
Heidl | 0:d1960beb98fe | 312 | * @param enabled Self-test enabled value |
Heidl | 0:d1960beb98fe | 313 | * @see MPU6050_RA_ACCEL_CONFIG |
Heidl | 0:d1960beb98fe | 314 | */ |
Heidl | 0:d1960beb98fe | 315 | void MPU6050::setAccelXSelfTest(bool enabled) |
Heidl | 0:d1960beb98fe | 316 | { |
Heidl | 0:d1960beb98fe | 317 | i2Cdev.writeBit(devAddr, MPU6050_RA_ACCEL_CONFIG, MPU6050_ACONFIG_XA_ST_BIT, enabled); |
Heidl | 0:d1960beb98fe | 318 | } |
Heidl | 0:d1960beb98fe | 319 | /** Get self-test enabled value for accelerometer Y axis. |
Heidl | 0:d1960beb98fe | 320 | * @return Self-test enabled value |
Heidl | 0:d1960beb98fe | 321 | * @see MPU6050_RA_ACCEL_CONFIG |
Heidl | 0:d1960beb98fe | 322 | */ |
Heidl | 0:d1960beb98fe | 323 | bool MPU6050::getAccelYSelfTest() |
Heidl | 0:d1960beb98fe | 324 | { |
Heidl | 0:d1960beb98fe | 325 | i2Cdev.readBit(devAddr, MPU6050_RA_ACCEL_CONFIG, MPU6050_ACONFIG_YA_ST_BIT, buffer); |
Heidl | 0:d1960beb98fe | 326 | return buffer[0]; |
Heidl | 0:d1960beb98fe | 327 | } |
Heidl | 0:d1960beb98fe | 328 | /** Get self-test enabled value for accelerometer Y axis. |
Heidl | 0:d1960beb98fe | 329 | * @param enabled Self-test enabled value |
Heidl | 0:d1960beb98fe | 330 | * @see MPU6050_RA_ACCEL_CONFIG |
Heidl | 0:d1960beb98fe | 331 | */ |
Heidl | 0:d1960beb98fe | 332 | void MPU6050::setAccelYSelfTest(bool enabled) |
Heidl | 0:d1960beb98fe | 333 | { |
Heidl | 0:d1960beb98fe | 334 | i2Cdev.writeBit(devAddr, MPU6050_RA_ACCEL_CONFIG, MPU6050_ACONFIG_YA_ST_BIT, enabled); |
Heidl | 0:d1960beb98fe | 335 | } |
Heidl | 0:d1960beb98fe | 336 | /** Get self-test enabled value for accelerometer Z axis. |
Heidl | 0:d1960beb98fe | 337 | * @return Self-test enabled value |
Heidl | 0:d1960beb98fe | 338 | * @see MPU6050_RA_ACCEL_CONFIG |
Heidl | 0:d1960beb98fe | 339 | */ |
Heidl | 0:d1960beb98fe | 340 | bool MPU6050::getAccelZSelfTest() |
Heidl | 0:d1960beb98fe | 341 | { |
Heidl | 0:d1960beb98fe | 342 | i2Cdev.readBit(devAddr, MPU6050_RA_ACCEL_CONFIG, MPU6050_ACONFIG_ZA_ST_BIT, buffer); |
Heidl | 0:d1960beb98fe | 343 | return buffer[0]; |
Heidl | 0:d1960beb98fe | 344 | } |
Heidl | 0:d1960beb98fe | 345 | /** Set self-test enabled value for accelerometer Z axis. |
Heidl | 0:d1960beb98fe | 346 | * @param enabled Self-test enabled value |
Heidl | 0:d1960beb98fe | 347 | * @see MPU6050_RA_ACCEL_CONFIG |
Heidl | 0:d1960beb98fe | 348 | */ |
Heidl | 0:d1960beb98fe | 349 | void MPU6050::setAccelZSelfTest(bool enabled) |
Heidl | 0:d1960beb98fe | 350 | { |
Heidl | 0:d1960beb98fe | 351 | i2Cdev.writeBit(devAddr, MPU6050_RA_ACCEL_CONFIG, MPU6050_ACONFIG_ZA_ST_BIT, enabled); |
Heidl | 0:d1960beb98fe | 352 | } |
Heidl | 0:d1960beb98fe | 353 | /** Get full-scale accelerometer range. |
Heidl | 0:d1960beb98fe | 354 | * The FS_SEL parameter allows setting the full-scale range of the accelerometer |
Heidl | 0:d1960beb98fe | 355 | * sensors, as described in the table below. |
Heidl | 0:d1960beb98fe | 356 | * |
Heidl | 0:d1960beb98fe | 357 | * <pre> |
Heidl | 0:d1960beb98fe | 358 | * 0 = +/- 2g |
Heidl | 0:d1960beb98fe | 359 | * 1 = +/- 4g |
Heidl | 0:d1960beb98fe | 360 | * 2 = +/- 8g |
Heidl | 0:d1960beb98fe | 361 | * 3 = +/- 16g |
Heidl | 0:d1960beb98fe | 362 | * </pre> |
Heidl | 0:d1960beb98fe | 363 | * |
Heidl | 0:d1960beb98fe | 364 | * @return Current full-scale accelerometer range setting |
Heidl | 0:d1960beb98fe | 365 | * @see MPU6050_ACCEL_FS_2 |
Heidl | 0:d1960beb98fe | 366 | * @see MPU6050_RA_ACCEL_CONFIG |
Heidl | 0:d1960beb98fe | 367 | * @see MPU6050_ACONFIG_AFS_SEL_BIT |
Heidl | 0:d1960beb98fe | 368 | * @see MPU6050_ACONFIG_AFS_SEL_LENGTH |
Heidl | 0:d1960beb98fe | 369 | */ |
Heidl | 0:d1960beb98fe | 370 | uint8_t MPU6050::getFullScaleAccelRange() |
Heidl | 0:d1960beb98fe | 371 | { |
Heidl | 0:d1960beb98fe | 372 | i2Cdev.readBits(devAddr, MPU6050_RA_ACCEL_CONFIG, MPU6050_ACONFIG_AFS_SEL_BIT, MPU6050_ACONFIG_AFS_SEL_LENGTH, buffer); |
Heidl | 0:d1960beb98fe | 373 | return buffer[0]; |
Heidl | 0:d1960beb98fe | 374 | } |
Heidl | 0:d1960beb98fe | 375 | /** Set full-scale accelerometer range. |
Heidl | 0:d1960beb98fe | 376 | * @param range New full-scale accelerometer range setting |
Heidl | 0:d1960beb98fe | 377 | * @see getFullScaleAccelRange() |
Heidl | 0:d1960beb98fe | 378 | */ |
Heidl | 0:d1960beb98fe | 379 | void MPU6050::setFullScaleAccelRange(uint8_t range) |
Heidl | 0:d1960beb98fe | 380 | { |
Heidl | 0:d1960beb98fe | 381 | i2Cdev.writeBits(devAddr, MPU6050_RA_ACCEL_CONFIG, MPU6050_ACONFIG_AFS_SEL_BIT, MPU6050_ACONFIG_AFS_SEL_LENGTH, range); |
Heidl | 0:d1960beb98fe | 382 | } |
Heidl | 0:d1960beb98fe | 383 | /** Get the high-pass filter configuration. |
Heidl | 0:d1960beb98fe | 384 | * The DHPF is a filter module in the path leading to motion detectors (Free |
Heidl | 0:d1960beb98fe | 385 | * Fall, Motion threshold, and Zero Motion). The high pass filter output is not |
Heidl | 0:d1960beb98fe | 386 | * available to the data registers (see Figure in Section 8 of the MPU-6000/ |
Heidl | 0:d1960beb98fe | 387 | * MPU-6050 Product Specification document). |
Heidl | 0:d1960beb98fe | 388 | * |
Heidl | 0:d1960beb98fe | 389 | * The high pass filter has three modes: |
Heidl | 0:d1960beb98fe | 390 | * |
Heidl | 0:d1960beb98fe | 391 | * <pre> |
Heidl | 0:d1960beb98fe | 392 | * Reset: The filter output settles to zero within one sample. This |
Heidl | 0:d1960beb98fe | 393 | * effectively disables the high pass filter. This mode may be toggled |
Heidl | 0:d1960beb98fe | 394 | * to quickly settle the filter. |
Heidl | 0:d1960beb98fe | 395 | * |
Heidl | 0:d1960beb98fe | 396 | * On: The high pass filter will pass signals above the cut off frequency. |
Heidl | 0:d1960beb98fe | 397 | * |
Heidl | 0:d1960beb98fe | 398 | * Hold: When triggered, the filter holds the present sample. The filter |
Heidl | 0:d1960beb98fe | 399 | * output will be the difference between the input sample and the held |
Heidl | 0:d1960beb98fe | 400 | * sample. |
Heidl | 0:d1960beb98fe | 401 | * </pre> |
Heidl | 0:d1960beb98fe | 402 | * |
Heidl | 0:d1960beb98fe | 403 | * <pre> |
Heidl | 0:d1960beb98fe | 404 | * ACCEL_HPF | Filter Mode | Cut-off Frequency |
Heidl | 0:d1960beb98fe | 405 | * ----------+-------------+------------------ |
Heidl | 0:d1960beb98fe | 406 | * 0 | Reset | None |
Heidl | 0:d1960beb98fe | 407 | * 1 | On | 5Hz |
Heidl | 0:d1960beb98fe | 408 | * 2 | On | 2.5Hz |
Heidl | 0:d1960beb98fe | 409 | * 3 | On | 1.25Hz |
Heidl | 0:d1960beb98fe | 410 | * 4 | On | 0.63Hz |
Heidl | 0:d1960beb98fe | 411 | * 7 | Hold | None |
Heidl | 0:d1960beb98fe | 412 | * </pre> |
Heidl | 0:d1960beb98fe | 413 | * |
Heidl | 0:d1960beb98fe | 414 | * @return Current high-pass filter configuration |
Heidl | 0:d1960beb98fe | 415 | * @see MPU6050_DHPF_RESET |
Heidl | 0:d1960beb98fe | 416 | * @see MPU6050_RA_ACCEL_CONFIG |
Heidl | 0:d1960beb98fe | 417 | */ |
Heidl | 0:d1960beb98fe | 418 | uint8_t MPU6050::getDHPFMode() |
Heidl | 0:d1960beb98fe | 419 | { |
Heidl | 0:d1960beb98fe | 420 | i2Cdev.readBits(devAddr, MPU6050_RA_ACCEL_CONFIG, MPU6050_ACONFIG_ACCEL_HPF_BIT, MPU6050_ACONFIG_ACCEL_HPF_LENGTH, buffer); |
Heidl | 0:d1960beb98fe | 421 | return buffer[0]; |
Heidl | 0:d1960beb98fe | 422 | } |
Heidl | 0:d1960beb98fe | 423 | /** Set the high-pass filter configuration. |
Heidl | 0:d1960beb98fe | 424 | * @param bandwidth New high-pass filter configuration |
Heidl | 0:d1960beb98fe | 425 | * @see setDHPFMode() |
Heidl | 0:d1960beb98fe | 426 | * @see MPU6050_DHPF_RESET |
Heidl | 0:d1960beb98fe | 427 | * @see MPU6050_RA_ACCEL_CONFIG |
Heidl | 0:d1960beb98fe | 428 | */ |
Heidl | 0:d1960beb98fe | 429 | void MPU6050::setDHPFMode(uint8_t bandwidth) |
Heidl | 0:d1960beb98fe | 430 | { |
Heidl | 0:d1960beb98fe | 431 | i2Cdev.writeBits(devAddr, MPU6050_RA_ACCEL_CONFIG, MPU6050_ACONFIG_ACCEL_HPF_BIT, MPU6050_ACONFIG_ACCEL_HPF_LENGTH, bandwidth); |
Heidl | 0:d1960beb98fe | 432 | } |
Heidl | 0:d1960beb98fe | 433 | |
Heidl | 0:d1960beb98fe | 434 | // FF_THR register |
Heidl | 0:d1960beb98fe | 435 | |
Heidl | 0:d1960beb98fe | 436 | /** Get free-fall event acceleration threshold. |
Heidl | 0:d1960beb98fe | 437 | * This register configures the detection threshold for Free Fall event |
Heidl | 0:d1960beb98fe | 438 | * detection. The unit of FF_THR is 1LSB = 2mg. Free Fall is detected when the |
Heidl | 0:d1960beb98fe | 439 | * absolute value of the accelerometer measurements for the three axes are each |
Heidl | 0:d1960beb98fe | 440 | * less than the detection threshold. This condition increments the Free Fall |
Heidl | 0:d1960beb98fe | 441 | * duration counter (Register 30). The Free Fall interrupt is triggered when the |
Heidl | 0:d1960beb98fe | 442 | * Free Fall duration counter reaches the time specified in FF_DUR. |
Heidl | 0:d1960beb98fe | 443 | * |
Heidl | 0:d1960beb98fe | 444 | * For more details on the Free Fall detection interrupt, see Section 8.2 of the |
Heidl | 0:d1960beb98fe | 445 | * MPU-6000/MPU-6050 Product Specification document as well as Registers 56 and |
Heidl | 0:d1960beb98fe | 446 | * 58 of this document. |
Heidl | 0:d1960beb98fe | 447 | * |
Heidl | 0:d1960beb98fe | 448 | * @return Current free-fall acceleration threshold value (LSB = 2mg) |
Heidl | 0:d1960beb98fe | 449 | * @see MPU6050_RA_FF_THR |
Heidl | 0:d1960beb98fe | 450 | */ |
Heidl | 0:d1960beb98fe | 451 | uint8_t MPU6050::getFreefallDetectionThreshold() |
Heidl | 0:d1960beb98fe | 452 | { |
Heidl | 0:d1960beb98fe | 453 | i2Cdev.readByte(devAddr, MPU6050_RA_FF_THR, buffer); |
Heidl | 0:d1960beb98fe | 454 | return buffer[0]; |
Heidl | 0:d1960beb98fe | 455 | } |
Heidl | 0:d1960beb98fe | 456 | /** Get free-fall event acceleration threshold. |
Heidl | 0:d1960beb98fe | 457 | * @param threshold New free-fall acceleration threshold value (LSB = 2mg) |
Heidl | 0:d1960beb98fe | 458 | * @see getFreefallDetectionThreshold() |
Heidl | 0:d1960beb98fe | 459 | * @see MPU6050_RA_FF_THR |
Heidl | 0:d1960beb98fe | 460 | */ |
Heidl | 0:d1960beb98fe | 461 | void MPU6050::setFreefallDetectionThreshold(uint8_t threshold) |
Heidl | 0:d1960beb98fe | 462 | { |
Heidl | 0:d1960beb98fe | 463 | i2Cdev.writeByte(devAddr, MPU6050_RA_FF_THR, threshold); |
Heidl | 0:d1960beb98fe | 464 | } |
Heidl | 0:d1960beb98fe | 465 | |
Heidl | 0:d1960beb98fe | 466 | // FF_DUR register |
Heidl | 0:d1960beb98fe | 467 | |
Heidl | 0:d1960beb98fe | 468 | /** Get free-fall event duration threshold. |
Heidl | 0:d1960beb98fe | 469 | * This register configures the duration counter threshold for Free Fall event |
Heidl | 0:d1960beb98fe | 470 | * detection. The duration counter ticks at 1kHz, therefore FF_DUR has a unit |
Heidl | 0:d1960beb98fe | 471 | * of 1 LSB = 1 ms. |
Heidl | 0:d1960beb98fe | 472 | * |
Heidl | 0:d1960beb98fe | 473 | * The Free Fall duration counter increments while the absolute value of the |
Heidl | 0:d1960beb98fe | 474 | * accelerometer measurements are each less than the detection threshold |
Heidl | 0:d1960beb98fe | 475 | * (Register 29). The Free Fall interrupt is triggered when the Free Fall |
Heidl | 0:d1960beb98fe | 476 | * duration counter reaches the time specified in this register. |
Heidl | 0:d1960beb98fe | 477 | * |
Heidl | 0:d1960beb98fe | 478 | * For more details on the Free Fall detection interrupt, see Section 8.2 of |
Heidl | 0:d1960beb98fe | 479 | * the MPU-6000/MPU-6050 Product Specification document as well as Registers 56 |
Heidl | 0:d1960beb98fe | 480 | * and 58 of this document. |
Heidl | 0:d1960beb98fe | 481 | * |
Heidl | 0:d1960beb98fe | 482 | * @return Current free-fall duration threshold value (LSB = 1ms) |
Heidl | 0:d1960beb98fe | 483 | * @see MPU6050_RA_FF_DUR |
Heidl | 0:d1960beb98fe | 484 | */ |
Heidl | 0:d1960beb98fe | 485 | uint8_t MPU6050::getFreefallDetectionDuration() |
Heidl | 0:d1960beb98fe | 486 | { |
Heidl | 0:d1960beb98fe | 487 | i2Cdev.readByte(devAddr, MPU6050_RA_FF_DUR, buffer); |
Heidl | 0:d1960beb98fe | 488 | return buffer[0]; |
Heidl | 0:d1960beb98fe | 489 | } |
Heidl | 0:d1960beb98fe | 490 | /** Get free-fall event duration threshold. |
Heidl | 0:d1960beb98fe | 491 | * @param duration New free-fall duration threshold value (LSB = 1ms) |
Heidl | 0:d1960beb98fe | 492 | * @see getFreefallDetectionDuration() |
Heidl | 0:d1960beb98fe | 493 | * @see MPU6050_RA_FF_DUR |
Heidl | 0:d1960beb98fe | 494 | */ |
Heidl | 0:d1960beb98fe | 495 | void MPU6050::setFreefallDetectionDuration(uint8_t duration) |
Heidl | 0:d1960beb98fe | 496 | { |
Heidl | 0:d1960beb98fe | 497 | i2Cdev.writeByte(devAddr, MPU6050_RA_FF_DUR, duration); |
Heidl | 0:d1960beb98fe | 498 | } |
Heidl | 0:d1960beb98fe | 499 | |
Heidl | 0:d1960beb98fe | 500 | // MOT_THR register |
Heidl | 0:d1960beb98fe | 501 | |
Heidl | 0:d1960beb98fe | 502 | /** Get motion detection event acceleration threshold. |
Heidl | 0:d1960beb98fe | 503 | * This register configures the detection threshold for Motion interrupt |
Heidl | 0:d1960beb98fe | 504 | * generation. The unit of MOT_THR is 1LSB = 2mg. Motion is detected when the |
Heidl | 0:d1960beb98fe | 505 | * absolute value of any of the accelerometer measurements exceeds this Motion |
Heidl | 0:d1960beb98fe | 506 | * detection threshold. This condition increments the Motion detection duration |
Heidl | 0:d1960beb98fe | 507 | * counter (Register 32). The Motion detection interrupt is triggered when the |
Heidl | 0:d1960beb98fe | 508 | * Motion Detection counter reaches the time count specified in MOT_DUR |
Heidl | 0:d1960beb98fe | 509 | * (Register 32). |
Heidl | 0:d1960beb98fe | 510 | * |
Heidl | 0:d1960beb98fe | 511 | * The Motion interrupt will indicate the axis and polarity of detected motion |
Heidl | 0:d1960beb98fe | 512 | * in MOT_DETECT_STATUS (Register 97). |
Heidl | 0:d1960beb98fe | 513 | * |
Heidl | 0:d1960beb98fe | 514 | * For more details on the Motion detection interrupt, see Section 8.3 of the |
Heidl | 0:d1960beb98fe | 515 | * MPU-6000/MPU-6050 Product Specification document as well as Registers 56 and |
Heidl | 0:d1960beb98fe | 516 | * 58 of this document. |
Heidl | 0:d1960beb98fe | 517 | * |
Heidl | 0:d1960beb98fe | 518 | * @return Current motion detection acceleration threshold value (LSB = 2mg) |
Heidl | 0:d1960beb98fe | 519 | * @see MPU6050_RA_MOT_THR |
Heidl | 0:d1960beb98fe | 520 | */ |
Heidl | 0:d1960beb98fe | 521 | uint8_t MPU6050::getMotionDetectionThreshold() |
Heidl | 0:d1960beb98fe | 522 | { |
Heidl | 0:d1960beb98fe | 523 | i2Cdev.readByte(devAddr, MPU6050_RA_MOT_THR, buffer); |
Heidl | 0:d1960beb98fe | 524 | return buffer[0]; |
Heidl | 0:d1960beb98fe | 525 | } |
Heidl | 0:d1960beb98fe | 526 | /** Set free-fall event acceleration threshold. |
Heidl | 0:d1960beb98fe | 527 | * @param threshold New motion detection acceleration threshold value (LSB = 2mg) |
Heidl | 0:d1960beb98fe | 528 | * @see getMotionDetectionThreshold() |
Heidl | 0:d1960beb98fe | 529 | * @see MPU6050_RA_MOT_THR |
Heidl | 0:d1960beb98fe | 530 | */ |
Heidl | 0:d1960beb98fe | 531 | void MPU6050::setMotionDetectionThreshold(uint8_t threshold) |
Heidl | 0:d1960beb98fe | 532 | { |
Heidl | 0:d1960beb98fe | 533 | i2Cdev.writeByte(devAddr, MPU6050_RA_MOT_THR, threshold); |
Heidl | 0:d1960beb98fe | 534 | } |
Heidl | 0:d1960beb98fe | 535 | |
Heidl | 0:d1960beb98fe | 536 | // MOT_DUR register |
Heidl | 0:d1960beb98fe | 537 | |
Heidl | 0:d1960beb98fe | 538 | /** Get motion detection event duration threshold. |
Heidl | 0:d1960beb98fe | 539 | * This register configures the duration counter threshold for Motion interrupt |
Heidl | 0:d1960beb98fe | 540 | * generation. The duration counter ticks at 1 kHz, therefore MOT_DUR has a unit |
Heidl | 0:d1960beb98fe | 541 | * of 1LSB = 1ms. The Motion detection duration counter increments when the |
Heidl | 0:d1960beb98fe | 542 | * absolute value of any of the accelerometer measurements exceeds the Motion |
Heidl | 0:d1960beb98fe | 543 | * detection threshold (Register 31). The Motion detection interrupt is |
Heidl | 0:d1960beb98fe | 544 | * triggered when the Motion detection counter reaches the time count specified |
Heidl | 0:d1960beb98fe | 545 | * in this register. |
Heidl | 0:d1960beb98fe | 546 | * |
Heidl | 0:d1960beb98fe | 547 | * For more details on the Motion detection interrupt, see Section 8.3 of the |
Heidl | 0:d1960beb98fe | 548 | * MPU-6000/MPU-6050 Product Specification document. |
Heidl | 0:d1960beb98fe | 549 | * |
Heidl | 0:d1960beb98fe | 550 | * @return Current motion detection duration threshold value (LSB = 1ms) |
Heidl | 0:d1960beb98fe | 551 | * @see MPU6050_RA_MOT_DUR |
Heidl | 0:d1960beb98fe | 552 | */ |
Heidl | 0:d1960beb98fe | 553 | uint8_t MPU6050::getMotionDetectionDuration() |
Heidl | 0:d1960beb98fe | 554 | { |
Heidl | 0:d1960beb98fe | 555 | i2Cdev.readByte(devAddr, MPU6050_RA_MOT_DUR, buffer); |
Heidl | 0:d1960beb98fe | 556 | return buffer[0]; |
Heidl | 0:d1960beb98fe | 557 | } |
Heidl | 0:d1960beb98fe | 558 | /** Set motion detection event duration threshold. |
Heidl | 0:d1960beb98fe | 559 | * @param duration New motion detection duration threshold value (LSB = 1ms) |
Heidl | 0:d1960beb98fe | 560 | * @see getMotionDetectionDuration() |
Heidl | 0:d1960beb98fe | 561 | * @see MPU6050_RA_MOT_DUR |
Heidl | 0:d1960beb98fe | 562 | */ |
Heidl | 0:d1960beb98fe | 563 | void MPU6050::setMotionDetectionDuration(uint8_t duration) |
Heidl | 0:d1960beb98fe | 564 | { |
Heidl | 0:d1960beb98fe | 565 | i2Cdev.writeByte(devAddr, MPU6050_RA_MOT_DUR, duration); |
Heidl | 0:d1960beb98fe | 566 | } |
Heidl | 0:d1960beb98fe | 567 | |
Heidl | 0:d1960beb98fe | 568 | // ZRMOT_THR register |
Heidl | 0:d1960beb98fe | 569 | |
Heidl | 0:d1960beb98fe | 570 | /** Get zero motion detection event acceleration threshold. |
Heidl | 0:d1960beb98fe | 571 | * This register configures the detection threshold for Zero Motion interrupt |
Heidl | 0:d1960beb98fe | 572 | * generation. The unit of ZRMOT_THR is 1LSB = 2mg. Zero Motion is detected when |
Heidl | 0:d1960beb98fe | 573 | * the absolute value of the accelerometer measurements for the 3 axes are each |
Heidl | 0:d1960beb98fe | 574 | * less than the detection threshold. This condition increments the Zero Motion |
Heidl | 0:d1960beb98fe | 575 | * duration counter (Register 34). The Zero Motion interrupt is triggered when |
Heidl | 0:d1960beb98fe | 576 | * the Zero Motion duration counter reaches the time count specified in |
Heidl | 0:d1960beb98fe | 577 | * ZRMOT_DUR (Register 34). |
Heidl | 0:d1960beb98fe | 578 | * |
Heidl | 0:d1960beb98fe | 579 | * Unlike Free Fall or Motion detection, Zero Motion detection triggers an |
Heidl | 0:d1960beb98fe | 580 | * interrupt both when Zero Motion is first detected and when Zero Motion is no |
Heidl | 0:d1960beb98fe | 581 | * longer detected. |
Heidl | 0:d1960beb98fe | 582 | * |
Heidl | 0:d1960beb98fe | 583 | * When a zero motion event is detected, a Zero Motion Status will be indicated |
Heidl | 0:d1960beb98fe | 584 | * in the MOT_DETECT_STATUS register (Register 97). When a motion-to-zero-motion |
Heidl | 0:d1960beb98fe | 585 | * condition is detected, the status bit is set to 1. When a zero-motion-to- |
Heidl | 0:d1960beb98fe | 586 | * motion condition is detected, the status bit is set to 0. |
Heidl | 0:d1960beb98fe | 587 | * |
Heidl | 0:d1960beb98fe | 588 | * For more details on the Zero Motion detection interrupt, see Section 8.4 of |
Heidl | 0:d1960beb98fe | 589 | * the MPU-6000/MPU-6050 Product Specification document as well as Registers 56 |
Heidl | 0:d1960beb98fe | 590 | * and 58 of this document. |
Heidl | 0:d1960beb98fe | 591 | * |
Heidl | 0:d1960beb98fe | 592 | * @return Current zero motion detection acceleration threshold value (LSB = 2mg) |
Heidl | 0:d1960beb98fe | 593 | * @see MPU6050_RA_ZRMOT_THR |
Heidl | 0:d1960beb98fe | 594 | */ |
Heidl | 0:d1960beb98fe | 595 | uint8_t MPU6050::getZeroMotionDetectionThreshold() |
Heidl | 0:d1960beb98fe | 596 | { |
Heidl | 0:d1960beb98fe | 597 | i2Cdev.readByte(devAddr, MPU6050_RA_ZRMOT_THR, buffer); |
Heidl | 0:d1960beb98fe | 598 | return buffer[0]; |
Heidl | 0:d1960beb98fe | 599 | } |
Heidl | 0:d1960beb98fe | 600 | /** Set zero motion detection event acceleration threshold. |
Heidl | 0:d1960beb98fe | 601 | * @param threshold New zero motion detection acceleration threshold value (LSB = 2mg) |
Heidl | 0:d1960beb98fe | 602 | * @see getZeroMotionDetectionThreshold() |
Heidl | 0:d1960beb98fe | 603 | * @see MPU6050_RA_ZRMOT_THR |
Heidl | 0:d1960beb98fe | 604 | */ |
Heidl | 0:d1960beb98fe | 605 | void MPU6050::setZeroMotionDetectionThreshold(uint8_t threshold) |
Heidl | 0:d1960beb98fe | 606 | { |
Heidl | 0:d1960beb98fe | 607 | i2Cdev.writeByte(devAddr, MPU6050_RA_ZRMOT_THR, threshold); |
Heidl | 0:d1960beb98fe | 608 | } |
Heidl | 0:d1960beb98fe | 609 | |
Heidl | 0:d1960beb98fe | 610 | // ZRMOT_DUR register |
Heidl | 0:d1960beb98fe | 611 | |
Heidl | 0:d1960beb98fe | 612 | /** Get zero motion detection event duration threshold. |
Heidl | 0:d1960beb98fe | 613 | * This register configures the duration counter threshold for Zero Motion |
Heidl | 0:d1960beb98fe | 614 | * interrupt generation. The duration counter ticks at 16 Hz, therefore |
Heidl | 0:d1960beb98fe | 615 | * ZRMOT_DUR has a unit of 1 LSB = 64 ms. The Zero Motion duration counter |
Heidl | 0:d1960beb98fe | 616 | * increments while the absolute value of the accelerometer measurements are |
Heidl | 0:d1960beb98fe | 617 | * each less than the detection threshold (Register 33). The Zero Motion |
Heidl | 0:d1960beb98fe | 618 | * interrupt is triggered when the Zero Motion duration counter reaches the time |
Heidl | 0:d1960beb98fe | 619 | * count specified in this register. |
Heidl | 0:d1960beb98fe | 620 | * |
Heidl | 0:d1960beb98fe | 621 | * For more details on the Zero Motion detection interrupt, see Section 8.4 of |
Heidl | 0:d1960beb98fe | 622 | * the MPU-6000/MPU-6050 Product Specification document, as well as Registers 56 |
Heidl | 0:d1960beb98fe | 623 | * and 58 of this document. |
Heidl | 0:d1960beb98fe | 624 | * |
Heidl | 0:d1960beb98fe | 625 | * @return Current zero motion detection duration threshold value (LSB = 64ms) |
Heidl | 0:d1960beb98fe | 626 | * @see MPU6050_RA_ZRMOT_DUR |
Heidl | 0:d1960beb98fe | 627 | */ |
Heidl | 0:d1960beb98fe | 628 | uint8_t MPU6050::getZeroMotionDetectionDuration() |
Heidl | 0:d1960beb98fe | 629 | { |
Heidl | 0:d1960beb98fe | 630 | i2Cdev.readByte(devAddr, MPU6050_RA_ZRMOT_DUR, buffer); |
Heidl | 0:d1960beb98fe | 631 | return buffer[0]; |
Heidl | 0:d1960beb98fe | 632 | } |
Heidl | 0:d1960beb98fe | 633 | /** Set zero motion detection event duration threshold. |
Heidl | 0:d1960beb98fe | 634 | * @param duration New zero motion detection duration threshold value (LSB = 1ms) |
Heidl | 0:d1960beb98fe | 635 | * @see getZeroMotionDetectionDuration() |
Heidl | 0:d1960beb98fe | 636 | * @see MPU6050_RA_ZRMOT_DUR |
Heidl | 0:d1960beb98fe | 637 | */ |
Heidl | 0:d1960beb98fe | 638 | void MPU6050::setZeroMotionDetectionDuration(uint8_t duration) |
Heidl | 0:d1960beb98fe | 639 | { |
Heidl | 0:d1960beb98fe | 640 | i2Cdev.writeByte(devAddr, MPU6050_RA_ZRMOT_DUR, duration); |
Heidl | 0:d1960beb98fe | 641 | } |
Heidl | 0:d1960beb98fe | 642 | |
Heidl | 0:d1960beb98fe | 643 | // FIFO_EN register |
Heidl | 0:d1960beb98fe | 644 | |
Heidl | 0:d1960beb98fe | 645 | /** Get temperature FIFO enabled value. |
Heidl | 0:d1960beb98fe | 646 | * When set to 1, this bit enables TEMP_OUT_H and TEMP_OUT_L (Registers 65 and |
Heidl | 0:d1960beb98fe | 647 | * 66) to be written into the FIFO buffer. |
Heidl | 0:d1960beb98fe | 648 | * @return Current temperature FIFO enabled value |
Heidl | 0:d1960beb98fe | 649 | * @see MPU6050_RA_FIFO_EN |
Heidl | 0:d1960beb98fe | 650 | */ |
Heidl | 0:d1960beb98fe | 651 | bool MPU6050::getTempFIFOEnabled() |
Heidl | 0:d1960beb98fe | 652 | { |
Heidl | 0:d1960beb98fe | 653 | i2Cdev.readBit(devAddr, MPU6050_RA_FIFO_EN, MPU6050_TEMP_FIFO_EN_BIT, buffer); |
Heidl | 0:d1960beb98fe | 654 | return buffer[0]; |
Heidl | 0:d1960beb98fe | 655 | } |
Heidl | 0:d1960beb98fe | 656 | /** Set temperature FIFO enabled value. |
Heidl | 0:d1960beb98fe | 657 | * @param enabled New temperature FIFO enabled value |
Heidl | 0:d1960beb98fe | 658 | * @see getTempFIFOEnabled() |
Heidl | 0:d1960beb98fe | 659 | * @see MPU6050_RA_FIFO_EN |
Heidl | 0:d1960beb98fe | 660 | */ |
Heidl | 0:d1960beb98fe | 661 | void MPU6050::setTempFIFOEnabled(bool enabled) |
Heidl | 0:d1960beb98fe | 662 | { |
Heidl | 0:d1960beb98fe | 663 | i2Cdev.writeBit(devAddr, MPU6050_RA_FIFO_EN, MPU6050_TEMP_FIFO_EN_BIT, enabled); |
Heidl | 0:d1960beb98fe | 664 | } |
Heidl | 0:d1960beb98fe | 665 | /** Get gyroscope X-axis FIFO enabled value. |
Heidl | 0:d1960beb98fe | 666 | * When set to 1, this bit enables GYRO_XOUT_H and GYRO_XOUT_L (Registers 67 and |
Heidl | 0:d1960beb98fe | 667 | * 68) to be written into the FIFO buffer. |
Heidl | 0:d1960beb98fe | 668 | * @return Current gyroscope X-axis FIFO enabled value |
Heidl | 0:d1960beb98fe | 669 | * @see MPU6050_RA_FIFO_EN |
Heidl | 0:d1960beb98fe | 670 | */ |
Heidl | 0:d1960beb98fe | 671 | bool MPU6050::getXGyroFIFOEnabled() |
Heidl | 0:d1960beb98fe | 672 | { |
Heidl | 0:d1960beb98fe | 673 | i2Cdev.readBit(devAddr, MPU6050_RA_FIFO_EN, MPU6050_XG_FIFO_EN_BIT, buffer); |
Heidl | 0:d1960beb98fe | 674 | return buffer[0]; |
Heidl | 0:d1960beb98fe | 675 | } |
Heidl | 0:d1960beb98fe | 676 | /** Set gyroscope X-axis FIFO enabled value. |
Heidl | 0:d1960beb98fe | 677 | * @param enabled New gyroscope X-axis FIFO enabled value |
Heidl | 0:d1960beb98fe | 678 | * @see getXGyroFIFOEnabled() |
Heidl | 0:d1960beb98fe | 679 | * @see MPU6050_RA_FIFO_EN |
Heidl | 0:d1960beb98fe | 680 | */ |
Heidl | 0:d1960beb98fe | 681 | void MPU6050::setXGyroFIFOEnabled(bool enabled) |
Heidl | 0:d1960beb98fe | 682 | { |
Heidl | 0:d1960beb98fe | 683 | i2Cdev.writeBit(devAddr, MPU6050_RA_FIFO_EN, MPU6050_XG_FIFO_EN_BIT, enabled); |
Heidl | 0:d1960beb98fe | 684 | } |
Heidl | 0:d1960beb98fe | 685 | /** Get gyroscope Y-axis FIFO enabled value. |
Heidl | 0:d1960beb98fe | 686 | * When set to 1, this bit enables GYRO_YOUT_H and GYRO_YOUT_L (Registers 69 and |
Heidl | 0:d1960beb98fe | 687 | * 70) to be written into the FIFO buffer. |
Heidl | 0:d1960beb98fe | 688 | * @return Current gyroscope Y-axis FIFO enabled value |
Heidl | 0:d1960beb98fe | 689 | * @see MPU6050_RA_FIFO_EN |
Heidl | 0:d1960beb98fe | 690 | */ |
Heidl | 0:d1960beb98fe | 691 | bool MPU6050::getYGyroFIFOEnabled() |
Heidl | 0:d1960beb98fe | 692 | { |
Heidl | 0:d1960beb98fe | 693 | i2Cdev.readBit(devAddr, MPU6050_RA_FIFO_EN, MPU6050_YG_FIFO_EN_BIT, buffer); |
Heidl | 0:d1960beb98fe | 694 | return buffer[0]; |
Heidl | 0:d1960beb98fe | 695 | } |
Heidl | 0:d1960beb98fe | 696 | /** Set gyroscope Y-axis FIFO enabled value. |
Heidl | 0:d1960beb98fe | 697 | * @param enabled New gyroscope Y-axis FIFO enabled value |
Heidl | 0:d1960beb98fe | 698 | * @see getYGyroFIFOEnabled() |
Heidl | 0:d1960beb98fe | 699 | * @see MPU6050_RA_FIFO_EN |
Heidl | 0:d1960beb98fe | 700 | */ |
Heidl | 0:d1960beb98fe | 701 | void MPU6050::setYGyroFIFOEnabled(bool enabled) |
Heidl | 0:d1960beb98fe | 702 | { |
Heidl | 0:d1960beb98fe | 703 | i2Cdev.writeBit(devAddr, MPU6050_RA_FIFO_EN, MPU6050_YG_FIFO_EN_BIT, enabled); |
Heidl | 0:d1960beb98fe | 704 | } |
Heidl | 0:d1960beb98fe | 705 | /** Get gyroscope Z-axis FIFO enabled value. |
Heidl | 0:d1960beb98fe | 706 | * When set to 1, this bit enables GYRO_ZOUT_H and GYRO_ZOUT_L (Registers 71 and |
Heidl | 0:d1960beb98fe | 707 | * 72) to be written into the FIFO buffer. |
Heidl | 0:d1960beb98fe | 708 | * @return Current gyroscope Z-axis FIFO enabled value |
Heidl | 0:d1960beb98fe | 709 | * @see MPU6050_RA_FIFO_EN |
Heidl | 0:d1960beb98fe | 710 | */ |
Heidl | 0:d1960beb98fe | 711 | bool MPU6050::getZGyroFIFOEnabled() |
Heidl | 0:d1960beb98fe | 712 | { |
Heidl | 0:d1960beb98fe | 713 | i2Cdev.readBit(devAddr, MPU6050_RA_FIFO_EN, MPU6050_ZG_FIFO_EN_BIT, buffer); |
Heidl | 0:d1960beb98fe | 714 | return buffer[0]; |
Heidl | 0:d1960beb98fe | 715 | } |
Heidl | 0:d1960beb98fe | 716 | /** Set gyroscope Z-axis FIFO enabled value. |
Heidl | 0:d1960beb98fe | 717 | * @param enabled New gyroscope Z-axis FIFO enabled value |
Heidl | 0:d1960beb98fe | 718 | * @see getZGyroFIFOEnabled() |
Heidl | 0:d1960beb98fe | 719 | * @see MPU6050_RA_FIFO_EN |
Heidl | 0:d1960beb98fe | 720 | */ |
Heidl | 0:d1960beb98fe | 721 | void MPU6050::setZGyroFIFOEnabled(bool enabled) |
Heidl | 0:d1960beb98fe | 722 | { |
Heidl | 0:d1960beb98fe | 723 | i2Cdev.writeBit(devAddr, MPU6050_RA_FIFO_EN, MPU6050_ZG_FIFO_EN_BIT, enabled); |
Heidl | 0:d1960beb98fe | 724 | } |
Heidl | 0:d1960beb98fe | 725 | /** Get accelerometer FIFO enabled value. |
Heidl | 0:d1960beb98fe | 726 | * When set to 1, this bit enables ACCEL_XOUT_H, ACCEL_XOUT_L, ACCEL_YOUT_H, |
Heidl | 0:d1960beb98fe | 727 | * ACCEL_YOUT_L, ACCEL_ZOUT_H, and ACCEL_ZOUT_L (Registers 59 to 64) to be |
Heidl | 0:d1960beb98fe | 728 | * written into the FIFO buffer. |
Heidl | 0:d1960beb98fe | 729 | * @return Current accelerometer FIFO enabled value |
Heidl | 0:d1960beb98fe | 730 | * @see MPU6050_RA_FIFO_EN |
Heidl | 0:d1960beb98fe | 731 | */ |
Heidl | 0:d1960beb98fe | 732 | bool MPU6050::getAccelFIFOEnabled() |
Heidl | 0:d1960beb98fe | 733 | { |
Heidl | 0:d1960beb98fe | 734 | i2Cdev.readBit(devAddr, MPU6050_RA_FIFO_EN, MPU6050_ACCEL_FIFO_EN_BIT, buffer); |
Heidl | 0:d1960beb98fe | 735 | return buffer[0]; |
Heidl | 0:d1960beb98fe | 736 | } |
Heidl | 0:d1960beb98fe | 737 | /** Set accelerometer FIFO enabled value. |
Heidl | 0:d1960beb98fe | 738 | * @param enabled New accelerometer FIFO enabled value |
Heidl | 0:d1960beb98fe | 739 | * @see getAccelFIFOEnabled() |
Heidl | 0:d1960beb98fe | 740 | * @see MPU6050_RA_FIFO_EN |
Heidl | 0:d1960beb98fe | 741 | */ |
Heidl | 0:d1960beb98fe | 742 | void MPU6050::setAccelFIFOEnabled(bool enabled) |
Heidl | 0:d1960beb98fe | 743 | { |
Heidl | 0:d1960beb98fe | 744 | i2Cdev.writeBit(devAddr, MPU6050_RA_FIFO_EN, MPU6050_ACCEL_FIFO_EN_BIT, enabled); |
Heidl | 0:d1960beb98fe | 745 | } |
Heidl | 0:d1960beb98fe | 746 | /** Get Slave 2 FIFO enabled value. |
Heidl | 0:d1960beb98fe | 747 | * When set to 1, this bit enables EXT_SENS_DATA registers (Registers 73 to 96) |
Heidl | 0:d1960beb98fe | 748 | * associated with Slave 2 to be written into the FIFO buffer. |
Heidl | 0:d1960beb98fe | 749 | * @return Current Slave 2 FIFO enabled value |
Heidl | 0:d1960beb98fe | 750 | * @see MPU6050_RA_FIFO_EN |
Heidl | 0:d1960beb98fe | 751 | */ |
Heidl | 0:d1960beb98fe | 752 | bool MPU6050::getSlave2FIFOEnabled() |
Heidl | 0:d1960beb98fe | 753 | { |
Heidl | 0:d1960beb98fe | 754 | i2Cdev.readBit(devAddr, MPU6050_RA_FIFO_EN, MPU6050_SLV2_FIFO_EN_BIT, buffer); |
Heidl | 0:d1960beb98fe | 755 | return buffer[0]; |
Heidl | 0:d1960beb98fe | 756 | } |
Heidl | 0:d1960beb98fe | 757 | /** Set Slave 2 FIFO enabled value. |
Heidl | 0:d1960beb98fe | 758 | * @param enabled New Slave 2 FIFO enabled value |
Heidl | 0:d1960beb98fe | 759 | * @see getSlave2FIFOEnabled() |
Heidl | 0:d1960beb98fe | 760 | * @see MPU6050_RA_FIFO_EN |
Heidl | 0:d1960beb98fe | 761 | */ |
Heidl | 0:d1960beb98fe | 762 | void MPU6050::setSlave2FIFOEnabled(bool enabled) |
Heidl | 0:d1960beb98fe | 763 | { |
Heidl | 0:d1960beb98fe | 764 | i2Cdev.writeBit(devAddr, MPU6050_RA_FIFO_EN, MPU6050_SLV2_FIFO_EN_BIT, enabled); |
Heidl | 0:d1960beb98fe | 765 | } |
Heidl | 0:d1960beb98fe | 766 | /** Get Slave 1 FIFO enabled value. |
Heidl | 0:d1960beb98fe | 767 | * When set to 1, this bit enables EXT_SENS_DATA registers (Registers 73 to 96) |
Heidl | 0:d1960beb98fe | 768 | * associated with Slave 1 to be written into the FIFO buffer. |
Heidl | 0:d1960beb98fe | 769 | * @return Current Slave 1 FIFO enabled value |
Heidl | 0:d1960beb98fe | 770 | * @see MPU6050_RA_FIFO_EN |
Heidl | 0:d1960beb98fe | 771 | */ |
Heidl | 0:d1960beb98fe | 772 | bool MPU6050::getSlave1FIFOEnabled() |
Heidl | 0:d1960beb98fe | 773 | { |
Heidl | 0:d1960beb98fe | 774 | i2Cdev.readBit(devAddr, MPU6050_RA_FIFO_EN, MPU6050_SLV1_FIFO_EN_BIT, buffer); |
Heidl | 0:d1960beb98fe | 775 | return buffer[0]; |
Heidl | 0:d1960beb98fe | 776 | } |
Heidl | 0:d1960beb98fe | 777 | /** Set Slave 1 FIFO enabled value. |
Heidl | 0:d1960beb98fe | 778 | * @param enabled New Slave 1 FIFO enabled value |
Heidl | 0:d1960beb98fe | 779 | * @see getSlave1FIFOEnabled() |
Heidl | 0:d1960beb98fe | 780 | * @see MPU6050_RA_FIFO_EN |
Heidl | 0:d1960beb98fe | 781 | */ |
Heidl | 0:d1960beb98fe | 782 | void MPU6050::setSlave1FIFOEnabled(bool enabled) |
Heidl | 0:d1960beb98fe | 783 | { |
Heidl | 0:d1960beb98fe | 784 | i2Cdev.writeBit(devAddr, MPU6050_RA_FIFO_EN, MPU6050_SLV1_FIFO_EN_BIT, enabled); |
Heidl | 0:d1960beb98fe | 785 | } |
Heidl | 0:d1960beb98fe | 786 | /** Get Slave 0 FIFO enabled value. |
Heidl | 0:d1960beb98fe | 787 | * When set to 1, this bit enables EXT_SENS_DATA registers (Registers 73 to 96) |
Heidl | 0:d1960beb98fe | 788 | * associated with Slave 0 to be written into the FIFO buffer. |
Heidl | 0:d1960beb98fe | 789 | * @return Current Slave 0 FIFO enabled value |
Heidl | 0:d1960beb98fe | 790 | * @see MPU6050_RA_FIFO_EN |
Heidl | 0:d1960beb98fe | 791 | */ |
Heidl | 0:d1960beb98fe | 792 | bool MPU6050::getSlave0FIFOEnabled() |
Heidl | 0:d1960beb98fe | 793 | { |
Heidl | 0:d1960beb98fe | 794 | i2Cdev.readBit(devAddr, MPU6050_RA_FIFO_EN, MPU6050_SLV0_FIFO_EN_BIT, buffer); |
Heidl | 0:d1960beb98fe | 795 | return buffer[0]; |
Heidl | 0:d1960beb98fe | 796 | } |
Heidl | 0:d1960beb98fe | 797 | /** Set Slave 0 FIFO enabled value. |
Heidl | 0:d1960beb98fe | 798 | * @param enabled New Slave 0 FIFO enabled value |
Heidl | 0:d1960beb98fe | 799 | * @see getSlave0FIFOEnabled() |
Heidl | 0:d1960beb98fe | 800 | * @see MPU6050_RA_FIFO_EN |
Heidl | 0:d1960beb98fe | 801 | */ |
Heidl | 0:d1960beb98fe | 802 | void MPU6050::setSlave0FIFOEnabled(bool enabled) |
Heidl | 0:d1960beb98fe | 803 | { |
Heidl | 0:d1960beb98fe | 804 | i2Cdev.writeBit(devAddr, MPU6050_RA_FIFO_EN, MPU6050_SLV0_FIFO_EN_BIT, enabled); |
Heidl | 0:d1960beb98fe | 805 | } |
Heidl | 0:d1960beb98fe | 806 | |
Heidl | 0:d1960beb98fe | 807 | // I2C_MST_CTRL register |
Heidl | 0:d1960beb98fe | 808 | |
Heidl | 0:d1960beb98fe | 809 | /** Get multi-master enabled value. |
Heidl | 0:d1960beb98fe | 810 | * Multi-master capability allows multiple I2C masters to operate on the same |
Heidl | 0:d1960beb98fe | 811 | * bus. In circuits where multi-master capability is required, set MULT_MST_EN |
Heidl | 0:d1960beb98fe | 812 | * to 1. This will increase current drawn by approximately 30uA. |
Heidl | 0:d1960beb98fe | 813 | * |
Heidl | 0:d1960beb98fe | 814 | * In circuits where multi-master capability is required, the state of the I2C |
Heidl | 0:d1960beb98fe | 815 | * bus must always be monitored by each separate I2C Master. Before an I2C |
Heidl | 0:d1960beb98fe | 816 | * Master can assume arbitration of the bus, it must first confirm that no other |
Heidl | 0:d1960beb98fe | 817 | * I2C Master has arbitration of the bus. When MULT_MST_EN is set to 1, the |
Heidl | 0:d1960beb98fe | 818 | * MPU-60X0's bus arbitration detection logic is turned on, enabling it to |
Heidl | 0:d1960beb98fe | 819 | * detect when the bus is available. |
Heidl | 0:d1960beb98fe | 820 | * |
Heidl | 0:d1960beb98fe | 821 | * @return Current multi-master enabled value |
Heidl | 0:d1960beb98fe | 822 | * @see MPU6050_RA_I2C_MST_CTRL |
Heidl | 0:d1960beb98fe | 823 | */ |
Heidl | 0:d1960beb98fe | 824 | bool MPU6050::getMultiMasterEnabled() |
Heidl | 0:d1960beb98fe | 825 | { |
Heidl | 0:d1960beb98fe | 826 | i2Cdev.readBit(devAddr, MPU6050_RA_I2C_MST_CTRL, MPU6050_MULT_MST_EN_BIT, buffer); |
Heidl | 0:d1960beb98fe | 827 | return buffer[0]; |
Heidl | 0:d1960beb98fe | 828 | } |
Heidl | 0:d1960beb98fe | 829 | /** Set multi-master enabled value. |
Heidl | 0:d1960beb98fe | 830 | * @param enabled New multi-master enabled value |
Heidl | 0:d1960beb98fe | 831 | * @see getMultiMasterEnabled() |
Heidl | 0:d1960beb98fe | 832 | * @see MPU6050_RA_I2C_MST_CTRL |
Heidl | 0:d1960beb98fe | 833 | */ |
Heidl | 0:d1960beb98fe | 834 | void MPU6050::setMultiMasterEnabled(bool enabled) |
Heidl | 0:d1960beb98fe | 835 | { |
Heidl | 0:d1960beb98fe | 836 | i2Cdev.writeBit(devAddr, MPU6050_RA_I2C_MST_CTRL, MPU6050_MULT_MST_EN_BIT, enabled); |
Heidl | 0:d1960beb98fe | 837 | } |
Heidl | 0:d1960beb98fe | 838 | /** Get wait-for-external-sensor-data enabled value. |
Heidl | 0:d1960beb98fe | 839 | * When the WAIT_FOR_ES bit is set to 1, the Data Ready interrupt will be |
Heidl | 0:d1960beb98fe | 840 | * delayed until External Sensor data from the Slave Devices are loaded into the |
Heidl | 0:d1960beb98fe | 841 | * EXT_SENS_DATA registers. This is used to ensure that both the internal sensor |
Heidl | 0:d1960beb98fe | 842 | * data (i.e. from gyro and accel) and external sensor data have been loaded to |
Heidl | 0:d1960beb98fe | 843 | * their respective data registers (i.e. the data is synced) when the Data Ready |
Heidl | 0:d1960beb98fe | 844 | * interrupt is triggered. |
Heidl | 0:d1960beb98fe | 845 | * |
Heidl | 0:d1960beb98fe | 846 | * @return Current wait-for-external-sensor-data enabled value |
Heidl | 0:d1960beb98fe | 847 | * @see MPU6050_RA_I2C_MST_CTRL |
Heidl | 0:d1960beb98fe | 848 | */ |
Heidl | 0:d1960beb98fe | 849 | bool MPU6050::getWaitForExternalSensorEnabled() |
Heidl | 0:d1960beb98fe | 850 | { |
Heidl | 0:d1960beb98fe | 851 | i2Cdev.readBit(devAddr, MPU6050_RA_I2C_MST_CTRL, MPU6050_WAIT_FOR_ES_BIT, buffer); |
Heidl | 0:d1960beb98fe | 852 | return buffer[0]; |
Heidl | 0:d1960beb98fe | 853 | } |
Heidl | 0:d1960beb98fe | 854 | /** Set wait-for-external-sensor-data enabled value. |
Heidl | 0:d1960beb98fe | 855 | * @param enabled New wait-for-external-sensor-data enabled value |
Heidl | 0:d1960beb98fe | 856 | * @see getWaitForExternalSensorEnabled() |
Heidl | 0:d1960beb98fe | 857 | * @see MPU6050_RA_I2C_MST_CTRL |
Heidl | 0:d1960beb98fe | 858 | */ |
Heidl | 0:d1960beb98fe | 859 | void MPU6050::setWaitForExternalSensorEnabled(bool enabled) |
Heidl | 0:d1960beb98fe | 860 | { |
Heidl | 0:d1960beb98fe | 861 | i2Cdev.writeBit(devAddr, MPU6050_RA_I2C_MST_CTRL, MPU6050_WAIT_FOR_ES_BIT, enabled); |
Heidl | 0:d1960beb98fe | 862 | } |
Heidl | 0:d1960beb98fe | 863 | /** Get Slave 3 FIFO enabled value. |
Heidl | 0:d1960beb98fe | 864 | * When set to 1, this bit enables EXT_SENS_DATA registers (Registers 73 to 96) |
Heidl | 0:d1960beb98fe | 865 | * associated with Slave 3 to be written into the FIFO buffer. |
Heidl | 0:d1960beb98fe | 866 | * @return Current Slave 3 FIFO enabled value |
Heidl | 0:d1960beb98fe | 867 | * @see MPU6050_RA_MST_CTRL |
Heidl | 0:d1960beb98fe | 868 | */ |
Heidl | 0:d1960beb98fe | 869 | bool MPU6050::getSlave3FIFOEnabled() |
Heidl | 0:d1960beb98fe | 870 | { |
Heidl | 0:d1960beb98fe | 871 | i2Cdev.readBit(devAddr, MPU6050_RA_I2C_MST_CTRL, MPU6050_SLV_3_FIFO_EN_BIT, buffer); |
Heidl | 0:d1960beb98fe | 872 | return buffer[0]; |
Heidl | 0:d1960beb98fe | 873 | } |
Heidl | 0:d1960beb98fe | 874 | /** Set Slave 3 FIFO enabled value. |
Heidl | 0:d1960beb98fe | 875 | * @param enabled New Slave 3 FIFO enabled value |
Heidl | 0:d1960beb98fe | 876 | * @see getSlave3FIFOEnabled() |
Heidl | 0:d1960beb98fe | 877 | * @see MPU6050_RA_MST_CTRL |
Heidl | 0:d1960beb98fe | 878 | */ |
Heidl | 0:d1960beb98fe | 879 | void MPU6050::setSlave3FIFOEnabled(bool enabled) |
Heidl | 0:d1960beb98fe | 880 | { |
Heidl | 0:d1960beb98fe | 881 | i2Cdev.writeBit(devAddr, MPU6050_RA_I2C_MST_CTRL, MPU6050_SLV_3_FIFO_EN_BIT, enabled); |
Heidl | 0:d1960beb98fe | 882 | } |
Heidl | 0:d1960beb98fe | 883 | /** Get slave read/write transition enabled value. |
Heidl | 0:d1960beb98fe | 884 | * The I2C_MST_P_NSR bit configures the I2C Master's transition from one slave |
Heidl | 0:d1960beb98fe | 885 | * read to the next slave read. If the bit equals 0, there will be a restart |
Heidl | 0:d1960beb98fe | 886 | * between reads. If the bit equals 1, there will be a stop followed by a start |
Heidl | 0:d1960beb98fe | 887 | * of the following read. When a write transaction follows a read transaction, |
Heidl | 0:d1960beb98fe | 888 | * the stop followed by a start of the successive write will be always used. |
Heidl | 0:d1960beb98fe | 889 | * |
Heidl | 0:d1960beb98fe | 890 | * @return Current slave read/write transition enabled value |
Heidl | 0:d1960beb98fe | 891 | * @see MPU6050_RA_I2C_MST_CTRL |
Heidl | 0:d1960beb98fe | 892 | */ |
Heidl | 0:d1960beb98fe | 893 | bool MPU6050::getSlaveReadWriteTransitionEnabled() |
Heidl | 0:d1960beb98fe | 894 | { |
Heidl | 0:d1960beb98fe | 895 | i2Cdev.readBit(devAddr, MPU6050_RA_I2C_MST_CTRL, MPU6050_I2C_MST_P_NSR_BIT, buffer); |
Heidl | 0:d1960beb98fe | 896 | return buffer[0]; |
Heidl | 0:d1960beb98fe | 897 | } |
Heidl | 0:d1960beb98fe | 898 | /** Set slave read/write transition enabled value. |
Heidl | 0:d1960beb98fe | 899 | * @param enabled New slave read/write transition enabled value |
Heidl | 0:d1960beb98fe | 900 | * @see getSlaveReadWriteTransitionEnabled() |
Heidl | 0:d1960beb98fe | 901 | * @see MPU6050_RA_I2C_MST_CTRL |
Heidl | 0:d1960beb98fe | 902 | */ |
Heidl | 0:d1960beb98fe | 903 | void MPU6050::setSlaveReadWriteTransitionEnabled(bool enabled) |
Heidl | 0:d1960beb98fe | 904 | { |
Heidl | 0:d1960beb98fe | 905 | i2Cdev.writeBit(devAddr, MPU6050_RA_I2C_MST_CTRL, MPU6050_I2C_MST_P_NSR_BIT, enabled); |
Heidl | 0:d1960beb98fe | 906 | } |
Heidl | 0:d1960beb98fe | 907 | /** Get I2C master clock speed. |
Heidl | 0:d1960beb98fe | 908 | * I2C_MST_CLK is a 4 bit unsigned value which configures a divider on the |
Heidl | 0:d1960beb98fe | 909 | * MPU-60X0 internal 8MHz clock. It sets the I2C master clock speed according to |
Heidl | 0:d1960beb98fe | 910 | * the following table: |
Heidl | 0:d1960beb98fe | 911 | * |
Heidl | 0:d1960beb98fe | 912 | * <pre> |
Heidl | 0:d1960beb98fe | 913 | * I2C_MST_CLK | I2C Master Clock Speed | 8MHz Clock Divider |
Heidl | 0:d1960beb98fe | 914 | * ------------+------------------------+------------------- |
Heidl | 0:d1960beb98fe | 915 | * 0 | 348kHz | 23 |
Heidl | 0:d1960beb98fe | 916 | * 1 | 333kHz | 24 |
Heidl | 0:d1960beb98fe | 917 | * 2 | 320kHz | 25 |
Heidl | 0:d1960beb98fe | 918 | * 3 | 308kHz | 26 |
Heidl | 0:d1960beb98fe | 919 | * 4 | 296kHz | 27 |
Heidl | 0:d1960beb98fe | 920 | * 5 | 286kHz | 28 |
Heidl | 0:d1960beb98fe | 921 | * 6 | 276kHz | 29 |
Heidl | 0:d1960beb98fe | 922 | * 7 | 267kHz | 30 |
Heidl | 0:d1960beb98fe | 923 | * 8 | 258kHz | 31 |
Heidl | 0:d1960beb98fe | 924 | * 9 | 500kHz | 16 |
Heidl | 0:d1960beb98fe | 925 | * 10 | 471kHz | 17 |
Heidl | 0:d1960beb98fe | 926 | * 11 | 444kHz | 18 |
Heidl | 0:d1960beb98fe | 927 | * 12 | 421kHz | 19 |
Heidl | 0:d1960beb98fe | 928 | * 13 | 400kHz | 20 |
Heidl | 0:d1960beb98fe | 929 | * 14 | 381kHz | 21 |
Heidl | 0:d1960beb98fe | 930 | * 15 | 364kHz | 22 |
Heidl | 0:d1960beb98fe | 931 | * </pre> |
Heidl | 0:d1960beb98fe | 932 | * |
Heidl | 0:d1960beb98fe | 933 | * @return Current I2C master clock speed |
Heidl | 0:d1960beb98fe | 934 | * @see MPU6050_RA_I2C_MST_CTRL |
Heidl | 0:d1960beb98fe | 935 | */ |
Heidl | 0:d1960beb98fe | 936 | uint8_t MPU6050::getMasterClockSpeed() |
Heidl | 0:d1960beb98fe | 937 | { |
Heidl | 0:d1960beb98fe | 938 | i2Cdev.readBits(devAddr, MPU6050_RA_I2C_MST_CTRL, MPU6050_I2C_MST_CLK_BIT, MPU6050_I2C_MST_CLK_LENGTH, buffer); |
Heidl | 0:d1960beb98fe | 939 | return buffer[0]; |
Heidl | 0:d1960beb98fe | 940 | } |
Heidl | 0:d1960beb98fe | 941 | /** Set I2C master clock speed. |
Heidl | 0:d1960beb98fe | 942 | * @reparam speed Current I2C master clock speed |
Heidl | 0:d1960beb98fe | 943 | * @see MPU6050_RA_I2C_MST_CTRL |
Heidl | 0:d1960beb98fe | 944 | */ |
Heidl | 0:d1960beb98fe | 945 | void MPU6050::setMasterClockSpeed(uint8_t speed) |
Heidl | 0:d1960beb98fe | 946 | { |
Heidl | 0:d1960beb98fe | 947 | i2Cdev.writeBits(devAddr, MPU6050_RA_I2C_MST_CTRL, MPU6050_I2C_MST_CLK_BIT, MPU6050_I2C_MST_CLK_LENGTH, speed); |
Heidl | 0:d1960beb98fe | 948 | } |
Heidl | 0:d1960beb98fe | 949 | |
Heidl | 0:d1960beb98fe | 950 | // I2C_SLV* registers (Slave 0-3) |
Heidl | 0:d1960beb98fe | 951 | |
Heidl | 0:d1960beb98fe | 952 | /** Get the I2C address of the specified slave (0-3). |
Heidl | 0:d1960beb98fe | 953 | * Note that Bit 7 (MSB) controls read/write mode. If Bit 7 is set, it's a read |
Heidl | 0:d1960beb98fe | 954 | * operation, and if it is cleared, then it's a write operation. The remaining |
Heidl | 0:d1960beb98fe | 955 | * bits (6-0) are the 7-bit device address of the slave device. |
Heidl | 0:d1960beb98fe | 956 | * |
Heidl | 0:d1960beb98fe | 957 | * In read mode, the result of the read is placed in the lowest available |
Heidl | 0:d1960beb98fe | 958 | * EXT_SENS_DATA register. For further information regarding the allocation of |
Heidl | 0:d1960beb98fe | 959 | * read results, please refer to the EXT_SENS_DATA register description |
Heidl | 0:d1960beb98fe | 960 | * (Registers 73 - 96). |
Heidl | 0:d1960beb98fe | 961 | * |
Heidl | 0:d1960beb98fe | 962 | * The MPU-6050 supports a total of five slaves, but Slave 4 has unique |
Heidl | 0:d1960beb98fe | 963 | * characteristics, and so it has its own functions (getSlave4* and setSlave4*). |
Heidl | 0:d1960beb98fe | 964 | * |
Heidl | 0:d1960beb98fe | 965 | * I2C data transactions are performed at the Sample Rate, as defined in |
Heidl | 0:d1960beb98fe | 966 | * Register 25. The user is responsible for ensuring that I2C data transactions |
Heidl | 0:d1960beb98fe | 967 | * to and from each enabled Slave can be completed within a single period of the |
Heidl | 0:d1960beb98fe | 968 | * Sample Rate. |
Heidl | 0:d1960beb98fe | 969 | * |
Heidl | 0:d1960beb98fe | 970 | * The I2C slave access rate can be reduced relative to the Sample Rate. This |
Heidl | 0:d1960beb98fe | 971 | * reduced access rate is determined by I2C_MST_DLY (Register 52). Whether a |
Heidl | 0:d1960beb98fe | 972 | * slave's access rate is reduced relative to the Sample Rate is determined by |
Heidl | 0:d1960beb98fe | 973 | * I2C_MST_DELAY_CTRL (Register 103). |
Heidl | 0:d1960beb98fe | 974 | * |
Heidl | 0:d1960beb98fe | 975 | * The processing order for the slaves is fixed. The sequence followed for |
Heidl | 0:d1960beb98fe | 976 | * processing the slaves is Slave 0, Slave 1, Slave 2, Slave 3 and Slave 4. If a |
Heidl | 0:d1960beb98fe | 977 | * particular Slave is disabled it will be skipped. |
Heidl | 0:d1960beb98fe | 978 | * |
Heidl | 0:d1960beb98fe | 979 | * Each slave can either be accessed at the sample rate or at a reduced sample |
Heidl | 0:d1960beb98fe | 980 | * rate. In a case where some slaves are accessed at the Sample Rate and some |
Heidl | 0:d1960beb98fe | 981 | * slaves are accessed at the reduced rate, the sequence of accessing the slaves |
Heidl | 0:d1960beb98fe | 982 | * (Slave 0 to Slave 4) is still followed. However, the reduced rate slaves will |
Heidl | 0:d1960beb98fe | 983 | * be skipped if their access rate dictates that they should not be accessed |
Heidl | 0:d1960beb98fe | 984 | * during that particular cycle. For further information regarding the reduced |
Heidl | 0:d1960beb98fe | 985 | * access rate, please refer to Register 52. Whether a slave is accessed at the |
Heidl | 0:d1960beb98fe | 986 | * Sample Rate or at the reduced rate is determined by the Delay Enable bits in |
Heidl | 0:d1960beb98fe | 987 | * Register 103. |
Heidl | 0:d1960beb98fe | 988 | * |
Heidl | 0:d1960beb98fe | 989 | * @param num Slave number (0-3) |
Heidl | 0:d1960beb98fe | 990 | * @return Current address for specified slave |
Heidl | 0:d1960beb98fe | 991 | * @see MPU6050_RA_I2C_SLV0_ADDR |
Heidl | 0:d1960beb98fe | 992 | */ |
Heidl | 0:d1960beb98fe | 993 | uint8_t MPU6050::getSlaveAddress(uint8_t num) |
Heidl | 0:d1960beb98fe | 994 | { |
Heidl | 0:d1960beb98fe | 995 | if (num > 3) return 0; |
Heidl | 0:d1960beb98fe | 996 | i2Cdev.readByte(devAddr, MPU6050_RA_I2C_SLV0_ADDR + num*3, buffer); |
Heidl | 0:d1960beb98fe | 997 | return buffer[0]; |
Heidl | 0:d1960beb98fe | 998 | } |
Heidl | 0:d1960beb98fe | 999 | /** Set the I2C address of the specified slave (0-3). |
Heidl | 0:d1960beb98fe | 1000 | * @param num Slave number (0-3) |
Heidl | 0:d1960beb98fe | 1001 | * @param address New address for specified slave |
Heidl | 0:d1960beb98fe | 1002 | * @see getSlaveAddress() |
Heidl | 0:d1960beb98fe | 1003 | * @see MPU6050_RA_I2C_SLV0_ADDR |
Heidl | 0:d1960beb98fe | 1004 | */ |
Heidl | 0:d1960beb98fe | 1005 | void MPU6050::setSlaveAddress(uint8_t num, uint8_t address) |
Heidl | 0:d1960beb98fe | 1006 | { |
Heidl | 0:d1960beb98fe | 1007 | if (num > 3) return; |
Heidl | 0:d1960beb98fe | 1008 | i2Cdev.writeByte(devAddr, MPU6050_RA_I2C_SLV0_ADDR + num*3, address); |
Heidl | 0:d1960beb98fe | 1009 | } |
Heidl | 0:d1960beb98fe | 1010 | /** Get the active internal register for the specified slave (0-3). |
Heidl | 0:d1960beb98fe | 1011 | * Read/write operations for this slave will be done to whatever internal |
Heidl | 0:d1960beb98fe | 1012 | * register address is stored in this MPU register. |
Heidl | 0:d1960beb98fe | 1013 | * |
Heidl | 0:d1960beb98fe | 1014 | * The MPU-6050 supports a total of five slaves, but Slave 4 has unique |
Heidl | 0:d1960beb98fe | 1015 | * characteristics, and so it has its own functions. |
Heidl | 0:d1960beb98fe | 1016 | * |
Heidl | 0:d1960beb98fe | 1017 | * @param num Slave number (0-3) |
Heidl | 0:d1960beb98fe | 1018 | * @return Current active register for specified slave |
Heidl | 0:d1960beb98fe | 1019 | * @see MPU6050_RA_I2C_SLV0_REG |
Heidl | 0:d1960beb98fe | 1020 | */ |
Heidl | 0:d1960beb98fe | 1021 | uint8_t MPU6050::getSlaveRegister(uint8_t num) |
Heidl | 0:d1960beb98fe | 1022 | { |
Heidl | 0:d1960beb98fe | 1023 | if (num > 3) return 0; |
Heidl | 0:d1960beb98fe | 1024 | i2Cdev.readByte(devAddr, MPU6050_RA_I2C_SLV0_REG + num*3, buffer); |
Heidl | 0:d1960beb98fe | 1025 | return buffer[0]; |
Heidl | 0:d1960beb98fe | 1026 | } |
Heidl | 0:d1960beb98fe | 1027 | /** Set the active internal register for the specified slave (0-3). |
Heidl | 0:d1960beb98fe | 1028 | * @param num Slave number (0-3) |
Heidl | 0:d1960beb98fe | 1029 | * @param reg New active register for specified slave |
Heidl | 0:d1960beb98fe | 1030 | * @see getSlaveRegister() |
Heidl | 0:d1960beb98fe | 1031 | * @see MPU6050_RA_I2C_SLV0_REG |
Heidl | 0:d1960beb98fe | 1032 | */ |
Heidl | 0:d1960beb98fe | 1033 | void MPU6050::setSlaveRegister(uint8_t num, uint8_t reg) |
Heidl | 0:d1960beb98fe | 1034 | { |
Heidl | 0:d1960beb98fe | 1035 | if (num > 3) return; |
Heidl | 0:d1960beb98fe | 1036 | i2Cdev.writeByte(devAddr, MPU6050_RA_I2C_SLV0_REG + num*3, reg); |
Heidl | 0:d1960beb98fe | 1037 | } |
Heidl | 0:d1960beb98fe | 1038 | /** Get the enabled value for the specified slave (0-3). |
Heidl | 0:d1960beb98fe | 1039 | * When set to 1, this bit enables Slave 0 for data transfer operations. When |
Heidl | 0:d1960beb98fe | 1040 | * cleared to 0, this bit disables Slave 0 from data transfer operations. |
Heidl | 0:d1960beb98fe | 1041 | * @param num Slave number (0-3) |
Heidl | 0:d1960beb98fe | 1042 | * @return Current enabled value for specified slave |
Heidl | 0:d1960beb98fe | 1043 | * @see MPU6050_RA_I2C_SLV0_CTRL |
Heidl | 0:d1960beb98fe | 1044 | */ |
Heidl | 0:d1960beb98fe | 1045 | bool MPU6050::getSlaveEnabled(uint8_t num) |
Heidl | 0:d1960beb98fe | 1046 | { |
Heidl | 0:d1960beb98fe | 1047 | if (num > 3) return 0; |
Heidl | 0:d1960beb98fe | 1048 | i2Cdev.readBit(devAddr, MPU6050_RA_I2C_SLV0_CTRL + num*3, MPU6050_I2C_SLV_EN_BIT, buffer); |
Heidl | 0:d1960beb98fe | 1049 | return buffer[0]; |
Heidl | 0:d1960beb98fe | 1050 | } |
Heidl | 0:d1960beb98fe | 1051 | /** Set the enabled value for the specified slave (0-3). |
Heidl | 0:d1960beb98fe | 1052 | * @param num Slave number (0-3) |
Heidl | 0:d1960beb98fe | 1053 | * @param enabled New enabled value for specified slave |
Heidl | 0:d1960beb98fe | 1054 | * @see getSlaveEnabled() |
Heidl | 0:d1960beb98fe | 1055 | * @see MPU6050_RA_I2C_SLV0_CTRL |
Heidl | 0:d1960beb98fe | 1056 | */ |
Heidl | 0:d1960beb98fe | 1057 | void MPU6050::setSlaveEnabled(uint8_t num, bool enabled) |
Heidl | 0:d1960beb98fe | 1058 | { |
Heidl | 0:d1960beb98fe | 1059 | if (num > 3) return; |
Heidl | 0:d1960beb98fe | 1060 | i2Cdev.writeBit(devAddr, MPU6050_RA_I2C_SLV0_CTRL + num*3, MPU6050_I2C_SLV_EN_BIT, enabled); |
Heidl | 0:d1960beb98fe | 1061 | } |
Heidl | 0:d1960beb98fe | 1062 | /** Get word pair byte-swapping enabled for the specified slave (0-3). |
Heidl | 0:d1960beb98fe | 1063 | * When set to 1, this bit enables byte swapping. When byte swapping is enabled, |
Heidl | 0:d1960beb98fe | 1064 | * the high and low bytes of a word pair are swapped. Please refer to |
Heidl | 0:d1960beb98fe | 1065 | * I2C_SLV0_GRP for the pairing convention of the word pairs. When cleared to 0, |
Heidl | 0:d1960beb98fe | 1066 | * bytes transferred to and from Slave 0 will be written to EXT_SENS_DATA |
Heidl | 0:d1960beb98fe | 1067 | * registers in the order they were transferred. |
Heidl | 0:d1960beb98fe | 1068 | * |
Heidl | 0:d1960beb98fe | 1069 | * @param num Slave number (0-3) |
Heidl | 0:d1960beb98fe | 1070 | * @return Current word pair byte-swapping enabled value for specified slave |
Heidl | 0:d1960beb98fe | 1071 | * @see MPU6050_RA_I2C_SLV0_CTRL |
Heidl | 0:d1960beb98fe | 1072 | */ |
Heidl | 0:d1960beb98fe | 1073 | bool MPU6050::getSlaveWordByteSwap(uint8_t num) |
Heidl | 0:d1960beb98fe | 1074 | { |
Heidl | 0:d1960beb98fe | 1075 | if (num > 3) return 0; |
Heidl | 0:d1960beb98fe | 1076 | i2Cdev.readBit(devAddr, MPU6050_RA_I2C_SLV0_CTRL + num*3, MPU6050_I2C_SLV_BYTE_SW_BIT, buffer); |
Heidl | 0:d1960beb98fe | 1077 | return buffer[0]; |
Heidl | 0:d1960beb98fe | 1078 | } |
Heidl | 0:d1960beb98fe | 1079 | /** Set word pair byte-swapping enabled for the specified slave (0-3). |
Heidl | 0:d1960beb98fe | 1080 | * @param num Slave number (0-3) |
Heidl | 0:d1960beb98fe | 1081 | * @param enabled New word pair byte-swapping enabled value for specified slave |
Heidl | 0:d1960beb98fe | 1082 | * @see getSlaveWordByteSwap() |
Heidl | 0:d1960beb98fe | 1083 | * @see MPU6050_RA_I2C_SLV0_CTRL |
Heidl | 0:d1960beb98fe | 1084 | */ |
Heidl | 0:d1960beb98fe | 1085 | void MPU6050::setSlaveWordByteSwap(uint8_t num, bool enabled) |
Heidl | 0:d1960beb98fe | 1086 | { |
Heidl | 0:d1960beb98fe | 1087 | if (num > 3) return; |
Heidl | 0:d1960beb98fe | 1088 | i2Cdev.writeBit(devAddr, MPU6050_RA_I2C_SLV0_CTRL + num*3, MPU6050_I2C_SLV_BYTE_SW_BIT, enabled); |
Heidl | 0:d1960beb98fe | 1089 | } |
Heidl | 0:d1960beb98fe | 1090 | /** Get write mode for the specified slave (0-3). |
Heidl | 0:d1960beb98fe | 1091 | * When set to 1, the transaction will read or write data only. When cleared to |
Heidl | 0:d1960beb98fe | 1092 | * 0, the transaction will write a register address prior to reading or writing |
Heidl | 0:d1960beb98fe | 1093 | * data. This should equal 0 when specifying the register address within the |
Heidl | 0:d1960beb98fe | 1094 | * Slave device to/from which the ensuing data transaction will take place. |
Heidl | 0:d1960beb98fe | 1095 | * |
Heidl | 0:d1960beb98fe | 1096 | * @param num Slave number (0-3) |
Heidl | 0:d1960beb98fe | 1097 | * @return Current write mode for specified slave (0 = register address + data, 1 = data only) |
Heidl | 0:d1960beb98fe | 1098 | * @see MPU6050_RA_I2C_SLV0_CTRL |
Heidl | 0:d1960beb98fe | 1099 | */ |
Heidl | 0:d1960beb98fe | 1100 | bool MPU6050::getSlaveWriteMode(uint8_t num) |
Heidl | 0:d1960beb98fe | 1101 | { |
Heidl | 0:d1960beb98fe | 1102 | if (num > 3) return 0; |
Heidl | 0:d1960beb98fe | 1103 | i2Cdev.readBit(devAddr, MPU6050_RA_I2C_SLV0_CTRL + num*3, MPU6050_I2C_SLV_REG_DIS_BIT, buffer); |
Heidl | 0:d1960beb98fe | 1104 | return buffer[0]; |
Heidl | 0:d1960beb98fe | 1105 | } |
Heidl | 0:d1960beb98fe | 1106 | /** Set write mode for the specified slave (0-3). |
Heidl | 0:d1960beb98fe | 1107 | * @param num Slave number (0-3) |
Heidl | 0:d1960beb98fe | 1108 | * @param mode New write mode for specified slave (0 = register address + data, 1 = data only) |
Heidl | 0:d1960beb98fe | 1109 | * @see getSlaveWriteMode() |
Heidl | 0:d1960beb98fe | 1110 | * @see MPU6050_RA_I2C_SLV0_CTRL |
Heidl | 0:d1960beb98fe | 1111 | */ |
Heidl | 0:d1960beb98fe | 1112 | void MPU6050::setSlaveWriteMode(uint8_t num, bool mode) |
Heidl | 0:d1960beb98fe | 1113 | { |
Heidl | 0:d1960beb98fe | 1114 | if (num > 3) return; |
Heidl | 0:d1960beb98fe | 1115 | i2Cdev.writeBit(devAddr, MPU6050_RA_I2C_SLV0_CTRL + num*3, MPU6050_I2C_SLV_REG_DIS_BIT, mode); |
Heidl | 0:d1960beb98fe | 1116 | } |
Heidl | 0:d1960beb98fe | 1117 | /** Get word pair grouping order offset for the specified slave (0-3). |
Heidl | 0:d1960beb98fe | 1118 | * This sets specifies the grouping order of word pairs received from registers. |
Heidl | 0:d1960beb98fe | 1119 | * When cleared to 0, bytes from register addresses 0 and 1, 2 and 3, etc (even, |
Heidl | 0:d1960beb98fe | 1120 | * then odd register addresses) are paired to form a word. When set to 1, bytes |
Heidl | 0:d1960beb98fe | 1121 | * from register addresses are paired 1 and 2, 3 and 4, etc. (odd, then even |
Heidl | 0:d1960beb98fe | 1122 | * register addresses) are paired to form a word. |
Heidl | 0:d1960beb98fe | 1123 | * |
Heidl | 0:d1960beb98fe | 1124 | * @param num Slave number (0-3) |
Heidl | 0:d1960beb98fe | 1125 | * @return Current word pair grouping order offset for specified slave |
Heidl | 0:d1960beb98fe | 1126 | * @see MPU6050_RA_I2C_SLV0_CTRL |
Heidl | 0:d1960beb98fe | 1127 | */ |
Heidl | 0:d1960beb98fe | 1128 | bool MPU6050::getSlaveWordGroupOffset(uint8_t num) |
Heidl | 0:d1960beb98fe | 1129 | { |
Heidl | 0:d1960beb98fe | 1130 | if (num > 3) return 0; |
Heidl | 0:d1960beb98fe | 1131 | i2Cdev.readBit(devAddr, MPU6050_RA_I2C_SLV0_CTRL + num*3, MPU6050_I2C_SLV_GRP_BIT, buffer); |
Heidl | 0:d1960beb98fe | 1132 | return buffer[0]; |
Heidl | 0:d1960beb98fe | 1133 | } |
Heidl | 0:d1960beb98fe | 1134 | /** Set word pair grouping order offset for the specified slave (0-3). |
Heidl | 0:d1960beb98fe | 1135 | * @param num Slave number (0-3) |
Heidl | 0:d1960beb98fe | 1136 | * @param enabled New word pair grouping order offset for specified slave |
Heidl | 0:d1960beb98fe | 1137 | * @see getSlaveWordGroupOffset() |
Heidl | 0:d1960beb98fe | 1138 | * @see MPU6050_RA_I2C_SLV0_CTRL |
Heidl | 0:d1960beb98fe | 1139 | */ |
Heidl | 0:d1960beb98fe | 1140 | void MPU6050::setSlaveWordGroupOffset(uint8_t num, bool enabled) |
Heidl | 0:d1960beb98fe | 1141 | { |
Heidl | 0:d1960beb98fe | 1142 | if (num > 3) return; |
Heidl | 0:d1960beb98fe | 1143 | i2Cdev.writeBit(devAddr, MPU6050_RA_I2C_SLV0_CTRL + num*3, MPU6050_I2C_SLV_GRP_BIT, enabled); |
Heidl | 0:d1960beb98fe | 1144 | } |
Heidl | 0:d1960beb98fe | 1145 | /** Get number of bytes to read for the specified slave (0-3). |
Heidl | 0:d1960beb98fe | 1146 | * Specifies the number of bytes transferred to and from Slave 0. Clearing this |
Heidl | 0:d1960beb98fe | 1147 | * bit to 0 is equivalent to disabling the register by writing 0 to I2C_SLV0_EN. |
Heidl | 0:d1960beb98fe | 1148 | * @param num Slave number (0-3) |
Heidl | 0:d1960beb98fe | 1149 | * @return Number of bytes to read for specified slave |
Heidl | 0:d1960beb98fe | 1150 | * @see MPU6050_RA_I2C_SLV0_CTRL |
Heidl | 0:d1960beb98fe | 1151 | */ |
Heidl | 0:d1960beb98fe | 1152 | uint8_t MPU6050::getSlaveDataLength(uint8_t num) |
Heidl | 0:d1960beb98fe | 1153 | { |
Heidl | 0:d1960beb98fe | 1154 | if (num > 3) return 0; |
Heidl | 0:d1960beb98fe | 1155 | i2Cdev.readBits(devAddr, MPU6050_RA_I2C_SLV0_CTRL + num*3, MPU6050_I2C_SLV_LEN_BIT, MPU6050_I2C_SLV_LEN_LENGTH, buffer); |
Heidl | 0:d1960beb98fe | 1156 | return buffer[0]; |
Heidl | 0:d1960beb98fe | 1157 | } |
Heidl | 0:d1960beb98fe | 1158 | /** Set number of bytes to read for the specified slave (0-3). |
Heidl | 0:d1960beb98fe | 1159 | * @param num Slave number (0-3) |
Heidl | 0:d1960beb98fe | 1160 | * @param length Number of bytes to read for specified slave |
Heidl | 0:d1960beb98fe | 1161 | * @see getSlaveDataLength() |
Heidl | 0:d1960beb98fe | 1162 | * @see MPU6050_RA_I2C_SLV0_CTRL |
Heidl | 0:d1960beb98fe | 1163 | */ |
Heidl | 0:d1960beb98fe | 1164 | void MPU6050::setSlaveDataLength(uint8_t num, uint8_t length) |
Heidl | 0:d1960beb98fe | 1165 | { |
Heidl | 0:d1960beb98fe | 1166 | if (num > 3) return; |
Heidl | 0:d1960beb98fe | 1167 | i2Cdev.writeBits(devAddr, MPU6050_RA_I2C_SLV0_CTRL + num*3, MPU6050_I2C_SLV_LEN_BIT, MPU6050_I2C_SLV_LEN_LENGTH, length); |
Heidl | 0:d1960beb98fe | 1168 | } |
Heidl | 0:d1960beb98fe | 1169 | |
Heidl | 0:d1960beb98fe | 1170 | // I2C_SLV* registers (Slave 4) |
Heidl | 0:d1960beb98fe | 1171 | |
Heidl | 0:d1960beb98fe | 1172 | /** Get the I2C address of Slave 4. |
Heidl | 0:d1960beb98fe | 1173 | * Note that Bit 7 (MSB) controls read/write mode. If Bit 7 is set, it's a read |
Heidl | 0:d1960beb98fe | 1174 | * operation, and if it is cleared, then it's a write operation. The remaining |
Heidl | 0:d1960beb98fe | 1175 | * bits (6-0) are the 7-bit device address of the slave device. |
Heidl | 0:d1960beb98fe | 1176 | * |
Heidl | 0:d1960beb98fe | 1177 | * @return Current address for Slave 4 |
Heidl | 0:d1960beb98fe | 1178 | * @see getSlaveAddress() |
Heidl | 0:d1960beb98fe | 1179 | * @see MPU6050_RA_I2C_SLV4_ADDR |
Heidl | 0:d1960beb98fe | 1180 | */ |
Heidl | 0:d1960beb98fe | 1181 | uint8_t MPU6050::getSlave4Address() |
Heidl | 0:d1960beb98fe | 1182 | { |
Heidl | 0:d1960beb98fe | 1183 | i2Cdev.readByte(devAddr, MPU6050_RA_I2C_SLV4_ADDR, buffer); |
Heidl | 0:d1960beb98fe | 1184 | return buffer[0]; |
Heidl | 0:d1960beb98fe | 1185 | } |
Heidl | 0:d1960beb98fe | 1186 | /** Set the I2C address of Slave 4. |
Heidl | 0:d1960beb98fe | 1187 | * @param address New address for Slave 4 |
Heidl | 0:d1960beb98fe | 1188 | * @see getSlave4Address() |
Heidl | 0:d1960beb98fe | 1189 | * @see MPU6050_RA_I2C_SLV4_ADDR |
Heidl | 0:d1960beb98fe | 1190 | */ |
Heidl | 0:d1960beb98fe | 1191 | void MPU6050::setSlave4Address(uint8_t address) |
Heidl | 0:d1960beb98fe | 1192 | { |
Heidl | 0:d1960beb98fe | 1193 | i2Cdev.writeByte(devAddr, MPU6050_RA_I2C_SLV4_ADDR, address); |
Heidl | 0:d1960beb98fe | 1194 | } |
Heidl | 0:d1960beb98fe | 1195 | /** Get the active internal register for the Slave 4. |
Heidl | 0:d1960beb98fe | 1196 | * Read/write operations for this slave will be done to whatever internal |
Heidl | 0:d1960beb98fe | 1197 | * register address is stored in this MPU register. |
Heidl | 0:d1960beb98fe | 1198 | * |
Heidl | 0:d1960beb98fe | 1199 | * @return Current active register for Slave 4 |
Heidl | 0:d1960beb98fe | 1200 | * @see MPU6050_RA_I2C_SLV4_REG |
Heidl | 0:d1960beb98fe | 1201 | */ |
Heidl | 0:d1960beb98fe | 1202 | uint8_t MPU6050::getSlave4Register() |
Heidl | 0:d1960beb98fe | 1203 | { |
Heidl | 0:d1960beb98fe | 1204 | i2Cdev.readByte(devAddr, MPU6050_RA_I2C_SLV4_REG, buffer); |
Heidl | 0:d1960beb98fe | 1205 | return buffer[0]; |
Heidl | 0:d1960beb98fe | 1206 | } |
Heidl | 0:d1960beb98fe | 1207 | /** Set the active internal register for Slave 4. |
Heidl | 0:d1960beb98fe | 1208 | * @param reg New active register for Slave 4 |
Heidl | 0:d1960beb98fe | 1209 | * @see getSlave4Register() |
Heidl | 0:d1960beb98fe | 1210 | * @see MPU6050_RA_I2C_SLV4_REG |
Heidl | 0:d1960beb98fe | 1211 | */ |
Heidl | 0:d1960beb98fe | 1212 | void MPU6050::setSlave4Register(uint8_t reg) |
Heidl | 0:d1960beb98fe | 1213 | { |
Heidl | 0:d1960beb98fe | 1214 | i2Cdev.writeByte(devAddr, MPU6050_RA_I2C_SLV4_REG, reg); |
Heidl | 0:d1960beb98fe | 1215 | } |
Heidl | 0:d1960beb98fe | 1216 | /** Set new byte to write to Slave 4. |
Heidl | 0:d1960beb98fe | 1217 | * This register stores the data to be written into the Slave 4. If I2C_SLV4_RW |
Heidl | 0:d1960beb98fe | 1218 | * is set 1 (set to read), this register has no effect. |
Heidl | 0:d1960beb98fe | 1219 | * @param data New byte to write to Slave 4 |
Heidl | 0:d1960beb98fe | 1220 | * @see MPU6050_RA_I2C_SLV4_DO |
Heidl | 0:d1960beb98fe | 1221 | */ |
Heidl | 0:d1960beb98fe | 1222 | void MPU6050::setSlave4OutputByte(uint8_t data) |
Heidl | 0:d1960beb98fe | 1223 | { |
Heidl | 0:d1960beb98fe | 1224 | i2Cdev.writeByte(devAddr, MPU6050_RA_I2C_SLV4_DO, data); |
Heidl | 0:d1960beb98fe | 1225 | } |
Heidl | 0:d1960beb98fe | 1226 | /** Get the enabled value for the Slave 4. |
Heidl | 0:d1960beb98fe | 1227 | * When set to 1, this bit enables Slave 4 for data transfer operations. When |
Heidl | 0:d1960beb98fe | 1228 | * cleared to 0, this bit disables Slave 4 from data transfer operations. |
Heidl | 0:d1960beb98fe | 1229 | * @return Current enabled value for Slave 4 |
Heidl | 0:d1960beb98fe | 1230 | * @see MPU6050_RA_I2C_SLV4_CTRL |
Heidl | 0:d1960beb98fe | 1231 | */ |
Heidl | 0:d1960beb98fe | 1232 | bool MPU6050::getSlave4Enabled() |
Heidl | 0:d1960beb98fe | 1233 | { |
Heidl | 0:d1960beb98fe | 1234 | i2Cdev.readBit(devAddr, MPU6050_RA_I2C_SLV4_CTRL, MPU6050_I2C_SLV4_EN_BIT, buffer); |
Heidl | 0:d1960beb98fe | 1235 | return buffer[0]; |
Heidl | 0:d1960beb98fe | 1236 | } |
Heidl | 0:d1960beb98fe | 1237 | /** Set the enabled value for Slave 4. |
Heidl | 0:d1960beb98fe | 1238 | * @param enabled New enabled value for Slave 4 |
Heidl | 0:d1960beb98fe | 1239 | * @see getSlave4Enabled() |
Heidl | 0:d1960beb98fe | 1240 | * @see MPU6050_RA_I2C_SLV4_CTRL |
Heidl | 0:d1960beb98fe | 1241 | */ |
Heidl | 0:d1960beb98fe | 1242 | void MPU6050::setSlave4Enabled(bool enabled) |
Heidl | 0:d1960beb98fe | 1243 | { |
Heidl | 0:d1960beb98fe | 1244 | i2Cdev.writeBit(devAddr, MPU6050_RA_I2C_SLV4_CTRL, MPU6050_I2C_SLV4_EN_BIT, enabled); |
Heidl | 0:d1960beb98fe | 1245 | } |
Heidl | 0:d1960beb98fe | 1246 | /** Get the enabled value for Slave 4 transaction interrupts. |
Heidl | 0:d1960beb98fe | 1247 | * When set to 1, this bit enables the generation of an interrupt signal upon |
Heidl | 0:d1960beb98fe | 1248 | * completion of a Slave 4 transaction. When cleared to 0, this bit disables the |
Heidl | 0:d1960beb98fe | 1249 | * generation of an interrupt signal upon completion of a Slave 4 transaction. |
Heidl | 0:d1960beb98fe | 1250 | * The interrupt status can be observed in Register 54. |
Heidl | 0:d1960beb98fe | 1251 | * |
Heidl | 0:d1960beb98fe | 1252 | * @return Current enabled value for Slave 4 transaction interrupts. |
Heidl | 0:d1960beb98fe | 1253 | * @see MPU6050_RA_I2C_SLV4_CTRL |
Heidl | 0:d1960beb98fe | 1254 | */ |
Heidl | 0:d1960beb98fe | 1255 | bool MPU6050::getSlave4InterruptEnabled() |
Heidl | 0:d1960beb98fe | 1256 | { |
Heidl | 0:d1960beb98fe | 1257 | i2Cdev.readBit(devAddr, MPU6050_RA_I2C_SLV4_CTRL, MPU6050_I2C_SLV4_INT_EN_BIT, buffer); |
Heidl | 0:d1960beb98fe | 1258 | return buffer[0]; |
Heidl | 0:d1960beb98fe | 1259 | } |
Heidl | 0:d1960beb98fe | 1260 | /** Set the enabled value for Slave 4 transaction interrupts. |
Heidl | 0:d1960beb98fe | 1261 | * @param enabled New enabled value for Slave 4 transaction interrupts. |
Heidl | 0:d1960beb98fe | 1262 | * @see getSlave4InterruptEnabled() |
Heidl | 0:d1960beb98fe | 1263 | * @see MPU6050_RA_I2C_SLV4_CTRL |
Heidl | 0:d1960beb98fe | 1264 | */ |
Heidl | 0:d1960beb98fe | 1265 | void MPU6050::setSlave4InterruptEnabled(bool enabled) |
Heidl | 0:d1960beb98fe | 1266 | { |
Heidl | 0:d1960beb98fe | 1267 | i2Cdev.writeBit(devAddr, MPU6050_RA_I2C_SLV4_CTRL, MPU6050_I2C_SLV4_INT_EN_BIT, enabled); |
Heidl | 0:d1960beb98fe | 1268 | } |
Heidl | 0:d1960beb98fe | 1269 | /** Get write mode for Slave 4. |
Heidl | 0:d1960beb98fe | 1270 | * When set to 1, the transaction will read or write data only. When cleared to |
Heidl | 0:d1960beb98fe | 1271 | * 0, the transaction will write a register address prior to reading or writing |
Heidl | 0:d1960beb98fe | 1272 | * data. This should equal 0 when specifying the register address within the |
Heidl | 0:d1960beb98fe | 1273 | * Slave device to/from which the ensuing data transaction will take place. |
Heidl | 0:d1960beb98fe | 1274 | * |
Heidl | 0:d1960beb98fe | 1275 | * @return Current write mode for Slave 4 (0 = register address + data, 1 = data only) |
Heidl | 0:d1960beb98fe | 1276 | * @see MPU6050_RA_I2C_SLV4_CTRL |
Heidl | 0:d1960beb98fe | 1277 | */ |
Heidl | 0:d1960beb98fe | 1278 | bool MPU6050::getSlave4WriteMode() |
Heidl | 0:d1960beb98fe | 1279 | { |
Heidl | 0:d1960beb98fe | 1280 | i2Cdev.readBit(devAddr, MPU6050_RA_I2C_SLV4_CTRL, MPU6050_I2C_SLV4_REG_DIS_BIT, buffer); |
Heidl | 0:d1960beb98fe | 1281 | return buffer[0]; |
Heidl | 0:d1960beb98fe | 1282 | } |
Heidl | 0:d1960beb98fe | 1283 | /** Set write mode for the Slave 4. |
Heidl | 0:d1960beb98fe | 1284 | * @param mode New write mode for Slave 4 (0 = register address + data, 1 = data only) |
Heidl | 0:d1960beb98fe | 1285 | * @see getSlave4WriteMode() |
Heidl | 0:d1960beb98fe | 1286 | * @see MPU6050_RA_I2C_SLV4_CTRL |
Heidl | 0:d1960beb98fe | 1287 | */ |
Heidl | 0:d1960beb98fe | 1288 | void MPU6050::setSlave4WriteMode(bool mode) |
Heidl | 0:d1960beb98fe | 1289 | { |
Heidl | 0:d1960beb98fe | 1290 | i2Cdev.writeBit(devAddr, MPU6050_RA_I2C_SLV4_CTRL, MPU6050_I2C_SLV4_REG_DIS_BIT, mode); |
Heidl | 0:d1960beb98fe | 1291 | } |
Heidl | 0:d1960beb98fe | 1292 | /** Get Slave 4 master delay value. |
Heidl | 0:d1960beb98fe | 1293 | * This configures the reduced access rate of I2C slaves relative to the Sample |
Heidl | 0:d1960beb98fe | 1294 | * Rate. When a slave's access rate is decreased relative to the Sample Rate, |
Heidl | 0:d1960beb98fe | 1295 | * the slave is accessed every: |
Heidl | 0:d1960beb98fe | 1296 | * |
Heidl | 0:d1960beb98fe | 1297 | * 1 / (1 + I2C_MST_DLY) samples |
Heidl | 0:d1960beb98fe | 1298 | * |
Heidl | 0:d1960beb98fe | 1299 | * This base Sample Rate in turn is determined by SMPLRT_DIV (register 25) and |
Heidl | 0:d1960beb98fe | 1300 | * DLPF_CFG (register 26). Whether a slave's access rate is reduced relative to |
Heidl | 0:d1960beb98fe | 1301 | * the Sample Rate is determined by I2C_MST_DELAY_CTRL (register 103). For |
Heidl | 0:d1960beb98fe | 1302 | * further information regarding the Sample Rate, please refer to register 25. |
Heidl | 0:d1960beb98fe | 1303 | * |
Heidl | 0:d1960beb98fe | 1304 | * @return Current Slave 4 master delay value |
Heidl | 0:d1960beb98fe | 1305 | * @see MPU6050_RA_I2C_SLV4_CTRL |
Heidl | 0:d1960beb98fe | 1306 | */ |
Heidl | 0:d1960beb98fe | 1307 | uint8_t MPU6050::getSlave4MasterDelay() |
Heidl | 0:d1960beb98fe | 1308 | { |
Heidl | 0:d1960beb98fe | 1309 | i2Cdev.readBits(devAddr, MPU6050_RA_I2C_SLV4_CTRL, MPU6050_I2C_SLV4_MST_DLY_BIT, MPU6050_I2C_SLV4_MST_DLY_LENGTH, buffer); |
Heidl | 0:d1960beb98fe | 1310 | return buffer[0]; |
Heidl | 0:d1960beb98fe | 1311 | } |
Heidl | 0:d1960beb98fe | 1312 | /** Set Slave 4 master delay value. |
Heidl | 0:d1960beb98fe | 1313 | * @param delay New Slave 4 master delay value |
Heidl | 0:d1960beb98fe | 1314 | * @see getSlave4MasterDelay() |
Heidl | 0:d1960beb98fe | 1315 | * @see MPU6050_RA_I2C_SLV4_CTRL |
Heidl | 0:d1960beb98fe | 1316 | */ |
Heidl | 0:d1960beb98fe | 1317 | void MPU6050::setSlave4MasterDelay(uint8_t delay) |
Heidl | 0:d1960beb98fe | 1318 | { |
Heidl | 0:d1960beb98fe | 1319 | i2Cdev.writeBits(devAddr, MPU6050_RA_I2C_SLV4_CTRL, MPU6050_I2C_SLV4_MST_DLY_BIT, MPU6050_I2C_SLV4_MST_DLY_LENGTH, delay); |
Heidl | 0:d1960beb98fe | 1320 | } |
Heidl | 0:d1960beb98fe | 1321 | /** Get last available byte read from Slave 4. |
Heidl | 0:d1960beb98fe | 1322 | * This register stores the data read from Slave 4. This field is populated |
Heidl | 0:d1960beb98fe | 1323 | * after a read transaction. |
Heidl | 0:d1960beb98fe | 1324 | * @return Last available byte read from to Slave 4 |
Heidl | 0:d1960beb98fe | 1325 | * @see MPU6050_RA_I2C_SLV4_DI |
Heidl | 0:d1960beb98fe | 1326 | */ |
Heidl | 0:d1960beb98fe | 1327 | uint8_t MPU6050::getSlate4InputByte() |
Heidl | 0:d1960beb98fe | 1328 | { |
Heidl | 0:d1960beb98fe | 1329 | i2Cdev.readByte(devAddr, MPU6050_RA_I2C_SLV4_DI, buffer); |
Heidl | 0:d1960beb98fe | 1330 | return buffer[0]; |
Heidl | 0:d1960beb98fe | 1331 | } |
Heidl | 0:d1960beb98fe | 1332 | |
Heidl | 0:d1960beb98fe | 1333 | // I2C_MST_STATUS register |
Heidl | 0:d1960beb98fe | 1334 | |
Heidl | 0:d1960beb98fe | 1335 | /** Get FSYNC interrupt status. |
Heidl | 0:d1960beb98fe | 1336 | * This bit reflects the status of the FSYNC interrupt from an external device |
Heidl | 0:d1960beb98fe | 1337 | * into the MPU-60X0. This is used as a way to pass an external interrupt |
Heidl | 0:d1960beb98fe | 1338 | * through the MPU-60X0 to the host application processor. When set to 1, this |
Heidl | 0:d1960beb98fe | 1339 | * bit will cause an interrupt if FSYNC_INT_EN is asserted in INT_PIN_CFG |
Heidl | 0:d1960beb98fe | 1340 | * (Register 55). |
Heidl | 0:d1960beb98fe | 1341 | * @return FSYNC interrupt status |
Heidl | 0:d1960beb98fe | 1342 | * @see MPU6050_RA_I2C_MST_STATUS |
Heidl | 0:d1960beb98fe | 1343 | */ |
Heidl | 0:d1960beb98fe | 1344 | bool MPU6050::getPassthroughStatus() |
Heidl | 0:d1960beb98fe | 1345 | { |
Heidl | 0:d1960beb98fe | 1346 | i2Cdev.readBit(devAddr, MPU6050_RA_I2C_MST_STATUS, MPU6050_MST_PASS_THROUGH_BIT, buffer); |
Heidl | 0:d1960beb98fe | 1347 | return buffer[0]; |
Heidl | 0:d1960beb98fe | 1348 | } |
Heidl | 0:d1960beb98fe | 1349 | /** Get Slave 4 transaction done status. |
Heidl | 0:d1960beb98fe | 1350 | * Automatically sets to 1 when a Slave 4 transaction has completed. This |
Heidl | 0:d1960beb98fe | 1351 | * triggers an interrupt if the I2C_MST_INT_EN bit in the INT_ENABLE register |
Heidl | 0:d1960beb98fe | 1352 | * (Register 56) is asserted and if the SLV_4_DONE_INT bit is asserted in the |
Heidl | 0:d1960beb98fe | 1353 | * I2C_SLV4_CTRL register (Register 52). |
Heidl | 0:d1960beb98fe | 1354 | * @return Slave 4 transaction done status |
Heidl | 0:d1960beb98fe | 1355 | * @see MPU6050_RA_I2C_MST_STATUS |
Heidl | 0:d1960beb98fe | 1356 | */ |
Heidl | 0:d1960beb98fe | 1357 | bool MPU6050::getSlave4IsDone() |
Heidl | 0:d1960beb98fe | 1358 | { |
Heidl | 0:d1960beb98fe | 1359 | i2Cdev.readBit(devAddr, MPU6050_RA_I2C_MST_STATUS, MPU6050_MST_I2C_SLV4_DONE_BIT, buffer); |
Heidl | 0:d1960beb98fe | 1360 | return buffer[0]; |
Heidl | 0:d1960beb98fe | 1361 | } |
Heidl | 0:d1960beb98fe | 1362 | /** Get master arbitration lost status. |
Heidl | 0:d1960beb98fe | 1363 | * This bit automatically sets to 1 when the I2C Master has lost arbitration of |
Heidl | 0:d1960beb98fe | 1364 | * the auxiliary I2C bus (an error condition). This triggers an interrupt if the |
Heidl | 0:d1960beb98fe | 1365 | * I2C_MST_INT_EN bit in the INT_ENABLE register (Register 56) is asserted. |
Heidl | 0:d1960beb98fe | 1366 | * @return Master arbitration lost status |
Heidl | 0:d1960beb98fe | 1367 | * @see MPU6050_RA_I2C_MST_STATUS |
Heidl | 0:d1960beb98fe | 1368 | */ |
Heidl | 0:d1960beb98fe | 1369 | bool MPU6050::getLostArbitration() |
Heidl | 0:d1960beb98fe | 1370 | { |
Heidl | 0:d1960beb98fe | 1371 | i2Cdev.readBit(devAddr, MPU6050_RA_I2C_MST_STATUS, MPU6050_MST_I2C_LOST_ARB_BIT, buffer); |
Heidl | 0:d1960beb98fe | 1372 | return buffer[0]; |
Heidl | 0:d1960beb98fe | 1373 | } |
Heidl | 0:d1960beb98fe | 1374 | /** Get Slave 4 NACK status. |
Heidl | 0:d1960beb98fe | 1375 | * This bit automatically sets to 1 when the I2C Master receives a NACK in a |
Heidl | 0:d1960beb98fe | 1376 | * transaction with Slave 4. This triggers an interrupt if the I2C_MST_INT_EN |
Heidl | 0:d1960beb98fe | 1377 | * bit in the INT_ENABLE register (Register 56) is asserted. |
Heidl | 0:d1960beb98fe | 1378 | * @return Slave 4 NACK interrupt status |
Heidl | 0:d1960beb98fe | 1379 | * @see MPU6050_RA_I2C_MST_STATUS |
Heidl | 0:d1960beb98fe | 1380 | */ |
Heidl | 0:d1960beb98fe | 1381 | bool MPU6050::getSlave4Nack() |
Heidl | 0:d1960beb98fe | 1382 | { |
Heidl | 0:d1960beb98fe | 1383 | i2Cdev.readBit(devAddr, MPU6050_RA_I2C_MST_STATUS, MPU6050_MST_I2C_SLV4_NACK_BIT, buffer); |
Heidl | 0:d1960beb98fe | 1384 | return buffer[0]; |
Heidl | 0:d1960beb98fe | 1385 | } |
Heidl | 0:d1960beb98fe | 1386 | /** Get Slave 3 NACK status. |
Heidl | 0:d1960beb98fe | 1387 | * This bit automatically sets to 1 when the I2C Master receives a NACK in a |
Heidl | 0:d1960beb98fe | 1388 | * transaction with Slave 3. This triggers an interrupt if the I2C_MST_INT_EN |
Heidl | 0:d1960beb98fe | 1389 | * bit in the INT_ENABLE register (Register 56) is asserted. |
Heidl | 0:d1960beb98fe | 1390 | * @return Slave 3 NACK interrupt status |
Heidl | 0:d1960beb98fe | 1391 | * @see MPU6050_RA_I2C_MST_STATUS |
Heidl | 0:d1960beb98fe | 1392 | */ |
Heidl | 0:d1960beb98fe | 1393 | bool MPU6050::getSlave3Nack() |
Heidl | 0:d1960beb98fe | 1394 | { |
Heidl | 0:d1960beb98fe | 1395 | i2Cdev.readBit(devAddr, MPU6050_RA_I2C_MST_STATUS, MPU6050_MST_I2C_SLV3_NACK_BIT, buffer); |
Heidl | 0:d1960beb98fe | 1396 | return buffer[0]; |
Heidl | 0:d1960beb98fe | 1397 | } |
Heidl | 0:d1960beb98fe | 1398 | /** Get Slave 2 NACK status. |
Heidl | 0:d1960beb98fe | 1399 | * This bit automatically sets to 1 when the I2C Master receives a NACK in a |
Heidl | 0:d1960beb98fe | 1400 | * transaction with Slave 2. This triggers an interrupt if the I2C_MST_INT_EN |
Heidl | 0:d1960beb98fe | 1401 | * bit in the INT_ENABLE register (Register 56) is asserted. |
Heidl | 0:d1960beb98fe | 1402 | * @return Slave 2 NACK interrupt status |
Heidl | 0:d1960beb98fe | 1403 | * @see MPU6050_RA_I2C_MST_STATUS |
Heidl | 0:d1960beb98fe | 1404 | */ |
Heidl | 0:d1960beb98fe | 1405 | bool MPU6050::getSlave2Nack() |
Heidl | 0:d1960beb98fe | 1406 | { |
Heidl | 0:d1960beb98fe | 1407 | i2Cdev.readBit(devAddr, MPU6050_RA_I2C_MST_STATUS, MPU6050_MST_I2C_SLV2_NACK_BIT, buffer); |
Heidl | 0:d1960beb98fe | 1408 | return buffer[0]; |
Heidl | 0:d1960beb98fe | 1409 | } |
Heidl | 0:d1960beb98fe | 1410 | /** Get Slave 1 NACK status. |
Heidl | 0:d1960beb98fe | 1411 | * This bit automatically sets to 1 when the I2C Master receives a NACK in a |
Heidl | 0:d1960beb98fe | 1412 | * transaction with Slave 1. This triggers an interrupt if the I2C_MST_INT_EN |
Heidl | 0:d1960beb98fe | 1413 | * bit in the INT_ENABLE register (Register 56) is asserted. |
Heidl | 0:d1960beb98fe | 1414 | * @return Slave 1 NACK interrupt status |
Heidl | 0:d1960beb98fe | 1415 | * @see MPU6050_RA_I2C_MST_STATUS |
Heidl | 0:d1960beb98fe | 1416 | */ |
Heidl | 0:d1960beb98fe | 1417 | bool MPU6050::getSlave1Nack() |
Heidl | 0:d1960beb98fe | 1418 | { |
Heidl | 0:d1960beb98fe | 1419 | i2Cdev.readBit(devAddr, MPU6050_RA_I2C_MST_STATUS, MPU6050_MST_I2C_SLV1_NACK_BIT, buffer); |
Heidl | 0:d1960beb98fe | 1420 | return buffer[0]; |
Heidl | 0:d1960beb98fe | 1421 | } |
Heidl | 0:d1960beb98fe | 1422 | /** Get Slave 0 NACK status. |
Heidl | 0:d1960beb98fe | 1423 | * This bit automatically sets to 1 when the I2C Master receives a NACK in a |
Heidl | 0:d1960beb98fe | 1424 | * transaction with Slave 0. This triggers an interrupt if the I2C_MST_INT_EN |
Heidl | 0:d1960beb98fe | 1425 | * bit in the INT_ENABLE register (Register 56) is asserted. |
Heidl | 0:d1960beb98fe | 1426 | * @return Slave 0 NACK interrupt status |
Heidl | 0:d1960beb98fe | 1427 | * @see MPU6050_RA_I2C_MST_STATUS |
Heidl | 0:d1960beb98fe | 1428 | */ |
Heidl | 0:d1960beb98fe | 1429 | bool MPU6050::getSlave0Nack() |
Heidl | 0:d1960beb98fe | 1430 | { |
Heidl | 0:d1960beb98fe | 1431 | i2Cdev.readBit(devAddr, MPU6050_RA_I2C_MST_STATUS, MPU6050_MST_I2C_SLV0_NACK_BIT, buffer); |
Heidl | 0:d1960beb98fe | 1432 | return buffer[0]; |
Heidl | 0:d1960beb98fe | 1433 | } |
Heidl | 0:d1960beb98fe | 1434 | |
Heidl | 0:d1960beb98fe | 1435 | // INT_PIN_CFG register |
Heidl | 0:d1960beb98fe | 1436 | |
Heidl | 0:d1960beb98fe | 1437 | /** Get interrupt logic level mode. |
Heidl | 0:d1960beb98fe | 1438 | * Will be set 0 for active-high, 1 for active-low. |
Heidl | 0:d1960beb98fe | 1439 | * @return Current interrupt mode (0=active-high, 1=active-low) |
Heidl | 0:d1960beb98fe | 1440 | * @see MPU6050_RA_INT_PIN_CFG |
Heidl | 0:d1960beb98fe | 1441 | * @see MPU6050_INTCFG_INT_LEVEL_BIT |
Heidl | 0:d1960beb98fe | 1442 | */ |
Heidl | 0:d1960beb98fe | 1443 | bool MPU6050::getInterruptMode() |
Heidl | 0:d1960beb98fe | 1444 | { |
Heidl | 0:d1960beb98fe | 1445 | i2Cdev.readBit(devAddr, MPU6050_RA_INT_PIN_CFG, MPU6050_INTCFG_INT_LEVEL_BIT, buffer); |
Heidl | 0:d1960beb98fe | 1446 | return buffer[0]; |
Heidl | 0:d1960beb98fe | 1447 | } |
Heidl | 0:d1960beb98fe | 1448 | /** Set interrupt logic level mode. |
Heidl | 0:d1960beb98fe | 1449 | * @param mode New interrupt mode (0=active-high, 1=active-low) |
Heidl | 0:d1960beb98fe | 1450 | * @see getInterruptMode() |
Heidl | 0:d1960beb98fe | 1451 | * @see MPU6050_RA_INT_PIN_CFG |
Heidl | 0:d1960beb98fe | 1452 | * @see MPU6050_INTCFG_INT_LEVEL_BIT |
Heidl | 0:d1960beb98fe | 1453 | */ |
Heidl | 0:d1960beb98fe | 1454 | void MPU6050::setInterruptMode(bool mode) |
Heidl | 0:d1960beb98fe | 1455 | { |
Heidl | 0:d1960beb98fe | 1456 | i2Cdev.writeBit(devAddr, MPU6050_RA_INT_PIN_CFG, MPU6050_INTCFG_INT_LEVEL_BIT, mode); |
Heidl | 0:d1960beb98fe | 1457 | } |
Heidl | 0:d1960beb98fe | 1458 | /** Get interrupt drive mode. |
Heidl | 0:d1960beb98fe | 1459 | * Will be set 0 for push-pull, 1 for open-drain. |
Heidl | 0:d1960beb98fe | 1460 | * @return Current interrupt drive mode (0=push-pull, 1=open-drain) |
Heidl | 0:d1960beb98fe | 1461 | * @see MPU6050_RA_INT_PIN_CFG |
Heidl | 0:d1960beb98fe | 1462 | * @see MPU6050_INTCFG_INT_OPEN_BIT |
Heidl | 0:d1960beb98fe | 1463 | */ |
Heidl | 0:d1960beb98fe | 1464 | bool MPU6050::getInterruptDrive() |
Heidl | 0:d1960beb98fe | 1465 | { |
Heidl | 0:d1960beb98fe | 1466 | i2Cdev.readBit(devAddr, MPU6050_RA_INT_PIN_CFG, MPU6050_INTCFG_INT_OPEN_BIT, buffer); |
Heidl | 0:d1960beb98fe | 1467 | return buffer[0]; |
Heidl | 0:d1960beb98fe | 1468 | } |
Heidl | 0:d1960beb98fe | 1469 | /** Set interrupt drive mode. |
Heidl | 0:d1960beb98fe | 1470 | * @param drive New interrupt drive mode (0=push-pull, 1=open-drain) |
Heidl | 0:d1960beb98fe | 1471 | * @see getInterruptDrive() |
Heidl | 0:d1960beb98fe | 1472 | * @see MPU6050_RA_INT_PIN_CFG |
Heidl | 0:d1960beb98fe | 1473 | * @see MPU6050_INTCFG_INT_OPEN_BIT |
Heidl | 0:d1960beb98fe | 1474 | */ |
Heidl | 0:d1960beb98fe | 1475 | void MPU6050::setInterruptDrive(bool drive) |
Heidl | 0:d1960beb98fe | 1476 | { |
Heidl | 0:d1960beb98fe | 1477 | i2Cdev.writeBit(devAddr, MPU6050_RA_INT_PIN_CFG, MPU6050_INTCFG_INT_OPEN_BIT, drive); |
Heidl | 0:d1960beb98fe | 1478 | } |
Heidl | 0:d1960beb98fe | 1479 | /** Get interrupt latch mode. |
Heidl | 0:d1960beb98fe | 1480 | * Will be set 0 for 50us-pulse, 1 for latch-until-int-cleared. |
Heidl | 0:d1960beb98fe | 1481 | * @return Current latch mode (0=50us-pulse, 1=latch-until-int-cleared) |
Heidl | 0:d1960beb98fe | 1482 | * @see MPU6050_RA_INT_PIN_CFG |
Heidl | 0:d1960beb98fe | 1483 | * @see MPU6050_INTCFG_LATCH_INT_EN_BIT |
Heidl | 0:d1960beb98fe | 1484 | */ |
Heidl | 0:d1960beb98fe | 1485 | bool MPU6050::getInterruptLatch() |
Heidl | 0:d1960beb98fe | 1486 | { |
Heidl | 0:d1960beb98fe | 1487 | i2Cdev.readBit(devAddr, MPU6050_RA_INT_PIN_CFG, MPU6050_INTCFG_LATCH_INT_EN_BIT, buffer); |
Heidl | 0:d1960beb98fe | 1488 | return buffer[0]; |
Heidl | 0:d1960beb98fe | 1489 | } |
Heidl | 0:d1960beb98fe | 1490 | /** Set interrupt latch mode. |
Heidl | 0:d1960beb98fe | 1491 | * @param latch New latch mode (0=50us-pulse, 1=latch-until-int-cleared) |
Heidl | 0:d1960beb98fe | 1492 | * @see getInterruptLatch() |
Heidl | 0:d1960beb98fe | 1493 | * @see MPU6050_RA_INT_PIN_CFG |
Heidl | 0:d1960beb98fe | 1494 | * @see MPU6050_INTCFG_LATCH_INT_EN_BIT |
Heidl | 0:d1960beb98fe | 1495 | */ |
Heidl | 0:d1960beb98fe | 1496 | void MPU6050::setInterruptLatch(bool latch) |
Heidl | 0:d1960beb98fe | 1497 | { |
Heidl | 0:d1960beb98fe | 1498 | i2Cdev.writeBit(devAddr, MPU6050_RA_INT_PIN_CFG, MPU6050_INTCFG_LATCH_INT_EN_BIT, latch); |
Heidl | 0:d1960beb98fe | 1499 | } |
Heidl | 0:d1960beb98fe | 1500 | /** Get interrupt latch clear mode. |
Heidl | 0:d1960beb98fe | 1501 | * Will be set 0 for status-read-only, 1 for any-register-read. |
Heidl | 0:d1960beb98fe | 1502 | * @return Current latch clear mode (0=status-read-only, 1=any-register-read) |
Heidl | 0:d1960beb98fe | 1503 | * @see MPU6050_RA_INT_PIN_CFG |
Heidl | 0:d1960beb98fe | 1504 | * @see MPU6050_INTCFG_INT_RD_CLEAR_BIT |
Heidl | 0:d1960beb98fe | 1505 | */ |
Heidl | 0:d1960beb98fe | 1506 | bool MPU6050::getInterruptLatchClear() |
Heidl | 0:d1960beb98fe | 1507 | { |
Heidl | 0:d1960beb98fe | 1508 | i2Cdev.readBit(devAddr, MPU6050_RA_INT_PIN_CFG, MPU6050_INTCFG_INT_RD_CLEAR_BIT, buffer); |
Heidl | 0:d1960beb98fe | 1509 | return buffer[0]; |
Heidl | 0:d1960beb98fe | 1510 | } |
Heidl | 0:d1960beb98fe | 1511 | /** Set interrupt latch clear mode. |
Heidl | 0:d1960beb98fe | 1512 | * @param clear New latch clear mode (0=status-read-only, 1=any-register-read) |
Heidl | 0:d1960beb98fe | 1513 | * @see getInterruptLatchClear() |
Heidl | 0:d1960beb98fe | 1514 | * @see MPU6050_RA_INT_PIN_CFG |
Heidl | 0:d1960beb98fe | 1515 | * @see MPU6050_INTCFG_INT_RD_CLEAR_BIT |
Heidl | 0:d1960beb98fe | 1516 | */ |
Heidl | 0:d1960beb98fe | 1517 | void MPU6050::setInterruptLatchClear(bool clear) |
Heidl | 0:d1960beb98fe | 1518 | { |
Heidl | 0:d1960beb98fe | 1519 | i2Cdev.writeBit(devAddr, MPU6050_RA_INT_PIN_CFG, MPU6050_INTCFG_INT_RD_CLEAR_BIT, clear); |
Heidl | 0:d1960beb98fe | 1520 | } |
Heidl | 0:d1960beb98fe | 1521 | /** Get FSYNC interrupt logic level mode. |
Heidl | 0:d1960beb98fe | 1522 | * @return Current FSYNC interrupt mode (0=active-high, 1=active-low) |
Heidl | 0:d1960beb98fe | 1523 | * @see getFSyncInterruptMode() |
Heidl | 0:d1960beb98fe | 1524 | * @see MPU6050_RA_INT_PIN_CFG |
Heidl | 0:d1960beb98fe | 1525 | * @see MPU6050_INTCFG_FSYNC_INT_LEVEL_BIT |
Heidl | 0:d1960beb98fe | 1526 | */ |
Heidl | 0:d1960beb98fe | 1527 | bool MPU6050::getFSyncInterruptLevel() |
Heidl | 0:d1960beb98fe | 1528 | { |
Heidl | 0:d1960beb98fe | 1529 | i2Cdev.readBit(devAddr, MPU6050_RA_INT_PIN_CFG, MPU6050_INTCFG_FSYNC_INT_LEVEL_BIT, buffer); |
Heidl | 0:d1960beb98fe | 1530 | return buffer[0]; |
Heidl | 0:d1960beb98fe | 1531 | } |
Heidl | 0:d1960beb98fe | 1532 | /** Set FSYNC interrupt logic level mode. |
Heidl | 0:d1960beb98fe | 1533 | * @param mode New FSYNC interrupt mode (0=active-high, 1=active-low) |
Heidl | 0:d1960beb98fe | 1534 | * @see getFSyncInterruptMode() |
Heidl | 0:d1960beb98fe | 1535 | * @see MPU6050_RA_INT_PIN_CFG |
Heidl | 0:d1960beb98fe | 1536 | * @see MPU6050_INTCFG_FSYNC_INT_LEVEL_BIT |
Heidl | 0:d1960beb98fe | 1537 | */ |
Heidl | 0:d1960beb98fe | 1538 | void MPU6050::setFSyncInterruptLevel(bool level) |
Heidl | 0:d1960beb98fe | 1539 | { |
Heidl | 0:d1960beb98fe | 1540 | i2Cdev.writeBit(devAddr, MPU6050_RA_INT_PIN_CFG, MPU6050_INTCFG_FSYNC_INT_LEVEL_BIT, level); |
Heidl | 0:d1960beb98fe | 1541 | } |
Heidl | 0:d1960beb98fe | 1542 | /** Get FSYNC pin interrupt enabled setting. |
Heidl | 0:d1960beb98fe | 1543 | * Will be set 0 for disabled, 1 for enabled. |
Heidl | 0:d1960beb98fe | 1544 | * @return Current interrupt enabled setting |
Heidl | 0:d1960beb98fe | 1545 | * @see MPU6050_RA_INT_PIN_CFG |
Heidl | 0:d1960beb98fe | 1546 | * @see MPU6050_INTCFG_FSYNC_INT_EN_BIT |
Heidl | 0:d1960beb98fe | 1547 | */ |
Heidl | 0:d1960beb98fe | 1548 | bool MPU6050::getFSyncInterruptEnabled() |
Heidl | 0:d1960beb98fe | 1549 | { |
Heidl | 0:d1960beb98fe | 1550 | i2Cdev.readBit(devAddr, MPU6050_RA_INT_PIN_CFG, MPU6050_INTCFG_FSYNC_INT_EN_BIT, buffer); |
Heidl | 0:d1960beb98fe | 1551 | return buffer[0]; |
Heidl | 0:d1960beb98fe | 1552 | } |
Heidl | 0:d1960beb98fe | 1553 | /** Set FSYNC pin interrupt enabled setting. |
Heidl | 0:d1960beb98fe | 1554 | * @param enabled New FSYNC pin interrupt enabled setting |
Heidl | 0:d1960beb98fe | 1555 | * @see getFSyncInterruptEnabled() |
Heidl | 0:d1960beb98fe | 1556 | * @see MPU6050_RA_INT_PIN_CFG |
Heidl | 0:d1960beb98fe | 1557 | * @see MPU6050_INTCFG_FSYNC_INT_EN_BIT |
Heidl | 0:d1960beb98fe | 1558 | */ |
Heidl | 0:d1960beb98fe | 1559 | void MPU6050::setFSyncInterruptEnabled(bool enabled) |
Heidl | 0:d1960beb98fe | 1560 | { |
Heidl | 0:d1960beb98fe | 1561 | i2Cdev.writeBit(devAddr, MPU6050_RA_INT_PIN_CFG, MPU6050_INTCFG_FSYNC_INT_EN_BIT, enabled); |
Heidl | 0:d1960beb98fe | 1562 | } |
Heidl | 0:d1960beb98fe | 1563 | /** Get I2C bypass enabled status. |
Heidl | 0:d1960beb98fe | 1564 | * When this bit is equal to 1 and I2C_MST_EN (Register 106 bit[5]) is equal to |
Heidl | 0:d1960beb98fe | 1565 | * 0, the host application processor will be able to directly access the |
Heidl | 0:d1960beb98fe | 1566 | * auxiliary I2C bus of the MPU-60X0. When this bit is equal to 0, the host |
Heidl | 0:d1960beb98fe | 1567 | * application processor will not be able to directly access the auxiliary I2C |
Heidl | 0:d1960beb98fe | 1568 | * bus of the MPU-60X0 regardless of the state of I2C_MST_EN (Register 106 |
Heidl | 0:d1960beb98fe | 1569 | * bit[5]). |
Heidl | 0:d1960beb98fe | 1570 | * @return Current I2C bypass enabled status |
Heidl | 0:d1960beb98fe | 1571 | * @see MPU6050_RA_INT_PIN_CFG |
Heidl | 0:d1960beb98fe | 1572 | * @see MPU6050_INTCFG_I2C_BYPASS_EN_BIT |
Heidl | 0:d1960beb98fe | 1573 | */ |
Heidl | 0:d1960beb98fe | 1574 | bool MPU6050::getI2CBypassEnabled() |
Heidl | 0:d1960beb98fe | 1575 | { |
Heidl | 0:d1960beb98fe | 1576 | i2Cdev.readBit(devAddr, MPU6050_RA_INT_PIN_CFG, MPU6050_INTCFG_I2C_BYPASS_EN_BIT, buffer); |
Heidl | 0:d1960beb98fe | 1577 | return buffer[0]; |
Heidl | 0:d1960beb98fe | 1578 | } |
Heidl | 0:d1960beb98fe | 1579 | /** Set I2C bypass enabled status. |
Heidl | 0:d1960beb98fe | 1580 | * When this bit is equal to 1 and I2C_MST_EN (Register 106 bit[5]) is equal to |
Heidl | 0:d1960beb98fe | 1581 | * 0, the host application processor will be able to directly access the |
Heidl | 0:d1960beb98fe | 1582 | * auxiliary I2C bus of the MPU-60X0. When this bit is equal to 0, the host |
Heidl | 0:d1960beb98fe | 1583 | * application processor will not be able to directly access the auxiliary I2C |
Heidl | 0:d1960beb98fe | 1584 | * bus of the MPU-60X0 regardless of the state of I2C_MST_EN (Register 106 |
Heidl | 0:d1960beb98fe | 1585 | * bit[5]). |
Heidl | 0:d1960beb98fe | 1586 | * @param enabled New I2C bypass enabled status |
Heidl | 0:d1960beb98fe | 1587 | * @see MPU6050_RA_INT_PIN_CFG |
Heidl | 0:d1960beb98fe | 1588 | * @see MPU6050_INTCFG_I2C_BYPASS_EN_BIT |
Heidl | 0:d1960beb98fe | 1589 | */ |
Heidl | 0:d1960beb98fe | 1590 | void MPU6050::setI2CBypassEnabled(bool enabled) |
Heidl | 0:d1960beb98fe | 1591 | { |
Heidl | 0:d1960beb98fe | 1592 | i2Cdev.writeBit(devAddr, MPU6050_RA_INT_PIN_CFG, MPU6050_INTCFG_I2C_BYPASS_EN_BIT, enabled); |
Heidl | 0:d1960beb98fe | 1593 | } |
Heidl | 0:d1960beb98fe | 1594 | /** Get reference clock output enabled status. |
Heidl | 0:d1960beb98fe | 1595 | * When this bit is equal to 1, a reference clock output is provided at the |
Heidl | 0:d1960beb98fe | 1596 | * CLKOUT pin. When this bit is equal to 0, the clock output is disabled. For |
Heidl | 0:d1960beb98fe | 1597 | * further information regarding CLKOUT, please refer to the MPU-60X0 Product |
Heidl | 0:d1960beb98fe | 1598 | * Specification document. |
Heidl | 0:d1960beb98fe | 1599 | * @return Current reference clock output enabled status |
Heidl | 0:d1960beb98fe | 1600 | * @see MPU6050_RA_INT_PIN_CFG |
Heidl | 0:d1960beb98fe | 1601 | * @see MPU6050_INTCFG_CLKOUT_EN_BIT |
Heidl | 0:d1960beb98fe | 1602 | */ |
Heidl | 0:d1960beb98fe | 1603 | bool MPU6050::getClockOutputEnabled() |
Heidl | 0:d1960beb98fe | 1604 | { |
Heidl | 0:d1960beb98fe | 1605 | i2Cdev.readBit(devAddr, MPU6050_RA_INT_PIN_CFG, MPU6050_INTCFG_CLKOUT_EN_BIT, buffer); |
Heidl | 0:d1960beb98fe | 1606 | return buffer[0]; |
Heidl | 0:d1960beb98fe | 1607 | } |
Heidl | 0:d1960beb98fe | 1608 | /** Set reference clock output enabled status. |
Heidl | 0:d1960beb98fe | 1609 | * When this bit is equal to 1, a reference clock output is provided at the |
Heidl | 0:d1960beb98fe | 1610 | * CLKOUT pin. When this bit is equal to 0, the clock output is disabled. For |
Heidl | 0:d1960beb98fe | 1611 | * further information regarding CLKOUT, please refer to the MPU-60X0 Product |
Heidl | 0:d1960beb98fe | 1612 | * Specification document. |
Heidl | 0:d1960beb98fe | 1613 | * @param enabled New reference clock output enabled status |
Heidl | 0:d1960beb98fe | 1614 | * @see MPU6050_RA_INT_PIN_CFG |
Heidl | 0:d1960beb98fe | 1615 | * @see MPU6050_INTCFG_CLKOUT_EN_BIT |
Heidl | 0:d1960beb98fe | 1616 | */ |
Heidl | 0:d1960beb98fe | 1617 | void MPU6050::setClockOutputEnabled(bool enabled) |
Heidl | 0:d1960beb98fe | 1618 | { |
Heidl | 0:d1960beb98fe | 1619 | i2Cdev.writeBit(devAddr, MPU6050_RA_INT_PIN_CFG, MPU6050_INTCFG_CLKOUT_EN_BIT, enabled); |
Heidl | 0:d1960beb98fe | 1620 | } |
Heidl | 0:d1960beb98fe | 1621 | |
Heidl | 0:d1960beb98fe | 1622 | // INT_ENABLE register |
Heidl | 0:d1960beb98fe | 1623 | |
Heidl | 0:d1960beb98fe | 1624 | /** Get full interrupt enabled status. |
Heidl | 0:d1960beb98fe | 1625 | * Full register byte for all interrupts, for quick reading. Each bit will be |
Heidl | 0:d1960beb98fe | 1626 | * set 0 for disabled, 1 for enabled. |
Heidl | 0:d1960beb98fe | 1627 | * @return Current interrupt enabled status |
Heidl | 0:d1960beb98fe | 1628 | * @see MPU6050_RA_INT_ENABLE |
Heidl | 0:d1960beb98fe | 1629 | * @see MPU6050_INTERRUPT_FF_BIT |
Heidl | 0:d1960beb98fe | 1630 | **/ |
Heidl | 0:d1960beb98fe | 1631 | uint8_t MPU6050::getIntEnabled() |
Heidl | 0:d1960beb98fe | 1632 | { |
Heidl | 0:d1960beb98fe | 1633 | i2Cdev.readByte(devAddr, MPU6050_RA_INT_ENABLE, buffer); |
Heidl | 0:d1960beb98fe | 1634 | return buffer[0]; |
Heidl | 0:d1960beb98fe | 1635 | } |
Heidl | 0:d1960beb98fe | 1636 | /** Set full interrupt enabled status. |
Heidl | 0:d1960beb98fe | 1637 | * Full register byte for all interrupts, for quick reading. Each bit should be |
Heidl | 0:d1960beb98fe | 1638 | * set 0 for disabled, 1 for enabled. |
Heidl | 0:d1960beb98fe | 1639 | * @param enabled New interrupt enabled status |
Heidl | 0:d1960beb98fe | 1640 | * @see getIntFreefallEnabled() |
Heidl | 0:d1960beb98fe | 1641 | * @see MPU6050_RA_INT_ENABLE |
Heidl | 0:d1960beb98fe | 1642 | * @see MPU6050_INTERRUPT_FF_BIT |
Heidl | 0:d1960beb98fe | 1643 | **/ |
Heidl | 0:d1960beb98fe | 1644 | void MPU6050::setIntEnabled(uint8_t enabled) |
Heidl | 0:d1960beb98fe | 1645 | { |
Heidl | 0:d1960beb98fe | 1646 | i2Cdev.writeByte(devAddr, MPU6050_RA_INT_ENABLE, enabled); |
Heidl | 0:d1960beb98fe | 1647 | } |
Heidl | 0:d1960beb98fe | 1648 | /** Get Free Fall interrupt enabled status. |
Heidl | 0:d1960beb98fe | 1649 | * Will be set 0 for disabled, 1 for enabled. |
Heidl | 0:d1960beb98fe | 1650 | * @return Current interrupt enabled status |
Heidl | 0:d1960beb98fe | 1651 | * @see MPU6050_RA_INT_ENABLE |
Heidl | 0:d1960beb98fe | 1652 | * @see MPU6050_INTERRUPT_FF_BIT |
Heidl | 0:d1960beb98fe | 1653 | **/ |
Heidl | 0:d1960beb98fe | 1654 | bool MPU6050::getIntFreefallEnabled() |
Heidl | 0:d1960beb98fe | 1655 | { |
Heidl | 0:d1960beb98fe | 1656 | i2Cdev.readBit(devAddr, MPU6050_RA_INT_ENABLE, MPU6050_INTERRUPT_FF_BIT, buffer); |
Heidl | 0:d1960beb98fe | 1657 | return buffer[0]; |
Heidl | 0:d1960beb98fe | 1658 | } |
Heidl | 0:d1960beb98fe | 1659 | /** Set Free Fall interrupt enabled status. |
Heidl | 0:d1960beb98fe | 1660 | * @param enabled New interrupt enabled status |
Heidl | 0:d1960beb98fe | 1661 | * @see getIntFreefallEnabled() |
Heidl | 0:d1960beb98fe | 1662 | * @see MPU6050_RA_INT_ENABLE |
Heidl | 0:d1960beb98fe | 1663 | * @see MPU6050_INTERRUPT_FF_BIT |
Heidl | 0:d1960beb98fe | 1664 | **/ |
Heidl | 0:d1960beb98fe | 1665 | void MPU6050::setIntFreefallEnabled(bool enabled) |
Heidl | 0:d1960beb98fe | 1666 | { |
Heidl | 0:d1960beb98fe | 1667 | i2Cdev.writeBit(devAddr, MPU6050_RA_INT_ENABLE, MPU6050_INTERRUPT_FF_BIT, enabled); |
Heidl | 0:d1960beb98fe | 1668 | } |
Heidl | 0:d1960beb98fe | 1669 | /** Get Motion Detection interrupt enabled status. |
Heidl | 0:d1960beb98fe | 1670 | * Will be set 0 for disabled, 1 for enabled. |
Heidl | 0:d1960beb98fe | 1671 | * @return Current interrupt enabled status |
Heidl | 0:d1960beb98fe | 1672 | * @see MPU6050_RA_INT_ENABLE |
Heidl | 0:d1960beb98fe | 1673 | * @see MPU6050_INTERRUPT_MOT_BIT |
Heidl | 0:d1960beb98fe | 1674 | **/ |
Heidl | 0:d1960beb98fe | 1675 | bool MPU6050::getIntMotionEnabled() |
Heidl | 0:d1960beb98fe | 1676 | { |
Heidl | 0:d1960beb98fe | 1677 | i2Cdev.readBit(devAddr, MPU6050_RA_INT_ENABLE, MPU6050_INTERRUPT_MOT_BIT, buffer); |
Heidl | 0:d1960beb98fe | 1678 | return buffer[0]; |
Heidl | 0:d1960beb98fe | 1679 | } |
Heidl | 0:d1960beb98fe | 1680 | /** Set Motion Detection interrupt enabled status. |
Heidl | 0:d1960beb98fe | 1681 | * @param enabled New interrupt enabled status |
Heidl | 0:d1960beb98fe | 1682 | * @see getIntMotionEnabled() |
Heidl | 0:d1960beb98fe | 1683 | * @see MPU6050_RA_INT_ENABLE |
Heidl | 0:d1960beb98fe | 1684 | * @see MPU6050_INTERRUPT_MOT_BIT |
Heidl | 0:d1960beb98fe | 1685 | **/ |
Heidl | 0:d1960beb98fe | 1686 | void MPU6050::setIntMotionEnabled(bool enabled) |
Heidl | 0:d1960beb98fe | 1687 | { |
Heidl | 0:d1960beb98fe | 1688 | i2Cdev.writeBit(devAddr, MPU6050_RA_INT_ENABLE, MPU6050_INTERRUPT_MOT_BIT, enabled); |
Heidl | 0:d1960beb98fe | 1689 | } |
Heidl | 0:d1960beb98fe | 1690 | /** Get Zero Motion Detection interrupt enabled status. |
Heidl | 0:d1960beb98fe | 1691 | * Will be set 0 for disabled, 1 for enabled. |
Heidl | 0:d1960beb98fe | 1692 | * @return Current interrupt enabled status |
Heidl | 0:d1960beb98fe | 1693 | * @see MPU6050_RA_INT_ENABLE |
Heidl | 0:d1960beb98fe | 1694 | * @see MPU6050_INTERRUPT_ZMOT_BIT |
Heidl | 0:d1960beb98fe | 1695 | **/ |
Heidl | 0:d1960beb98fe | 1696 | bool MPU6050::getIntZeroMotionEnabled() |
Heidl | 0:d1960beb98fe | 1697 | { |
Heidl | 0:d1960beb98fe | 1698 | i2Cdev.readBit(devAddr, MPU6050_RA_INT_ENABLE, MPU6050_INTERRUPT_ZMOT_BIT, buffer); |
Heidl | 0:d1960beb98fe | 1699 | return buffer[0]; |
Heidl | 0:d1960beb98fe | 1700 | } |
Heidl | 0:d1960beb98fe | 1701 | /** Set Zero Motion Detection interrupt enabled status. |
Heidl | 0:d1960beb98fe | 1702 | * @param enabled New interrupt enabled status |
Heidl | 0:d1960beb98fe | 1703 | * @see getIntZeroMotionEnabled() |
Heidl | 0:d1960beb98fe | 1704 | * @see MPU6050_RA_INT_ENABLE |
Heidl | 0:d1960beb98fe | 1705 | * @see MPU6050_INTERRUPT_ZMOT_BIT |
Heidl | 0:d1960beb98fe | 1706 | **/ |
Heidl | 0:d1960beb98fe | 1707 | void MPU6050::setIntZeroMotionEnabled(bool enabled) |
Heidl | 0:d1960beb98fe | 1708 | { |
Heidl | 0:d1960beb98fe | 1709 | i2Cdev.writeBit(devAddr, MPU6050_RA_INT_ENABLE, MPU6050_INTERRUPT_ZMOT_BIT, enabled); |
Heidl | 0:d1960beb98fe | 1710 | } |
Heidl | 0:d1960beb98fe | 1711 | /** Get FIFO Buffer Overflow interrupt enabled status. |
Heidl | 0:d1960beb98fe | 1712 | * Will be set 0 for disabled, 1 for enabled. |
Heidl | 0:d1960beb98fe | 1713 | * @return Current interrupt enabled status |
Heidl | 0:d1960beb98fe | 1714 | * @see MPU6050_RA_INT_ENABLE |
Heidl | 0:d1960beb98fe | 1715 | * @see MPU6050_INTERRUPT_FIFO_OFLOW_BIT |
Heidl | 0:d1960beb98fe | 1716 | **/ |
Heidl | 0:d1960beb98fe | 1717 | bool MPU6050::getIntFIFOBufferOverflowEnabled() |
Heidl | 0:d1960beb98fe | 1718 | { |
Heidl | 0:d1960beb98fe | 1719 | i2Cdev.readBit(devAddr, MPU6050_RA_INT_ENABLE, MPU6050_INTERRUPT_FIFO_OFLOW_BIT, buffer); |
Heidl | 0:d1960beb98fe | 1720 | return buffer[0]; |
Heidl | 0:d1960beb98fe | 1721 | } |
Heidl | 0:d1960beb98fe | 1722 | /** Set FIFO Buffer Overflow interrupt enabled status. |
Heidl | 0:d1960beb98fe | 1723 | * @param enabled New interrupt enabled status |
Heidl | 0:d1960beb98fe | 1724 | * @see getIntFIFOBufferOverflowEnabled() |
Heidl | 0:d1960beb98fe | 1725 | * @see MPU6050_RA_INT_ENABLE |
Heidl | 0:d1960beb98fe | 1726 | * @see MPU6050_INTERRUPT_FIFO_OFLOW_BIT |
Heidl | 0:d1960beb98fe | 1727 | **/ |
Heidl | 0:d1960beb98fe | 1728 | void MPU6050::setIntFIFOBufferOverflowEnabled(bool enabled) |
Heidl | 0:d1960beb98fe | 1729 | { |
Heidl | 0:d1960beb98fe | 1730 | i2Cdev.writeBit(devAddr, MPU6050_RA_INT_ENABLE, MPU6050_INTERRUPT_FIFO_OFLOW_BIT, enabled); |
Heidl | 0:d1960beb98fe | 1731 | } |
Heidl | 0:d1960beb98fe | 1732 | /** Get I2C Master interrupt enabled status. |
Heidl | 0:d1960beb98fe | 1733 | * This enables any of the I2C Master interrupt sources to generate an |
Heidl | 0:d1960beb98fe | 1734 | * interrupt. Will be set 0 for disabled, 1 for enabled. |
Heidl | 0:d1960beb98fe | 1735 | * @return Current interrupt enabled status |
Heidl | 0:d1960beb98fe | 1736 | * @see MPU6050_RA_INT_ENABLE |
Heidl | 0:d1960beb98fe | 1737 | * @see MPU6050_INTERRUPT_I2C_MST_INT_BIT |
Heidl | 0:d1960beb98fe | 1738 | **/ |
Heidl | 0:d1960beb98fe | 1739 | bool MPU6050::getIntI2CMasterEnabled() |
Heidl | 0:d1960beb98fe | 1740 | { |
Heidl | 0:d1960beb98fe | 1741 | i2Cdev.readBit(devAddr, MPU6050_RA_INT_ENABLE, MPU6050_INTERRUPT_I2C_MST_INT_BIT, buffer); |
Heidl | 0:d1960beb98fe | 1742 | return buffer[0]; |
Heidl | 0:d1960beb98fe | 1743 | } |
Heidl | 0:d1960beb98fe | 1744 | /** Set I2C Master interrupt enabled status. |
Heidl | 0:d1960beb98fe | 1745 | * @param enabled New interrupt enabled status |
Heidl | 0:d1960beb98fe | 1746 | * @see getIntI2CMasterEnabled() |
Heidl | 0:d1960beb98fe | 1747 | * @see MPU6050_RA_INT_ENABLE |
Heidl | 0:d1960beb98fe | 1748 | * @see MPU6050_INTERRUPT_I2C_MST_INT_BIT |
Heidl | 0:d1960beb98fe | 1749 | **/ |
Heidl | 0:d1960beb98fe | 1750 | void MPU6050::setIntI2CMasterEnabled(bool enabled) |
Heidl | 0:d1960beb98fe | 1751 | { |
Heidl | 0:d1960beb98fe | 1752 | i2Cdev.writeBit(devAddr, MPU6050_RA_INT_ENABLE, MPU6050_INTERRUPT_I2C_MST_INT_BIT, enabled); |
Heidl | 0:d1960beb98fe | 1753 | } |
Heidl | 0:d1960beb98fe | 1754 | /** Get Data Ready interrupt enabled setting. |
Heidl | 0:d1960beb98fe | 1755 | * This event occurs each time a write operation to all of the sensor registers |
Heidl | 0:d1960beb98fe | 1756 | * has been completed. Will be set 0 for disabled, 1 for enabled. |
Heidl | 0:d1960beb98fe | 1757 | * @return Current interrupt enabled status |
Heidl | 0:d1960beb98fe | 1758 | * @see MPU6050_RA_INT_ENABLE |
Heidl | 0:d1960beb98fe | 1759 | * @see MPU6050_INTERRUPT_DATA_RDY_BIT |
Heidl | 0:d1960beb98fe | 1760 | */ |
Heidl | 0:d1960beb98fe | 1761 | bool MPU6050::getIntDataReadyEnabled() |
Heidl | 0:d1960beb98fe | 1762 | { |
Heidl | 0:d1960beb98fe | 1763 | i2Cdev.readBit(devAddr, MPU6050_RA_INT_ENABLE, MPU6050_INTERRUPT_DATA_RDY_BIT, buffer); |
Heidl | 0:d1960beb98fe | 1764 | return buffer[0]; |
Heidl | 0:d1960beb98fe | 1765 | } |
Heidl | 0:d1960beb98fe | 1766 | /** Set Data Ready interrupt enabled status. |
Heidl | 0:d1960beb98fe | 1767 | * @param enabled New interrupt enabled status |
Heidl | 0:d1960beb98fe | 1768 | * @see getIntDataReadyEnabled() |
Heidl | 0:d1960beb98fe | 1769 | * @see MPU6050_RA_INT_CFG |
Heidl | 0:d1960beb98fe | 1770 | * @see MPU6050_INTERRUPT_DATA_RDY_BIT |
Heidl | 0:d1960beb98fe | 1771 | */ |
Heidl | 0:d1960beb98fe | 1772 | void MPU6050::setIntDataReadyEnabled(bool enabled) |
Heidl | 0:d1960beb98fe | 1773 | { |
Heidl | 0:d1960beb98fe | 1774 | i2Cdev.writeBit(devAddr, MPU6050_RA_INT_ENABLE, MPU6050_INTERRUPT_DATA_RDY_BIT, enabled); |
Heidl | 0:d1960beb98fe | 1775 | } |
Heidl | 0:d1960beb98fe | 1776 | |
Heidl | 0:d1960beb98fe | 1777 | // INT_STATUS register |
Heidl | 0:d1960beb98fe | 1778 | |
Heidl | 0:d1960beb98fe | 1779 | /** Get full set of interrupt status bits. |
Heidl | 0:d1960beb98fe | 1780 | * These bits clear to 0 after the register has been read. Very useful |
Heidl | 0:d1960beb98fe | 1781 | * for getting multiple INT statuses, since each single bit read clears |
Heidl | 0:d1960beb98fe | 1782 | * all of them because it has to read the whole byte. |
Heidl | 0:d1960beb98fe | 1783 | * @return Current interrupt status |
Heidl | 0:d1960beb98fe | 1784 | * @see MPU6050_RA_INT_STATUS |
Heidl | 0:d1960beb98fe | 1785 | */ |
Heidl | 0:d1960beb98fe | 1786 | uint8_t MPU6050::getIntStatus() |
Heidl | 0:d1960beb98fe | 1787 | { |
Heidl | 0:d1960beb98fe | 1788 | i2Cdev.readByte(devAddr, MPU6050_RA_INT_STATUS, buffer); |
Heidl | 0:d1960beb98fe | 1789 | return buffer[0]; |
Heidl | 0:d1960beb98fe | 1790 | } |
Heidl | 0:d1960beb98fe | 1791 | /** Get Free Fall interrupt status. |
Heidl | 0:d1960beb98fe | 1792 | * This bit automatically sets to 1 when a Free Fall interrupt has been |
Heidl | 0:d1960beb98fe | 1793 | * generated. The bit clears to 0 after the register has been read. |
Heidl | 0:d1960beb98fe | 1794 | * @return Current interrupt status |
Heidl | 0:d1960beb98fe | 1795 | * @see MPU6050_RA_INT_STATUS |
Heidl | 0:d1960beb98fe | 1796 | * @see MPU6050_INTERRUPT_FF_BIT |
Heidl | 0:d1960beb98fe | 1797 | */ |
Heidl | 0:d1960beb98fe | 1798 | bool MPU6050::getIntFreefallStatus() |
Heidl | 0:d1960beb98fe | 1799 | { |
Heidl | 0:d1960beb98fe | 1800 | i2Cdev.readBit(devAddr, MPU6050_RA_INT_STATUS, MPU6050_INTERRUPT_FF_BIT, buffer); |
Heidl | 0:d1960beb98fe | 1801 | return buffer[0]; |
Heidl | 0:d1960beb98fe | 1802 | } |
Heidl | 0:d1960beb98fe | 1803 | /** Get Motion Detection interrupt status. |
Heidl | 0:d1960beb98fe | 1804 | * This bit automatically sets to 1 when a Motion Detection interrupt has been |
Heidl | 0:d1960beb98fe | 1805 | * generated. The bit clears to 0 after the register has been read. |
Heidl | 0:d1960beb98fe | 1806 | * @return Current interrupt status |
Heidl | 0:d1960beb98fe | 1807 | * @see MPU6050_RA_INT_STATUS |
Heidl | 0:d1960beb98fe | 1808 | * @see MPU6050_INTERRUPT_MOT_BIT |
Heidl | 0:d1960beb98fe | 1809 | */ |
Heidl | 0:d1960beb98fe | 1810 | bool MPU6050::getIntMotionStatus() |
Heidl | 0:d1960beb98fe | 1811 | { |
Heidl | 0:d1960beb98fe | 1812 | i2Cdev.readBit(devAddr, MPU6050_RA_INT_STATUS, MPU6050_INTERRUPT_MOT_BIT, buffer); |
Heidl | 0:d1960beb98fe | 1813 | return buffer[0]; |
Heidl | 0:d1960beb98fe | 1814 | } |
Heidl | 0:d1960beb98fe | 1815 | /** Get Zero Motion Detection interrupt status. |
Heidl | 0:d1960beb98fe | 1816 | * This bit automatically sets to 1 when a Zero Motion Detection interrupt has |
Heidl | 0:d1960beb98fe | 1817 | * been generated. The bit clears to 0 after the register has been read. |
Heidl | 0:d1960beb98fe | 1818 | * @return Current interrupt status |
Heidl | 0:d1960beb98fe | 1819 | * @see MPU6050_RA_INT_STATUS |
Heidl | 0:d1960beb98fe | 1820 | * @see MPU6050_INTERRUPT_ZMOT_BIT |
Heidl | 0:d1960beb98fe | 1821 | */ |
Heidl | 0:d1960beb98fe | 1822 | bool MPU6050::getIntZeroMotionStatus() |
Heidl | 0:d1960beb98fe | 1823 | { |
Heidl | 0:d1960beb98fe | 1824 | i2Cdev.readBit(devAddr, MPU6050_RA_INT_STATUS, MPU6050_INTERRUPT_ZMOT_BIT, buffer); |
Heidl | 0:d1960beb98fe | 1825 | return buffer[0]; |
Heidl | 0:d1960beb98fe | 1826 | } |
Heidl | 0:d1960beb98fe | 1827 | /** Get FIFO Buffer Overflow interrupt status. |
Heidl | 0:d1960beb98fe | 1828 | * This bit automatically sets to 1 when a Free Fall interrupt has been |
Heidl | 0:d1960beb98fe | 1829 | * generated. The bit clears to 0 after the register has been read. |
Heidl | 0:d1960beb98fe | 1830 | * @return Current interrupt status |
Heidl | 0:d1960beb98fe | 1831 | * @see MPU6050_RA_INT_STATUS |
Heidl | 0:d1960beb98fe | 1832 | * @see MPU6050_INTERRUPT_FIFO_OFLOW_BIT |
Heidl | 0:d1960beb98fe | 1833 | */ |
Heidl | 0:d1960beb98fe | 1834 | bool MPU6050::getIntFIFOBufferOverflowStatus() |
Heidl | 0:d1960beb98fe | 1835 | { |
Heidl | 0:d1960beb98fe | 1836 | i2Cdev.readBit(devAddr, MPU6050_RA_INT_STATUS, MPU6050_INTERRUPT_FIFO_OFLOW_BIT, buffer); |
Heidl | 0:d1960beb98fe | 1837 | return buffer[0]; |
Heidl | 0:d1960beb98fe | 1838 | } |
Heidl | 0:d1960beb98fe | 1839 | /** Get I2C Master interrupt status. |
Heidl | 0:d1960beb98fe | 1840 | * This bit automatically sets to 1 when an I2C Master interrupt has been |
Heidl | 0:d1960beb98fe | 1841 | * generated. For a list of I2C Master interrupts, please refer to Register 54. |
Heidl | 0:d1960beb98fe | 1842 | * The bit clears to 0 after the register has been read. |
Heidl | 0:d1960beb98fe | 1843 | * @return Current interrupt status |
Heidl | 0:d1960beb98fe | 1844 | * @see MPU6050_RA_INT_STATUS |
Heidl | 0:d1960beb98fe | 1845 | * @see MPU6050_INTERRUPT_I2C_MST_INT_BIT |
Heidl | 0:d1960beb98fe | 1846 | */ |
Heidl | 0:d1960beb98fe | 1847 | bool MPU6050::getIntI2CMasterStatus() |
Heidl | 0:d1960beb98fe | 1848 | { |
Heidl | 0:d1960beb98fe | 1849 | i2Cdev.readBit(devAddr, MPU6050_RA_INT_STATUS, MPU6050_INTERRUPT_I2C_MST_INT_BIT, buffer); |
Heidl | 0:d1960beb98fe | 1850 | return buffer[0]; |
Heidl | 0:d1960beb98fe | 1851 | } |
Heidl | 0:d1960beb98fe | 1852 | /** Get Data Ready interrupt status. |
Heidl | 0:d1960beb98fe | 1853 | * This bit automatically sets to 1 when a Data Ready interrupt has been |
Heidl | 0:d1960beb98fe | 1854 | * generated. The bit clears to 0 after the register has been read. |
Heidl | 0:d1960beb98fe | 1855 | * @return Current interrupt status |
Heidl | 0:d1960beb98fe | 1856 | * @see MPU6050_RA_INT_STATUS |
Heidl | 0:d1960beb98fe | 1857 | * @see MPU6050_INTERRUPT_DATA_RDY_BIT |
Heidl | 0:d1960beb98fe | 1858 | */ |
Heidl | 0:d1960beb98fe | 1859 | bool MPU6050::getIntDataReadyStatus() |
Heidl | 0:d1960beb98fe | 1860 | { |
Heidl | 0:d1960beb98fe | 1861 | i2Cdev.readBit(devAddr, MPU6050_RA_INT_STATUS, MPU6050_INTERRUPT_DATA_RDY_BIT, buffer); |
Heidl | 0:d1960beb98fe | 1862 | return buffer[0]; |
Heidl | 0:d1960beb98fe | 1863 | } |
Heidl | 0:d1960beb98fe | 1864 | |
Heidl | 0:d1960beb98fe | 1865 | // ACCEL_*OUT_* registers |
Heidl | 0:d1960beb98fe | 1866 | |
Heidl | 0:d1960beb98fe | 1867 | /** Get raw 9-axis motion sensor readings (accel/gyro/compass). |
Heidl | 0:d1960beb98fe | 1868 | * FUNCTION NOT FULLY IMPLEMENTED YET. |
Heidl | 0:d1960beb98fe | 1869 | * @param ax 16-bit signed integer container for accelerometer X-axis value |
Heidl | 0:d1960beb98fe | 1870 | * @param ay 16-bit signed integer container for accelerometer Y-axis value |
Heidl | 0:d1960beb98fe | 1871 | * @param az 16-bit signed integer container for accelerometer Z-axis value |
Heidl | 0:d1960beb98fe | 1872 | * @param gx 16-bit signed integer container for gyroscope X-axis value |
Heidl | 0:d1960beb98fe | 1873 | * @param gy 16-bit signed integer container for gyroscope Y-axis value |
Heidl | 0:d1960beb98fe | 1874 | * @param gz 16-bit signed integer container for gyroscope Z-axis value |
Heidl | 0:d1960beb98fe | 1875 | * @param mx 16-bit signed integer container for magnetometer X-axis value |
Heidl | 0:d1960beb98fe | 1876 | * @param my 16-bit signed integer container for magnetometer Y-axis value |
Heidl | 0:d1960beb98fe | 1877 | * @param mz 16-bit signed integer container for magnetometer Z-axis value |
Heidl | 0:d1960beb98fe | 1878 | * @see getMotion6() |
Heidl | 0:d1960beb98fe | 1879 | * @see getAcceleration() |
Heidl | 0:d1960beb98fe | 1880 | * @see getRotation() |
Heidl | 0:d1960beb98fe | 1881 | * @see MPU6050_RA_ACCEL_XOUT_H |
Heidl | 0:d1960beb98fe | 1882 | */ |
Heidl | 0:d1960beb98fe | 1883 | void MPU6050::getMotion9(int16_t* ax, int16_t* ay, int16_t* az, int16_t* gx, int16_t* gy, int16_t* gz, int16_t* mx, int16_t* my, int16_t* mz) |
Heidl | 0:d1960beb98fe | 1884 | { |
Heidl | 0:d1960beb98fe | 1885 | getMotion6(ax, ay, az, gx, gy, gz); |
Heidl | 0:d1960beb98fe | 1886 | // TODO: magnetometer integration |
Heidl | 0:d1960beb98fe | 1887 | } |
Heidl | 0:d1960beb98fe | 1888 | /** Get raw 6-axis motion sensor readings (accel/gyro). |
Heidl | 0:d1960beb98fe | 1889 | * Retrieves all currently available motion sensor values. |
Heidl | 0:d1960beb98fe | 1890 | * @param ax 16-bit signed integer container for accelerometer X-axis value |
Heidl | 0:d1960beb98fe | 1891 | * @param ay 16-bit signed integer container for accelerometer Y-axis value |
Heidl | 0:d1960beb98fe | 1892 | * @param az 16-bit signed integer container for accelerometer Z-axis value |
Heidl | 0:d1960beb98fe | 1893 | * @param gx 16-bit signed integer container for gyroscope X-axis value |
Heidl | 0:d1960beb98fe | 1894 | * @param gy 16-bit signed integer container for gyroscope Y-axis value |
Heidl | 0:d1960beb98fe | 1895 | * @param gz 16-bit signed integer container for gyroscope Z-axis value |
Heidl | 0:d1960beb98fe | 1896 | * @see getAcceleration() |
Heidl | 0:d1960beb98fe | 1897 | * @see getRotation() |
Heidl | 0:d1960beb98fe | 1898 | * @see MPU6050_RA_ACCEL_XOUT_H |
Heidl | 0:d1960beb98fe | 1899 | */ |
Heidl | 0:d1960beb98fe | 1900 | void MPU6050::getMotion6(int16_t* ax, int16_t* ay, int16_t* az, int16_t* gx, int16_t* gy, int16_t* gz) |
Heidl | 0:d1960beb98fe | 1901 | { |
Heidl | 0:d1960beb98fe | 1902 | i2Cdev.readBytes(devAddr, MPU6050_RA_ACCEL_XOUT_H, 14, buffer); |
Heidl | 0:d1960beb98fe | 1903 | *ax = (((int16_t)buffer[0]) << 8) | buffer[1]; |
Heidl | 0:d1960beb98fe | 1904 | *ay = (((int16_t)buffer[2]) << 8) | buffer[3]; |
Heidl | 0:d1960beb98fe | 1905 | *az = (((int16_t)buffer[4]) << 8) | buffer[5]; |
Heidl | 0:d1960beb98fe | 1906 | *gx = (((int16_t)buffer[8]) << 8) | buffer[9]; |
Heidl | 0:d1960beb98fe | 1907 | *gy = (((int16_t)buffer[10]) << 8) | buffer[11]; |
Heidl | 0:d1960beb98fe | 1908 | *gz = (((int16_t)buffer[12]) << 8) | buffer[13]; |
Heidl | 0:d1960beb98fe | 1909 | } |
Heidl | 0:d1960beb98fe | 1910 | /** Get 3-axis accelerometer readings. |
Heidl | 0:d1960beb98fe | 1911 | * These registers store the most recent accelerometer measurements. |
Heidl | 0:d1960beb98fe | 1912 | * Accelerometer measurements are written to these registers at the Sample Rate |
Heidl | 0:d1960beb98fe | 1913 | * as defined in Register 25. |
Heidl | 0:d1960beb98fe | 1914 | * |
Heidl | 0:d1960beb98fe | 1915 | * The accelerometer measurement registers, along with the temperature |
Heidl | 0:d1960beb98fe | 1916 | * measurement registers, gyroscope measurement registers, and external sensor |
Heidl | 0:d1960beb98fe | 1917 | * data registers, are composed of two sets of registers: an internal register |
Heidl | 0:d1960beb98fe | 1918 | * set and a user-facing read register set. |
Heidl | 0:d1960beb98fe | 1919 | * |
Heidl | 0:d1960beb98fe | 1920 | * The data within the accelerometer sensors' internal register set is always |
Heidl | 0:d1960beb98fe | 1921 | * updated at the Sample Rate. Meanwhile, the user-facing read register set |
Heidl | 0:d1960beb98fe | 1922 | * duplicates the internal register set's data values whenever the serial |
Heidl | 0:d1960beb98fe | 1923 | * interface is idle. This guarantees that a burst read of sensor registers will |
Heidl | 0:d1960beb98fe | 1924 | * read measurements from the same sampling instant. Note that if burst reads |
Heidl | 0:d1960beb98fe | 1925 | * are not used, the user is responsible for ensuring a set of single byte reads |
Heidl | 0:d1960beb98fe | 1926 | * correspond to a single sampling instant by checking the Data Ready interrupt. |
Heidl | 0:d1960beb98fe | 1927 | * |
Heidl | 0:d1960beb98fe | 1928 | * Each 16-bit accelerometer measurement has a full scale defined in ACCEL_FS |
Heidl | 0:d1960beb98fe | 1929 | * (Register 28). For each full scale setting, the accelerometers' sensitivity |
Heidl | 0:d1960beb98fe | 1930 | * per LSB in ACCEL_xOUT is shown in the table below: |
Heidl | 0:d1960beb98fe | 1931 | * |
Heidl | 0:d1960beb98fe | 1932 | * <pre> |
Heidl | 0:d1960beb98fe | 1933 | * AFS_SEL | Full Scale Range | LSB Sensitivity |
Heidl | 0:d1960beb98fe | 1934 | * --------+------------------+---------------- |
Heidl | 0:d1960beb98fe | 1935 | * 0 | +/- 2g | 8192 LSB/mg |
Heidl | 0:d1960beb98fe | 1936 | * 1 | +/- 4g | 4096 LSB/mg |
Heidl | 0:d1960beb98fe | 1937 | * 2 | +/- 8g | 2048 LSB/mg |
Heidl | 0:d1960beb98fe | 1938 | * 3 | +/- 16g | 1024 LSB/mg |
Heidl | 0:d1960beb98fe | 1939 | * </pre> |
Heidl | 0:d1960beb98fe | 1940 | * |
Heidl | 0:d1960beb98fe | 1941 | * @param x 16-bit signed integer container for X-axis acceleration |
Heidl | 0:d1960beb98fe | 1942 | * @param y 16-bit signed integer container for Y-axis acceleration |
Heidl | 0:d1960beb98fe | 1943 | * @param z 16-bit signed integer container for Z-axis acceleration |
Heidl | 0:d1960beb98fe | 1944 | * @see MPU6050_RA_GYRO_XOUT_H |
Heidl | 0:d1960beb98fe | 1945 | */ |
Heidl | 0:d1960beb98fe | 1946 | void MPU6050::getAcceleration(int16_t* x, int16_t* y, int16_t* z) |
Heidl | 0:d1960beb98fe | 1947 | { |
Heidl | 0:d1960beb98fe | 1948 | i2Cdev.readBytes(devAddr, MPU6050_RA_ACCEL_XOUT_H, 6, buffer); |
Heidl | 0:d1960beb98fe | 1949 | *x = (((int16_t)buffer[0]) << 8) | buffer[1]; |
Heidl | 0:d1960beb98fe | 1950 | *y = (((int16_t)buffer[2]) << 8) | buffer[3]; |
Heidl | 0:d1960beb98fe | 1951 | *z = (((int16_t)buffer[4]) << 8) | buffer[5]; |
Heidl | 0:d1960beb98fe | 1952 | } |
Heidl | 0:d1960beb98fe | 1953 | /** Get X-axis accelerometer reading. |
Heidl | 0:d1960beb98fe | 1954 | * @return X-axis acceleration measurement in 16-bit 2's complement format |
Heidl | 0:d1960beb98fe | 1955 | * @see getMotion6() |
Heidl | 0:d1960beb98fe | 1956 | * @see MPU6050_RA_ACCEL_XOUT_H |
Heidl | 0:d1960beb98fe | 1957 | */ |
Heidl | 0:d1960beb98fe | 1958 | int16_t MPU6050::getAccelerationX() |
Heidl | 0:d1960beb98fe | 1959 | { |
Heidl | 0:d1960beb98fe | 1960 | i2Cdev.readBytes(devAddr, MPU6050_RA_ACCEL_XOUT_H, 2, buffer); |
Heidl | 0:d1960beb98fe | 1961 | return (((int16_t)buffer[0]) << 8) | buffer[1]; |
Heidl | 0:d1960beb98fe | 1962 | } |
Heidl | 0:d1960beb98fe | 1963 | /** Get Y-axis accelerometer reading. |
Heidl | 0:d1960beb98fe | 1964 | * @return Y-axis acceleration measurement in 16-bit 2's complement format |
Heidl | 0:d1960beb98fe | 1965 | * @see getMotion6() |
Heidl | 0:d1960beb98fe | 1966 | * @see MPU6050_RA_ACCEL_YOUT_H |
Heidl | 0:d1960beb98fe | 1967 | */ |
Heidl | 0:d1960beb98fe | 1968 | int16_t MPU6050::getAccelerationY() |
Heidl | 0:d1960beb98fe | 1969 | { |
Heidl | 0:d1960beb98fe | 1970 | i2Cdev.readBytes(devAddr, MPU6050_RA_ACCEL_YOUT_H, 2, buffer); |
Heidl | 0:d1960beb98fe | 1971 | return (((int16_t)buffer[0]) << 8) | buffer[1]; |
Heidl | 0:d1960beb98fe | 1972 | } |
Heidl | 0:d1960beb98fe | 1973 | /** Get Z-axis accelerometer reading. |
Heidl | 0:d1960beb98fe | 1974 | * @return Z-axis acceleration measurement in 16-bit 2's complement format |
Heidl | 0:d1960beb98fe | 1975 | * @see getMotion6() |
Heidl | 0:d1960beb98fe | 1976 | * @see MPU6050_RA_ACCEL_ZOUT_H |
Heidl | 0:d1960beb98fe | 1977 | */ |
Heidl | 0:d1960beb98fe | 1978 | int16_t MPU6050::getAccelerationZ() |
Heidl | 0:d1960beb98fe | 1979 | { |
Heidl | 0:d1960beb98fe | 1980 | i2Cdev.readBytes(devAddr, MPU6050_RA_ACCEL_ZOUT_H, 2, buffer); |
Heidl | 0:d1960beb98fe | 1981 | return (((int16_t)buffer[0]) << 8) | buffer[1]; |
Heidl | 0:d1960beb98fe | 1982 | } |
Heidl | 0:d1960beb98fe | 1983 | |
Heidl | 0:d1960beb98fe | 1984 | // TEMP_OUT_* registers |
Heidl | 0:d1960beb98fe | 1985 | |
Heidl | 0:d1960beb98fe | 1986 | /** Get current internal temperature. |
Heidl | 0:d1960beb98fe | 1987 | * @return Temperature reading in 16-bit 2's complement format |
Heidl | 0:d1960beb98fe | 1988 | * @see MPU6050_RA_TEMP_OUT_H |
Heidl | 0:d1960beb98fe | 1989 | */ |
Heidl | 0:d1960beb98fe | 1990 | int16_t MPU6050::getTemperature() |
Heidl | 0:d1960beb98fe | 1991 | { |
Heidl | 0:d1960beb98fe | 1992 | i2Cdev.readBytes(devAddr, MPU6050_RA_TEMP_OUT_H, 2, buffer); |
Heidl | 0:d1960beb98fe | 1993 | return (((int16_t)buffer[0]) << 8) | buffer[1]; |
Heidl | 0:d1960beb98fe | 1994 | } |
Heidl | 0:d1960beb98fe | 1995 | |
Heidl | 0:d1960beb98fe | 1996 | // GYRO_*OUT_* registers |
Heidl | 0:d1960beb98fe | 1997 | |
Heidl | 0:d1960beb98fe | 1998 | /** Get 3-axis gyroscope readings. |
Heidl | 0:d1960beb98fe | 1999 | * These gyroscope measurement registers, along with the accelerometer |
Heidl | 0:d1960beb98fe | 2000 | * measurement registers, temperature measurement registers, and external sensor |
Heidl | 0:d1960beb98fe | 2001 | * data registers, are composed of two sets of registers: an internal register |
Heidl | 0:d1960beb98fe | 2002 | * set and a user-facing read register set. |
Heidl | 0:d1960beb98fe | 2003 | * The data within the gyroscope sensors' internal register set is always |
Heidl | 0:d1960beb98fe | 2004 | * updated at the Sample Rate. Meanwhile, the user-facing read register set |
Heidl | 0:d1960beb98fe | 2005 | * duplicates the internal register set's data values whenever the serial |
Heidl | 0:d1960beb98fe | 2006 | * interface is idle. This guarantees that a burst read of sensor registers will |
Heidl | 0:d1960beb98fe | 2007 | * read measurements from the same sampling instant. Note that if burst reads |
Heidl | 0:d1960beb98fe | 2008 | * are not used, the user is responsible for ensuring a set of single byte reads |
Heidl | 0:d1960beb98fe | 2009 | * correspond to a single sampling instant by checking the Data Ready interrupt. |
Heidl | 0:d1960beb98fe | 2010 | * |
Heidl | 0:d1960beb98fe | 2011 | * Each 16-bit gyroscope measurement has a full scale defined in FS_SEL |
Heidl | 0:d1960beb98fe | 2012 | * (Register 27). For each full scale setting, the gyroscopes' sensitivity per |
Heidl | 0:d1960beb98fe | 2013 | * LSB in GYRO_xOUT is shown in the table below: |
Heidl | 0:d1960beb98fe | 2014 | * |
Heidl | 0:d1960beb98fe | 2015 | * <pre> |
Heidl | 0:d1960beb98fe | 2016 | * FS_SEL | Full Scale Range | LSB Sensitivity |
Heidl | 0:d1960beb98fe | 2017 | * -------+--------------------+---------------- |
Heidl | 0:d1960beb98fe | 2018 | * 0 | +/- 250 degrees/s | 131 LSB/deg/s |
Heidl | 0:d1960beb98fe | 2019 | * 1 | +/- 500 degrees/s | 65.5 LSB/deg/s |
Heidl | 0:d1960beb98fe | 2020 | * 2 | +/- 1000 degrees/s | 32.8 LSB/deg/s |
Heidl | 0:d1960beb98fe | 2021 | * 3 | +/- 2000 degrees/s | 16.4 LSB/deg/s |
Heidl | 0:d1960beb98fe | 2022 | * </pre> |
Heidl | 0:d1960beb98fe | 2023 | * |
Heidl | 0:d1960beb98fe | 2024 | * @param x 16-bit signed integer container for X-axis rotation |
Heidl | 0:d1960beb98fe | 2025 | * @param y 16-bit signed integer container for Y-axis rotation |
Heidl | 0:d1960beb98fe | 2026 | * @param z 16-bit signed integer container for Z-axis rotation |
Heidl | 0:d1960beb98fe | 2027 | * @see getMotion6() |
Heidl | 0:d1960beb98fe | 2028 | * @see MPU6050_RA_GYRO_XOUT_H |
Heidl | 0:d1960beb98fe | 2029 | */ |
Heidl | 0:d1960beb98fe | 2030 | void MPU6050::getRotation(int16_t* x, int16_t* y, int16_t* z) |
Heidl | 0:d1960beb98fe | 2031 | { |
Heidl | 0:d1960beb98fe | 2032 | i2Cdev.readBytes(devAddr, MPU6050_RA_GYRO_XOUT_H, 6, buffer); |
Heidl | 0:d1960beb98fe | 2033 | *x = (((int16_t)buffer[0]) << 8) | buffer[1]; |
Heidl | 0:d1960beb98fe | 2034 | *y = (((int16_t)buffer[2]) << 8) | buffer[3]; |
Heidl | 0:d1960beb98fe | 2035 | *z = (((int16_t)buffer[4]) << 8) | buffer[5]; |
Heidl | 0:d1960beb98fe | 2036 | } |
Heidl | 0:d1960beb98fe | 2037 | /** Get X-axis gyroscope reading. |
Heidl | 0:d1960beb98fe | 2038 | * @return X-axis rotation measurement in 16-bit 2's complement format |
Heidl | 0:d1960beb98fe | 2039 | * @see getMotion6() |
Heidl | 0:d1960beb98fe | 2040 | * @see MPU6050_RA_GYRO_XOUT_H |
Heidl | 0:d1960beb98fe | 2041 | */ |
Heidl | 0:d1960beb98fe | 2042 | int16_t MPU6050::getRotationX() |
Heidl | 0:d1960beb98fe | 2043 | { |
Heidl | 0:d1960beb98fe | 2044 | i2Cdev.readBytes(devAddr, MPU6050_RA_GYRO_XOUT_H, 2, buffer); |
Heidl | 0:d1960beb98fe | 2045 | return (((int16_t)buffer[0]) << 8) | buffer[1]; |
Heidl | 0:d1960beb98fe | 2046 | } |
Heidl | 0:d1960beb98fe | 2047 | /** Get Y-axis gyroscope reading. |
Heidl | 0:d1960beb98fe | 2048 | * @return Y-axis rotation measurement in 16-bit 2's complement format |
Heidl | 0:d1960beb98fe | 2049 | * @see getMotion6() |
Heidl | 0:d1960beb98fe | 2050 | * @see MPU6050_RA_GYRO_YOUT_H |
Heidl | 0:d1960beb98fe | 2051 | */ |
Heidl | 0:d1960beb98fe | 2052 | int16_t MPU6050::getRotationY() |
Heidl | 0:d1960beb98fe | 2053 | { |
Heidl | 0:d1960beb98fe | 2054 | i2Cdev.readBytes(devAddr, MPU6050_RA_GYRO_YOUT_H, 2, buffer); |
Heidl | 0:d1960beb98fe | 2055 | return (((int16_t)buffer[0]) << 8) | buffer[1]; |
Heidl | 0:d1960beb98fe | 2056 | } |
Heidl | 0:d1960beb98fe | 2057 | /** Get Z-axis gyroscope reading. |
Heidl | 0:d1960beb98fe | 2058 | * @return Z-axis rotation measurement in 16-bit 2's complement format |
Heidl | 0:d1960beb98fe | 2059 | * @see getMotion6() |
Heidl | 0:d1960beb98fe | 2060 | * @see MPU6050_RA_GYRO_ZOUT_H |
Heidl | 0:d1960beb98fe | 2061 | */ |
Heidl | 0:d1960beb98fe | 2062 | int16_t MPU6050::getRotationZ() |
Heidl | 0:d1960beb98fe | 2063 | { |
Heidl | 0:d1960beb98fe | 2064 | i2Cdev.readBytes(devAddr, MPU6050_RA_GYRO_ZOUT_H, 2, buffer); |
Heidl | 0:d1960beb98fe | 2065 | return (((int16_t)buffer[0]) << 8) | buffer[1]; |
Heidl | 0:d1960beb98fe | 2066 | } |
Heidl | 0:d1960beb98fe | 2067 | |
Heidl | 0:d1960beb98fe | 2068 | // EXT_SENS_DATA_* registers |
Heidl | 0:d1960beb98fe | 2069 | |
Heidl | 0:d1960beb98fe | 2070 | /** Read single byte from external sensor data register. |
Heidl | 0:d1960beb98fe | 2071 | * These registers store data read from external sensors by the Slave 0, 1, 2, |
Heidl | 0:d1960beb98fe | 2072 | * and 3 on the auxiliary I2C interface. Data read by Slave 4 is stored in |
Heidl | 0:d1960beb98fe | 2073 | * I2C_SLV4_DI (Register 53). |
Heidl | 0:d1960beb98fe | 2074 | * |
Heidl | 0:d1960beb98fe | 2075 | * External sensor data is written to these registers at the Sample Rate as |
Heidl | 0:d1960beb98fe | 2076 | * defined in Register 25. This access rate can be reduced by using the Slave |
Heidl | 0:d1960beb98fe | 2077 | * Delay Enable registers (Register 103). |
Heidl | 0:d1960beb98fe | 2078 | * |
Heidl | 0:d1960beb98fe | 2079 | * External sensor data registers, along with the gyroscope measurement |
Heidl | 0:d1960beb98fe | 2080 | * registers, accelerometer measurement registers, and temperature measurement |
Heidl | 0:d1960beb98fe | 2081 | * registers, are composed of two sets of registers: an internal register set |
Heidl | 0:d1960beb98fe | 2082 | * and a user-facing read register set. |
Heidl | 0:d1960beb98fe | 2083 | * |
Heidl | 0:d1960beb98fe | 2084 | * The data within the external sensors' internal register set is always updated |
Heidl | 0:d1960beb98fe | 2085 | * at the Sample Rate (or the reduced access rate) whenever the serial interface |
Heidl | 0:d1960beb98fe | 2086 | * is idle. This guarantees that a burst read of sensor registers will read |
Heidl | 0:d1960beb98fe | 2087 | * measurements from the same sampling instant. Note that if burst reads are not |
Heidl | 0:d1960beb98fe | 2088 | * used, the user is responsible for ensuring a set of single byte reads |
Heidl | 0:d1960beb98fe | 2089 | * correspond to a single sampling instant by checking the Data Ready interrupt. |
Heidl | 0:d1960beb98fe | 2090 | * |
Heidl | 0:d1960beb98fe | 2091 | * Data is placed in these external sensor data registers according to |
Heidl | 0:d1960beb98fe | 2092 | * I2C_SLV0_CTRL, I2C_SLV1_CTRL, I2C_SLV2_CTRL, and I2C_SLV3_CTRL (Registers 39, |
Heidl | 0:d1960beb98fe | 2093 | * 42, 45, and 48). When more than zero bytes are read (I2C_SLVx_LEN > 0) from |
Heidl | 0:d1960beb98fe | 2094 | * an enabled slave (I2C_SLVx_EN = 1), the slave is read at the Sample Rate (as |
Heidl | 0:d1960beb98fe | 2095 | * defined in Register 25) or delayed rate (if specified in Register 52 and |
Heidl | 0:d1960beb98fe | 2096 | * 103). During each Sample cycle, slave reads are performed in order of Slave |
Heidl | 0:d1960beb98fe | 2097 | * number. If all slaves are enabled with more than zero bytes to be read, the |
Heidl | 0:d1960beb98fe | 2098 | * order will be Slave 0, followed by Slave 1, Slave 2, and Slave 3. |
Heidl | 0:d1960beb98fe | 2099 | * |
Heidl | 0:d1960beb98fe | 2100 | * Each enabled slave will have EXT_SENS_DATA registers associated with it by |
Heidl | 0:d1960beb98fe | 2101 | * number of bytes read (I2C_SLVx_LEN) in order of slave number, starting from |
Heidl | 0:d1960beb98fe | 2102 | * EXT_SENS_DATA_00. Note that this means enabling or disabling a slave may |
Heidl | 0:d1960beb98fe | 2103 | * change the higher numbered slaves' associated registers. Furthermore, if |
Heidl | 0:d1960beb98fe | 2104 | * fewer total bytes are being read from the external sensors as a result of |
Heidl | 0:d1960beb98fe | 2105 | * such a change, then the data remaining in the registers which no longer have |
Heidl | 0:d1960beb98fe | 2106 | * an associated slave device (i.e. high numbered registers) will remain in |
Heidl | 0:d1960beb98fe | 2107 | * these previously allocated registers unless reset. |
Heidl | 0:d1960beb98fe | 2108 | * |
Heidl | 0:d1960beb98fe | 2109 | * If the sum of the read lengths of all SLVx transactions exceed the number of |
Heidl | 0:d1960beb98fe | 2110 | * available EXT_SENS_DATA registers, the excess bytes will be dropped. There |
Heidl | 0:d1960beb98fe | 2111 | * are 24 EXT_SENS_DATA registers and hence the total read lengths between all |
Heidl | 0:d1960beb98fe | 2112 | * the slaves cannot be greater than 24 or some bytes will be lost. |
Heidl | 0:d1960beb98fe | 2113 | * |
Heidl | 0:d1960beb98fe | 2114 | * Note: Slave 4's behavior is distinct from that of Slaves 0-3. For further |
Heidl | 0:d1960beb98fe | 2115 | * information regarding the characteristics of Slave 4, please refer to |
Heidl | 0:d1960beb98fe | 2116 | * Registers 49 to 53. |
Heidl | 0:d1960beb98fe | 2117 | * |
Heidl | 0:d1960beb98fe | 2118 | * EXAMPLE: |
Heidl | 0:d1960beb98fe | 2119 | * Suppose that Slave 0 is enabled with 4 bytes to be read (I2C_SLV0_EN = 1 and |
Heidl | 0:d1960beb98fe | 2120 | * I2C_SLV0_LEN = 4) while Slave 1 is enabled with 2 bytes to be read so that |
Heidl | 0:d1960beb98fe | 2121 | * I2C_SLV1_EN = 1 and I2C_SLV1_LEN = 2. In such a situation, EXT_SENS_DATA _00 |
Heidl | 0:d1960beb98fe | 2122 | * through _03 will be associated with Slave 0, while EXT_SENS_DATA _04 and 05 |
Heidl | 0:d1960beb98fe | 2123 | * will be associated with Slave 1. If Slave 2 is enabled as well, registers |
Heidl | 0:d1960beb98fe | 2124 | * starting from EXT_SENS_DATA_06 will be allocated to Slave 2. |
Heidl | 0:d1960beb98fe | 2125 | * |
Heidl | 0:d1960beb98fe | 2126 | * If Slave 2 is disabled while Slave 3 is enabled in this same situation, then |
Heidl | 0:d1960beb98fe | 2127 | * registers starting from EXT_SENS_DATA_06 will be allocated to Slave 3 |
Heidl | 0:d1960beb98fe | 2128 | * instead. |
Heidl | 0:d1960beb98fe | 2129 | * |
Heidl | 0:d1960beb98fe | 2130 | * REGISTER ALLOCATION FOR DYNAMIC DISABLE VS. NORMAL DISABLE: |
Heidl | 0:d1960beb98fe | 2131 | * If a slave is disabled at any time, the space initially allocated to the |
Heidl | 0:d1960beb98fe | 2132 | * slave in the EXT_SENS_DATA register, will remain associated with that slave. |
Heidl | 0:d1960beb98fe | 2133 | * This is to avoid dynamic adjustment of the register allocation. |
Heidl | 0:d1960beb98fe | 2134 | * |
Heidl | 0:d1960beb98fe | 2135 | * The allocation of the EXT_SENS_DATA registers is recomputed only when (1) all |
Heidl | 0:d1960beb98fe | 2136 | * slaves are disabled, or (2) the I2C_MST_RST bit is set (Register 106). |
Heidl | 0:d1960beb98fe | 2137 | * |
Heidl | 0:d1960beb98fe | 2138 | * This above is also true if one of the slaves gets NACKed and stops |
Heidl | 0:d1960beb98fe | 2139 | * functioning. |
Heidl | 0:d1960beb98fe | 2140 | * |
Heidl | 0:d1960beb98fe | 2141 | * @param position Starting position (0-23) |
Heidl | 0:d1960beb98fe | 2142 | * @return Byte read from register |
Heidl | 0:d1960beb98fe | 2143 | */ |
Heidl | 0:d1960beb98fe | 2144 | uint8_t MPU6050::getExternalSensorByte(int position) |
Heidl | 0:d1960beb98fe | 2145 | { |
Heidl | 0:d1960beb98fe | 2146 | i2Cdev.readByte(devAddr, MPU6050_RA_EXT_SENS_DATA_00 + position, buffer); |
Heidl | 0:d1960beb98fe | 2147 | return buffer[0]; |
Heidl | 0:d1960beb98fe | 2148 | } |
Heidl | 0:d1960beb98fe | 2149 | /** Read word (2 bytes) from external sensor data registers. |
Heidl | 0:d1960beb98fe | 2150 | * @param position Starting position (0-21) |
Heidl | 0:d1960beb98fe | 2151 | * @return Word read from register |
Heidl | 0:d1960beb98fe | 2152 | * @see getExternalSensorByte() |
Heidl | 0:d1960beb98fe | 2153 | */ |
Heidl | 0:d1960beb98fe | 2154 | uint16_t MPU6050::getExternalSensorWord(int position) |
Heidl | 0:d1960beb98fe | 2155 | { |
Heidl | 0:d1960beb98fe | 2156 | i2Cdev.readBytes(devAddr, MPU6050_RA_EXT_SENS_DATA_00 + position, 2, buffer); |
Heidl | 0:d1960beb98fe | 2157 | return (((uint16_t)buffer[0]) << 8) | buffer[1]; |
Heidl | 0:d1960beb98fe | 2158 | } |
Heidl | 0:d1960beb98fe | 2159 | /** Read double word (4 bytes) from external sensor data registers. |
Heidl | 0:d1960beb98fe | 2160 | * @param position Starting position (0-20) |
Heidl | 0:d1960beb98fe | 2161 | * @return Double word read from registers |
Heidl | 0:d1960beb98fe | 2162 | * @see getExternalSensorByte() |
Heidl | 0:d1960beb98fe | 2163 | */ |
Heidl | 0:d1960beb98fe | 2164 | uint32_t MPU6050::getExternalSensorDWord(int position) |
Heidl | 0:d1960beb98fe | 2165 | { |
Heidl | 0:d1960beb98fe | 2166 | i2Cdev.readBytes(devAddr, MPU6050_RA_EXT_SENS_DATA_00 + position, 4, buffer); |
Heidl | 0:d1960beb98fe | 2167 | return (((uint32_t)buffer[0]) << 24) | (((uint32_t)buffer[1]) << 16) | (((uint16_t)buffer[2]) << 8) | buffer[3]; |
Heidl | 0:d1960beb98fe | 2168 | } |
Heidl | 0:d1960beb98fe | 2169 | |
Heidl | 0:d1960beb98fe | 2170 | // MOT_DETECT_STATUS register |
Heidl | 0:d1960beb98fe | 2171 | |
Heidl | 0:d1960beb98fe | 2172 | /** Get X-axis negative motion detection interrupt status. |
Heidl | 0:d1960beb98fe | 2173 | * @return Motion detection status |
Heidl | 0:d1960beb98fe | 2174 | * @see MPU6050_RA_MOT_DETECT_STATUS |
Heidl | 0:d1960beb98fe | 2175 | * @see MPU6050_MOTION_MOT_XNEG_BIT |
Heidl | 0:d1960beb98fe | 2176 | */ |
Heidl | 0:d1960beb98fe | 2177 | bool MPU6050::getXNegMotionDetected() |
Heidl | 0:d1960beb98fe | 2178 | { |
Heidl | 0:d1960beb98fe | 2179 | i2Cdev.readBit(devAddr, MPU6050_RA_MOT_DETECT_STATUS, MPU6050_MOTION_MOT_XNEG_BIT, buffer); |
Heidl | 0:d1960beb98fe | 2180 | return buffer[0]; |
Heidl | 0:d1960beb98fe | 2181 | } |
Heidl | 0:d1960beb98fe | 2182 | /** Get X-axis positive motion detection interrupt status. |
Heidl | 0:d1960beb98fe | 2183 | * @return Motion detection status |
Heidl | 0:d1960beb98fe | 2184 | * @see MPU6050_RA_MOT_DETECT_STATUS |
Heidl | 0:d1960beb98fe | 2185 | * @see MPU6050_MOTION_MOT_XPOS_BIT |
Heidl | 0:d1960beb98fe | 2186 | */ |
Heidl | 0:d1960beb98fe | 2187 | bool MPU6050::getXPosMotionDetected() |
Heidl | 0:d1960beb98fe | 2188 | { |
Heidl | 0:d1960beb98fe | 2189 | i2Cdev.readBit(devAddr, MPU6050_RA_MOT_DETECT_STATUS, MPU6050_MOTION_MOT_XPOS_BIT, buffer); |
Heidl | 0:d1960beb98fe | 2190 | return buffer[0]; |
Heidl | 0:d1960beb98fe | 2191 | } |
Heidl | 0:d1960beb98fe | 2192 | /** Get Y-axis negative motion detection interrupt status. |
Heidl | 0:d1960beb98fe | 2193 | * @return Motion detection status |
Heidl | 0:d1960beb98fe | 2194 | * @see MPU6050_RA_MOT_DETECT_STATUS |
Heidl | 0:d1960beb98fe | 2195 | * @see MPU6050_MOTION_MOT_YNEG_BIT |
Heidl | 0:d1960beb98fe | 2196 | */ |
Heidl | 0:d1960beb98fe | 2197 | bool MPU6050::getYNegMotionDetected() |
Heidl | 0:d1960beb98fe | 2198 | { |
Heidl | 0:d1960beb98fe | 2199 | i2Cdev.readBit(devAddr, MPU6050_RA_MOT_DETECT_STATUS, MPU6050_MOTION_MOT_YNEG_BIT, buffer); |
Heidl | 0:d1960beb98fe | 2200 | return buffer[0]; |
Heidl | 0:d1960beb98fe | 2201 | } |
Heidl | 0:d1960beb98fe | 2202 | /** Get Y-axis positive motion detection interrupt status. |
Heidl | 0:d1960beb98fe | 2203 | * @return Motion detection status |
Heidl | 0:d1960beb98fe | 2204 | * @see MPU6050_RA_MOT_DETECT_STATUS |
Heidl | 0:d1960beb98fe | 2205 | * @see MPU6050_MOTION_MOT_YPOS_BIT |
Heidl | 0:d1960beb98fe | 2206 | */ |
Heidl | 0:d1960beb98fe | 2207 | bool MPU6050::getYPosMotionDetected() |
Heidl | 0:d1960beb98fe | 2208 | { |
Heidl | 0:d1960beb98fe | 2209 | i2Cdev.readBit(devAddr, MPU6050_RA_MOT_DETECT_STATUS, MPU6050_MOTION_MOT_YPOS_BIT, buffer); |
Heidl | 0:d1960beb98fe | 2210 | return buffer[0]; |
Heidl | 0:d1960beb98fe | 2211 | } |
Heidl | 0:d1960beb98fe | 2212 | /** Get Z-axis negative motion detection interrupt status. |
Heidl | 0:d1960beb98fe | 2213 | * @return Motion detection status |
Heidl | 0:d1960beb98fe | 2214 | * @see MPU6050_RA_MOT_DETECT_STATUS |
Heidl | 0:d1960beb98fe | 2215 | * @see MPU6050_MOTION_MOT_ZNEG_BIT |
Heidl | 0:d1960beb98fe | 2216 | */ |
Heidl | 0:d1960beb98fe | 2217 | bool MPU6050::getZNegMotionDetected() |
Heidl | 0:d1960beb98fe | 2218 | { |
Heidl | 0:d1960beb98fe | 2219 | i2Cdev.readBit(devAddr, MPU6050_RA_MOT_DETECT_STATUS, MPU6050_MOTION_MOT_ZNEG_BIT, buffer); |
Heidl | 0:d1960beb98fe | 2220 | return buffer[0]; |
Heidl | 0:d1960beb98fe | 2221 | } |
Heidl | 0:d1960beb98fe | 2222 | /** Get Z-axis positive motion detection interrupt status. |
Heidl | 0:d1960beb98fe | 2223 | * @return Motion detection status |
Heidl | 0:d1960beb98fe | 2224 | * @see MPU6050_RA_MOT_DETECT_STATUS |
Heidl | 0:d1960beb98fe | 2225 | * @see MPU6050_MOTION_MOT_ZPOS_BIT |
Heidl | 0:d1960beb98fe | 2226 | */ |
Heidl | 0:d1960beb98fe | 2227 | bool MPU6050::getZPosMotionDetected() |
Heidl | 0:d1960beb98fe | 2228 | { |
Heidl | 0:d1960beb98fe | 2229 | i2Cdev.readBit(devAddr, MPU6050_RA_MOT_DETECT_STATUS, MPU6050_MOTION_MOT_ZPOS_BIT, buffer); |
Heidl | 0:d1960beb98fe | 2230 | return buffer[0]; |
Heidl | 0:d1960beb98fe | 2231 | } |
Heidl | 0:d1960beb98fe | 2232 | /** Get zero motion detection interrupt status. |
Heidl | 0:d1960beb98fe | 2233 | * @return Motion detection status |
Heidl | 0:d1960beb98fe | 2234 | * @see MPU6050_RA_MOT_DETECT_STATUS |
Heidl | 0:d1960beb98fe | 2235 | * @see MPU6050_MOTION_MOT_ZRMOT_BIT |
Heidl | 0:d1960beb98fe | 2236 | */ |
Heidl | 0:d1960beb98fe | 2237 | bool MPU6050::getZeroMotionDetected() |
Heidl | 0:d1960beb98fe | 2238 | { |
Heidl | 0:d1960beb98fe | 2239 | i2Cdev.readBit(devAddr, MPU6050_RA_MOT_DETECT_STATUS, MPU6050_MOTION_MOT_ZRMOT_BIT, buffer); |
Heidl | 0:d1960beb98fe | 2240 | return buffer[0]; |
Heidl | 0:d1960beb98fe | 2241 | } |
Heidl | 0:d1960beb98fe | 2242 | |
Heidl | 0:d1960beb98fe | 2243 | // I2C_SLV*_DO register |
Heidl | 0:d1960beb98fe | 2244 | |
Heidl | 0:d1960beb98fe | 2245 | /** Write byte to Data Output container for specified slave. |
Heidl | 0:d1960beb98fe | 2246 | * This register holds the output data written into Slave when Slave is set to |
Heidl | 0:d1960beb98fe | 2247 | * write mode. For further information regarding Slave control, please |
Heidl | 0:d1960beb98fe | 2248 | * refer to Registers 37 to 39 and immediately following. |
Heidl | 0:d1960beb98fe | 2249 | * @param num Slave number (0-3) |
Heidl | 0:d1960beb98fe | 2250 | * @param data Byte to write |
Heidl | 0:d1960beb98fe | 2251 | * @see MPU6050_RA_I2C_SLV0_DO |
Heidl | 0:d1960beb98fe | 2252 | */ |
Heidl | 0:d1960beb98fe | 2253 | void MPU6050::setSlaveOutputByte(uint8_t num, uint8_t data) |
Heidl | 0:d1960beb98fe | 2254 | { |
Heidl | 0:d1960beb98fe | 2255 | if (num > 3) return; |
Heidl | 0:d1960beb98fe | 2256 | i2Cdev.writeByte(devAddr, MPU6050_RA_I2C_SLV0_DO + num, data); |
Heidl | 0:d1960beb98fe | 2257 | } |
Heidl | 0:d1960beb98fe | 2258 | |
Heidl | 0:d1960beb98fe | 2259 | // I2C_MST_DELAY_CTRL register |
Heidl | 0:d1960beb98fe | 2260 | |
Heidl | 0:d1960beb98fe | 2261 | /** Get external data shadow delay enabled status. |
Heidl | 0:d1960beb98fe | 2262 | * This register is used to specify the timing of external sensor data |
Heidl | 0:d1960beb98fe | 2263 | * shadowing. When DELAY_ES_SHADOW is set to 1, shadowing of external |
Heidl | 0:d1960beb98fe | 2264 | * sensor data is delayed until all data has been received. |
Heidl | 0:d1960beb98fe | 2265 | * @return Current external data shadow delay enabled status. |
Heidl | 0:d1960beb98fe | 2266 | * @see MPU6050_RA_I2C_MST_DELAY_CTRL |
Heidl | 0:d1960beb98fe | 2267 | * @see MPU6050_DELAYCTRL_DELAY_ES_SHADOW_BIT |
Heidl | 0:d1960beb98fe | 2268 | */ |
Heidl | 0:d1960beb98fe | 2269 | bool MPU6050::getExternalShadowDelayEnabled() |
Heidl | 0:d1960beb98fe | 2270 | { |
Heidl | 0:d1960beb98fe | 2271 | i2Cdev.readBit(devAddr, MPU6050_RA_I2C_MST_DELAY_CTRL, MPU6050_DELAYCTRL_DELAY_ES_SHADOW_BIT, buffer); |
Heidl | 0:d1960beb98fe | 2272 | return buffer[0]; |
Heidl | 0:d1960beb98fe | 2273 | } |
Heidl | 0:d1960beb98fe | 2274 | /** Set external data shadow delay enabled status. |
Heidl | 0:d1960beb98fe | 2275 | * @param enabled New external data shadow delay enabled status. |
Heidl | 0:d1960beb98fe | 2276 | * @see getExternalShadowDelayEnabled() |
Heidl | 0:d1960beb98fe | 2277 | * @see MPU6050_RA_I2C_MST_DELAY_CTRL |
Heidl | 0:d1960beb98fe | 2278 | * @see MPU6050_DELAYCTRL_DELAY_ES_SHADOW_BIT |
Heidl | 0:d1960beb98fe | 2279 | */ |
Heidl | 0:d1960beb98fe | 2280 | void MPU6050::setExternalShadowDelayEnabled(bool enabled) |
Heidl | 0:d1960beb98fe | 2281 | { |
Heidl | 0:d1960beb98fe | 2282 | i2Cdev.writeBit(devAddr, MPU6050_RA_I2C_MST_DELAY_CTRL, MPU6050_DELAYCTRL_DELAY_ES_SHADOW_BIT, enabled); |
Heidl | 0:d1960beb98fe | 2283 | } |
Heidl | 0:d1960beb98fe | 2284 | /** Get slave delay enabled status. |
Heidl | 0:d1960beb98fe | 2285 | * When a particular slave delay is enabled, the rate of access for the that |
Heidl | 0:d1960beb98fe | 2286 | * slave device is reduced. When a slave's access rate is decreased relative to |
Heidl | 0:d1960beb98fe | 2287 | * the Sample Rate, the slave is accessed every: |
Heidl | 0:d1960beb98fe | 2288 | * |
Heidl | 0:d1960beb98fe | 2289 | * 1 / (1 + I2C_MST_DLY) Samples |
Heidl | 0:d1960beb98fe | 2290 | * |
Heidl | 0:d1960beb98fe | 2291 | * This base Sample Rate in turn is determined by SMPLRT_DIV (register * 25) |
Heidl | 0:d1960beb98fe | 2292 | * and DLPF_CFG (register 26). |
Heidl | 0:d1960beb98fe | 2293 | * |
Heidl | 0:d1960beb98fe | 2294 | * For further information regarding I2C_MST_DLY, please refer to register 52. |
Heidl | 0:d1960beb98fe | 2295 | * For further information regarding the Sample Rate, please refer to register 25. |
Heidl | 0:d1960beb98fe | 2296 | * |
Heidl | 0:d1960beb98fe | 2297 | * @param num Slave number (0-4) |
Heidl | 0:d1960beb98fe | 2298 | * @return Current slave delay enabled status. |
Heidl | 0:d1960beb98fe | 2299 | * @see MPU6050_RA_I2C_MST_DELAY_CTRL |
Heidl | 0:d1960beb98fe | 2300 | * @see MPU6050_DELAYCTRL_I2C_SLV0_DLY_EN_BIT |
Heidl | 0:d1960beb98fe | 2301 | */ |
Heidl | 0:d1960beb98fe | 2302 | bool MPU6050::getSlaveDelayEnabled(uint8_t num) |
Heidl | 0:d1960beb98fe | 2303 | { |
Heidl | 0:d1960beb98fe | 2304 | // MPU6050_DELAYCTRL_I2C_SLV4_DLY_EN_BIT is 4, SLV3 is 3, etc. |
Heidl | 0:d1960beb98fe | 2305 | if (num > 4) return 0; |
Heidl | 0:d1960beb98fe | 2306 | i2Cdev.readBit(devAddr, MPU6050_RA_I2C_MST_DELAY_CTRL, num, buffer); |
Heidl | 0:d1960beb98fe | 2307 | return buffer[0]; |
Heidl | 0:d1960beb98fe | 2308 | } |
Heidl | 0:d1960beb98fe | 2309 | /** Set slave delay enabled status. |
Heidl | 0:d1960beb98fe | 2310 | * @param num Slave number (0-4) |
Heidl | 0:d1960beb98fe | 2311 | * @param enabled New slave delay enabled status. |
Heidl | 0:d1960beb98fe | 2312 | * @see MPU6050_RA_I2C_MST_DELAY_CTRL |
Heidl | 0:d1960beb98fe | 2313 | * @see MPU6050_DELAYCTRL_I2C_SLV0_DLY_EN_BIT |
Heidl | 0:d1960beb98fe | 2314 | */ |
Heidl | 0:d1960beb98fe | 2315 | void MPU6050::setSlaveDelayEnabled(uint8_t num, bool enabled) |
Heidl | 0:d1960beb98fe | 2316 | { |
Heidl | 0:d1960beb98fe | 2317 | i2Cdev.writeBit(devAddr, MPU6050_RA_I2C_MST_DELAY_CTRL, num, enabled); |
Heidl | 0:d1960beb98fe | 2318 | } |
Heidl | 0:d1960beb98fe | 2319 | |
Heidl | 0:d1960beb98fe | 2320 | // SIGNAL_PATH_RESET register |
Heidl | 0:d1960beb98fe | 2321 | |
Heidl | 0:d1960beb98fe | 2322 | /** Reset gyroscope signal path. |
Heidl | 0:d1960beb98fe | 2323 | * The reset will revert the signal path analog to digital converters and |
Heidl | 0:d1960beb98fe | 2324 | * filters to their power up configurations. |
Heidl | 0:d1960beb98fe | 2325 | * @see MPU6050_RA_SIGNAL_PATH_RESET |
Heidl | 0:d1960beb98fe | 2326 | * @see MPU6050_PATHRESET_GYRO_RESET_BIT |
Heidl | 0:d1960beb98fe | 2327 | */ |
Heidl | 0:d1960beb98fe | 2328 | void MPU6050::resetGyroscopePath() |
Heidl | 0:d1960beb98fe | 2329 | { |
Heidl | 0:d1960beb98fe | 2330 | i2Cdev.writeBit(devAddr, MPU6050_RA_SIGNAL_PATH_RESET, MPU6050_PATHRESET_GYRO_RESET_BIT, true); |
Heidl | 0:d1960beb98fe | 2331 | } |
Heidl | 0:d1960beb98fe | 2332 | /** Reset accelerometer signal path. |
Heidl | 0:d1960beb98fe | 2333 | * The reset will revert the signal path analog to digital converters and |
Heidl | 0:d1960beb98fe | 2334 | * filters to their power up configurations. |
Heidl | 0:d1960beb98fe | 2335 | * @see MPU6050_RA_SIGNAL_PATH_RESET |
Heidl | 0:d1960beb98fe | 2336 | * @see MPU6050_PATHRESET_ACCEL_RESET_BIT |
Heidl | 0:d1960beb98fe | 2337 | */ |
Heidl | 0:d1960beb98fe | 2338 | void MPU6050::resetAccelerometerPath() |
Heidl | 0:d1960beb98fe | 2339 | { |
Heidl | 0:d1960beb98fe | 2340 | i2Cdev.writeBit(devAddr, MPU6050_RA_SIGNAL_PATH_RESET, MPU6050_PATHRESET_ACCEL_RESET_BIT, true); |
Heidl | 0:d1960beb98fe | 2341 | } |
Heidl | 0:d1960beb98fe | 2342 | /** Reset temperature sensor signal path. |
Heidl | 0:d1960beb98fe | 2343 | * The reset will revert the signal path analog to digital converters and |
Heidl | 0:d1960beb98fe | 2344 | * filters to their power up configurations. |
Heidl | 0:d1960beb98fe | 2345 | * @see MPU6050_RA_SIGNAL_PATH_RESET |
Heidl | 0:d1960beb98fe | 2346 | * @see MPU6050_PATHRESET_TEMP_RESET_BIT |
Heidl | 0:d1960beb98fe | 2347 | */ |
Heidl | 0:d1960beb98fe | 2348 | void MPU6050::resetTemperaturePath() |
Heidl | 0:d1960beb98fe | 2349 | { |
Heidl | 0:d1960beb98fe | 2350 | i2Cdev.writeBit(devAddr, MPU6050_RA_SIGNAL_PATH_RESET, MPU6050_PATHRESET_TEMP_RESET_BIT, true); |
Heidl | 0:d1960beb98fe | 2351 | } |
Heidl | 0:d1960beb98fe | 2352 | |
Heidl | 0:d1960beb98fe | 2353 | // MOT_DETECT_CTRL register |
Heidl | 0:d1960beb98fe | 2354 | |
Heidl | 0:d1960beb98fe | 2355 | /** Get accelerometer power-on delay. |
Heidl | 0:d1960beb98fe | 2356 | * The accelerometer data path provides samples to the sensor registers, Motion |
Heidl | 0:d1960beb98fe | 2357 | * detection, Zero Motion detection, and Free Fall detection modules. The |
Heidl | 0:d1960beb98fe | 2358 | * signal path contains filters which must be flushed on wake-up with new |
Heidl | 0:d1960beb98fe | 2359 | * samples before the detection modules begin operations. The default wake-up |
Heidl | 0:d1960beb98fe | 2360 | * delay, of 4ms can be lengthened by up to 3ms. This additional delay is |
Heidl | 0:d1960beb98fe | 2361 | * specified in ACCEL_ON_DELAY in units of 1 LSB = 1 ms. The user may select |
Heidl | 0:d1960beb98fe | 2362 | * any value above zero unless instructed otherwise by InvenSense. Please refer |
Heidl | 0:d1960beb98fe | 2363 | * to Section 8 of the MPU-6000/MPU-6050 Product Specification document for |
Heidl | 0:d1960beb98fe | 2364 | * further information regarding the detection modules. |
Heidl | 0:d1960beb98fe | 2365 | * @return Current accelerometer power-on delay |
Heidl | 0:d1960beb98fe | 2366 | * @see MPU6050_RA_MOT_DETECT_CTRL |
Heidl | 0:d1960beb98fe | 2367 | * @see MPU6050_DETECT_ACCEL_ON_DELAY_BIT |
Heidl | 0:d1960beb98fe | 2368 | */ |
Heidl | 0:d1960beb98fe | 2369 | uint8_t MPU6050::getAccelerometerPowerOnDelay() |
Heidl | 0:d1960beb98fe | 2370 | { |
Heidl | 0:d1960beb98fe | 2371 | i2Cdev.readBits(devAddr, MPU6050_RA_MOT_DETECT_CTRL, MPU6050_DETECT_ACCEL_ON_DELAY_BIT, MPU6050_DETECT_ACCEL_ON_DELAY_LENGTH, buffer); |
Heidl | 0:d1960beb98fe | 2372 | return buffer[0]; |
Heidl | 0:d1960beb98fe | 2373 | } |
Heidl | 0:d1960beb98fe | 2374 | /** Set accelerometer power-on delay. |
Heidl | 0:d1960beb98fe | 2375 | * @param delay New accelerometer power-on delay (0-3) |
Heidl | 0:d1960beb98fe | 2376 | * @see getAccelerometerPowerOnDelay() |
Heidl | 0:d1960beb98fe | 2377 | * @see MPU6050_RA_MOT_DETECT_CTRL |
Heidl | 0:d1960beb98fe | 2378 | * @see MPU6050_DETECT_ACCEL_ON_DELAY_BIT |
Heidl | 0:d1960beb98fe | 2379 | */ |
Heidl | 0:d1960beb98fe | 2380 | void MPU6050::setAccelerometerPowerOnDelay(uint8_t delay) |
Heidl | 0:d1960beb98fe | 2381 | { |
Heidl | 0:d1960beb98fe | 2382 | i2Cdev.writeBits(devAddr, MPU6050_RA_MOT_DETECT_CTRL, MPU6050_DETECT_ACCEL_ON_DELAY_BIT, MPU6050_DETECT_ACCEL_ON_DELAY_LENGTH, delay); |
Heidl | 0:d1960beb98fe | 2383 | } |
Heidl | 0:d1960beb98fe | 2384 | /** Get Free Fall detection counter decrement configuration. |
Heidl | 0:d1960beb98fe | 2385 | * Detection is registered by the Free Fall detection module after accelerometer |
Heidl | 0:d1960beb98fe | 2386 | * measurements meet their respective threshold conditions over a specified |
Heidl | 0:d1960beb98fe | 2387 | * number of samples. When the threshold conditions are met, the corresponding |
Heidl | 0:d1960beb98fe | 2388 | * detection counter increments by 1. The user may control the rate at which the |
Heidl | 0:d1960beb98fe | 2389 | * detection counter decrements when the threshold condition is not met by |
Heidl | 0:d1960beb98fe | 2390 | * configuring FF_COUNT. The decrement rate can be set according to the |
Heidl | 0:d1960beb98fe | 2391 | * following table: |
Heidl | 0:d1960beb98fe | 2392 | * |
Heidl | 0:d1960beb98fe | 2393 | * <pre> |
Heidl | 0:d1960beb98fe | 2394 | * FF_COUNT | Counter Decrement |
Heidl | 0:d1960beb98fe | 2395 | * ---------+------------------ |
Heidl | 0:d1960beb98fe | 2396 | * 0 | Reset |
Heidl | 0:d1960beb98fe | 2397 | * 1 | 1 |
Heidl | 0:d1960beb98fe | 2398 | * 2 | 2 |
Heidl | 0:d1960beb98fe | 2399 | * 3 | 4 |
Heidl | 0:d1960beb98fe | 2400 | * </pre> |
Heidl | 0:d1960beb98fe | 2401 | * |
Heidl | 0:d1960beb98fe | 2402 | * When FF_COUNT is configured to 0 (reset), any non-qualifying sample will |
Heidl | 0:d1960beb98fe | 2403 | * reset the counter to 0. For further information on Free Fall detection, |
Heidl | 0:d1960beb98fe | 2404 | * please refer to Registers 29 to 32. |
Heidl | 0:d1960beb98fe | 2405 | * |
Heidl | 0:d1960beb98fe | 2406 | * @return Current decrement configuration |
Heidl | 0:d1960beb98fe | 2407 | * @see MPU6050_RA_MOT_DETECT_CTRL |
Heidl | 0:d1960beb98fe | 2408 | * @see MPU6050_DETECT_FF_COUNT_BIT |
Heidl | 0:d1960beb98fe | 2409 | */ |
Heidl | 0:d1960beb98fe | 2410 | uint8_t MPU6050::getFreefallDetectionCounterDecrement() |
Heidl | 0:d1960beb98fe | 2411 | { |
Heidl | 0:d1960beb98fe | 2412 | i2Cdev.readBits(devAddr, MPU6050_RA_MOT_DETECT_CTRL, MPU6050_DETECT_FF_COUNT_BIT, MPU6050_DETECT_FF_COUNT_LENGTH, buffer); |
Heidl | 0:d1960beb98fe | 2413 | return buffer[0]; |
Heidl | 0:d1960beb98fe | 2414 | } |
Heidl | 0:d1960beb98fe | 2415 | /** Set Free Fall detection counter decrement configuration. |
Heidl | 0:d1960beb98fe | 2416 | * @param decrement New decrement configuration value |
Heidl | 0:d1960beb98fe | 2417 | * @see getFreefallDetectionCounterDecrement() |
Heidl | 0:d1960beb98fe | 2418 | * @see MPU6050_RA_MOT_DETECT_CTRL |
Heidl | 0:d1960beb98fe | 2419 | * @see MPU6050_DETECT_FF_COUNT_BIT |
Heidl | 0:d1960beb98fe | 2420 | */ |
Heidl | 0:d1960beb98fe | 2421 | void MPU6050::setFreefallDetectionCounterDecrement(uint8_t decrement) |
Heidl | 0:d1960beb98fe | 2422 | { |
Heidl | 0:d1960beb98fe | 2423 | i2Cdev.writeBits(devAddr, MPU6050_RA_MOT_DETECT_CTRL, MPU6050_DETECT_FF_COUNT_BIT, MPU6050_DETECT_FF_COUNT_LENGTH, decrement); |
Heidl | 0:d1960beb98fe | 2424 | } |
Heidl | 0:d1960beb98fe | 2425 | /** Get Motion detection counter decrement configuration. |
Heidl | 0:d1960beb98fe | 2426 | * Detection is registered by the Motion detection module after accelerometer |
Heidl | 0:d1960beb98fe | 2427 | * measurements meet their respective threshold conditions over a specified |
Heidl | 0:d1960beb98fe | 2428 | * number of samples. When the threshold conditions are met, the corresponding |
Heidl | 0:d1960beb98fe | 2429 | * detection counter increments by 1. The user may control the rate at which the |
Heidl | 0:d1960beb98fe | 2430 | * detection counter decrements when the threshold condition is not met by |
Heidl | 0:d1960beb98fe | 2431 | * configuring MOT_COUNT. The decrement rate can be set according to the |
Heidl | 0:d1960beb98fe | 2432 | * following table: |
Heidl | 0:d1960beb98fe | 2433 | * |
Heidl | 0:d1960beb98fe | 2434 | * <pre> |
Heidl | 0:d1960beb98fe | 2435 | * MOT_COUNT | Counter Decrement |
Heidl | 0:d1960beb98fe | 2436 | * ----------+------------------ |
Heidl | 0:d1960beb98fe | 2437 | * 0 | Reset |
Heidl | 0:d1960beb98fe | 2438 | * 1 | 1 |
Heidl | 0:d1960beb98fe | 2439 | * 2 | 2 |
Heidl | 0:d1960beb98fe | 2440 | * 3 | 4 |
Heidl | 0:d1960beb98fe | 2441 | * </pre> |
Heidl | 0:d1960beb98fe | 2442 | * |
Heidl | 0:d1960beb98fe | 2443 | * When MOT_COUNT is configured to 0 (reset), any non-qualifying sample will |
Heidl | 0:d1960beb98fe | 2444 | * reset the counter to 0. For further information on Motion detection, |
Heidl | 0:d1960beb98fe | 2445 | * please refer to Registers 29 to 32. |
Heidl | 0:d1960beb98fe | 2446 | * |
Heidl | 0:d1960beb98fe | 2447 | */ |
Heidl | 0:d1960beb98fe | 2448 | uint8_t MPU6050::getMotionDetectionCounterDecrement() |
Heidl | 0:d1960beb98fe | 2449 | { |
Heidl | 0:d1960beb98fe | 2450 | i2Cdev.readBits(devAddr, MPU6050_RA_MOT_DETECT_CTRL, MPU6050_DETECT_MOT_COUNT_BIT, MPU6050_DETECT_MOT_COUNT_LENGTH, buffer); |
Heidl | 0:d1960beb98fe | 2451 | return buffer[0]; |
Heidl | 0:d1960beb98fe | 2452 | } |
Heidl | 0:d1960beb98fe | 2453 | /** Set Motion detection counter decrement configuration. |
Heidl | 0:d1960beb98fe | 2454 | * @param decrement New decrement configuration value |
Heidl | 0:d1960beb98fe | 2455 | * @see getMotionDetectionCounterDecrement() |
Heidl | 0:d1960beb98fe | 2456 | * @see MPU6050_RA_MOT_DETECT_CTRL |
Heidl | 0:d1960beb98fe | 2457 | * @see MPU6050_DETECT_MOT_COUNT_BIT |
Heidl | 0:d1960beb98fe | 2458 | */ |
Heidl | 0:d1960beb98fe | 2459 | void MPU6050::setMotionDetectionCounterDecrement(uint8_t decrement) |
Heidl | 0:d1960beb98fe | 2460 | { |
Heidl | 0:d1960beb98fe | 2461 | i2Cdev.writeBits(devAddr, MPU6050_RA_MOT_DETECT_CTRL, MPU6050_DETECT_MOT_COUNT_BIT, MPU6050_DETECT_MOT_COUNT_LENGTH, decrement); |
Heidl | 0:d1960beb98fe | 2462 | } |
Heidl | 0:d1960beb98fe | 2463 | |
Heidl | 0:d1960beb98fe | 2464 | // USER_CTRL register |
Heidl | 0:d1960beb98fe | 2465 | |
Heidl | 0:d1960beb98fe | 2466 | /** Get FIFO enabled status. |
Heidl | 0:d1960beb98fe | 2467 | * When this bit is set to 0, the FIFO buffer is disabled. The FIFO buffer |
Heidl | 0:d1960beb98fe | 2468 | * cannot be written to or read from while disabled. The FIFO buffer's state |
Heidl | 0:d1960beb98fe | 2469 | * does not change unless the MPU-60X0 is power cycled. |
Heidl | 0:d1960beb98fe | 2470 | * @return Current FIFO enabled status |
Heidl | 0:d1960beb98fe | 2471 | * @see MPU6050_RA_USER_CTRL |
Heidl | 0:d1960beb98fe | 2472 | * @see MPU6050_USERCTRL_FIFO_EN_BIT |
Heidl | 0:d1960beb98fe | 2473 | */ |
Heidl | 0:d1960beb98fe | 2474 | bool MPU6050::getFIFOEnabled() |
Heidl | 0:d1960beb98fe | 2475 | { |
Heidl | 0:d1960beb98fe | 2476 | i2Cdev.readBit(devAddr, MPU6050_RA_USER_CTRL, MPU6050_USERCTRL_FIFO_EN_BIT, buffer); |
Heidl | 0:d1960beb98fe | 2477 | return buffer[0]; |
Heidl | 0:d1960beb98fe | 2478 | } |
Heidl | 0:d1960beb98fe | 2479 | /** Set FIFO enabled status. |
Heidl | 0:d1960beb98fe | 2480 | * @param enabled New FIFO enabled status |
Heidl | 0:d1960beb98fe | 2481 | * @see getFIFOEnabled() |
Heidl | 0:d1960beb98fe | 2482 | * @see MPU6050_RA_USER_CTRL |
Heidl | 0:d1960beb98fe | 2483 | * @see MPU6050_USERCTRL_FIFO_EN_BIT |
Heidl | 0:d1960beb98fe | 2484 | */ |
Heidl | 0:d1960beb98fe | 2485 | void MPU6050::setFIFOEnabled(bool enabled) |
Heidl | 0:d1960beb98fe | 2486 | { |
Heidl | 0:d1960beb98fe | 2487 | i2Cdev.writeBit(devAddr, MPU6050_RA_USER_CTRL, MPU6050_USERCTRL_FIFO_EN_BIT, enabled); |
Heidl | 0:d1960beb98fe | 2488 | } |
Heidl | 0:d1960beb98fe | 2489 | /** Get I2C Master Mode enabled status. |
Heidl | 0:d1960beb98fe | 2490 | * When this mode is enabled, the MPU-60X0 acts as the I2C Master to the |
Heidl | 0:d1960beb98fe | 2491 | * external sensor slave devices on the auxiliary I2C bus. When this bit is |
Heidl | 0:d1960beb98fe | 2492 | * cleared to 0, the auxiliary I2C bus lines (AUX_DA and AUX_CL) are logically |
Heidl | 0:d1960beb98fe | 2493 | * driven by the primary I2C bus (SDA and SCL). This is a precondition to |
Heidl | 0:d1960beb98fe | 2494 | * enabling Bypass Mode. For further information regarding Bypass Mode, please |
Heidl | 0:d1960beb98fe | 2495 | * refer to Register 55. |
Heidl | 0:d1960beb98fe | 2496 | * @return Current I2C Master Mode enabled status |
Heidl | 0:d1960beb98fe | 2497 | * @see MPU6050_RA_USER_CTRL |
Heidl | 0:d1960beb98fe | 2498 | * @see MPU6050_USERCTRL_I2C_MST_EN_BIT |
Heidl | 0:d1960beb98fe | 2499 | */ |
Heidl | 0:d1960beb98fe | 2500 | bool MPU6050::getI2CMasterModeEnabled() |
Heidl | 0:d1960beb98fe | 2501 | { |
Heidl | 0:d1960beb98fe | 2502 | i2Cdev.readBit(devAddr, MPU6050_RA_USER_CTRL, MPU6050_USERCTRL_I2C_MST_EN_BIT, buffer); |
Heidl | 0:d1960beb98fe | 2503 | return buffer[0]; |
Heidl | 0:d1960beb98fe | 2504 | } |
Heidl | 0:d1960beb98fe | 2505 | /** Set I2C Master Mode enabled status. |
Heidl | 0:d1960beb98fe | 2506 | * @param enabled New I2C Master Mode enabled status |
Heidl | 0:d1960beb98fe | 2507 | * @see getI2CMasterModeEnabled() |
Heidl | 0:d1960beb98fe | 2508 | * @see MPU6050_RA_USER_CTRL |
Heidl | 0:d1960beb98fe | 2509 | * @see MPU6050_USERCTRL_I2C_MST_EN_BIT |
Heidl | 0:d1960beb98fe | 2510 | */ |
Heidl | 0:d1960beb98fe | 2511 | void MPU6050::setI2CMasterModeEnabled(bool enabled) |
Heidl | 0:d1960beb98fe | 2512 | { |
Heidl | 0:d1960beb98fe | 2513 | i2Cdev.writeBit(devAddr, MPU6050_RA_USER_CTRL, MPU6050_USERCTRL_I2C_MST_EN_BIT, enabled); |
Heidl | 0:d1960beb98fe | 2514 | } |
Heidl | 0:d1960beb98fe | 2515 | /** Switch from I2C to SPI mode (MPU-6000 only) |
Heidl | 0:d1960beb98fe | 2516 | * If this is set, the primary SPI interface will be enabled in place of the |
Heidl | 0:d1960beb98fe | 2517 | * disabled primary I2C interface. |
Heidl | 0:d1960beb98fe | 2518 | */ |
Heidl | 0:d1960beb98fe | 2519 | void MPU6050::switchSPIEnabled(bool enabled) |
Heidl | 0:d1960beb98fe | 2520 | { |
Heidl | 0:d1960beb98fe | 2521 | i2Cdev.writeBit(devAddr, MPU6050_RA_USER_CTRL, MPU6050_USERCTRL_I2C_IF_DIS_BIT, enabled); |
Heidl | 0:d1960beb98fe | 2522 | } |
Heidl | 0:d1960beb98fe | 2523 | /** Reset the FIFO. |
Heidl | 0:d1960beb98fe | 2524 | * This bit resets the FIFO buffer when set to 1 while FIFO_EN equals 0. This |
Heidl | 0:d1960beb98fe | 2525 | * bit automatically clears to 0 after the reset has been triggered. |
Heidl | 0:d1960beb98fe | 2526 | * @see MPU6050_RA_USER_CTRL |
Heidl | 0:d1960beb98fe | 2527 | * @see MPU6050_USERCTRL_FIFO_RESET_BIT |
Heidl | 0:d1960beb98fe | 2528 | */ |
Heidl | 0:d1960beb98fe | 2529 | void MPU6050::resetFIFO() |
Heidl | 0:d1960beb98fe | 2530 | { |
Heidl | 0:d1960beb98fe | 2531 | i2Cdev.writeBit(devAddr, MPU6050_RA_USER_CTRL, MPU6050_USERCTRL_FIFO_RESET_BIT, true); |
Heidl | 0:d1960beb98fe | 2532 | } |
Heidl | 0:d1960beb98fe | 2533 | /** Reset the I2C Master. |
Heidl | 0:d1960beb98fe | 2534 | * This bit resets the I2C Master when set to 1 while I2C_MST_EN equals 0. |
Heidl | 0:d1960beb98fe | 2535 | * This bit automatically clears to 0 after the reset has been triggered. |
Heidl | 0:d1960beb98fe | 2536 | * @see MPU6050_RA_USER_CTRL |
Heidl | 0:d1960beb98fe | 2537 | * @see MPU6050_USERCTRL_I2C_MST_RESET_BIT |
Heidl | 0:d1960beb98fe | 2538 | */ |
Heidl | 0:d1960beb98fe | 2539 | void MPU6050::resetI2CMaster() |
Heidl | 0:d1960beb98fe | 2540 | { |
Heidl | 0:d1960beb98fe | 2541 | i2Cdev.writeBit(devAddr, MPU6050_RA_USER_CTRL, MPU6050_USERCTRL_I2C_MST_RESET_BIT, true); |
Heidl | 0:d1960beb98fe | 2542 | } |
Heidl | 0:d1960beb98fe | 2543 | /** Reset all sensor registers and signal paths. |
Heidl | 0:d1960beb98fe | 2544 | * When set to 1, this bit resets the signal paths for all sensors (gyroscopes, |
Heidl | 0:d1960beb98fe | 2545 | * accelerometers, and temperature sensor). This operation will also clear the |
Heidl | 0:d1960beb98fe | 2546 | * sensor registers. This bit automatically clears to 0 after the reset has been |
Heidl | 0:d1960beb98fe | 2547 | * triggered. |
Heidl | 0:d1960beb98fe | 2548 | * |
Heidl | 0:d1960beb98fe | 2549 | * When resetting only the signal path (and not the sensor registers), please |
Heidl | 0:d1960beb98fe | 2550 | * use Register 104, SIGNAL_PATH_RESET. |
Heidl | 0:d1960beb98fe | 2551 | * |
Heidl | 0:d1960beb98fe | 2552 | * @see MPU6050_RA_USER_CTRL |
Heidl | 0:d1960beb98fe | 2553 | * @see MPU6050_USERCTRL_SIG_COND_RESET_BIT |
Heidl | 0:d1960beb98fe | 2554 | */ |
Heidl | 0:d1960beb98fe | 2555 | void MPU6050::resetSensors() |
Heidl | 0:d1960beb98fe | 2556 | { |
Heidl | 0:d1960beb98fe | 2557 | i2Cdev.writeBit(devAddr, MPU6050_RA_USER_CTRL, MPU6050_USERCTRL_SIG_COND_RESET_BIT, true); |
Heidl | 0:d1960beb98fe | 2558 | } |
Heidl | 0:d1960beb98fe | 2559 | |
Heidl | 0:d1960beb98fe | 2560 | // PWR_MGMT_1 register |
Heidl | 0:d1960beb98fe | 2561 | |
Heidl | 0:d1960beb98fe | 2562 | /** Trigger a full device reset. |
Heidl | 0:d1960beb98fe | 2563 | * A small delay of ~50ms may be desirable after triggering a reset. |
Heidl | 0:d1960beb98fe | 2564 | * @see MPU6050_RA_PWR_MGMT_1 |
Heidl | 0:d1960beb98fe | 2565 | * @see MPU6050_PWR1_DEVICE_RESET_BIT |
Heidl | 0:d1960beb98fe | 2566 | */ |
Heidl | 0:d1960beb98fe | 2567 | void MPU6050::reset() |
Heidl | 0:d1960beb98fe | 2568 | { |
Heidl | 0:d1960beb98fe | 2569 | i2Cdev.writeBit(devAddr, MPU6050_RA_PWR_MGMT_1, MPU6050_PWR1_DEVICE_RESET_BIT, true); |
Heidl | 0:d1960beb98fe | 2570 | } |
Heidl | 0:d1960beb98fe | 2571 | /** Get sleep mode status. |
Heidl | 0:d1960beb98fe | 2572 | * Setting the SLEEP bit in the register puts the device into very low power |
Heidl | 0:d1960beb98fe | 2573 | * sleep mode. In this mode, only the serial interface and internal registers |
Heidl | 0:d1960beb98fe | 2574 | * remain active, allowing for a very low standby current. Clearing this bit |
Heidl | 0:d1960beb98fe | 2575 | * puts the device back into normal mode. To save power, the individual standby |
Heidl | 0:d1960beb98fe | 2576 | * selections for each of the gyros should be used if any gyro axis is not used |
Heidl | 0:d1960beb98fe | 2577 | * by the application. |
Heidl | 0:d1960beb98fe | 2578 | * @return Current sleep mode enabled status |
Heidl | 0:d1960beb98fe | 2579 | * @see MPU6050_RA_PWR_MGMT_1 |
Heidl | 0:d1960beb98fe | 2580 | * @see MPU6050_PWR1_SLEEP_BIT |
Heidl | 0:d1960beb98fe | 2581 | */ |
Heidl | 0:d1960beb98fe | 2582 | bool MPU6050::getSleepEnabled() |
Heidl | 0:d1960beb98fe | 2583 | { |
Heidl | 0:d1960beb98fe | 2584 | i2Cdev.readBit(devAddr, MPU6050_RA_PWR_MGMT_1, MPU6050_PWR1_SLEEP_BIT, buffer); |
Heidl | 0:d1960beb98fe | 2585 | return buffer[0]; |
Heidl | 0:d1960beb98fe | 2586 | } |
Heidl | 0:d1960beb98fe | 2587 | /** Set sleep mode status. |
Heidl | 0:d1960beb98fe | 2588 | * @param enabled New sleep mode enabled status |
Heidl | 0:d1960beb98fe | 2589 | * @see getSleepEnabled() |
Heidl | 0:d1960beb98fe | 2590 | * @see MPU6050_RA_PWR_MGMT_1 |
Heidl | 0:d1960beb98fe | 2591 | * @see MPU6050_PWR1_SLEEP_BIT |
Heidl | 0:d1960beb98fe | 2592 | */ |
Heidl | 0:d1960beb98fe | 2593 | void MPU6050::setSleepEnabled(bool enabled) |
Heidl | 0:d1960beb98fe | 2594 | { |
Heidl | 0:d1960beb98fe | 2595 | i2Cdev.writeBit(devAddr, MPU6050_RA_PWR_MGMT_1, MPU6050_PWR1_SLEEP_BIT, enabled); |
Heidl | 0:d1960beb98fe | 2596 | } |
Heidl | 0:d1960beb98fe | 2597 | /** Get wake cycle enabled status. |
Heidl | 0:d1960beb98fe | 2598 | * When this bit is set to 1 and SLEEP is disabled, the MPU-60X0 will cycle |
Heidl | 0:d1960beb98fe | 2599 | * between sleep mode and waking up to take a single sample of data from active |
Heidl | 0:d1960beb98fe | 2600 | * sensors at a rate determined by LP_WAKE_CTRL (register 108). |
Heidl | 0:d1960beb98fe | 2601 | * @return Current sleep mode enabled status |
Heidl | 0:d1960beb98fe | 2602 | * @see MPU6050_RA_PWR_MGMT_1 |
Heidl | 0:d1960beb98fe | 2603 | * @see MPU6050_PWR1_CYCLE_BIT |
Heidl | 0:d1960beb98fe | 2604 | */ |
Heidl | 0:d1960beb98fe | 2605 | bool MPU6050::getWakeCycleEnabled() |
Heidl | 0:d1960beb98fe | 2606 | { |
Heidl | 0:d1960beb98fe | 2607 | i2Cdev.readBit(devAddr, MPU6050_RA_PWR_MGMT_1, MPU6050_PWR1_CYCLE_BIT, buffer); |
Heidl | 0:d1960beb98fe | 2608 | return buffer[0]; |
Heidl | 0:d1960beb98fe | 2609 | } |
Heidl | 0:d1960beb98fe | 2610 | /** Set wake cycle enabled status. |
Heidl | 0:d1960beb98fe | 2611 | * @param enabled New sleep mode enabled status |
Heidl | 0:d1960beb98fe | 2612 | * @see getWakeCycleEnabled() |
Heidl | 0:d1960beb98fe | 2613 | * @see MPU6050_RA_PWR_MGMT_1 |
Heidl | 0:d1960beb98fe | 2614 | * @see MPU6050_PWR1_CYCLE_BIT |
Heidl | 0:d1960beb98fe | 2615 | */ |
Heidl | 0:d1960beb98fe | 2616 | void MPU6050::setWakeCycleEnabled(bool enabled) |
Heidl | 0:d1960beb98fe | 2617 | { |
Heidl | 0:d1960beb98fe | 2618 | i2Cdev.writeBit(devAddr, MPU6050_RA_PWR_MGMT_1, MPU6050_PWR1_CYCLE_BIT, enabled); |
Heidl | 0:d1960beb98fe | 2619 | } |
Heidl | 0:d1960beb98fe | 2620 | /** Get temperature sensor enabled status. |
Heidl | 0:d1960beb98fe | 2621 | * Control the usage of the internal temperature sensor. |
Heidl | 0:d1960beb98fe | 2622 | * |
Heidl | 0:d1960beb98fe | 2623 | * Note: this register stores the *disabled* value, but for consistency with the |
Heidl | 0:d1960beb98fe | 2624 | * rest of the code, the function is named and used with standard true/false |
Heidl | 0:d1960beb98fe | 2625 | * values to indicate whether the sensor is enabled or disabled, respectively. |
Heidl | 0:d1960beb98fe | 2626 | * |
Heidl | 0:d1960beb98fe | 2627 | * @return Current temperature sensor enabled status |
Heidl | 0:d1960beb98fe | 2628 | * @see MPU6050_RA_PWR_MGMT_1 |
Heidl | 0:d1960beb98fe | 2629 | * @see MPU6050_PWR1_TEMP_DIS_BIT |
Heidl | 0:d1960beb98fe | 2630 | */ |
Heidl | 0:d1960beb98fe | 2631 | bool MPU6050::getTempSensorEnabled() |
Heidl | 0:d1960beb98fe | 2632 | { |
Heidl | 0:d1960beb98fe | 2633 | i2Cdev.readBit(devAddr, MPU6050_RA_PWR_MGMT_1, MPU6050_PWR1_TEMP_DIS_BIT, buffer); |
Heidl | 0:d1960beb98fe | 2634 | return buffer[0] == 0; // 1 is actually disabled here |
Heidl | 0:d1960beb98fe | 2635 | } |
Heidl | 0:d1960beb98fe | 2636 | /** Set temperature sensor enabled status. |
Heidl | 0:d1960beb98fe | 2637 | * Note: this register stores the *disabled* value, but for consistency with the |
Heidl | 0:d1960beb98fe | 2638 | * rest of the code, the function is named and used with standard true/false |
Heidl | 0:d1960beb98fe | 2639 | * values to indicate whether the sensor is enabled or disabled, respectively. |
Heidl | 0:d1960beb98fe | 2640 | * |
Heidl | 0:d1960beb98fe | 2641 | * @param enabled New temperature sensor enabled status |
Heidl | 0:d1960beb98fe | 2642 | * @see getTempSensorEnabled() |
Heidl | 0:d1960beb98fe | 2643 | * @see MPU6050_RA_PWR_MGMT_1 |
Heidl | 0:d1960beb98fe | 2644 | * @see MPU6050_PWR1_TEMP_DIS_BIT |
Heidl | 0:d1960beb98fe | 2645 | */ |
Heidl | 0:d1960beb98fe | 2646 | void MPU6050::setTempSensorEnabled(bool enabled) |
Heidl | 0:d1960beb98fe | 2647 | { |
Heidl | 0:d1960beb98fe | 2648 | // 1 is actually disabled here |
Heidl | 0:d1960beb98fe | 2649 | i2Cdev.writeBit(devAddr, MPU6050_RA_PWR_MGMT_1, MPU6050_PWR1_TEMP_DIS_BIT, !enabled); |
Heidl | 0:d1960beb98fe | 2650 | } |
Heidl | 0:d1960beb98fe | 2651 | /** Get clock source setting. |
Heidl | 0:d1960beb98fe | 2652 | * @return Current clock source setting |
Heidl | 0:d1960beb98fe | 2653 | * @see MPU6050_RA_PWR_MGMT_1 |
Heidl | 0:d1960beb98fe | 2654 | * @see MPU6050_PWR1_CLKSEL_BIT |
Heidl | 0:d1960beb98fe | 2655 | * @see MPU6050_PWR1_CLKSEL_LENGTH |
Heidl | 0:d1960beb98fe | 2656 | */ |
Heidl | 0:d1960beb98fe | 2657 | uint8_t MPU6050::getClockSource() |
Heidl | 0:d1960beb98fe | 2658 | { |
Heidl | 0:d1960beb98fe | 2659 | i2Cdev.readBits(devAddr, MPU6050_RA_PWR_MGMT_1, MPU6050_PWR1_CLKSEL_BIT, MPU6050_PWR1_CLKSEL_LENGTH, buffer); |
Heidl | 0:d1960beb98fe | 2660 | return buffer[0]; |
Heidl | 0:d1960beb98fe | 2661 | } |
Heidl | 0:d1960beb98fe | 2662 | /** Set clock source setting. |
Heidl | 0:d1960beb98fe | 2663 | * An internal 8MHz oscillator, gyroscope based clock, or external sources can |
Heidl | 0:d1960beb98fe | 2664 | * be selected as the MPU-60X0 clock source. When the internal 8 MHz oscillator |
Heidl | 0:d1960beb98fe | 2665 | * or an external source is chosen as the clock source, the MPU-60X0 can operate |
Heidl | 0:d1960beb98fe | 2666 | * in low power modes with the gyroscopes disabled. |
Heidl | 0:d1960beb98fe | 2667 | * |
Heidl | 0:d1960beb98fe | 2668 | * Upon power up, the MPU-60X0 clock source defaults to the internal oscillator. |
Heidl | 0:d1960beb98fe | 2669 | * However, it is highly recommended that the device be configured to use one of |
Heidl | 0:d1960beb98fe | 2670 | * the gyroscopes (or an external clock source) as the clock reference for |
Heidl | 0:d1960beb98fe | 2671 | * improved stability. The clock source can be selected according to the following table: |
Heidl | 0:d1960beb98fe | 2672 | * |
Heidl | 0:d1960beb98fe | 2673 | * <pre> |
Heidl | 0:d1960beb98fe | 2674 | * CLK_SEL | Clock Source |
Heidl | 0:d1960beb98fe | 2675 | * --------+-------------------------------------- |
Heidl | 0:d1960beb98fe | 2676 | * 0 | Internal oscillator |
Heidl | 0:d1960beb98fe | 2677 | * 1 | PLL with X Gyro reference |
Heidl | 0:d1960beb98fe | 2678 | * 2 | PLL with Y Gyro reference |
Heidl | 0:d1960beb98fe | 2679 | * 3 | PLL with Z Gyro reference |
Heidl | 0:d1960beb98fe | 2680 | * 4 | PLL with external 32.768kHz reference |
Heidl | 0:d1960beb98fe | 2681 | * 5 | PLL with external 19.2MHz reference |
Heidl | 0:d1960beb98fe | 2682 | * 6 | Reserved |
Heidl | 0:d1960beb98fe | 2683 | * 7 | Stops the clock and keeps the timing generator in reset |
Heidl | 0:d1960beb98fe | 2684 | * </pre> |
Heidl | 0:d1960beb98fe | 2685 | * |
Heidl | 0:d1960beb98fe | 2686 | * @param source New clock source setting |
Heidl | 0:d1960beb98fe | 2687 | * @see getClockSource() |
Heidl | 0:d1960beb98fe | 2688 | * @see MPU6050_RA_PWR_MGMT_1 |
Heidl | 0:d1960beb98fe | 2689 | * @see MPU6050_PWR1_CLKSEL_BIT |
Heidl | 0:d1960beb98fe | 2690 | * @see MPU6050_PWR1_CLKSEL_LENGTH |
Heidl | 0:d1960beb98fe | 2691 | */ |
Heidl | 0:d1960beb98fe | 2692 | void MPU6050::setClockSource(uint8_t source) |
Heidl | 0:d1960beb98fe | 2693 | { |
Heidl | 0:d1960beb98fe | 2694 | i2Cdev.writeBits(devAddr, MPU6050_RA_PWR_MGMT_1, MPU6050_PWR1_CLKSEL_BIT, MPU6050_PWR1_CLKSEL_LENGTH, source); |
Heidl | 0:d1960beb98fe | 2695 | } |
Heidl | 0:d1960beb98fe | 2696 | |
Heidl | 0:d1960beb98fe | 2697 | // PWR_MGMT_2 register |
Heidl | 0:d1960beb98fe | 2698 | |
Heidl | 0:d1960beb98fe | 2699 | /** Get wake frequency in Accel-Only Low Power Mode. |
Heidl | 0:d1960beb98fe | 2700 | * The MPU-60X0 can be put into Accerlerometer Only Low Power Mode by setting |
Heidl | 0:d1960beb98fe | 2701 | * PWRSEL to 1 in the Power Management 1 register (Register 107). In this mode, |
Heidl | 0:d1960beb98fe | 2702 | * the device will power off all devices except for the primary I2C interface, |
Heidl | 0:d1960beb98fe | 2703 | * waking only the accelerometer at fixed intervals to take a single |
Heidl | 0:d1960beb98fe | 2704 | * measurement. The frequency of wake-ups can be configured with LP_WAKE_CTRL |
Heidl | 0:d1960beb98fe | 2705 | * as shown below: |
Heidl | 0:d1960beb98fe | 2706 | * |
Heidl | 0:d1960beb98fe | 2707 | * <pre> |
Heidl | 0:d1960beb98fe | 2708 | * LP_WAKE_CTRL | Wake-up Frequency |
Heidl | 0:d1960beb98fe | 2709 | * -------------+------------------ |
Heidl | 0:d1960beb98fe | 2710 | * 0 | 1.25 Hz |
Heidl | 0:d1960beb98fe | 2711 | * 1 | 2.5 Hz |
Heidl | 0:d1960beb98fe | 2712 | * 2 | 5 Hz |
Heidl | 0:d1960beb98fe | 2713 | * 3 | 10 Hz |
Heidl | 0:d1960beb98fe | 2714 | * <pre> |
Heidl | 0:d1960beb98fe | 2715 | * |
Heidl | 0:d1960beb98fe | 2716 | * For further information regarding the MPU-60X0's power modes, please refer to |
Heidl | 0:d1960beb98fe | 2717 | * Register 107. |
Heidl | 0:d1960beb98fe | 2718 | * |
Heidl | 0:d1960beb98fe | 2719 | * @return Current wake frequency |
Heidl | 0:d1960beb98fe | 2720 | * @see MPU6050_RA_PWR_MGMT_2 |
Heidl | 0:d1960beb98fe | 2721 | */ |
Heidl | 0:d1960beb98fe | 2722 | uint8_t MPU6050::getWakeFrequency() |
Heidl | 0:d1960beb98fe | 2723 | { |
Heidl | 0:d1960beb98fe | 2724 | i2Cdev.readBits(devAddr, MPU6050_RA_PWR_MGMT_2, MPU6050_PWR2_LP_WAKE_CTRL_BIT, MPU6050_PWR2_LP_WAKE_CTRL_LENGTH, buffer); |
Heidl | 0:d1960beb98fe | 2725 | return buffer[0]; |
Heidl | 0:d1960beb98fe | 2726 | } |
Heidl | 0:d1960beb98fe | 2727 | /** Set wake frequency in Accel-Only Low Power Mode. |
Heidl | 0:d1960beb98fe | 2728 | * @param frequency New wake frequency |
Heidl | 0:d1960beb98fe | 2729 | * @see MPU6050_RA_PWR_MGMT_2 |
Heidl | 0:d1960beb98fe | 2730 | */ |
Heidl | 0:d1960beb98fe | 2731 | void MPU6050::setWakeFrequency(uint8_t frequency) |
Heidl | 0:d1960beb98fe | 2732 | { |
Heidl | 0:d1960beb98fe | 2733 | i2Cdev.writeBits(devAddr, MPU6050_RA_PWR_MGMT_2, MPU6050_PWR2_LP_WAKE_CTRL_BIT, MPU6050_PWR2_LP_WAKE_CTRL_LENGTH, frequency); |
Heidl | 0:d1960beb98fe | 2734 | } |
Heidl | 0:d1960beb98fe | 2735 | |
Heidl | 0:d1960beb98fe | 2736 | /** Get X-axis accelerometer standby enabled status. |
Heidl | 0:d1960beb98fe | 2737 | * If enabled, the X-axis will not gather or report data (or use power). |
Heidl | 0:d1960beb98fe | 2738 | * @return Current X-axis standby enabled status |
Heidl | 0:d1960beb98fe | 2739 | * @see MPU6050_RA_PWR_MGMT_2 |
Heidl | 0:d1960beb98fe | 2740 | * @see MPU6050_PWR2_STBY_XA_BIT |
Heidl | 0:d1960beb98fe | 2741 | */ |
Heidl | 0:d1960beb98fe | 2742 | bool MPU6050::getStandbyXAccelEnabled() |
Heidl | 0:d1960beb98fe | 2743 | { |
Heidl | 0:d1960beb98fe | 2744 | i2Cdev.readBit(devAddr, MPU6050_RA_PWR_MGMT_2, MPU6050_PWR2_STBY_XA_BIT, buffer); |
Heidl | 0:d1960beb98fe | 2745 | return buffer[0]; |
Heidl | 0:d1960beb98fe | 2746 | } |
Heidl | 0:d1960beb98fe | 2747 | /** Set X-axis accelerometer standby enabled status. |
Heidl | 0:d1960beb98fe | 2748 | * @param New X-axis standby enabled status |
Heidl | 0:d1960beb98fe | 2749 | * @see getStandbyXAccelEnabled() |
Heidl | 0:d1960beb98fe | 2750 | * @see MPU6050_RA_PWR_MGMT_2 |
Heidl | 0:d1960beb98fe | 2751 | * @see MPU6050_PWR2_STBY_XA_BIT |
Heidl | 0:d1960beb98fe | 2752 | */ |
Heidl | 0:d1960beb98fe | 2753 | void MPU6050::setStandbyXAccelEnabled(bool enabled) |
Heidl | 0:d1960beb98fe | 2754 | { |
Heidl | 0:d1960beb98fe | 2755 | i2Cdev.writeBit(devAddr, MPU6050_RA_PWR_MGMT_2, MPU6050_PWR2_STBY_XA_BIT, enabled); |
Heidl | 0:d1960beb98fe | 2756 | } |
Heidl | 0:d1960beb98fe | 2757 | /** Get Y-axis accelerometer standby enabled status. |
Heidl | 0:d1960beb98fe | 2758 | * If enabled, the Y-axis will not gather or report data (or use power). |
Heidl | 0:d1960beb98fe | 2759 | * @return Current Y-axis standby enabled status |
Heidl | 0:d1960beb98fe | 2760 | * @see MPU6050_RA_PWR_MGMT_2 |
Heidl | 0:d1960beb98fe | 2761 | * @see MPU6050_PWR2_STBY_YA_BIT |
Heidl | 0:d1960beb98fe | 2762 | */ |
Heidl | 0:d1960beb98fe | 2763 | bool MPU6050::getStandbyYAccelEnabled() |
Heidl | 0:d1960beb98fe | 2764 | { |
Heidl | 0:d1960beb98fe | 2765 | i2Cdev.readBit(devAddr, MPU6050_RA_PWR_MGMT_2, MPU6050_PWR2_STBY_YA_BIT, buffer); |
Heidl | 0:d1960beb98fe | 2766 | return buffer[0]; |
Heidl | 0:d1960beb98fe | 2767 | } |
Heidl | 0:d1960beb98fe | 2768 | /** Set Y-axis accelerometer standby enabled status. |
Heidl | 0:d1960beb98fe | 2769 | * @param New Y-axis standby enabled status |
Heidl | 0:d1960beb98fe | 2770 | * @see getStandbyYAccelEnabled() |
Heidl | 0:d1960beb98fe | 2771 | * @see MPU6050_RA_PWR_MGMT_2 |
Heidl | 0:d1960beb98fe | 2772 | * @see MPU6050_PWR2_STBY_YA_BIT |
Heidl | 0:d1960beb98fe | 2773 | */ |
Heidl | 0:d1960beb98fe | 2774 | void MPU6050::setStandbyYAccelEnabled(bool enabled) |
Heidl | 0:d1960beb98fe | 2775 | { |
Heidl | 0:d1960beb98fe | 2776 | i2Cdev.writeBit(devAddr, MPU6050_RA_PWR_MGMT_2, MPU6050_PWR2_STBY_YA_BIT, enabled); |
Heidl | 0:d1960beb98fe | 2777 | } |
Heidl | 0:d1960beb98fe | 2778 | /** Get Z-axis accelerometer standby enabled status. |
Heidl | 0:d1960beb98fe | 2779 | * If enabled, the Z-axis will not gather or report data (or use power). |
Heidl | 0:d1960beb98fe | 2780 | * @return Current Z-axis standby enabled status |
Heidl | 0:d1960beb98fe | 2781 | * @see MPU6050_RA_PWR_MGMT_2 |
Heidl | 0:d1960beb98fe | 2782 | * @see MPU6050_PWR2_STBY_ZA_BIT |
Heidl | 0:d1960beb98fe | 2783 | */ |
Heidl | 0:d1960beb98fe | 2784 | bool MPU6050::getStandbyZAccelEnabled() |
Heidl | 0:d1960beb98fe | 2785 | { |
Heidl | 0:d1960beb98fe | 2786 | i2Cdev.readBit(devAddr, MPU6050_RA_PWR_MGMT_2, MPU6050_PWR2_STBY_ZA_BIT, buffer); |
Heidl | 0:d1960beb98fe | 2787 | return buffer[0]; |
Heidl | 0:d1960beb98fe | 2788 | } |
Heidl | 0:d1960beb98fe | 2789 | /** Set Z-axis accelerometer standby enabled status. |
Heidl | 0:d1960beb98fe | 2790 | * @param New Z-axis standby enabled status |
Heidl | 0:d1960beb98fe | 2791 | * @see getStandbyZAccelEnabled() |
Heidl | 0:d1960beb98fe | 2792 | * @see MPU6050_RA_PWR_MGMT_2 |
Heidl | 0:d1960beb98fe | 2793 | * @see MPU6050_PWR2_STBY_ZA_BIT |
Heidl | 0:d1960beb98fe | 2794 | */ |
Heidl | 0:d1960beb98fe | 2795 | void MPU6050::setStandbyZAccelEnabled(bool enabled) |
Heidl | 0:d1960beb98fe | 2796 | { |
Heidl | 0:d1960beb98fe | 2797 | i2Cdev.writeBit(devAddr, MPU6050_RA_PWR_MGMT_2, MPU6050_PWR2_STBY_ZA_BIT, enabled); |
Heidl | 0:d1960beb98fe | 2798 | } |
Heidl | 0:d1960beb98fe | 2799 | /** Get X-axis gyroscope standby enabled status. |
Heidl | 0:d1960beb98fe | 2800 | * If enabled, the X-axis will not gather or report data (or use power). |
Heidl | 0:d1960beb98fe | 2801 | * @return Current X-axis standby enabled status |
Heidl | 0:d1960beb98fe | 2802 | * @see MPU6050_RA_PWR_MGMT_2 |
Heidl | 0:d1960beb98fe | 2803 | * @see MPU6050_PWR2_STBY_XG_BIT |
Heidl | 0:d1960beb98fe | 2804 | */ |
Heidl | 0:d1960beb98fe | 2805 | bool MPU6050::getStandbyXGyroEnabled() |
Heidl | 0:d1960beb98fe | 2806 | { |
Heidl | 0:d1960beb98fe | 2807 | i2Cdev.readBit(devAddr, MPU6050_RA_PWR_MGMT_2, MPU6050_PWR2_STBY_XG_BIT, buffer); |
Heidl | 0:d1960beb98fe | 2808 | return buffer[0]; |
Heidl | 0:d1960beb98fe | 2809 | } |
Heidl | 0:d1960beb98fe | 2810 | /** Set X-axis gyroscope standby enabled status. |
Heidl | 0:d1960beb98fe | 2811 | * @param New X-axis standby enabled status |
Heidl | 0:d1960beb98fe | 2812 | * @see getStandbyXGyroEnabled() |
Heidl | 0:d1960beb98fe | 2813 | * @see MPU6050_RA_PWR_MGMT_2 |
Heidl | 0:d1960beb98fe | 2814 | * @see MPU6050_PWR2_STBY_XG_BIT |
Heidl | 0:d1960beb98fe | 2815 | */ |
Heidl | 0:d1960beb98fe | 2816 | void MPU6050::setStandbyXGyroEnabled(bool enabled) |
Heidl | 0:d1960beb98fe | 2817 | { |
Heidl | 0:d1960beb98fe | 2818 | i2Cdev.writeBit(devAddr, MPU6050_RA_PWR_MGMT_2, MPU6050_PWR2_STBY_XG_BIT, enabled); |
Heidl | 0:d1960beb98fe | 2819 | } |
Heidl | 0:d1960beb98fe | 2820 | /** Get Y-axis gyroscope standby enabled status. |
Heidl | 0:d1960beb98fe | 2821 | * If enabled, the Y-axis will not gather or report data (or use power). |
Heidl | 0:d1960beb98fe | 2822 | * @return Current Y-axis standby enabled status |
Heidl | 0:d1960beb98fe | 2823 | * @see MPU6050_RA_PWR_MGMT_2 |
Heidl | 0:d1960beb98fe | 2824 | * @see MPU6050_PWR2_STBY_YG_BIT |
Heidl | 0:d1960beb98fe | 2825 | */ |
Heidl | 0:d1960beb98fe | 2826 | bool MPU6050::getStandbyYGyroEnabled() |
Heidl | 0:d1960beb98fe | 2827 | { |
Heidl | 0:d1960beb98fe | 2828 | i2Cdev.readBit(devAddr, MPU6050_RA_PWR_MGMT_2, MPU6050_PWR2_STBY_YG_BIT, buffer); |
Heidl | 0:d1960beb98fe | 2829 | return buffer[0]; |
Heidl | 0:d1960beb98fe | 2830 | } |
Heidl | 0:d1960beb98fe | 2831 | /** Set Y-axis gyroscope standby enabled status. |
Heidl | 0:d1960beb98fe | 2832 | * @param New Y-axis standby enabled status |
Heidl | 0:d1960beb98fe | 2833 | * @see getStandbyYGyroEnabled() |
Heidl | 0:d1960beb98fe | 2834 | * @see MPU6050_RA_PWR_MGMT_2 |
Heidl | 0:d1960beb98fe | 2835 | * @see MPU6050_PWR2_STBY_YG_BIT |
Heidl | 0:d1960beb98fe | 2836 | */ |
Heidl | 0:d1960beb98fe | 2837 | void MPU6050::setStandbyYGyroEnabled(bool enabled) |
Heidl | 0:d1960beb98fe | 2838 | { |
Heidl | 0:d1960beb98fe | 2839 | i2Cdev.writeBit(devAddr, MPU6050_RA_PWR_MGMT_2, MPU6050_PWR2_STBY_YG_BIT, enabled); |
Heidl | 0:d1960beb98fe | 2840 | } |
Heidl | 0:d1960beb98fe | 2841 | /** Get Z-axis gyroscope standby enabled status. |
Heidl | 0:d1960beb98fe | 2842 | * If enabled, the Z-axis will not gather or report data (or use power). |
Heidl | 0:d1960beb98fe | 2843 | * @return Current Z-axis standby enabled status |
Heidl | 0:d1960beb98fe | 2844 | * @see MPU6050_RA_PWR_MGMT_2 |
Heidl | 0:d1960beb98fe | 2845 | * @see MPU6050_PWR2_STBY_ZG_BIT |
Heidl | 0:d1960beb98fe | 2846 | */ |
Heidl | 0:d1960beb98fe | 2847 | bool MPU6050::getStandbyZGyroEnabled() |
Heidl | 0:d1960beb98fe | 2848 | { |
Heidl | 0:d1960beb98fe | 2849 | i2Cdev.readBit(devAddr, MPU6050_RA_PWR_MGMT_2, MPU6050_PWR2_STBY_ZG_BIT, buffer); |
Heidl | 0:d1960beb98fe | 2850 | return buffer[0]; |
Heidl | 0:d1960beb98fe | 2851 | } |
Heidl | 0:d1960beb98fe | 2852 | /** Set Z-axis gyroscope standby enabled status. |
Heidl | 0:d1960beb98fe | 2853 | * @param New Z-axis standby enabled status |
Heidl | 0:d1960beb98fe | 2854 | * @see getStandbyZGyroEnabled() |
Heidl | 0:d1960beb98fe | 2855 | * @see MPU6050_RA_PWR_MGMT_2 |
Heidl | 0:d1960beb98fe | 2856 | * @see MPU6050_PWR2_STBY_ZG_BIT |
Heidl | 0:d1960beb98fe | 2857 | */ |
Heidl | 0:d1960beb98fe | 2858 | void MPU6050::setStandbyZGyroEnabled(bool enabled) |
Heidl | 0:d1960beb98fe | 2859 | { |
Heidl | 0:d1960beb98fe | 2860 | i2Cdev.writeBit(devAddr, MPU6050_RA_PWR_MGMT_2, MPU6050_PWR2_STBY_ZG_BIT, enabled); |
Heidl | 0:d1960beb98fe | 2861 | } |
Heidl | 0:d1960beb98fe | 2862 | |
Heidl | 0:d1960beb98fe | 2863 | // FIFO_COUNT* registers |
Heidl | 0:d1960beb98fe | 2864 | |
Heidl | 0:d1960beb98fe | 2865 | /** Get current FIFO buffer size. |
Heidl | 0:d1960beb98fe | 2866 | * This value indicates the number of bytes stored in the FIFO buffer. This |
Heidl | 0:d1960beb98fe | 2867 | * number is in turn the number of bytes that can be read from the FIFO buffer |
Heidl | 0:d1960beb98fe | 2868 | * and it is directly proportional to the number of samples available given the |
Heidl | 0:d1960beb98fe | 2869 | * set of sensor data bound to be stored in the FIFO (register 35 and 36). |
Heidl | 0:d1960beb98fe | 2870 | * @return Current FIFO buffer size |
Heidl | 0:d1960beb98fe | 2871 | */ |
Heidl | 0:d1960beb98fe | 2872 | uint16_t MPU6050::getFIFOCount() |
Heidl | 0:d1960beb98fe | 2873 | { |
Heidl | 0:d1960beb98fe | 2874 | i2Cdev.readBytes(devAddr, MPU6050_RA_FIFO_COUNTH, 2, buffer); |
Heidl | 0:d1960beb98fe | 2875 | return (((uint16_t)buffer[0]) << 8) | buffer[1]; |
Heidl | 0:d1960beb98fe | 2876 | } |
Heidl | 0:d1960beb98fe | 2877 | |
Heidl | 0:d1960beb98fe | 2878 | // FIFO_R_W register |
Heidl | 0:d1960beb98fe | 2879 | |
Heidl | 0:d1960beb98fe | 2880 | /** Get byte from FIFO buffer. |
Heidl | 0:d1960beb98fe | 2881 | * This register is used to read and write data from the FIFO buffer. Data is |
Heidl | 0:d1960beb98fe | 2882 | * written to the FIFO in order of register number (from lowest to highest). If |
Heidl | 0:d1960beb98fe | 2883 | * all the FIFO enable flags (see below) are enabled and all External Sensor |
Heidl | 0:d1960beb98fe | 2884 | * Data registers (Registers 73 to 96) are associated with a Slave device, the |
Heidl | 0:d1960beb98fe | 2885 | * contents of registers 59 through 96 will be written in order at the Sample |
Heidl | 0:d1960beb98fe | 2886 | * Rate. |
Heidl | 0:d1960beb98fe | 2887 | * |
Heidl | 0:d1960beb98fe | 2888 | * The contents of the sensor data registers (Registers 59 to 96) are written |
Heidl | 0:d1960beb98fe | 2889 | * into the FIFO buffer when their corresponding FIFO enable flags are set to 1 |
Heidl | 0:d1960beb98fe | 2890 | * in FIFO_EN (Register 35). An additional flag for the sensor data registers |
Heidl | 0:d1960beb98fe | 2891 | * associated with I2C Slave 3 can be found in I2C_MST_CTRL (Register 36). |
Heidl | 0:d1960beb98fe | 2892 | * |
Heidl | 0:d1960beb98fe | 2893 | * If the FIFO buffer has overflowed, the status bit FIFO_OFLOW_INT is |
Heidl | 0:d1960beb98fe | 2894 | * automatically set to 1. This bit is located in INT_STATUS (Register 58). |
Heidl | 0:d1960beb98fe | 2895 | * When the FIFO buffer has overflowed, the oldest data will be lost and new |
Heidl | 0:d1960beb98fe | 2896 | * data will be written to the FIFO. |
Heidl | 0:d1960beb98fe | 2897 | * |
Heidl | 0:d1960beb98fe | 2898 | * If the FIFO buffer is empty, reading this register will return the last byte |
Heidl | 0:d1960beb98fe | 2899 | * that was previously read from the FIFO until new data is available. The user |
Heidl | 0:d1960beb98fe | 2900 | * should check FIFO_COUNT to ensure that the FIFO buffer is not read when |
Heidl | 0:d1960beb98fe | 2901 | * empty. |
Heidl | 0:d1960beb98fe | 2902 | * |
Heidl | 0:d1960beb98fe | 2903 | * @return Byte from FIFO buffer |
Heidl | 0:d1960beb98fe | 2904 | */ |
Heidl | 0:d1960beb98fe | 2905 | uint8_t MPU6050::getFIFOByte() |
Heidl | 0:d1960beb98fe | 2906 | { |
Heidl | 0:d1960beb98fe | 2907 | i2Cdev.readByte(devAddr, MPU6050_RA_FIFO_R_W, buffer); |
Heidl | 0:d1960beb98fe | 2908 | return buffer[0]; |
Heidl | 0:d1960beb98fe | 2909 | } |
Heidl | 0:d1960beb98fe | 2910 | void MPU6050::getFIFOBytes(uint8_t *data, uint8_t length) |
Heidl | 0:d1960beb98fe | 2911 | { |
Heidl | 0:d1960beb98fe | 2912 | i2Cdev.readBytes(devAddr, MPU6050_RA_FIFO_R_W, length, data); |
Heidl | 0:d1960beb98fe | 2913 | } |
Heidl | 0:d1960beb98fe | 2914 | /** Write byte to FIFO buffer. |
Heidl | 0:d1960beb98fe | 2915 | * @see getFIFOByte() |
Heidl | 0:d1960beb98fe | 2916 | * @see MPU6050_RA_FIFO_R_W |
Heidl | 0:d1960beb98fe | 2917 | */ |
Heidl | 0:d1960beb98fe | 2918 | void MPU6050::setFIFOByte(uint8_t data) |
Heidl | 0:d1960beb98fe | 2919 | { |
Heidl | 0:d1960beb98fe | 2920 | i2Cdev.writeByte(devAddr, MPU6050_RA_FIFO_R_W, data); |
Heidl | 0:d1960beb98fe | 2921 | } |
Heidl | 0:d1960beb98fe | 2922 | |
Heidl | 0:d1960beb98fe | 2923 | // WHO_AM_I register |
Heidl | 0:d1960beb98fe | 2924 | |
Heidl | 0:d1960beb98fe | 2925 | /** Get Device ID. |
Heidl | 0:d1960beb98fe | 2926 | * This register is used to verify the identity of the device (0b110100, 0x34). |
Heidl | 0:d1960beb98fe | 2927 | * @return Device ID (6 bits only! should be 0x34) |
Heidl | 0:d1960beb98fe | 2928 | * @see MPU6050_RA_WHO_AM_I |
Heidl | 0:d1960beb98fe | 2929 | * @see MPU6050_WHO_AM_I_BIT |
Heidl | 0:d1960beb98fe | 2930 | * @see MPU6050_WHO_AM_I_LENGTH |
Heidl | 0:d1960beb98fe | 2931 | */ |
Heidl | 0:d1960beb98fe | 2932 | uint8_t MPU6050::getDeviceID() |
Heidl | 0:d1960beb98fe | 2933 | { |
Heidl | 0:d1960beb98fe | 2934 | i2Cdev.readBits(devAddr, MPU6050_RA_WHO_AM_I, MPU6050_WHO_AM_I_BIT, MPU6050_WHO_AM_I_LENGTH, buffer); |
Heidl | 0:d1960beb98fe | 2935 | return buffer[0]; |
Heidl | 0:d1960beb98fe | 2936 | } |
Heidl | 0:d1960beb98fe | 2937 | /** Set Device ID. |
Heidl | 0:d1960beb98fe | 2938 | * Write a new ID into the WHO_AM_I register (no idea why this should ever be |
Heidl | 0:d1960beb98fe | 2939 | * necessary though). |
Heidl | 0:d1960beb98fe | 2940 | * @param id New device ID to set. |
Heidl | 0:d1960beb98fe | 2941 | * @see getDeviceID() |
Heidl | 0:d1960beb98fe | 2942 | * @see MPU6050_RA_WHO_AM_I |
Heidl | 0:d1960beb98fe | 2943 | * @see MPU6050_WHO_AM_I_BIT |
Heidl | 0:d1960beb98fe | 2944 | * @see MPU6050_WHO_AM_I_LENGTH |
Heidl | 0:d1960beb98fe | 2945 | */ |
Heidl | 0:d1960beb98fe | 2946 | void MPU6050::setDeviceID(uint8_t id) |
Heidl | 0:d1960beb98fe | 2947 | { |
Heidl | 0:d1960beb98fe | 2948 | i2Cdev.writeBits(devAddr, MPU6050_RA_WHO_AM_I, MPU6050_WHO_AM_I_BIT, MPU6050_WHO_AM_I_LENGTH, id); |
Heidl | 0:d1960beb98fe | 2949 | } |
Heidl | 0:d1960beb98fe | 2950 | |
Heidl | 0:d1960beb98fe | 2951 | // ======== UNDOCUMENTED/DMP REGISTERS/METHODS ======== |
Heidl | 0:d1960beb98fe | 2952 | |
Heidl | 0:d1960beb98fe | 2953 | // XG_OFFS_TC register |
Heidl | 0:d1960beb98fe | 2954 | |
Heidl | 0:d1960beb98fe | 2955 | uint8_t MPU6050::getOTPBankValid() |
Heidl | 0:d1960beb98fe | 2956 | { |
Heidl | 0:d1960beb98fe | 2957 | i2Cdev.readBit(devAddr, MPU6050_RA_XG_OFFS_TC, MPU6050_TC_OTP_BNK_VLD_BIT, buffer); |
Heidl | 0:d1960beb98fe | 2958 | return buffer[0]; |
Heidl | 0:d1960beb98fe | 2959 | } |
Heidl | 0:d1960beb98fe | 2960 | void MPU6050::setOTPBankValid(bool enabled) |
Heidl | 0:d1960beb98fe | 2961 | { |
Heidl | 0:d1960beb98fe | 2962 | i2Cdev.writeBit(devAddr, MPU6050_RA_XG_OFFS_TC, MPU6050_TC_OTP_BNK_VLD_BIT, enabled); |
Heidl | 0:d1960beb98fe | 2963 | } |
Heidl | 0:d1960beb98fe | 2964 | int8_t MPU6050::getXGyroOffset() |
Heidl | 0:d1960beb98fe | 2965 | { |
Heidl | 0:d1960beb98fe | 2966 | i2Cdev.readBits(devAddr, MPU6050_RA_XG_OFFS_TC, MPU6050_TC_OFFSET_BIT, MPU6050_TC_OFFSET_LENGTH, buffer); |
Heidl | 0:d1960beb98fe | 2967 | return buffer[0]; |
Heidl | 0:d1960beb98fe | 2968 | } |
Heidl | 0:d1960beb98fe | 2969 | void MPU6050::setXGyroOffset(int8_t offset) |
Heidl | 0:d1960beb98fe | 2970 | { |
Heidl | 0:d1960beb98fe | 2971 | i2Cdev.writeBits(devAddr, MPU6050_RA_XG_OFFS_TC, MPU6050_TC_OFFSET_BIT, MPU6050_TC_OFFSET_LENGTH, offset); |
Heidl | 0:d1960beb98fe | 2972 | } |
Heidl | 0:d1960beb98fe | 2973 | |
Heidl | 0:d1960beb98fe | 2974 | // YG_OFFS_TC register |
Heidl | 0:d1960beb98fe | 2975 | |
Heidl | 0:d1960beb98fe | 2976 | int8_t MPU6050::getYGyroOffset() |
Heidl | 0:d1960beb98fe | 2977 | { |
Heidl | 0:d1960beb98fe | 2978 | i2Cdev.readBits(devAddr, MPU6050_RA_YG_OFFS_TC, MPU6050_TC_OFFSET_BIT, MPU6050_TC_OFFSET_LENGTH, buffer); |
Heidl | 0:d1960beb98fe | 2979 | return buffer[0]; |
Heidl | 0:d1960beb98fe | 2980 | } |
Heidl | 0:d1960beb98fe | 2981 | void MPU6050::setYGyroOffset(int8_t offset) |
Heidl | 0:d1960beb98fe | 2982 | { |
Heidl | 0:d1960beb98fe | 2983 | i2Cdev.writeBits(devAddr, MPU6050_RA_YG_OFFS_TC, MPU6050_TC_OFFSET_BIT, MPU6050_TC_OFFSET_LENGTH, offset); |
Heidl | 0:d1960beb98fe | 2984 | } |
Heidl | 0:d1960beb98fe | 2985 | |
Heidl | 0:d1960beb98fe | 2986 | // ZG_OFFS_TC register |
Heidl | 0:d1960beb98fe | 2987 | |
Heidl | 0:d1960beb98fe | 2988 | int8_t MPU6050::getZGyroOffset() |
Heidl | 0:d1960beb98fe | 2989 | { |
Heidl | 0:d1960beb98fe | 2990 | i2Cdev.readBits(devAddr, MPU6050_RA_ZG_OFFS_TC, MPU6050_TC_OFFSET_BIT, MPU6050_TC_OFFSET_LENGTH, buffer); |
Heidl | 0:d1960beb98fe | 2991 | return buffer[0]; |
Heidl | 0:d1960beb98fe | 2992 | } |
Heidl | 0:d1960beb98fe | 2993 | void MPU6050::setZGyroOffset(int8_t offset) |
Heidl | 0:d1960beb98fe | 2994 | { |
Heidl | 0:d1960beb98fe | 2995 | i2Cdev.writeBits(devAddr, MPU6050_RA_ZG_OFFS_TC, MPU6050_TC_OFFSET_BIT, MPU6050_TC_OFFSET_LENGTH, offset); |
Heidl | 0:d1960beb98fe | 2996 | } |
Heidl | 0:d1960beb98fe | 2997 | |
Heidl | 0:d1960beb98fe | 2998 | // X_FINE_GAIN register |
Heidl | 0:d1960beb98fe | 2999 | |
Heidl | 0:d1960beb98fe | 3000 | int8_t MPU6050::getXFineGain() |
Heidl | 0:d1960beb98fe | 3001 | { |
Heidl | 0:d1960beb98fe | 3002 | i2Cdev.readByte(devAddr, MPU6050_RA_X_FINE_GAIN, buffer); |
Heidl | 0:d1960beb98fe | 3003 | return buffer[0]; |
Heidl | 0:d1960beb98fe | 3004 | } |
Heidl | 0:d1960beb98fe | 3005 | void MPU6050::setXFineGain(int8_t gain) |
Heidl | 0:d1960beb98fe | 3006 | { |
Heidl | 0:d1960beb98fe | 3007 | i2Cdev.writeByte(devAddr, MPU6050_RA_X_FINE_GAIN, gain); |
Heidl | 0:d1960beb98fe | 3008 | } |
Heidl | 0:d1960beb98fe | 3009 | |
Heidl | 0:d1960beb98fe | 3010 | // Y_FINE_GAIN register |
Heidl | 0:d1960beb98fe | 3011 | |
Heidl | 0:d1960beb98fe | 3012 | int8_t MPU6050::getYFineGain() |
Heidl | 0:d1960beb98fe | 3013 | { |
Heidl | 0:d1960beb98fe | 3014 | i2Cdev.readByte(devAddr, MPU6050_RA_Y_FINE_GAIN, buffer); |
Heidl | 0:d1960beb98fe | 3015 | return buffer[0]; |
Heidl | 0:d1960beb98fe | 3016 | } |
Heidl | 0:d1960beb98fe | 3017 | void MPU6050::setYFineGain(int8_t gain) |
Heidl | 0:d1960beb98fe | 3018 | { |
Heidl | 0:d1960beb98fe | 3019 | i2Cdev.writeByte(devAddr, MPU6050_RA_Y_FINE_GAIN, gain); |
Heidl | 0:d1960beb98fe | 3020 | } |
Heidl | 0:d1960beb98fe | 3021 | |
Heidl | 0:d1960beb98fe | 3022 | // Z_FINE_GAIN register |
Heidl | 0:d1960beb98fe | 3023 | |
Heidl | 0:d1960beb98fe | 3024 | int8_t MPU6050::getZFineGain() |
Heidl | 0:d1960beb98fe | 3025 | { |
Heidl | 0:d1960beb98fe | 3026 | i2Cdev.readByte(devAddr, MPU6050_RA_Z_FINE_GAIN, buffer); |
Heidl | 0:d1960beb98fe | 3027 | return buffer[0]; |
Heidl | 0:d1960beb98fe | 3028 | } |
Heidl | 0:d1960beb98fe | 3029 | void MPU6050::setZFineGain(int8_t gain) |
Heidl | 0:d1960beb98fe | 3030 | { |
Heidl | 0:d1960beb98fe | 3031 | i2Cdev.writeByte(devAddr, MPU6050_RA_Z_FINE_GAIN, gain); |
Heidl | 0:d1960beb98fe | 3032 | } |
Heidl | 0:d1960beb98fe | 3033 | |
Heidl | 0:d1960beb98fe | 3034 | // XA_OFFS_* registers |
Heidl | 0:d1960beb98fe | 3035 | |
Heidl | 0:d1960beb98fe | 3036 | int16_t MPU6050::getXAccelOffset() |
Heidl | 0:d1960beb98fe | 3037 | { |
Heidl | 0:d1960beb98fe | 3038 | i2Cdev.readBytes(devAddr, MPU6050_RA_XA_OFFS_H, 2, buffer); |
Heidl | 0:d1960beb98fe | 3039 | return (((int16_t)buffer[0]) << 8) | buffer[1]; |
Heidl | 0:d1960beb98fe | 3040 | } |
Heidl | 0:d1960beb98fe | 3041 | void MPU6050::setXAccelOffset(int16_t offset) |
Heidl | 0:d1960beb98fe | 3042 | { |
Heidl | 0:d1960beb98fe | 3043 | i2Cdev.writeWord(devAddr, MPU6050_RA_XA_OFFS_H, offset); |
Heidl | 0:d1960beb98fe | 3044 | } |
Heidl | 0:d1960beb98fe | 3045 | |
Heidl | 0:d1960beb98fe | 3046 | // YA_OFFS_* register |
Heidl | 0:d1960beb98fe | 3047 | |
Heidl | 0:d1960beb98fe | 3048 | int16_t MPU6050::getYAccelOffset() |
Heidl | 0:d1960beb98fe | 3049 | { |
Heidl | 0:d1960beb98fe | 3050 | i2Cdev.readBytes(devAddr, MPU6050_RA_YA_OFFS_H, 2, buffer); |
Heidl | 0:d1960beb98fe | 3051 | return (((int16_t)buffer[0]) << 8) | buffer[1]; |
Heidl | 0:d1960beb98fe | 3052 | } |
Heidl | 0:d1960beb98fe | 3053 | void MPU6050::setYAccelOffset(int16_t offset) |
Heidl | 0:d1960beb98fe | 3054 | { |
Heidl | 0:d1960beb98fe | 3055 | i2Cdev.writeWord(devAddr, MPU6050_RA_YA_OFFS_H, offset); |
Heidl | 0:d1960beb98fe | 3056 | } |
Heidl | 0:d1960beb98fe | 3057 | |
Heidl | 0:d1960beb98fe | 3058 | // ZA_OFFS_* register |
Heidl | 0:d1960beb98fe | 3059 | |
Heidl | 0:d1960beb98fe | 3060 | int16_t MPU6050::getZAccelOffset() |
Heidl | 0:d1960beb98fe | 3061 | { |
Heidl | 0:d1960beb98fe | 3062 | i2Cdev.readBytes(devAddr, MPU6050_RA_ZA_OFFS_H, 2, buffer); |
Heidl | 0:d1960beb98fe | 3063 | return (((int16_t)buffer[0]) << 8) | buffer[1]; |
Heidl | 0:d1960beb98fe | 3064 | } |
Heidl | 0:d1960beb98fe | 3065 | void MPU6050::setZAccelOffset(int16_t offset) |
Heidl | 0:d1960beb98fe | 3066 | { |
Heidl | 0:d1960beb98fe | 3067 | i2Cdev.writeWord(devAddr, MPU6050_RA_ZA_OFFS_H, offset); |
Heidl | 0:d1960beb98fe | 3068 | } |
Heidl | 0:d1960beb98fe | 3069 | |
Heidl | 0:d1960beb98fe | 3070 | // XG_OFFS_USR* registers |
Heidl | 0:d1960beb98fe | 3071 | |
Heidl | 0:d1960beb98fe | 3072 | int16_t MPU6050::getXGyroOffsetUser() |
Heidl | 0:d1960beb98fe | 3073 | { |
Heidl | 0:d1960beb98fe | 3074 | i2Cdev.readBytes(devAddr, MPU6050_RA_XG_OFFS_USRH, 2, buffer); |
Heidl | 0:d1960beb98fe | 3075 | return (((int16_t)buffer[0]) << 8) | buffer[1]; |
Heidl | 0:d1960beb98fe | 3076 | } |
Heidl | 0:d1960beb98fe | 3077 | void MPU6050::setXGyroOffsetUser(int16_t offset) |
Heidl | 0:d1960beb98fe | 3078 | { |
Heidl | 0:d1960beb98fe | 3079 | i2Cdev.writeWord(devAddr, MPU6050_RA_XG_OFFS_USRH, offset); |
Heidl | 0:d1960beb98fe | 3080 | } |
Heidl | 0:d1960beb98fe | 3081 | |
Heidl | 0:d1960beb98fe | 3082 | // YG_OFFS_USR* register |
Heidl | 0:d1960beb98fe | 3083 | |
Heidl | 0:d1960beb98fe | 3084 | int16_t MPU6050::getYGyroOffsetUser() |
Heidl | 0:d1960beb98fe | 3085 | { |
Heidl | 0:d1960beb98fe | 3086 | i2Cdev.readBytes(devAddr, MPU6050_RA_YG_OFFS_USRH, 2, buffer); |
Heidl | 0:d1960beb98fe | 3087 | return (((int16_t)buffer[0]) << 8) | buffer[1]; |
Heidl | 0:d1960beb98fe | 3088 | } |
Heidl | 0:d1960beb98fe | 3089 | void MPU6050::setYGyroOffsetUser(int16_t offset) |
Heidl | 0:d1960beb98fe | 3090 | { |
Heidl | 0:d1960beb98fe | 3091 | i2Cdev.writeWord(devAddr, MPU6050_RA_YG_OFFS_USRH, offset); |
Heidl | 0:d1960beb98fe | 3092 | } |
Heidl | 0:d1960beb98fe | 3093 | |
Heidl | 0:d1960beb98fe | 3094 | // ZG_OFFS_USR* register |
Heidl | 0:d1960beb98fe | 3095 | |
Heidl | 0:d1960beb98fe | 3096 | int16_t MPU6050::getZGyroOffsetUser() |
Heidl | 0:d1960beb98fe | 3097 | { |
Heidl | 0:d1960beb98fe | 3098 | i2Cdev.readBytes(devAddr, MPU6050_RA_ZG_OFFS_USRH, 2, buffer); |
Heidl | 0:d1960beb98fe | 3099 | return (((int16_t)buffer[0]) << 8) | buffer[1]; |
Heidl | 0:d1960beb98fe | 3100 | } |
Heidl | 0:d1960beb98fe | 3101 | void MPU6050::setZGyroOffsetUser(int16_t offset) |
Heidl | 0:d1960beb98fe | 3102 | { |
Heidl | 0:d1960beb98fe | 3103 | i2Cdev.writeWord(devAddr, MPU6050_RA_ZG_OFFS_USRH, offset); |
Heidl | 0:d1960beb98fe | 3104 | } |
Heidl | 0:d1960beb98fe | 3105 | |
Heidl | 0:d1960beb98fe | 3106 | // INT_ENABLE register (DMP functions) |
Heidl | 0:d1960beb98fe | 3107 | |
Heidl | 0:d1960beb98fe | 3108 | bool MPU6050::getIntPLLReadyEnabled() |
Heidl | 0:d1960beb98fe | 3109 | { |
Heidl | 0:d1960beb98fe | 3110 | i2Cdev.readBit(devAddr, MPU6050_RA_INT_ENABLE, MPU6050_INTERRUPT_PLL_RDY_INT_BIT, buffer); |
Heidl | 0:d1960beb98fe | 3111 | return buffer[0]; |
Heidl | 0:d1960beb98fe | 3112 | } |
Heidl | 0:d1960beb98fe | 3113 | void MPU6050::setIntPLLReadyEnabled(bool enabled) |
Heidl | 0:d1960beb98fe | 3114 | { |
Heidl | 0:d1960beb98fe | 3115 | i2Cdev.writeBit(devAddr, MPU6050_RA_INT_ENABLE, MPU6050_INTERRUPT_PLL_RDY_INT_BIT, enabled); |
Heidl | 0:d1960beb98fe | 3116 | } |
Heidl | 0:d1960beb98fe | 3117 | bool MPU6050::getIntDMPEnabled() |
Heidl | 0:d1960beb98fe | 3118 | { |
Heidl | 0:d1960beb98fe | 3119 | i2Cdev.readBit(devAddr, MPU6050_RA_INT_ENABLE, MPU6050_INTERRUPT_DMP_INT_BIT, buffer); |
Heidl | 0:d1960beb98fe | 3120 | return buffer[0]; |
Heidl | 0:d1960beb98fe | 3121 | } |
Heidl | 0:d1960beb98fe | 3122 | void MPU6050::setIntDMPEnabled(bool enabled) |
Heidl | 0:d1960beb98fe | 3123 | { |
Heidl | 0:d1960beb98fe | 3124 | i2Cdev.writeBit(devAddr, MPU6050_RA_INT_ENABLE, MPU6050_INTERRUPT_DMP_INT_BIT, enabled); |
Heidl | 0:d1960beb98fe | 3125 | } |
Heidl | 0:d1960beb98fe | 3126 | |
Heidl | 0:d1960beb98fe | 3127 | // DMP_INT_STATUS |
Heidl | 0:d1960beb98fe | 3128 | |
Heidl | 0:d1960beb98fe | 3129 | bool MPU6050::getDMPInt5Status() |
Heidl | 0:d1960beb98fe | 3130 | { |
Heidl | 0:d1960beb98fe | 3131 | i2Cdev.readBit(devAddr, MPU6050_RA_DMP_INT_STATUS, MPU6050_DMPINT_5_BIT, buffer); |
Heidl | 0:d1960beb98fe | 3132 | return buffer[0]; |
Heidl | 0:d1960beb98fe | 3133 | } |
Heidl | 0:d1960beb98fe | 3134 | bool MPU6050::getDMPInt4Status() |
Heidl | 0:d1960beb98fe | 3135 | { |
Heidl | 0:d1960beb98fe | 3136 | i2Cdev.readBit(devAddr, MPU6050_RA_DMP_INT_STATUS, MPU6050_DMPINT_4_BIT, buffer); |
Heidl | 0:d1960beb98fe | 3137 | return buffer[0]; |
Heidl | 0:d1960beb98fe | 3138 | } |
Heidl | 0:d1960beb98fe | 3139 | bool MPU6050::getDMPInt3Status() |
Heidl | 0:d1960beb98fe | 3140 | { |
Heidl | 0:d1960beb98fe | 3141 | i2Cdev.readBit(devAddr, MPU6050_RA_DMP_INT_STATUS, MPU6050_DMPINT_3_BIT, buffer); |
Heidl | 0:d1960beb98fe | 3142 | return buffer[0]; |
Heidl | 0:d1960beb98fe | 3143 | } |
Heidl | 0:d1960beb98fe | 3144 | bool MPU6050::getDMPInt2Status() |
Heidl | 0:d1960beb98fe | 3145 | { |
Heidl | 0:d1960beb98fe | 3146 | i2Cdev.readBit(devAddr, MPU6050_RA_DMP_INT_STATUS, MPU6050_DMPINT_2_BIT, buffer); |
Heidl | 0:d1960beb98fe | 3147 | return buffer[0]; |
Heidl | 0:d1960beb98fe | 3148 | } |
Heidl | 0:d1960beb98fe | 3149 | bool MPU6050::getDMPInt1Status() |
Heidl | 0:d1960beb98fe | 3150 | { |
Heidl | 0:d1960beb98fe | 3151 | i2Cdev.readBit(devAddr, MPU6050_RA_DMP_INT_STATUS, MPU6050_DMPINT_1_BIT, buffer); |
Heidl | 0:d1960beb98fe | 3152 | return buffer[0]; |
Heidl | 0:d1960beb98fe | 3153 | } |
Heidl | 0:d1960beb98fe | 3154 | bool MPU6050::getDMPInt0Status() |
Heidl | 0:d1960beb98fe | 3155 | { |
Heidl | 0:d1960beb98fe | 3156 | i2Cdev.readBit(devAddr, MPU6050_RA_DMP_INT_STATUS, MPU6050_DMPINT_0_BIT, buffer); |
Heidl | 0:d1960beb98fe | 3157 | return buffer[0]; |
Heidl | 0:d1960beb98fe | 3158 | } |
Heidl | 0:d1960beb98fe | 3159 | |
Heidl | 0:d1960beb98fe | 3160 | // INT_STATUS register (DMP functions) |
Heidl | 0:d1960beb98fe | 3161 | |
Heidl | 0:d1960beb98fe | 3162 | bool MPU6050::getIntPLLReadyStatus() |
Heidl | 0:d1960beb98fe | 3163 | { |
Heidl | 0:d1960beb98fe | 3164 | i2Cdev.readBit(devAddr, MPU6050_RA_INT_STATUS, MPU6050_INTERRUPT_PLL_RDY_INT_BIT, buffer); |
Heidl | 0:d1960beb98fe | 3165 | return buffer[0]; |
Heidl | 0:d1960beb98fe | 3166 | } |
Heidl | 0:d1960beb98fe | 3167 | bool MPU6050::getIntDMPStatus() |
Heidl | 0:d1960beb98fe | 3168 | { |
Heidl | 0:d1960beb98fe | 3169 | i2Cdev.readBit(devAddr, MPU6050_RA_INT_STATUS, MPU6050_INTERRUPT_DMP_INT_BIT, buffer); |
Heidl | 0:d1960beb98fe | 3170 | return buffer[0]; |
Heidl | 0:d1960beb98fe | 3171 | } |
Heidl | 0:d1960beb98fe | 3172 | |
Heidl | 0:d1960beb98fe | 3173 | // USER_CTRL register (DMP functions) |
Heidl | 0:d1960beb98fe | 3174 | |
Heidl | 0:d1960beb98fe | 3175 | bool MPU6050::getDMPEnabled() |
Heidl | 0:d1960beb98fe | 3176 | { |
Heidl | 0:d1960beb98fe | 3177 | i2Cdev.readBit(devAddr, MPU6050_RA_USER_CTRL, MPU6050_USERCTRL_DMP_EN_BIT, buffer); |
Heidl | 0:d1960beb98fe | 3178 | return buffer[0]; |
Heidl | 0:d1960beb98fe | 3179 | } |
Heidl | 0:d1960beb98fe | 3180 | void MPU6050::setDMPEnabled(bool enabled) |
Heidl | 0:d1960beb98fe | 3181 | { |
Heidl | 0:d1960beb98fe | 3182 | i2Cdev.writeBit(devAddr, MPU6050_RA_USER_CTRL, MPU6050_USERCTRL_DMP_EN_BIT, enabled); |
Heidl | 0:d1960beb98fe | 3183 | } |
Heidl | 0:d1960beb98fe | 3184 | void MPU6050::resetDMP() |
Heidl | 0:d1960beb98fe | 3185 | { |
Heidl | 0:d1960beb98fe | 3186 | i2Cdev.writeBit(devAddr, MPU6050_RA_USER_CTRL, MPU6050_USERCTRL_DMP_RESET_BIT, true); |
Heidl | 0:d1960beb98fe | 3187 | } |
Heidl | 0:d1960beb98fe | 3188 | |
Heidl | 0:d1960beb98fe | 3189 | // BANK_SEL register |
Heidl | 0:d1960beb98fe | 3190 | |
Heidl | 0:d1960beb98fe | 3191 | void MPU6050::setMemoryBank(uint8_t bank, bool prefetchEnabled, bool userBank) |
Heidl | 0:d1960beb98fe | 3192 | { |
Heidl | 0:d1960beb98fe | 3193 | bank &= 0x1F; |
Heidl | 0:d1960beb98fe | 3194 | if (userBank) bank |= 0x20; |
Heidl | 0:d1960beb98fe | 3195 | if (prefetchEnabled) bank |= 0x40; |
Heidl | 0:d1960beb98fe | 3196 | i2Cdev.writeByte(devAddr, MPU6050_RA_BANK_SEL, bank); |
Heidl | 0:d1960beb98fe | 3197 | } |
Heidl | 0:d1960beb98fe | 3198 | |
Heidl | 0:d1960beb98fe | 3199 | // MEM_START_ADDR register |
Heidl | 0:d1960beb98fe | 3200 | |
Heidl | 0:d1960beb98fe | 3201 | void MPU6050::setMemoryStartAddress(uint8_t address) |
Heidl | 0:d1960beb98fe | 3202 | { |
Heidl | 0:d1960beb98fe | 3203 | i2Cdev.writeByte(devAddr, MPU6050_RA_MEM_START_ADDR, address); |
Heidl | 0:d1960beb98fe | 3204 | } |
Heidl | 0:d1960beb98fe | 3205 | |
Heidl | 0:d1960beb98fe | 3206 | // MEM_R_W register |
Heidl | 0:d1960beb98fe | 3207 | |
Heidl | 0:d1960beb98fe | 3208 | uint8_t MPU6050::readMemoryByte() |
Heidl | 0:d1960beb98fe | 3209 | { |
Heidl | 0:d1960beb98fe | 3210 | i2Cdev.readByte(devAddr, MPU6050_RA_MEM_R_W, buffer); |
Heidl | 0:d1960beb98fe | 3211 | return buffer[0]; |
Heidl | 0:d1960beb98fe | 3212 | } |
Heidl | 0:d1960beb98fe | 3213 | void MPU6050::writeMemoryByte(uint8_t data) |
Heidl | 0:d1960beb98fe | 3214 | { |
Heidl | 0:d1960beb98fe | 3215 | i2Cdev.writeByte(devAddr, MPU6050_RA_MEM_R_W, data); |
Heidl | 0:d1960beb98fe | 3216 | } |
Heidl | 0:d1960beb98fe | 3217 | void MPU6050::readMemoryBlock(uint8_t *data, uint16_t dataSize, uint8_t bank, uint8_t address) |
Heidl | 0:d1960beb98fe | 3218 | { |
Heidl | 0:d1960beb98fe | 3219 | setMemoryBank(bank); |
Heidl | 0:d1960beb98fe | 3220 | setMemoryStartAddress(address); |
Heidl | 0:d1960beb98fe | 3221 | uint8_t chunkSize; |
Heidl | 0:d1960beb98fe | 3222 | for (uint16_t i = 0; i < dataSize;) { |
Heidl | 0:d1960beb98fe | 3223 | // determine correct chunk size according to bank position and data size |
Heidl | 0:d1960beb98fe | 3224 | chunkSize = MPU6050_DMP_MEMORY_CHUNK_SIZE; |
Heidl | 0:d1960beb98fe | 3225 | |
Heidl | 0:d1960beb98fe | 3226 | // make sure we don't go past the data size |
Heidl | 0:d1960beb98fe | 3227 | if (i + chunkSize > dataSize) chunkSize = dataSize - i; |
Heidl | 0:d1960beb98fe | 3228 | |
Heidl | 0:d1960beb98fe | 3229 | // make sure this chunk doesn't go past the bank boundary (256 bytes) |
Heidl | 0:d1960beb98fe | 3230 | if (chunkSize > 256 - address) chunkSize = 256 - address; |
Heidl | 0:d1960beb98fe | 3231 | |
Heidl | 0:d1960beb98fe | 3232 | // read the chunk of data as specified |
Heidl | 0:d1960beb98fe | 3233 | i2Cdev.readBytes(devAddr, MPU6050_RA_MEM_R_W, chunkSize, data + i); |
Heidl | 0:d1960beb98fe | 3234 | |
Heidl | 0:d1960beb98fe | 3235 | // increase byte index by [chunkSize] |
Heidl | 0:d1960beb98fe | 3236 | i += chunkSize; |
Heidl | 0:d1960beb98fe | 3237 | |
Heidl | 0:d1960beb98fe | 3238 | // uint8_t automatically wraps to 0 at 256 |
Heidl | 0:d1960beb98fe | 3239 | address += chunkSize; |
Heidl | 0:d1960beb98fe | 3240 | |
Heidl | 0:d1960beb98fe | 3241 | // if we aren't done, update bank (if necessary) and address |
Heidl | 0:d1960beb98fe | 3242 | if (i < dataSize) { |
Heidl | 0:d1960beb98fe | 3243 | if (address == 0) bank++; |
Heidl | 0:d1960beb98fe | 3244 | setMemoryBank(bank); |
Heidl | 0:d1960beb98fe | 3245 | setMemoryStartAddress(address); |
Heidl | 0:d1960beb98fe | 3246 | } |
Heidl | 0:d1960beb98fe | 3247 | } |
Heidl | 0:d1960beb98fe | 3248 | } |
Heidl | 0:d1960beb98fe | 3249 | bool MPU6050::writeMemoryBlock(const uint8_t *data, uint16_t dataSize, uint8_t bank, uint8_t address, bool verify, bool useProgMem) |
Heidl | 0:d1960beb98fe | 3250 | { |
Heidl | 0:d1960beb98fe | 3251 | setMemoryBank(bank); |
Heidl | 0:d1960beb98fe | 3252 | setMemoryStartAddress(address); |
Heidl | 0:d1960beb98fe | 3253 | uint8_t chunkSize; |
Heidl | 0:d1960beb98fe | 3254 | uint8_t *verifyBuffer; |
Heidl | 0:d1960beb98fe | 3255 | uint8_t *progBuffer; |
Heidl | 0:d1960beb98fe | 3256 | uint16_t i; |
Heidl | 0:d1960beb98fe | 3257 | uint8_t j; |
Heidl | 0:d1960beb98fe | 3258 | if (verify) verifyBuffer = (uint8_t *)malloc(MPU6050_DMP_MEMORY_CHUNK_SIZE); |
Heidl | 0:d1960beb98fe | 3259 | if (useProgMem) progBuffer = (uint8_t *)malloc(MPU6050_DMP_MEMORY_CHUNK_SIZE); |
Heidl | 0:d1960beb98fe | 3260 | for (i = 0; i < dataSize;) { |
Heidl | 0:d1960beb98fe | 3261 | // determine correct chunk size according to bank position and data size |
Heidl | 0:d1960beb98fe | 3262 | chunkSize = MPU6050_DMP_MEMORY_CHUNK_SIZE; |
Heidl | 0:d1960beb98fe | 3263 | |
Heidl | 0:d1960beb98fe | 3264 | // make sure we don't go past the data size |
Heidl | 0:d1960beb98fe | 3265 | if (i + chunkSize > dataSize) chunkSize = dataSize - i; |
Heidl | 0:d1960beb98fe | 3266 | |
Heidl | 0:d1960beb98fe | 3267 | // make sure this chunk doesn't go past the bank boundary (256 bytes) |
Heidl | 0:d1960beb98fe | 3268 | if (chunkSize > 256 - address) chunkSize = 256 - address; |
Heidl | 0:d1960beb98fe | 3269 | |
Heidl | 0:d1960beb98fe | 3270 | if (useProgMem) { |
Heidl | 0:d1960beb98fe | 3271 | // write the chunk of data as specified |
Heidl | 0:d1960beb98fe | 3272 | for (j = 0; j < chunkSize; j++) progBuffer[j] = pgm_read_byte(data + i + j); |
Heidl | 0:d1960beb98fe | 3273 | } else { |
Heidl | 0:d1960beb98fe | 3274 | // write the chunk of data as specified |
Heidl | 0:d1960beb98fe | 3275 | progBuffer = (uint8_t *)data + i; |
Heidl | 0:d1960beb98fe | 3276 | } |
Heidl | 0:d1960beb98fe | 3277 | |
Heidl | 0:d1960beb98fe | 3278 | i2Cdev.writeBytes(devAddr, MPU6050_RA_MEM_R_W, chunkSize, progBuffer); |
Heidl | 0:d1960beb98fe | 3279 | |
Heidl | 0:d1960beb98fe | 3280 | // verify data if needed |
Heidl | 0:d1960beb98fe | 3281 | if (verify && verifyBuffer) { |
Heidl | 0:d1960beb98fe | 3282 | setMemoryBank(bank); |
Heidl | 0:d1960beb98fe | 3283 | setMemoryStartAddress(address); |
Heidl | 0:d1960beb98fe | 3284 | i2Cdev.readBytes(devAddr, MPU6050_RA_MEM_R_W, chunkSize, verifyBuffer); |
Heidl | 0:d1960beb98fe | 3285 | if (memcmp(progBuffer, verifyBuffer, chunkSize) != 0) { |
Heidl | 0:d1960beb98fe | 3286 | /*Serial.print("Block write verification error, bank "); |
Heidl | 0:d1960beb98fe | 3287 | Serial.print(bank, DEC); |
Heidl | 0:d1960beb98fe | 3288 | Serial.print(", address "); |
Heidl | 0:d1960beb98fe | 3289 | Serial.print(address, DEC); |
Heidl | 0:d1960beb98fe | 3290 | Serial.print("!\nExpected:"); |
Heidl | 0:d1960beb98fe | 3291 | for (j = 0; j < chunkSize; j++) { |
Heidl | 0:d1960beb98fe | 3292 | Serial.print(" 0x"); |
Heidl | 0:d1960beb98fe | 3293 | if (progBuffer[j] < 16) Serial.print("0"); |
Heidl | 0:d1960beb98fe | 3294 | Serial.print(progBuffer[j], HEX); |
Heidl | 0:d1960beb98fe | 3295 | } |
Heidl | 0:d1960beb98fe | 3296 | Serial.print("\nReceived:"); |
Heidl | 0:d1960beb98fe | 3297 | for (uint8_t j = 0; j < chunkSize; j++) { |
Heidl | 0:d1960beb98fe | 3298 | Serial.print(" 0x"); |
Heidl | 0:d1960beb98fe | 3299 | if (verifyBuffer[i + j] < 16) Serial.print("0"); |
Heidl | 0:d1960beb98fe | 3300 | Serial.print(verifyBuffer[i + j], HEX); |
Heidl | 0:d1960beb98fe | 3301 | } |
Heidl | 0:d1960beb98fe | 3302 | Serial.print("\n");*/ |
Heidl | 0:d1960beb98fe | 3303 | free(verifyBuffer); |
Heidl | 0:d1960beb98fe | 3304 | if (useProgMem) free(progBuffer); |
Heidl | 0:d1960beb98fe | 3305 | return false; // uh oh. |
Heidl | 0:d1960beb98fe | 3306 | } |
Heidl | 0:d1960beb98fe | 3307 | } |
Heidl | 0:d1960beb98fe | 3308 | |
Heidl | 0:d1960beb98fe | 3309 | // increase byte index by [chunkSize] |
Heidl | 0:d1960beb98fe | 3310 | i += chunkSize; |
Heidl | 0:d1960beb98fe | 3311 | |
Heidl | 0:d1960beb98fe | 3312 | // uint8_t automatically wraps to 0 at 256 |
Heidl | 0:d1960beb98fe | 3313 | address += chunkSize; |
Heidl | 0:d1960beb98fe | 3314 | |
Heidl | 0:d1960beb98fe | 3315 | // if we aren't done, update bank (if necessary) and address |
Heidl | 0:d1960beb98fe | 3316 | if (i < dataSize) { |
Heidl | 0:d1960beb98fe | 3317 | if (address == 0) bank++; |
Heidl | 0:d1960beb98fe | 3318 | setMemoryBank(bank); |
Heidl | 0:d1960beb98fe | 3319 | setMemoryStartAddress(address); |
Heidl | 0:d1960beb98fe | 3320 | } |
Heidl | 0:d1960beb98fe | 3321 | } |
Heidl | 0:d1960beb98fe | 3322 | if (verify) free(verifyBuffer); |
Heidl | 0:d1960beb98fe | 3323 | if (useProgMem) free(progBuffer); |
Heidl | 0:d1960beb98fe | 3324 | return true; |
Heidl | 0:d1960beb98fe | 3325 | } |
Heidl | 0:d1960beb98fe | 3326 | bool MPU6050::writeProgMemoryBlock(const uint8_t *data, uint16_t dataSize, uint8_t bank, uint8_t address, bool verify) |
Heidl | 0:d1960beb98fe | 3327 | { |
Heidl | 0:d1960beb98fe | 3328 | return writeMemoryBlock(data, dataSize, bank, address, verify, true); |
Heidl | 0:d1960beb98fe | 3329 | } |
Heidl | 0:d1960beb98fe | 3330 | bool MPU6050::writeDMPConfigurationSet(const uint8_t *data, uint16_t dataSize, bool useProgMem) |
Heidl | 0:d1960beb98fe | 3331 | { |
Heidl | 0:d1960beb98fe | 3332 | uint8_t *progBuffer, success, special; |
Heidl | 0:d1960beb98fe | 3333 | uint16_t i, j; |
Heidl | 0:d1960beb98fe | 3334 | if (useProgMem) { |
Heidl | 0:d1960beb98fe | 3335 | progBuffer = (uint8_t *)malloc(8); // assume 8-byte blocks, realloc later if necessary |
Heidl | 0:d1960beb98fe | 3336 | } |
Heidl | 0:d1960beb98fe | 3337 | |
Heidl | 0:d1960beb98fe | 3338 | // config set data is a long string of blocks with the following structure: |
Heidl | 0:d1960beb98fe | 3339 | // [bank] [offset] [length] [byte[0], byte[1], ..., byte[length]] |
Heidl | 0:d1960beb98fe | 3340 | uint8_t bank, offset, length; |
Heidl | 0:d1960beb98fe | 3341 | for (i = 0; i < dataSize;) { |
Heidl | 0:d1960beb98fe | 3342 | if (useProgMem) { |
Heidl | 0:d1960beb98fe | 3343 | bank = pgm_read_byte(data + i++); |
Heidl | 0:d1960beb98fe | 3344 | offset = pgm_read_byte(data + i++); |
Heidl | 0:d1960beb98fe | 3345 | length = pgm_read_byte(data + i++); |
Heidl | 0:d1960beb98fe | 3346 | } else { |
Heidl | 0:d1960beb98fe | 3347 | bank = data[i++]; |
Heidl | 0:d1960beb98fe | 3348 | offset = data[i++]; |
Heidl | 0:d1960beb98fe | 3349 | length = data[i++]; |
Heidl | 0:d1960beb98fe | 3350 | } |
Heidl | 0:d1960beb98fe | 3351 | |
Heidl | 0:d1960beb98fe | 3352 | // write data or perform special action |
Heidl | 0:d1960beb98fe | 3353 | if (length > 0) { |
Heidl | 0:d1960beb98fe | 3354 | // regular block of data to write |
Heidl | 0:d1960beb98fe | 3355 | /*Serial.print("Writing config block to bank "); |
Heidl | 0:d1960beb98fe | 3356 | Serial.print(bank); |
Heidl | 0:d1960beb98fe | 3357 | Serial.print(", offset "); |
Heidl | 0:d1960beb98fe | 3358 | Serial.print(offset); |
Heidl | 0:d1960beb98fe | 3359 | Serial.print(", length="); |
Heidl | 0:d1960beb98fe | 3360 | Serial.println(length);*/ |
Heidl | 0:d1960beb98fe | 3361 | if (useProgMem) { |
Heidl | 0:d1960beb98fe | 3362 | if (sizeof(progBuffer) < length) progBuffer = (uint8_t *)realloc(progBuffer, length); |
Heidl | 0:d1960beb98fe | 3363 | for (j = 0; j < length; j++) progBuffer[j] = pgm_read_byte(data + i + j); |
Heidl | 0:d1960beb98fe | 3364 | } else { |
Heidl | 0:d1960beb98fe | 3365 | progBuffer = (uint8_t *)data + i; |
Heidl | 0:d1960beb98fe | 3366 | } |
Heidl | 0:d1960beb98fe | 3367 | success = writeMemoryBlock(progBuffer, length, bank, offset, true); |
Heidl | 0:d1960beb98fe | 3368 | i += length; |
Heidl | 0:d1960beb98fe | 3369 | } else { |
Heidl | 0:d1960beb98fe | 3370 | // special instruction |
Heidl | 0:d1960beb98fe | 3371 | // NOTE: this kind of behavior (what and when to do certain things) |
Heidl | 0:d1960beb98fe | 3372 | // is totally undocumented. This code is in here based on observed |
Heidl | 0:d1960beb98fe | 3373 | // behavior only, and exactly why (or even whether) it has to be here |
Heidl | 0:d1960beb98fe | 3374 | // is anybody's guess for now. |
Heidl | 0:d1960beb98fe | 3375 | if (useProgMem) { |
Heidl | 0:d1960beb98fe | 3376 | special = pgm_read_byte(data + i++); |
Heidl | 0:d1960beb98fe | 3377 | } else { |
Heidl | 0:d1960beb98fe | 3378 | special = data[i++]; |
Heidl | 0:d1960beb98fe | 3379 | } |
Heidl | 0:d1960beb98fe | 3380 | /*Serial.print("Special command code "); |
Heidl | 0:d1960beb98fe | 3381 | Serial.print(special, HEX); |
Heidl | 0:d1960beb98fe | 3382 | Serial.println(" found...");*/ |
Heidl | 0:d1960beb98fe | 3383 | if (special == 0x01) { |
Heidl | 0:d1960beb98fe | 3384 | // enable DMP-related interrupts |
Heidl | 0:d1960beb98fe | 3385 | |
Heidl | 0:d1960beb98fe | 3386 | //setIntZeroMotionEnabled(true); |
Heidl | 0:d1960beb98fe | 3387 | //setIntFIFOBufferOverflowEnabled(true); |
Heidl | 0:d1960beb98fe | 3388 | //setIntDMPEnabled(true); |
Heidl | 0:d1960beb98fe | 3389 | i2Cdev.writeByte(devAddr, MPU6050_RA_INT_ENABLE, 0x32); // single operation |
Heidl | 0:d1960beb98fe | 3390 | |
Heidl | 0:d1960beb98fe | 3391 | success = true; |
Heidl | 0:d1960beb98fe | 3392 | } else { |
Heidl | 0:d1960beb98fe | 3393 | // unknown special command |
Heidl | 0:d1960beb98fe | 3394 | success = false; |
Heidl | 0:d1960beb98fe | 3395 | } |
Heidl | 0:d1960beb98fe | 3396 | } |
Heidl | 0:d1960beb98fe | 3397 | |
Heidl | 0:d1960beb98fe | 3398 | if (!success) { |
Heidl | 0:d1960beb98fe | 3399 | if (useProgMem) free(progBuffer); |
Heidl | 0:d1960beb98fe | 3400 | return false; // uh oh |
Heidl | 0:d1960beb98fe | 3401 | } |
Heidl | 0:d1960beb98fe | 3402 | } |
Heidl | 0:d1960beb98fe | 3403 | if (useProgMem) free(progBuffer); |
Heidl | 0:d1960beb98fe | 3404 | return true; |
Heidl | 0:d1960beb98fe | 3405 | } |
Heidl | 0:d1960beb98fe | 3406 | bool MPU6050::writeProgDMPConfigurationSet(const uint8_t *data, uint16_t dataSize) |
Heidl | 0:d1960beb98fe | 3407 | { |
Heidl | 0:d1960beb98fe | 3408 | return writeDMPConfigurationSet(data, dataSize, false); |
Heidl | 0:d1960beb98fe | 3409 | } |
Heidl | 0:d1960beb98fe | 3410 | |
Heidl | 0:d1960beb98fe | 3411 | // DMP_CFG_1 register |
Heidl | 0:d1960beb98fe | 3412 | |
Heidl | 0:d1960beb98fe | 3413 | uint8_t MPU6050::getDMPConfig1() |
Heidl | 0:d1960beb98fe | 3414 | { |
Heidl | 0:d1960beb98fe | 3415 | i2Cdev.readByte(devAddr, MPU6050_RA_DMP_CFG_1, buffer); |
Heidl | 0:d1960beb98fe | 3416 | return buffer[0]; |
Heidl | 0:d1960beb98fe | 3417 | } |
Heidl | 0:d1960beb98fe | 3418 | void MPU6050::setDMPConfig1(uint8_t config) |
Heidl | 0:d1960beb98fe | 3419 | { |
Heidl | 0:d1960beb98fe | 3420 | i2Cdev.writeByte(devAddr, MPU6050_RA_DMP_CFG_1, config); |
Heidl | 0:d1960beb98fe | 3421 | } |
Heidl | 0:d1960beb98fe | 3422 | |
Heidl | 0:d1960beb98fe | 3423 | // DMP_CFG_2 register |
Heidl | 0:d1960beb98fe | 3424 | |
Heidl | 0:d1960beb98fe | 3425 | uint8_t MPU6050::getDMPConfig2() |
Heidl | 0:d1960beb98fe | 3426 | { |
Heidl | 0:d1960beb98fe | 3427 | i2Cdev.readByte(devAddr, MPU6050_RA_DMP_CFG_2, buffer); |
Heidl | 0:d1960beb98fe | 3428 | return buffer[0]; |
Heidl | 0:d1960beb98fe | 3429 | } |
Heidl | 0:d1960beb98fe | 3430 | void MPU6050::setDMPConfig2(uint8_t config) |
Heidl | 0:d1960beb98fe | 3431 | { |
Heidl | 0:d1960beb98fe | 3432 | i2Cdev.writeByte(devAddr, MPU6050_RA_DMP_CFG_2, config); |
Heidl | 0:d1960beb98fe | 3433 | } |