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