Skip to content
This repository was archived by the owner on Feb 28, 2024. It is now read-only.

Commit 688d157

Browse files
leonardocavagnisleonardocavagnis
authoredJan 24, 2024
Merge pull request #120 from leonardocavagnis/i2cdevlib_update
Update I2CDev library
·
1.1.2
2 parents ca7ff9b + bd65147 commit 688d157

File tree

2 files changed

+173
-156
lines changed

2 files changed

+173
-156
lines changed
 

‎src/utility/ioexpander/I2Cdev.cpp

Lines changed: 130 additions & 135 deletions
Original file line numberDiff line numberDiff line change
@@ -3,6 +3,9 @@
33
// 2013-06-05 by Jeff Rowberg <jeff@rowberg.net>
44
//
55
// Changelog:
6+
// 2021-09-28 - allow custom Wire object as transaction function argument
7+
// 2020-01-20 - hardija : complete support for Teensy 3.x
8+
// 2015-10-30 - simondlevy : support i2c_t3 for Teensy3.1
69
// 2013-05-06 - add Francesco Ferrara's Fastwire v0.24 implementation with small modifications
710
// 2013-05-05 - fix issue with writing bit values to words (Sasquatch/Farzanegan)
811
// 2012-06-09 - fix major issue with reading > 32 bytes at a time with Arduino Wire
@@ -87,11 +90,6 @@ THE SOFTWARE.
8790

8891
#endif
8992

90-
#ifndef BUFFER_LENGTH
91-
// band-aid fix for platforms without Wire-defined BUFFER_LENGTH (removed from some official implementations)
92-
#define BUFFER_LENGTH 32
93-
#endif
94-
9593
/** Default constructor.
9694
*/
9795
I2Cdev::I2Cdev() {
@@ -105,9 +103,9 @@ I2Cdev::I2Cdev() {
105103
* @param timeout Optional read timeout in milliseconds (0 to disable, leave off to use default class value in I2Cdev::readTimeout)
106104
* @return Status of read operation (true = success)
107105
*/
108-
int8_t I2Cdev::readBit(uint8_t devAddr, uint8_t regAddr, uint8_t bitNum, uint8_t *data, uint16_t timeout) {
106+
int8_t I2Cdev::readBit(uint8_t devAddr, uint8_t regAddr, uint8_t bitNum, uint8_t *data, uint16_t timeout, void *wireObj) {
109107
uint8_t b;
110-
uint8_t count = readByte(devAddr, regAddr, &b, timeout);
108+
uint8_t count = readByte(devAddr, regAddr, &b, timeout, wireObj);
111109
*data = b & (1 << bitNum);
112110
return count;
113111
}
@@ -120,9 +118,9 @@ int8_t I2Cdev::readBit(uint8_t devAddr, uint8_t regAddr, uint8_t bitNum, uint8_t
120118
* @param timeout Optional read timeout in milliseconds (0 to disable, leave off to use default class value in I2Cdev::readTimeout)
121119
* @return Status of read operation (true = success)
122120
*/
123-
int8_t I2Cdev::readBitW(uint8_t devAddr, uint8_t regAddr, uint8_t bitNum, uint16_t *data, uint16_t timeout) {
121+
int8_t I2Cdev::readBitW(uint8_t devAddr, uint8_t regAddr, uint8_t bitNum, uint16_t *data, uint16_t timeout, void *wireObj) {
124122
uint16_t b;
125-
uint8_t count = readWord(devAddr, regAddr, &b, timeout);
123+
uint8_t count = readWord(devAddr, regAddr, &b, timeout, wireObj);
126124
*data = b & (1 << bitNum);
127125
return count;
128126
}
@@ -136,14 +134,14 @@ int8_t I2Cdev::readBitW(uint8_t devAddr, uint8_t regAddr, uint8_t bitNum, uint16
136134
* @param timeout Optional read timeout in milliseconds (0 to disable, leave off to use default class value in I2Cdev::readTimeout)
137135
* @return Status of read operation (true = success)
138136
*/
139-
int8_t I2Cdev::readBits(uint8_t devAddr, uint8_t regAddr, uint8_t bitStart, uint8_t length, uint8_t *data, uint16_t timeout) {
137+
int8_t I2Cdev::readBits(uint8_t devAddr, uint8_t regAddr, uint8_t bitStart, uint8_t length, uint8_t *data, uint16_t timeout, void *wireObj) {
140138
// 01101001 read byte
141139
// 76543210 bit numbers
142140
// xxx args: bitStart=4, length=3
143141
// 010 masked
144142
// -> 010 shifted
145143
uint8_t count, b;
146-
if ((count = readByte(devAddr, regAddr, &b, timeout)) != 0) {
144+
if ((count = readByte(devAddr, regAddr, &b, timeout, wireObj)) != 0) {
147145
uint8_t mask = ((1 << length) - 1) << (bitStart - length + 1);
148146
b &= mask;
149147
b >>= (bitStart - length + 1);
@@ -161,15 +159,15 @@ int8_t I2Cdev::readBits(uint8_t devAddr, uint8_t regAddr, uint8_t bitStart, uint
161159
* @param timeout Optional read timeout in milliseconds (0 to disable, leave off to use default class value in I2Cdev::readTimeout)
162160
* @return Status of read operation (1 = success, 0 = failure, -1 = timeout)
163161
*/
164-
int8_t I2Cdev::readBitsW(uint8_t devAddr, uint8_t regAddr, uint8_t bitStart, uint8_t length, uint16_t *data, uint16_t timeout) {
162+
int8_t I2Cdev::readBitsW(uint8_t devAddr, uint8_t regAddr, uint8_t bitStart, uint8_t length, uint16_t *data, uint16_t timeout, void *wireObj) {
165163
// 1101011001101001 read byte
166164
// fedcba9876543210 bit numbers
167165
// xxx args: bitStart=12, length=3
168166
// 010 masked
169167
// -> 010 shifted
170168
uint8_t count;
171169
uint16_t w;
172-
if ((count = readWord(devAddr, regAddr, &w, timeout)) != 0) {
170+
if ((count = readWord(devAddr, regAddr, &w, timeout, wireObj)) != 0) {
173171
uint16_t mask = ((1 << length) - 1) << (bitStart - length + 1);
174172
w &= mask;
175173
w >>= (bitStart - length + 1);
@@ -185,8 +183,8 @@ int8_t I2Cdev::readBitsW(uint8_t devAddr, uint8_t regAddr, uint8_t bitStart, uin
185183
* @param timeout Optional read timeout in milliseconds (0 to disable, leave off to use default class value in I2Cdev::readTimeout)
186184
* @return Status of read operation (true = success)
187185
*/
188-
int8_t I2Cdev::readByte(uint8_t devAddr, uint8_t regAddr, uint8_t *data, uint16_t timeout) {
189-
return readBytes(devAddr, regAddr, 1, data, timeout);
186+
int8_t I2Cdev::readByte(uint8_t devAddr, uint8_t regAddr, uint8_t *data, uint16_t timeout, void *wireObj) {
187+
return readBytes(devAddr, regAddr, 1, data, timeout, wireObj);
190188
}
191189

192190
/** Read single word from a 16-bit device register.
@@ -196,8 +194,8 @@ int8_t I2Cdev::readByte(uint8_t devAddr, uint8_t regAddr, uint8_t *data, uint16_
196194
* @param timeout Optional read timeout in milliseconds (0 to disable, leave off to use default class value in I2Cdev::readTimeout)
197195
* @return Status of read operation (true = success)
198196
*/
199-
int8_t I2Cdev::readWord(uint8_t devAddr, uint8_t regAddr, uint16_t *data, uint16_t timeout) {
200-
return readWords(devAddr, regAddr, 1, data, timeout);
197+
int8_t I2Cdev::readWord(uint8_t devAddr, uint8_t regAddr, uint16_t *data, uint16_t timeout, void *wireObj) {
198+
return readWords(devAddr, regAddr, 1, data, timeout, wireObj);
201199
}
202200

203201
/** Read multiple bytes from an 8-bit device register.
@@ -208,7 +206,7 @@ int8_t I2Cdev::readWord(uint8_t devAddr, uint8_t regAddr, uint16_t *data, uint16
208206
* @param timeout Optional read timeout in milliseconds (0 to disable, leave off to use default class value in I2Cdev::readTimeout)
209207
* @return Number of bytes read (-1 indicates failure)
210208
*/
211-
int8_t I2Cdev::readBytes(uint8_t devAddr, uint8_t regAddr, uint8_t length, uint8_t *data, uint16_t timeout) {
209+
int8_t I2Cdev::readBytes(uint8_t devAddr, uint8_t regAddr, uint8_t length, uint8_t *data, uint16_t timeout, void *wireObj) {
212210
#ifdef I2CDEV_SERIAL_DEBUG
213211
Serial.print("I2C (0x");
214212
Serial.print(devAddr, HEX);
@@ -219,74 +217,66 @@ int8_t I2Cdev::readBytes(uint8_t devAddr, uint8_t regAddr, uint8_t length, uint8
219217
Serial.print("...");
220218
#endif
221219

222-
int8_t count = 0;
220+
uint8_t count = 0;
223221
uint32_t t1 = millis();
224222

225223
#if (I2CDEV_IMPLEMENTATION == I2CDEV_ARDUINO_WIRE || I2CDEV_IMPLEMENTATION == I2CDEV_BUILTIN_SBWIRE || I2CDEV_IMPLEMENTATION == I2CDEV_TEENSY_3X_WIRE)
224+
TwoWire *useWire = &Wire;
225+
if (wireObj) useWire = (TwoWire *)wireObj;
226226

227227
#if (ARDUINO < 100)
228228
// Arduino v00xx (before v1.0), Wire library
229229

230230
// I2C/TWI subsystem uses internal buffer that breaks with large data requests
231-
// so if user requests more than BUFFER_LENGTH bytes, we have to do it in
231+
// so if user requests more than I2CDEVLIB_WIRE_BUFFER_LENGTH bytes, we have to do it in
232232
// smaller chunks instead of all at once
233-
for (uint8_t k = 0; k < length; k += min((int)length, BUFFER_LENGTH)) {
234-
Wire.beginTransmission(devAddr);
235-
Wire.send(regAddr);
236-
Wire.endTransmission();
237-
Wire.beginTransmission(devAddr);
238-
Wire.requestFrom(devAddr, (uint8_t)min(length - k, BUFFER_LENGTH));
239-
240-
for (; Wire.available() && (timeout == 0 || millis() - t1 < timeout); count++) {
241-
data[count] = Wire.receive();
233+
for (int k = 0; k < length; k += min((int)length, I2CDEVLIB_WIRE_BUFFER_LENGTH)) {
234+
useWire->beginTransmission(devAddr);
235+
useWire->send(regAddr);
236+
useWire->endTransmission();
237+
useWire->requestFrom((uint8_t)devAddr, (uint8_t)min((int)length - k, I2CDEVLIB_WIRE_BUFFER_LENGTH));
238+
for (; useWire->available() && (timeout == 0 || millis() - t1 < timeout); count++) {
239+
data[count] = useWire->receive();
242240
#ifdef I2CDEV_SERIAL_DEBUG
243241
Serial.print(data[count], HEX);
244242
if (count + 1 < length) Serial.print(" ");
245243
#endif
246244
}
247-
248-
Wire.endTransmission();
249245
}
250246
#elif (ARDUINO == 100)
251247
// Arduino v1.0.0, Wire library
252248
// Adds standardized write() and read() stream methods instead of send() and receive()
253249

254250
// I2C/TWI subsystem uses internal buffer that breaks with large data requests
255-
// so if user requests more than BUFFER_LENGTH bytes, we have to do it in
251+
// so if user requests more than I2CDEVLIB_WIRE_BUFFER_LENGTH bytes, we have to do it in
256252
// smaller chunks instead of all at once
257-
for (uint8_t k = 0; k < length; k += min((int)length, BUFFER_LENGTH)) {
258-
Wire.beginTransmission(devAddr);
259-
Wire.write(regAddr);
260-
Wire.endTransmission();
261-
Wire.beginTransmission(devAddr);
262-
Wire.requestFrom(devAddr, (uint8_t)min(length - k, BUFFER_LENGTH));
263-
264-
for (; Wire.available() && (timeout == 0 || millis() - t1 < timeout); count++) {
265-
data[count] = Wire.read();
253+
for (int k = 0; k < length; k += min((int)length, I2CDEVLIB_WIRE_BUFFER_LENGTH)) {
254+
useWire->beginTransmission(devAddr);
255+
useWire->write(regAddr);
256+
useWire->endTransmission();
257+
useWire->requestFrom((uint8_t)devAddr, (uint8_t)min((int)length - k, I2CDEVLIB_WIRE_BUFFER_LENGTH));
258+
for (; useWire->available() && (timeout == 0 || millis() - t1 < timeout); count++) {
259+
data[count] = useWire->read();
266260
#ifdef I2CDEV_SERIAL_DEBUG
267261
Serial.print(data[count], HEX);
268262
if (count + 1 < length) Serial.print(" ");
269263
#endif
270264
}
271-
272-
Wire.endTransmission();
273265
}
274266
#elif (ARDUINO > 100)
275267
// Arduino v1.0.1+, Wire library
276268
// Adds official support for repeated start condition, yay!
277269

278270
// I2C/TWI subsystem uses internal buffer that breaks with large data requests
279-
// so if user requests more than BUFFER_LENGTH bytes, we have to do it in
271+
// so if user requests more than I2CDEVLIB_WIRE_BUFFER_LENGTH bytes, we have to do it in
280272
// smaller chunks instead of all at once
281-
for (uint8_t k = 0; k < length; k += min((int)length, BUFFER_LENGTH)) {
282-
Wire.beginTransmission(devAddr);
283-
Wire.write(regAddr);
284-
Wire.endTransmission();
285-
Wire.beginTransmission(devAddr);
286-
Wire.requestFrom(devAddr, (uint8_t)min(length - k, BUFFER_LENGTH));
287-
288-
for (; Wire.available() && (timeout == 0 || millis() - t1 < timeout); count++) {
289-
data[count] = Wire.read();
273+
for (int k = 0; k < length; k += min((int)length, I2CDEVLIB_WIRE_BUFFER_LENGTH)) {
274+
useWire->beginTransmission(devAddr);
275+
useWire->write(regAddr);
276+
useWire->endTransmission();
277+
useWire->requestFrom((uint8_t)devAddr, (uint8_t)min((int)length - k, I2CDEVLIB_WIRE_BUFFER_LENGTH));
278+
for (; useWire->available() && (timeout == 0 || millis() - t1 < timeout); count++) {
279+
data[count] = useWire->read();
290280
#ifdef I2CDEV_SERIAL_DEBUG
291281
Serial.print(data[count], HEX);
292282
if (count + 1 < length) Serial.print(" ");
@@ -328,7 +318,7 @@ int8_t I2Cdev::readBytes(uint8_t devAddr, uint8_t regAddr, uint8_t length, uint8
328318
* @param timeout Optional read timeout in milliseconds (0 to disable, leave off to use default class value in I2Cdev::readTimeout)
329319
* @return Number of words read (-1 indicates failure)
330320
*/
331-
int8_t I2Cdev::readWords(uint8_t devAddr, uint8_t regAddr, uint8_t length, uint16_t *data, uint16_t timeout) {
321+
int8_t I2Cdev::readWords(uint8_t devAddr, uint8_t regAddr, uint8_t length, uint16_t *data, uint16_t timeout, void *wireObj) {
332322
#ifdef I2CDEV_SERIAL_DEBUG
333323
Serial.print("I2C (0x");
334324
Serial.print(devAddr, HEX);
@@ -339,32 +329,33 @@ int8_t I2Cdev::readWords(uint8_t devAddr, uint8_t regAddr, uint8_t length, uint1
339329
Serial.print("...");
340330
#endif
341331

342-
int8_t count = 0;
332+
uint8_t count = 0;
343333
uint32_t t1 = millis();
344334

345335
#if I2CDEV_IMPLEMENTATION == I2CDEV_ARDUINO_WIRE || I2CDEV_IMPLEMENTATION == I2CDEV_BUILTIN_SBWIRE || I2CDEV_IMPLEMENTATION == I2CDEV_TEENSY_3X_WIRE
336+
TwoWire *useWire = &Wire;
337+
if (wireObj) useWire = (TwoWire *)wireObj;
346338

347339
#if (ARDUINO < 100)
348340
// Arduino v00xx (before v1.0), Wire library
349341

350342
// I2C/TWI subsystem uses internal buffer that breaks with large data requests
351-
// so if user requests more than BUFFER_LENGTH bytes, we have to do it in
343+
// so if user requests more than I2CDEVLIB_WIRE_BUFFER_LENGTH bytes, we have to do it in
352344
// smaller chunks instead of all at once
353-
for (uint8_t k = 0; k < length * 2; k += min(length * 2, BUFFER_LENGTH)) {
354-
Wire.beginTransmission(devAddr);
355-
Wire.send(regAddr);
356-
Wire.endTransmission();
357-
Wire.beginTransmission(devAddr);
358-
Wire.requestFrom(devAddr, (uint8_t)(length * 2)); // length=words, this wants bytes
345+
for (uint8_t k = 0; k < length * 2; k += min(length * 2, I2CDEVLIB_WIRE_BUFFER_LENGTH)) {
346+
useWire->beginTransmission(devAddr);
347+
useWire->send(regAddr);
348+
useWire->endTransmission();
349+
useWire->requestFrom(devAddr, (uint8_t)(length * 2)); // length=words, this wants bytes
359350

360351
bool msb = true; // starts with MSB, then LSB
361-
for (; Wire.available() && count < length && (timeout == 0 || millis() - t1 < timeout);) {
352+
for (; useWire->available() && count < length && (timeout == 0 || millis() - t1 < timeout);) {
362353
if (msb) {
363354
// first byte is bits 15-8 (MSb=15)
364-
data[count] = Wire.receive() << 8;
355+
data[count] = useWire->receive() << 8;
365356
} else {
366357
// second byte is bits 7-0 (LSb=0)
367-
data[count] |= Wire.receive();
358+
data[count] |= useWire->receive();
368359
#ifdef I2CDEV_SERIAL_DEBUG
369360
Serial.print(data[count], HEX);
370361
if (count + 1 < length) Serial.print(" ");
@@ -373,31 +364,28 @@ int8_t I2Cdev::readWords(uint8_t devAddr, uint8_t regAddr, uint8_t length, uint1
373364
}
374365
msb = !msb;
375366
}
376-
377-
Wire.endTransmission();
378367
}
379368
#elif (ARDUINO == 100)
380369
// Arduino v1.0.0, Wire library
381370
// Adds standardized write() and read() stream methods instead of send() and receive()
382371

383372
// I2C/TWI subsystem uses internal buffer that breaks with large data requests
384-
// so if user requests more than BUFFER_LENGTH bytes, we have to do it in
373+
// so if user requests more than I2CDEVLIB_WIRE_BUFFER_LENGTH bytes, we have to do it in
385374
// smaller chunks instead of all at once
386-
for (uint8_t k = 0; k < length * 2; k += min(length * 2, BUFFER_LENGTH)) {
387-
Wire.beginTransmission(devAddr);
388-
Wire.write(regAddr);
389-
Wire.endTransmission();
390-
Wire.beginTransmission(devAddr);
391-
Wire.requestFrom(devAddr, (uint8_t)(length * 2)); // length=words, this wants bytes
375+
for (uint8_t k = 0; k < length * 2; k += min(length * 2, I2CDEVLIB_WIRE_BUFFER_LENGTH)) {
376+
useWire->beginTransmission(devAddr);
377+
useWire->write(regAddr);
378+
useWire->endTransmission();
379+
useWire->requestFrom(devAddr, (uint8_t)(length * 2)); // length=words, this wants bytes
392380

393381
bool msb = true; // starts with MSB, then LSB
394-
for (; Wire.available() && count < length && (timeout == 0 || millis() - t1 < timeout);) {
382+
for (; useWire->available() && count < length && (timeout == 0 || millis() - t1 < timeout);) {
395383
if (msb) {
396384
// first byte is bits 15-8 (MSb=15)
397-
data[count] = Wire.read() << 8;
385+
data[count] = useWire->read() << 8;
398386
} else {
399387
// second byte is bits 7-0 (LSb=0)
400-
data[count] |= Wire.read();
388+
data[count] |= useWire->read();
401389
#ifdef I2CDEV_SERIAL_DEBUG
402390
Serial.print(data[count], HEX);
403391
if (count + 1 < length) Serial.print(" ");
@@ -406,31 +394,28 @@ int8_t I2Cdev::readWords(uint8_t devAddr, uint8_t regAddr, uint8_t length, uint1
406394
}
407395
msb = !msb;
408396
}
409-
410-
Wire.endTransmission();
411397
}
412398
#elif (ARDUINO > 100)
413399
// Arduino v1.0.1+, Wire library
414400
// Adds official support for repeated start condition, yay!
415401

416402
// I2C/TWI subsystem uses internal buffer that breaks with large data requests
417-
// so if user requests more than BUFFER_LENGTH bytes, we have to do it in
403+
// so if user requests more than I2CDEVLIB_WIRE_BUFFER_LENGTH bytes, we have to do it in
418404
// smaller chunks instead of all at once
419-
for (uint8_t k = 0; k < length * 2; k += min(length * 2, BUFFER_LENGTH)) {
420-
Wire.beginTransmission(devAddr);
421-
Wire.write(regAddr);
422-
Wire.endTransmission();
423-
Wire.beginTransmission(devAddr);
424-
Wire.requestFrom(devAddr, (uint8_t)(length * 2)); // length=words, this wants bytes
405+
for (uint8_t k = 0; k < length * 2; k += min(length * 2, I2CDEVLIB_WIRE_BUFFER_LENGTH)) {
406+
useWire->beginTransmission(devAddr);
407+
useWire->write(regAddr);
408+
useWire->endTransmission();
409+
useWire->requestFrom(devAddr, (uint8_t)(length * 2)); // length=words, this wants bytes
425410

426411
bool msb = true; // starts with MSB, then LSB
427-
for (; Wire.available() && count < length && (timeout == 0 || millis() - t1 < timeout);) {
412+
for (; useWire->available() && count < length && (timeout == 0 || millis() - t1 < timeout);) {
428413
if (msb) {
429414
// first byte is bits 15-8 (MSb=15)
430-
data[count] = Wire.read() << 8;
415+
data[count] = useWire->read() << 8;
431416
} else {
432417
// second byte is bits 7-0 (LSb=0)
433-
data[count] |= Wire.read();
418+
data[count] |= useWire->read();
434419
#ifdef I2CDEV_SERIAL_DEBUG
435420
Serial.print(data[count], HEX);
436421
if (count + 1 < length) Serial.print(" ");
@@ -439,8 +424,6 @@ int8_t I2Cdev::readWords(uint8_t devAddr, uint8_t regAddr, uint8_t length, uint1
439424
}
440425
msb = !msb;
441426
}
442-
443-
Wire.endTransmission();
444427
}
445428
#endif
446429

@@ -479,11 +462,11 @@ int8_t I2Cdev::readWords(uint8_t devAddr, uint8_t regAddr, uint8_t length, uint1
479462
* @param value New bit value to write
480463
* @return Status of operation (true = success)
481464
*/
482-
bool I2Cdev::writeBit(uint8_t devAddr, uint8_t regAddr, uint8_t bitNum, uint8_t data) {
465+
bool I2Cdev::writeBit(uint8_t devAddr, uint8_t regAddr, uint8_t bitNum, uint8_t data, void *wireObj) {
483466
uint8_t b;
484-
readByte(devAddr, regAddr, &b);
467+
readByte(devAddr, regAddr, &b, I2Cdev::readTimeout, wireObj);
485468
b = (data != 0) ? (b | (1 << bitNum)) : (b & ~(1 << bitNum));
486-
return writeByte(devAddr, regAddr, b);
469+
return writeByte(devAddr, regAddr, b, wireObj);
487470
}
488471

489472
/** write a single bit in a 16-bit device register.
@@ -493,11 +476,11 @@ bool I2Cdev::writeBit(uint8_t devAddr, uint8_t regAddr, uint8_t bitNum, uint8_t
493476
* @param value New bit value to write
494477
* @return Status of operation (true = success)
495478
*/
496-
bool I2Cdev::writeBitW(uint8_t devAddr, uint8_t regAddr, uint8_t bitNum, uint16_t data) {
479+
bool I2Cdev::writeBitW(uint8_t devAddr, uint8_t regAddr, uint8_t bitNum, uint16_t data, void *wireObj) {
497480
uint16_t w;
498-
readWord(devAddr, regAddr, &w);
481+
readWord(devAddr, regAddr, &w, I2Cdev::readTimeout, wireObj);
499482
w = (data != 0) ? (w | (1 << bitNum)) : (w & ~(1 << bitNum));
500-
return writeWord(devAddr, regAddr, w);
483+
return writeWord(devAddr, regAddr, w, wireObj);
501484
}
502485

503486
/** Write multiple bits in an 8-bit device register.
@@ -508,7 +491,7 @@ bool I2Cdev::writeBitW(uint8_t devAddr, uint8_t regAddr, uint8_t bitNum, uint16_
508491
* @param data Right-aligned value to write
509492
* @return Status of operation (true = success)
510493
*/
511-
bool I2Cdev::writeBits(uint8_t devAddr, uint8_t regAddr, uint8_t bitStart, uint8_t length, uint8_t data) {
494+
bool I2Cdev::writeBits(uint8_t devAddr, uint8_t regAddr, uint8_t bitStart, uint8_t length, uint8_t data, void *wireObj) {
512495
// 010 value to write
513496
// 76543210 bit numbers
514497
// xxx args: bitStart=4, length=3
@@ -517,13 +500,13 @@ bool I2Cdev::writeBits(uint8_t devAddr, uint8_t regAddr, uint8_t bitStart, uint8
517500
// 10100011 original & ~mask
518501
// 10101011 masked | value
519502
uint8_t b;
520-
if (readByte(devAddr, regAddr, &b) != 0) {
503+
if (readByte(devAddr, regAddr, &b, I2Cdev::readTimeout, wireObj) != 0) {
521504
uint8_t mask = ((1 << length) - 1) << (bitStart - length + 1);
522505
data <<= (bitStart - length + 1); // shift data into correct position
523506
data &= mask; // zero all non-important bits in data
524507
b &= ~(mask); // zero all important bits in existing byte
525508
b |= data; // combine data with existing byte
526-
return writeByte(devAddr, regAddr, b);
509+
return writeByte(devAddr, regAddr, b, wireObj);
527510
} else {
528511
return false;
529512
}
@@ -537,7 +520,7 @@ bool I2Cdev::writeBits(uint8_t devAddr, uint8_t regAddr, uint8_t bitStart, uint8
537520
* @param data Right-aligned value to write
538521
* @return Status of operation (true = success)
539522
*/
540-
bool I2Cdev::writeBitsW(uint8_t devAddr, uint8_t regAddr, uint8_t bitStart, uint8_t length, uint16_t data) {
523+
bool I2Cdev::writeBitsW(uint8_t devAddr, uint8_t regAddr, uint8_t bitStart, uint8_t length, uint16_t data, void *wireObj) {
541524
// 010 value to write
542525
// fedcba9876543210 bit numbers
543526
// xxx args: bitStart=12, length=3
@@ -546,13 +529,13 @@ bool I2Cdev::writeBitsW(uint8_t devAddr, uint8_t regAddr, uint8_t bitStart, uint
546529
// 1010001110010110 original & ~mask
547530
// 1010101110010110 masked | value
548531
uint16_t w;
549-
if (readWord(devAddr, regAddr, &w) != 0) {
532+
if (readWord(devAddr, regAddr, &w, I2Cdev::readTimeout, wireObj) != 0) {
550533
uint16_t mask = ((1 << length) - 1) << (bitStart - length + 1);
551534
data <<= (bitStart - length + 1); // shift data into correct position
552535
data &= mask; // zero all non-important bits in data
553536
w &= ~(mask); // zero all important bits in existing word
554537
w |= data; // combine data with existing word
555-
return writeWord(devAddr, regAddr, w);
538+
return writeWord(devAddr, regAddr, w, wireObj);
556539
} else {
557540
return false;
558541
}
@@ -564,8 +547,8 @@ bool I2Cdev::writeBitsW(uint8_t devAddr, uint8_t regAddr, uint8_t bitStart, uint
564547
* @param data New byte value to write
565548
* @return Status of operation (true = success)
566549
*/
567-
bool I2Cdev::writeByte(uint8_t devAddr, uint8_t regAddr, uint8_t data) {
568-
return writeBytes(devAddr, regAddr, 1, &data);
550+
bool I2Cdev::writeByte(uint8_t devAddr, uint8_t regAddr, uint8_t data, void *wireObj) {
551+
return writeBytes(devAddr, regAddr, 1, &data, wireObj);
569552
}
570553

571554
/** Write single word to a 16-bit device register.
@@ -574,8 +557,8 @@ bool I2Cdev::writeByte(uint8_t devAddr, uint8_t regAddr, uint8_t data) {
574557
* @param data New word value to write
575558
* @return Status of operation (true = success)
576559
*/
577-
bool I2Cdev::writeWord(uint8_t devAddr, uint8_t regAddr, uint16_t data) {
578-
return writeWords(devAddr, regAddr, 1, &data);
560+
bool I2Cdev::writeWord(uint8_t devAddr, uint8_t regAddr, uint16_t data, void *wireObj) {
561+
return writeWords(devAddr, regAddr, 1, &data, wireObj);
579562
}
580563

581564
/** Write multiple bytes to an 8-bit device register.
@@ -585,7 +568,7 @@ bool I2Cdev::writeWord(uint8_t devAddr, uint8_t regAddr, uint16_t data) {
585568
* @param data Buffer to copy new data from
586569
* @return Status of operation (true = success)
587570
*/
588-
bool I2Cdev::writeBytes(uint8_t devAddr, uint8_t regAddr, uint8_t length, uint8_t* data) {
571+
bool I2Cdev::writeBytes(uint8_t devAddr, uint8_t regAddr, uint8_t length, uint8_t* data, void *wireObj) {
589572
#ifdef I2CDEV_SERIAL_DEBUG
590573
Serial.print("I2C (0x");
591574
Serial.print(devAddr, HEX);
@@ -596,14 +579,20 @@ bool I2Cdev::writeBytes(uint8_t devAddr, uint8_t regAddr, uint8_t length, uint8_
596579
Serial.print("...");
597580
#endif
598581
uint8_t status = 0;
582+
583+
#if I2CDEV_IMPLEMENTATION == I2CDEV_ARDUINO_WIRE || I2CDEV_IMPLEMENTATION == I2CDEV_BUILTIN_SBWIRE || I2CDEV_IMPLEMENTATION == I2CDEV_TEENSY_3X_WIRE
584+
TwoWire *useWire = &Wire;
585+
if (wireObj) useWire = (TwoWire *)wireObj;
586+
#endif
587+
599588
#if ((I2CDEV_IMPLEMENTATION == I2CDEV_ARDUINO_WIRE && ARDUINO < 100) || I2CDEV_IMPLEMENTATION == I2CDEV_BUILTIN_NBWIRE)
600-
Wire.beginTransmission(devAddr);
601-
Wire.send((uint8_t) regAddr); // send address
589+
useWire->beginTransmission(devAddr);
590+
useWire->send((uint8_t) regAddr); // send address
602591
#elif ((I2CDEV_IMPLEMENTATION == I2CDEV_ARDUINO_WIRE && ARDUINO >= 100) \
603592
|| (I2CDEV_IMPLEMENTATION == I2CDEV_BUILTIN_SBWIRE && ARDUINO >= 100) \
604593
|| I2CDEV_IMPLEMENTATION == I2CDEV_TEENSY_3X_WIRE)
605-
Wire.beginTransmission(devAddr);
606-
Wire.write((uint8_t) regAddr); // send address
594+
useWire->beginTransmission(devAddr);
595+
useWire->write((uint8_t) regAddr); // send address
607596
#elif (I2CDEV_IMPLEMENTATION == I2CDEV_BUILTIN_FASTWIRE)
608597
Fastwire::beginTransmission(devAddr);
609598
Fastwire::write(regAddr);
@@ -614,21 +603,21 @@ bool I2Cdev::writeBytes(uint8_t devAddr, uint8_t regAddr, uint8_t length, uint8_
614603
if (i + 1 < length) Serial.print(" ");
615604
#endif
616605
#if ((I2CDEV_IMPLEMENTATION == I2CDEV_ARDUINO_WIRE && ARDUINO < 100) || I2CDEV_IMPLEMENTATION == I2CDEV_BUILTIN_NBWIRE)
617-
Wire.send((uint8_t) data[i]);
606+
useWire->send((uint8_t) data[i]);
618607
#elif ((I2CDEV_IMPLEMENTATION == I2CDEV_ARDUINO_WIRE && ARDUINO >= 100) \
619608
|| (I2CDEV_IMPLEMENTATION == I2CDEV_BUILTIN_SBWIRE && ARDUINO >= 100) \
620609
|| I2CDEV_IMPLEMENTATION == I2CDEV_TEENSY_3X_WIRE)
621-
Wire.write((uint8_t) data[i]);
610+
useWire->write((uint8_t) data[i]);
622611
#elif (I2CDEV_IMPLEMENTATION == I2CDEV_BUILTIN_FASTWIRE)
623612
Fastwire::write((uint8_t) data[i]);
624613
#endif
625614
}
626615
#if ((I2CDEV_IMPLEMENTATION == I2CDEV_ARDUINO_WIRE && ARDUINO < 100) || I2CDEV_IMPLEMENTATION == I2CDEV_BUILTIN_NBWIRE)
627-
Wire.endTransmission();
616+
useWire->endTransmission();
628617
#elif ((I2CDEV_IMPLEMENTATION == I2CDEV_ARDUINO_WIRE && ARDUINO >= 100) \
629618
|| (I2CDEV_IMPLEMENTATION == I2CDEV_BUILTIN_SBWIRE && ARDUINO >= 100) \
630619
|| I2CDEV_IMPLEMENTATION == I2CDEV_TEENSY_3X_WIRE)
631-
status = Wire.endTransmission();
620+
status = useWire->endTransmission();
632621
#elif (I2CDEV_IMPLEMENTATION == I2CDEV_BUILTIN_FASTWIRE)
633622
Fastwire::stop();
634623
//status = Fastwire::endTransmission();
@@ -646,7 +635,7 @@ bool I2Cdev::writeBytes(uint8_t devAddr, uint8_t regAddr, uint8_t length, uint8_
646635
* @param data Buffer to copy new data from
647636
* @return Status of operation (true = success)
648637
*/
649-
bool I2Cdev::writeWords(uint8_t devAddr, uint8_t regAddr, uint8_t length, uint16_t* data) {
638+
bool I2Cdev::writeWords(uint8_t devAddr, uint8_t regAddr, uint8_t length, uint16_t* data, void *wireObj) {
650639
#ifdef I2CDEV_SERIAL_DEBUG
651640
Serial.print("I2C (0x");
652641
Serial.print(devAddr, HEX);
@@ -657,14 +646,20 @@ bool I2Cdev::writeWords(uint8_t devAddr, uint8_t regAddr, uint8_t length, uint16
657646
Serial.print("...");
658647
#endif
659648
uint8_t status = 0;
649+
650+
#if I2CDEV_IMPLEMENTATION == I2CDEV_ARDUINO_WIRE || I2CDEV_IMPLEMENTATION == I2CDEV_BUILTIN_SBWIRE || I2CDEV_IMPLEMENTATION == I2CDEV_TEENSY_3X_WIRE
651+
TwoWire *useWire = &Wire;
652+
if (wireObj) useWire = (TwoWire *)wireObj;
653+
#endif
654+
660655
#if ((I2CDEV_IMPLEMENTATION == I2CDEV_ARDUINO_WIRE && ARDUINO < 100) || I2CDEV_IMPLEMENTATION == I2CDEV_BUILTIN_NBWIRE)
661-
Wire.beginTransmission(devAddr);
662-
Wire.send(regAddr); // send address
656+
useWire->beginTransmission(devAddr);
657+
useWire->send(regAddr); // send address
663658
#elif ((I2CDEV_IMPLEMENTATION == I2CDEV_ARDUINO_WIRE && ARDUINO >= 100) \
664659
|| (I2CDEV_IMPLEMENTATION == I2CDEV_BUILTIN_SBWIRE && ARDUINO >= 100) \
665660
|| I2CDEV_IMPLEMENTATION == I2CDEV_TEENSY_3X_WIRE)
666-
Wire.beginTransmission(devAddr);
667-
Wire.write(regAddr); // send address
661+
useWire->beginTransmission(devAddr);
662+
useWire->write(regAddr); // send address
668663
#elif (I2CDEV_IMPLEMENTATION == I2CDEV_BUILTIN_FASTWIRE)
669664
Fastwire::beginTransmission(devAddr);
670665
Fastwire::write(regAddr);
@@ -675,25 +670,25 @@ bool I2Cdev::writeWords(uint8_t devAddr, uint8_t regAddr, uint8_t length, uint16
675670
if (i + 1 < length) Serial.print(" ");
676671
#endif
677672
#if ((I2CDEV_IMPLEMENTATION == I2CDEV_ARDUINO_WIRE && ARDUINO < 100) || I2CDEV_IMPLEMENTATION == I2CDEV_BUILTIN_NBWIRE)
678-
Wire.send((uint8_t)(data[i] >> 8)); // send MSB
679-
Wire.send((uint8_t)data[i]); // send LSB
673+
useWire->send((uint8_t)(data[i] >> 8)); // send MSB
674+
useWire->send((uint8_t)data[i]); // send LSB
680675
#elif ((I2CDEV_IMPLEMENTATION == I2CDEV_ARDUINO_WIRE && ARDUINO >= 100) \
681676
|| (I2CDEV_IMPLEMENTATION == I2CDEV_BUILTIN_SBWIRE && ARDUINO >= 100) \
682677
|| I2CDEV_IMPLEMENTATION == I2CDEV_TEENSY_3X_WIRE)
683-
Wire.write((uint8_t)(data[i] >> 8)); // send MSB
684-
Wire.write((uint8_t)data[i]); // send LSB
678+
useWire->write((uint8_t)(data[i] >> 8)); // send MSB
679+
useWire->write((uint8_t)data[i]); // send LSB
685680
#elif (I2CDEV_IMPLEMENTATION == I2CDEV_BUILTIN_FASTWIRE)
686681
Fastwire::write((uint8_t)(data[i] >> 8)); // send MSB
687682
status = Fastwire::write((uint8_t)data[i]); // send LSB
688683
if (status != 0) break;
689684
#endif
690685
}
691686
#if ((I2CDEV_IMPLEMENTATION == I2CDEV_ARDUINO_WIRE && ARDUINO < 100) || I2CDEV_IMPLEMENTATION == I2CDEV_BUILTIN_NBWIRE)
692-
Wire.endTransmission();
687+
useWire->endTransmission();
693688
#elif ((I2CDEV_IMPLEMENTATION == I2CDEV_ARDUINO_WIRE && ARDUINO >= 100) \
694689
|| (I2CDEV_IMPLEMENTATION == I2CDEV_BUILTIN_SBWIRE && ARDUINO >= 100) \
695690
|| I2CDEV_IMPLEMENTATION == I2CDEV_TEENSY_3X_WIRE)
696-
status = Wire.endTransmission();
691+
status = useWire->endTransmission();
697692
#elif (I2CDEV_IMPLEMENTATION == I2CDEV_BUILTIN_FASTWIRE)
698693
Fastwire::stop();
699694
//status = Fastwire::endTransmission();
@@ -753,7 +748,7 @@ uint16_t I2Cdev::readTimeout = I2CDEV_DEFAULT_READ_TIMEOUT;
753748
#endif
754749

755750
TWSR = 0; // no prescaler => prescaler = 1
756-
TWBR = ((16000L / khz) - 16) / 2; // change the I2C clock rate
751+
TWBR = F_CPU / 2000 / khz - 8; // change the I2C clock rate
757752
TWCR = 1 << TWEN; // enable twi module, no interrupt
758753
}
759754

@@ -993,7 +988,7 @@ uint16_t I2Cdev::readTimeout = I2CDEV_DEFAULT_READ_TIMEOUT;
993988
TWBR = ((CPU_FREQ / TWI_FREQ) - 16) / 2; // bitrate register
994989
// enable twi module, acks, and twi interrupt
995990

996-
TWCR = _BV(TWEN) | _BV(TWIE) | _BV(TWEA);
991+
TWCR = (1 << TWEN) | (1 << TWIE) | (1 << TWEA);
997992

998993
/* TWEN - TWI Enable Bit
999994
TWIE - TWI Interrupt Enable
@@ -1062,7 +1057,7 @@ uint16_t I2Cdev::readTimeout = I2CDEV_DEFAULT_READ_TIMEOUT;
10621057
}
10631058

10641059
void twii_SetStart() {
1065-
TWCR = _BV(TWEN) | _BV(TWIE) | _BV(TWEA) | _BV(TWINT) | _BV(TWSTA);
1060+
TWCR = (1 << TWEN) | (1 << TWIE) | (1 << TWEA) | (1 << TWINT) | (1 << TWSTA);
10661061
}
10671062

10681063
void twi_write01() {
@@ -1145,19 +1140,19 @@ uint16_t I2Cdev::readTimeout = I2CDEV_DEFAULT_READ_TIMEOUT;
11451140
void twi_reply(uint8_t ack) {
11461141
// transmit master read ready signal, with or without ack
11471142
if (ack){
1148-
TWCR = _BV(TWEN) | _BV(TWIE) | _BV(TWINT) | _BV(TWEA);
1143+
TWCR = (1 << TWEN) | (1 << TWIE) | (1 << TWINT) | (1 << TWEA);
11491144
} else {
1150-
TWCR = _BV(TWEN) | _BV(TWIE) | _BV(TWINT);
1145+
TWCR = (1 << TWEN) | (1 << TWIE) | (1 << TWINT);
11511146
}
11521147
}
11531148

11541149
void twi_stop(void) {
11551150
// send stop condition
1156-
TWCR = _BV(TWEN) | _BV(TWIE) | _BV(TWEA) | _BV(TWINT) | _BV(TWSTO);
1151+
TWCR = (1 << TWEN) | (1 << TWIE) | (1 << TWEA) | (1 << TWINT) | (1 << TWSTO);
11571152

11581153
// wait for stop condition to be exectued on bus
11591154
// TWINT is not set after a stop condition!
1160-
while (TWCR & _BV(TWSTO)) {
1155+
while (TWCR & (1 << TWSTO)) {
11611156
continue;
11621157
}
11631158

@@ -1167,7 +1162,7 @@ uint16_t I2Cdev::readTimeout = I2CDEV_DEFAULT_READ_TIMEOUT;
11671162

11681163
void twi_releaseBus(void) {
11691164
// release bus
1170-
TWCR = _BV(TWEN) | _BV(TWIE) | _BV(TWEA) | _BV(TWINT);
1165+
TWCR = (1 << TWEN) | (1 << TWIE) | (1 << TWEA) | (1 << TWINT);
11711166

11721167
// update twi state
11731168
twi_state = TWI_READY;

‎src/utility/ioexpander/I2Cdev.h

Lines changed: 43 additions & 21 deletions
Original file line numberDiff line numberDiff line change
@@ -3,6 +3,7 @@
33
// 2013-06-05 by Jeff Rowberg <jeff@rowberg.net>
44
//
55
// Changelog:
6+
// 2021-09-28 - allow custom Wire object as transaction function argument
67
// 2020-01-20 - hardija : complete support for Teensy 3.x
78
// 2015-10-30 - simondlevy : support i2c_t3 for Teensy3.1
89
// 2013-05-06 - add Francesco Ferrara's Fastwire v0.24 implementation with small modifications
@@ -48,6 +49,11 @@ THE SOFTWARE.
4849
#ifndef _I2CDEV_H_
4950
#define _I2CDEV_H_
5051

52+
// -----------------------------------------------------------------------------
53+
// Enable deprecated pgmspace typedefs in avr-libc
54+
// -----------------------------------------------------------------------------
55+
#define __PROG_TYPES_COMPAT__
56+
5157
// -----------------------------------------------------------------------------
5258
// I2C interface implementation setting
5359
// -----------------------------------------------------------------------------
@@ -99,10 +105,26 @@ THE SOFTWARE.
99105
#endif
100106

101107
#ifdef SPARK
102-
#include <spark_wiring_i2c.h>
108+
#include "application.h"
103109
#define ARDUINO 101
110+
#define BUFFER_LENGTH 32
104111
#endif
105112

113+
#ifndef I2CDEVLIB_WIRE_BUFFER_LENGTH
114+
#if defined(I2C_BUFFER_LENGTH)
115+
// Arduino ESP32 core Wire uses this
116+
#define I2CDEVLIB_WIRE_BUFFER_LENGTH I2C_BUFFER_LENGTH
117+
#elif defined(BUFFER_LENGTH)
118+
// Arduino AVR core Wire and many others use this
119+
#define I2CDEVLIB_WIRE_BUFFER_LENGTH BUFFER_LENGTH
120+
#elif defined(SERIAL_BUFFER_SIZE)
121+
// Arduino SAMD core Wire uses this
122+
#define I2CDEVLIB_WIRE_BUFFER_LENGTH SERIAL_BUFFER_SIZE
123+
#else
124+
// should be a safe fallback, though possibly inefficient
125+
#define I2CDEVLIB_WIRE_BUFFER_LENGTH 32
126+
#endif
127+
#endif
106128

107129
// 1000ms default read timeout (modify with "I2Cdev::readTimeout = [ms];")
108130
#define I2CDEV_DEFAULT_READ_TIMEOUT 1000
@@ -111,23 +133,23 @@ class I2Cdev {
111133
public:
112134
I2Cdev();
113135

114-
static int8_t readBit(uint8_t devAddr, uint8_t regAddr, uint8_t bitNum, uint8_t *data, uint16_t timeout=I2Cdev::readTimeout);
115-
static int8_t readBitW(uint8_t devAddr, uint8_t regAddr, uint8_t bitNum, uint16_t *data, uint16_t timeout=I2Cdev::readTimeout);
116-
static int8_t readBits(uint8_t devAddr, uint8_t regAddr, uint8_t bitStart, uint8_t length, uint8_t *data, uint16_t timeout=I2Cdev::readTimeout);
117-
static int8_t readBitsW(uint8_t devAddr, uint8_t regAddr, uint8_t bitStart, uint8_t length, uint16_t *data, uint16_t timeout=I2Cdev::readTimeout);
118-
static int8_t readByte(uint8_t devAddr, uint8_t regAddr, uint8_t *data, uint16_t timeout=I2Cdev::readTimeout);
119-
static int8_t readWord(uint8_t devAddr, uint8_t regAddr, uint16_t *data, uint16_t timeout=I2Cdev::readTimeout);
120-
static int8_t readBytes(uint8_t devAddr, uint8_t regAddr, uint8_t length, uint8_t *data, uint16_t timeout=I2Cdev::readTimeout);
121-
static int8_t readWords(uint8_t devAddr, uint8_t regAddr, uint8_t length, uint16_t *data, uint16_t timeout=I2Cdev::readTimeout);
122-
123-
static bool writeBit(uint8_t devAddr, uint8_t regAddr, uint8_t bitNum, uint8_t data);
124-
static bool writeBitW(uint8_t devAddr, uint8_t regAddr, uint8_t bitNum, uint16_t data);
125-
static bool writeBits(uint8_t devAddr, uint8_t regAddr, uint8_t bitStart, uint8_t length, uint8_t data);
126-
static bool writeBitsW(uint8_t devAddr, uint8_t regAddr, uint8_t bitStart, uint8_t length, uint16_t data);
127-
static bool writeByte(uint8_t devAddr, uint8_t regAddr, uint8_t data);
128-
static bool writeWord(uint8_t devAddr, uint8_t regAddr, uint16_t data);
129-
static bool writeBytes(uint8_t devAddr, uint8_t regAddr, uint8_t length, uint8_t *data);
130-
static bool writeWords(uint8_t devAddr, uint8_t regAddr, uint8_t length, uint16_t *data);
136+
static int8_t readBit(uint8_t devAddr, uint8_t regAddr, uint8_t bitNum, uint8_t *data, uint16_t timeout=I2Cdev::readTimeout, void *wireObj=0);
137+
static int8_t readBitW(uint8_t devAddr, uint8_t regAddr, uint8_t bitNum, uint16_t *data, uint16_t timeout=I2Cdev::readTimeout, void *wireObj=0);
138+
static int8_t readBits(uint8_t devAddr, uint8_t regAddr, uint8_t bitStart, uint8_t length, uint8_t *data, uint16_t timeout=I2Cdev::readTimeout, void *wireObj=0);
139+
static int8_t readBitsW(uint8_t devAddr, uint8_t regAddr, uint8_t bitStart, uint8_t length, uint16_t *data, uint16_t timeout=I2Cdev::readTimeout, void *wireObj=0);
140+
static int8_t readByte(uint8_t devAddr, uint8_t regAddr, uint8_t *data, uint16_t timeout=I2Cdev::readTimeout, void *wireObj=0);
141+
static int8_t readWord(uint8_t devAddr, uint8_t regAddr, uint16_t *data, uint16_t timeout=I2Cdev::readTimeout, void *wireObj=0);
142+
static int8_t readBytes(uint8_t devAddr, uint8_t regAddr, uint8_t length, uint8_t *data, uint16_t timeout=I2Cdev::readTimeout, void *wireObj=0);
143+
static int8_t readWords(uint8_t devAddr, uint8_t regAddr, uint8_t length, uint16_t *data, uint16_t timeout=I2Cdev::readTimeout, void *wireObj=0);
144+
145+
static bool writeBit(uint8_t devAddr, uint8_t regAddr, uint8_t bitNum, uint8_t data, void *wireObj=0);
146+
static bool writeBitW(uint8_t devAddr, uint8_t regAddr, uint8_t bitNum, uint16_t data, void *wireObj=0);
147+
static bool writeBits(uint8_t devAddr, uint8_t regAddr, uint8_t bitStart, uint8_t length, uint8_t data, void *wireObj=0);
148+
static bool writeBitsW(uint8_t devAddr, uint8_t regAddr, uint8_t bitStart, uint8_t length, uint16_t data, void *wireObj=0);
149+
static bool writeByte(uint8_t devAddr, uint8_t regAddr, uint8_t data, void *wireObj=0);
150+
static bool writeWord(uint8_t devAddr, uint8_t regAddr, uint16_t data, void *wireObj=0);
151+
static bool writeBytes(uint8_t devAddr, uint8_t regAddr, uint8_t length, uint8_t *data, void *wireObj=0);
152+
static bool writeWords(uint8_t devAddr, uint8_t regAddr, uint8_t length, uint16_t *data, void *wireObj=0);
131153

132154
static uint16_t readTimeout;
133155
};
@@ -240,7 +262,7 @@ class I2Cdev {
240262

241263
/* TWI Status is in TWSR, in the top 5 bits: TWS7 - TWS3 */
242264

243-
#define TW_STATUS_MASK (_BV(TWS7)|_BV(TWS6)|_BV(TWS5)|_BV(TWS4)|_BV(TWS3))
265+
#define TW_STATUS_MASK ((1 << TWS7)|(1 << TWS6)|(1 << TWS5)|(1 << TWS4)|(1 << TWS3))
244266
#define TW_STATUS (TWSR & TW_STATUS_MASK)
245267
#define TW_START 0x08
246268
#define TW_REP_START 0x10
@@ -275,11 +297,11 @@ class I2Cdev {
275297
//#define _SFR_BYTE(sfr) _MMIO_BYTE(_SFR_ADDR(sfr))
276298

277299
#ifndef sbi // set bit
278-
#define sbi(sfr, bit) (_SFR_BYTE(sfr) |= _BV(bit))
300+
#define sbi(sfr, bit) (_SFR_BYTE(sfr) |= (1 << bit))
279301
#endif // sbi
280302

281303
#ifndef cbi // clear bit
282-
#define cbi(sfr, bit) (_SFR_BYTE(sfr) &= ~_BV(bit))
304+
#define cbi(sfr, bit) (_SFR_BYTE(sfr) &= ~(1 << bit))
283305
#endif // cbi
284306

285307
extern TwoWire Wire;

0 commit comments

Comments
 (0)
This repository has been archived.