I2Cdev2.cpp

00001 // ported from arduino library: https://github.com/jrowberg/i2cdevlib
00002 // written by szymon gaertig (email: szymon@gaertig.com.pl, website: szymongaertig.pl)
00003 // Changelog:
00004 // 2013-01-08 - first release
00005 
00006 #include "I2Cdev2.h"
00007 
00008 //#define useDebugSerial
00009 
00010 I2Cdev2::I2Cdev2(): i2c(I2C2_SDA,I2C2_SCL)//, debugSerial(USBTX, USBRX)
00011 {
00012 
00013 }
00014 
00015 I2Cdev2::I2Cdev2(PinName i2cSda, PinName i2cScl): i2c(i2cSda,i2cScl)//, debugSerial(USBTX, USBRX)
00016 {
00017 
00018 }
00019 
00020 /** Read a single bit from an 8-bit device register.
00021  * @param devAddr I2C slave device address
00022  * @param regAddr Register regAddr to read from
00023  * @param bitNum Bit position to read (0-7)
00024  * @param data Container for single bit value
00025  * @param timeout Optional read timeout in milliseconds (0 to disable, leave off to use default class value in I2Cdev2::readTimeout)
00026  * @return Status of read operation (true = success)
00027  */
00028 int8_t I2Cdev2::readBit(uint8_t devAddr, uint8_t regAddr, uint8_t bitNum, uint8_t *data, uint16_t timeout) {
00029     uint8_t b;
00030     uint8_t count = readByte(devAddr, regAddr, &b, timeout);
00031     *data = b & (1 << bitNum);
00032     return count;
00033 }
00034 
00035 /** Read a single bit from a 16-bit device register.
00036  * @param devAddr I2C slave device address
00037  * @param regAddr Register regAddr to read from
00038  * @param bitNum Bit position to read (0-15)
00039  * @param data Container for single bit value
00040  * @param timeout Optional read timeout in milliseconds (0 to disable, leave off to use default class value in I2Cdev2::readTimeout)
00041  * @return Status of read operation (true = success)
00042  */
00043 int8_t I2Cdev2::readBitW(uint8_t devAddr, uint8_t regAddr, uint8_t bitNum, uint16_t *data, uint16_t timeout) {
00044     uint16_t b;
00045     uint8_t count = readWord(devAddr, regAddr, &b, timeout);
00046     *data = b & (1 << bitNum);
00047     return count;
00048 }
00049 
00050 /** Read multiple bits from an 8-bit device register.
00051  * @param devAddr I2C slave device address
00052  * @param regAddr Register regAddr to read from
00053  * @param bitStart First bit position to read (0-7)
00054  * @param length Number of bits to read (not more than 8)
00055  * @param data Container for right-aligned value (i.e. '101' read from any bitStart position will equal 0x05)
00056  * @param timeout Optional read timeout in milliseconds (0 to disable, leave off to use default class value in I2Cdev2::readTimeout)
00057  * @return Status of read operation (true = success)
00058  */
00059 int8_t I2Cdev2::readBits(uint8_t devAddr, uint8_t regAddr, uint8_t bitStart, uint8_t length, uint8_t *data, uint16_t timeout) {
00060     // 01101001 read byte
00061     // 76543210 bit numbers
00062     //    xxx   args: bitStart=4, length=3
00063     //    010   masked
00064     //   -> 010 shifted
00065     uint8_t count, b;
00066     if ((count = readByte(devAddr, regAddr, &b, timeout)) != 0) {
00067         uint8_t mask = ((1 << length) - 1) << (bitStart - length + 1);
00068         b &= mask;
00069         b >>= (bitStart - length + 1);
00070         *data = b;
00071     }
00072     return count;
00073 }
00074 
00075 /** Read multiple bits from a 16-bit device register.
00076  * @param devAddr I2C slave device address
00077  * @param regAddr Register regAddr to read from
00078  * @param bitStart First bit position to read (0-15)
00079  * @param length Number of bits to read (not more than 16)
00080  * @param data Container for right-aligned value (i.e. '101' read from any bitStart position will equal 0x05)
00081  * @param timeout Optional read timeout in milliseconds (0 to disable, leave off to use default class value in I2Cdev2::readTimeout)
00082  * @return Status of read operation (1 = success, 0 = failure, -1 = timeout)
00083  */
00084 int8_t I2Cdev2::readBitsW(uint8_t devAddr, uint8_t regAddr, uint8_t bitStart, uint8_t length, uint16_t *data, uint16_t timeout) {
00085     // 1101011001101001 read byte
00086     // fedcba9876543210 bit numbers
00087     //    xxx           args: bitStart=12, length=3
00088     //    010           masked
00089     //           -> 010 shifted
00090     uint8_t count;
00091     uint16_t w;
00092     if ((count = readWord(devAddr, regAddr, &w, timeout)) != 0) {
00093         uint16_t mask = ((1 << length) - 1) << (bitStart - length + 1);
00094         w &= mask;
00095         w >>= (bitStart - length + 1);
00096         *data = w;
00097     }
00098     return count;
00099 }
00100 /** Read single byte from an 8-bit device register.
00101  * @param devAddr I2C slave device address
00102  * @param regAddr Register regAddr to read from
00103  * @param data Container for byte value read from device
00104  * @param timeout Optional read timeout in milliseconds (0 to disable, leave off to use default class value in I2Cdev2::readTimeout)
00105  * @return Status of read operation (true = success)
00106  */
00107 int8_t I2Cdev2::readByte(uint8_t devAddr, uint8_t regAddr, uint8_t *data, uint16_t timeout) {
00108     return readBytes(devAddr, regAddr, 1, data, timeout);
00109 }
00110 
00111 /** Read single word from a 16-bit device register.
00112  * @param devAddr I2C slave device address
00113  * @param regAddr Register regAddr to read from
00114  * @param data Container for word value read from device
00115  * @param timeout Optional read timeout in milliseconds (0 to disable, leave off to use default class value in I2Cdev2::readTimeout)
00116  * @return Status of read operation (true = success)
00117  */
00118 int8_t I2Cdev2::readWord(uint8_t devAddr, uint8_t regAddr, uint16_t *data, uint16_t timeout) {
00119     return readWords(devAddr, regAddr, 1, data, timeout);
00120 }
00121 
00122 /** Read multiple bytes from an 8-bit device register.
00123  * @param devAddr I2C slave device address
00124  * @param regAddr First register regAddr to read from
00125  * @param length Number of bytes to read
00126  * @param data Buffer to store read data in
00127  * @param timeout Optional read timeout in milliseconds (0 to disable, leave off to use default class value in I2Cdev2::readTimeout)
00128  * @return Number of bytes read (-1 indicates failure)
00129  */
00130 int8_t I2Cdev2::readBytes(uint8_t devAddr, uint8_t regAddr, uint8_t length, uint8_t *data, uint16_t timeout)
00131 {
00132     char command[1];
00133     command[0] = regAddr;
00134     char *redData = (char*)malloc(length);
00135     i2c.write(devAddr<<1, command, 1, true);
00136     i2c.read(devAddr<<1, redData, length);
00137     for(int i =0; i < length; i++) {
00138         data[i] = redData[i];
00139     }
00140     free (redData);
00141     return length;
00142 }
00143 
00144 int8_t I2Cdev2::readWords(uint8_t devAddr, uint8_t regAddr, uint8_t length, uint16_t *data, uint16_t timeout)
00145 {
00146     return 0;
00147 }
00148 
00149 /** write a single bit in an 8-bit device register.
00150  * @param devAddr I2C slave device address
00151  * @param regAddr Register regAddr to write to
00152  * @param bitNum Bit position to write (0-7)
00153  * @param value New bit value to write
00154  * @return Status of operation (true = success)
00155  */
00156 bool I2Cdev2::writeBit(uint8_t devAddr, uint8_t regAddr, uint8_t bitNum, uint8_t data) {
00157     uint8_t b;
00158     readByte(devAddr, regAddr, &b);
00159     b = (data != 0) ? (b | (1 << bitNum)) : (b & ~(1 << bitNum));
00160     return writeByte(devAddr, regAddr, b);
00161 }
00162 
00163 /** write a single bit in a 16-bit device register.
00164  * @param devAddr I2C slave device address
00165  * @param regAddr Register regAddr to write to
00166  * @param bitNum Bit position to write (0-15)
00167  * @param value New bit value to write
00168  * @return Status of operation (true = success)
00169  */
00170 bool I2Cdev2::writeBitW(uint8_t devAddr, uint8_t regAddr, uint8_t bitNum, uint16_t data) {
00171     uint16_t w;
00172     readWord(devAddr, regAddr, &w);
00173     w = (data != 0) ? (w | (1 << bitNum)) : (w & ~(1 << bitNum));
00174     return writeWord(devAddr, regAddr, w);
00175 }
00176 
00177 /** Write multiple bits in an 8-bit device register.
00178  * @param devAddr I2C slave device address
00179  * @param regAddr Register regAddr to write to
00180  * @param bitStart First bit position to write (0-7)
00181  * @param length Number of bits to write (not more than 8)
00182  * @param data Right-aligned value to write
00183  * @return Status of operation (true = success)
00184  */
00185 bool I2Cdev2::writeBits(uint8_t devAddr, uint8_t regAddr, uint8_t bitStart, uint8_t length, uint8_t data) {
00186     //      010 value to write
00187     // 76543210 bit numbers
00188     //    xxx   args: bitStart=4, length=3
00189     // 00011100 mask byte
00190     // 10101111 original value (sample)
00191     // 10100011 original & ~mask
00192     // 10101011 masked | value
00193     uint8_t b;
00194     if (readByte(devAddr, regAddr, &b) != 0) {
00195         uint8_t mask = ((1 << length) - 1) << (bitStart - length + 1);
00196         data <<= (bitStart - length + 1); // shift data into correct position
00197         data &= mask; // zero all non-important bits in data
00198         b &= ~(mask); // zero all important bits in existing byte
00199         b |= data; // combine data with existing byte
00200         return writeByte(devAddr, regAddr, b);
00201     } else {
00202         return false;
00203     }
00204 }
00205 
00206 /** Write multiple bits in a 16-bit device register.
00207  * @param devAddr I2C slave device address
00208  * @param regAddr Register regAddr to write to
00209  * @param bitStart First bit position to write (0-15)
00210  * @param length Number of bits to write (not more than 16)
00211  * @param data Right-aligned value to write
00212  * @return Status of operation (true = success)
00213  */
00214 bool I2Cdev2::writeBitsW(uint8_t devAddr, uint8_t regAddr, uint8_t bitStart, uint8_t length, uint16_t data) {
00215     //              010 value to write
00216     // fedcba9876543210 bit numbers
00217     //    xxx           args: bitStart=12, length=3
00218     // 0001110000000000 mask byte
00219     // 1010111110010110 original value (sample)
00220     // 1010001110010110 original & ~mask
00221     // 1010101110010110 masked | value
00222     uint16_t w;
00223     if (readWord(devAddr, regAddr, &w) != 0) {
00224         uint8_t mask = ((1 << length) - 1) << (bitStart - length + 1);
00225         data <<= (bitStart - length + 1); // shift data into correct position
00226         data &= mask; // zero all non-important bits in data
00227         w &= ~(mask); // zero all important bits in existing word
00228         w |= data; // combine data with existing word
00229         return writeWord(devAddr, regAddr, w);
00230     } else {
00231         return false;
00232     }
00233 }
00234 
00235 /** Write single byte to an 8-bit device register.
00236  * @param devAddr I2C slave device address
00237  * @param regAddr Register address to write to
00238  * @param data New byte value to write
00239  * @return Status of operation (true = success)
00240  */
00241 bool I2Cdev2::writeByte(uint8_t devAddr, uint8_t regAddr, uint8_t data) {
00242     return writeBytes(devAddr, regAddr, 1, &data);
00243 }
00244 
00245 /** Write single word to a 16-bit device register.
00246  * @param devAddr I2C slave device address
00247  * @param regAddr Register address to write to
00248  * @param data New word value to write
00249  * @return Status of operation (true = success)
00250  */
00251 bool I2Cdev2::writeWord(uint8_t devAddr, uint8_t regAddr, uint16_t data) {
00252     return writeWords(devAddr, regAddr, 1, &data);
00253 }
00254 
00255 bool I2Cdev2::writeBytes(uint8_t devAddr, uint8_t regAddr, uint8_t length, uint8_t *data)
00256 {
00257     i2c.start();
00258     i2c.write(devAddr<<1);
00259     i2c.write(regAddr);
00260     for(int i = 0; i < length; i++) {
00261         i2c.write(data[i]);
00262     }
00263     i2c.stop();
00264     return true;
00265 }
00266 
00267 bool I2Cdev2::writeWords(uint8_t devAddr, uint8_t regAddr, uint8_t length, uint16_t *data)
00268 {
00269     return true;
00270 }
00271 
00272 uint16_t I2Cdev2::readTimeout(void)
00273 {
00274     return 0;
00275 }