Skip to content

HTTPS clone URL

Subversion checkout URL

You can clone with HTTPS or Subversion.

Download ZIP
Browse files

first

  • Loading branch information...
commit 07c2fe087dc6dbaf4bb0e2828a603f2f761eee95 0 parents
aaron authored
33 README.txt
@@ -0,0 +1,33 @@
+These are the most up to date hardware and firmware files for the [MPU-9150 Breakout](https://www.sparkfun.com/products/11486) at SparkFun Electronics.
+
+The MPU-9150 is an accelerometer, gyro, and magnetometer all in a single package with an I2C interface.
+
+The hardware directory contains the Eagle design files and the firmware directory contains an Arduino library with an example that send raw sensor data out of the serial port.
+
+Hardware License
+[Creative Commons Attribution-ShareAlike](http://creativecommons.org/licenses/by-sa/3.0/)
+
+Author: Aaron Weiss @ SparkFun Electonics
+
+Firmware License
+From the original author [Jeff Rowberg](https://github.com/jrowberg/i2cdevlib) jeff@rowberg.net
+
+The Arduino library code is placed under the MIT license:
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in
+all copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
+THE SOFTWARE.
1,373 firmware/I2Cdev/I2Cdev.cpp
@@ -0,0 +1,1373 @@
+// I2Cdev library collection - Main I2C device class
+// Abstracts bit and byte I2C R/W functions into a convenient class
+// 6/9/2012 by Jeff Rowberg <jeff@rowberg.net>
+//
+// Changelog:
+// 2012-06-09 - fix major issue with reading > 32 bytes at a time with Arduino Wire
+// - add compiler warnings when using outdated or IDE or limited I2Cdev implementation
+// 2011-11-01 - fix write*Bits mask calculation (thanks sasquatch @ Arduino forums)
+// 2011-10-03 - added automatic Arduino version detection for ease of use
+// 2011-10-02 - added Gene Knight's NBWire TwoWire class implementation with small modifications
+// 2011-08-31 - added support for Arduino 1.0 Wire library (methods are different from 0.x)
+// 2011-08-03 - added optional timeout parameter to read* methods to easily change from default
+// 2011-08-02 - added support for 16-bit registers
+// - fixed incorrect Doxygen comments on some methods
+// - added timeout value for read operations (thanks mem @ Arduino forums)
+// 2011-07-30 - changed read/write function structures to return success or byte counts
+// - made all methods static for multi-device memory savings
+// 2011-07-28 - initial release
+
+/* ============================================
+I2Cdev device library code is placed under the MIT license
+Copyright (c) 2012 Jeff Rowberg
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in
+all copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
+THE SOFTWARE.
+===============================================
+*/
+
+#include "I2Cdev.h"
+
+#if I2CDEV_IMPLEMENTATION == I2CDEV_ARDUINO_WIRE
+
+ #ifdef I2CDEV_IMPLEMENTATION_WARNINGS
+ #if ARDUINO < 100
+ #warning Using outdated Arduino IDE with Wire library is functionally limiting.
+ #warning Arduino IDE v1.0.1+ with I2Cdev Fastwire implementation is recommended.
+ #warning This I2Cdev implementation does not support:
+ #warning - Repeated starts conditions
+ #warning - Timeout detection (some Wire requests block forever)
+ #elif ARDUINO == 100
+ #warning Using outdated Arduino IDE with Wire library is functionally limiting.
+ #warning Arduino IDE v1.0.1+ with I2Cdev Fastwire implementation is recommended.
+ #warning This I2Cdev implementation does not support:
+ #warning - Repeated starts conditions
+ #warning - Timeout detection (some Wire requests block forever)
+ #elif ARDUINO > 100
+ /*
+ #warning Using current Arduino IDE with Wire library is functionally limiting.
+ #warning Arduino IDE v1.0.1+ with I2CDEV_BUILTIN_FASTWIRE implementation is recommended.
+ #warning This I2Cdev implementation does not support:
+ #warning - Timeout detection (some Wire requests block forever)
+ */
+ #endif
+ #endif
+
+#elif I2CDEV_IMPLEMENTATION == I2CDEV_BUILTIN_FASTWIRE
+
+ #error The I2CDEV_BUILTIN_FASTWIRE implementation is known to be broken right now. Patience, Iago!
+
+#elif I2CDEV_IMPLEMENTATION == I2CDEV_BUILTIN_NBWIRE
+
+ #ifdef I2CDEV_IMPLEMENTATION_WARNINGS
+ #warning Using I2CDEV_BUILTIN_NBWIRE implementation may adversely affect interrupt detection.
+ #warning This I2Cdev implementation does not support:
+ #warning - Repeated starts conditions
+ #endif
+
+ // NBWire implementation based heavily on code by Gene Knight <Gene@Telobot.com>
+ // Originally posted on the Arduino forum at http://arduino.cc/forum/index.php/topic,70705.0.html
+ // Originally offered to the i2cdevlib project at http://arduino.cc/forum/index.php/topic,68210.30.html
+ TwoWire Wire;
+
+#endif
+
+/** Default constructor.
+ */
+I2Cdev::I2Cdev() {
+}
+
+/** Read a single bit from an 8-bit device register.
+ * @param devAddr I2C slave device address
+ * @param regAddr Register regAddr to read from
+ * @param bitNum Bit position to read (0-7)
+ * @param data Container for single bit value
+ * @param timeout Optional read timeout in milliseconds (0 to disable, leave off to use default class value in I2Cdev::readTimeout)
+ * @return Status of read operation (true = success)
+ */
+int8_t I2Cdev::readBit(uint8_t devAddr, uint8_t regAddr, uint8_t bitNum, uint8_t *data, uint16_t timeout) {
+ uint8_t b;
+ uint8_t count = readByte(devAddr, regAddr, &b, timeout);
+ *data = b & (1 << bitNum);
+ return count;
+}
+
+/** Read a single bit from a 16-bit device register.
+ * @param devAddr I2C slave device address
+ * @param regAddr Register regAddr to read from
+ * @param bitNum Bit position to read (0-15)
+ * @param data Container for single bit value
+ * @param timeout Optional read timeout in milliseconds (0 to disable, leave off to use default class value in I2Cdev::readTimeout)
+ * @return Status of read operation (true = success)
+ */
+int8_t I2Cdev::readBitW(uint8_t devAddr, uint8_t regAddr, uint8_t bitNum, uint16_t *data, uint16_t timeout) {
+ uint16_t b;
+ uint8_t count = readWord(devAddr, regAddr, &b, timeout);
+ *data = b & (1 << bitNum);
+ return count;
+}
+
+/** Read multiple bits from an 8-bit device register.
+ * @param devAddr I2C slave device address
+ * @param regAddr Register regAddr to read from
+ * @param bitStart First bit position to read (0-7)
+ * @param length Number of bits to read (not more than 8)
+ * @param data Container for right-aligned value (i.e. '101' read from any bitStart position will equal 0x05)
+ * @param timeout Optional read timeout in milliseconds (0 to disable, leave off to use default class value in I2Cdev::readTimeout)
+ * @return Status of read operation (true = success)
+ */
+int8_t I2Cdev::readBits(uint8_t devAddr, uint8_t regAddr, uint8_t bitStart, uint8_t length, uint8_t *data, uint16_t timeout) {
+ // 01101001 read byte
+ // 76543210 bit numbers
+ // xxx args: bitStart=4, length=3
+ // 010 masked
+ // -> 010 shifted
+ uint8_t count, b;
+ if ((count = readByte(devAddr, regAddr, &b, timeout)) != 0) {
+ uint8_t mask = ((1 << length) - 1) << (bitStart - length + 1);
+ b &= mask;
+ b >>= (bitStart - length + 1);
+ *data = b;
+ }
+ return count;
+}
+
+/** Read multiple bits from a 16-bit device register.
+ * @param devAddr I2C slave device address
+ * @param regAddr Register regAddr to read from
+ * @param bitStart First bit position to read (0-15)
+ * @param length Number of bits to read (not more than 16)
+ * @param data Container for right-aligned value (i.e. '101' read from any bitStart position will equal 0x05)
+ * @param timeout Optional read timeout in milliseconds (0 to disable, leave off to use default class value in I2Cdev::readTimeout)
+ * @return Status of read operation (1 = success, 0 = failure, -1 = timeout)
+ */
+int8_t I2Cdev::readBitsW(uint8_t devAddr, uint8_t regAddr, uint8_t bitStart, uint8_t length, uint16_t *data, uint16_t timeout) {
+ // 1101011001101001 read byte
+ // fedcba9876543210 bit numbers
+ // xxx args: bitStart=12, length=3
+ // 010 masked
+ // -> 010 shifted
+ uint8_t count;
+ uint16_t w;
+ if ((count = readWord(devAddr, regAddr, &w, timeout)) != 0) {
+ uint16_t mask = ((1 << length) - 1) << (bitStart - length + 1);
+ w &= mask;
+ w >>= (bitStart - length + 1);
+ *data = w;
+ }
+ return count;
+}
+
+/** Read single byte from an 8-bit device register.
+ * @param devAddr I2C slave device address
+ * @param regAddr Register regAddr to read from
+ * @param data Container for byte value read from device
+ * @param timeout Optional read timeout in milliseconds (0 to disable, leave off to use default class value in I2Cdev::readTimeout)
+ * @return Status of read operation (true = success)
+ */
+int8_t I2Cdev::readByte(uint8_t devAddr, uint8_t regAddr, uint8_t *data, uint16_t timeout) {
+ return readBytes(devAddr, regAddr, 1, data, timeout);
+}
+
+/** Read single word from a 16-bit device register.
+ * @param devAddr I2C slave device address
+ * @param regAddr Register regAddr to read from
+ * @param data Container for word value read from device
+ * @param timeout Optional read timeout in milliseconds (0 to disable, leave off to use default class value in I2Cdev::readTimeout)
+ * @return Status of read operation (true = success)
+ */
+int8_t I2Cdev::readWord(uint8_t devAddr, uint8_t regAddr, uint16_t *data, uint16_t timeout) {
+ return readWords(devAddr, regAddr, 1, data, timeout);
+}
+
+/** Read multiple bytes from an 8-bit device register.
+ * @param devAddr I2C slave device address
+ * @param regAddr First register regAddr to read from
+ * @param length Number of bytes to read
+ * @param data Buffer to store read data in
+ * @param timeout Optional read timeout in milliseconds (0 to disable, leave off to use default class value in I2Cdev::readTimeout)
+ * @return Number of bytes read (-1 indicates failure)
+ */
+int8_t I2Cdev::readBytes(uint8_t devAddr, uint8_t regAddr, uint8_t length, uint8_t *data, uint16_t timeout) {
+ #ifdef I2CDEV_SERIAL_DEBUG
+ Serial.print("I2C (0x");
+ Serial.print(devAddr, HEX);
+ Serial.print(") reading ");
+ Serial.print(length, DEC);
+ Serial.print(" bytes from 0x");
+ Serial.print(regAddr, HEX);
+ Serial.print("...");
+ #endif
+
+ int8_t count = 0;
+ uint32_t t1 = millis();
+
+ #if (I2CDEV_IMPLEMENTATION == I2CDEV_ARDUINO_WIRE)
+
+ #if (ARDUINO < 100)
+ // Arduino v00xx (before v1.0), Wire library
+
+ // I2C/TWI subsystem uses internal buffer that breaks with large data requests
+ // so if user requests more than BUFFER_LENGTH bytes, we have to do it in
+ // smaller chunks instead of all at once
+ for (uint8_t k = 0; k < length; k += min(length, BUFFER_LENGTH)) {
+ Wire.beginTransmission(devAddr);
+ Wire.send(regAddr);
+ Wire.endTransmission();
+ Wire.beginTransmission(devAddr);
+ Wire.requestFrom(devAddr, (uint8_t)min(length - k, BUFFER_LENGTH));
+
+ for (; Wire.available() && (timeout == 0 || millis() - t1 < timeout); count++) {
+ data[count] = Wire.receive();
+ #ifdef I2CDEV_SERIAL_DEBUG
+ Serial.print(data[count], HEX);
+ if (count + 1 < length) Serial.print(" ");
+ #endif
+ }
+
+ Wire.endTransmission();
+ }
+ #elif (ARDUINO == 100)
+ // Arduino v1.0.0, Wire library
+ // Adds standardized write() and read() stream methods instead of send() and receive()
+
+ // I2C/TWI subsystem uses internal buffer that breaks with large data requests
+ // so if user requests more than BUFFER_LENGTH bytes, we have to do it in
+ // smaller chunks instead of all at once
+ for (uint8_t k = 0; k < length; k += min(length, BUFFER_LENGTH)) {
+ Wire.beginTransmission(devAddr);
+ Wire.write(regAddr);
+ Wire.endTransmission();
+ Wire.beginTransmission(devAddr);
+ Wire.requestFrom(devAddr, (uint8_t)min(length - k, BUFFER_LENGTH));
+
+ for (; Wire.available() && (timeout == 0 || millis() - t1 < timeout); count++) {
+ data[count] = Wire.read();
+ #ifdef I2CDEV_SERIAL_DEBUG
+ Serial.print(data[count], HEX);
+ if (count + 1 < length) Serial.print(" ");
+ #endif
+ }
+
+ Wire.endTransmission();
+ }
+ #elif (ARDUINO > 100)
+ // Arduino v1.0.1+, Wire library
+ // Adds official support for repeated start condition, yay!
+
+ // I2C/TWI subsystem uses internal buffer that breaks with large data requests
+ // so if user requests more than BUFFER_LENGTH bytes, we have to do it in
+ // smaller chunks instead of all at once
+ for (uint8_t k = 0; k < length; k += min(length, BUFFER_LENGTH)) {
+ Wire.beginTransmission(devAddr);
+ Wire.write(regAddr);
+ Wire.endTransmission();
+ Wire.beginTransmission(devAddr);
+ Wire.requestFrom(devAddr, (uint8_t)min(length - k, BUFFER_LENGTH));
+
+ for (; Wire.available() && (timeout == 0 || millis() - t1 < timeout); count++) {
+ data[count] = Wire.read();
+ #ifdef I2CDEV_SERIAL_DEBUG
+ Serial.print(data[count], HEX);
+ if (count + 1 < length) Serial.print(" ");
+ #endif
+ }
+
+ Wire.endTransmission();
+ }
+ #endif
+
+ #elif (I2CDEV_IMPLEMENTATION == I2CDEV_BUILTIN_FASTWIRE)
+ // Fastwire library (STILL UNDER DEVELOPMENT, NON-FUNCTIONAL!)
+
+ // no loop required for fastwire
+ uint8_t status = Fastwire::readBuf(devAddr, regAddr, data, length);
+ if (status == 0) {
+ count = length; // success
+ } else {
+ count = -1; // error
+ }
+
+ #endif
+
+ // check for timeout
+ if (timeout > 0 && millis() - t1 >= timeout && count < length) count = -1; // timeout
+
+ #ifdef I2CDEV_SERIAL_DEBUG
+ Serial.print(". Done (");
+ Serial.print(count, DEC);
+ Serial.println(" read).");
+ #endif
+
+ return count;
+}
+
+/** Read multiple words from a 16-bit device register.
+ * @param devAddr I2C slave device address
+ * @param regAddr First register regAddr to read from
+ * @param length Number of words to read
+ * @param data Buffer to store read data in
+ * @param timeout Optional read timeout in milliseconds (0 to disable, leave off to use default class value in I2Cdev::readTimeout)
+ * @return Number of words read (0 indicates failure)
+ */
+int8_t I2Cdev::readWords(uint8_t devAddr, uint8_t regAddr, uint8_t length, uint16_t *data, uint16_t timeout) {
+ #ifdef I2CDEV_SERIAL_DEBUG
+ Serial.print("I2C (0x");
+ Serial.print(devAddr, HEX);
+ Serial.print(") reading ");
+ Serial.print(length, DEC);
+ Serial.print(" words from 0x");
+ Serial.print(regAddr, HEX);
+ Serial.print("...");
+ #endif
+
+ int8_t count = 0;
+ uint32_t t1 = millis();
+
+ #if (I2CDEV_IMPLEMENTATION == I2CDEV_ARDUINO_WIRE)
+
+ #if (ARDUINO < 100)
+ // Arduino v00xx (before v1.0), Wire library
+
+ // I2C/TWI subsystem uses internal buffer that breaks with large data requests
+ // so if user requests more than BUFFER_LENGTH bytes, we have to do it in
+ // smaller chunks instead of all at once
+ for (uint8_t k = 0; k < length * 2; k += min(length * 2, BUFFER_LENGTH)) {
+ Wire.beginTransmission(devAddr);
+ Wire.send(regAddr);
+ Wire.endTransmission();
+ Wire.beginTransmission(devAddr);
+ Wire.requestFrom(devAddr, (uint8_t)(length * 2)); // length=words, this wants bytes
+
+ bool msb = true; // starts with MSB, then LSB
+ for (; Wire.available() && count < length && (timeout == 0 || millis() - t1 < timeout);) {
+ if (msb) {
+ // first byte is bits 15-8 (MSb=15)
+ data[count] = Wire.receive() << 8;
+ } else {
+ // second byte is bits 7-0 (LSb=0)
+ data[count] |= Wire.receive();
+ #ifdef I2CDEV_SERIAL_DEBUG
+ Serial.print(data[count], HEX);
+ if (count + 1 < length) Serial.print(" ");
+ #endif
+ count++;
+ }
+ msb = !msb;
+ }
+
+ Wire.endTransmission();
+ }
+ #elif (ARDUINO == 100)
+ // Arduino v1.0.0, Wire library
+ // Adds standardized write() and read() stream methods instead of send() and receive()
+
+ // I2C/TWI subsystem uses internal buffer that breaks with large data requests
+ // so if user requests more than BUFFER_LENGTH bytes, we have to do it in
+ // smaller chunks instead of all at once
+ for (uint8_t k = 0; k < length * 2; k += min(length * 2, BUFFER_LENGTH)) {
+ Wire.beginTransmission(devAddr);
+ Wire.write(regAddr);
+ Wire.endTransmission();
+ Wire.beginTransmission(devAddr);
+ Wire.requestFrom(devAddr, (uint8_t)(length * 2)); // length=words, this wants bytes
+
+ bool msb = true; // starts with MSB, then LSB
+ for (; Wire.available() && count < length && (timeout == 0 || millis() - t1 < timeout);) {
+ if (msb) {
+ // first byte is bits 15-8 (MSb=15)
+ data[count] = Wire.read() << 8;
+ } else {
+ // second byte is bits 7-0 (LSb=0)
+ data[count] |= Wire.read();
+ #ifdef I2CDEV_SERIAL_DEBUG
+ Serial.print(data[count], HEX);
+ if (count + 1 < length) Serial.print(" ");
+ #endif
+ count++;
+ }
+ msb = !msb;
+ }
+
+ Wire.endTransmission();
+ }
+ #elif (ARDUINO > 100)
+ // Arduino v1.0.1+, Wire library
+ // Adds official support for repeated start condition, yay!
+
+ // I2C/TWI subsystem uses internal buffer that breaks with large data requests
+ // so if user requests more than BUFFER_LENGTH bytes, we have to do it in
+ // smaller chunks instead of all at once
+ for (uint8_t k = 0; k < length * 2; k += min(length * 2, BUFFER_LENGTH)) {
+ Wire.beginTransmission(devAddr);
+ Wire.write(regAddr);
+ Wire.endTransmission();
+ Wire.beginTransmission(devAddr);
+ Wire.requestFrom(devAddr, (uint8_t)(length * 2)); // length=words, this wants bytes
+
+ bool msb = true; // starts with MSB, then LSB
+ for (; Wire.available() && count < length && (timeout == 0 || millis() - t1 < timeout);) {
+ if (msb) {
+ // first byte is bits 15-8 (MSb=15)
+ data[count] = Wire.read() << 8;
+ } else {
+ // second byte is bits 7-0 (LSb=0)
+ data[count] |= Wire.read();
+ #ifdef I2CDEV_SERIAL_DEBUG
+ Serial.print(data[count], HEX);
+ if (count + 1 < length) Serial.print(" ");
+ #endif
+ count++;
+ }
+ msb = !msb;
+ }
+
+ Wire.endTransmission();
+ }
+ #endif
+
+ #elif (I2CDEV_IMPLEMENTATION == I2CDEV_BUILTIN_FASTWIRE)
+ // Fastwire library (STILL UNDER DEVELOPMENT, NON-FUNCTIONAL!)
+
+ // no loop required for fastwire
+ uint16_t intermediate[(uint8_t)length];
+ uint8_t status = Fastwire::readBuf(devAddr, regAddr, (uint8_t *)intermediate, (uint8_t)(length * 2));
+ if (status == 0) {
+ count = length; // success
+ for (uint8_t i = 0; i < length; i++) {
+ data[i] = (intermediate[2*i] << 8) | intermediate[2*i + 1];
+ }
+ } else {
+ count = -1; // error
+ }
+
+ #endif
+
+ if (timeout > 0 && millis() - t1 >= timeout && count < length) count = -1; // timeout
+
+ #ifdef I2CDEV_SERIAL_DEBUG
+ Serial.print(". Done (");
+ Serial.print(count, DEC);
+ Serial.println(" read).");
+ #endif
+
+ return count;
+}
+
+/** write a single bit in an 8-bit device register.
+ * @param devAddr I2C slave device address
+ * @param regAddr Register regAddr to write to
+ * @param bitNum Bit position to write (0-7)
+ * @param value New bit value to write
+ * @return Status of operation (true = success)
+ */
+bool I2Cdev::writeBit(uint8_t devAddr, uint8_t regAddr, uint8_t bitNum, uint8_t data) {
+ uint8_t b;
+ readByte(devAddr, regAddr, &b);
+ b = (data != 0) ? (b | (1 << bitNum)) : (b & ~(1 << bitNum));
+ return writeByte(devAddr, regAddr, b);
+}
+
+/** write a single bit in a 16-bit device register.
+ * @param devAddr I2C slave device address
+ * @param regAddr Register regAddr to write to
+ * @param bitNum Bit position to write (0-15)
+ * @param value New bit value to write
+ * @return Status of operation (true = success)
+ */
+bool I2Cdev::writeBitW(uint8_t devAddr, uint8_t regAddr, uint8_t bitNum, uint16_t data) {
+ uint16_t w;
+ readWord(devAddr, regAddr, &w);
+ w = (data != 0) ? (w | (1 << bitNum)) : (w & ~(1 << bitNum));
+ return writeWord(devAddr, regAddr, w);
+}
+
+/** Write multiple bits in an 8-bit device register.
+ * @param devAddr I2C slave device address
+ * @param regAddr Register regAddr to write to
+ * @param bitStart First bit position to write (0-7)
+ * @param length Number of bits to write (not more than 8)
+ * @param data Right-aligned value to write
+ * @return Status of operation (true = success)
+ */
+bool I2Cdev::writeBits(uint8_t devAddr, uint8_t regAddr, uint8_t bitStart, uint8_t length, uint8_t data) {
+ // 010 value to write
+ // 76543210 bit numbers
+ // xxx args: bitStart=4, length=3
+ // 00011100 mask byte
+ // 10101111 original value (sample)
+ // 10100011 original & ~mask
+ // 10101011 masked | value
+ uint8_t b;
+ if (readByte(devAddr, regAddr, &b) != 0) {
+ uint8_t mask = ((1 << length) - 1) << (bitStart - length + 1);
+ data <<= (bitStart - length + 1); // shift data into correct position
+ data &= mask; // zero all non-important bits in data
+ b &= ~(mask); // zero all important bits in existing byte
+ b |= data; // combine data with existing byte
+ return writeByte(devAddr, regAddr, b);
+ } else {
+ return false;
+ }
+}
+
+/** Write multiple bits in a 16-bit device register.
+ * @param devAddr I2C slave device address
+ * @param regAddr Register regAddr to write to
+ * @param bitStart First bit position to write (0-15)
+ * @param length Number of bits to write (not more than 16)
+ * @param data Right-aligned value to write
+ * @return Status of operation (true = success)
+ */
+bool I2Cdev::writeBitsW(uint8_t devAddr, uint8_t regAddr, uint8_t bitStart, uint8_t length, uint16_t data) {
+ // 010 value to write
+ // fedcba9876543210 bit numbers
+ // xxx args: bitStart=12, length=3
+ // 0001110000000000 mask byte
+ // 1010111110010110 original value (sample)
+ // 1010001110010110 original & ~mask
+ // 1010101110010110 masked | value
+ uint16_t w;
+ if (readWord(devAddr, regAddr, &w) != 0) {
+ uint8_t mask = ((1 << length) - 1) << (bitStart - length + 1);
+ data <<= (bitStart - length + 1); // shift data into correct position
+ data &= mask; // zero all non-important bits in data
+ w &= ~(mask); // zero all important bits in existing word
+ w |= data; // combine data with existing word
+ return writeWord(devAddr, regAddr, w);
+ } else {
+ return false;
+ }
+}
+
+/** Write single byte to an 8-bit device register.
+ * @param devAddr I2C slave device address
+ * @param regAddr Register address to write to
+ * @param data New byte value to write
+ * @return Status of operation (true = success)
+ */
+bool I2Cdev::writeByte(uint8_t devAddr, uint8_t regAddr, uint8_t data) {
+ return writeBytes(devAddr, regAddr, 1, &data);
+}
+
+/** Write single word to a 16-bit device register.
+ * @param devAddr I2C slave device address
+ * @param regAddr Register address to write to
+ * @param data New word value to write
+ * @return Status of operation (true = success)
+ */
+bool I2Cdev::writeWord(uint8_t devAddr, uint8_t regAddr, uint16_t data) {
+ return writeWords(devAddr, regAddr, 1, &data);
+}
+
+/** Write multiple bytes to an 8-bit device register.
+ * @param devAddr I2C slave device address
+ * @param regAddr First register address to write to
+ * @param length Number of bytes to write
+ * @param data Buffer to copy new data from
+ * @return Status of operation (true = success)
+ */
+bool I2Cdev::writeBytes(uint8_t devAddr, uint8_t regAddr, uint8_t length, uint8_t* data) {
+ #ifdef I2CDEV_SERIAL_DEBUG
+ Serial.print("I2C (0x");
+ Serial.print(devAddr, HEX);
+ Serial.print(") writing ");
+ Serial.print(length, DEC);
+ Serial.print(" bytes to 0x");
+ Serial.print(regAddr, HEX);
+ Serial.print("...");
+ #endif
+ uint8_t status = 0;
+ #if ((I2CDEV_IMPLEMENTATION == I2CDEV_ARDUINO_WIRE && ARDUINO < 100) || I2CDEV_IMPLEMENTATION == I2CDEV_BUILTIN_NBWIRE)
+ Wire.beginTransmission(devAddr);
+ Wire.send((uint8_t) regAddr); // send address
+ #elif (I2CDEV_IMPLEMENTATION == I2CDEV_ARDUINO_WIRE && ARDUINO >= 100)
+ Wire.beginTransmission(devAddr);
+ Wire.write((uint8_t) regAddr); // send address
+ #endif
+ for (uint8_t i = 0; i < length; i++) {
+ #if ((I2CDEV_IMPLEMENTATION == I2CDEV_ARDUINO_WIRE && ARDUINO < 100) || I2CDEV_IMPLEMENTATION == I2CDEV_BUILTIN_NBWIRE)
+ Wire.send((uint8_t) data[i]);
+ #elif (I2CDEV_IMPLEMENTATION == I2CDEV_ARDUINO_WIRE && ARDUINO >= 100)
+ Wire.write((uint8_t) data[i]);
+ #elif (I2CDEV_IMPLEMENTATION == I2CDEV_BUILTIN_FASTWIRE)
+ status = Fastwire::write(devAddr, regAddr, data[i]);
+ Serial.println(status);
+ #endif
+ #ifdef I2CDEV_SERIAL_DEBUG
+ Serial.print(data[i], HEX);
+ if (i + 1 < length) Serial.print(" ");
+ #endif
+ }
+ #if ((I2CDEV_IMPLEMENTATION == I2CDEV_ARDUINO_WIRE && ARDUINO < 100) || I2CDEV_IMPLEMENTATION == I2CDEV_BUILTIN_NBWIRE)
+ Wire.endTransmission();
+ #elif (I2CDEV_IMPLEMENTATION == I2CDEV_ARDUINO_WIRE && ARDUINO >= 100)
+ status = Wire.endTransmission();
+ #endif
+ #ifdef I2CDEV_SERIAL_DEBUG
+ Serial.println(". Done.");
+ #endif
+ return status == 0;
+}
+
+/** Write multiple words to a 16-bit device register.
+ * @param devAddr I2C slave device address
+ * @param regAddr First register address to write to
+ * @param length Number of words to write
+ * @param data Buffer to copy new data from
+ * @return Status of operation (true = success)
+ */
+bool I2Cdev::writeWords(uint8_t devAddr, uint8_t regAddr, uint8_t length, uint16_t* data) {
+ #ifdef I2CDEV_SERIAL_DEBUG
+ Serial.print("I2C (0x");
+ Serial.print(devAddr, HEX);
+ Serial.print(") writing ");
+ Serial.print(length, DEC);
+ Serial.print(" words to 0x");
+ Serial.print(regAddr, HEX);
+ Serial.print("...");
+ #endif
+ uint8_t status = 0;
+ #if ((I2CDEV_IMPLEMENTATION == I2CDEV_ARDUINO_WIRE && ARDUINO < 100) || I2CDEV_IMPLEMENTATION == I2CDEV_BUILTIN_NBWIRE)
+ Wire.beginTransmission(devAddr);
+ Wire.send(regAddr); // send address
+ #elif (I2CDEV_IMPLEMENTATION == I2CDEV_ARDUINO_WIRE && ARDUINO >= 100)
+ Wire.beginTransmission(devAddr);
+ Wire.write(regAddr); // send address
+ #endif
+ for (uint8_t i = 0; i < length * 2; i++) {
+ #if ((I2CDEV_IMPLEMENTATION == I2CDEV_ARDUINO_WIRE && ARDUINO < 100) || I2CDEV_IMPLEMENTATION == I2CDEV_BUILTIN_NBWIRE)
+ Wire.send((uint8_t)(data[i++] >> 8)); // send MSB
+ Wire.send((uint8_t)data[i]); // send LSB
+ #elif (I2CDEV_IMPLEMENTATION == I2CDEV_ARDUINO_WIRE && ARDUINO >= 100)
+ Wire.write((uint8_t)(data[i++] >> 8)); // send MSB
+ Wire.write((uint8_t)data[i]); // send LSB
+ #elif (I2CDEV_IMPLEMENTATION == I2CDEV_BUILTIN_FASTWIRE)
+ status = Fastwire::write(devAddr, regAddr, (uint8_t)(data[i++] >> 8));
+ status = Fastwire::write(devAddr, regAddr + 1, (uint8_t)data[i]);
+ #endif
+ #ifdef I2CDEV_SERIAL_DEBUG
+ Serial.print(data[i], HEX);
+ if (i + 1 < length) Serial.print(" ");
+ #endif
+ }
+ #if ((I2CDEV_IMPLEMENTATION == I2CDEV_ARDUINO_WIRE && ARDUINO < 100) || I2CDEV_IMPLEMENTATION == I2CDEV_BUILTIN_NBWIRE)
+ Wire.endTransmission();
+ #elif (I2CDEV_IMPLEMENTATION == I2CDEV_ARDUINO_WIRE && ARDUINO >= 100)
+ status = Wire.endTransmission();
+ #endif
+ #ifdef I2CDEV_SERIAL_DEBUG
+ Serial.println(". Done.");
+ #endif
+ return status == 0;
+}
+
+/** Default timeout value for read operations.
+ * Set this to 0 to disable timeout detection.
+ */
+uint16_t I2Cdev::readTimeout = I2CDEV_DEFAULT_READ_TIMEOUT;
+
+#if I2CDEV_IMPLEMENTATION == I2CDEV_BUILTIN_FASTWIRE
+ /*
+ FastWire 0.2
+ This is a library to help faster programs to read I2C devices.
+ Copyright(C) 2011 Francesco Ferrara
+ occhiobello at gmail dot com
+ */
+
+ boolean Fastwire::waitInt() {
+ int l = 250;
+ while (!(TWCR & (1 << TWINT)) && l-- > 0);
+ return l > 0;
+ }
+
+ void Fastwire::setup(int khz, boolean pullup) {
+ TWCR = 0;
+ #if defined(__AVR_ATmega168__) || defined(__AVR_ATmega8__) || defined(__AVR_ATmega328P__)
+ // activate internal pull-ups for twi (PORTC bits 4 & 5)
+ // as per note from atmega8 manual pg167
+ if (pullup) PORTC |= ((1 << 4) | (1 << 5));
+ else PORTC &= ~((1 << 4) | (1 << 5));
+ #elif defined(__AVR_ATmega644P__) || defined(__AVR_ATmega644__)
+ // activate internal pull-ups for twi (PORTC bits 0 & 1)
+ if (pullup) PORTC |= ((1 << 0) | (1 << 1));
+ else PORTC &= ~((1 << 0) | (1 << 1));
+ #else
+ // activate internal pull-ups for twi (PORTD bits 0 & 1)
+ // as per note from atmega128 manual pg204
+ if (pullup) PORTD |= ((1 << 0) | (1 << 1));
+ else PORTD &= ~((1 << 0) | (1 << 1));
+ #endif
+
+ TWSR = 0; // no prescaler => prescaler = 1
+ TWBR = ((16000L / khz) - 16) / 2; // change the I2C clock rate
+ TWCR = 1 << TWEN; // enable twi module, no interrupt
+ }
+
+ byte Fastwire::write(byte device, byte address, byte value) {
+ byte twst, retry;
+
+ retry = 2;
+ do {
+ TWCR = (1 << TWINT) | (1 << TWEN) | (1 << TWSTO) | (1 << TWSTA);
+ if (!waitInt()) return 1;
+ twst = TWSR & 0xF8;
+ if (twst != TW_START && twst != TW_REP_START) return 2;
+
+ TWDR = device & 0xFE; // send device address without read bit (1)
+ TWCR = (1 << TWINT) | (1 << TWEN);
+ if (!waitInt()) return 3;
+ twst = TWSR & 0xF8;
+ } while (twst == TW_MT_SLA_NACK && retry-- > 0);
+ if (twst != TW_MT_SLA_ACK) return 4;
+
+ TWDR = address; // send data to the previously addressed device
+ TWCR = (1 << TWINT) | (1 << TWEN);
+ if (!waitInt()) return 5;
+ twst = TWSR & 0xF8;
+ if (twst != TW_MT_DATA_ACK) return 6;
+
+ TWDR = value; // send data to the previously addressed device
+ TWCR = (1 << TWINT) | (1 << TWEN);
+ if (!waitInt()) return 7;
+ twst = TWSR & 0xF8;
+ if (twst != TW_MT_DATA_ACK) return 8;
+
+ return 0;
+ }
+
+ byte Fastwire::readBuf(byte device, byte address, byte *data, byte num) {
+ byte twst, retry;
+
+ retry = 2;
+ do {
+ TWCR = (1 << TWINT) | (1 << TWEN) | (1 << TWSTO) | (1 << TWSTA);
+ if (!waitInt()) return 16;
+ twst = TWSR & 0xF8;
+ if (twst != TW_START && twst != TW_REP_START) return 17;
+
+ TWDR = device & 0xfe; // send device address to write
+ TWCR = (1 << TWINT) | (1 << TWEN);
+ if (!waitInt()) return 18;
+ twst = TWSR & 0xF8;
+ } while (twst == TW_MT_SLA_NACK && retry-- > 0);
+ if (twst != TW_MT_SLA_ACK) return 19;
+
+ TWDR = address; // send data to the previously addressed device
+ TWCR = (1 << TWINT) | (1 << TWEN);
+ if (!waitInt()) return 20;
+ twst = TWSR & 0xF8;
+ if (twst != TW_MT_DATA_ACK) return 21;
+
+ /***/
+
+ retry = 2;
+ do {
+ TWCR = (1 << TWINT) | (1 << TWEN) | (1 << TWSTO) | (1 << TWSTA);
+ if (!waitInt()) return 22;
+ twst = TWSR & 0xF8;
+ if (twst != TW_START && twst != TW_REP_START) return 23;
+
+ TWDR = device | 0x01; // send device address with the read bit (1)
+ TWCR = (1 << TWINT) | (1 << TWEN);
+ if (!waitInt()) return 24;
+ twst = TWSR & 0xF8;
+ } while (twst == TW_MR_SLA_NACK && retry-- > 0);
+ if (twst != TW_MR_SLA_ACK) return 25;
+
+ for(uint8_t i = 0; i < num; i++) {
+ if (i == num - 1)
+ TWCR = (1 << TWINT) | (1 << TWEN);
+ else
+ TWCR = (1 << TWINT) | (1 << TWEN) | (1 << TWEA);
+ if (!waitInt()) return 26;
+ twst = TWSR & 0xF8;
+ if (twst != TW_MR_DATA_ACK && twst != TW_MR_DATA_NACK) return twst;
+ data[i] = TWDR;
+ }
+
+ return 0;
+ }
+#endif
+
+#if I2CDEV_IMPLEMENTATION == I2CDEV_BUILTIN_NBWIRE
+ // NBWire implementation based heavily on code by Gene Knight <Gene@Telobot.com>
+ // Originally posted on the Arduino forum at http://arduino.cc/forum/index.php/topic,70705.0.html
+ // Originally offered to the i2cdevlib project at http://arduino.cc/forum/index.php/topic,68210.30.html
+
+ /*
+ call this version 1.0
+
+ Offhand, the only funky part that I can think of is in nbrequestFrom, where the buffer
+ length and index are set *before* the data is actually read. The problem is that these
+ are variables local to the TwoWire object, and by the time we actually have read the
+ data, and know what the length actually is, we have no simple access to the object's
+ variables. The actual bytes read *is* given to the callback function, though.
+
+ The ISR code for a slave receiver is commented out. I don't have that setup, and can't
+ verify it at this time. Save it for 2.0!
+
+ The handling of the read and write processes here is much like in the demo sketch code:
+ the process is broken down into sequential functions, where each registers the next as a
+ callback, essentially.
+
+ For example, for the Read process, twi_read00 just returns if TWI is not yet in a
+ ready state. When there's another interrupt, and the interface *is* ready, then it
+ sets up the read, starts it, and registers twi_read01 as the function to call after
+ the *next* interrupt. twi_read01, then, just returns if the interface is still in a
+ "reading" state. When the reading is done, it copies the information to the buffer,
+ cleans up, and calls the user-requested callback function with the actual number of
+ bytes read.
+
+ The writing is similar.
+
+ Questions, comments and problems can go to Gene@Telobot.com.
+
+ Thumbs Up!
+ Gene Knight
+
+ */
+
+ uint8_t TwoWire::rxBuffer[NBWIRE_BUFFER_LENGTH];
+ uint8_t TwoWire::rxBufferIndex = 0;
+ uint8_t TwoWire::rxBufferLength = 0;
+
+ uint8_t TwoWire::txAddress = 0;
+ uint8_t TwoWire::txBuffer[NBWIRE_BUFFER_LENGTH];
+ uint8_t TwoWire::txBufferIndex = 0;
+ uint8_t TwoWire::txBufferLength = 0;
+
+ //uint8_t TwoWire::transmitting = 0;
+ void (*TwoWire::user_onRequest)(void);
+ void (*TwoWire::user_onReceive)(int);
+
+ static volatile uint8_t twi_transmitting;
+ static volatile uint8_t twi_state;
+ static uint8_t twi_slarw;
+ static volatile uint8_t twi_error;
+ static uint8_t twi_masterBuffer[TWI_BUFFER_LENGTH];
+ static volatile uint8_t twi_masterBufferIndex;
+ static uint8_t twi_masterBufferLength;
+ static uint8_t twi_rxBuffer[TWI_BUFFER_LENGTH];
+ static volatile uint8_t twi_rxBufferIndex;
+ //static volatile uint8_t twi_Interrupt_Continue_Command;
+ static volatile uint8_t twi_Return_Value;
+ static volatile uint8_t twi_Done;
+ void (*twi_cbendTransmissionDone)(int);
+ void (*twi_cbreadFromDone)(int);
+
+ void twi_init() {
+ // initialize state
+ twi_state = TWI_READY;
+
+ // activate internal pull-ups for twi
+ // as per note from atmega8 manual pg167
+ sbi(PORTC, 4);
+ sbi(PORTC, 5);
+
+ // initialize twi prescaler and bit rate
+ cbi(TWSR, TWPS0); // TWI Status Register - Prescaler bits
+ cbi(TWSR, TWPS1);
+
+ /* twi bit rate formula from atmega128 manual pg 204
+ SCL Frequency = CPU Clock Frequency / (16 + (2 * TWBR))
+ note: TWBR should be 10 or higher for master mode
+ It is 72 for a 16mhz Wiring board with 100kHz TWI */
+
+ TWBR = ((CPU_FREQ / TWI_FREQ) - 16) / 2; // bitrate register
+ // enable twi module, acks, and twi interrupt
+
+ TWCR = _BV(TWEN) | _BV(TWIE) | _BV(TWEA);
+
+ /* TWEN - TWI Enable Bit
+ TWIE - TWI Interrupt Enable
+ TWEA - TWI Enable Acknowledge Bit
+ TWINT - TWI Interrupt Flag
+ TWSTA - TWI Start Condition
+ */
+ }
+
+ typedef struct {
+ uint8_t address;
+ uint8_t* data;
+ uint8_t length;
+ uint8_t wait;
+ uint8_t i;
+ } twi_Write_Vars;
+
+ twi_Write_Vars *ptwv = 0;
+ static void (*fNextInterruptFunction)(void) = 0;
+
+ void twi_Finish(byte bRetVal) {
+ if (ptwv) {
+ free(ptwv);
+ ptwv = 0;
+ }
+ twi_Done = 0xFF;
+ twi_Return_Value = bRetVal;
+ fNextInterruptFunction = 0;
+ }
+
+ uint8_t twii_WaitForDone(uint16_t timeout) {
+ uint32_t endMillis = millis() + timeout;
+ while (!twi_Done && (timeout == 0 || millis() < endMillis)) continue;
+ return twi_Return_Value;
+ }
+
+ void twii_SetState(uint8_t ucState) {
+ twi_state = ucState;
+ }
+
+ void twii_SetError(uint8_t ucError) {
+ twi_error = ucError ;
+ }
+
+ void twii_InitBuffer(uint8_t ucPos, uint8_t ucLength) {
+ twi_masterBufferIndex = 0;
+ twi_masterBufferLength = ucLength;
+ }
+
+ void twii_CopyToBuf(uint8_t* pData, uint8_t ucLength) {
+ uint8_t i;
+ for (i = 0; i < ucLength; ++i) {
+ twi_masterBuffer[i] = pData[i];
+ }
+ }
+
+ void twii_CopyFromBuf(uint8_t *pData, uint8_t ucLength) {
+ uint8_t i;
+ for (i = 0; i < ucLength; ++i) {
+ pData[i] = twi_masterBuffer[i];
+ }
+ }
+
+ void twii_SetSlaRW(uint8_t ucSlaRW) {
+ twi_slarw = ucSlaRW;
+ }
+
+ void twii_SetStart() {
+ TWCR = _BV(TWEN) | _BV(TWIE) | _BV(TWEA) | _BV(TWINT) | _BV(TWSTA);
+ }
+
+ void twi_write01() {
+ if (TWI_MTX == twi_state) return; // blocking test
+ twi_transmitting = 0 ;
+ if (twi_error == 0xFF)
+ twi_Finish (0); // success
+ else if (twi_error == TW_MT_SLA_NACK)
+ twi_Finish (2); // error: address send, nack received
+ else if (twi_error == TW_MT_DATA_NACK)
+ twi_Finish (3); // error: data send, nack received
+ else
+ twi_Finish (4); // other twi error
+ if (twi_cbendTransmissionDone) return twi_cbendTransmissionDone(twi_Return_Value);
+ return;
+ }
+
+
+ void twi_write00() {
+ if (TWI_READY != twi_state) return; // blocking test
+ if (TWI_BUFFER_LENGTH < ptwv -> length) {
+ twi_Finish(1); // end write with error 1
+ return;
+ }
+ twi_Done = 0x00; // show as working
+ twii_SetState(TWI_MTX); // to transmitting
+ twii_SetError(0xFF); // to No Error
+ twii_InitBuffer(0, ptwv -> length); // pointer and length
+ twii_CopyToBuf(ptwv -> data, ptwv -> length); // get the data
+ twii_SetSlaRW((ptwv -> address << 1) | TW_WRITE); // write command
+ twii_SetStart(); // start the cycle
+ fNextInterruptFunction = twi_write01; // next routine
+ return twi_write01();
+ }
+
+ void twi_writeTo(uint8_t address, uint8_t* data, uint8_t length, uint8_t wait) {
+ uint8_t i;
+ ptwv = (twi_Write_Vars *)malloc(sizeof(twi_Write_Vars));
+ ptwv -> address = address;
+ ptwv -> data = data;
+ ptwv -> length = length;
+ ptwv -> wait = wait;
+ fNextInterruptFunction = twi_write00;
+ return twi_write00();
+ }
+
+ void twi_read01() {
+ if (TWI_MRX == twi_state) return; // blocking test
+ if (twi_masterBufferIndex < ptwv -> length) ptwv -> length = twi_masterBufferIndex;
+ twii_CopyFromBuf(ptwv -> data, ptwv -> length);
+ twi_Finish(ptwv -> length);
+ if (twi_cbreadFromDone) return twi_cbreadFromDone(twi_Return_Value);
+ return;
+ }
+
+ void twi_read00() {
+ if (TWI_READY != twi_state) return; // blocking test
+ if (TWI_BUFFER_LENGTH < ptwv -> length) twi_Finish(0); // error return
+ twi_Done = 0x00; // show as working
+ twii_SetState(TWI_MRX); // reading
+ twii_SetError(0xFF); // reset error
+ twii_InitBuffer(0, ptwv -> length - 1); // init to one less than length
+ twii_SetSlaRW((ptwv -> address << 1) | TW_READ); // read command
+ twii_SetStart(); // start cycle
+ fNextInterruptFunction = twi_read01;
+ return twi_read01();
+ }
+
+ void twi_readFrom(uint8_t address, uint8_t* data, uint8_t length) {
+ uint8_t i;
+
+ ptwv = (twi_Write_Vars *)malloc(sizeof(twi_Write_Vars));
+ ptwv -> address = address;
+ ptwv -> data = data;
+ ptwv -> length = length;
+ fNextInterruptFunction = twi_read00;
+ return twi_read00();
+ }
+
+ void twi_reply(uint8_t ack) {
+ // transmit master read ready signal, with or without ack
+ if (ack){
+ TWCR = _BV(TWEN) | _BV(TWIE) | _BV(TWINT) | _BV(TWEA);
+ } else {
+ TWCR = _BV(TWEN) | _BV(TWIE) | _BV(TWINT);
+ }
+ }
+
+ void twi_stop(void) {
+ // send stop condition
+ TWCR = _BV(TWEN) | _BV(TWIE) | _BV(TWEA) | _BV(TWINT) | _BV(TWSTO);
+
+ // wait for stop condition to be exectued on bus
+ // TWINT is not set after a stop condition!
+ while (TWCR & _BV(TWSTO)) {
+ continue;
+ }
+
+ // update twi state
+ twi_state = TWI_READY;
+ }
+
+ void twi_releaseBus(void) {
+ // release bus
+ TWCR = _BV(TWEN) | _BV(TWIE) | _BV(TWEA) | _BV(TWINT);
+
+ // update twi state
+ twi_state = TWI_READY;
+ }
+
+ SIGNAL(TWI_vect) {
+ switch (TW_STATUS) {
+ // All Master
+ case TW_START: // sent start condition
+ case TW_REP_START: // sent repeated start condition
+ // copy device address and r/w bit to output register and ack
+ TWDR = twi_slarw;
+ twi_reply(1);
+ break;
+
+ // Master Transmitter
+ case TW_MT_SLA_ACK: // slave receiver acked address
+ case TW_MT_DATA_ACK: // slave receiver acked data
+ // if there is data to send, send it, otherwise stop
+ if (twi_masterBufferIndex < twi_masterBufferLength) {
+ // copy data to output register and ack
+ TWDR = twi_masterBuffer[twi_masterBufferIndex++];
+ twi_reply(1);
+ } else {
+ twi_stop();
+ }
+ break;
+
+ case TW_MT_SLA_NACK: // address sent, nack received
+ twi_error = TW_MT_SLA_NACK;
+ twi_stop();
+ break;
+
+ case TW_MT_DATA_NACK: // data sent, nack received
+ twi_error = TW_MT_DATA_NACK;
+ twi_stop();
+ break;
+
+ case TW_MT_ARB_LOST: // lost bus arbitration
+ twi_error = TW_MT_ARB_LOST;
+ twi_releaseBus();
+ break;
+
+ // Master Receiver
+ case TW_MR_DATA_ACK: // data received, ack sent
+ // put byte into buffer
+ twi_masterBuffer[twi_masterBufferIndex++] = TWDR;
+
+ case TW_MR_SLA_ACK: // address sent, ack received
+ // ack if more bytes are expected, otherwise nack
+ if (twi_masterBufferIndex < twi_masterBufferLength) {
+ twi_reply(1);
+ } else {
+ twi_reply(0);
+ }
+ break;
+
+ case TW_MR_DATA_NACK: // data received, nack sent
+ // put final byte into buffer
+ twi_masterBuffer[twi_masterBufferIndex++] = TWDR;
+
+ case TW_MR_SLA_NACK: // address sent, nack received
+ twi_stop();
+ break;
+
+ // TW_MR_ARB_LOST handled by TW_MT_ARB_LOST case
+
+ // Slave Receiver (NOT IMPLEMENTED YET)
+ /*
+ case TW_SR_SLA_ACK: // addressed, returned ack
+ case TW_SR_GCALL_ACK: // addressed generally, returned ack
+ case TW_SR_ARB_LOST_SLA_ACK: // lost arbitration, returned ack
+ case TW_SR_ARB_LOST_GCALL_ACK: // lost arbitration, returned ack
+ // enter slave receiver mode
+ twi_state = TWI_SRX;
+
+ // indicate that rx buffer can be overwritten and ack
+ twi_rxBufferIndex = 0;
+ twi_reply(1);
+ break;
+
+ case TW_SR_DATA_ACK: // data received, returned ack
+ case TW_SR_GCALL_DATA_ACK: // data received generally, returned ack
+ // if there is still room in the rx buffer
+ if (twi_rxBufferIndex < TWI_BUFFER_LENGTH) {
+ // put byte in buffer and ack
+ twi_rxBuffer[twi_rxBufferIndex++] = TWDR;
+ twi_reply(1);
+ } else {
+ // otherwise nack
+ twi_reply(0);
+ }
+ break;
+
+ case TW_SR_STOP: // stop or repeated start condition received
+ // put a null char after data if there's room
+ if (twi_rxBufferIndex < TWI_BUFFER_LENGTH) {
+ twi_rxBuffer[twi_rxBufferIndex] = 0;
+ }
+
+ // sends ack and stops interface for clock stretching
+ twi_stop();
+
+ // callback to user defined callback
+ twi_onSlaveReceive(twi_rxBuffer, twi_rxBufferIndex);
+
+ // since we submit rx buffer to "wire" library, we can reset it
+ twi_rxBufferIndex = 0;
+
+ // ack future responses and leave slave receiver state
+ twi_releaseBus();
+ break;
+
+ case TW_SR_DATA_NACK: // data received, returned nack
+ case TW_SR_GCALL_DATA_NACK: // data received generally, returned nack
+ // nack back at master
+ twi_reply(0);
+ break;
+
+ // Slave Transmitter
+ case TW_ST_SLA_ACK: // addressed, returned ack
+ case TW_ST_ARB_LOST_SLA_ACK: // arbitration lost, returned ack
+ // enter slave transmitter mode
+ twi_state = TWI_STX;
+
+ // ready the tx buffer index for iteration
+ twi_txBufferIndex = 0;
+
+ // set tx buffer length to be zero, to verify if user changes it
+ twi_txBufferLength = 0;
+
+ // request for txBuffer to be filled and length to be set
+ // note: user must call twi_transmit(bytes, length) to do this
+ twi_onSlaveTransmit();
+
+ // if they didn't change buffer & length, initialize it
+ if (0 == twi_txBufferLength) {
+ twi_txBufferLength = 1;
+ twi_txBuffer[0] = 0x00;
+ }
+
+ // transmit first byte from buffer, fall through
+
+ case TW_ST_DATA_ACK: // byte sent, ack returned
+ // copy data to output register
+ TWDR = twi_txBuffer[twi_txBufferIndex++];
+
+ // if there is more to send, ack, otherwise nack
+ if (twi_txBufferIndex < twi_txBufferLength) {
+ twi_reply(1);
+ } else {
+ twi_reply(0);
+ }
+ break;
+
+ case TW_ST_DATA_NACK: // received nack, we are done
+ case TW_ST_LAST_DATA: // received ack, but we are done already!
+ // ack future responses
+ twi_reply(1);
+ // leave slave receiver state
+ twi_state = TWI_READY;
+ break;
+ */
+
+ // all
+ case TW_NO_INFO: // no state information
+ break;
+
+ case TW_BUS_ERROR: // bus error, illegal stop/start
+ twi_error = TW_BUS_ERROR;
+ twi_stop();
+ break;
+ }
+
+ if (fNextInterruptFunction) return fNextInterruptFunction();
+ }
+
+ TwoWire::TwoWire() { }
+
+ void TwoWire::begin(void) {
+ rxBufferIndex = 0;
+ rxBufferLength = 0;
+
+ txBufferIndex = 0;
+ txBufferLength = 0;
+
+ twi_init();
+ }
+
+ void TwoWire::beginTransmission(uint8_t address) {
+ //beginTransmission((uint8_t)address);
+
+ // indicate that we are transmitting
+ twi_transmitting = 1;
+
+ // set address of targeted slave
+ txAddress = address;
+
+ // reset tx buffer iterator vars
+ txBufferIndex = 0;
+ txBufferLength = 0;
+ }
+
+ uint8_t TwoWire::endTransmission(uint16_t timeout) {
+ // transmit buffer (blocking)
+ //int8_t ret =
+ twi_cbendTransmissionDone = NULL;
+ twi_writeTo(txAddress, txBuffer, txBufferLength, 1);
+ int8_t ret = twii_WaitForDone(timeout);
+
+ // reset tx buffer iterator vars
+ txBufferIndex = 0;
+ txBufferLength = 0;
+
+ // indicate that we are done transmitting
+ // twi_transmitting = 0;
+ return ret;
+ }
+
+ void TwoWire::nbendTransmission(void (*function)(int)) {
+ twi_cbendTransmissionDone = function;
+ twi_writeTo(txAddress, txBuffer, txBufferLength, 1);
+ return;
+ }
+
+ void TwoWire::send(uint8_t data) {
+ if (twi_transmitting) {
+ // in master transmitter mode
+ // don't bother if buffer is full
+ if (txBufferLength >= NBWIRE_BUFFER_LENGTH) {
+ return;
+ }
+
+ // put byte in tx buffer
+ txBuffer[txBufferIndex] = data;
+ ++txBufferIndex;
+
+ // update amount in buffer
+ txBufferLength = txBufferIndex;
+ } else {
+ // in slave send mode
+ // reply to master
+ //twi_transmit(&data, 1);
+ }
+ }
+
+ uint8_t TwoWire::receive(void) {
+ // default to returning null char
+ // for people using with char strings
+ uint8_t value = 0;
+
+ // get each successive byte on each call
+ if (rxBufferIndex < rxBufferLength) {
+ value = rxBuffer[rxBufferIndex];
+ ++rxBufferIndex;
+ }
+
+ return value;
+ }
+
+ uint8_t TwoWire::requestFrom(uint8_t address, int quantity, uint16_t timeout) {
+ // clamp to buffer length
+ if (quantity > NBWIRE_BUFFER_LENGTH) {
+ quantity = NBWIRE_BUFFER_LENGTH;
+ }
+
+ // perform blocking read into buffer
+ twi_cbreadFromDone = NULL;
+ twi_readFrom(address, rxBuffer, quantity);
+ uint8_t read = twii_WaitForDone(timeout);
+
+ // set rx buffer iterator vars
+ rxBufferIndex = 0;
+ rxBufferLength = read;
+
+ return read;
+ }
+
+ void TwoWire::nbrequestFrom(uint8_t address, int quantity, void (*function)(int)) {
+ // clamp to buffer length
+ if (quantity > NBWIRE_BUFFER_LENGTH) {
+ quantity = NBWIRE_BUFFER_LENGTH;
+ }
+
+ // perform blocking read into buffer
+ twi_cbreadFromDone = function;
+ twi_readFrom(address, rxBuffer, quantity);
+ //uint8_t read = twii_WaitForDone();
+
+ // set rx buffer iterator vars
+ //rxBufferIndex = 0;
+ //rxBufferLength = read;
+
+ rxBufferIndex = 0;
+ rxBufferLength = quantity; // this is a hack
+
+ return; //read;
+ }
+
+ uint8_t TwoWire::available(void) {
+ return rxBufferLength - rxBufferIndex;
+ }
+
+#endif
261 firmware/I2Cdev/I2Cdev.h
@@ -0,0 +1,261 @@
+// I2Cdev library collection - Main I2C device class header file
+// Abstracts bit and byte I2C R/W functions into a convenient class
+// 6/9/2012 by Jeff Rowberg <jeff@rowberg.net>
+//
+// Changelog:
+// 2012-06-09 - fix major issue with reading > 32 bytes at a time with Arduino Wire
+// - add compiler warnings when using outdated or IDE or limited I2Cdev implementation
+// 2011-11-01 - fix write*Bits mask calculation (thanks sasquatch @ Arduino forums)
+// 2011-10-03 - added automatic Arduino version detection for ease of use
+// 2011-10-02 - added Gene Knight's NBWire TwoWire class implementation with small modifications
+// 2011-08-31 - added support for Arduino 1.0 Wire library (methods are different from 0.x)
+// 2011-08-03 - added optional timeout parameter to read* methods to easily change from default
+// 2011-08-02 - added support for 16-bit registers
+// - fixed incorrect Doxygen comments on some methods
+// - added timeout value for read operations (thanks mem @ Arduino forums)
+// 2011-07-30 - changed read/write function structures to return success or byte counts
+// - made all methods static for multi-device memory savings
+// 2011-07-28 - initial release
+
+/* ============================================
+I2Cdev device library code is placed under the MIT license
+Copyright (c) 2012 Jeff Rowberg
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in
+all copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
+THE SOFTWARE.
+===============================================
+*/
+
+#ifndef _I2CDEV_H_
+#define _I2CDEV_H_
+
+// -----------------------------------------------------------------------------
+// I2C interface implementation setting
+// -----------------------------------------------------------------------------
+#define I2CDEV_IMPLEMENTATION I2CDEV_ARDUINO_WIRE
+
+// comment this out if you are using a non-optimal IDE/implementation setting
+// but want the compiler to shut up about it
+#define I2CDEV_IMPLEMENTATION_WARNINGS
+
+// -----------------------------------------------------------------------------
+// I2C interface implementation options
+// -----------------------------------------------------------------------------
+#define I2CDEV_ARDUINO_WIRE 1 // Wire object from Arduino
+#define I2CDEV_BUILTIN_NBWIRE 2 // Tweaked Wire object from Gene Knight's NBWire project
+ // ^^^ NBWire implementation is still buggy w/some interrupts!
+#define I2CDEV_BUILTIN_FASTWIRE 3 // FastWire object from Francesco Ferrara's project
+ // ^^^ FastWire implementation in I2Cdev is INCOMPLETE!
+
+// -----------------------------------------------------------------------------
+// Arduino-style "Serial.print" debug constant (uncomment to enable)
+// -----------------------------------------------------------------------------
+//#define I2CDEV_SERIAL_DEBUG
+
+#ifdef ARDUINO
+ #if ARDUINO < 100
+ #include "WProgram.h"
+ #else
+ #include "Arduino.h"
+ #endif
+ #if I2CDEV_IMPLEMENTATION == I2CDEV_ARDUINO_WIRE
+ #include <Wire.h>
+ #endif
+#else
+ #include "ArduinoWrapper.h"
+#endif
+
+// 1000ms default read timeout (modify with "I2Cdev::readTimeout = [ms];")
+#define I2CDEV_DEFAULT_READ_TIMEOUT 1000
+
+class I2Cdev {
+ public:
+ I2Cdev();
+
+ static int8_t readBit(uint8_t devAddr, uint8_t regAddr, uint8_t bitNum, uint8_t *data, uint16_t timeout=I2Cdev::readTimeout);
+ static int8_t readBitW(uint8_t devAddr, uint8_t regAddr, uint8_t bitNum, uint16_t *data, uint16_t timeout=I2Cdev::readTimeout);
+ static int8_t readBits(uint8_t devAddr, uint8_t regAddr, uint8_t bitStart, uint8_t length, uint8_t *data, uint16_t timeout=I2Cdev::readTimeout);
+ static int8_t readBitsW(uint8_t devAddr, uint8_t regAddr, uint8_t bitStart, uint8_t length, uint16_t *data, uint16_t timeout=I2Cdev::readTimeout);
+ static int8_t readByte(uint8_t devAddr, uint8_t regAddr, uint8_t *data, uint16_t timeout=I2Cdev::readTimeout);
+ static int8_t readWord(uint8_t devAddr, uint8_t regAddr, uint16_t *data, uint16_t timeout=I2Cdev::readTimeout);
+ static int8_t readBytes(uint8_t devAddr, uint8_t regAddr, uint8_t length, uint8_t *data, uint16_t timeout=I2Cdev::readTimeout);
+ static int8_t readWords(uint8_t devAddr, uint8_t regAddr, uint8_t length, uint16_t *data, uint16_t timeout=I2Cdev::readTimeout);
+
+ static bool writeBit(uint8_t devAddr, uint8_t regAddr, uint8_t bitNum, uint8_t data);
+ static bool writeBitW(uint8_t devAddr, uint8_t regAddr, uint8_t bitNum, uint16_t data);
+ static bool writeBits(uint8_t devAddr, uint8_t regAddr, uint8_t bitStart, uint8_t length, uint8_t data);
+ static bool writeBitsW(uint8_t devAddr, uint8_t regAddr, uint8_t bitStart, uint8_t length, uint16_t data);
+ static bool writeByte(uint8_t devAddr, uint8_t regAddr, uint8_t data);
+ static bool writeWord(uint8_t devAddr, uint8_t regAddr, uint16_t data);
+ static bool writeBytes(uint8_t devAddr, uint8_t regAddr, uint8_t length, uint8_t *data);
+ static bool writeWords(uint8_t devAddr, uint8_t regAddr, uint8_t length, uint16_t *data);
+
+ static uint16_t readTimeout;
+};
+
+#if I2CDEV_IMPLEMENTATION == I2CDEV_BUILTIN_FASTWIRE
+ //////////////////////
+ // FastWire 0.2
+ // This is a library to help faster programs to read I2C devices.
+ // Copyright(C) 2011
+ // Francesco Ferrara
+ //////////////////////
+
+ /* Master */
+ #define TW_START 0x08
+ #define TW_REP_START 0x10
+
+ /* Master Transmitter */
+ #define TW_MT_SLA_ACK 0x18
+ #define TW_MT_SLA_NACK 0x20
+ #define TW_MT_DATA_ACK 0x28
+ #define TW_MT_DATA_NACK 0x30
+ #define TW_MT_ARB_LOST 0x38
+
+ /* Master Receiver */
+ #define TW_MR_ARB_LOST 0x38
+ #define TW_MR_SLA_ACK 0x40
+ #define TW_MR_SLA_NACK 0x48
+ #define TW_MR_DATA_ACK 0x50
+ #define TW_MR_DATA_NACK 0x58
+
+ #define TW_OK 0
+ #define TW_ERROR 1
+
+ class Fastwire {
+ private:
+ static boolean waitInt();
+
+ public:
+ static void setup(int khz, boolean pullup);
+ static byte write(byte device, byte address, byte value);
+ static byte readBuf(byte device, byte address, byte *data, byte num);
+ };
+#endif
+
+#if I2CDEV_IMPLEMENTATION == I2CDEV_BUILTIN_NBWIRE
+ // NBWire implementation based heavily on code by Gene Knight <Gene@Telobot.com>
+ // Originally posted on the Arduino forum at http://arduino.cc/forum/index.php/topic,70705.0.html
+ // Originally offered to the i2cdevlib project at http://arduino.cc/forum/index.php/topic,68210.30.html
+
+ #define NBWIRE_BUFFER_LENGTH 32
+
+ class TwoWire {
+ private:
+ static uint8_t rxBuffer[];
+ static uint8_t rxBufferIndex;
+ static uint8_t rxBufferLength;
+
+ static uint8_t txAddress;
+ static uint8_t txBuffer[];
+ static uint8_t txBufferIndex;
+ static uint8_t txBufferLength;
+
+ // static uint8_t transmitting;
+ static void (*user_onRequest)(void);
+ static void (*user_onReceive)(int);
+ static void onRequestService(void);
+ static void onReceiveService(uint8_t*, int);
+
+ public:
+ TwoWire();
+ void begin();
+ void begin(uint8_t);
+ void begin(int);
+ void beginTransmission(uint8_t);
+ //void beginTransmission(int);
+ uint8_t endTransmission(uint16_t timeout=0);
+ void nbendTransmission(void (*function)(int)) ;
+ uint8_t requestFrom(uint8_t, int, uint16_t timeout=0);
+ //uint8_t requestFrom(int, int);
+ void nbrequestFrom(uint8_t, int, void (*function)(int));
+ void send(uint8_t);
+ void send(uint8_t*, uint8_t);
+ //void send(int);
+ void send(char*);
+ uint8_t available(void);
+ uint8_t receive(void);
+ void onReceive(void (*)(int));
+ void onRequest(void (*)(void));
+ };
+
+ #define TWI_READY 0
+ #define TWI_MRX 1
+ #define TWI_MTX 2
+ #define TWI_SRX 3
+ #define TWI_STX 4
+
+ #define TW_WRITE 0
+ #define TW_READ 1
+
+ #define TW_MT_SLA_NACK 0x20
+ #define TW_MT_DATA_NACK 0x30
+
+ #define CPU_FREQ 16000000L
+ #define TWI_FREQ 100000L
+ #define TWI_BUFFER_LENGTH 32
+
+ /* TWI Status is in TWSR, in the top 5 bits: TWS7 - TWS3 */
+
+ #define TW_STATUS_MASK (_BV(TWS7)|_BV(TWS6)|_BV(TWS5)|_BV(TWS4)|_BV(TWS3))
+ #define TW_STATUS (TWSR & TW_STATUS_MASK)
+ #define TW_START 0x08
+ #define TW_REP_START 0x10
+ #define TW_MT_SLA_ACK 0x18
+ #define TW_MT_SLA_NACK 0x20
+ #define TW_MT_DATA_ACK 0x28
+ #define TW_MT_DATA_NACK 0x30
+ #define TW_MT_ARB_LOST 0x38
+ #define TW_MR_ARB_LOST 0x38
+ #define TW_MR_SLA_ACK 0x40
+ #define TW_MR_SLA_NACK 0x48
+ #define TW_MR_DATA_ACK 0x50
+ #define TW_MR_DATA_NACK 0x58
+ #define TW_ST_SLA_ACK 0xA8
+ #define TW_ST_ARB_LOST_SLA_ACK 0xB0
+ #define TW_ST_DATA_ACK 0xB8
+ #define TW_ST_DATA_NACK 0xC0
+ #define TW_ST_LAST_DATA 0xC8
+ #define TW_SR_SLA_ACK 0x60
+ #define TW_SR_ARB_LOST_SLA_ACK 0x68
+ #define TW_SR_GCALL_ACK 0x70
+ #define TW_SR_ARB_LOST_GCALL_ACK 0x78
+ #define TW_SR_DATA_ACK 0x80
+ #define TW_SR_DATA_NACK 0x88
+ #define TW_SR_GCALL_DATA_ACK 0x90
+ #define TW_SR_GCALL_DATA_NACK 0x98
+ #define TW_SR_STOP 0xA0
+ #define TW_NO_INFO 0xF8
+ #define TW_BUS_ERROR 0x00
+
+ //#define _MMIO_BYTE(mem_addr) (*(volatile uint8_t *)(mem_addr))
+ //#define _SFR_BYTE(sfr) _MMIO_BYTE(_SFR_ADDR(sfr))
+
+ #ifndef sbi // set bit
+ #define sbi(sfr, bit) (_SFR_BYTE(sfr) |= _BV(bit))
+ #endif // sbi
+
+ #ifndef cbi // clear bit
+ #define cbi(sfr, bit) (_SFR_BYTE(sfr) &= ~_BV(bit))
+ #endif // cbi
+
+ extern TwoWire Wire;
+
+#endif // I2CDEV_IMPLEMENTATION == I2CDEV_BUILTIN_NBWIRE
+
+#endif /* _I2CDEV_H_ */
38 firmware/I2Cdev/keywords.txt
@@ -0,0 +1,38 @@
+#######################################
+# Syntax Coloring Map For I2Cdev
+#######################################
+
+#######################################
+# Datatypes (KEYWORD1)
+#######################################
+I2Cdev KEYWORD1
+
+#######################################
+# Methods and Functions (KEYWORD2)
+#######################################
+
+readBit KEYWORD2
+readBitW KEYWORD2
+readBits KEYWORD2
+readBitsW KEYWORD2
+readByte KEYWORD2
+readBytes KEYWORD2
+readWord KEYWORD2
+readWords KEYWORD2
+writeBit KEYWORD2
+writeBitW KEYWORD2
+writeBits KEYWORD2
+writeBitsW KEYWORD2
+writeByte KEYWORD2
+writeBytes KEYWORD2
+writeWord KEYWORD2
+writeWords KEYWORD2
+
+#######################################
+# Instances (KEYWORD2)
+#######################################
+
+#######################################
+# Constants (LITERAL1)
+#######################################
+
355 firmware/MPU6050/Examples/MPU6050_DMP6/MPU6050_DMP6.ino
@@ -0,0 +1,355 @@
+// I2C device class (I2Cdev) demonstration Arduino sketch for MPU6050 class using DMP (MotionApps v2.0)
+// 6/21/2012 by Jeff Rowberg <jeff@rowberg.net>
+// Updates should (hopefully) always be available at https://github.com/jrowberg/i2cdevlib
+//
+// Changelog:
+// 2012-06-21 - added note about Arduino 1.0.1 + Leonardo compatibility error
+// 2012-06-20 - improved FIFO overflow handling and simplified read process
+// 2012-06-19 - completely rearranged DMP initialization code and simplification
+// 2012-06-13 - pull gyro and accel data from FIFO packet instead of reading directly
+// 2012-06-09 - fix broken FIFO read sequence and change interrupt detection to RISING
+// 2012-06-05 - add gravity-compensated initial reference frame acceleration output
+// - add 3D math helper file to DMP6 example sketch
+// - add Euler output and Yaw/Pitch/Roll output formats
+// 2012-06-04 - remove accel offset clearing for better results (thanks Sungon Lee)
+// 2012-06-01 - fixed gyro sensitivity to be 2000 deg/sec instead of 250
+// 2012-05-30 - basic DMP initialization working
+
+/* ============================================
+I2Cdev device library code is placed under the MIT license
+Copyright (c) 2012 Jeff Rowberg
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in
+all copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
+THE SOFTWARE.
+===============================================
+*/
+
+// Arduino Wire library is required if I2Cdev I2CDEV_ARDUINO_WIRE implementation
+// is used in I2Cdev.h
+#include "Wire.h"
+
+// I2Cdev and MPU6050 must be installed as libraries, or else the .cpp/.h files
+// for both classes must be in the include path of your project
+#include "I2Cdev.h"
+
+#include "MPU6050_6Axis_MotionApps20.h"
+//#include "MPU6050.h" // not necessary if using MotionApps include file
+
+// class default I2C address is 0x68
+// specific I2C addresses may be passed as a parameter here
+// AD0 low = 0x68 (default for SparkFun breakout and InvenSense evaluation board)
+// AD0 high = 0x69
+MPU6050 mpu;
+
+/* =========================================================================
+ NOTE: In addition to connection 3.3v, GND, SDA, and SCL, this sketch
+ depends on the MPU-6050's INT pin being connected to the Arduino's
+ external interrupt #0 pin. On the Arduino Uno and Mega 2560, this is
+ digital I/O pin 2.
+ * ========================================================================= */
+
+/* =========================================================================
+ NOTE: Arduino v1.0.1 with the Leonardo board generates a compile error
+ when using Serial.write(buf, len). The Teapot output uses this method.
+ The solution requires a modification to the Arduino USBAPI.h file, which
+ is fortunately simple, but annoying. This will be fixed in the next IDE
+ release. For more info, see these links:
+
+ http://arduino.cc/forum/index.php/topic,109987.0.html
+ http://code.google.com/p/arduino/issues/detail?id=958
+ * ========================================================================= */
+
+
+
+// uncomment "OUTPUT_READABLE_QUATERNION" if you want to see the actual
+// quaternion components in a [w, x, y, z] format (not best for parsing
+// on a remote host such as Processing or something though)
+//#define OUTPUT_READABLE_QUATERNION
+
+// uncomment "OUTPUT_READABLE_EULER" if you want to see Euler angles
+// (in degrees) calculated from the quaternions coming from the FIFO.
+// Note that Euler angles suffer from gimbal lock (for more info, see
+// http://en.wikipedia.org/wiki/Gimbal_lock)
+//#define OUTPUT_READABLE_EULER
+
+// uncomment "OUTPUT_READABLE_YAWPITCHROLL" if you want to see the yaw/
+// pitch/roll angles (in degrees) calculated from the quaternions coming
+// from the FIFO. Note this also requires gravity vector calculations.
+// Also note that yaw/pitch/roll angles suffer from gimbal lock (for
+// more info, see: http://en.wikipedia.org/wiki/Gimbal_lock)
+//#define OUTPUT_READABLE_YAWPITCHROLL
+
+// uncomment "OUTPUT_READABLE_REALACCEL" if you want to see acceleration
+// components with gravity removed. This acceleration reference frame is
+// not compensated for orientation, so +X is always +X according to the
+// sensor, just without the effects of gravity. If you want acceleration
+// compensated for orientation, us OUTPUT_READABLE_WORLDACCEL instead.
+//#define OUTPUT_READABLE_REALACCEL
+
+// uncomment "OUTPUT_READABLE_WORLDACCEL" if you want to see acceleration
+// components with gravity removed and adjusted for the world frame of
+// reference (yaw is relative to initial orientation, since no magnetometer
+// is present in this case). Could be quite handy in some cases.
+//#define OUTPUT_READABLE_WORLDACCEL
+
+// uncomment "OUTPUT_TEAPOT" if you want output that matches the
+// format used for the InvenSense teapot demo
+#define OUTPUT_TEAPOT
+
+
+
+#define LED_PIN 13 // (Arduino is 13, Teensy is 11, Teensy++ is 6)
+bool blinkState = false;
+
+// MPU control/status vars
+bool dmpReady = false; // set true if DMP init was successful
+uint8_t mpuIntStatus; // holds actual interrupt status byte from MPU
+uint8_t devStatus; // return status after each device operation (0 = success, !0 = error)
+uint16_t packetSize; // expected DMP packet size (default is 42 bytes)
+uint16_t fifoCount; // count of all bytes currently in FIFO
+uint8_t fifoBuffer[64]; // FIFO storage buffer
+
+// orientation/motion vars
+Quaternion q; // [w, x, y, z] quaternion container
+VectorInt16 aa; // [x, y, z] accel sensor measurements
+VectorInt16 aaReal; // [x, y, z] gravity-free accel sensor measurements
+VectorInt16 aaWorld; // [x, y, z] world-frame accel sensor measurements
+VectorFloat gravity; // [x, y, z] gravity vector
+float euler[3]; // [psi, theta, phi] Euler angle container
+float ypr[3]; // [yaw, pitch, roll] yaw/pitch/roll container and gravity vector
+
+// packet structure for InvenSense teapot demo
+uint8_t teapotPacket[14] = { '$', 0x02, 0,0, 0,0, 0,0, 0,0, 0x00, 0x00, '\r', '\n' };
+
+
+
+// ================================================================
+// === INTERRUPT DETECTION ROUTINE ===
+// ================================================================
+
+volatile bool mpuInterrupt = false; // indicates whether MPU interrupt pin has gone high
+void dmpDataReady() {
+ mpuInterrupt = true;
+}
+
+
+
+// ================================================================
+// === INITIAL SETUP ===
+// ================================================================
+
+void setup() {
+ // join I2C bus (I2Cdev library doesn't do this automatically)
+ Wire.begin();
+
+ // initialize serial communication
+ // (115200 chosen because it is required for Teapot Demo output, but it's
+ // really up to you depending on your project)
+ Serial.begin(115200);
+ while (!Serial); // wait for Leonardo enumeration, others continue immediately
+
+ // NOTE: 8MHz or slower host processors, like the Teensy @ 3.3v or Ardunio
+ // Pro Mini running at 3.3v, cannot handle this baud rate reliably due to
+ // the baud timing being too misaligned with processor ticks. You must use
+ // 38400 or slower in these cases, or use some kind of external separate
+ // crystal solution for the UART timer.
+
+ // initialize device
+ Serial.println(F("Initializing I2C devices..."));
+ mpu.initialize();
+
+ // verify connection
+ Serial.println(F("Testing device connections..."));
+ Serial.println(mpu.testConnection() ? F("MPU6050 connection successful") : F("MPU6050 connection failed"));
+
+ // wait for ready
+ Serial.println(F("\nSend any character to begin DMP programming and demo: "));
+ while (Serial.available() && Serial.read()); // empty buffer
+ while (!Serial.available()); // wait for data
+ while (Serial.available() && Serial.read()); // empty buffer again
+
+ // load and configure the DMP
+ Serial.println(F("Initializing DMP..."));
+ devStatus = mpu.dmpInitialize();
+
+ // make sure it worked (returns 0 if so)
+ if (devStatus == 0) {
+ // turn on the DMP, now that it's ready
+ Serial.println(F("Enabling DMP..."));
+ mpu.setDMPEnabled(true);
+
+ // enable Arduino interrupt detection
+ Serial.println(F("Enabling interrupt detection (Arduino external interrupt 0)..."));
+ attachInterrupt(0, dmpDataReady, RISING);
+ mpuIntStatus = mpu.getIntStatus();
+
+ // set our DMP Ready flag so the main loop() function knows it's okay to use it
+ Serial.println(F("DMP ready! Waiting for first interrupt..."));
+ dmpReady = true;
+
+ // get expected DMP packet size for later comparison
+ packetSize = mpu.dmpGetFIFOPacketSize();
+ } else {
+ // ERROR!
+ // 1 = initial memory load failed
+ // 2 = DMP configuration updates failed
+ // (if it's going to break, usually the code will be 1)
+ Serial.print(F("DMP Initialization failed (code "));
+ Serial.print(devStatus);
+ Serial.println(F(")"));
+ }
+
+ // configure LED for output
+ pinMode(LED_PIN, OUTPUT);
+}
+
+
+
+// ================================================================
+// === MAIN PROGRAM LOOP ===
+// ================================================================
+
+void loop() {
+ // if programming failed, don't try to do anything
+ if (!dmpReady) return;
+
+ // wait for MPU interrupt or extra packet(s) available
+ while (!mpuInterrupt && fifoCount < packetSize) {
+ // other program behavior stuff here
+ // .
+ // .
+ // .
+ // if you are really paranoid you can frequently test in between other
+ // stuff to see if mpuInterrupt is true, and if so, "break;" from the
+ // while() loop to immediately process the MPU data
+ // .
+ // .
+ // .
+ }
+
+ // reset interrupt flag and get INT_STATUS byte
+ mpuInterrupt = false;
+ mpuIntStatus = mpu.getIntStatus();
+
+ // get current FIFO count
+ fifoCount = mpu.getFIFOCount();
+
+ // check for overflow (this should never happen unless our code is too inefficient)
+ if ((mpuIntStatus & 0x10) || fifoCount == 1024) {
+ // reset so we can continue cleanly
+ mpu.resetFIFO();
+ Serial.println(F("FIFO overflow!"));
+
+ // otherwise, check for DMP data ready interrupt (this should happen frequently)
+ } else if (mpuIntStatus & 0x02) {
+ // wait for correct available data length, should be a VERY short wait
+ while (fifoCount < packetSize) fifoCount = mpu.getFIFOCount();
+
+ // read a packet from FIFO
+ mpu.getFIFOBytes(fifoBuffer, packetSize);
+
+ // track FIFO count here in case there is > 1 packet available
+ // (this lets us immediately read more without waiting for an interrupt)
+ fifoCount -= packetSize;
+
+ #ifdef OUTPUT_READABLE_QUATERNION
+ // display quaternion values in easy matrix form: w x y z
+ mpu.dmpGetQuaternion(&q, fifoBuffer);
+ Serial.print("quat\t");
+ Serial.print(q.w);
+ Serial.print("\t");
+ Serial.print(q.x);
+ Serial.print("\t");
+ Serial.print(q.y);
+ Serial.print("\t");
+ Serial.println(q.z);
+ #endif
+
+ #ifdef OUTPUT_READABLE_EULER
+ // display Euler angles in degrees
+ mpu.dmpGetQuaternion(&q, fifoBuffer);
+ mpu.dmpGetEuler(euler, &q);
+ Serial.print("euler\t");
+ Serial.print(euler[0] * 180/M_PI);
+ Serial.print("\t");
+ Serial.print(euler[1] * 180/M_PI);
+ Serial.print("\t");
+ Serial.println(euler[2] * 180/M_PI);
+ #endif
+
+ #ifdef OUTPUT_READABLE_YAWPITCHROLL
+ // display Euler angles in degrees
+ mpu.dmpGetQuaternion(&q, fifoBuffer);
+ mpu.dmpGetGravity(&gravity, &q);
+ mpu.dmpGetYawPitchRoll(ypr, &q, &gravity);
+ Serial.print("ypr\t");
+ Serial.print(ypr[0] * 180/M_PI);
+ Serial.print("\t");
+ Serial.print(ypr[1] * 180/M_PI);
+ Serial.print("\t");
+ Serial.println(ypr[2] * 180/M_PI);
+ #endif
+
+ #ifdef OUTPUT_READABLE_REALACCEL
+ // display real acceleration, adjusted to remove gravity
+ mpu.dmpGetQuaternion(&q, fifoBuffer);
+ mpu.dmpGetAccel(&aa, fifoBuffer);
+ mpu.dmpGetGravity(&gravity, &q);
+ mpu.dmpGetLinearAccel(&aaReal, &aa, &gravity);
+ Serial.print("areal\t");
+ Serial.print(aaReal.x);
+ Serial.print("\t");
+ Serial.print(aaReal.y);
+ Serial.print("\t");
+ Serial.println(aaReal.z);
+ #endif
+
+ #ifdef OUTPUT_READABLE_WORLDACCEL
+ // display initial world-frame acceleration, adjusted to remove gravity
+ // and rotated based on known orientation from quaternion
+ mpu.dmpGetQuaternion(&q, fifoBuffer);
+ mpu.dmpGetAccel(&aa, fifoBuffer);
+ mpu.dmpGetGravity(&gravity, &q);
+ mpu.dmpGetLinearAccelInWorld(&aaWorld, &aaReal, &q);
+ Serial.print("aworld\t");
+ Serial.print(aaWorld.x);
+ Serial.print("\t");
+ Serial.print(aaWorld.y);
+ Serial.print("\t");
+ Serial.println(aaWorld.z);
+ #endif
+
+ #ifdef OUTPUT_TEAPOT
+ // display quaternion values in InvenSense Teapot demo format:
+ teapotPacket[2] = fifoBuffer[0];
+ teapotPacket[3] = fifoBuffer[1];
+ teapotPacket[4] = fifoBuffer[4];
+ teapotPacket[5] = fifoBuffer[5];
+ teapotPacket[6] = fifoBuffer[8];
+ teapotPacket[7] = fifoBuffer[9];
+ teapotPacket[8] = fifoBuffer[12];
+ teapotPacket[9] = fifoBuffer[13];
+ Serial.write(teapotPacket, 14);
+ teapotPacket[11]++; // packetCount, loops at 0xFF on purpose
+ #endif
+
+ // blink LED to indicate activity
+ blinkState = !blinkState;
+ digitalWrite(LED_PIN, blinkState);
+ }
+}
246 firmware/MPU6050/Examples/MPU6050_DMP6/Processing/MPUTeapot.pde
@@ -0,0 +1,246 @@
+// I2C device class (I2Cdev) demonstration Processing sketch for MPU6050 DMP output
+// 6/20/2012 by Jeff Rowberg <jeff@rowberg.net>
+// Updates should (hopefully) always be available at https://github.com/jrowberg/i2cdevlib
+//
+// Changelog:
+// 2012-06-20 - initial release
+
+/* ============================================
+I2Cdev device library code is placed under the MIT license
+Copyright (c) 2012 Jeff Rowberg
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in
+all copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
+THE SOFTWARE.
+===============================================
+*/
+
+import processing.serial.*;
+import processing.opengl.*;
+import toxi.geom.*;
+import toxi.processing.*;
+
+// NOTE: requires ToxicLibs to be installed in order to run properly.
+// 1. Download from http://toxiclibs.org/downloads
+// 2. Extract into [userdir]/Processing/libraries
+// (location may be different on Mac/Linux)
+// 3. Run and bask in awesomeness
+
+ToxiclibsSupport gfx;
+
+Serial port; // The serial port
+char[] teapotPacket = new char[14]; // InvenSense Teapot packet
+int serialCount = 0; // current packet byte position
+int aligned = 0;
+int interval = 0;
+
+float[] q = new float[4];
+Quaternion quat = new Quaternion(1, 0, 0, 0);
+
+float[] gravity = new float[3];
+float[] euler = new float[3];
+float[] ypr = new float[3];
+
+void setup() {
+ // 300px square viewport using OpenGL rendering
+ size(300, 300, OPENGL);
+ gfx = new ToxiclibsSupport(this);
+
+ // setup lights and antialiasing
+ lights();
+ smooth();
+
+ // display serial port list for debugging/clarity
+ println(Serial.list());
+
+ // get the first available port (use EITHER this OR the specific port code below)
+ String portName = Serial.list()[0];
+
+ // get a specific serial port (use EITHER this OR the first-available code above)
+ //String portName = "COM4";
+
+ // open the serial port
+ port = new Serial(this, portName, 115200);
+
+ // send single character to trigger DMP init/start
+ // (expected by MPU6050_DMP6 example Arduino sketch)
+ port.write('r');
+}
+
+void draw() {
+ if (millis() - interval > 1000) {
+ // resend single character to trigger DMP init/start
+ // in case the MPU is halted/reset while applet is running
+ port.write('r');
+ interval = millis();
+ }
+
+ // black background
+ background(0);
+
+ // translate everything to the middle of the viewport
+ pushMatrix();
+ translate(width / 2, height / 2);
+
+ // 3-step rotation from yaw/pitch/roll angles (gimbal lock!)
+ // ...and other weirdness I haven't figured out yet
+ //rotateY(-ypr[0]);
+ //rotateZ(-ypr[1]);
+ //rotateX(-ypr[2]);
+
+ // toxiclibs direct angle/axis rotation from quaternion (NO gimbal lock!)
+ // (axis order [1, 3, 2] and inversion [-1, +1, +1] is a consequence of
+ // different coordinate system orientation assumptions between Processing
+ // and InvenSense DMP)
+ float[] axis = quat.toAxisAngle();
+ rotate(axis[0], -axis[1], axis[3], axis[2]);
+
+ // draw main body in red
+ fill(255, 0, 0, 200);
+ box(10, 10, 200);
+
+ // draw front-facing tip in blue
+ fill(0, 0, 255, 200);
+ pushMatrix();
+ translate(0, 0, -120);
+ rotateX(PI/2);
+ drawCylinder(0, 20, 20, 8);
+ popMatrix();
+
+ // draw wings and tail fin in green
+ fill(0, 255, 0, 200);
+ beginShape(TRIANGLES);
+ vertex(-100, 2, 30); vertex(0, 2, -80); vertex(100, 2, 30); // wing top layer
+ vertex(-100, -2, 30); vertex(0, -2, -80); vertex(100, -2, 30); // wing bottom layer
+ vertex(-2, 0, 98); vertex(-2, -30, 98); vertex(-2, 0, 70); // tail left layer
+ vertex( 2, 0, 98); vertex( 2, -30, 98); vertex( 2, 0, 70); // tail right layer
+ endShape();
+ beginShape(QUADS);
+ vertex(-100, 2, 30); vertex(-100, -2, 30); vertex( 0, -2, -80); vertex( 0, 2, -80);
+ vertex( 100, 2, 30); vertex( 100, -2, 30); vertex( 0, -2, -80); vertex( 0, 2, -80);
+ vertex(-100, 2, 30); vertex(-100, -2, 30); vertex(100, -2, 30); vertex(100, 2, 30);
+ vertex(-2, 0, 98); vertex(2, 0, 98); vertex(2, -30, 98); vertex(-2, -30, 98);
+ vertex(-2, 0, 98); vertex(2, 0, 98); vertex(2, 0, 70); vertex(-2, 0, 70);
+ vertex(-2, -30, 98); vertex(2, -30, 98); vertex(2, 0, 70); vertex(-2, 0, 70);
+ endShape();
+
+ popMatrix();
+}
+
+void serialEvent(Serial port) {
+ interval = millis();
+ while (port.available() > 0) {
+ int ch = port.read();
+ print((char)ch);
+ if (aligned < 4) {
+ // make sure we are properly aligned on a 14-byte packet
+ if (serialCount == 0) {
+ if (ch == '$') aligned++; else aligned = 0;
+ } else if (serialCount == 1) {
+ if (ch == 2) aligned++; else aligned = 0;
+ } else if (serialCount == 12) {
+ if (ch == '\r') aligned++; else aligned = 0;
+ } else if (serialCount == 13) {
+ if (ch == '\n') aligned++; else aligned = 0;
+ }
+ //println(ch + " " + aligned + " " + serialCount);
+ serialCount++;
+ if (serialCount == 14) serialCount = 0;
+ } else {
+ if (serialCount > 0 || ch == '$') {
+ teapotPacket[serialCount++] = (char)ch;
+ if (serialCount == 14) {
+ serialCount = 0; // restart packet byte position
+
+ // get quaternion from data packet
+ q[0] = ((teapotPacket[2] << 8) | teapotPacket[3]) / 16384.0f;
+ q[1] = ((teapotPacket[4] << 8) | teapotPacket[5]) / 16384.0f;
+ q[2] = ((teapotPacket[6] << 8) | teapotPacket[7]) / 16384.0f;
+ q[3] = ((teapotPacket[8] << 8) | teapotPacket[9]) / 16384.0f;
+ for (int i = 0; i < 4; i++) if (q[i] >= 2) q[i] = -4 + q[i];
+
+ // set our toxilibs quaternion to new data
+ quat.set(q[0], q[1], q[2], q[3]);
+
+ /*
+ // below calculations unnecessary for orientation only using toxilibs
+
+ // calculate gravity vector
+ gravity[0] = 2 * (q[1]*q[3] - q[0]*q[2]);
+ gravity[1] = 2 * (q[0]*q[1] + q[2]*q[3]);
+ gravity[2] = q[0]*q[0] - q[1]*q[1] - q[2]*q[2] + q[3]*q[3];
+
+ // calculate Euler angles
+ euler[0] = atan2(2*q[1]*q[2] - 2*q[0]*q[3], 2*q[0]*q[0] + 2*q[1]*q[1] - 1);
+ euler[1] = -asin(2*q[1]*q[3] + 2*q[0]*q[2]);
+ euler[2] = atan2(2*q[2]*q[3] - 2*q[0]*q[1], 2*q[0]*q[0] + 2*q[3]*q[3] - 1);
+
+ // calculate yaw/pitch/roll angles
+ ypr[0] = atan2(2*q[1]*q[2] - 2*q[0]*q[3], 2*q[0]*q[0] + 2*q[1]*q[1] - 1);
+ ypr[1] = atan(gravity[0] / sqrt(gravity[1]*gravity[1] + gravity[2]*gravity[2]));
+ ypr[2] = atan(gravity[1] / sqrt(gravity[0]*gravity[0] + gravity[2]*gravity[2]));
+
+ // output various components for debugging
+ //println("q:\t" + round(q[0]*100.0f)/100.0f + "\t" + round(q[1]*100.0f)/100.0f + "\t" + round(q[2]*100.0f)/100.0f + "\t" + round(q[3]*100.0f)/100.0f);
+ //println("euler:\t" + euler[0]*180.0f/PI + "\t" + euler[1]*180.0f/PI + "\t" + euler[2]*180.0f/PI);
+ //println("ypr:\t" + ypr[0]*180.0f/PI + "\t" + ypr[1]*180.0f/PI + "\t" + ypr[2]*180.0f/PI);
+ */
+ }
+ }
+ }
+ }
+}
+
+void drawCylinder(float topRadius, float bottomRadius, float tall, int sides) {
+ float angle = 0;
+ float angleIncrement = TWO_PI / sides;
+ beginShape(QUAD_STRIP);
+ for (int i = 0; i < sides + 1; ++i) {
+ vertex(topRadius*cos(angle), 0, topRadius*sin(angle));
+ vertex(bottomRadius*cos(angle), tall, bottomRadius*sin(angle));
+ angle += angleIncrement;
+ }
+ endShape();
+
+ // If it is not a cone, draw the circular top cap
+ if (topRadius != 0) {
+ angle = 0;
+ beginShape(TRIANGLE_FAN);
+
+ // Center point
+ vertex(0, 0, 0);
+ for (int i = 0; i < sides + 1; i++) {
+ vertex(topRadius * cos(angle), 0, topRadius * sin(angle));
+ angle += angleIncrement;
+ }
+ endShape();
+ }
+
+ // If it is not a cone, draw the circular bottom cap
+ if (bottomRadius != 0) {
+ angle = 0;
+ beginShape(TRIANGLE_FAN);
+
+ // Center point
+ vertex(0, tall, 0);
+ for (int i = 0; i < sides + 1; i++) {
+ vertex(bottomRadius * cos(angle), tall, bottomRadius * sin(angle));
+ angle += angleIncrement;
+ }
+ endShape();
+ }
+}
94 firmware/MPU6050/Examples/MPU6050_raw/MPU6050_raw.ino
@@ -0,0 +1,94 @@
+// I2C device class (I2Cdev) demonstration Arduino sketch for MPU6050 class
+// 10/7/2011 by Jeff Rowberg <jeff@rowberg.net>
+// Updates should (hopefully) always be available at https://github.com/jrowberg/i2cdevlib
+//
+// Changelog:
+// 2011-10-07 - initial release
+
+/* ============================================
+I2Cdev device library code is placed under the MIT license
+Copyright (c) 2011 Jeff Rowberg
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in
+all copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
+THE SOFTWARE.
+===============================================
+*/
+
+// Arduino Wire library is required if I2Cdev I2CDEV_ARDUINO_WIRE implementation
+// is used in I2Cdev.h
+#include "Wire.h"
+
+// I2Cdev and MPU6050 must be installed as libraries, or else the .cpp/.h files
+// for both classes must be in the include path of your project
+#include "I2Cdev.h"
+#include "MPU6050.h"
+
+// class default I2C address is 0x68
+// specific I2C addresses may be passed as a parameter here
+// AD0 low = 0x68 (default for InvenSense evaluation board)
+// AD0 high = 0x69
+MPU6050 accelgyro;
+
+int16_t ax, ay, az;
+int16_t gx, gy, gz;
+
+#define LED_PIN 13
+bool blinkState = false;
+
+void setup() {
+ // join I2C bus (I2Cdev library doesn't do this automatically)
+ Wire.begin();
+
+ // initialize serial communication
+ // (38400 chosen because it works as well at 8MHz as it does at 16MHz, but
+ // it's really up to you depending on your project)
+ Serial.begin(38400);
+
+ // initialize device
+ Serial.println("Initializing I2C devices...");
+ accelgyro.initialize();
+
+ // verify connection
+ Serial.println("Testing device connections...");
+ Serial.println(accelgyro.testConnection() ? "MPU6050 connection successful" : "MPU6050 connection failed");
+
+ // configure Arduino LED for
+ pinMode(LED_PIN, OUTPUT);
+}
+
+void loop() {
+ // read raw accel/gyro measurements from device
+ accelgyro.getMotion6(&ax, &ay, &az, &gx, &gy, &gz);
+
+ // these methods (and a few others) are also available
+ //accelgyro.getAcceleration(&ax, &ay, &az);
+ //accelgyro.getRotation(&gx, &gy, &gz);
+
+ // display tab-separated accel/gyro x/y/z values
+ Serial.print("a/g:\t");
+ Serial.print(ax); Serial.print("\t");
+ Serial.print(ay); Serial.print("\t");
+ Serial.print(az); Serial.print("\t");
+ Serial.print(gx); Serial.print("\t");
+ Serial.print(gy); Serial.print("\t");
+ Serial.println(gz);
+
+ // blink LED to indicate activity
+ blinkState = !blinkState;
+ digitalWrite(LED_PIN, blinkState);
+}
98 firmware/MPU6050/Examples/MPU9150_raw/MPU9150_raw.ino
@@ -0,0 +1,98 @@
+// I2C device class (I2Cdev) demonstration Arduino sketch for MPU9150
+// 1/4/2013 original by Jeff Rowberg <jeff@rowberg.net> at https://github.com/jrowberg/i2cdevlib
+// modified by Aaron Weiss <aaron@sparkfun.com>
+//
+// Changelog:
+// 2011-10-07 - initial release
+// 2013-1-4 - added raw magnetometer output
+
+/* ============================================
+I2Cdev device library code is placed under the MIT license
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in
+all copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
+THE SOFTWARE.
+===============================================
+*/
+
+// Arduino Wire library is required if I2Cdev I2CDEV_ARDUINO_WIRE implementation
+// is used in I2Cdev.h
+#include "Wire.h"
+
+// I2Cdev and MPU6050 must be installed as libraries, or else the .cpp/.h files
+// for both classes must be in the include path of your project
+#include "I2Cdev.h"
+#include "MPU6050.h"
+
+// class default I2C address is 0x68
+// specific I2C addresses may be passed as a parameter here
+// AD0 low = 0x68 (default for InvenSense evaluation board)
+// AD0 high = 0x69
+MPU6050 accelgyro;
+
+int16_t ax, ay, az;
+int16_t gx, gy, gz;
+int16_t mx, my, mz;
+
+#define LED_PIN 13
+bool blinkState = false;
+
+void setup() {
+ // join I2C bus (I2Cdev library doesn't do this automatically)
+ Wire.begin();
+
+ // initialize serial communication
+ // (38400 chosen because it works as well at 8MHz as it does at 16MHz, but
+ // it's really up to you depending on your project)
+ Serial.begin(38400);
+
+ // initialize device
+ Serial.println("Initializing I2C devices...");
+ accelgyro.initialize();
+
+ // verify connection
+ Serial.println("Testing device connections...");
+ Serial.println(accelgyro.testConnection() ? "MPU6050 connection successful" : "MPU6050 connection failed");
+
+ // configure Arduino LED for
+ pinMode(LED_PIN, OUTPUT);
+}
+
+void loop() {
+ // read raw accel/gyro measurements from device
+ accelgyro.getMotion9(&ax, &ay, &az, &gx, &gy, &gz, &mx, &my, &mz);
+
+ // these methods (and a few others) are also available
+ //accelgyro.getAcceleration(&ax, &ay, &az);
+ //accelgyro.getRotation(&gx, &gy, &gz);
+
+ // display tab-separated accel/gyro x/y/z values
+ Serial.print("a/g/m:\t");
+ Serial.print(ax); Serial.print("\t");
+ Serial.print(ay); Serial.print("\t");
+ Serial.print(az); Serial.print("\t");
+ Serial.print(gx); Serial.print("\t");
+ Serial.print(gy); Serial.print("\t");
+ Serial.print(gz); Serial.print("\t");
+ Serial.print(mx); Serial.print("\t");
+ Serial.print(my); Serial.print("\t");
+ Serial.println(mz);
+
+ // blink LED to indicate activity
+ blinkState = !blinkState;
+ digitalWrite(LED_PIN, blinkState);
+}
3,151 firmware/MPU6050/MPU6050.cpp
3,151 additions, 0 deletions not shown
994 firmware/MPU6050/MPU6050.h
<
@@ -0,0 +1,994 @@
+// I2Cdev library collection - MPU6050 I2C device class
+// Based on InvenSense MPU-6050 register map document rev. 2.0, 5/19/2011 (RM-MPU-6000A-00)
+// 10/3/2011 by Jeff Rowberg <jeff@rowberg.net>
+// Updates should (hopefully) always be available at https://github.com/jrowberg/i2cdevlib
+//
+// Changelog:
+// ... - ongoing debug release
+
+// NOTE: THIS IS ONLY A PARIAL RELEASE. THIS DEVICE CLASS IS CURRENTLY UNDERGOING ACTIVE
+// DEVELOPMENT AND IS STILL MISSING SOME IMPORTANT FEATURES. PLEASE KEEP THIS IN MIND IF
+// YOU DECIDE TO USE THIS PARTICULAR CODE FOR ANYTHING.
+
+/* ============================================
+I2Cdev device library code is placed under the MIT license
+Copyright (c) 2012 Jeff Rowberg
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in
+all copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
+THE SOFTWARE.
+===============================================
+*/
+
+#ifndef _MPU6050_H_
+#define _MPU6050_H_
+
+#include "I2Cdev.h"
+#include <avr/pgmspace.h>
+
+//Magnetometer Registers
+#define MPU9150_RA_MAG_ADDRESS 0x0C
+#define MPU9150_RA_MAG_XOUT_L 0x03
+#define MPU9150_RA_MAG_XOUT_H 0x04
+#define MPU9150_RA_MAG_YOUT_L 0x05
+#define MPU9150_RA_MAG_YOUT_H 0x06
+#define MPU9150_RA_MAG_ZOUT_L 0x07
+#define MPU9150_RA_MAG_ZOUT_H 0x08
+
+#define MPU6050_ADDRESS_AD0_LOW 0x68 // address pin low (GND), default for InvenSense evaluation board
+#define MPU6050_ADDRESS_AD0_HIGH 0x69 // address pin high (VCC)
+#define MPU6050_DEFAULT_ADDRESS MPU6050_ADDRESS_AD0_LOW
+
+#define MPU6050_RA_XG_OFFS_TC 0x00 //[7] PWR_MODE, [6:1] XG_OFFS_TC, [0] OTP_BNK_VLD
+#define MPU6050_RA_YG_OFFS_TC 0x01 //[7] PWR_MODE, [6:1] YG_OFFS_TC, [0] OTP_BNK_VLD
+#define MPU6050_RA_ZG_OFFS_TC 0x02 //[7] PWR_MODE, [6:1] ZG_OFFS_TC, [0] OTP_BNK_VLD
+#define MPU6050_RA_X_FINE_GAIN 0x03 //[7:0] X_FINE_GAIN
+#define MPU6050_RA_Y_FINE_GAIN 0x04 //[7:0] Y_FINE_GAIN
+#define MPU6050_RA_Z_FINE_GAIN 0x05 //[7:0] Z_FINE_GAIN
+#define MPU6050_RA_XA_OFFS_H 0x06 //[15:0] XA_OFFS
+#define MPU6050_RA_XA_OFFS_L_TC 0x07
+#define MPU6050_RA_YA_OFFS_H 0x08 //[15:0] YA_OFFS
+#define MPU6050_RA_YA_OFFS_L_TC 0x09
+#define MPU6050_RA_ZA_OFFS_H 0x0A //[15:0] ZA_OFFS
+#define MPU6050_RA_ZA_OFFS_L_TC 0x0B
+#define MPU6050_RA_XG_OFFS_USRH 0x13 //[15:0] XG_OFFS_USR
+#define MPU6050_RA_XG_OFFS_USRL 0x14
+#define MPU6050_RA_YG_OFFS_USRH 0x15 //[15:0] YG_OFFS_USR
+#define MPU6050_RA_YG_OFFS_USRL 0x16
+#define MPU6050_RA_ZG_OFFS_USRH 0x17 //[15:0] ZG_OFFS_USR
+#define MPU6050_RA_ZG_OFFS_USRL 0x18
+#define MPU6050_RA_SMPLRT_DIV 0x19
+#define MPU6050_RA_CONFIG 0x1A
+#define MPU6050_RA_GYRO_CONFIG 0x1B
+#define MPU6050_RA_ACCEL_CONFIG 0x1C
+#define MPU6050_RA_FF_THR 0x1D
+#define MPU6050_RA_FF_DUR 0x1E
+#define MPU6050_RA_MOT_THR 0x1F
+#define MPU6050_RA_MOT_DUR 0x20
+#define MPU6050_RA_ZRMOT_THR 0x21
+#define MPU6050_RA_ZRMOT_DUR 0x22
+#define MPU6050_RA_FIFO_EN 0x23
+#define MPU6050_RA_I2C_MST_CTRL 0x24
+#define MPU6050_RA_I2C_SLV0_ADDR 0x25
+#define MPU6050_RA_I2C_SLV0_REG 0x26
+#define MPU6050_RA_I2C_SLV0_CTRL 0x27
+#define MPU6050_RA_I2C_SLV1_ADDR 0x28
+#define MPU6050_RA_I2C_SLV1_REG 0x29
+#define MPU6050_RA_I2C_SLV1_CTRL 0x2A
+#define MPU6050_RA_I2C_SLV2_ADDR 0x2B
+#define MPU6050_RA_I2C_SLV2_REG 0x2C
+#define MPU6050_RA_I2C_SLV2_CTRL 0x2D
+#define MPU6050_RA_I2C_SLV3_ADDR 0x2E
+#define MPU6050_RA_I2C_SLV3_REG 0x2F
+#define MPU6050_RA_I2C_SLV3_CTRL 0x30
+#define MPU6050_RA_I2C_SLV4_ADDR 0x31
+#define MPU6050_RA_I2C_SLV4_REG 0x32
+#define MPU6050_RA_I2C_SLV4_DO 0x33
+#define MPU6050_RA_I2C_SLV4_CTRL 0x34
+#define MPU6050_RA_I2C_SLV4_DI 0x35
+#define MPU6050_RA_I2C_MST_STATUS 0x36
+#define MPU6050_RA_INT_PIN_CFG 0x37
+#define MPU6050_RA_INT_ENABLE 0x38
+#define MPU6050_RA_DMP_INT_STATUS 0x39
+#define MPU6050_RA_INT_STATUS 0x3A
+#define MPU6050_RA_ACCEL_XOUT_H 0x3B
+#define MPU6050_RA_ACCEL_XOUT_L 0x3C
+#define MPU6050_RA_ACCEL_YOUT_H 0x3D
+#define MPU6050_RA_ACCEL_YOUT_L 0x3E
+#define MPU6050_RA_ACCEL_ZOUT_H 0x3F
+#define MPU6050_RA_ACCEL_ZOUT_L 0x40
+#define MPU6050_RA_TEMP_OUT_H 0x41
+#define MPU6050_RA_TEMP_OUT_L 0x42
+#define MPU6050_RA_GYRO_XOUT_H 0x43
+#define MPU6050_RA_GYRO_XOUT_L 0x44
+#define MPU6050_RA_GYRO_YOUT_H 0x45
+#define MPU6050_RA_GYRO_YOUT_L 0x46
+#define MPU6050_RA_GYRO_ZOUT_H 0x47
+#define MPU6050_RA_GYRO_ZOUT_L 0x48
+#define MPU6050_RA_EXT_SENS_DATA_00 0x49
+#define MPU6050_RA_EXT_SENS_DATA_01 0x4A
+#define MPU6050_RA_EXT_SENS_DATA_02 0x4B
+#define MPU6050_RA_EXT_SENS_DATA_03 0x4C
+#define MPU6050_RA_EXT_SENS_DATA_04 0x4D
+#define MPU6050_RA_EXT_SENS_DATA_05 0x4E
+#define MPU6050_RA_EXT_SENS_DATA_06 0x4F
+#define MPU6050_RA_EXT_SENS_DATA_07 0x50
+#define MPU6050_RA_EXT_SENS_DATA_08 0x51
+#define MPU6050_RA_EXT_SENS_DATA_09 0x52
+#define MPU6050_RA_EXT_SENS_DATA_10 0x53
+#define MPU6050_RA_EXT_SENS_DATA_11 0x54
+#define MPU6050_RA_EXT_SENS_DATA_12 0x55
+#define MPU6050_RA_EXT_SENS_DATA_13 0x56
+#define MPU6050_RA_EXT_SENS_DATA_14 0x57
+#define MPU6050_RA_EXT_SENS_DATA_15 0x58
+#define MPU6050_RA_EXT_SENS_DATA_16 0x59