Reworked Wire library

- implemented two classes, one support only I2C master role, fully non-static with independent instances, second implementing both master and slave roles, always using the same static TWI singleton class from core
- classes implementing both mods can be always used directly via names TwoWireMaster and TwoWireMasterOrSlave, however that's not a recommand use for portable code/libraries!
- mode (the behaviour or TwoWire class) can be switched from default/compatible master-or-slave to master-only via TWOWIRE_MASTER_ONLY define
- support for optional global Wire instance in both modes
- master-only and master-or-slave modes can used together in some project by splitting code into separate compilation units

Author: michkot

libraries/Wire/Wire.cpp

@@ -38,113 +38,132 @@ extern "C" {
 #error Wire library is not supported on this board
 #endif
 
+// Private Methods /////////////////////////////////////////////////////////////
 // Constructors ////////////////////////////////////////////////////////////////
 
-TwoWire::TwoWire(uint8_t rxBufferSize, uint8_t txBufferSize) :
-    rxBuffer{new uint8_t[rxBufferSize]}, 
-    txBuffer{new uint8_t[txBufferSize]} 
+TwoWireBase::TwoWireBase(uint8_t rxBufferSize, uint8_t txBufferSize) :
+    twiMaster{new TwiMaster},
+    rxBufferSize{rxBufferSize},
+    rxBuffer{new uint8_t[rxBufferSize]},
+    txBufferSize{txBufferSize},
+    txBuffer{new uint8_t[txBufferSize]}
 {
-    this->txBufferSize = txBufferSize;
-    this->rxBufferSize = rxBufferSize;
 }
 
-// Public Methods //////////////////////////////////////////////////////////////
+TwoWireBase::TwoWireBase(TwiMaster* twiPtr, uint8_t rxBufferSize, uint8_t txBufferSize, uint8_t* rxBuffer, uint8_t* txBuffer) :
+    twiMaster{twiPtr},
+    rxBufferSize{rxBufferSize},
+    rxBuffer{rxBuffer},
+    txBufferSize{txBufferSize},
+    txBuffer{txBuffer}
+{
+}
 
-void TwoWire::begin(int sda, int scl)
+inline TwiMaster& TwoWireBase::getTwiMaster()
 {
-    twi.init(sda, scl);
-    flush();
+    return *twiMaster;
 }
+inline void TwoWireBase::releaseTwiMaster()
+{
+    twiMaster.release();
+}
+
+// Public Methods //////////////////////////////////////////////////////////////
 
-void TwoWire::pins(int sda, int scl)
+void TwoWireBase::begin(int sda, int scl)
 {
+    lastSdaPin = sda;
+    lastSclPin = scl;
+    getTwiMaster().init(sda, scl);
+    flush();
 }
 
-void TwoWire::begin(void)
+void TwoWireBase::begin(void)
 {
-    begin(SDA, SCL);
+    begin(lastSdaPin, lastSclPin);
 }
 
-uint8_t TwoWire::status()
+void TwoWireBase::pins(int sda, int scl)
 {
-    return twi.status();
+    lastSdaPin = sda;
+    lastSclPin = scl;
 }
 
-void TwoWire::begin(int address)
+uint8_t TwoWireBase::status()
 {
-    begin((uint8_t)address);
+    return getTwiMaster().status();
 }
 
-void TwoWire::setClock(uint32_t frequency)
+void TwoWireBase::setClock(uint32_t frequency)
 {
-    twi.setClock(frequency);
+    getTwiMaster().setClock(frequency);
 }
 
-void TwoWire::setClockStretchLimit(uint32_t limit)
+void TwoWireBase::setClockStretchLimit(uint32_t limit)
 {
-    twi.setClockStretchLimit(limit);
+    getTwiMaster().setClockStretchLimit(limit);
 }
 
-size_t TwoWire::requestFrom(uint8_t address, size_t size, bool sendStop)
+size_t TwoWireBase::requestFrom(uint8_t address, size_t size, bool sendStop)
 {
     if (size > rxBufferSize)
     {
         size = rxBufferSize;
     }
-    size_t read = (twi.readFrom(address, rxBuffer.get(), size, sendStop) == 0) ? size : 0;
+    size_t read = (getTwiMaster().readFrom(address, rxBuffer.get(), size, sendStop) == 0) ? size : 0;
     rxBufferIndex = 0;
     rxBufferLength = read;
     return read;
 }
 
-uint8_t TwoWire::requestFrom(uint8_t address, uint8_t quantity, uint8_t sendStop)
+uint8_t TwoWireBase::requestFrom(uint8_t address, uint8_t quantity, uint8_t sendStop)
 {
     return requestFrom(address, static_cast<size_t>(quantity), static_cast<bool>(sendStop));
 }
 
-uint8_t TwoWire::requestFrom(uint8_t address, uint8_t quantity)
+uint8_t TwoWireBase::requestFrom(uint8_t address, uint8_t quantity)
 {
     return requestFrom(address, static_cast<size_t>(quantity), true);
 }
 
-uint8_t TwoWire::requestFrom(int address, int quantity)
+uint8_t TwoWireBase::requestFrom(int address, int quantity)
 {
     return requestFrom(static_cast<uint8_t>(address), static_cast<size_t>(quantity), true);
 }
 
-uint8_t TwoWire::requestFrom(int address, int quantity, int sendStop)
+uint8_t TwoWireBase::requestFrom(int address, int quantity, int sendStop)
 {
     return requestFrom(static_cast<uint8_t>(address), static_cast<size_t>(quantity), static_cast<bool>(sendStop));
 }
 
-void TwoWire::beginTransmission(uint8_t address)
+void TwoWireBase::beginTransmission(uint8_t address)
 {
     transmitting = 1;
     txAddress = address;
     txBufferIndex = 0;
     txBufferLength = 0;
 }
 
-void TwoWire::beginTransmission(int address)
+void TwoWireBase::beginTransmission(int address)
 {
     beginTransmission((uint8_t)address);
 }
 
-uint8_t TwoWire::endTransmission(uint8_t sendStop)
+uint8_t TwoWireBase::endTransmission(uint8_t sendStop)
 {
-    int8_t ret = twi.writeTo(txAddress, txBuffer.get(), txBufferLength, sendStop);
+    int8_t ret = getTwiMaster().writeTo(txAddress, txBuffer.get(), txBufferLength, sendStop);
     txBufferIndex = 0;
     txBufferLength = 0;
     transmitting = 0;
     return ret;
 }
 
-uint8_t TwoWire::endTransmission(void)
+uint8_t TwoWireBase::endTransmission(void)
 {
     return endTransmission(true);
 }
 
-size_t TwoWire::write(uint8_t data)
+size_t TwoWireBase::write(uint8_t data)
 {
     if (transmitting)
     {
@@ -165,7 +184,7 @@ size_t TwoWire::write(uint8_t data)
     return 1;
 }
 
-size_t TwoWire::write(const uint8_t *data, size_t quantity)
+size_t TwoWireBase::write(const uint8_t *data, size_t quantity)
 {
     if (transmitting)
     {
@@ -185,7 +204,7 @@ size_t TwoWire::write(const uint8_t *data, size_t quantity)
     return quantity;
 }
 
-int TwoWire::available(void)
+int TwoWireBase::available(void)
 {
     int result = rxBufferLength - rxBufferIndex;
 
@@ -199,7 +218,7 @@ int TwoWire::available(void)
     return result;
 }
 
-int TwoWire::read(void)
+int TwoWireBase::read(void)
 {
     int value = -1;
     if (rxBufferIndex < rxBufferLength)
@@ -210,7 +229,7 @@ int TwoWire::read(void)
     return value;
 }
 
-int TwoWire::peek(void)
+int TwoWireBase::peek(void)
 {
     int value = -1;
     if (rxBufferIndex < rxBufferLength)
@@ -220,16 +239,144 @@ int TwoWire::peek(void)
     return value;
 }
 
-void TwoWire::flush(void)
+void TwoWireBase::flush(void)
 {
     rxBufferIndex = 0;
     rxBufferLength = 0;
     txBufferIndex = 0;
     txBufferLength = 0;
 }
 
-// Preinstantiate Objects //////////////////////////////////////////////////////
+// Master-only Constructors ////////////////////////////////////////////////////
+
+TwoWireMaster::TwoWireMaster(uint8_t rxBufferSize, uint8_t txBufferSize)
+    : TwoWireBase(rxBufferSize, txBufferSize)
+{}
 
+TwoWireMaster::TwoWireMaster(uint8_t rxBufferSize, uint8_t txBufferSize, uint8_t* rxBuffer, uint8_t* txBuffer)
+    : TwoWireBase(new TwiMaster{}, rxBufferSize, txBufferSize, rxBuffer, txBuffer)
+{}
+
+// Master-or-Slave Constructors ////////////////////////////////////////////////
+
+TwoWireMasterOrSlave::TwoWireMasterOrSlave(uint8_t rxBufferSize, uint8_t txBufferSize, uint8_t* rxBuffer, uint8_t* txBuffer)
+    : TwoWireBase(&twiMasterSingleton, rxBufferSize, txBufferSize, rxBuffer, txBuffer)
+{}
+
+TwoWireMasterOrSlave::~TwoWireMasterOrSlave()
+{
+    releaseTwiMaster();
+}
+
+// Master-or-Slave Public Methods //////////////////////////////////////////////
+
+void TwoWireMasterOrSlave::begin(int sda, int scl, uint8_t address)
+{
+    twi_setAddress(address);
+    twi_attachSlaveTxEventWithTarget(onRequestService);
+    twi_attachSlaveRxEventWithTarget(onReceiveService);
+    begin(sda, scl);
+}
+
+void TwoWireMasterOrSlave::begin(uint8_t address)
+{
+    twi_setAddress(address);
+    twi_attachSlaveTxEventWithTarget(onRequestService);
+    twi_attachSlaveRxEventWithTarget(onReceiveService);
+    begin();
+}
+void TwoWireMasterOrSlave::begin(int address)
+{
+    begin((uint8_t)address);
+}
+
+void TwoWireMasterOrSlave::onReceiveService(uint8_t* inBytes, size_t numBytes, void* targetObject)
+{
+    auto& instance = *(TwoWireMasterOrSlave*)targetObject;
+
+    // return if targetObject (an instance of TwoWireMasterOrSlave) was not set/received correctly
+    // don't bother if user hasn't registered a callback
+    if (targetObject == nullptr || !instance.user_onReceive)
+    {
+        return;
+    }
+    // // don't bother if rx buffer is in use by a master requestFrom() op
+    // // i know this drops data, but it allows for slight stupidity
+    // // meaning, they may not have read all the master requestFrom() data yet
+    // if(rxBufferIndex < rxBufferLength){
+    //   return;
+    // }
+
+    // copy twi rx buffer into local read buffer
+    // this enables new reads to happen in parallel
+    for (uint8_t i = 0; i < numBytes; ++i)
+    {
+        instance.rxBuffer[i] = inBytes[i];
+    }
+
+    // set rx iterator vars
+    instance.rxBufferIndex = 0;
+    instance.rxBufferLength = numBytes;
+
+    // alert user program
+    instance.user_onReceive(numBytes);
+}
+
+void TwoWireMasterOrSlave::onRequestService(void* targetObject)
+{
+    auto& instance = *(TwoWireMasterOrSlave*)targetObject;
+
+    // return if targetObject (an instance of TwoWireMasterOrSlave) was not set/received correctly
+    // don't bother if user hasn't registered a callback
+    if (targetObject == nullptr || !instance.user_onRequest)
+    {
+        return;
+    }
+
+    // reset tx buffer iterator vars
+    // !!! this will kill any pending pre-master sendTo() activity
+    instance.txBufferIndex = 0;
+    instance.txBufferLength = 0;
+
+    // alert user program
+    instance.user_onRequest();
+}
+
+void TwoWireMasterOrSlave::onReceive(void (*function)(int))
+{
+    // arduino api compatibility fixer:
+    // really hope size parameter will not exceed 2^31 :)
+    static_assert(sizeof(int) == sizeof(size_t), "something is wrong in Arduino kingdom");
+    user_onReceive = reinterpret_cast<void(*)(size_t)>(function);
+}
+
+void TwoWireMasterOrSlave::onReceive(void (*function)(size_t))
+{
+    user_onReceive = function;
+    twi_enableSlaveModeWithTarget(this);
+}
+
+void TwoWireMasterOrSlave::onRequest(void (*function)(void))
+{
+    user_onRequest = function;
+    twi_enableSlaveModeWithTarget(this);
+}
+
+// Preinstantiate Objects //////////////////////////////////////////////////////
 #if !defined(NO_GLOBAL_INSTANCES) && !defined(NO_GLOBAL_TWOWIRE)
-TwoWire Wire;
+static uint8_t _rxBuffer[I2C_BUFFER_LENGTH];
+static uint8_t _txBuffer[I2C_BUFFER_LENGTH];
+
+TwoWire Wire{I2C_BUFFER_LENGTH, I2C_BUFFER_LENGTH, _rxBuffer, _txBuffer};
+
+TwoWireMasterOrSlave::TwoWireMasterOrSlave()
+    : TwoWireBase(&twiMasterSingleton, I2C_BUFFER_LENGTH, I2C_BUFFER_LENGTH, _txBuffer, _rxBuffer)
+{}
+
+#else
+
+TwoWireMasterOrSlave::TwoWireMasterOrSlave()
+    : TwoWireBase(&twiMasterSingleton, I2C_BUFFER_LENGTH, I2C_BUFFER_LENGTH, new uint8_t[I2C_BUFFER_LENGTH], new uint8_t[I2C_BUFFER_LENGTH])
+{}
+
 #endif