I2C functions validated

Specific Wire examples for STM32F1xx added.

Signed-off-by: fpr <fabien.perroquin@wi6labs.com>

Author: fpr

cores/arduino/stm32/twi.c

@@ -47,10 +47,10 @@
 /** @addtogroup STM32F4xx_System_Private_Includes
   * @{
   */
-
 #include "stm32_def.h"
 #include "hw_config.h"
 #include "twi.h"
+#include "PinAF_STM32F1.h"
 
 /**
   * @}
@@ -168,6 +168,9 @@ void i2c_custom_init(i2c_t *obj, i2c_timing_e timing, uint32_t addressingMode, u
       __HAL_RCC_I2C1_FORCE_RESET();
       __HAL_RCC_I2C1_RELEASE_RESET();
       obj->irq = I2C1_EV_IRQn;
+#ifdef STM32F1xx
+      obj->irqER = I2C1_ER_IRQn;
+#endif
       i2c_handles[0] = handle;
   }
 #endif
@@ -181,6 +184,9 @@ void i2c_custom_init(i2c_t *obj, i2c_timing_e timing, uint32_t addressingMode, u
       obj->irq = I2C2_IRQn;
 #else
       obj->irq = I2C2_EV_IRQn;
+#ifdef STM32F1xx
+      obj->irqER = I2C2_ER_IRQn;
+#endif
 #endif
       i2c_handles[1] = handle;
   }
@@ -212,7 +218,11 @@ void i2c_custom_init(i2c_t *obj, i2c_timing_e timing, uint32_t addressingMode, u
   GPIO_InitStruct.Mode        = STM_PIN_MODE(pinmap_function(obj->scl,PinMap_I2C_SCL));
   GPIO_InitStruct.Speed       = GPIO_SPEED_FREQ_HIGH;
   GPIO_InitStruct.Pull        = STM_PIN_PUPD(pinmap_function(obj->scl,PinMap_I2C_SCL));
+#ifdef STM32F1xx
+  pin_SetF1AFPin(STM_PIN_AFNUM(pinmap_function(obj->scl,PinMap_I2C_SCL)));
+#else
   GPIO_InitStruct.Alternate   = STM_PIN_AFNUM(pinmap_function(obj->scl,PinMap_I2C_SCL));
+#endif /* STM32F1xx */
   HAL_GPIO_Init(port, &GPIO_InitStruct);
 
   //SDA
@@ -221,7 +231,11 @@ void i2c_custom_init(i2c_t *obj, i2c_timing_e timing, uint32_t addressingMode, u
   GPIO_InitStruct.Mode        = STM_PIN_MODE(pinmap_function(obj->sda,PinMap_I2C_SDA));
   GPIO_InitStruct.Speed       = GPIO_SPEED_FREQ_HIGH;
   GPIO_InitStruct.Pull        = STM_PIN_PUPD(pinmap_function(obj->sda,PinMap_I2C_SDA));
+#ifdef STM32F1xx
+  pin_SetF1AFPin(STM_PIN_AFNUM(pinmap_function(obj->sda,PinMap_I2C_SDA)));
+#else
   GPIO_InitStruct.Alternate   = STM_PIN_AFNUM(pinmap_function(obj->sda,PinMap_I2C_SDA));
+#endif /* STM32F1xx */
   HAL_GPIO_Init(port, &GPIO_InitStruct);
 
   handle->Instance             = obj->i2c;
@@ -242,6 +256,10 @@ void i2c_custom_init(i2c_t *obj, i2c_timing_e timing, uint32_t addressingMode, u
   if(master == 0) {
     HAL_NVIC_SetPriority(obj->irq, 0, 1);
     HAL_NVIC_EnableIRQ(obj->irq);
+#ifdef STM32F1xx
+    HAL_NVIC_SetPriority(obj->irqER, 0, 1);
+    HAL_NVIC_EnableIRQ(obj->irqER);
+#endif
   }
 
   // Init the I2C
@@ -256,6 +274,9 @@ void i2c_custom_init(i2c_t *obj, i2c_timing_e timing, uint32_t addressingMode, u
 void i2c_deinit(i2c_t *obj)
 {
   HAL_NVIC_DisableIRQ(obj->irq);
+#ifdef STM32F1xx
+  HAL_NVIC_DisableIRQ(obj->irqER);
+#endif
   HAL_I2C_DeInit(&(obj->handle));
 }
 
@@ -402,8 +423,16 @@ i2c_t *get_i2c_obj(I2C_HandleTypeDef *hi2c){
   */
 void i2c_attachSlaveRxEvent(i2c_t *obj, void (*function)(uint8_t*, int) )
 {
+  if((obj == NULL) || (function == NULL))
+    return;
+
   obj->i2c_onSlaveReceive = function;
+#ifdef STM32F1xx
+  obj->i2cTxRxBufferSize = 0;
+  HAL_I2C_Slave_Receive_IT(&(obj->handle), obj->i2cTxRxBuffer, I2C_TXRX_BUFFER_SIZE);
+#else
   HAL_I2C_EnableListen_IT(&(obj->handle));
+#endif
 }
 
 /** @brief  sets function called before a slave write operation
@@ -413,10 +442,64 @@ void i2c_attachSlaveRxEvent(i2c_t *obj, void (*function)(uint8_t*, int) )
   */
 void i2c_attachSlaveTxEvent(i2c_t *obj, void (*function)(void) )
 {
+  if((obj == NULL) || (function == NULL))
+    return;
+
   obj->i2c_onSlaveTransmit = function;
+#ifdef STM32F1xx
+  /* Fill i2c buffer with data to transmit otherwize the buffer will be empty
+  when master will read the data for the first time */
+  obj->i2cTxRxBufferSize = 0;
+  obj->i2c_onSlaveTransmit();
+  HAL_I2C_Slave_Transmit_IT(&(obj->handle), obj->i2cTxRxBuffer, obj->i2cTxRxBufferSize);
+#else
   HAL_I2C_EnableListen_IT(&(obj->handle));
+#endif
+}
+
+#ifdef STM32F1xx
+
+/** @brief  Slave Tx Transfer completed callback.
+  * @param  hi2c Pointer to a I2C_HandleTypeDef structure that contains
+  *                the configuration information for the specified I2C.
+  * @retval None
+  */
+void HAL_I2C_SlaveTxCpltCallback(I2C_HandleTypeDef *hi2c)
+{
+  i2c_t *obj = get_i2c_obj(hi2c);
+
+  if(NULL != obj->i2c_onSlaveTransmit) {
+    // reset buffer size and fill buffer with new data before the next Tx
+    obj->i2cTxRxBufferSize = 0;
+    obj->i2c_onSlaveTransmit();
+    HAL_I2C_Slave_Transmit_IT(hi2c, obj->i2cTxRxBuffer, obj->i2cTxRxBufferSize);
+  }
+}
+
+/**
+  * @brief  Slave Rx Transfer completed callback.
+  * @param  hi2c Pointer to a I2C_HandleTypeDef structure that contains
+  *                the configuration information for the specified I2C.
+  * @retval None
+  */
+void HAL_I2C_SlaveRxCpltCallback(I2C_HandleTypeDef *hi2c)
+{
+  uint8_t nbData = 0;
+  i2c_t *obj = get_i2c_obj(hi2c);
+
+  if(NULL != obj->i2c_onSlaveReceive) {
+    nbData = I2C_TXRX_BUFFER_SIZE - obj->handle.XferCount;
+
+    if(nbData != 0) {
+      obj->i2c_onSlaveReceive(obj->i2cTxRxBuffer, nbData);
+    }
+
+    HAL_I2C_Slave_Receive_IT(hi2c, obj->i2cTxRxBuffer, I2C_TXRX_BUFFER_SIZE);
+  }
 }
 
+#else /* Others */
+
 /**
   * @brief  Slave Address Match callback.
   * @param  hi2c Pointer to a I2C_HandleTypeDef structure that contains
@@ -469,6 +552,8 @@ void HAL_I2C_ListenCpltCallback(I2C_HandleTypeDef *hi2c)
   HAL_I2C_EnableListen_IT(hi2c);
 }
 
+#endif /* STM32F1xx */
+
 /**
   * @brief  I2C error callback.
   * @param  hi2c Pointer to a I2C_HandleTypeDef structure that contains
@@ -477,7 +562,11 @@ void HAL_I2C_ListenCpltCallback(I2C_HandleTypeDef *hi2c)
   */
 void HAL_I2C_ErrorCallback(I2C_HandleTypeDef *hi2c)
 {
+#ifdef STM32F1xx
+  UNUSED(hi2c);
+#else
   HAL_I2C_EnableListen_IT(hi2c);
+#endif
 }
 
 /**

cores/arduino/stm32/twi.h

@@ -67,6 +67,9 @@ struct i2c_s {
   PinName sda;
   PinName scl;
   IRQn_Type irq;
+#ifdef STM32F1xx
+  IRQn_Type irqER;
+#endif
   uint8_t slaveMode;
   void (*i2c_onSlaveReceive)(uint8_t *, int);
   void (*i2c_onSlaveTransmit)(void);

libraries/Wire/Wire.cpp

@@ -81,13 +81,15 @@ void TwoWire::begin(uint8_t address)
 
   i2c_custom_init(&_i2c,I2C_100KHz,I2C_ADDRESSINGMODE_7BIT,ownAddress,master);
 
+#ifndef STM32F1xx
   if(master == false){
     // i2c_attachSlaveTxEvent(&_i2c, reinterpret_cast<void(*)(i2c_t*)>(&TwoWire::onRequestService));
     // i2c_attachSlaveRxEvent(&_i2c, reinterpret_cast<void(*)(i2c_t*, uint8_t*, int)>(&TwoWire::onReceiveService));
 
     i2c_attachSlaveTxEvent(&_i2c, onRequestService);
     i2c_attachSlaveRxEvent(&_i2c, onReceiveService);
   }
+#endif
 }
 
 void TwoWire::begin(int address)
@@ -109,6 +111,8 @@ uint8_t TwoWire::requestFrom(uint8_t address, uint8_t quantity, uint32_t iaddres
 {
   UNUSED(sendStop);
   if (master == true) {
+    //NOTE: do not work with STM32F1xx boards (latest HAL version: 1.0.4)
+#ifndef STM32F1xx
     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
@@ -127,6 +131,7 @@ uint8_t TwoWire::requestFrom(uint8_t address, uint8_t quantity, uint32_t iaddres
       }
       endTransmission(false);
     }
+#endif /* !STM32F1xx */
 
     // clamp to buffer length
     if(quantity > BUFFER_LENGTH){
@@ -369,12 +374,22 @@ void TwoWire::onRequestService(void)
 void TwoWire::onReceive( void (*function)(int) )
 {
   user_onReceive = function;
+
+#ifdef STM32F1xx
+  //Enable slave receive IT
+  i2c_attachSlaveRxEvent(&_i2c, onReceiveService);
+#endif
 }
 
 // sets function called on slave read
 void TwoWire::onRequest( void (*function)(void) )
 {
   user_onRequest = function;
+
+#ifdef STM32F1xx
+  //Enable slave transmit IT
+  i2c_attachSlaveTxEvent(&_i2c, onRequestService);
+#endif
 }
 
 // Preinstantiate Objects //////////////////////////////////////////////////////

libraries/Wire/examples/master_reader_writer/master_reader_writer.ino

@@ -0,0 +1,44 @@
+/* Wire Master Reader Writer
+by Wi6Labs
+
+Demonstrates use of the Wire library, particullary with STM32F1xx boards.
+Reads/writes data from/to an I2C/TWI slave device.
+Refer to the "Wire Slave Sender Receiver" example for use with this.
+
+Created 27 June 2017
+
+This example code is in the public domain.
+*/
+
+#include <Wire.h>
+
+#define I2C_ADDR  2
+
+byte x = 0;
+
+void setup()
+{
+  Wire.begin();        // join i2c bus (address optional for master)
+  Serial.begin(9600);  // start serial for output
+}
+
+void loop()
+{
+  Wire.requestFrom(I2C_ADDR, 6);  // request 6 bytes from slave device
+
+  while(Wire.available())         // slave may send less than requested
+  {
+    char c = Wire.read();         // receive a byte as character
+    Serial.print(c);              // print the character
+  }
+
+  delay(10);
+
+  Wire.beginTransmission(I2C_ADDR); // transmit to device
+  Wire.write("x is ");              // sends five bytes
+  Wire.write(x);                    // sends one byte
+  Wire.endTransmission();           // stop transmitting
+  x++;
+
+  delay(1000);
+}

libraries/Wire/examples/slave_sender_receiver/slave_sender_receiver.ino

@@ -0,0 +1,70 @@
+/* Wire Slave Receiver
+by Wi6Labs
+
+Demonstrates use of the Wire library, particullary with STM32F1xx boards where
+we can't use slave Tx & Rx mode in same time.
+Receives/sends data as an I2C/TWI slave device.
+Refer to the "Wire Master Reader Writer" example for use with this.
+
+Created 27 June 2017
+
+This example code is in the public domain.
+*/
+
+#include <Wire.h>
+
+#define SLAVE_MODE_RX 0
+#define SLAVE_MODE_TX 1
+
+#define I2C_ADDR  2
+
+int w_r_mode = SLAVE_MODE_TX;
+bool switch_mode = false;
+
+void setup()
+{
+  Wire.begin(I2C_ADDR);         // join i2c bus with address #4
+  Wire.onRequest(requestEvent); // register event
+  Serial.begin(9600);           // start serial for output
+}
+
+void loop()
+{
+  if(switch_mode == true) {
+    switch_mode = false;
+    Wire.end();
+    Wire.begin(I2C_ADDR);
+    if(w_r_mode == SLAVE_MODE_TX) {
+      Wire.onRequest(requestEvent); // register event
+    } else {
+      Wire.onReceive(receiveEvent); // register event
+    }
+  }
+}
+
+// function that executes whenever data is received from master
+// this function is registered as an event, see setup()
+void receiveEvent(int howMany)
+{
+  while(1 < Wire.available()) // loop through all but the last
+  {
+    char c = Wire.read(); // receive byte as a character
+    Serial.print(c);         // print the character
+  }
+  int x = Wire.read();    // receive byte as an integer
+  Serial.println(x);         // print the integer
+
+  switch_mode = true;
+  w_r_mode = SLAVE_MODE_TX;
+}
+
+// function that executes whenever data is requested by master
+// this function is registered as an event, see setup()
+void requestEvent()
+{
+  Wire.write("hello "); // respond with message of 6 bytes
+                       // as expected by master
+
+  switch_mode = true;
+  w_r_mode = SLAVE_MODE_RX;
+}