Merge pull request #1777 from Ralim/dev

Release 2.22

source/Core/BSP/MHP30/BSP.cpp

@@ -263,6 +263,25 @@ void unstick_I2C() {
   int              timeout     = 100;
   int              timeout_cnt = 0;
 
+  // 1. Clear PE bit.
+  hi2c1.Instance->CR1 &= ~(0x0001);
+  /**I2C1 GPIO Configuration
+   PB6     ------> I2C1_SCL
+   PB7     ------> I2C1_SDA
+   */
+  //  2. Configure the SCL and SDA I/Os as General Purpose Output Open-Drain, High level (Write 1 to GPIOx_ODR).
+  GPIO_InitStruct.Mode  = GPIO_MODE_OUTPUT_OD;
+  GPIO_InitStruct.Pull  = GPIO_PULLUP;
+  GPIO_InitStruct.Speed = GPIO_SPEED_FREQ_LOW;
+
+  GPIO_InitStruct.Pin = SCL_Pin;
+  HAL_GPIO_Init(SCL_GPIO_Port, &GPIO_InitStruct);
+  HAL_GPIO_WritePin(SCL_GPIO_Port, SCL_Pin, GPIO_PIN_SET);
+
+  GPIO_InitStruct.Pin = SDA_Pin;
+  HAL_GPIO_Init(SDA_GPIO_Port, &GPIO_InitStruct);
+  HAL_GPIO_WritePin(SDA_GPIO_Port, SDA_Pin, GPIO_PIN_SET);
+
   while (GPIO_PIN_SET != HAL_GPIO_ReadPin(SDA_GPIO_Port, SDA_Pin)) {
     // Move clock to release I2C
     HAL_GPIO_WritePin(SCL_GPIO_Port, SCL_Pin, GPIO_PIN_RESET);
@@ -276,6 +295,36 @@ void unstick_I2C() {
     if (timeout_cnt > timeout)
       return;
   }
+
+  // 12. Configure the SCL and SDA I/Os as Alternate function Open-Drain.
+  GPIO_InitStruct.Mode  = GPIO_MODE_AF_OD;
+  GPIO_InitStruct.Pull  = GPIO_PULLUP;
+  GPIO_InitStruct.Speed = GPIO_SPEED_FREQ_LOW;
+
+  GPIO_InitStruct.Pin = SCL_Pin;
+  HAL_GPIO_Init(SCL_GPIO_Port, &GPIO_InitStruct);
+
+  GPIO_InitStruct.Pin = SDA_Pin;
+  HAL_GPIO_Init(SDA_GPIO_Port, &GPIO_InitStruct);
+
+  HAL_GPIO_WritePin(SCL_GPIO_Port, SCL_Pin, GPIO_PIN_SET);
+  HAL_GPIO_WritePin(SDA_GPIO_Port, SDA_Pin, GPIO_PIN_SET);
+
+  // 13. Set SWRST bit in I2Cx_CR1 register.
+  hi2c1.Instance->CR1 |= 0x8000;
+
+  asm("nop");
+
+  // 14. Clear SWRST bit in I2Cx_CR1 register.
+  hi2c1.Instance->CR1 &= ~0x8000;
+
+  asm("nop");
+
+  // 15. Enable the I2C peripheral by setting the PE bit in I2Cx_CR1 register
+  hi2c1.Instance->CR1 |= 0x0001;
+
+  // Call initialization function.
+  HAL_I2C_Init(&hi2c1);
 }
 
 uint8_t getButtonA() { return HAL_GPIO_ReadPin(KEY_A_GPIO_Port, KEY_A_Pin) == GPIO_PIN_RESET ? 1 : 0; }

source/Core/BSP/MHP30/I2C_Wrapper.cpp

@@ -0,0 +1,91 @@
+/*
+ * FRToSI2C.cpp
+ *
+ *  Created on: 14Apr.,2018
+ *      Author: Ralim
+ */
+#include "BSP.h"
+#include "Setup.h"
+#include <I2C_Wrapper.hpp>
+SemaphoreHandle_t FRToSI2C::I2CSemaphore = nullptr;
+StaticSemaphore_t FRToSI2C::xSemaphoreBuffer;
+
+void FRToSI2C::CpltCallback() {
+  hi2c1.State = HAL_I2C_STATE_READY; // Force state reset (even if tx error)
+  if (I2CSemaphore) {
+    xSemaphoreGiveFromISR(I2CSemaphore, NULL);
+  }
+}
+
+bool FRToSI2C::Mem_Read(uint16_t DevAddress, uint16_t MemAddress, uint8_t *pData, uint16_t Size) {
+
+  if (!lock())
+    return false;
+  if (HAL_I2C_Mem_Read(&hi2c1, DevAddress, MemAddress, I2C_MEMADD_SIZE_8BIT, pData, Size, 500) != HAL_OK) {
+
+    I2C_Unstick();
+    unlock();
+    return false;
+  }
+
+  unlock();
+  return true;
+}
+bool FRToSI2C::I2C_RegisterWrite(uint8_t address, uint8_t reg, uint8_t data) { return Mem_Write(address, reg, &data, 1); }
+
+uint8_t FRToSI2C::I2C_RegisterRead(uint8_t add, uint8_t reg) {
+  uint8_t tx_data[1];
+  Mem_Read(add, reg, tx_data, 1);
+  return tx_data[0];
+}
+bool FRToSI2C::Mem_Write(uint16_t DevAddress, uint16_t MemAddress, uint8_t *pData, uint16_t Size) {
+
+  if (!lock())
+    return false;
+  if (HAL_I2C_Mem_Write(&hi2c1, DevAddress, MemAddress, I2C_MEMADD_SIZE_8BIT, pData, Size, 500) != HAL_OK) {
+
+    I2C_Unstick();
+    unlock();
+    return false;
+  }
+
+  unlock();
+  return true;
+}
+
+bool FRToSI2C::Transmit(uint16_t DevAddress, uint8_t *pData, uint16_t Size) {
+  if (!lock())
+    return false;
+  if (HAL_I2C_Master_Transmit_DMA(&hi2c1, DevAddress, pData, Size) != HAL_OK) {
+    I2C_Unstick();
+    unlock();
+    return false;
+  }
+  return true;
+}
+
+bool FRToSI2C::probe(uint16_t DevAddress) {
+  if (!lock())
+    return false;
+  uint8_t buffer[1];
+  bool    worked = HAL_I2C_Mem_Read(&hi2c1, DevAddress, 0x0F, I2C_MEMADD_SIZE_8BIT, buffer, 1, 1000) == HAL_OK;
+  unlock();
+  return worked;
+}
+
+void FRToSI2C::I2C_Unstick() { unstick_I2C(); }
+
+void FRToSI2C::unlock() { xSemaphoreGive(I2CSemaphore); }
+
+bool FRToSI2C::lock() { return xSemaphoreTake(I2CSemaphore, (TickType_t)50) == pdTRUE; }
+
+bool FRToSI2C::writeRegistersBulk(const uint8_t address, const I2C_REG *registers, const uint8_t registersLength) {
+  for (int index = 0; index < registersLength; index++) {
+    if (!I2C_RegisterWrite(address, registers[index].reg, registers[index].val)) {
+      return false;
+    }
+    if (registers[index].pause_ms)
+      delay_ms(registers[index].pause_ms);
+  }
+  return true;
+}

source/Core/BSP/MHP30/IRQ.cpp

@@ -27,6 +27,12 @@ void HAL_ADC_ConvCpltCallback(ADC_HandleTypeDef *hadc) {
     }
   }
 }
+void HAL_I2C_MasterRxCpltCallback(I2C_HandleTypeDef *hi2c __unused) { FRToSI2C::CpltCallback(); }
+void HAL_I2C_MasterTxCpltCallback(I2C_HandleTypeDef *hi2c __unused) { FRToSI2C::CpltCallback(); }
+void HAL_I2C_MemTxCpltCallback(I2C_HandleTypeDef *hi2c __unused) { FRToSI2C::CpltCallback(); }
+void HAL_I2C_ErrorCallback(I2C_HandleTypeDef *hi2c __unused) { FRToSI2C::CpltCallback(); }
+void HAL_I2C_AbortCpltCallback(I2C_HandleTypeDef *hi2c __unused) { FRToSI2C::CpltCallback(); }
+void HAL_I2C_MemRxCpltCallback(I2C_HandleTypeDef *hi2c __unused) { FRToSI2C::CpltCallback(); }
 
 extern osThreadId POWTaskHandle;
 void              HAL_GPIO_EXTI_Callback(uint16_t GPIO_Pin) {

source/Core/BSP/MHP30/IRQ.h

@@ -18,6 +18,12 @@
 extern "C" {
 #endif
 void HAL_ADC_ConvCpltCallback(ADC_HandleTypeDef *hadc);
+void HAL_I2C_ErrorCallback(I2C_HandleTypeDef *hi2c);
+void HAL_I2C_AbortCpltCallback(I2C_HandleTypeDef *hi2c);
+void HAL_I2C_MasterTxCpltCallback(I2C_HandleTypeDef *hi2c);
+void HAL_I2C_MasterRxCpltCallback(I2C_HandleTypeDef *hi2c);
+void HAL_I2C_MemTxCpltCallback(I2C_HandleTypeDef *hi2c);
+void HAL_I2C_MemRxCpltCallback(I2C_HandleTypeDef *hi2c);
 void HAL_GPIO_EXTI_Callback(uint16_t);
 
 #ifdef __cplusplus

source/Core/BSP/MHP30/Setup.c

@@ -11,6 +11,10 @@ ADC_HandleTypeDef hadc1;
 ADC_HandleTypeDef hadc2;
 DMA_HandleTypeDef hdma_adc1;
 
+I2C_HandleTypeDef hi2c1;
+DMA_HandleTypeDef hdma_i2c1_rx;
+DMA_HandleTypeDef hdma_i2c1_tx;
+
 IWDG_HandleTypeDef hiwdg;
 TIM_HandleTypeDef  htim2;
 TIM_HandleTypeDef  htim3;
@@ -21,7 +25,7 @@ uint32_t ADCReadings[ADC_SAMPLES * ADC_CHANNELS]; // room for 32 lots of the pai
 // Functions
 static void SystemClock_Config(void);
 static void MX_ADC1_Init(void);
-
+static void MX_I2C1_Init(void);
 static void MX_IWDG_Init(void);
 static void MX_TIM3_Init(void);
 static void MX_TIM2_Init(void);
@@ -35,7 +39,7 @@ void        Setup_HAL() {
 
   MX_GPIO_Init();
   MX_DMA_Init();
-
+  MX_I2C1_Init();
   MX_ADC1_Init();
   MX_ADC2_Init();
   MX_TIM3_Init();
@@ -123,12 +127,12 @@ static void MX_ADC1_Init(void) {
 
   /**Configure the ADC multi-mode
    */
-  multimode.Mode = ADC_MODE_INDEPENDENT;
+  multimode.Mode = ADC_DUALMODE_REGSIMULT_INJECSIMULT;
   HAL_ADCEx_MultiModeConfigChannel(&hadc1, &multimode);
 
   /**Configure Regular Channel
    */
-  sConfig.SamplingTime = ADC_SAMPLETIME_71CYCLES_5;
+  sConfig.SamplingTime = ADC_SAMPLETIME_239CYCLES_5;
 
   sConfig.Channel = TMP36_ADC1_CHANNEL;
   sConfig.Rank    = ADC_REGULAR_RANK_1;
@@ -192,6 +196,19 @@ static void MX_ADC2_Init(void) {
     ;
   }
 }
+/* I2C1 init function */
+static void MX_I2C1_Init(void) {
+  hi2c1.Instance             = I2C1;
+  hi2c1.Init.ClockSpeed      = 300000;
+  hi2c1.Init.DutyCycle       = I2C_DUTYCYCLE_2;
+  hi2c1.Init.OwnAddress1     = 0;
+  hi2c1.Init.AddressingMode  = I2C_ADDRESSINGMODE_7BIT;
+  hi2c1.Init.DualAddressMode = I2C_DUALADDRESS_DISABLE;
+  hi2c1.Init.OwnAddress2     = 0;
+  hi2c1.Init.GeneralCallMode = I2C_GENERALCALL_DISABLE;
+  hi2c1.Init.NoStretchMode   = I2C_NOSTRETCH_DISABLE;
+  HAL_I2C_Init(&hi2c1);
+}
 
 /* IWDG init function */
 static void MX_IWDG_Init(void) {

source/Core/BSP/MHP30/Setup.h

@@ -20,6 +20,7 @@ extern DMA_HandleTypeDef hdma_adc1;
 
 extern DMA_HandleTypeDef hdma_i2c1_rx;
 extern DMA_HandleTypeDef hdma_i2c1_tx;
+extern I2C_HandleTypeDef hi2c1;
 
 extern IWDG_HandleTypeDef hiwdg;
 

source/Core/BSP/MHP30/Software_I2C.h

@@ -18,26 +18,13 @@
 #define SOFT_SDA2_LOW()  HAL_GPIO_WritePin(SDA2_GPIO_Port, SDA2_Pin, GPIO_PIN_RESET)
 #define SOFT_SDA2_READ() (HAL_GPIO_ReadPin(SDA2_GPIO_Port, SDA2_Pin) == GPIO_PIN_SET ? 1 : 0)
 #define SOFT_SCL2_READ() (HAL_GPIO_ReadPin(SCL2_GPIO_Port, SCL2_Pin) == GPIO_PIN_SET ? 1 : 0)
-
-#endif
-
-#ifdef I2C_SOFT_BUS_1
-#define SOFT_SCL1_HIGH() HAL_GPIO_WritePin(SCL_GPIO_Port, SCL_Pin, GPIO_PIN_SET)
-#define SOFT_SCL1_LOW()  HAL_GPIO_WritePin(SCL_GPIO_Port, SCL_Pin, GPIO_PIN_RESET)
-#define SOFT_SDA1_HIGH() HAL_GPIO_WritePin(SDA_GPIO_Port, SDA_Pin, GPIO_PIN_SET)
-#define SOFT_SDA1_LOW()  HAL_GPIO_WritePin(SDA_GPIO_Port, SDA_Pin, GPIO_PIN_RESET)
-#define SOFT_SDA1_READ() (HAL_GPIO_ReadPin(SDA_GPIO_Port, SDA_Pin) == GPIO_PIN_SET ? 1 : 0)
-#define SOFT_SCL1_READ() (HAL_GPIO_ReadPin(SCL_GPIO_Port, SCL_Pin) == GPIO_PIN_SET ? 1 : 0)
-
-#endif
-
 #define SOFT_I2C_DELAY()              \
   {                                   \
-    for (int xx = 0; xx < 15; xx++) { \
+    for (int xx = 0; xx < 20; xx++) { \
       asm("nop");                     \
     }                                 \
   }
 
-// 40 ~= 100kHz; 15 gives around 250kHz or so which is fast _and_ stable
+#endif
 
 #endif /* BSP_MINIWARE_SOFTWARE_I2C_H_ */

source/Core/BSP/MHP30/Vendor/STM32F1xx_HAL_Driver/Inc/stm32f1xx_hal_i2c.h

@@ -0,0 +1,728 @@
+/**
+ ******************************************************************************
+ * @file    stm32f1xx_hal_i2c.h
+ * @author  MCD Application Team
+ * @brief   Header file of I2C HAL module.
+ ******************************************************************************
+ * @attention
+ *
+ * <h2><center>&copy; Copyright (c) 2016 STMicroelectronics.
+ * All rights reserved.</center></h2>
+ *
+ * This software component is licensed by ST under BSD 3-Clause license,
+ * the "License"; You may not use this file except in compliance with the
+ * License. You may obtain a copy of the License at:
+ *                        opensource.org/licenses/BSD-3-Clause
+ *
+ ******************************************************************************
+ */
+
+/* Define to prevent recursive inclusion -------------------------------------*/
+#ifndef __STM32F1xx_HAL_I2C_H
+#define __STM32F1xx_HAL_I2C_H
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+/* Includes ------------------------------------------------------------------*/
+#include "stm32f1xx_hal_def.h"
+
+/** @addtogroup STM32F1xx_HAL_Driver
+ * @{
+ */
+
+/** @addtogroup I2C
+ * @{
+ */
+
+/* Exported types ------------------------------------------------------------*/
+/** @defgroup I2C_Exported_Types I2C Exported Types
+ * @{
+ */
+
+/** @defgroup I2C_Configuration_Structure_definition I2C Configuration Structure definition
+ * @brief  I2C Configuration Structure definition
+ * @{
+ */
+typedef struct {
+  uint32_t ClockSpeed; /*!< Specifies the clock frequency.
+                            This parameter must be set to a value lower than 400kHz */
+
+  uint32_t DutyCycle; /*!< Specifies the I2C fast mode duty cycle.
+                           This parameter can be a value of @ref I2C_duty_cycle_in_fast_mode */
+
+  uint32_t OwnAddress1; /*!< Specifies the first device own address.
+                             This parameter can be a 7-bit or 10-bit address. */
+
+  uint32_t AddressingMode; /*!< Specifies if 7-bit or 10-bit addressing mode is selected.
+                                This parameter can be a value of @ref I2C_addressing_mode */
+
+  uint32_t DualAddressMode; /*!< Specifies if dual addressing mode is selected.
+                                 This parameter can be a value of @ref I2C_dual_addressing_mode */
+
+  uint32_t OwnAddress2; /*!< Specifies the second device own address if dual addressing mode is selected
+                             This parameter can be a 7-bit address. */
+
+  uint32_t GeneralCallMode; /*!< Specifies if general call mode is selected.
+                                 This parameter can be a value of @ref I2C_general_call_addressing_mode */
+
+  uint32_t NoStretchMode; /*!< Specifies if nostretch mode is selected.
+                               This parameter can be a value of @ref I2C_nostretch_mode */
+
+} I2C_InitTypeDef;
+
+/**
+ * @}
+ */
+
+/** @defgroup HAL_state_structure_definition HAL state structure definition
+ * @brief  HAL State structure definition
+ * @note  HAL I2C State value coding follow below described bitmap :
+ *          b7-b6  Error information
+ *             00 : No Error
+ *             01 : Abort (Abort user request on going)
+ *             10 : Timeout
+ *             11 : Error
+ *          b5     Peripheral initilisation status
+ *             0  : Reset (Peripheral not initialized)
+ *             1  : Init done (Peripheral initialized and ready to use. HAL I2C Init function called)
+ *          b4     (not used)
+ *             x  : Should be set to 0
+ *          b3
+ *             0  : Ready or Busy (No Listen mode ongoing)
+ *             1  : Listen (Peripheral in Address Listen Mode)
+ *          b2     Intrinsic process state
+ *             0  : Ready
+ *             1  : Busy (Peripheral busy with some configuration or internal operations)
+ *          b1     Rx state
+ *             0  : Ready (no Rx operation ongoing)
+ *             1  : Busy (Rx operation ongoing)
+ *          b0     Tx state
+ *             0  : Ready (no Tx operation ongoing)
+ *             1  : Busy (Tx operation ongoing)
+ * @{
+ */
+typedef enum {
+  HAL_I2C_STATE_RESET          = 0x00U, /*!< Peripheral is not yet Initialized         */
+  HAL_I2C_STATE_READY          = 0x20U, /*!< Peripheral Initialized and ready for use  */
+  HAL_I2C_STATE_BUSY           = 0x24U, /*!< An internal process is ongoing            */
+  HAL_I2C_STATE_BUSY_TX        = 0x21U, /*!< Data Transmission process is ongoing      */
+  HAL_I2C_STATE_BUSY_RX        = 0x22U, /*!< Data Reception process is ongoing         */
+  HAL_I2C_STATE_LISTEN         = 0x28U, /*!< Address Listen Mode is ongoing            */
+  HAL_I2C_STATE_BUSY_TX_LISTEN = 0x29U, /*!< Address Listen Mode and Data Transmission
+                                            process is ongoing                         */
+  HAL_I2C_STATE_BUSY_RX_LISTEN = 0x2AU, /*!< Address Listen Mode and Data Reception
+                                            process is ongoing                         */
+  HAL_I2C_STATE_ABORT   = 0x60U,        /*!< Abort user request ongoing                */
+  HAL_I2C_STATE_TIMEOUT = 0xA0U,        /*!< Timeout state                             */
+  HAL_I2C_STATE_ERROR   = 0xE0U         /*!< Error                                     */
+
+} HAL_I2C_StateTypeDef;
+
+/**
+ * @}
+ */
+
+/** @defgroup HAL_mode_structure_definition HAL mode structure definition
+ * @brief  HAL Mode structure definition
+ * @note  HAL I2C Mode value coding follow below described bitmap :\n
+ *          b7     (not used)\n
+ *             x  : Should be set to 0\n
+ *          b6\n
+ *             0  : None\n
+ *             1  : Memory (HAL I2C communication is in Memory Mode)\n
+ *          b5\n
+ *             0  : None\n
+ *             1  : Slave (HAL I2C communication is in Slave Mode)\n
+ *          b4\n
+ *             0  : None\n
+ *             1  : Master (HAL I2C communication is in Master Mode)\n
+ *          b3-b2-b1-b0  (not used)\n
+ *             xxxx : Should be set to 0000
+ * @{
+ */
+typedef enum {
+  HAL_I2C_MODE_NONE   = 0x00U, /*!< No I2C communication on going             */
+  HAL_I2C_MODE_MASTER = 0x10U, /*!< I2C communication is in Master Mode       */
+  HAL_I2C_MODE_SLAVE  = 0x20U, /*!< I2C communication is in Slave Mode        */
+  HAL_I2C_MODE_MEM    = 0x40U  /*!< I2C communication is in Memory Mode       */
+
+} HAL_I2C_ModeTypeDef;
+
+/**
+ * @}
+ */
+
+/** @defgroup I2C_Error_Code_definition I2C Error Code definition
+ * @brief  I2C Error Code definition
+ * @{
+ */
+#define HAL_I2C_ERROR_NONE      0x00000000U /*!< No error              */
+#define HAL_I2C_ERROR_BERR      0x00000001U /*!< BERR error            */
+#define HAL_I2C_ERROR_ARLO      0x00000002U /*!< ARLO error            */
+#define HAL_I2C_ERROR_AF        0x00000004U /*!< AF error              */
+#define HAL_I2C_ERROR_OVR       0x00000008U /*!< OVR error             */
+#define HAL_I2C_ERROR_DMA       0x00000010U /*!< DMA transfer error    */
+#define HAL_I2C_ERROR_TIMEOUT   0x00000020U /*!< Timeout Error         */
+#define HAL_I2C_ERROR_SIZE      0x00000040U /*!< Size Management error */
+#define HAL_I2C_ERROR_DMA_PARAM 0x00000080U /*!< DMA Parameter Error   */
+#define HAL_I2C_WRONG_START     0x00000200U /*!< Wrong start Error     */
+#if (USE_HAL_I2C_REGISTER_CALLBACKS == 1)
+#define HAL_I2C_ERROR_INVALID_CALLBACK 0x00000100U /*!< Invalid Callback error */
+#endif                                             /* USE_HAL_I2C_REGISTER_CALLBACKS */
+/**
+ * @}
+ */
+
+/** @defgroup I2C_handle_Structure_definition I2C handle Structure definition
+ * @brief  I2C handle Structure definition
+ * @{
+ */
+#if (USE_HAL_I2C_REGISTER_CALLBACKS == 1)
+typedef struct __I2C_HandleTypeDef
+#else
+typedef struct
+#endif /* USE_HAL_I2C_REGISTER_CALLBACKS */
+{
+  I2C_TypeDef *Instance; /*!< I2C registers base address               */
+
+  I2C_InitTypeDef Init; /*!< I2C communication parameters             */
+
+  uint8_t *pBuffPtr; /*!< Pointer to I2C transfer buffer           */
+
+  uint16_t XferSize; /*!< I2C transfer size                        */
+
+  __IO uint16_t XferCount; /*!< I2C transfer counter                     */
+
+  __IO uint32_t XferOptions; /*!< I2C transfer options                     */
+
+  __IO uint32_t PreviousState; /*!< I2C communication Previous state and mode
+                                    context for internal usage               */
+
+  DMA_HandleTypeDef *hdmatx; /*!< I2C Tx DMA handle parameters             */
+
+  DMA_HandleTypeDef *hdmarx; /*!< I2C Rx DMA handle parameters             */
+
+  HAL_LockTypeDef Lock; /*!< I2C locking object                       */
+
+  __IO HAL_I2C_StateTypeDef State; /*!< I2C communication state                  */
+
+  __IO HAL_I2C_ModeTypeDef Mode; /*!< I2C communication mode                   */
+
+  __IO uint32_t ErrorCode; /*!< I2C Error code                           */
+
+  __IO uint32_t Devaddress; /*!< I2C Target device address                */
+
+  __IO uint32_t Memaddress; /*!< I2C Target memory address                */
+
+  __IO uint32_t MemaddSize; /*!< I2C Target memory address  size          */
+
+  __IO uint32_t EventCount; /*!< I2C Event counter                        */
+#ifndef USE_HAL_I2C_REGISTER_CALLBACKS
+#define USE_HAL_I2C_REGISTER_CALLBACKS 0
+#endif
+#if (USE_HAL_I2C_REGISTER_CALLBACKS == 1)
+  void (*MasterTxCpltCallback)(struct __I2C_HandleTypeDef *hi2c); /*!< I2C Master Tx Transfer completed callback */
+  void (*MasterRxCpltCallback)(struct __I2C_HandleTypeDef *hi2c); /*!< I2C Master Rx Transfer completed callback */
+  void (*SlaveTxCpltCallback)(struct __I2C_HandleTypeDef *hi2c);  /*!< I2C Slave Tx Transfer completed callback  */
+  void (*SlaveRxCpltCallback)(struct __I2C_HandleTypeDef *hi2c);  /*!< I2C Slave Rx Transfer completed callback  */
+  void (*ListenCpltCallback)(struct __I2C_HandleTypeDef *hi2c);   /*!< I2C Listen Complete callback              */
+  void (*MemTxCpltCallback)(struct __I2C_HandleTypeDef *hi2c);    /*!< I2C Memory Tx Transfer completed callback */
+  void (*MemRxCpltCallback)(struct __I2C_HandleTypeDef *hi2c);    /*!< I2C Memory Rx Transfer completed callback */
+  void (*ErrorCallback)(struct __I2C_HandleTypeDef *hi2c);        /*!< I2C Error callback                        */
+  void (*AbortCpltCallback)(struct __I2C_HandleTypeDef *hi2c);    /*!< I2C Abort callback                        */
+
+  void (*AddrCallback)(struct __I2C_HandleTypeDef *hi2c, uint8_t TransferDirection, uint16_t AddrMatchCode); /*!< I2C Slave Address Match callback */
+
+  void (*MspInitCallback)(struct __I2C_HandleTypeDef *hi2c);   /*!< I2C Msp Init callback                     */
+  void (*MspDeInitCallback)(struct __I2C_HandleTypeDef *hi2c); /*!< I2C Msp DeInit callback                   */
+
+#endif /* USE_HAL_I2C_REGISTER_CALLBACKS */
+} I2C_HandleTypeDef;
+
+#if (USE_HAL_I2C_REGISTER_CALLBACKS == 1)
+/**
+ * @brief  HAL I2C Callback ID enumeration definition
+ */
+typedef enum {
+  HAL_I2C_MASTER_TX_COMPLETE_CB_ID = 0x00U, /*!< I2C Master Tx Transfer completed callback ID  */
+  HAL_I2C_MASTER_RX_COMPLETE_CB_ID = 0x01U, /*!< I2C Master Rx Transfer completed callback ID  */
+  HAL_I2C_SLAVE_TX_COMPLETE_CB_ID  = 0x02U, /*!< I2C Slave Tx Transfer completed callback ID   */
+  HAL_I2C_SLAVE_RX_COMPLETE_CB_ID  = 0x03U, /*!< I2C Slave Rx Transfer completed callback ID   */
+  HAL_I2C_LISTEN_COMPLETE_CB_ID    = 0x04U, /*!< I2C Listen Complete callback ID               */
+  HAL_I2C_MEM_TX_COMPLETE_CB_ID    = 0x05U, /*!< I2C Memory Tx Transfer callback ID            */
+  HAL_I2C_MEM_RX_COMPLETE_CB_ID    = 0x06U, /*!< I2C Memory Rx Transfer completed callback ID  */
+  HAL_I2C_ERROR_CB_ID              = 0x07U, /*!< I2C Error callback ID                         */
+  HAL_I2C_ABORT_CB_ID              = 0x08U, /*!< I2C Abort callback ID                         */
+
+  HAL_I2C_MSPINIT_CB_ID   = 0x09U, /*!< I2C Msp Init callback ID                      */
+  HAL_I2C_MSPDEINIT_CB_ID = 0x0AU  /*!< I2C Msp DeInit callback ID                    */
+
+} HAL_I2C_CallbackIDTypeDef;
+
+/**
+ * @brief  HAL I2C Callback pointer definition
+ */
+typedef void (*pI2C_CallbackTypeDef)(I2C_HandleTypeDef *hi2c);                                                        /*!< pointer to an I2C callback function */
+typedef void (*pI2C_AddrCallbackTypeDef)(I2C_HandleTypeDef *hi2c, uint8_t TransferDirection, uint16_t AddrMatchCode); /*!< pointer to an I2C Address Match callback function */
+
+#endif /* USE_HAL_I2C_REGISTER_CALLBACKS */
+/**
+ * @}
+ */
+
+/**
+ * @}
+ */
+/* Exported constants --------------------------------------------------------*/
+
+/** @defgroup I2C_Exported_Constants I2C Exported Constants
+ * @{
+ */
+
+/** @defgroup I2C_duty_cycle_in_fast_mode I2C duty cycle in fast mode
+ * @{
+ */
+#define I2C_DUTYCYCLE_2    0x00000000U
+#define I2C_DUTYCYCLE_16_9 I2C_CCR_DUTY
+/**
+ * @}
+ */
+
+/** @defgroup I2C_addressing_mode I2C addressing mode
+ * @{
+ */
+#define I2C_ADDRESSINGMODE_7BIT  0x00004000U
+#define I2C_ADDRESSINGMODE_10BIT (I2C_OAR1_ADDMODE | 0x00004000U)
+/**
+ * @}
+ */
+
+/** @defgroup I2C_dual_addressing_mode  I2C dual addressing mode
+ * @{
+ */
+#define I2C_DUALADDRESS_DISABLE 0x00000000U
+#define I2C_DUALADDRESS_ENABLE  I2C_OAR2_ENDUAL
+/**
+ * @}
+ */
+
+/** @defgroup I2C_general_call_addressing_mode I2C general call addressing mode
+ * @{
+ */
+#define I2C_GENERALCALL_DISABLE 0x00000000U
+#define I2C_GENERALCALL_ENABLE  I2C_CR1_ENGC
+/**
+ * @}
+ */
+
+/** @defgroup I2C_nostretch_mode I2C nostretch mode
+ * @{
+ */
+#define I2C_NOSTRETCH_DISABLE 0x00000000U
+#define I2C_NOSTRETCH_ENABLE  I2C_CR1_NOSTRETCH
+/**
+ * @}
+ */
+
+/** @defgroup I2C_Memory_Address_Size I2C Memory Address Size
+ * @{
+ */
+#define I2C_MEMADD_SIZE_8BIT  0x00000001U
+#define I2C_MEMADD_SIZE_16BIT 0x00000010U
+/**
+ * @}
+ */
+
+/** @defgroup I2C_XferDirection_definition I2C XferDirection definition
+ * @{
+ */
+#define I2C_DIRECTION_RECEIVE  0x00000000U
+#define I2C_DIRECTION_TRANSMIT 0x00000001U
+/**
+ * @}
+ */
+
+/** @defgroup I2C_XferOptions_definition I2C XferOptions definition
+ * @{
+ */
+#define I2C_FIRST_FRAME          0x00000001U
+#define I2C_FIRST_AND_NEXT_FRAME 0x00000002U
+#define I2C_NEXT_FRAME           0x00000004U
+#define I2C_FIRST_AND_LAST_FRAME 0x00000008U
+#define I2C_LAST_FRAME_NO_STOP   0x00000010U
+#define I2C_LAST_FRAME           0x00000020U
+
+/* List of XferOptions in usage of :
+ * 1- Restart condition in all use cases (direction change or not)
+ */
+#define I2C_OTHER_FRAME          (0x00AA0000U)
+#define I2C_OTHER_AND_LAST_FRAME (0xAA000000U)
+/**
+ * @}
+ */
+
+/** @defgroup I2C_Interrupt_configuration_definition I2C Interrupt configuration definition
+ * @brief I2C Interrupt definition
+ *        Elements values convention: 0xXXXXXXXX
+ *           - XXXXXXXX  : Interrupt control mask
+ * @{
+ */
+#define I2C_IT_BUF I2C_CR2_ITBUFEN
+#define I2C_IT_EVT I2C_CR2_ITEVTEN
+#define I2C_IT_ERR I2C_CR2_ITERREN
+/**
+ * @}
+ */
+
+/** @defgroup I2C_Flag_definition I2C Flag definition
+ * @{
+ */
+
+#define I2C_FLAG_OVR     0x00010800U
+#define I2C_FLAG_AF      0x00010400U
+#define I2C_FLAG_ARLO    0x00010200U
+#define I2C_FLAG_BERR    0x00010100U
+#define I2C_FLAG_TXE     0x00010080U
+#define I2C_FLAG_RXNE    0x00010040U
+#define I2C_FLAG_STOPF   0x00010010U
+#define I2C_FLAG_ADD10   0x00010008U
+#define I2C_FLAG_BTF     0x00010004U
+#define I2C_FLAG_ADDR    0x00010002U
+#define I2C_FLAG_SB      0x00010001U
+#define I2C_FLAG_DUALF   0x00100080U
+#define I2C_FLAG_GENCALL 0x00100010U
+#define I2C_FLAG_TRA     0x00100004U
+#define I2C_FLAG_BUSY    0x00100002U
+#define I2C_FLAG_MSL     0x00100001U
+/**
+ * @}
+ */
+
+/**
+ * @}
+ */
+
+/* Exported macros -----------------------------------------------------------*/
+
+/** @defgroup I2C_Exported_Macros I2C Exported Macros
+ * @{
+ */
+
+/** @brief Reset I2C handle state.
+ * @param  __HANDLE__ specifies the I2C Handle.
+ * @retval None
+ */
+#if (USE_HAL_I2C_REGISTER_CALLBACKS == 1)
+#define __HAL_I2C_RESET_HANDLE_STATE(__HANDLE__)           \
+  do {                                                     \
+    (__HANDLE__)->State             = HAL_I2C_STATE_RESET; \
+    (__HANDLE__)->MspInitCallback   = NULL;                \
+    (__HANDLE__)->MspDeInitCallback = NULL;                \
+  } while (0)
+#else
+#define __HAL_I2C_RESET_HANDLE_STATE(__HANDLE__) ((__HANDLE__)->State = HAL_I2C_STATE_RESET)
+#endif
+
+/** @brief  Enable or disable the specified I2C interrupts.
+ * @param  __HANDLE__ specifies the I2C Handle.
+ * @param  __INTERRUPT__ specifies the interrupt source to enable or disable.
+ *         This parameter can be one of the following values:
+ *            @arg I2C_IT_BUF: Buffer interrupt enable
+ *            @arg I2C_IT_EVT: Event interrupt enable
+ *            @arg I2C_IT_ERR: Error interrupt enable
+ * @retval None
+ */
+#define __HAL_I2C_ENABLE_IT(__HANDLE__, __INTERRUPT__)  SET_BIT((__HANDLE__)->Instance->CR2, (__INTERRUPT__))
+#define __HAL_I2C_DISABLE_IT(__HANDLE__, __INTERRUPT__) CLEAR_BIT((__HANDLE__)->Instance->CR2, (__INTERRUPT__))
+
+/** @brief  Checks if the specified I2C interrupt source is enabled or disabled.
+ * @param  __HANDLE__ specifies the I2C Handle.
+ * @param  __INTERRUPT__ specifies the I2C interrupt source to check.
+ *          This parameter can be one of the following values:
+ *            @arg I2C_IT_BUF: Buffer interrupt enable
+ *            @arg I2C_IT_EVT: Event interrupt enable
+ *            @arg I2C_IT_ERR: Error interrupt enable
+ * @retval The new state of __INTERRUPT__ (TRUE or FALSE).
+ */
+#define __HAL_I2C_GET_IT_SOURCE(__HANDLE__, __INTERRUPT__) ((((__HANDLE__)->Instance->CR2 & (__INTERRUPT__)) == (__INTERRUPT__)) ? SET : RESET)
+
+/** @brief  Checks whether the specified I2C flag is set or not.
+ * @param  __HANDLE__ specifies the I2C Handle.
+ * @param  __FLAG__ specifies the flag to check.
+ *         This parameter can be one of the following values:
+ *            @arg I2C_FLAG_OVR: Overrun/Underrun flag
+ *            @arg I2C_FLAG_AF: Acknowledge failure flag
+ *            @arg I2C_FLAG_ARLO: Arbitration lost flag
+ *            @arg I2C_FLAG_BERR: Bus error flag
+ *            @arg I2C_FLAG_TXE: Data register empty flag
+ *            @arg I2C_FLAG_RXNE: Data register not empty flag
+ *            @arg I2C_FLAG_STOPF: Stop detection flag
+ *            @arg I2C_FLAG_ADD10: 10-bit header sent flag
+ *            @arg I2C_FLAG_BTF: Byte transfer finished flag
+ *            @arg I2C_FLAG_ADDR: Address sent flag
+ *                                Address matched flag
+ *            @arg I2C_FLAG_SB: Start bit flag
+ *            @arg I2C_FLAG_DUALF: Dual flag
+ *            @arg I2C_FLAG_GENCALL: General call header flag
+ *            @arg I2C_FLAG_TRA: Transmitter/Receiver flag
+ *            @arg I2C_FLAG_BUSY: Bus busy flag
+ *            @arg I2C_FLAG_MSL: Master/Slave flag
+ * @retval The new state of __FLAG__ (TRUE or FALSE).
+ */
+#define __HAL_I2C_GET_FLAG(__HANDLE__, __FLAG__)                                                                                                            \
+  ((((uint8_t)((__FLAG__) >> 16U)) == 0x01U) ? (((((__HANDLE__)->Instance->SR1) & ((__FLAG__)&I2C_FLAG_MASK)) == ((__FLAG__)&I2C_FLAG_MASK)) ? SET : RESET) \
+                                             : (((((__HANDLE__)->Instance->SR2) & ((__FLAG__)&I2C_FLAG_MASK)) == ((__FLAG__)&I2C_FLAG_MASK)) ? SET : RESET))
+
+/** @brief  Clears the I2C pending flags which are cleared by writing 0 in a specific bit.
+ * @param  __HANDLE__ specifies the I2C Handle.
+ * @param  __FLAG__ specifies the flag to clear.
+ *         This parameter can be any combination of the following values:
+ *            @arg I2C_FLAG_OVR: Overrun/Underrun flag (Slave mode)
+ *            @arg I2C_FLAG_AF: Acknowledge failure flag
+ *            @arg I2C_FLAG_ARLO: Arbitration lost flag (Master mode)
+ *            @arg I2C_FLAG_BERR: Bus error flag
+ * @retval None
+ */
+#define __HAL_I2C_CLEAR_FLAG(__HANDLE__, __FLAG__) ((__HANDLE__)->Instance->SR1 = ~((__FLAG__)&I2C_FLAG_MASK))
+
+/** @brief  Clears the I2C ADDR pending flag.
+ * @param  __HANDLE__ specifies the I2C Handle.
+ *         This parameter can be I2C where x: 1, 2, or 3 to select the I2C peripheral.
+ * @retval None
+ */
+#define __HAL_I2C_CLEAR_ADDRFLAG(__HANDLE__)            \
+  do {                                                  \
+    __IO uint32_t tmpreg = 0x00U;                       \
+    tmpreg               = (__HANDLE__)->Instance->SR1; \
+    tmpreg               = (__HANDLE__)->Instance->SR2; \
+    UNUSED(tmpreg);                                     \
+  } while (0)
+
+/** @brief  Clears the I2C STOPF pending flag.
+ * @param  __HANDLE__ specifies the I2C Handle.
+ * @retval None
+ */
+#define __HAL_I2C_CLEAR_STOPFLAG(__HANDLE__)            \
+  do {                                                  \
+    __IO uint32_t tmpreg = 0x00U;                       \
+    tmpreg               = (__HANDLE__)->Instance->SR1; \
+    SET_BIT((__HANDLE__)->Instance->CR1, I2C_CR1_PE);   \
+    UNUSED(tmpreg);                                     \
+  } while (0)
+
+/** @brief  Enable the specified I2C peripheral.
+ * @param  __HANDLE__ specifies the I2C Handle.
+ * @retval None
+ */
+#define __HAL_I2C_ENABLE(__HANDLE__) SET_BIT((__HANDLE__)->Instance->CR1, I2C_CR1_PE)
+
+/** @brief  Disable the specified I2C peripheral.
+ * @param  __HANDLE__ specifies the I2C Handle.
+ * @retval None
+ */
+#define __HAL_I2C_DISABLE(__HANDLE__) CLEAR_BIT((__HANDLE__)->Instance->CR1, I2C_CR1_PE)
+
+/**
+ * @}
+ */
+
+/* Exported functions --------------------------------------------------------*/
+/** @addtogroup I2C_Exported_Functions
+ * @{
+ */
+
+/** @addtogroup I2C_Exported_Functions_Group1 Initialization and de-initialization functions
+ * @{
+ */
+/* Initialization and de-initialization functions******************************/
+HAL_StatusTypeDef HAL_I2C_Init(I2C_HandleTypeDef *hi2c);
+HAL_StatusTypeDef HAL_I2C_DeInit(I2C_HandleTypeDef *hi2c);
+void              HAL_I2C_MspInit(I2C_HandleTypeDef *hi2c);
+void              HAL_I2C_MspDeInit(I2C_HandleTypeDef *hi2c);
+
+/* Callbacks Register/UnRegister functions  ***********************************/
+#if (USE_HAL_I2C_REGISTER_CALLBACKS == 1)
+HAL_StatusTypeDef HAL_I2C_RegisterCallback(I2C_HandleTypeDef *hi2c, HAL_I2C_CallbackIDTypeDef CallbackID, pI2C_CallbackTypeDef pCallback);
+HAL_StatusTypeDef HAL_I2C_UnRegisterCallback(I2C_HandleTypeDef *hi2c, HAL_I2C_CallbackIDTypeDef CallbackID);
+
+HAL_StatusTypeDef HAL_I2C_RegisterAddrCallback(I2C_HandleTypeDef *hi2c, pI2C_AddrCallbackTypeDef pCallback);
+HAL_StatusTypeDef HAL_I2C_UnRegisterAddrCallback(I2C_HandleTypeDef *hi2c);
+#endif /* USE_HAL_I2C_REGISTER_CALLBACKS */
+/**
+ * @}
+ */
+
+/** @addtogroup I2C_Exported_Functions_Group2 Input and Output operation functions
+ * @{
+ */
+/* IO operation functions  ****************************************************/
+/******* Blocking mode: Polling */
+HAL_StatusTypeDef HAL_I2C_Master_Transmit(I2C_HandleTypeDef *hi2c, uint16_t DevAddress, uint8_t *pData, uint16_t Size, uint32_t Timeout);
+HAL_StatusTypeDef HAL_I2C_Master_Receive(I2C_HandleTypeDef *hi2c, uint16_t DevAddress, uint8_t *pData, uint16_t Size, uint32_t Timeout);
+HAL_StatusTypeDef HAL_I2C_Slave_Transmit(I2C_HandleTypeDef *hi2c, uint8_t *pData, uint16_t Size, uint32_t Timeout);
+HAL_StatusTypeDef HAL_I2C_Slave_Receive(I2C_HandleTypeDef *hi2c, uint8_t *pData, uint16_t Size, uint32_t Timeout);
+HAL_StatusTypeDef HAL_I2C_Mem_Write(I2C_HandleTypeDef *hi2c, uint16_t DevAddress, uint16_t MemAddress, uint16_t MemAddSize, uint8_t *pData, uint16_t Size, uint32_t Timeout);
+HAL_StatusTypeDef HAL_I2C_Mem_Read(I2C_HandleTypeDef *hi2c, uint16_t DevAddress, uint16_t MemAddress, uint16_t MemAddSize, uint8_t *pData, uint16_t Size, uint32_t Timeout);
+HAL_StatusTypeDef HAL_I2C_IsDeviceReady(I2C_HandleTypeDef *hi2c, uint16_t DevAddress, uint32_t Trials, uint32_t Timeout);
+
+/******* Non-Blocking mode: Interrupt */
+HAL_StatusTypeDef HAL_I2C_Master_Transmit_IT(I2C_HandleTypeDef *hi2c, uint16_t DevAddress, uint8_t *pData, uint16_t Size);
+HAL_StatusTypeDef HAL_I2C_Master_Receive_IT(I2C_HandleTypeDef *hi2c, uint16_t DevAddress, uint8_t *pData, uint16_t Size);
+HAL_StatusTypeDef HAL_I2C_Slave_Transmit_IT(I2C_HandleTypeDef *hi2c, uint8_t *pData, uint16_t Size);
+HAL_StatusTypeDef HAL_I2C_Slave_Receive_IT(I2C_HandleTypeDef *hi2c, uint8_t *pData, uint16_t Size);
+HAL_StatusTypeDef HAL_I2C_Mem_Write_IT(I2C_HandleTypeDef *hi2c, uint16_t DevAddress, uint16_t MemAddress, uint16_t MemAddSize, uint8_t *pData, uint16_t Size);
+HAL_StatusTypeDef HAL_I2C_Mem_Read_IT(I2C_HandleTypeDef *hi2c, uint16_t DevAddress, uint16_t MemAddress, uint16_t MemAddSize, uint8_t *pData, uint16_t Size);
+
+HAL_StatusTypeDef HAL_I2C_Master_Seq_Transmit_IT(I2C_HandleTypeDef *hi2c, uint16_t DevAddress, uint8_t *pData, uint16_t Size, uint32_t XferOptions);
+HAL_StatusTypeDef HAL_I2C_Master_Seq_Receive_IT(I2C_HandleTypeDef *hi2c, uint16_t DevAddress, uint8_t *pData, uint16_t Size, uint32_t XferOptions);
+HAL_StatusTypeDef HAL_I2C_Slave_Seq_Transmit_IT(I2C_HandleTypeDef *hi2c, uint8_t *pData, uint16_t Size, uint32_t XferOptions);
+HAL_StatusTypeDef HAL_I2C_Slave_Seq_Receive_IT(I2C_HandleTypeDef *hi2c, uint8_t *pData, uint16_t Size, uint32_t XferOptions);
+HAL_StatusTypeDef HAL_I2C_EnableListen_IT(I2C_HandleTypeDef *hi2c);
+HAL_StatusTypeDef HAL_I2C_DisableListen_IT(I2C_HandleTypeDef *hi2c);
+HAL_StatusTypeDef HAL_I2C_Master_Abort_IT(I2C_HandleTypeDef *hi2c, uint16_t DevAddress);
+
+/******* Non-Blocking mode: DMA */
+HAL_StatusTypeDef HAL_I2C_Master_Transmit_DMA(I2C_HandleTypeDef *hi2c, uint16_t DevAddress, uint8_t *pData, uint16_t Size);
+HAL_StatusTypeDef HAL_I2C_Master_Receive_DMA(I2C_HandleTypeDef *hi2c, uint16_t DevAddress, uint8_t *pData, uint16_t Size);
+HAL_StatusTypeDef HAL_I2C_Slave_Transmit_DMA(I2C_HandleTypeDef *hi2c, uint8_t *pData, uint16_t Size);
+HAL_StatusTypeDef HAL_I2C_Slave_Receive_DMA(I2C_HandleTypeDef *hi2c, uint8_t *pData, uint16_t Size);
+HAL_StatusTypeDef HAL_I2C_Mem_Write_DMA(I2C_HandleTypeDef *hi2c, uint16_t DevAddress, uint16_t MemAddress, uint16_t MemAddSize, uint8_t *pData, uint16_t Size);
+HAL_StatusTypeDef HAL_I2C_Mem_Read_DMA(I2C_HandleTypeDef *hi2c, uint16_t DevAddress, uint16_t MemAddress, uint16_t MemAddSize, uint8_t *pData, uint16_t Size);
+
+HAL_StatusTypeDef HAL_I2C_Master_Seq_Transmit_DMA(I2C_HandleTypeDef *hi2c, uint16_t DevAddress, uint8_t *pData, uint16_t Size, uint32_t XferOptions);
+HAL_StatusTypeDef HAL_I2C_Master_Seq_Receive_DMA(I2C_HandleTypeDef *hi2c, uint16_t DevAddress, uint8_t *pData, uint16_t Size, uint32_t XferOptions);
+HAL_StatusTypeDef HAL_I2C_Slave_Seq_Transmit_DMA(I2C_HandleTypeDef *hi2c, uint8_t *pData, uint16_t Size, uint32_t XferOptions);
+HAL_StatusTypeDef HAL_I2C_Slave_Seq_Receive_DMA(I2C_HandleTypeDef *hi2c, uint8_t *pData, uint16_t Size, uint32_t XferOptions);
+/**
+ * @}
+ */
+
+/** @addtogroup I2C_IRQ_Handler_and_Callbacks IRQ Handler and Callbacks
+ * @{
+ */
+/******* I2C IRQHandler and Callbacks used in non blocking modes (Interrupt and DMA) */
+void HAL_I2C_EV_IRQHandler(I2C_HandleTypeDef *hi2c);
+void HAL_I2C_ER_IRQHandler(I2C_HandleTypeDef *hi2c);
+void HAL_I2C_MasterTxCpltCallback(I2C_HandleTypeDef *hi2c);
+void HAL_I2C_MasterRxCpltCallback(I2C_HandleTypeDef *hi2c);
+void HAL_I2C_SlaveTxCpltCallback(I2C_HandleTypeDef *hi2c);
+void HAL_I2C_SlaveRxCpltCallback(I2C_HandleTypeDef *hi2c);
+void HAL_I2C_AddrCallback(I2C_HandleTypeDef *hi2c, uint8_t TransferDirection, uint16_t AddrMatchCode);
+void HAL_I2C_ListenCpltCallback(I2C_HandleTypeDef *hi2c);
+void HAL_I2C_MemTxCpltCallback(I2C_HandleTypeDef *hi2c);
+void HAL_I2C_MemRxCpltCallback(I2C_HandleTypeDef *hi2c);
+void HAL_I2C_ErrorCallback(I2C_HandleTypeDef *hi2c);
+void HAL_I2C_AbortCpltCallback(I2C_HandleTypeDef *hi2c);
+/**
+ * @}
+ */
+
+/** @addtogroup I2C_Exported_Functions_Group3 Peripheral State, Mode and Error functions
+ * @{
+ */
+/* Peripheral State, Mode and Error functions  *********************************/
+HAL_I2C_StateTypeDef HAL_I2C_GetState(I2C_HandleTypeDef *hi2c);
+HAL_I2C_ModeTypeDef  HAL_I2C_GetMode(I2C_HandleTypeDef *hi2c);
+uint32_t             HAL_I2C_GetError(I2C_HandleTypeDef *hi2c);
+
+/**
+ * @}
+ */
+
+/**
+ * @}
+ */
+/* Private types -------------------------------------------------------------*/
+/* Private variables ---------------------------------------------------------*/
+/* Private constants ---------------------------------------------------------*/
+/** @defgroup I2C_Private_Constants I2C Private Constants
+ * @{
+ */
+#define I2C_FLAG_MASK              0x0000FFFFU
+#define I2C_MIN_PCLK_FREQ_STANDARD 2000000U /*!< 2 MHz                     */
+#define I2C_MIN_PCLK_FREQ_FAST     4000000U /*!< 4 MHz                     */
+/**
+ * @}
+ */
+
+/* Private macros ------------------------------------------------------------*/
+/** @defgroup I2C_Private_Macros I2C Private Macros
+ * @{
+ */
+
+#define I2C_MIN_PCLK_FREQ(__PCLK__, __SPEED__)              (((__SPEED__) <= 100000U) ? ((__PCLK__) < I2C_MIN_PCLK_FREQ_STANDARD) : ((__PCLK__) < I2C_MIN_PCLK_FREQ_FAST))
+#define I2C_CCR_CALCULATION(__PCLK__, __SPEED__, __COEFF__) (((((__PCLK__)-1U) / ((__SPEED__) * (__COEFF__))) + 1U) & I2C_CCR_CCR)
+#define I2C_FREQRANGE(__PCLK__)                             ((__PCLK__) / 1000000U)
+#define I2C_RISE_TIME(__FREQRANGE__, __SPEED__)             (((__SPEED__) <= 100000U) ? ((__FREQRANGE__) + 1U) : ((((__FREQRANGE__)*300U) / 1000U) + 1U))
+#define I2C_SPEED_STANDARD(__PCLK__, __SPEED__)             ((I2C_CCR_CALCULATION((__PCLK__), (__SPEED__), 2U) < 4U) ? 4U : I2C_CCR_CALCULATION((__PCLK__), (__SPEED__), 2U))
+#define I2C_SPEED_FAST(__PCLK__, __SPEED__, __DUTYCYCLE__) \
+  (((__DUTYCYCLE__) == I2C_DUTYCYCLE_2) ? I2C_CCR_CALCULATION((__PCLK__), (__SPEED__), 3U) : (I2C_CCR_CALCULATION((__PCLK__), (__SPEED__), 25U) | I2C_DUTYCYCLE_16_9))
+#define I2C_SPEED(__PCLK__, __SPEED__, __DUTYCYCLE__)                                                                                 \
+  (((__SPEED__) <= 100000U)                                                           ? (I2C_SPEED_STANDARD((__PCLK__), (__SPEED__))) \
+   : ((I2C_SPEED_FAST((__PCLK__), (__SPEED__), (__DUTYCYCLE__)) & I2C_CCR_CCR) == 0U) ? 1U                                            \
+                                                                                      : ((I2C_SPEED_FAST((__PCLK__), (__SPEED__), (__DUTYCYCLE__))) | I2C_CCR_FS))
+
+#define I2C_7BIT_ADD_WRITE(__ADDRESS__) ((uint8_t)((__ADDRESS__) & (uint8_t)(~I2C_OAR1_ADD0)))
+#define I2C_7BIT_ADD_READ(__ADDRESS__)  ((uint8_t)((__ADDRESS__) | I2C_OAR1_ADD0))
+
+#define I2C_10BIT_ADDRESS(__ADDRESS__)      ((uint8_t)((uint16_t)((__ADDRESS__) & (uint16_t)0x00FF)))
+#define I2C_10BIT_HEADER_WRITE(__ADDRESS__) ((uint8_t)((uint16_t)((uint16_t)(((uint16_t)((__ADDRESS__) & (uint16_t)0x0300)) >> 7) | (uint16_t)0x00F0)))
+#define I2C_10BIT_HEADER_READ(__ADDRESS__)  ((uint8_t)((uint16_t)((uint16_t)(((uint16_t)((__ADDRESS__) & (uint16_t)0x0300)) >> 7) | (uint16_t)(0x00F1))))
+
+#define I2C_MEM_ADD_MSB(__ADDRESS__) ((uint8_t)((uint16_t)(((uint16_t)((__ADDRESS__) & (uint16_t)0xFF00)) >> 8)))
+#define I2C_MEM_ADD_LSB(__ADDRESS__) ((uint8_t)((uint16_t)((__ADDRESS__) & (uint16_t)0x00FF)))
+
+/** @defgroup I2C_IS_RTC_Definitions I2C Private macros to check input parameters
+ * @{
+ */
+#define IS_I2C_DUTY_CYCLE(CYCLE)        (((CYCLE) == I2C_DUTYCYCLE_2) || ((CYCLE) == I2C_DUTYCYCLE_16_9))
+#define IS_I2C_ADDRESSING_MODE(ADDRESS) (((ADDRESS) == I2C_ADDRESSINGMODE_7BIT) || ((ADDRESS) == I2C_ADDRESSINGMODE_10BIT))
+#define IS_I2C_DUAL_ADDRESS(ADDRESS)    (((ADDRESS) == I2C_DUALADDRESS_DISABLE) || ((ADDRESS) == I2C_DUALADDRESS_ENABLE))
+#define IS_I2C_GENERAL_CALL(CALL)       (((CALL) == I2C_GENERALCALL_DISABLE) || ((CALL) == I2C_GENERALCALL_ENABLE))
+#define IS_I2C_NO_STRETCH(STRETCH)      (((STRETCH) == I2C_NOSTRETCH_DISABLE) || ((STRETCH) == I2C_NOSTRETCH_ENABLE))
+#define IS_I2C_MEMADD_SIZE(SIZE)        (((SIZE) == I2C_MEMADD_SIZE_8BIT) || ((SIZE) == I2C_MEMADD_SIZE_16BIT))
+#define IS_I2C_CLOCK_SPEED(SPEED)       (((SPEED) > 0U) && ((SPEED) <= 400000U))
+#define IS_I2C_OWN_ADDRESS1(ADDRESS1)   (((ADDRESS1)&0xFFFFFC00U) == 0U)
+#define IS_I2C_OWN_ADDRESS2(ADDRESS2)   (((ADDRESS2)&0xFFFFFF01U) == 0U)
+#define IS_I2C_TRANSFER_OPTIONS_REQUEST(REQUEST)                                                                                                                                          \
+  (((REQUEST) == I2C_FIRST_FRAME) || ((REQUEST) == I2C_FIRST_AND_NEXT_FRAME) || ((REQUEST) == I2C_NEXT_FRAME) || ((REQUEST) == I2C_FIRST_AND_LAST_FRAME) || ((REQUEST) == I2C_LAST_FRAME) \
+   || ((REQUEST) == I2C_LAST_FRAME_NO_STOP) || IS_I2C_TRANSFER_OTHER_OPTIONS_REQUEST(REQUEST))
+
+#define IS_I2C_TRANSFER_OTHER_OPTIONS_REQUEST(REQUEST) (((REQUEST) == I2C_OTHER_FRAME) || ((REQUEST) == I2C_OTHER_AND_LAST_FRAME))
+
+#define I2C_CHECK_FLAG(__ISR__, __FLAG__)    ((((__ISR__) & ((__FLAG__)&I2C_FLAG_MASK)) == ((__FLAG__)&I2C_FLAG_MASK)) ? SET : RESET)
+#define I2C_CHECK_IT_SOURCE(__CR1__, __IT__) ((((__CR1__) & (__IT__)) == (__IT__)) ? SET : RESET)
+/**
+ * @}
+ */
+
+/**
+ * @}
+ */
+
+/* Private functions ---------------------------------------------------------*/
+/** @defgroup I2C_Private_Functions I2C Private Functions
+ * @{
+ */
+
+/**
+ * @}
+ */
+
+/**
+ * @}
+ */
+
+/**
+ * @}
+ */
+
+#ifdef __cplusplus
+}
+#endif
+
+#endif /* __STM32F1xx_HAL_I2C_H */
+
+/************************ (C) COPYRIGHT STMicroelectronics *****END OF FILE****/

source/Core/BSP/MHP30/configuration.h

@@ -155,10 +155,7 @@
 #define POW_PD     1
 #define POW_PD_EXT 0
 #define TEMP_NTC
-#define I2C_SOFT_BUS_2  1
-#define I2C_SOFT_BUS_1  1
-#define OLED_I2CBB1     1
-#define ACCEL_I2CBB1    1
+#define I2C_SOFT_BUS_2
 #define BATTFILTERDEPTH 8
 #define OLED_I2CBB2
 #define ACCEL_EXITS_ON_MOVEMENT

source/Core/BSP/MHP30/fusb_user.cpp

@@ -1,13 +1,13 @@
 #include "configuration.h"
 #ifdef POW_PD
 #include "BSP.h"
-#include "I2CBB1.hpp"
+#include "I2C_Wrapper.hpp"
 #include "Pins.h"
 #include "Setup.h"
 #include "USBPD.h"
-bool fusb_read_buf(const uint8_t deviceAddr, const uint8_t registerAdd, const uint8_t size, uint8_t *buf) { return I2CBB1::Mem_Read(deviceAddr, registerAdd, buf, size); }
+bool fusb_read_buf(const uint8_t deviceAddr, const uint8_t registerAdd, const uint8_t size, uint8_t *buf) { return FRToSI2C::Mem_Read(deviceAddr, registerAdd, buf, size); }
 
-bool fusb_write_buf(const uint8_t deviceAddr, const uint8_t registerAdd, const uint8_t size, uint8_t *buf) { return I2CBB1::Mem_Write(deviceAddr, registerAdd, (uint8_t *)buf, size); }
+bool fusb_write_buf(const uint8_t deviceAddr, const uint8_t registerAdd, const uint8_t size, uint8_t *buf) { return FRToSI2C::Mem_Write(deviceAddr, registerAdd, (uint8_t *)buf, size); }
 
 void setupFUSBIRQ() {
   GPIO_InitTypeDef GPIO_InitStruct;

source/Core/BSP/MHP30/preRTOS.cpp

@@ -6,7 +6,6 @@
  */
 
 #include "BSP.h"
-#include "I2CBB1.hpp"
 #include "I2CBB2.hpp"
 #include "Pins.h"
 #include "Setup.h"
@@ -19,5 +18,6 @@ void preRToSInit() {
   Setup_HAL(); // Setup all the HAL objects
   BSPInit();
   I2CBB2::init();
-  I2CBB1::init();
+  /* Init the IPC objects */
+  FRToSI2C::FRToSInit();
 }

source/Core/BSP/MHP30/stm32f1xx_hal_msp.c

@@ -75,6 +75,55 @@ void HAL_ADC_MspInit(ADC_HandleTypeDef *hadc) {
   }
 }
 
+void HAL_I2C_MspInit(I2C_HandleTypeDef *hi2c) {
+
+  GPIO_InitTypeDef GPIO_InitStruct;
+  /**I2C1 GPIO Configuration
+   PB6     ------> I2C1_SCL
+   PB7     ------> I2C1_SDA
+   */
+  GPIO_InitStruct.Pin   = SCL_Pin | SDA_Pin;
+  GPIO_InitStruct.Mode  = GPIO_MODE_AF_OD;
+  GPIO_InitStruct.Pull  = GPIO_PULLUP;
+  GPIO_InitStruct.Speed = GPIO_SPEED_FREQ_LOW;
+  HAL_GPIO_Init(GPIOB, &GPIO_InitStruct);
+
+  /* Peripheral clock enable */
+  __HAL_RCC_I2C1_CLK_ENABLE();
+  /* I2C1 DMA Init */
+  /* I2C1_RX Init */
+  hdma_i2c1_rx.Instance                 = DMA1_Channel7;
+  hdma_i2c1_rx.Init.Direction           = DMA_PERIPH_TO_MEMORY;
+  hdma_i2c1_rx.Init.PeriphInc           = DMA_PINC_DISABLE;
+  hdma_i2c1_rx.Init.MemInc              = DMA_MINC_ENABLE;
+  hdma_i2c1_rx.Init.PeriphDataAlignment = DMA_PDATAALIGN_BYTE;
+  hdma_i2c1_rx.Init.MemDataAlignment    = DMA_MDATAALIGN_BYTE;
+  hdma_i2c1_rx.Init.Mode                = DMA_NORMAL;
+  hdma_i2c1_rx.Init.Priority            = DMA_PRIORITY_LOW;
+  HAL_DMA_Init(&hdma_i2c1_rx);
+
+  __HAL_LINKDMA(hi2c, hdmarx, hdma_i2c1_rx);
+
+  /* I2C1_TX Init */
+  hdma_i2c1_tx.Instance                 = DMA1_Channel6;
+  hdma_i2c1_tx.Init.Direction           = DMA_MEMORY_TO_PERIPH;
+  hdma_i2c1_tx.Init.PeriphInc           = DMA_PINC_DISABLE;
+  hdma_i2c1_tx.Init.MemInc              = DMA_MINC_ENABLE;
+  hdma_i2c1_tx.Init.PeriphDataAlignment = DMA_PDATAALIGN_BYTE;
+  hdma_i2c1_tx.Init.MemDataAlignment    = DMA_MDATAALIGN_BYTE;
+  hdma_i2c1_tx.Init.Mode                = DMA_NORMAL;
+  hdma_i2c1_tx.Init.Priority            = DMA_PRIORITY_MEDIUM;
+  HAL_DMA_Init(&hdma_i2c1_tx);
+
+  __HAL_LINKDMA(hi2c, hdmatx, hdma_i2c1_tx);
+
+  /* I2C1 interrupt Init */
+  HAL_NVIC_SetPriority(I2C1_EV_IRQn, 15, 0);
+  HAL_NVIC_EnableIRQ(I2C1_EV_IRQn);
+  HAL_NVIC_SetPriority(I2C1_ER_IRQn, 15, 0);
+  HAL_NVIC_EnableIRQ(I2C1_ER_IRQn);
+}
+
 void HAL_TIM_Base_MspInit(TIM_HandleTypeDef *htim_base) {
 
   if (htim_base->Instance == TIM3) {

source/Core/BSP/MHP30/stm32f1xx_it.c

@@ -44,5 +44,10 @@ void ADC1_2_IRQHandler(void) { HAL_ADC_IRQHandler(&hadc1); }
 
 // used for hal ticks
 void TIM4_IRQHandler(void) { HAL_TIM_IRQHandler(&htim4); }
+void I2C1_EV_IRQHandler(void) { HAL_I2C_EV_IRQHandler(&hi2c1); }
+void I2C1_ER_IRQHandler(void) { HAL_I2C_ER_IRQHandler(&hi2c1); }
 
+void DMA1_Channel6_IRQHandler(void) { HAL_DMA_IRQHandler(&hdma_i2c1_tx); }
+
+void DMA1_Channel7_IRQHandler(void) { HAL_DMA_IRQHandler(&hdma_i2c1_rx); }
 void EXTI9_5_IRQHandler(void) { HAL_GPIO_EXTI_IRQHandler(INT_PD_Pin); }

source/Core/BSP/Miniware/I2C_Wrapper.cpp

@@ -0,0 +1,91 @@
+/*
+ * FRToSI2C.cpp
+ *
+ *  Created on: 14Apr.,2018
+ *      Author: Ralim
+ */
+#include "BSP.h"
+#include "Setup.h"
+#include <I2C_Wrapper.hpp>
+SemaphoreHandle_t FRToSI2C::I2CSemaphore = nullptr;
+StaticSemaphore_t FRToSI2C::xSemaphoreBuffer;
+
+void FRToSI2C::CpltCallback() {
+  hi2c1.State = HAL_I2C_STATE_READY; // Force state reset (even if tx error)
+  if (I2CSemaphore) {
+    xSemaphoreGiveFromISR(I2CSemaphore, NULL);
+  }
+}
+
+bool FRToSI2C::Mem_Read(uint16_t DevAddress, uint16_t MemAddress, uint8_t *pData, uint16_t Size) {
+
+  if (!lock())
+    return false;
+  if (HAL_I2C_Mem_Read(&hi2c1, DevAddress, MemAddress, I2C_MEMADD_SIZE_8BIT, pData, Size, 500) != HAL_OK) {
+
+    I2C_Unstick();
+    unlock();
+    return false;
+  }
+
+  unlock();
+  return true;
+}
+bool FRToSI2C::I2C_RegisterWrite(uint8_t address, uint8_t reg, uint8_t data) { return Mem_Write(address, reg, &data, 1); }
+
+uint8_t FRToSI2C::I2C_RegisterRead(uint8_t add, uint8_t reg) {
+  uint8_t tx_data[1];
+  Mem_Read(add, reg, tx_data, 1);
+  return tx_data[0];
+}
+bool FRToSI2C::Mem_Write(uint16_t DevAddress, uint16_t MemAddress, uint8_t *pData, uint16_t Size) {
+
+  if (!lock())
+    return false;
+  if (HAL_I2C_Mem_Write(&hi2c1, DevAddress, MemAddress, I2C_MEMADD_SIZE_8BIT, pData, Size, 500) != HAL_OK) {
+
+    I2C_Unstick();
+    unlock();
+    return false;
+  }
+
+  unlock();
+  return true;
+}
+
+bool FRToSI2C::Transmit(uint16_t DevAddress, uint8_t *pData, uint16_t Size) {
+  if (!lock())
+    return false;
+  if (HAL_I2C_Master_Transmit_IT(&hi2c1, DevAddress, pData, Size) != HAL_OK) {
+    I2C_Unstick();
+    unlock();
+    return false;
+  }
+  return true;
+}
+
+bool FRToSI2C::probe(uint16_t DevAddress) {
+  if (!lock())
+    return false;
+  uint8_t buffer[1];
+  bool    worked = HAL_I2C_Mem_Read(&hi2c1, DevAddress, 0x0F, I2C_MEMADD_SIZE_8BIT, buffer, 1, 1000) == HAL_OK;
+  unlock();
+  return worked;
+}
+
+void FRToSI2C::I2C_Unstick() { unstick_I2C(); }
+
+void FRToSI2C::unlock() { xSemaphoreGive(I2CSemaphore); }
+
+bool FRToSI2C::lock() { return xSemaphoreTake(I2CSemaphore, (TickType_t)50) == pdTRUE; }
+
+bool FRToSI2C::writeRegistersBulk(const uint8_t address, const I2C_REG *registers, const uint8_t registersLength) {
+  for (int index = 0; index < registersLength; index++) {
+    if (!I2C_RegisterWrite(address, registers[index].reg, registers[index].val)) {
+      return false;
+    }
+    if (registers[index].pause_ms)
+      delay_ms(registers[index].pause_ms);
+  }
+  return true;
+}

source/Core/BSP/Miniware/IRQ.cpp

@@ -23,6 +23,12 @@ void HAL_ADCEx_InjectedConvCpltCallback(ADC_HandleTypeDef *hadc) {
     }
   }
 }
+void HAL_I2C_MasterRxCpltCallback(I2C_HandleTypeDef *hi2c __unused) { FRToSI2C::CpltCallback(); }
+void HAL_I2C_MasterTxCpltCallback(I2C_HandleTypeDef *hi2c __unused) { FRToSI2C::CpltCallback(); }
+void HAL_I2C_MemTxCpltCallback(I2C_HandleTypeDef *hi2c __unused) { FRToSI2C::CpltCallback(); }
+void HAL_I2C_ErrorCallback(I2C_HandleTypeDef *hi2c __unused) { FRToSI2C::CpltCallback(); }
+void HAL_I2C_AbortCpltCallback(I2C_HandleTypeDef *hi2c __unused) { FRToSI2C::CpltCallback(); }
+void HAL_I2C_MemRxCpltCallback(I2C_HandleTypeDef *hi2c __unused) { FRToSI2C::CpltCallback(); }
 
 extern osThreadId POWTaskHandle;
 

source/Core/BSP/Miniware/IRQ.h

@@ -18,6 +18,12 @@
 extern "C" {
 #endif
 void HAL_ADCEx_InjectedConvCpltCallback(ADC_HandleTypeDef *hadc);
+void HAL_I2C_ErrorCallback(I2C_HandleTypeDef *hi2c);
+void HAL_I2C_AbortCpltCallback(I2C_HandleTypeDef *hi2c);
+void HAL_I2C_MasterTxCpltCallback(I2C_HandleTypeDef *hi2c);
+void HAL_I2C_MasterRxCpltCallback(I2C_HandleTypeDef *hi2c);
+void HAL_I2C_MemTxCpltCallback(I2C_HandleTypeDef *hi2c);
+void HAL_I2C_MemRxCpltCallback(I2C_HandleTypeDef *hi2c);
 void HAL_GPIO_EXTI_Callback(uint16_t);
 
 #ifdef __cplusplus

source/Core/BSP/Miniware/Setup.cpp

@@ -7,13 +7,16 @@
 #include "Setup.h"
 #include "BSP.h"
 #include "Pins.h"
-#include "configuration.h"
 #include "history.hpp"
 #include <stdint.h>
 ADC_HandleTypeDef hadc1;
 ADC_HandleTypeDef hadc2;
 DMA_HandleTypeDef hdma_adc1;
 
+I2C_HandleTypeDef hi2c1;
+DMA_HandleTypeDef hdma_i2c1_rx;
+DMA_HandleTypeDef hdma_i2c1_tx;
+
 IWDG_HandleTypeDef hiwdg;
 TIM_HandleTypeDef  htimADC;
 TIM_HandleTypeDef  htimTip;
@@ -24,6 +27,7 @@ uint16_t ADCReadings[ADC_SAMPLES]; // Used to store the adc readings for the han
 // Functions
 static void SystemClock_Config(void);
 static void MX_ADC1_Init(void);
+static void MX_I2C1_Init(void);
 static void MX_IWDG_Init(void);
 static void MX_TIP_CONTROL_TIMER_Init(void);
 static void MX_ADC_CONTROL_TIMER_Init(void);
@@ -42,7 +46,7 @@ void        Setup_HAL() {
   MX_GPIO_Init();
   MX_DMA_Init();
 #ifndef I2C_SOFT_BUS_1
-#error "Only Bit-Bang now"
+  MX_I2C1_Init();
 #endif
   MX_ADC1_Init();
   MX_ADC2_Init();
@@ -273,6 +277,20 @@ static void MX_ADC2_Init(void) {
     ;
   }
 }
+/* I2C1 init function */
+static void MX_I2C1_Init(void) {
+  hi2c1.Instance        = I2C1;
+  hi2c1.Init.ClockSpeed = 75000;
+  // OLED doesnt handle >100k when its asleep (off).
+  hi2c1.Init.DutyCycle       = I2C_DUTYCYCLE_2;
+  hi2c1.Init.OwnAddress1     = 0;
+  hi2c1.Init.AddressingMode  = I2C_ADDRESSINGMODE_7BIT;
+  hi2c1.Init.DualAddressMode = I2C_DUALADDRESS_DISABLE;
+  hi2c1.Init.OwnAddress2     = 0;
+  hi2c1.Init.GeneralCallMode = I2C_GENERALCALL_DISABLE;
+  hi2c1.Init.NoStretchMode   = I2C_NOSTRETCH_DISABLE;
+  HAL_I2C_Init(&hi2c1);
+}
 
 /* IWDG init function */
 static void MX_IWDG_Init(void) {

source/Core/BSP/Miniware/Setup.h

@@ -18,6 +18,10 @@ extern ADC_HandleTypeDef hadc1;
 extern ADC_HandleTypeDef hadc2;
 extern DMA_HandleTypeDef hdma_adc1;
 
+extern DMA_HandleTypeDef hdma_i2c1_rx;
+extern DMA_HandleTypeDef hdma_i2c1_tx;
+extern I2C_HandleTypeDef hi2c1;
+
 extern IWDG_HandleTypeDef hiwdg;
 
 extern TIM_HandleTypeDef htimADC;

source/Core/BSP/Miniware/configuration.h

@@ -86,7 +86,7 @@
 #define POWER_PULSE_DEFAULT 0
 #else
 #define POWER_PULSE_DEFAULT 5
-#endif                                 /* TS100 */
+#endif /* TS100 */
 #define POWER_PULSE_WAIT_DEFAULT     4 // Default rate of the power pulse: 4*2500 = 10000 ms = 10 s
 #define POWER_PULSE_DURATION_DEFAULT 1 // Default duration of the power pulse: 1*250 = 250 ms
 
@@ -156,10 +156,6 @@
 #define MIN_BOOST_TEMP_C       250 // The min settable temp for boost mode °C
 #define MIN_BOOST_TEMP_F       480 // The min settable temp for boost mode °F
 
-// Miniware cant be trusted, and keep using the GD32 randomly now, so assume they will clones in the future
-
-#define I2C_SOFT_BUS_1 1
-
 #ifdef MODEL_TS100
 #define VOLTAGE_DIV        467 // 467 - Default divider from schematic
 #define CALIBRATION_OFFSET 900 // 900 - Default adc offset in uV
@@ -169,9 +165,8 @@
 #define POWER_LIMIT_STEPS  5
 #define OP_AMP_GAIN_STAGE  OP_AMP_GAIN_STAGE_TS100
 #define TEMP_uV_LOOKUP_HAKKO
-#define USB_PD_VMAX              20 // Maximum voltage for PD to negotiate
-#define OLED_I2CBB1              1
-#define ACCEL_I2CBB1             1
+#define USB_PD_VMAX 20 // Maximum voltage for PD to negotiate
+
 #define HARDWARE_MAX_WATTAGE_X10 750
 #define TIP_THERMAL_MASS         65 // X10 watts to raise 1 deg C in 1 second
 #define TIP_RESISTANCE           75 // x10 ohms, 7.5 typical for ts100 tips
@@ -199,6 +194,7 @@
 #define POW_DC               1
 #define POW_PD               1
 #define I2C_SOFT_BUS_2       1
+#define I2C_SOFT_BUS_1       1
 #define OLED_I2CBB1          1
 #define USB_PD_I2CBB2        1
 #define USB_PD_VMAX          28 // Device supposedly can do 28V; looks like vmax is 33 ish
@@ -222,7 +218,7 @@
 
 #define TIP_THERMAL_MASS 40
 #define TIP_RESISTANCE   45 // x10 ohms, 4.5 typical for ts80 tips
-#define I2C_SOFT_BUS_2   1
+
 #define LIS_ORI_FLIP
 #define OLED_FLIP
 #endif /* TS80(P) */
@@ -232,8 +228,6 @@
 #define CALIBRATION_OFFSET 900 // the adc offset in uV
 #define PID_POWER_LIMIT    35  // Sets the max pwm power limit
 #define POWER_LIMIT        32  // 24 watts default power limit
-#define OLED_I2CBB1        1
-#define ACCEL_I2CBB1       1
 
 #define HARDWARE_MAX_WATTAGE_X10 320
 
@@ -243,18 +237,17 @@
 #endif /* TS80 */
 
 #ifdef MODEL_TS80P
-#define VOLTAGE_DIV              650  // Default for TS80P with slightly different resistors
-#define CALIBRATION_OFFSET       1500 // the adc offset in uV
-#define PID_POWER_LIMIT          35   // Sets the max pwm power limit
-#define POWER_LIMIT              32   // 30 watts default power limit
-#define I2C_SOFT_BUS_2           1
+#define VOLTAGE_DIV        650  // Default for TS80P with slightly different resistors
+#define CALIBRATION_OFFSET 1500 // the adc offset in uV
+#define PID_POWER_LIMIT    35   // Sets the max pwm power limit
+#define POWER_LIMIT        32   // 30 watts default power limit
+
 #define HARDWARE_MAX_WATTAGE_X10 320
-#define OLED_I2CBB1              1
-#define ACCEL_I2CBB1             1
 
 #define POW_PD 1
 #define POW_QC 1
 #define TEMP_NTC
+#define I2C_SOFT_BUS_2 1
 #define SC7_ORI_FLIP
 #endif /* TS80P */
 
@@ -262,8 +255,8 @@
 #define FLASH_LOGOADDR      (0x08000000 + (126 * 1024))
 #define SETTINGS_START_PAGE (0x08000000 + (127 * 1024))
 #else
-#define FLASH_LOGOADDR      (0x08000000 + (62 * 1024))
-#define SETTINGS_START_PAGE (0x08000000 + (63 * 1024))
+#define FLASH_LOGOADDR      (0x08000000 +  (62 * 1024))
+#define SETTINGS_START_PAGE (0x08000000 +  (63 * 1024))
 #endif /* TS101 */
 
 #endif /* CONFIGURATION_H_ */

source/Core/BSP/Miniware/preRTOS.cpp

@@ -25,4 +25,7 @@ void preRToSInit() {
 #ifdef I2C_SOFT_BUS_1
   I2CBB1::init();
 #endif
+
+  /* Init the IPC objects */
+  FRToSI2C::FRToSInit();
 }

source/Core/BSP/Miniware/stm32f1xx_hal_msp.c

@@ -81,6 +81,55 @@ void HAL_ADC_MspInit(ADC_HandleTypeDef *hadc) {
   }
 }
 
+void HAL_I2C_MspInit(I2C_HandleTypeDef *hi2c) {
+
+  GPIO_InitTypeDef GPIO_InitStruct;
+  /**I2C1 GPIO Configuration
+   PB6     ------> I2C1_SCL
+   PB7     ------> I2C1_SDA
+   */
+  GPIO_InitStruct.Pin   = SCL_Pin | SDA_Pin;
+  GPIO_InitStruct.Mode  = GPIO_MODE_AF_OD;
+  GPIO_InitStruct.Pull  = GPIO_PULLUP;
+  GPIO_InitStruct.Speed = GPIO_SPEED_FREQ_HIGH;
+  HAL_GPIO_Init(SCL_GPIO_Port, &GPIO_InitStruct);
+
+  /* Peripheral clock enable */
+  __HAL_RCC_I2C1_CLK_ENABLE();
+  /* I2C1 DMA Init */
+  /* I2C1_RX Init */
+  hdma_i2c1_rx.Instance                 = DMA1_Channel7;
+  hdma_i2c1_rx.Init.Direction           = DMA_PERIPH_TO_MEMORY;
+  hdma_i2c1_rx.Init.PeriphInc           = DMA_PINC_DISABLE;
+  hdma_i2c1_rx.Init.MemInc              = DMA_MINC_ENABLE;
+  hdma_i2c1_rx.Init.PeriphDataAlignment = DMA_PDATAALIGN_BYTE;
+  hdma_i2c1_rx.Init.MemDataAlignment    = DMA_MDATAALIGN_BYTE;
+  hdma_i2c1_rx.Init.Mode                = DMA_NORMAL;
+  hdma_i2c1_rx.Init.Priority            = DMA_PRIORITY_LOW;
+  HAL_DMA_Init(&hdma_i2c1_rx);
+
+  __HAL_LINKDMA(hi2c, hdmarx, hdma_i2c1_rx);
+
+  /* I2C1_TX Init */
+  hdma_i2c1_tx.Instance                 = DMA1_Channel6;
+  hdma_i2c1_tx.Init.Direction           = DMA_MEMORY_TO_PERIPH;
+  hdma_i2c1_tx.Init.PeriphInc           = DMA_PINC_DISABLE;
+  hdma_i2c1_tx.Init.MemInc              = DMA_MINC_ENABLE;
+  hdma_i2c1_tx.Init.PeriphDataAlignment = DMA_PDATAALIGN_BYTE;
+  hdma_i2c1_tx.Init.MemDataAlignment    = DMA_MDATAALIGN_BYTE;
+  hdma_i2c1_tx.Init.Mode                = DMA_NORMAL;
+  hdma_i2c1_tx.Init.Priority            = DMA_PRIORITY_MEDIUM;
+  HAL_DMA_Init(&hdma_i2c1_tx);
+
+  __HAL_LINKDMA(hi2c, hdmatx, hdma_i2c1_tx);
+
+  /* I2C1 interrupt Init */
+  HAL_NVIC_SetPriority(I2C1_EV_IRQn, 15, 0);
+  HAL_NVIC_EnableIRQ(I2C1_EV_IRQn);
+  HAL_NVIC_SetPriority(I2C1_ER_IRQn, 15, 0);
+  HAL_NVIC_EnableIRQ(I2C1_ER_IRQn);
+}
+
 void HAL_TIM_Base_MspInit(TIM_HandleTypeDef *htim_base) {
   if (htim_base->Instance == TIM3) {
     /* Peripheral clock enable */

source/Core/BSP/Miniware/stm32f1xx_it.c

@@ -57,6 +57,13 @@ void TIM4_IRQHandler(void) {
   HAL_TIM_IRQHandler(handle);
 }
 
+void I2C1_EV_IRQHandler(void) { HAL_I2C_EV_IRQHandler(&hi2c1); }
+void I2C1_ER_IRQHandler(void) { HAL_I2C_ER_IRQHandler(&hi2c1); }
+
+void DMA1_Channel6_IRQHandler(void) { HAL_DMA_IRQHandler(&hdma_i2c1_tx); }
+
+void DMA1_Channel7_IRQHandler(void) { HAL_DMA_IRQHandler(&hdma_i2c1_rx); }
+
 void EXTI9_5_IRQHandler(void) {
 #ifdef INT_PD_Pin
   HAL_GPIO_EXTI_IRQHandler(INT_PD_Pin);

source/Core/BSP/Sequre_S60/I2C_Wrapper.cpp

@@ -0,0 +1,91 @@
+/*
+ * FRToSI2C.cpp
+ *
+ *  Created on: 14Apr.,2018
+ *      Author: Ralim
+ */
+#include "BSP.h"
+#include "Setup.h"
+#include <I2C_Wrapper.hpp>
+SemaphoreHandle_t FRToSI2C::I2CSemaphore = nullptr;
+StaticSemaphore_t FRToSI2C::xSemaphoreBuffer;
+
+void FRToSI2C::CpltCallback() {
+  hi2c1.State = HAL_I2C_STATE_READY; // Force state reset (even if tx error)
+  if (I2CSemaphore) {
+    xSemaphoreGiveFromISR(I2CSemaphore, NULL);
+  }
+}
+
+bool FRToSI2C::Mem_Read(uint16_t DevAddress, uint16_t MemAddress, uint8_t *pData, uint16_t Size) {
+
+  if (!lock())
+    return false;
+  if (HAL_I2C_Mem_Read(&hi2c1, DevAddress, MemAddress, I2C_MEMADD_SIZE_8BIT, pData, Size, 500) != HAL_OK) {
+
+    I2C_Unstick();
+    unlock();
+    return false;
+  }
+
+  unlock();
+  return true;
+}
+bool FRToSI2C::I2C_RegisterWrite(uint8_t address, uint8_t reg, uint8_t data) { return Mem_Write(address, reg, &data, 1); }
+
+uint8_t FRToSI2C::I2C_RegisterRead(uint8_t add, uint8_t reg) {
+  uint8_t tx_data[1];
+  Mem_Read(add, reg, tx_data, 1);
+  return tx_data[0];
+}
+bool FRToSI2C::Mem_Write(uint16_t DevAddress, uint16_t MemAddress, uint8_t *pData, uint16_t Size) {
+
+  if (!lock())
+    return false;
+  if (HAL_I2C_Mem_Write(&hi2c1, DevAddress, MemAddress, I2C_MEMADD_SIZE_8BIT, pData, Size, 500) != HAL_OK) {
+
+    I2C_Unstick();
+    unlock();
+    return false;
+  }
+
+  unlock();
+  return true;
+}
+
+bool FRToSI2C::Transmit(uint16_t DevAddress, uint8_t *pData, uint16_t Size) {
+  if (!lock())
+    return false;
+  if (HAL_I2C_Master_Transmit_IT(&hi2c1, DevAddress, pData, Size) != HAL_OK) {
+    I2C_Unstick();
+    unlock();
+    return false;
+  }
+  return true;
+}
+
+bool FRToSI2C::probe(uint16_t DevAddress) {
+  if (!lock())
+    return false;
+  uint8_t buffer[1];
+  bool    worked = HAL_I2C_Mem_Read(&hi2c1, DevAddress, 0x0F, I2C_MEMADD_SIZE_8BIT, buffer, 1, 1000) == HAL_OK;
+  unlock();
+  return worked;
+}
+
+void FRToSI2C::I2C_Unstick() { unstick_I2C(); }
+
+void FRToSI2C::unlock() { xSemaphoreGive(I2CSemaphore); }
+
+bool FRToSI2C::lock() { return xSemaphoreTake(I2CSemaphore, (TickType_t)50) == pdTRUE; }
+
+bool FRToSI2C::writeRegistersBulk(const uint8_t address, const I2C_REG *registers, const uint8_t registersLength) {
+  for (int index = 0; index < registersLength; index++) {
+    if (!I2C_RegisterWrite(address, registers[index].reg, registers[index].val)) {
+      return false;
+    }
+    if (registers[index].pause_ms)
+      delay_ms(registers[index].pause_ms);
+  }
+  return true;
+}

source/Core/BSP/Sequre_S60/IRQ.cpp

@@ -23,6 +23,12 @@ void HAL_ADCEx_InjectedConvCpltCallback(ADC_HandleTypeDef *hadc) {
     }
   }
 }
+void HAL_I2C_MasterRxCpltCallback(I2C_HandleTypeDef *hi2c __unused) { FRToSI2C::CpltCallback(); }
+void HAL_I2C_MasterTxCpltCallback(I2C_HandleTypeDef *hi2c __unused) { FRToSI2C::CpltCallback(); }
+void HAL_I2C_MemTxCpltCallback(I2C_HandleTypeDef *hi2c __unused) { FRToSI2C::CpltCallback(); }
+void HAL_I2C_ErrorCallback(I2C_HandleTypeDef *hi2c __unused) { FRToSI2C::CpltCallback(); }
+void HAL_I2C_AbortCpltCallback(I2C_HandleTypeDef *hi2c __unused) { FRToSI2C::CpltCallback(); }
+void HAL_I2C_MemRxCpltCallback(I2C_HandleTypeDef *hi2c __unused) { FRToSI2C::CpltCallback(); }
 
 extern osThreadId POWTaskHandle;
 

source/Core/BSP/Sequre_S60/IRQ.h

@@ -18,6 +18,12 @@
 extern "C" {
 #endif
 void HAL_ADCEx_InjectedConvCpltCallback(ADC_HandleTypeDef *hadc);
+void HAL_I2C_ErrorCallback(I2C_HandleTypeDef *hi2c);
+void HAL_I2C_AbortCpltCallback(I2C_HandleTypeDef *hi2c);
+void HAL_I2C_MasterTxCpltCallback(I2C_HandleTypeDef *hi2c);
+void HAL_I2C_MasterRxCpltCallback(I2C_HandleTypeDef *hi2c);
+void HAL_I2C_MemTxCpltCallback(I2C_HandleTypeDef *hi2c);
+void HAL_I2C_MemRxCpltCallback(I2C_HandleTypeDef *hi2c);
 void HAL_GPIO_EXTI_Callback(uint16_t);
 
 #ifdef __cplusplus

source/Core/BSP/Sequre_S60/Setup.cpp

@@ -14,6 +14,10 @@ ADC_HandleTypeDef hadc1;
 ADC_HandleTypeDef hadc2;
 DMA_HandleTypeDef hdma_adc1;
 
+I2C_HandleTypeDef hi2c1;
+DMA_HandleTypeDef hdma_i2c1_rx;
+DMA_HandleTypeDef hdma_i2c1_tx;
+
 IWDG_HandleTypeDef hiwdg;
 TIM_HandleTypeDef  htim4; // Tip control
 TIM_HandleTypeDef  htim2; // ADC Scheduling
@@ -24,6 +28,7 @@ uint16_t ADCReadings[ADC_SAMPLES]; // Used to store the adc readings for the han
 // Functions
 static void SystemClock_Config(void);
 static void MX_ADC1_Init(void);
+static void MX_I2C1_Init(void);
 static void MX_IWDG_Init(void);
 static void MX_TIM4_Init(void); // Tip control
 static void MX_TIM2_Init(void); // ADC Scheduling
@@ -39,6 +44,9 @@ void        Setup_HAL() {
 
   // These are not shared so no harm enabling
   __HAL_AFIO_REMAP_SWJ_NOJTAG();
+#ifdef SCL_Pin
+  MX_I2C1_Init();
+#endif
   MX_GPIO_Init();
   MX_DMA_Init();
   MX_ADC1_Init();
@@ -241,6 +249,33 @@ static void MX_ADC2_Init(void) {
     ;
   }
 }
+/* I2C1 init function */
+static void MX_I2C1_Init(void) {
+  hi2c1.Instance        = I2C1;
+  hi2c1.Init.ClockSpeed = 200000;
+  // OLED doesnt handle >100k when its asleep (off).
+  hi2c1.Init.DutyCycle       = I2C_DUTYCYCLE_16_9;
+  hi2c1.Init.OwnAddress1     = 0;
+  hi2c1.Init.AddressingMode  = I2C_ADDRESSINGMODE_7BIT;
+  hi2c1.Init.DualAddressMode = I2C_DUALADDRESS_DISABLE;
+  hi2c1.Init.OwnAddress2     = 0;
+  hi2c1.Init.GeneralCallMode = I2C_GENERALCALL_DISABLE;
+  hi2c1.Init.NoStretchMode   = I2C_NOSTRETCH_DISABLE;
+  __HAL_I2C_DISABLE(&hi2c1);
+
+  __HAL_RCC_I2C1_CLK_ENABLE();
+
+  // 13. Set SWRST bit in I2Cx_CR1 register.
+  hi2c1.Instance->CR1 |= 0x8000;
+
+  asm("nop");
+
+  // 14. Clear SWRST bit in I2Cx_CR1 register.
+  hi2c1.Instance->CR1 &= ~0x8000;
+
+  HAL_I2C_Init(&hi2c1);
+  unstick_I2C();
+}
 
 /* IWDG init function */
 static void MX_IWDG_Init(void) {

source/Core/BSP/Sequre_S60/Setup.h

@@ -18,6 +18,10 @@ extern ADC_HandleTypeDef hadc1;
 extern ADC_HandleTypeDef hadc2;
 extern DMA_HandleTypeDef hdma_adc1;
 
+extern DMA_HandleTypeDef hdma_i2c1_rx;
+extern DMA_HandleTypeDef hdma_i2c1_tx;
+extern I2C_HandleTypeDef hi2c1;
+
 extern IWDG_HandleTypeDef hiwdg;
 
 extern TIM_HandleTypeDef htim4;

source/Core/BSP/Sequre_S60/configuration.h

@@ -163,7 +163,7 @@
 #define OLED_I2CBB2
 
 #define MODEL_HAS_DCDC // We dont have DC/DC but have reallly fast PWM that gets us roughly the same place
-#endif                 /* S60 */
+#endif /* S60 */
 
 #define FLASH_LOGOADDR      (0x08000000 + (62 * 1024))
 #define SETTINGS_START_PAGE (0x08000000 + (63 * 1024))

source/Core/BSP/Sequre_S60/preRTOS.cpp

@@ -20,4 +20,6 @@ void preRToSInit() {
 #ifdef I2C_SOFT_BUS_2
   I2CBB2::init();
 #endif
+  /* Init the IPC objects */
+  FRToSI2C::FRToSInit();
 }

source/Core/BSP/Sequre_S60/stm32f1xx_hal_msp.c

@@ -72,6 +72,54 @@ void HAL_ADC_MspInit(ADC_HandleTypeDef *hadc) {
   }
 }
 
+void HAL_I2C_MspInit(I2C_HandleTypeDef *hi2c) {
+#ifdef SCL_Pin
+  GPIO_InitTypeDef GPIO_InitStruct;
+  /**I2C1 GPIO Configuration
+   PB6     ------> I2C1_SCL
+   PB7     ------> I2C1_SDA
+   */
+  GPIO_InitStruct.Pin   = SCL_Pin | SDA_Pin;
+  GPIO_InitStruct.Mode  = GPIO_MODE_AF_OD;
+  GPIO_InitStruct.Pull  = GPIO_PULLUP;
+  GPIO_InitStruct.Speed = GPIO_SPEED_FREQ_MEDIUM;
+  HAL_GPIO_Init(GPIOB, &GPIO_InitStruct);
+
+  /* I2C1 DMA Init */
+  /* I2C1_RX Init */
+  hdma_i2c1_rx.Instance                 = DMA1_Channel7;
+  hdma_i2c1_rx.Init.Direction           = DMA_PERIPH_TO_MEMORY;
+  hdma_i2c1_rx.Init.PeriphInc           = DMA_PINC_DISABLE;
+  hdma_i2c1_rx.Init.MemInc              = DMA_MINC_ENABLE;
+  hdma_i2c1_rx.Init.PeriphDataAlignment = DMA_PDATAALIGN_BYTE;
+  hdma_i2c1_rx.Init.MemDataAlignment    = DMA_MDATAALIGN_BYTE;
+  hdma_i2c1_rx.Init.Mode                = DMA_NORMAL;
+  hdma_i2c1_rx.Init.Priority            = DMA_PRIORITY_LOW;
+  HAL_DMA_Init(&hdma_i2c1_rx);
+
+  __HAL_LINKDMA(hi2c, hdmarx, hdma_i2c1_rx);
+
+  /* I2C1_TX Init */
+  hdma_i2c1_tx.Instance                 = DMA1_Channel6;
+  hdma_i2c1_tx.Init.Direction           = DMA_MEMORY_TO_PERIPH;
+  hdma_i2c1_tx.Init.PeriphInc           = DMA_PINC_DISABLE;
+  hdma_i2c1_tx.Init.MemInc              = DMA_MINC_ENABLE;
+  hdma_i2c1_tx.Init.PeriphDataAlignment = DMA_PDATAALIGN_BYTE;
+  hdma_i2c1_tx.Init.MemDataAlignment    = DMA_MDATAALIGN_BYTE;
+  hdma_i2c1_tx.Init.Mode                = DMA_NORMAL;
+  hdma_i2c1_tx.Init.Priority            = DMA_PRIORITY_MEDIUM;
+  HAL_DMA_Init(&hdma_i2c1_tx);
+
+  __HAL_LINKDMA(hi2c, hdmatx, hdma_i2c1_tx);
+
+  /* I2C1 interrupt Init */
+  HAL_NVIC_SetPriority(I2C1_EV_IRQn, 15, 0);
+  HAL_NVIC_EnableIRQ(I2C1_EV_IRQn);
+  HAL_NVIC_SetPriority(I2C1_ER_IRQn, 15, 0);
+  HAL_NVIC_EnableIRQ(I2C1_ER_IRQn);
+#endif
+}
+
 void HAL_TIM_Base_MspInit(TIM_HandleTypeDef *htim_base) {
   if (htim_base->Instance == TIM4) {
     /* Peripheral clock enable */

source/Core/BSP/Sequre_S60/stm32f1xx_it.c

@@ -33,4 +33,10 @@ void TIM1_UP_IRQHandler(void) { HAL_TIM_IRQHandler(&htim1); }
 void TIM4_IRQHandler(void) { HAL_TIM_IRQHandler(&htim4); }
 void TIM2_IRQHandler(void) { HAL_TIM_IRQHandler(&htim2); }
 
+void I2C1_EV_IRQHandler(void) { HAL_I2C_EV_IRQHandler(&hi2c1); }
+void I2C1_ER_IRQHandler(void) { HAL_I2C_ER_IRQHandler(&hi2c1); }
+
+void DMA1_Channel6_IRQHandler(void) { HAL_DMA_IRQHandler(&hdma_i2c1_tx); }
+
+void DMA1_Channel7_IRQHandler(void) { HAL_DMA_IRQHandler(&hdma_i2c1_rx); }
 void EXTI9_5_IRQHandler(void) { HAL_GPIO_EXTI_IRQHandler(GPIO_PIN_9); }

source/Core/Drivers/BMA223.cpp

@@ -5,15 +5,14 @@
  *      Author: Ralim
  */
 
-#include "accelerometers_common.h"
 #include <BMA223.hpp>
 #include <array>
 
 bool BMA223::detect() {
-  if (ACCEL_I2C_CLASS::probe(BMA223_ADDRESS)) {
+  if (FRToSI2C::probe(BMA223_ADDRESS)) {
     // Read chip id to ensure its not an address collision
     uint8_t id = 0;
-    if (ACCEL_I2C_CLASS::Mem_Read(BMA223_ADDRESS, BMA223_BGW_CHIPID, &id, 1)) {
+    if (FRToSI2C::Mem_Read(BMA223_ADDRESS, BMA223_BGW_CHIPID, &id, 1)) {
       return id == 0b11111000;
     }
   }
@@ -21,7 +20,7 @@ bool BMA223::detect() {
   return false;
 }
 
-static const ACCEL_I2C_CLASS::I2C_REG i2c_registers[] = {
+static const FRToSI2C::I2C_REG i2c_registers[] = {
     //
     //
     {BMA223_PMU_RANGE, 0b00000011, 0},     // 2G range
@@ -45,7 +44,7 @@ bool BMA223::initalize() {
   // Hysteresis is set to ~ 16 counts
   // Theta blocking is set to 0b10
 
-  return ACCEL_I2C_CLASS::writeRegistersBulk(BMA223_ADDRESS, i2c_registers, sizeof(i2c_registers) / sizeof(i2c_registers[0]));
+  return FRToSI2C::writeRegistersBulk(BMA223_ADDRESS, i2c_registers, sizeof(i2c_registers) / sizeof(i2c_registers[0]));
 }
 
 void BMA223::getAxisReadings(int16_t &x, int16_t &y, int16_t &z) {
@@ -53,7 +52,7 @@ void BMA223::getAxisReadings(int16_t &x, int16_t &y, int16_t &z) {
   // And yet there are MSB and LSB registers _sigh_.
   uint8_t sensorData[6] = {0, 0, 0, 0, 0, 0};
 
-  if (ACCEL_I2C_CLASS::Mem_Read(BMA223_ADDRESS, BMA223_ACCD_X_LSB, sensorData, 6) == false) {
+  if (FRToSI2C::Mem_Read(BMA223_ADDRESS, BMA223_ACCD_X_LSB, sensorData, 6) == false) {
     x = y = z = 0;
     return;
   }

source/Core/Drivers/BMA223.hpp

@@ -10,8 +10,6 @@
 #include "BMA223_defines.h"
 #include "BSP.h"
 #include "I2C_Wrapper.hpp"
-#include "accelerometers_common.h"
-
 
 class BMA223 {
 public:
@@ -19,7 +17,7 @@ public:
   static bool initalize();
   // 1 = rh, 2,=lh, 8=flat
   static Orientation getOrientation() {
-    uint8_t val = ACCEL_I2C_CLASS::I2C_RegisterRead(BMA223_ADDRESS, BMA223_INT_STATUS_3);
+    uint8_t val = FRToSI2C::I2C_RegisterRead(BMA223_ADDRESS, BMA223_INT_STATUS_3);
     val >>= 4; // we dont need high values
     val &= 0b11;
     if (val & 0b10) {

source/Core/Drivers/I2CBB1.cpp

@@ -314,15 +314,4 @@ bool I2CBB1::writeRegistersBulk(const uint8_t address, const I2C_REG *registers,
   }
   return true;
 }
-
-bool I2CBB1::wakePart(uint16_t DevAddress) {
-  // wakepart is a special case  where only the device address is sent
-  if (!lock())
-    return false;
-  start();
-  bool ack = send(DevAddress);
-  stop();
-  unlock();
-  return ack;
-}
 #endif

source/Core/Drivers/I2CBB1.hpp

@@ -36,7 +36,6 @@ public:
     const uint8_t pause_ms; // How many ms to pause _after_ writing this reg
   } I2C_REG;
   static bool writeRegistersBulk(const uint8_t address, const I2C_REG *registers, const uint8_t registersLength);
-  static bool wakePart(uint16_t DevAddress);
 
 private:
   static SemaphoreHandle_t I2CSemaphore;

source/Core/Drivers/I2CBB2.cpp

@@ -313,15 +313,4 @@ bool I2CBB2::writeRegistersBulk(const uint8_t address, const I2C_REG *registers,
   }
   return true;
 }
-
-bool I2CBB2::wakePart(uint16_t DevAddress) {
-  // wakepart is a special case  where only the device address is sent
-  if (!lock())
-    return false;
-  start();
-  bool ack = send(DevAddress);
-  stop();
-  unlock();
-  return ack;
-}
 #endif

source/Core/Drivers/I2CBB2.hpp

@@ -36,7 +36,6 @@ public:
     const uint8_t pause_ms; // How many ms to pause _after_ writing this reg
   } I2C_REG;
   static bool writeRegistersBulk(const uint8_t address, const I2C_REG *registers, const uint8_t registersLength);
-  static bool wakePart(uint16_t DevAddress);
 
 private:
   static SemaphoreHandle_t I2CSemaphore;

source/Core/Drivers/MMA8652FC.cpp

@@ -5,12 +5,12 @@
  *      Author: Ben V. Brown
  */
 
-#include "MMA8652FC.hpp"
-#include "accelerometers_common.h"
-#include "cmsis_os.h"
 #include <array>
 
-static const ACCEL_I2C_CLASS::I2C_REG i2c_registers[] = {
+#include "MMA8652FC.hpp"
+#include "cmsis_os.h"
+
+static const FRToSI2C::I2C_REG i2c_registers[] = {
     {CTRL_REG2, 0, 0},                // Normal mode
     {CTRL_REG2, 0x40, 2},             // Reset all registers to POR values
     {FF_MT_CFG_REG, 0x78, 0},         // Enable motion detection for X, Y, Z axis, latch disabled
@@ -26,11 +26,11 @@ static const ACCEL_I2C_CLASS::I2C_REG i2c_registers[] = {
     {CTRL_REG1, 0x19, 0}              // ODR=12 Hz, Active mode
 };
 
-bool MMA8652FC::initalize() { return ACCEL_I2C_CLASS::writeRegistersBulk(MMA8652FC_I2C_ADDRESS, i2c_registers, sizeof(i2c_registers) / sizeof(i2c_registers[0])); }
+bool MMA8652FC::initalize() { return FRToSI2C::writeRegistersBulk(MMA8652FC_I2C_ADDRESS, i2c_registers, sizeof(i2c_registers) / sizeof(i2c_registers[0])); }
 
 Orientation MMA8652FC::getOrientation() {
   // First read the PL_STATUS register
-  uint8_t plStatus = ACCEL_I2C_CLASS::I2C_RegisterRead(MMA8652FC_I2C_ADDRESS, PL_STATUS_REG);
+  uint8_t plStatus = FRToSI2C::I2C_RegisterRead(MMA8652FC_I2C_ADDRESS, PL_STATUS_REG);
   if ((plStatus & 0b10000000) == 0b10000000) {
     plStatus >>= 1;   // We don't need the up/down bit
     plStatus &= 0x03; // mask to the two lower bits
@@ -47,11 +47,11 @@ Orientation MMA8652FC::getOrientation() {
 void MMA8652FC::getAxisReadings(int16_t &x, int16_t &y, int16_t &z) {
   std::array<int16_t, 3> sensorData;
 
-  ACCEL_I2C_CLASS::Mem_Read(MMA8652FC_I2C_ADDRESS, OUT_X_MSB_REG, reinterpret_cast<uint8_t *>(sensorData.begin()), sensorData.size() * sizeof(int16_t));
+  FRToSI2C::Mem_Read(MMA8652FC_I2C_ADDRESS, OUT_X_MSB_REG, reinterpret_cast<uint8_t *>(sensorData.begin()), sensorData.size() * sizeof(int16_t));
 
   x = static_cast<int16_t>(__builtin_bswap16(*reinterpret_cast<uint16_t *>(&sensorData[0])));
   y = static_cast<int16_t>(__builtin_bswap16(*reinterpret_cast<uint16_t *>(&sensorData[1])));
   z = static_cast<int16_t>(__builtin_bswap16(*reinterpret_cast<uint16_t *>(&sensorData[2])));
 }
 
-bool MMA8652FC::detect() { return ACCEL_I2C_CLASS::probe(MMA8652FC_I2C_ADDRESS); }
+bool MMA8652FC::detect() { return FRToSI2C::probe(MMA8652FC_I2C_ADDRESS); }

source/Core/Drivers/MSA301.cpp

@@ -6,13 +6,11 @@
  */
 
 #include "MSA301_defines.h"
-#include "accelerometers_common.h"
 #include <MSA301.h>
-
 #define MSA301_I2C_ADDRESS 0x26 << 1
-bool MSA301::detect() { return ACCEL_I2C_CLASS::probe(MSA301_I2C_ADDRESS); }
+bool MSA301::detect() { return FRToSI2C::probe(MSA301_I2C_ADDRESS); }
 
-static const ACCEL_I2C_CLASS::I2C_REG i2c_registers[] = {
+static const FRToSI2C::I2C_REG i2c_registers[] = {
     //
     //
     {MSA301_REG_ODR, 0b00001000, 1},       // X/Y/Z enabled @ 250Hz
@@ -23,11 +21,11 @@ static const ACCEL_I2C_CLASS::I2C_REG i2c_registers[] = {
 
 };
 
-bool MSA301::initalize() { return ACCEL_I2C_CLASS::writeRegistersBulk(MSA301_I2C_ADDRESS, i2c_registers, sizeof(i2c_registers) / sizeof(i2c_registers[0])); }
+bool MSA301::initalize() { return FRToSI2C::writeRegistersBulk(MSA301_I2C_ADDRESS, i2c_registers, sizeof(i2c_registers) / sizeof(i2c_registers[0])); }
 
 Orientation MSA301::getOrientation() {
   uint8_t temp = 0;
-  ACCEL_I2C_CLASS::Mem_Read(MSA301_I2C_ADDRESS, MSA301_REG_ORIENT_STATUS, &temp, 1);
+  FRToSI2C::Mem_Read(MSA301_I2C_ADDRESS, MSA301_REG_ORIENT_STATUS, &temp, 1);
   switch (temp) {
   case 112:
     return Orientation::ORIENTATION_LEFT_HAND;
@@ -41,7 +39,7 @@ Orientation MSA301::getOrientation() {
 void MSA301::getAxisReadings(int16_t &x, int16_t &y, int16_t &z) {
   uint8_t temp[6];
   // Bulk read all 6 regs
-  ACCEL_I2C_CLASS::Mem_Read(MSA301_I2C_ADDRESS, MSA301_REG_OUT_X_L, temp, 6);
+  FRToSI2C::Mem_Read(MSA301_I2C_ADDRESS, MSA301_REG_OUT_X_L, temp, 6);
   x = int16_t(((int16_t)temp[1]) << 8 | temp[0]) >> 2;
   y = int16_t(((int16_t)temp[3]) << 8 | temp[2]) >> 2;
   z = int16_t(((int16_t)temp[5]) << 8 | temp[4]) >> 2;

source/Core/Drivers/OLED.hpp

@@ -46,9 +46,9 @@ extern "C" {
 #define OLED_GRAM_START_FLIP 0
 #define OLED_GRAM_END_FLIP   0x7F
 
-#define OLED_VCOM_LAYOUT 0x12
+#define OLED_VCOM_LAYOUT     0x12
 #define OLED_SEGMENT_MAP_REVERSED
-#define OLED_DIVIDER 0xD3
+#define OLED_DIVIDER         0xD3
 
 #else
 
@@ -59,14 +59,14 @@ extern "C" {
 #define OLED_GRAM_START_FLIP 0
 #define OLED_GRAM_END_FLIP   95
 
-#define OLED_VCOM_LAYOUT 0x02
-#define OLED_SEGMENT_MAP 0xA0
-#define OLED_DIVIDER     0xD5
+#define OLED_VCOM_LAYOUT     0x02
+#define OLED_SEGMENT_MAP     0xA0
+#define OLED_DIVIDER         0xD5
 
 #endif /* OLED_128x32 */
 
-#define OLED_ON  0xAF
-#define OLED_OFF 0xAE
+#define OLED_ON   0xAF
+#define OLED_OFF  0xAE
 
 #define FRAMEBUFFER_START 17
 
@@ -78,10 +78,7 @@ enum class FontStyle {
 
 class OLED {
 public:
-  enum DisplayState : bool {
-    OFF = false,
-    ON  = true
-  };
+  enum DisplayState : bool { OFF = false, ON = true };
 
   static void initialize(); // Startup the I2C coms (brings screen out of reset etc)
   static bool isInitDone();
@@ -120,10 +117,10 @@ public:
   static void    setInverseDisplay(bool inverted);
   static int16_t getCursorX() { return cursor_x; }
   // Draw a string to the current location, with selected font; optionally - with MAX length only
-  static void print(const char *string, FontStyle fontStyle, uint8_t length = 255);
-  static void printWholeScreen(const char *string);
+  static void    print(const char *string, FontStyle fontStyle, uint8_t length = 255);
+  static void    printWholeScreen(const char *string);
   // Print *F or *C - in font style of Small, Large (by default) or Extra based on input arg
-  static void printSymbolDeg(FontStyle fontStyle = FontStyle::LARGE);
+  static void    printSymbolDeg(FontStyle fontStyle = FontStyle::LARGE);
   // Set the cursor location by pixels
   static void setCursor(int16_t x, int16_t y) {
     cursor_x = x;

source/Core/Drivers/SC7A20.cpp

@@ -6,7 +6,6 @@
  */
 
 #include "LIS2DH12_defines.hpp"
-#include "accelerometers_common.h"
 #include <SC7A20.hpp>
 #include <SC7A20_defines.h>
 #include <array>
@@ -18,20 +17,20 @@ bool SC7A20::isInImitationMode;
 */
 
 bool SC7A20::detect() {
-  if (ACCEL_I2C_CLASS::probe(SC7A20_ADDRESS)) {
+  if (FRToSI2C::probe(SC7A20_ADDRESS)) {
     // Read chip id to ensure its not an address collision
     uint8_t id = 0;
-    if (ACCEL_I2C_CLASS::Mem_Read(SC7A20_ADDRESS, SC7A20_WHO_AMI_I, &id, 1)) {
+    if (FRToSI2C::Mem_Read(SC7A20_ADDRESS, SC7A20_WHO_AMI_I, &id, 1)) {
       if (id == SC7A20_WHO_AM_I_VALUE) {
         isInImitationMode = false;
         return true;
       }
     }
   }
-  if (ACCEL_I2C_CLASS::probe(SC7A20_ADDRESS2)) {
+  if (FRToSI2C::probe(SC7A20_ADDRESS2)) {
     // Read chip id to ensure its not an address collision
     uint8_t id = 0;
-    if (ACCEL_I2C_CLASS::Mem_Read(SC7A20_ADDRESS2, SC7A20_WHO_AMI_I, &id, 1)) {
+    if (FRToSI2C::Mem_Read(SC7A20_ADDRESS2, SC7A20_WHO_AMI_I, &id, 1)) {
       if (id == SC7A20_WHO_AM_I_VALUE) {
         isInImitationMode = true;
         return true;
@@ -41,7 +40,7 @@ bool SC7A20::detect() {
   return false;
 }
 
-static const ACCEL_I2C_CLASS::I2C_REG i2c_registers[] = {
+static const FRToSI2C::I2C_REG i2c_registers[] = {
     //
     //
     {SC7A20_CTRL_REG1, 0b01100111, 0}, // 200Hz, XYZ enabled
@@ -60,19 +59,19 @@ static const ACCEL_I2C_CLASS::I2C_REG i2c_registers[] = {
 
     //
 };
-static const ACCEL_I2C_CLASS::I2C_REG i2c_registers_alt[] = {{LIS_CTRL_REG1, 0b00110111, 0}, // 200Hz XYZ
-                                                             {LIS_CTRL_REG2, 0b00000000, 0}, //
-                                                             {LIS_CTRL_REG3, 0b01100000, 0}, // Setup interrupt pins
-                                                             {LIS_CTRL_REG4, 0b00001000, 0}, // Block update mode off, HR on
-                                                             {LIS_CTRL_REG5, 0b00000010, 0}, //
-                                                             {LIS_CTRL_REG6, 0b01100010, 0},
-                                                             // Basically setup the unit to run, and enable 4D orientation detection
-                                                             {LIS_INT2_CFG, 0b01111110, 0}, // setup for movement detection
-                                                             {LIS_INT2_THS, 0x28, 0},       //
-                                                             {LIS_INT2_DURATION, 64, 0},    //
-                                                             {LIS_INT1_CFG, 0b01111110, 0}, //
-                                                             {LIS_INT1_THS, 0x28, 0},       //
-                                                             {LIS_INT1_DURATION, 64, 0}};
+static const FRToSI2C::I2C_REG i2c_registers_alt[] = {{LIS_CTRL_REG1, 0b00110111, 0}, // 200Hz XYZ
+                                                      {LIS_CTRL_REG2, 0b00000000, 0}, //
+                                                      {LIS_CTRL_REG3, 0b01100000, 0}, // Setup interrupt pins
+                                                      {LIS_CTRL_REG4, 0b00001000, 0}, // Block update mode off, HR on
+                                                      {LIS_CTRL_REG5, 0b00000010, 0}, //
+                                                      {LIS_CTRL_REG6, 0b01100010, 0},
+                                                      // Basically setup the unit to run, and enable 4D orientation detection
+                                                      {LIS_INT2_CFG, 0b01111110, 0}, // setup for movement detection
+                                                      {LIS_INT2_THS, 0x28, 0},       //
+                                                      {LIS_INT2_DURATION, 64, 0},    //
+                                                      {LIS_INT1_CFG, 0b01111110, 0}, //
+                                                      {LIS_INT1_THS, 0x28, 0},       //
+                                                      {LIS_INT1_DURATION, 64, 0}};
 
 bool SC7A20::initalize() {
   // Setup acceleration readings
@@ -84,9 +83,9 @@ bool SC7A20::initalize() {
   // Hysteresis is set to ~ 16 counts
   // Theta blocking is set to 0b10
   if (isInImitationMode) {
-    return ACCEL_I2C_CLASS::writeRegistersBulk(SC7A20_ADDRESS2, i2c_registers_alt, sizeof(i2c_registers_alt) / sizeof(i2c_registers_alt[0]));
+    return FRToSI2C::writeRegistersBulk(SC7A20_ADDRESS2, i2c_registers_alt, sizeof(i2c_registers_alt) / sizeof(i2c_registers_alt[0]));
   } else {
-    return ACCEL_I2C_CLASS::writeRegistersBulk(SC7A20_ADDRESS, i2c_registers, sizeof(i2c_registers) / sizeof(i2c_registers[0]));
+    return FRToSI2C::writeRegistersBulk(SC7A20_ADDRESS, i2c_registers, sizeof(i2c_registers) / sizeof(i2c_registers[0]));
   }
 }
 
@@ -94,7 +93,7 @@ void SC7A20::getAxisReadings(int16_t &x, int16_t &y, int16_t &z) {
   // We can tell the accelerometer to output in LE mode which makes this simple
   uint16_t sensorData[3] = {0, 0, 0};
 
-  if (ACCEL_I2C_CLASS::Mem_Read(isInImitationMode ? SC7A20_ADDRESS2 : SC7A20_ADDRESS, isInImitationMode ? SC7A20_OUT_X_L_ALT : SC7A20_OUT_X_L, (uint8_t *)sensorData, 6) == false) {
+  if (FRToSI2C::Mem_Read(isInImitationMode ? SC7A20_ADDRESS2 : SC7A20_ADDRESS, isInImitationMode ? SC7A20_OUT_X_L_ALT : SC7A20_OUT_X_L, (uint8_t *)sensorData, 6) == false) {
     x = y = z = 0;
     return;
   }

source/Core/Drivers/SC7A20.hpp

@@ -10,7 +10,6 @@
 #include "BSP.h"
 #include "I2C_Wrapper.hpp"
 #include "SC7A20_defines.h"
-#include "accelerometers_common.h"
 
 class SC7A20 {
 public:
@@ -18,7 +17,7 @@ public:
   static bool initalize();
   // 1 = rh, 2,=lh, 8=flat
   static Orientation getOrientation() {
-    uint8_t val = ((ACCEL_I2C_CLASS::I2C_RegisterRead(isInImitationMode ? SC7A20_ADDRESS2 : SC7A20_ADDRESS, SC7A20_INT2_SOURCE) >> 2) - 1);
+    uint8_t val = ((FRToSI2C::I2C_RegisterRead(isInImitationMode ? SC7A20_ADDRESS2 : SC7A20_ADDRESS, SC7A20_INT2_SOURCE) >> 2) - 1);
     if (val == 1) {
 #ifdef SC7_ORI_FLIP
       return Orientation::ORIENTATION_RIGHT_HAND;

source/Core/Drivers/Si7210.cpp

@@ -10,17 +10,17 @@
  *      This class is licensed as MIT to match this code base
  */
 
+#include "I2C_Wrapper.hpp"
 #include "Si7210_defines.h"
-#include "accelerometers_common.h"
 #include <Si7210.h>
-bool Si7210::detect() { return ACCEL_I2C_CLASS::wakePart(SI7210_ADDRESS); }
+bool Si7210::detect() { return FRToSI2C::wakePart(SI7210_ADDRESS); }
 
 bool Si7210::init() {
   // Turn on auto increment and sanity check ID
   // Load OTP cal
 
   uint8_t temp;
-  if (ACCEL_I2C_CLASS::Mem_Read(SI7210_ADDRESS, SI7210_REG_ID, &temp, 1)) {
+  if (FRToSI2C::Mem_Read(SI7210_ADDRESS, SI7210_REG_ID, &temp, 1)) {
     // We don't really care what model it is etc, just probing to check its probably this iC
     if (temp != 0x00 && temp != 0xFF) {
       temp = 0x00;
@@ -77,10 +77,10 @@ bool Si7210::write_reg(const uint8_t reg, const uint8_t mask, const uint8_t val)
     temp &= mask;
   }
   temp |= val;
-  return ACCEL_I2C_CLASS::Mem_Write(SI7210_ADDRESS, reg, &temp, 1);
+  return FRToSI2C::Mem_Write(SI7210_ADDRESS, reg, &temp, 1);
 }
 
-bool Si7210::read_reg(const uint8_t reg, uint8_t *val) { return ACCEL_I2C_CLASS::Mem_Read(SI7210_ADDRESS, reg, val, 1); }
+bool Si7210::read_reg(const uint8_t reg, uint8_t *val) { return FRToSI2C::Mem_Read(SI7210_ADDRESS, reg, val, 1); }
 
 bool Si7210::start_periodic_measurement() {
   /* Enable periodic wakeup */
@@ -95,7 +95,7 @@ bool Si7210::start_periodic_measurement() {
 bool Si7210::get_field_strength(int16_t *field) {
   *field      = 0;
   uint8_t val = 0;
-  ACCEL_I2C_CLASS::wakePart(SI7210_ADDRESS);
+  FRToSI2C::wakePart(SI7210_ADDRESS);
 
   if (!write_reg(SI7210_POWER_CTRL, MEAS_MASK | USESTORE_MASK, STOP_MASK))
     return false;

source/Core/Drivers/accelerometers_common.h

@@ -1,6 +1,6 @@
 #ifndef CORE_DRIVERS_ACCELEROMTERS_COMMON_H_
 #define CORE_DRIVERS_ACCELEROMTERS_COMMON_H_
-#include "configuration.h"
+
 #if defined(ACCEL_I2CBB2)
 #include "I2CBB2.hpp"
 #define ACCEL_I2C_CLASS I2CBB2

source/Core/Inc/stm32f1xx_hal_conf.h

@@ -60,7 +60,7 @@ extern "C" {
 /*#define HAL_ETH_MODULE_ENABLED   */
 /*#define HAL_FLASH_MODULE_ENABLED   */
 #define HAL_GPIO_MODULE_ENABLED
-/* #define HAL_I2C_MODULE_ENABLED */
+#define HAL_I2C_MODULE_ENABLED
 /*#define HAL_I2S_MODULE_ENABLED   */
 /*#define HAL_IRDA_MODULE_ENABLED   */
 #define HAL_IWDG_MODULE_ENABLED