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