Merge pull request #152 from fpistm/pr/131

Change Wire Rx/Tx buffers managements

Author: fpistm

cores/arduino/stm32/twi.c

@@ -348,7 +348,7 @@ void i2c_setTiming(i2c_t *obj, uint32_t frequency)
   * @retval read status
   */
 i2c_status_e i2c_master_write(i2c_t *obj, uint8_t dev_address,
-                        uint8_t *data, uint8_t size)
+                        uint8_t *data, uint16_t size)
 
 {
   i2c_status_e ret = I2C_ERROR;
@@ -375,17 +375,24 @@ i2c_status_e i2c_master_write(i2c_t *obj, uint8_t dev_address,
   * @param  obj : pointer to i2c_t structure
   * @param  data: pointer to data to be write
   * @param  size: number of bytes to be write.
-  * @retval none
+  * @retval status
   */
-void i2c_slave_write_IT(i2c_t *obj, uint8_t *data, uint8_t size)
+i2c_status_e i2c_slave_write_IT(i2c_t *obj, uint8_t *data, uint16_t size)
 {
   uint8_t i = 0;
 
+  // Protection to not override the TxBuffer
+  if(size > I2C_TXRX_BUFFER_SIZE) {
+    return I2C_ERROR;
+  }
+
   // Check the communication status
   for(i = 0; i < size; i++) {
     obj->i2cTxRxBuffer[i] = *(data+i);
     obj->i2cTxRxBufferSize++;
   }
+
+  return I2C_OK;
 }
 
 /**
@@ -396,7 +403,7 @@ void i2c_slave_write_IT(i2c_t *obj, uint8_t *data, uint8_t size)
   * @param  size: number of bytes to be read.
   * @retval read status
   */
-i2c_status_e i2c_master_read(i2c_t *obj, uint8_t dev_address, uint8_t *data, uint8_t size)
+i2c_status_e i2c_master_read(i2c_t *obj, uint8_t dev_address, uint8_t *data, uint16_t size)
 {
   i2c_status_e ret = I2C_ERROR;
   uint32_t tickstart = HAL_GetTick();

cores/arduino/stm32/twi.h

@@ -148,9 +148,9 @@ void i2c_custom_init(i2c_t *obj, i2c_timing_e timing, uint32_t addressingMode,
                     uint32_t ownAddress, uint8_t master);
 void i2c_deinit(i2c_t *obj);
 void i2c_setTiming(i2c_t *obj, uint32_t frequency);
-i2c_status_e i2c_master_write(i2c_t *obj, uint8_t dev_address, uint8_t *data, uint8_t size);
-void i2c_slave_write_IT(i2c_t *obj, uint8_t *data, uint8_t size);
-i2c_status_e i2c_master_read(i2c_t *obj, uint8_t dev_address, uint8_t *data, uint8_t size);
+i2c_status_e i2c_master_write(i2c_t *obj, uint8_t dev_address, uint8_t *data, uint16_t size);
+i2c_status_e i2c_slave_write_IT(i2c_t *obj, uint8_t *data, uint16_t size);
+i2c_status_e i2c_master_read(i2c_t *obj, uint8_t dev_address, uint8_t *data, uint16_t size);
 
 i2c_status_e i2c_IsDeviceReady(i2c_t *obj, uint8_t devAddr,uint32_t trials);
 

libraries/Wire/keywords.txt

@@ -10,13 +10,13 @@
 # Methods and Functions (KEYWORD2)
 #######################################
 
-begin	KEYWORD2
-setClock	KEYWORD2
+begin			KEYWORD2
+setClock		KEYWORD2
 beginTransmission	KEYWORD2
-endTransmission	KEYWORD2
-requestFrom	KEYWORD2
-onReceive	KEYWORD2
-onRequest	KEYWORD2
+endTransmission		KEYWORD2
+requestFrom		KEYWORD2
+onReceive		KEYWORD2
+onRequest		KEYWORD2
 
 #######################################
 # Instances (KEYWORD2)
@@ -28,4 +28,3 @@ Wire1	KEYWORD2
 #######################################
 # Constants (LITERAL1)
 #######################################
-

libraries/Wire/library.properties

@@ -1,8 +1,8 @@
 name=Wire
 version=1.0
-author=Arduino
-maintainer=Arduino <[email protected]>
-sentence=Allows the communication between devices or sensors connected via Two Wire Interface Bus. For Arduino DUE only.
+author=Arduino, Wi6Labs
+maintainer=stm32duino
+sentence=Allows the communication between devices or sensors connected via Two Wire (I2C) Interface Bus.
 paragraph=
 category=Communication
 url=http://www.arduino.cc/en/Reference/Wire

libraries/Wire/Wire.cpp renamed to libraries/Wire/src/Wire.cpp

@@ -28,12 +28,14 @@ extern "C" {
 #include "Wire.h"
 
 // Initialize Class Variables //////////////////////////////////////////////////
-uint8_t TwoWire::rxBuffer[BUFFER_LENGTH];
+uint8_t *TwoWire::rxBuffer = nullptr;
+uint8_t TwoWire::rxBufferAllocated = 0;
 uint8_t TwoWire::rxBufferIndex = 0;
 uint8_t TwoWire::rxBufferLength = 0;
 
 uint8_t TwoWire::txAddress = 0;
-uint8_t TwoWire::txBuffer[BUFFER_LENGTH];
+uint8_t *TwoWire::txBuffer = nullptr;
+uint8_t TwoWire::txBufferAllocated = 0;
 uint8_t TwoWire::txBufferIndex = 0;
 uint8_t TwoWire::txBufferLength = 0;
 
@@ -66,9 +68,11 @@ void TwoWire::begin(uint8_t address)
 {
   rxBufferIndex = 0;
   rxBufferLength = 0;
+  resetRxBuffer();
 
   txBufferIndex = 0;
   txBufferLength = 0;
+  resetTxBuffer();
 
   transmitting = 0;
 
@@ -97,6 +101,12 @@ void TwoWire::begin(int address)
 
 void TwoWire::end(void)
 {
+  free(txBuffer);
+  txBuffer = nullptr;
+  txBufferAllocated = 0;
+  free(rxBuffer);
+  rxBuffer = nullptr;
+  rxBufferAllocated = 0;
   i2c_deinit(&_i2c);
 }
 
@@ -109,6 +119,13 @@ uint8_t TwoWire::requestFrom(uint8_t address, uint8_t quantity, uint32_t iaddres
 {
   UNUSED(sendStop);
   if (master == true) {
+    allocateRxBuffer(quantity);
+    // error if no memory block available to allocate the buffer
+    if(rxBuffer == nullptr){
+      setWriteError();
+      return 0;
+    }
+
     if (isize > 0) {
       // send internal address; this mode allows sending a repeated start to access
       // some devices' internal registers. This function is executed by the hardware
@@ -128,12 +145,7 @@ uint8_t TwoWire::requestFrom(uint8_t address, uint8_t quantity, uint32_t iaddres
       endTransmission(false);
     }
 
-    // clamp to buffer length
-    if(quantity > BUFFER_LENGTH){
-      quantity = BUFFER_LENGTH;
-    }
     // perform blocking read into buffer
-    //uint8_t read = twi_readFrom(address, rxBuffer, quantity, sendStop);
     uint8_t read = 0;
     if(I2C_OK == i2c_master_read(&_i2c, address << 1, rxBuffer, quantity))
       read = quantity;
@@ -216,9 +228,13 @@ uint8_t TwoWire::endTransmission(uint8_t sendStop)
     break;
     }
 
+    // reset Tx buffer
+    resetTxBuffer();
+
     // reset tx buffer iterator vars
     txBufferIndex = 0;
     txBufferLength = 0;
+
     // indicate that we are done transmitting
     transmitting = 0;
   }
@@ -241,8 +257,9 @@ size_t TwoWire::write(uint8_t data)
 {
   if(transmitting){
   // in master transmitter mode
-    // don't bother if buffer is full
-    if(txBufferLength >= BUFFER_LENGTH){
+    allocateTxBuffer(txBufferLength + 1);
+    // error if no memory block available to allocate the buffer
+    if(txBuffer == nullptr){
       setWriteError();
       return 0;
     }
@@ -254,27 +271,44 @@ size_t TwoWire::write(uint8_t data)
   }else{
   // in slave send mode
     // reply to master
-    i2c_slave_write_IT(&_i2c,&data,1);
+    if(i2c_slave_write_IT(&_i2c,&data,1) != I2C_OK) {
+      return 0;
+    }
   }
   return 1;
 }
 
-// must be called in:
-// slave tx event callback
-// or after beginTransmission(address)
+/**
+  * @brief  This function must be called in slave Tx event callback or after
+  *         beginTransmission() and before endTransmission().
+  * @param  pdata: pointer to the buffer data
+  * @param  quantity: number of bytes to write
+  * @retval number of bytes ready to write.
+  */
 size_t TwoWire::write(const uint8_t *data, size_t quantity)
 {
   if(transmitting){
   // in master transmitter mode
-    for(size_t i = 0; i < quantity; ++i){
-      write(data[i]);
+    allocateTxBuffer(txBufferLength + quantity);
+    // error if no memory block available to allocate the buffer
+    if(txBuffer == nullptr){
+      setWriteError();
+      return 0;
     }
+    // put bytes in tx buffer
+	memcpy(&(txBuffer[txBufferIndex]), data, quantity);
+    txBufferIndex= txBufferIndex + quantity;
+    // update amount in buffer
+    txBufferLength = txBufferIndex;
+    return quantity;
   }else{
   // in slave send mode
     // reply to master
-    i2c_slave_write_IT(&_i2c,(uint8_t *)data,quantity);
+    if(i2c_slave_write_IT(&_i2c, (uint8_t *)data, quantity) == I2C_OK) {
+      return quantity;
+    }
   }
-  return quantity;
+  return 0;
 }
 
 // must be called in:
@@ -296,6 +330,13 @@ int TwoWire::read(void)
   if(rxBufferIndex < rxBufferLength){
     value = rxBuffer[rxBufferIndex];
     ++rxBufferIndex;
+
+    /* Commented as not I think it is not useful
+     * but kept to show that it is possible to
+     * reset rx buffer when no more data available */
+    /*if(rxBufferIndex == rxBufferLength) {
+      resetRxBuffer();
+    }*/
   }
 
   return value;
@@ -319,8 +360,10 @@ void TwoWire::flush(void)
 {
   rxBufferIndex = 0;
   rxBufferLength = 0;
+  resetRxBuffer();
   txBufferIndex = 0;
   txBufferLength = 0;
+  resetTxBuffer();
 }
 
 // behind the scenes function that is called when data is received
@@ -339,9 +382,7 @@ void TwoWire::onReceiveService(uint8_t* inBytes, int numBytes)
   }
   // copy twi rx buffer into local read buffer
   // this enables new reads to happen in parallel
-  for(uint8_t i = 0; i < numBytes; ++i){
-    rxBuffer[i] = inBytes[i];
-  }
+  memcpy(rxBuffer, inBytes, numBytes);
   // set rx iterator vars
   rxBufferIndex = 0;
   rxBufferLength = numBytes;
@@ -377,6 +418,44 @@ void TwoWire::onRequest( void (*function)(void) )
   user_onRequest = function;
 }
 
+/**
+  * @brief  Allocate the Rx/Tx buffer to the requested length if needed
+  * @note   Minimum allocated size is BUFFER_LENGTH)
+  * @param  length: number of bytes to allocate
+  */
+inline void TwoWire::allocateRxBuffer(size_t length)
+{
+  if(rxBufferAllocated < length) {
+  // By default we allocate BUFFER_LENGTH bytes. It is the min size of the buffer.
+    if(length < BUFFER_LENGTH) { length = BUFFER_LENGTH; }
+    rxBuffer = (uint8_t *)realloc(rxBuffer, length * sizeof(uint8_t));
+	rxBufferAllocated = (rxBuffer != nullptr) ? length: 0;
+  }
+}
+
+inline void TwoWire::allocateTxBuffer(size_t length)
+{
+  if(txBufferAllocated < length) {
+    // By default we allocate BUFFER_LENGTH bytes. It is the min size of the buffer.
+    if(length < BUFFER_LENGTH) { length = BUFFER_LENGTH; }
+    txBuffer = (uint8_t *)realloc(txBuffer, length * sizeof(uint8_t));
+    txBufferAllocated = (txBuffer != nullptr) ? length: 0;
+  }
+}
+
+/**
+  * @brief  Reset Rx/Tx buffer content to 0
+  */
+inline void TwoWire::resetRxBuffer(void)
+{
+  if (rxBuffer != nullptr) memset(rxBuffer, 0, rxBufferAllocated);
+}
+
+inline void TwoWire::resetTxBuffer(void)
+{
+  if (txBuffer != nullptr) memset(txBuffer, 0, txBufferAllocated);
+}
+
 // Preinstantiate Objects //////////////////////////////////////////////////////
 
 TwoWire Wire = TwoWire(); //D14-D15

libraries/Wire/Wire.h renamed to libraries/Wire/src/Wire.h

@@ -36,12 +36,14 @@
 class TwoWire : public Stream
 {
   private:
-    static uint8_t rxBuffer[BUFFER_LENGTH];
+    static uint8_t *rxBuffer;
+    static uint8_t rxBufferAllocated;
     static uint8_t rxBufferIndex;
     static uint8_t rxBufferLength;
 
     static uint8_t txAddress;
-    static uint8_t txBuffer[BUFFER_LENGTH];
+    static uint8_t *txBuffer;
+    static uint8_t txBufferAllocated;
     static uint8_t txBufferIndex;
     static uint8_t txBufferLength;
 
@@ -56,6 +58,12 @@ class TwoWire : public Stream
     static void onRequestService(void);
     static void onReceiveService(uint8_t*, int);
 
+    void allocateRxBuffer(size_t length);
+    void allocateTxBuffer(size_t length);
+
+    void resetRxBuffer(void);
+    void resetTxBuffer(void);
+
   public:
     TwoWire();
     TwoWire(uint8_t sda, uint8_t scl);
@@ -70,7 +78,7 @@ class TwoWire : public Stream
     uint8_t endTransmission(uint8_t);
     uint8_t requestFrom(uint8_t, uint8_t);
     uint8_t requestFrom(uint8_t, uint8_t, uint8_t);
-	  uint8_t requestFrom(uint8_t, uint8_t, uint32_t, uint8_t, uint8_t);
+    uint8_t requestFrom(uint8_t, uint8_t, uint32_t, uint8_t, uint8_t);
     uint8_t requestFrom(int, int);
     uint8_t requestFrom(int, int, int);
     virtual size_t write(uint8_t);
@@ -89,6 +97,8 @@ class TwoWire : public Stream
     using Print::write;
 };
 
+
+
 extern TwoWire Wire;
 
 #endif