Increase PWM rate

Translations/translation_SK.json

@@ -34,7 +34,7 @@
             "message": "!Skrat hrotu!"
         },
         "SettingsCalibrationWarning": {
-            "message": "Pred reštartovaním sa uistite, že hrot a rúčka sú v izbovej teplote!"
+            "message": "Pred reštartovaním sa uistite, že hrot a rúčka je v izbovej teplote!"
         },
         "CJCCalibrating": {
             "message": "kalibrovanie\n"
@@ -73,7 +73,7 @@
             "message": "Vaše zariadenie je pravdepodobne falzifikát!"
         },
         "TooHotToStartProfileWarning": {
-            "message": "Teplota príliš vysoká pre štart profilu"
+            "message": "Teplota príliž vysoká pre štart profilu"
         }
     },
     "characters": {
@@ -168,43 +168,43 @@
             "description": "Rýchlosť predhrievania (stupňe za sekundu)"
         },
         "ProfilePhase1Temp": {
-            "displayText": "Teplota\nFáza 1",
+            "displayText": "Teplota\nFáze 1",
-            "description": "Cieľová teplota na konci tejto fázy"
+            "description": "Cieľová teplota na konci tejto fáze"
         },
         "ProfilePhase1Duration": {
-            "displayText": "Trvanie\nFáza 1",
+            "displayText": "Trvanie\nFáze 1",
-            "description": "Doba trvania tejto fázy (sekundy)"
+            "description": "Doba trvania tejto fáze (sekundy)"
         },
         "ProfilePhase2Temp": {
-            "displayText": "Teplota\nFáza 2",
+            "displayText": "Teplota\nFáze 2",
             "description": ""
         },
         "ProfilePhase2Duration": {
-            "displayText": "Trvanie\nFáza 2",
+            "displayText": "Trvanie\nFáze 2",
             "description": ""
         },
         "ProfilePhase3Temp": {
-            "displayText": "Teplota\nFáza 3",
+            "displayText": "Teplota\nFáze 3",
             "description": ""
         },
         "ProfilePhase3Duration": {
-            "displayText": "Trvanie\nFáza 3",
+            "displayText": "Trvanie\nFáze 3",
             "description": ""
         },
         "ProfilePhase4Temp": {
-            "displayText": "Teplota\nFáza 4",
+            "displayText": "Teplota\nFáze 4",
             "description": ""
         },
         "ProfilePhase4Duration": {
-            "displayText": "Trvanie\nFáza 4",
+            "displayText": "Trvanie\nFáze 4",
             "description": ""
         },
         "ProfilePhase5Temp": {
-            "displayText": "Teplota\nFáza 5",
+            "displayText": "Teplota\nFáze 5",
             "description": ""
         },
         "ProfilePhase5Duration": {
-            "displayText": "Trvanie\nFáza 4",
+            "displayText": "Trvanie\nFáze 4",
             "description": ""
         },
         "ProfileCooldownSpeed": {
@@ -288,7 +288,7 @@
             "description": "Obmedzenie výkonu podľa použitého zdroja (watt)"
         },
         "CalibrateCJC": {
-            "displayText": "Kalibrácia CJC\npri nasledujúcom štarte",
+            "displayText": "Kalibrácia CJC\npri nasladujúcom štarte",
             "description": "Pri nasledujúcom štarte bude kalibrovaná kompenzácia studeného spoja (nie je potrebné ak Delta T je < 5°C)"
         },
         "VoltageCalibration": {

source/Core/BSP/BSP_Power.h

@@ -19,8 +19,9 @@ void power_check();
 // Returns the tip resistance in x10 ohms, so 7.5 = 75; 14=140 etc
 uint8_t getTipResistanceX10();
 
-uint16_t getTipThermalMass();
+uint8_t getTipThermalMass();
-uint16_t getTipInertia();
+uint8_t getTipInertia();
+
 
 #ifdef __cplusplus
 }

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; }
@@ -423,7 +472,7 @@ uint64_t getDeviceID() {
 
 uint8_t preStartChecksDone() { return 1; }
 
-uint16_t getTipThermalMass() { return TIP_THERMAL_MASS; }
+uint8_t getTipThermalMass() { return TIP_THERMAL_MASS; }
-uint16_t getTipInertia() { return TIP_THERMAL_MASS; }
+uint8_t getTipInertia() { return TIP_THERMAL_MASS; }
 
 void showBootLogo(void) { BootLogo::handleShowingLogo((uint8_t *)FLASH_LOGOADDR); }

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();
@@ -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_2
-#define I2C_SOFT_BUS_1  1
-#define OLED_I2CBB1     1
-#define ACCEL_I2CBB1    1
 #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/BSP.cpp

@@ -396,7 +396,7 @@ bool isTipShorted() { return tipShorted; }
 #else
 bool isTipShorted() { return false; }
 #endif
-uint16_t getTipThermalMass() {
+uint8_t getTipThermalMass() {
 #ifdef TIP_RESISTANCE_SENSE_Pin
   if (lastTipResistance >= 80) {
     return TIP_THERMAL_MASS;
@@ -406,7 +406,7 @@ uint16_t getTipThermalMass() {
   return TIP_THERMAL_MASS;
 #endif
 }
-uint16_t getTipInertia() {
+uint8_t getTipInertia() {
 #ifdef TIP_RESISTANCE_SENSE_Pin
   if (lastTipResistance >= 80) {
     return TIP_THERMAL_MASS;

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

@@ -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
@@ -170,8 +166,7 @@
 #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 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
 
@@ -247,14 +241,13 @@
 #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 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 */
 

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/Pinecil/BSP.cpp

@@ -97,7 +97,7 @@ uint8_t getTipResistanceX10() { return TIP_RESISTANCE; }
 bool    isTipShorted() { return false; }
 uint8_t preStartChecksDone() { return 1; }
 
-uint16_t getTipThermalMass() { return TIP_THERMAL_MASS; }
+uint8_t getTipThermalMass() { return TIP_THERMAL_MASS; }
-uint16_t getTipInertia() { return TIP_THERMAL_MASS; }
+uint8_t getTipInertia() { return TIP_THERMAL_MASS; }
 
 void showBootLogo(void) { BootLogo::handleShowingLogo((uint8_t *)FLASH_LOGOADDR); }

source/Core/BSP/Pinecilv2/BSP.cpp

@@ -160,8 +160,18 @@ uint8_t       getTipResistanceX10() {
   return lastTipResistance;
 }
 
-uint16_t getTipThermalMass() { return 120; }
+uint8_t getTipThermalMass() {
-uint16_t getTipInertia() { return 750; }
+  if (lastTipResistance >= 80) {
+    return 65;
+  }
+  return 45;
+}
+uint8_t getTipInertia() {
+  if (lastTipResistance >= 80) {
+    return 90;
+  }
+  return 10;
+}
 // We want to calculate lastTipResistance
 // If tip is connected, and the tip is cold and the tip is not being heated
 // We can use the GPIO to inject a small current into the tip and measure this
@@ -170,7 +180,7 @@ uint16_t getTipInertia() { return 750; }
 // Which is around 0.54mA this will induce:
 // 6 ohm tip -> 3.24mV (Real world ~= 3320)
 // 8 ohm tip -> 4.32mV (Real world ~= 4500)
-// Which is definitely measurable
+// Which is definitely measureable
 // Taking shortcuts here as we know we only really have to pick apart 6 and 8 ohm tips
 // These are reported as 60 and 75 respectively
 void performTipResistanceSampleReading() {

source/Core/BSP/Pinecilv2/IRQ.cpp

@@ -19,17 +19,17 @@ extern "C" {
 }
 void start_PWM_output(void);
 
-#define ADC_Filter_Smooth 4 /* This basically smooths over one PWM cycle / set of readings */
+#define ADC_Filter_Smooth 1
 history<uint16_t, ADC_Filter_Smooth> ADC_Vin;
 history<uint16_t, ADC_Filter_Smooth> ADC_Temp;
 history<uint16_t, ADC_Filter_Smooth> ADC_Tip;
-
+volatile uint8_t                     ADCBurstCounter = 0;
-// IRQ is called at the end of the 8 set readings, pop these from the FIFO and send to filters
 void                                 adc_fifo_irq(void) {
   if (ADC_GetIntStatus(ADC_INT_FIFO_READY) == SET) {
     // Read out all entries in the fifo
     while (ADC_Get_FIFO_Count()) {
-      uint32_t reading = ADC_Read_FIFO();
+      ADCBurstCounter++;
+      volatile uint32_t reading = ADC_Read_FIFO();
       // As per manual, 26 bit reading; lowest 16 are the ADC
       uint16_t sample = reading & 0xFFFF;
       uint8_t  source = (reading >> 21) & 0b11111;
@@ -43,10 +43,16 @@ void adc_fifo_irq(void) {
       case VIN_ADC_CHANNEL:
         ADC_Vin.update(sample);
         break;
+
       default:
         break;
       }
     }
+
+    if (ADCBurstCounter >= 8) {
+      ADCBurstCounter = 0;
+      start_PWM_output();
+
       // unblock the PID controller thread
       if (xTaskGetSchedulerState() != taskSCHEDULER_NOT_STARTED) {
         BaseType_t xHigherPriorityTaskWoken = pdFALSE;
@@ -56,6 +62,7 @@ void adc_fifo_irq(void) {
         }
       }
     }
+  }
   // Clear IRQ
   ADC_IntClr(ADC_INT_ALL);
 }
@@ -93,57 +100,30 @@ void start_PWM_output(void) {
     PWM_Channel_Disable(PWM_Channel);
     switchToFastPWM();
   }
+  TIMER_Enable(TIMER_CH0);
 }
 
 // Timer 0 is used to co-ordinate the ADC and the output PWM
 void timer0_comp0_callback(void) {
-  if (PWM_Channel_Is_Enabled(PWM_Channel)) {
+  TIMER_Disable(TIMER_CH0);
-    // So there appears to be a bug _somewhere_ where sometimes the comparator doesn't fire
-    // Its not re-occurring with specific values, so suspect its a weird bug
-    // For now, we just skip the cycle and throw away the ADC readings. Its a waste but
-    // It stops stupid glitches in readings, i'd take slight instability from the time jump
-    // Over the readings we get that are borked as the header is left on
-    // <Ralim 2023/10/14>
-    PWM_Channel_Disable(PWM_Channel);
-    // MSG("ALERT PWM Glitch\r\n");
-    // Triger the PID now instead
-    if (xTaskGetSchedulerState() != taskSCHEDULER_NOT_STARTED) {
-      BaseType_t xHigherPriorityTaskWoken = pdFALSE;
-      if (pidTaskNotification) {
-        vTaskNotifyGiveFromISR(pidTaskNotification, &xHigherPriorityTaskWoken);
-        portYIELD_FROM_ISR(xHigherPriorityTaskWoken);
-      }
-    }
-  } else {
   ADC_Start();
 }
-  TIMER_ClearIntStatus(TIMER_CH0, TIMER_COMP_ID_0);
+void timer0_comp1_callback(void) { PWM_Channel_Disable(PWM_Channel); } // Trigged at end of output cycle; turn off the tip PWM
-}
-void timer0_comp1_callback(void) {
-  // Trigged at end of output cycle; turn off the tip PWM
-  PWM_Channel_Disable(PWM_Channel);
-  TIMER_ClearIntStatus(TIMER_CH0, TIMER_COMP_ID_1);
-}
 
-void timer0_comp2_callback(void) {
-  // Triggered at end of timer cycle; re-start the tip driver
-  start_PWM_output();
-  TIMER_ClearIntStatus(TIMER_CH0, TIMER_COMP_ID_2);
-}
 void switchToFastPWM(void) {
   inFastPWMMode    = true;
-  holdoffTicks     = 10;
+  holdoffTicks     = 20;
-  tempMeasureTicks = 10;
+  tempMeasureTicks = 20;
   totalPWM         = powerPWM + tempMeasureTicks + holdoffTicks;
   TIMER_SetCompValue(TIMER_CH0, TIMER_COMP_ID_2, totalPWM);
 
   // ~10Hz
   TIMER_SetCompValue(TIMER_CH0, TIMER_COMP_ID_0, powerPWM + holdoffTicks);
-
   // Set divider to 10 ~= 10.5Hz
+
   uint32_t tmpVal = BL_RD_REG(TIMER_BASE, TIMER_TCDR);
 
-  tmpVal = BL_SET_REG_BITS_VAL(tmpVal, TIMER_TCDR2, 10);
+  tmpVal = BL_SET_REG_BITS_VAL(tmpVal, TIMER_TCDR2, 6);
 
   BL_WR_REG(TIMER_BASE, TIMER_TCDR, tmpVal);
 }
@@ -151,19 +131,19 @@ void switchToFastPWM(void) {
 void switchToSlowPWM(void) {
   // 5Hz
   inFastPWMMode    = false;
-  holdoffTicks     = 5;
+  holdoffTicks     = 10;
-  tempMeasureTicks = 5;
+  tempMeasureTicks = 10;
   totalPWM         = powerPWM + tempMeasureTicks + holdoffTicks;
 
   TIMER_SetCompValue(TIMER_CH0, TIMER_COMP_ID_2, totalPWM);
   // Adjust ADC
   TIMER_SetCompValue(TIMER_CH0, TIMER_COMP_ID_0, powerPWM + holdoffTicks);
 
-  // Set divider for ~ 5Hz
+  // Set divider to 22
 
   uint32_t tmpVal = BL_RD_REG(TIMER_BASE, TIMER_TCDR);
 
-  tmpVal = BL_SET_REG_BITS_VAL(tmpVal, TIMER_TCDR2, 20);
+  tmpVal = BL_SET_REG_BITS_VAL(tmpVal, TIMER_TCDR2, 12);
 
   BL_WR_REG(TIMER_BASE, TIMER_TCDR, tmpVal);
 }
@@ -213,6 +193,5 @@ uint16_t getADCHandleTemp(uint8_t sample) { return ADC_Temp.average(); }
 
 uint16_t getADCVin(uint8_t sample) { return ADC_Vin.average(); }
 
-// Returns the current raw tip reading after any cleanup filtering
+// Returns either average or instant value. When sample is set the samples from the injected ADC are copied to the filter and then the raw reading is returned
-// For Pinecil V2 we dont do any rolling filtering other than just averaging all 4 readings in the adc snapshot
 uint16_t getTipRawTemp(uint8_t sample) { return ADC_Tip.average() >> 1; }

source/Core/BSP/Pinecilv2/Setup.cpp

@@ -102,7 +102,7 @@ void setup_adc(void) {
 
   adc_cfg.clkDiv         = ADC_CLK_DIV_4;
   adc_cfg.vref           = ADC_VREF_3P2V;
-  adc_cfg.resWidth       = ADC_DATA_WIDTH_14_WITH_16_AVERAGE;
+  adc_cfg.resWidth       = ADC_DATA_WIDTH_14_WITH_64_AVERAGE;
   adc_cfg.inputMode      = ADC_INPUT_SINGLE_END;
   adc_cfg.v18Sel         = ADC_V18_SEL_1P72V;
   adc_cfg.v11Sel         = ADC_V11_SEL_1P1V;
@@ -111,7 +111,7 @@ void setup_adc(void) {
   adc_cfg.chopMode       = ADC_CHOP_MOD_AZ_ON;
   adc_cfg.biasSel        = ADC_BIAS_SEL_MAIN_BANDGAP;
   adc_cfg.vcm            = ADC_PGA_VCM_1P6V;
-  adc_cfg.offsetCalibEn  = DISABLE;
+  adc_cfg.offsetCalibEn  = ENABLE;
   adc_cfg.offsetCalibVal = 0;
 
   ADC_Disable();
@@ -120,7 +120,7 @@ void setup_adc(void) {
 
   ADC_Init(&adc_cfg);
   adc_fifo_cfg.dmaEn         = DISABLE;
-  adc_fifo_cfg.fifoThreshold = ADC_FIFO_THRESHOLD_8; // Triger FIFO when all 8 measurements are done
+  adc_fifo_cfg.fifoThreshold = ADC_FIFO_THRESHOLD_8;
   ADC_FIFO_Cfg(&adc_fifo_cfg);
   ADC_MIC_Bias_Disable();
   ADC_Tsen_Disable();
@@ -140,27 +140,24 @@ void setup_timer_scheduler() {
   TIMER_CFG_Type cfg = {
       TIMER_CH0,                           // Channel
       TIMER_CLKSRC_32K,                    // Clock source
-      TIMER_PRELOAD_TRIG_COMP2,                               // Trigger; reset after trigger 0
+      TIMER_PRELOAD_TRIG_COMP0,            // Trigger; reset after trigger 0
       TIMER_COUNT_PRELOAD,                 // Counter mode
       22,                                  // Clock div
       (uint16_t)(powerPWM + holdoffTicks), // CH0 compare (adc)
-      (uint16_t)(powerPWM),                                   // CH1 compare (pwm out)
+      0,                                   // CH1 compare (pwm out)
-      (uint16_t)(powerPWM + holdoffTicks + tempMeasureTicks), // CH2 compare end of cycle
+      0,                                   // CH2 compare not used
       0,                                   // Preload
   };
   TIMER_Init(&cfg);
 
   Timer_Int_Callback_Install(TIMER_CH0, TIMER_INT_COMP_0, timer0_comp0_callback);
   Timer_Int_Callback_Install(TIMER_CH0, TIMER_INT_COMP_1, timer0_comp1_callback);
-  Timer_Int_Callback_Install(TIMER_CH0, TIMER_INT_COMP_2, timer0_comp2_callback);
 
   TIMER_ClearIntStatus(TIMER_CH0, TIMER_COMP_ID_0);
   TIMER_ClearIntStatus(TIMER_CH0, TIMER_COMP_ID_1);
-  TIMER_ClearIntStatus(TIMER_CH0, TIMER_COMP_ID_2);
 
   TIMER_IntMask(TIMER_CH0, TIMER_INT_COMP_0, UNMASK);
   TIMER_IntMask(TIMER_CH0, TIMER_INT_COMP_1, UNMASK);
-  TIMER_IntMask(TIMER_CH0, TIMER_INT_COMP_2, UNMASK);
   CPU_Interrupt_Enable(TIMER_CH0_IRQn);
   TIMER_Enable(TIMER_CH0);
 }

source/Core/BSP/Pinecilv2/bl_mcu_sdk/drivers/bl702_driver/std_drv/inc/bl702_pwm.h

@@ -36,9 +36,8 @@
 #ifndef __BL702_PWM_H__
 #define __BL702_PWM_H__
 
-#include "bl702_common.h"
 #include "pwm_reg.h"
-
+#include "bl702_common.h"
 
 /** @addtogroup  BL702_Peripheral_Driver
  *  @{
@@ -100,7 +99,8 @@ typedef enum {
 /**
  *  @brief PWM configuration structure type definition
  */
-typedef struct {
+typedef struct
+{
     PWM_CH_ID_Type ch;           /*!< PWM channel */
     PWM_Clk_Type clk;            /*!< PWM Clock */
     PWM_Stop_Mode_Type stopMode; /*!< PWM Stop Mode */
@@ -121,27 +121,37 @@ typedef struct {
 /** @defgroup  PWM_CH_ID_TYPE
  *  @{
  */
-#define IS_PWM_CH_ID_TYPE(type) (((type) == PWM_CH0) || ((type) == PWM_CH1) || ((type) == PWM_CH2) || ((type) == PWM_CH3) || ((type) == PWM_CH4) || ((type) == PWM_CH_MAX))
+#define IS_PWM_CH_ID_TYPE(type) (((type) == PWM_CH0) || \
+                                 ((type) == PWM_CH1) || \
+                                 ((type) == PWM_CH2) || \
+                                 ((type) == PWM_CH3) || \
+                                 ((type) == PWM_CH4) || \
+                                 ((type) == PWM_CH_MAX))
 
 /** @defgroup  PWM_CLK_TYPE
  *  @{
  */
-#define IS_PWM_CLK_TYPE(type) (((type) == PWM_CLK_XCLK) || ((type) == PWM_CLK_BCLK) || ((type) == PWM_CLK_32K))
+#define IS_PWM_CLK_TYPE(type) (((type) == PWM_CLK_XCLK) || \
+                               ((type) == PWM_CLK_BCLK) || \
+                               ((type) == PWM_CLK_32K))
 
 /** @defgroup  PWM_STOP_MODE_TYPE
  *  @{
  */
-#define IS_PWM_STOP_MODE_TYPE(type) (((type) == PWM_STOP_ABRUPT) || ((type) == PWM_STOP_GRACEFUL))
+#define IS_PWM_STOP_MODE_TYPE(type) (((type) == PWM_STOP_ABRUPT) || \
+                                     ((type) == PWM_STOP_GRACEFUL))
 
 /** @defgroup  PWM_POLARITY_TYPE
  *  @{
  */
-#define IS_PWM_POLARITY_TYPE(type) (((type) == PWM_POL_NORMAL) || ((type) == PWM_POL_INVERT))
+#define IS_PWM_POLARITY_TYPE(type) (((type) == PWM_POL_NORMAL) || \
+                                    ((type) == PWM_POL_INVERT))
 
 /** @defgroup  PWM_INT_TYPE
  *  @{
  */
-#define IS_PWM_INT_TYPE(type) (((type) == PWM_INT_PULSE_CNT) || ((type) == PWM_INT_ALL))
+#define IS_PWM_INT_TYPE(type) (((type) == PWM_INT_PULSE_CNT) || \
+                               ((type) == PWM_INT_ALL))
 
 /*@} end of group PWM_Public_Constants */
 
@@ -171,13 +181,13 @@ void        PWM_Channel_Set_Period(PWM_CH_ID_Type ch, uint16_t period);
 void PWM_Channel_Get(PWM_CH_ID_Type ch, uint16_t *period, uint16_t *threshold1, uint16_t *threshold2);
 void PWM_IntMask(PWM_CH_ID_Type ch, PWM_INT_Type intType, BL_Mask_Type intMask);
 void PWM_Channel_Enable(PWM_CH_ID_Type ch);
-uint8_t     PWM_Channel_Is_Enabled(PWM_CH_ID_Type ch);
 void PWM_Channel_Disable(PWM_CH_ID_Type ch);
 void PWM_SW_Mode(PWM_CH_ID_Type ch, BL_Fun_Type enable);
 void PWM_SW_Force_Value(PWM_CH_ID_Type ch, uint8_t value);
 void PWM_Int_Callback_Install(PWM_CH_ID_Type ch, uint32_t intType, intCallback_Type *cbFun);
 BL_Err_Type PWM_Smart_Configure(PWM_CH_ID_Type ch, uint32_t frequency, uint8_t dutyCycle);
 
+
 /*@} end of group PWM_Public_Functions */
 
 /*@} end of group PWM */

source/Core/BSP/Pinecilv2/bl_mcu_sdk/drivers/bl702_driver/std_drv/src/bl702_pwm.c

@@ -354,18 +354,7 @@ void PWM_Channel_Enable(PWM_CH_ID_Type ch) {
   tmpVal = BL_RD_REG(PWMx, PWM_CONFIG);
   BL_WR_REG(PWMx, PWM_CONFIG, BL_CLR_REG_BIT(tmpVal, PWM_STOP_EN));
 }
-uint8_t PWM_Channel_Is_Enabled(PWM_CH_ID_Type ch) {
-  uint32_t tmpVal;
-  /* Get channel register */
-  uint32_t PWMx = PWM_Get_Channel_Reg(ch);
 
-  /* Check the parameters */
-  CHECK_PARAM(IS_PWM_CH_ID_TYPE(ch));
-
-  /* Config pwm clock to enable pwm */
-  tmpVal = BL_RD_REG(PWMx, PWM_CONFIG);
-  return BL_GET_REG_BITS_VAL(tmpVal, PWM_STOP_EN) == 0;
-}
 /****************************************************************************
  * @brief  PWM disable
  *

source/Core/BSP/Pinecilv2/configuration.h

@@ -161,15 +161,9 @@
 #define DEBUG_UART_OUTPUT
 #define HAS_POWER_DEBUG_MENU
 #define HARDWARE_MAX_WATTAGE_X10 750
-#define BLE_ENABLED                   // We have a BLE stack
+#define BLE_ENABLED
-#define NEEDS_VBUS_PROBE          0   // No vbus probe, its not connected in pcb
+#define NEEDS_VBUS_PROBE 0
-#define CANT_DIRECT_READ_SETTINGS     // We cant memcpy settings due to flash cache
+#define CANT_DIRECT_READ_SETTINGS
-#define TIP_CONTROL_PID               // We use PID rather than integrator
-#define TIP_PID_KP                45  // Reasonable compromise for most tips so far
-#define TIP_PID_KI                9   // About as high for stability across tips
-#define TIP_PID_KD                200 // Helps dampen smaller tips; ~= nothing for larger tips
-#define FILTER_DISPLAYED_TIP_TEMP 8   // Filtering for GUI display
-
 #endif /* Pinecilv2 */
 
 #define FLASH_PAGE_SIZE (1024) // Read pages

source/Core/BSP/Sequre_S60/BSP.cpp

@@ -234,8 +234,8 @@ uint8_t getTipResistanceX10() { return TIP_RESISTANCE; }
 bool    isTipShorted() { return false; }
 uint8_t preStartChecksDone() { return 1; }
 
-uint16_t getTipThermalMass() { return TIP_THERMAL_MASS; }
+uint8_t getTipThermalMass() { return TIP_THERMAL_MASS; }
-uint16_t getTipInertia() { return TIP_THERMAL_INERTIA; }
+uint8_t getTipInertia() { return TIP_THERMAL_INERTIA; }
 
 void setBuzzer(bool on) {}
 

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/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

@@ -78,10 +78,7 @@ enum class FontStyle {
 
 class OLED {
 public:
-  enum DisplayState : bool {
+  enum DisplayState : bool { OFF = false, ON = true };
-    OFF = false,
-    ON  = true
-  };
 
   static void initialize(); // Startup the I2C coms (brings screen out of reset etc)
   static bool isInitDone();

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,7 +59,7 @@ 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
+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
@@ -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

source/Core/Threads/OperatingModes/OperatingModes.h

@@ -10,7 +10,6 @@ extern "C" {
 #include "Settings.h"
 #include "TipThermoModel.h"
 #include "Translation.h"
-#include "Types.h"
 #include "cmsis_os.h"
 #include "configuration.h"
 #include "history.hpp"
@@ -48,5 +47,5 @@ void renderHomeScreenAssets(void);                                 // Called to
 
 // Common helpers
 int8_t   getPowerSourceNumber(void);                               // Returns number ID of power source
-TemperatureType_t getTipTemp(void);           // Returns temperature of the tip in *C/*F (based on user settings)
+uint16_t getTipTemp(void);                                         // Returns temperature of the tip in *C/*F (based on user settings)
 #endif

source/Core/Threads/OperatingModes/Sleep.cpp

@@ -25,7 +25,7 @@ int gui_SolderingSleepingMode(bool stayOff, bool autoStarted) {
     }
 
     // draw the lcd
-    TemperatureType_t tipTemp = getTipTemp();
+    uint16_t tipTemp = getTipTemp();
 
     OLED::clearScreen();
     OLED::setCursor(0, 0);

source/Core/Threads/OperatingModes/utils/DrawTipTemperature.cpp

@@ -4,7 +4,7 @@
 
 void gui_drawTipTemp(bool symbol, const FontStyle font) {
   // Draw tip temp handling unit conversion & tolerance near setpoint
-  TemperatureType_t Temp = getTipTemp();
+  uint16_t Temp = getTipTemp();
 
   OLED::printNumber(Temp, 3, font); // Draw the tip temp out
   if (symbol) {

source/Core/Threads/OperatingModes/utils/SolderingCommon.cpp

@@ -4,8 +4,6 @@
 
 #include "SolderingCommon.h"
 #include "OperatingModes.h"
-#include "configuration.h"
-#include "history.hpp"
 
 extern bool heaterThermalRunaway;
 
@@ -168,14 +166,4 @@ int8_t getPowerSourceNumber(void) {
 }
 
 // Returns temperature of the tip in *C/*F (based on user settings)
-TemperatureType_t getTipTemp(void) {
+uint16_t getTipTemp(void) { return getSettingValue(SettingsOptions::TemperatureInF) ? TipThermoModel::getTipInF() : TipThermoModel::getTipInC(); }
-#ifdef FILTER_DISPLAYED_TIP_TEMP
-  static history<TemperatureType_t, FILTER_DISPLAYED_TIP_TEMP> Filter_Temp;
-  TemperatureType_t                                            reading = getSettingValue(SettingsOptions::TemperatureInF) ? TipThermoModel::getTipInF() : TipThermoModel::getTipInC();
-  Filter_Temp.update(reading);
-  return Filter_Temp.average();
-
-#else
-  return getSettingValue(SettingsOptions::TemperatureInF) ? TipThermoModel::getTipInF() : TipThermoModel::getTipInC();
-#endif
-}

source/Core/Threads/PIDThread.cpp

@@ -10,7 +10,6 @@
 #include "Settings.h"
 #include "TipThermoModel.h"
 #include "cmsis_os.h"
-#include "configuration.h"
 #include "history.hpp"
 #include "main.hpp"
 #include "power.hpp"
@@ -23,7 +22,7 @@ volatile TemperatureType_t currentTempTargetDegC   = 0; // Current temperature t
 int32_t                    powerSupplyWattageLimit = 0;
 bool                       heaterThermalRunaway    = false;
 
-static int32_t getPIDResultX10Watts(TemperatureType_t set_point, TemperatureType_t current_value);
+static int32_t getPIDResultX10Watts(TemperatureType_t tError);
 static void    detectThermalRunaway(const TemperatureType_t currentTipTempInC, const TemperatureType_t tError);
 static void    setOutputx10WattsViaFilters(int32_t x10Watts);
 static int32_t getX10WattageLimits();
@@ -72,9 +71,10 @@ void startPIDTask(void const *argument __unused) {
         if (PIDTempTarget > TipThermoModel::getTipMaxInC()) {
           PIDTempTarget = TipThermoModel::getTipMaxInC();
         }
+        TemperatureType_t tError = PIDTempTarget - currentTipTempInC;
 
-        detectThermalRunaway(currentTipTempInC, PIDTempTarget - currentTipTempInC);
+        detectThermalRunaway(currentTipTempInC, tError);
-        x10WattsOut = getPIDResultX10Watts(PIDTempTarget, currentTipTempInC);
+        x10WattsOut = getPIDResultX10Watts(tError);
       } else {
         detectThermalRunaway(currentTipTempInC, 0);
       }
@@ -89,53 +89,6 @@ void startPIDTask(void const *argument __unused) {
   }
 }
 
-#ifdef TIP_CONTROL_PID
-template <class T, T Kp, T Ki, T Kd, T integral_limit_scale> struct PID {
-  T previous_error_term;
-  T integration_running_sum;
-
-  T update(const T set_point, const T new_reading, const TickType_t interval_ms, const T max_output) {
-    const T target_delta = set_point - new_reading;
-
-    // Proportional term
-    const T kp_result = Kp * target_delta;
-
-    // Integral term as we use mixed sampling rates, we cant assume a constant sample interval
-    // Thus we multiply this out by the interval time to ~= dv/dt
-    // Then the shift by 1000 is ms -> Seconds
-
-    integration_running_sum += (target_delta * interval_ms * Ki) / 1000;
-
-    // We constrain integration_running_sum to limit windup
-    // This is not overly required for most use cases but can prevent large overshoot in constrained implementations
-    if (integration_running_sum > integral_limit_scale * max_output) {
-      integration_running_sum = integral_limit_scale * max_output;
-    } else if (integration_running_sum < -integral_limit_scale * max_output) {
-      integration_running_sum = -integral_limit_scale * max_output;
-    }
-    // Calculate the integral term, we use a shift 100 to get precision in integral as we often need small amounts
-    T ki_result = integration_running_sum / 100;
-
-    // Derivative term
-    T derivative = (target_delta - previous_error_term);
-    T kd_result  = ((Kd * derivative) / (T)(interval_ms));
-
-    // Summation of the outputs
-    T output = kp_result + ki_result + kd_result;
-
-    // Restrict to max / 0
-    if (output > max_output)
-      output = max_output;
-    else if (output < 0)
-      output = 0;
-
-    // Save target_delta to previous target_delta
-    previous_error_term = target_delta;
-
-    return output;
-  }
-};
-#else
 template <class T = TemperatureType_t> struct Integrator {
   T sum;
 
@@ -161,19 +114,11 @@ template <class T = TemperatureType_t> struct Integrator {
 
   T get(bool positiveOnly = true) const { return (positiveOnly) ? ((sum > 0) ? sum : 0) : sum; }
 };
-#endif
+int32_t getPIDResultX10Watts(TemperatureType_t setpointDelta) {
-int32_t getPIDResultX10Watts(TemperatureType_t set_point, TemperatureType_t current_reading) {
   static TickType_t                    lastCall   = 0;
-
-#ifdef TIP_CONTROL_PID
-  static PID<TemperatureType_t, TIP_PID_KP, TIP_PID_KI, TIP_PID_KD, 5> pid = {0, 0};
-
-  const TickType_t interval = (xTaskGetTickCount() - lastCall);
-
-#else
   static Integrator<TemperatureType_t> powerStore = {0};
+
   const TickType_t rate = TICKS_SECOND / (xTaskGetTickCount() - lastCall);
-#endif
   lastCall              = xTaskGetTickCount();
   // Sandman note:
   // PID Challenge - we have a small thermal mass that we to want heat up as fast as possible but we don't
@@ -196,16 +141,11 @@ int32_t getPIDResultX10Watts(TemperatureType_t set_point, TemperatureType_t curr
   // tip temperature with (Delta Temperature ) °C in 1 second.
   // Note on powerStore. On update, if the value is provided in X10 (W) units then inertia shall be provided
   // in X10 (J / °C) units as well.
-
+  return powerStore.update(((TemperatureType_t)getTipThermalMass()) * setpointDelta, // the required power
-#ifdef TIP_CONTROL_PID
-  return pid.update(set_point, current_reading, interval, getX10WattageLimits());
-#else
-  return powerStore.update(((TemperatureType_t)getTipThermalMass()) * (set_point - current_reading), // the required power
                            getTipInertia(),                                          // Inertia, smaller numbers increase dominance of the previous value
                            2,                                                        // gain
                            rate,                                                     // PID cycle frequency
                            getX10WattageLimits());
-#endif
 }
 
 void detectThermalRunaway(const TemperatureType_t currentTipTempInC, const TemperatureType_t tError) {