git.sur5r.net Git - freertos/blob - FreeRTOS/Demo/CORTEX_M7_STM32F7_STM32756G-EVAL_IAR_Keil/ST_Library/stm32f7xx_hal_i2c.c

   1 /**\r
   2   ******************************************************************************\r
   3   * @file    stm32f7xx_hal_i2c.c\r
   4   * @author  MCD Application Team\r
   5   * @version V1.0.0\r
   6   * @date    12-May-2015\r
   7   * @brief   I2C HAL module driver.\r
   8   *          This file provides firmware functions to manage the following \r
   9   *          functionalities of the Inter Integrated Circuit (I2C) peripheral:\r
  10   *           + Initialization and de-initialization functions\r
  11   *           + IO operation functions\r
  12   *           + Peripheral State and Errors functions\r
  13   *         \r
  14   @verbatim\r
  15   ==============================================================================\r
  16                         ##### How to use this driver #####\r
  17   ==============================================================================\r
  18     [..]\r
  19     The I2C HAL driver can be used as follows:\r
  20     \r
  21     (#) Declare a I2C_HandleTypeDef handle structure, for example:\r
  22         I2C_HandleTypeDef  hi2c; \r
  23 \r
  24     (#)Initialize the I2C low level resources by implement the HAL_I2C_MspInit ()API:\r
  25         (##) Enable the I2Cx interface clock\r
  26         (##) I2C pins configuration\r
  27             (+++) Enable the clock for the I2C GPIOs\r
  28             (+++) Configure I2C pins as alternate function open-drain\r
  29         (##) NVIC configuration if you need to use interrupt process\r
  30             (+++) Configure the I2Cx interrupt priority\r
  31             (+++) Enable the NVIC I2C IRQ Channel\r
  32         (##) DMA Configuration if you need to use DMA process\r
  33             (+++) Declare a DMA_HandleTypeDef handle structure for the transmit or receive stream\r
  34             (+++) Enable the DMAx interface clock using\r
  35             (+++) Configure the DMA handle parameters\r
  36             (+++) Configure the DMA Tx or Rx Stream\r
  37             (+++) Associate the initialized DMA handle to the hi2c DMA Tx or Rx handle\r
  38             (+++) Configure the priority and enable the NVIC for the transfer complete interrupt on the DMA Tx or Rx Stream\r
  39 \r
  40     (#) Configure the Communication Clock Timing, Own Address1, Master Addressing Mode, Dual Addressing mode,\r
  41         Own Address2, Own Address2 Mask, General call and Nostretch mode in the hi2c Init structure.\r
  42 \r
  43     (#) Initialize the I2C registers by calling the HAL_I2C_Init(), configures also the low level Hardware \r
  44         (GPIO, CLOCK, NVIC...etc) by calling the customed HAL_I2C_MspInit(&hi2c) API.\r
  45 \r
  46     (#) To check if target device is ready for communication, use the function HAL_I2C_IsDeviceReady()\r
  47 \r
  48     (#) For I2C IO and IO MEM operations, three operation modes are available within this driver :\r
  49 \r
  50     *** Polling mode IO operation ***\r
  51     =================================\r
  52     [..]\r
  53       (+) Transmit in master mode an amount of data in blocking mode using HAL_I2C_Master_Transmit()\r
  54       (+) Receive in master mode an amount of data in blocking mode using HAL_I2C_Master_Receive()\r
  55       (+) Transmit in slave mode an amount of data in blocking mode using HAL_I2C_Slave_Transmit()\r
  56       (+) Receive in slave mode an amount of data in blocking mode using HAL_I2C_Slave_Receive()\r
  57 \r
  58     *** Polling mode IO MEM operation ***\r
  59     =====================================\r
  60     [..]\r
  61       (+) Write an amount of data in blocking mode to a specific memory address using HAL_I2C_Mem_Write()\r
  62       (+) Read an amount of data in blocking mode from a specific memory address using HAL_I2C_Mem_Read()\r
  63 \r
  64 \r
  65     *** Interrupt mode IO operation ***\r
  66     ===================================\r
  67     [..]\r
  68       (+) Transmit in master mode an amount of data in non blocking mode using HAL_I2C_Master_Transmit_IT()\r
  69       (+) At transmission end of transfer HAL_I2C_MasterTxCpltCallback is executed and user can\r
  70            add his own code by customization of function pointer HAL_I2C_MasterTxCpltCallback\r
  71       (+) Receive in master mode an amount of data in non blocking mode using HAL_I2C_Master_Receive_IT()\r
  72       (+) At reception end of transfer HAL_I2C_MasterRxCpltCallback is executed and user can\r
  73            add his own code by customization of function pointer HAL_I2C_MasterRxCpltCallback\r
  74       (+) Transmit in slave mode an amount of data in non blocking mode using HAL_I2C_Slave_Transmit_IT()\r
  75       (+) At transmission end of transfer HAL_I2C_SlaveTxCpltCallback is executed and user can\r
  76            add his own code by customization of function pointer HAL_I2C_SlaveTxCpltCallback\r
  77       (+) Receive in slave mode an amount of data in non blocking mode using HAL_I2C_Slave_Receive_IT()\r
  78       (+) At reception end of transfer HAL_I2C_SlaveRxCpltCallback is executed and user can\r
  79            add his own code by customization of function pointer HAL_I2C_SlaveRxCpltCallback\r
  80       (+) In case of transfer Error, HAL_I2C_ErrorCallback() function is executed and user can\r
  81            add his own code by customization of function pointer HAL_I2C_ErrorCallback\r
  82 \r
  83     *** Interrupt mode IO MEM operation ***\r
  84     =======================================\r
  85     [..]\r
  86       (+) Write an amount of data in no-blocking mode with Interrupt to a specific memory address using\r
  87           HAL_I2C_Mem_Write_IT()\r
  88       (+) At MEM end of write transfer HAL_I2C_MemTxCpltCallback is executed and user can\r
  89            add his own code by customization of function pointer HAL_I2C_MemTxCpltCallback\r
  90       (+) Read an amount of data in no-blocking mode with Interrupt from a specific memory address using\r
  91           HAL_I2C_Mem_Read_IT()\r
  92       (+) At MEM end of read transfer HAL_I2C_MemRxCpltCallback is executed and user can\r
  93            add his own code by customization of function pointer HAL_I2C_MemRxCpltCallback\r
  94       (+) In case of transfer Error, HAL_I2C_ErrorCallback() function is executed and user can\r
  95            add his own code by customization of function pointer HAL_I2C_ErrorCallback\r
  96 \r
  97     *** DMA mode IO operation ***\r
  98     ==============================\r
  99     [..]\r
 100       (+) Transmit in master mode an amount of data in non blocking mode (DMA) using\r
 101           HAL_I2C_Master_Transmit_DMA()\r
 102       (+) At transmission end of transfer HAL_I2C_MasterTxCpltCallback is executed and user can\r
 103            add his own code by customization of function pointer HAL_I2C_MasterTxCpltCallback\r
 104       (+) Receive in master mode an amount of data in non blocking mode (DMA) using\r
 105           HAL_I2C_Master_Receive_DMA()\r
 106       (+) At reception end of transfer HAL_I2C_MasterRxCpltCallback is executed and user can\r
 107            add his own code by customization of function pointer HAL_I2C_MasterRxCpltCallback\r
 108       (+) Transmit in slave mode an amount of data in non blocking mode (DMA) using\r
 109           HAL_I2C_Slave_Transmit_DMA()\r
 110       (+) At transmission end of transfer HAL_I2C_SlaveTxCpltCallback is executed and user can\r
 111            add his own code by customization of function pointer HAL_I2C_SlaveTxCpltCallback\r
 112       (+) Receive in slave mode an amount of data in non blocking mode (DMA) using\r
 113           HAL_I2C_Slave_Receive_DMA()\r
 114       (+) At reception end of transfer HAL_I2C_SlaveRxCpltCallback is executed and user can\r
 115            add his own code by customization of function pointer HAL_I2C_SlaveRxCpltCallback\r
 116       (+) In case of transfer Error, HAL_I2C_ErrorCallback() function is executed and user can\r
 117            add his own code by customization of function pointer HAL_I2C_ErrorCallback\r
 118 \r
 119     *** DMA mode IO MEM operation ***\r
 120     =================================\r
 121     [..]\r
 122       (+) Write an amount of data in no-blocking mode with DMA to a specific memory address using\r
 123           HAL_I2C_Mem_Write_DMA()\r
 124       (+) At MEM end of write transfer HAL_I2C_MemTxCpltCallback is executed and user can\r
 125            add his own code by customization of function pointer HAL_I2C_MemTxCpltCallback\r
 126       (+) Read an amount of data in no-blocking mode with DMA from a specific memory address using\r
 127           HAL_I2C_Mem_Read_DMA()\r
 128       (+) At MEM end of read transfer HAL_I2C_MemRxCpltCallback is executed and user can\r
 129            add his own code by customization of function pointer HAL_I2C_MemRxCpltCallback\r
 130       (+) In case of transfer Error, HAL_I2C_ErrorCallback() function is executed and user can\r
 131            add his own code by customization of function pointer HAL_I2C_ErrorCallback\r
 132 \r
 133 \r
 134      *** I2C HAL driver macros list ***\r
 135      ==================================\r
 136      [..]\r
 137        Below the list of most used macros in I2C HAL driver.\r
 138 \r
 139       (+) __HAL_I2C_ENABLE: Enable the I2C peripheral\r
 140       (+) __HAL_I2C_DISABLE: Disable the I2C peripheral\r
 141       (+) __HAL_I2C_GET_FLAG : Checks whether the specified I2C flag is set or not\r
 142       (+) __HAL_I2C_CLEAR_FLAG : Clear the specified I2C pending flag\r
 143       (+) __HAL_I2C_ENABLE_IT: Enable the specified I2C interrupt\r
 144       (+) __HAL_I2C_DISABLE_IT: Disable the specified I2C interrupt\r
 145 \r
 146      [..]\r
 147        (@) You can refer to the I2C HAL driver header file for more useful macros\r
 148 \r
 149   @endverbatim\r
 150   ******************************************************************************\r
 151   * @attention\r
 152   *\r
 153   * <h2><center>&copy; COPYRIGHT(c) 2015 STMicroelectronics</center></h2>\r
 154   *\r
 155   * Redistribution and use in source and binary forms, with or without modification,\r
 156   * are permitted provided that the following conditions are met:\r
 157   *   1. Redistributions of source code must retain the above copyright notice,\r
 158   *      this list of conditions and the following disclaimer.\r
 159   *   2. Redistributions in binary form must reproduce the above copyright notice,\r
 160   *      this list of conditions and the following disclaimer in the documentation\r
 161   *      and/or other materials provided with the distribution.\r
 162   *   3. Neither the name of STMicroelectronics nor the names of its contributors\r
 163   *      may be used to endorse or promote products derived from this software\r
 164   *      without specific prior written permission.\r
 165   *\r
 166   * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS"\r
 167   * AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE\r
 168   * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE\r
 169   * DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR CONTRIBUTORS BE LIABLE\r
 170   * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL\r
 171   * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR\r
 172   * SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER\r
 173   * CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY,\r
 174   * OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE\r
 175   * OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.\r
 176   *\r
 177   ******************************************************************************  \r
 178   */ \r
 179 \r
 180 /* Includes ------------------------------------------------------------------*/\r
 181 #include "stm32f7xx_hal.h"\r
 182 \r
 183 /** @addtogroup STM32F7xx_HAL_Driver\r
 184   * @{\r
 185   */\r
 186 \r
 187 /** @defgroup I2C I2C\r
 188   * @brief I2C HAL module driver\r
 189   * @{\r
 190   */\r
 191 \r
 192 #ifdef HAL_I2C_MODULE_ENABLED\r
 193 \r
 194 /* Private typedef -----------------------------------------------------------*/\r
 195 /* Private constants ---------------------------------------------------------*/\r
 196 /** @addtogroup I2C_Private_Constants I2C Private Constants\r
 197   * @{\r
 198   */\r
 199 #define TIMING_CLEAR_MASK   ((uint32_t)0xF0FFFFFF)  /*<! I2C TIMING clear register Mask */\r
 200 #define I2C_TIMEOUT_ADDR    ((uint32_t)10000)  /* 10 s  */\r
 201 #define I2C_TIMEOUT_BUSY    ((uint32_t)25)     /* 25 ms */\r
 202 #define I2C_TIMEOUT_DIR     ((uint32_t)25)     /* 25 ms */\r
 203 #define I2C_TIMEOUT_RXNE    ((uint32_t)25)     /* 25 ms */\r
 204 #define I2C_TIMEOUT_STOPF   ((uint32_t)25)     /* 25 ms */\r
 205 #define I2C_TIMEOUT_TC      ((uint32_t)25)     /* 25 ms */\r
 206 #define I2C_TIMEOUT_TCR     ((uint32_t)25)     /* 25 ms */\r
 207 #define I2C_TIMEOUT_TXIS    ((uint32_t)25)     /* 25 ms */\r
 208 #define I2C_TIMEOUT_FLAG    ((uint32_t)25)     /* 25 ms */\r
 209 /**\r
 210   * @}\r
 211   */ \r
 212 \r
 213 /* Private macro -------------------------------------------------------------*/\r
 214 /* Private variables ---------------------------------------------------------*/\r
 215 /* Private function prototypes -----------------------------------------------*/\r
 216 /** @addtogroup I2C_Private_Functions I2C Private Functions\r
 217   * @{\r
 218   */\r
 219 static void I2C_DMAMasterTransmitCplt(DMA_HandleTypeDef *hdma);\r
 220 static void I2C_DMAMasterReceiveCplt(DMA_HandleTypeDef *hdma);\r
 221 static void I2C_DMASlaveTransmitCplt(DMA_HandleTypeDef *hdma);\r
 222 static void I2C_DMASlaveReceiveCplt(DMA_HandleTypeDef *hdma);\r
 223 static void I2C_DMAMemTransmitCplt(DMA_HandleTypeDef *hdma);\r
 224 static void I2C_DMAMemReceiveCplt(DMA_HandleTypeDef *hdma);\r
 225 static void I2C_DMAError(DMA_HandleTypeDef *hdma);\r
 226 \r
 227 static HAL_StatusTypeDef I2C_RequestMemoryWrite(I2C_HandleTypeDef *hi2c, uint16_t DevAddress, uint16_t MemAddress, uint16_t MemAddSize, uint32_t Timeout);\r
 228 static HAL_StatusTypeDef I2C_RequestMemoryRead(I2C_HandleTypeDef *hi2c, uint16_t DevAddress, uint16_t MemAddress, uint16_t MemAddSize, uint32_t Timeout);\r
 229 static HAL_StatusTypeDef I2C_WaitOnFlagUntilTimeout(I2C_HandleTypeDef *hi2c, uint32_t Flag, FlagStatus Status, uint32_t Timeout);\r
 230 static HAL_StatusTypeDef I2C_WaitOnTXISFlagUntilTimeout(I2C_HandleTypeDef *hi2c, uint32_t Timeout);\r
 231 static HAL_StatusTypeDef I2C_WaitOnRXNEFlagUntilTimeout(I2C_HandleTypeDef *hi2c, uint32_t Timeout);\r
 232 static HAL_StatusTypeDef I2C_WaitOnSTOPFlagUntilTimeout(I2C_HandleTypeDef *hi2c, uint32_t Timeout);\r
 233 static HAL_StatusTypeDef I2C_IsAcknowledgeFailed(I2C_HandleTypeDef *hi2c, uint32_t Timeout);\r
 234 \r
 235 static HAL_StatusTypeDef I2C_MasterTransmit_ISR(I2C_HandleTypeDef *hi2c);\r
 236 static HAL_StatusTypeDef I2C_MasterReceive_ISR(I2C_HandleTypeDef *hi2c);\r
 237 \r
 238 static HAL_StatusTypeDef I2C_SlaveTransmit_ISR(I2C_HandleTypeDef *hi2c);\r
 239 static HAL_StatusTypeDef I2C_SlaveReceive_ISR(I2C_HandleTypeDef *hi2c);\r
 240 \r
 241 static void I2C_TransferConfig(I2C_HandleTypeDef *hi2c,  uint16_t DevAddress, uint8_t Size, uint32_t Mode, uint32_t Request);\r
 242 /**\r
 243   * @}\r
 244   */ \r
 245 \r
 246 /* Exported functions --------------------------------------------------------*/\r
 247 \r
 248 /** @defgroup I2C_Exported_Functions I2C Exported Functions\r
 249   * @{\r
 250   */\r
 251 \r
 252 /** @defgroup I2C_Exported_Functions_Group1 Initialization and de-initialization functions\r
 253  *  @brief    Initialization and Configuration functions \r
 254  *\r
 255 @verbatim    \r
 256  ===============================================================================\r
 257               ##### Initialization and de-initialization functions #####\r
 258  ===============================================================================\r
 259     [..]  This subsection provides a set of functions allowing to initialize and \r
 260           de-initialize the I2Cx peripheral:\r
 261 \r
 262       (+) User must Implement HAL_I2C_MspInit() function in which he configures \r
 263           all related peripherals resources (CLOCK, GPIO, DMA, IT and NVIC ).\r
 264 \r
 265       (+) Call the function HAL_I2C_Init() to configure the selected device with \r
 266           the selected configuration:\r
 267         (++) Clock Timing\r
 268         (++) Own Address 1\r
 269         (++) Addressing mode (Master, Slave)\r
 270         (++) Dual Addressing mode\r
 271         (++) Own Address 2\r
 272         (++) Own Address 2 Mask\r
 273         (++) General call mode\r
 274         (++) Nostretch mode\r
 275 \r
 276       (+) Call the function HAL_I2C_DeInit() to restore the default configuration \r
 277           of the selected I2Cx peripheral.       \r
 278 \r
 279 @endverbatim\r
 280   * @{\r
 281   */\r
 282 \r
 283 /**\r
 284   * @brief  Initializes the I2C according to the specified parameters \r
 285   *         in the I2C_InitTypeDef and create the associated handle.\r
 286   * @param  hi2c : Pointer to a I2C_HandleTypeDef structure that contains\r
 287   *                the configuration information for the specified I2C.\r
 288   * @retval HAL status\r
 289   */\r
 290 HAL_StatusTypeDef HAL_I2C_Init(I2C_HandleTypeDef *hi2c)\r
 291 { \r
 292   /* Check the I2C handle allocation */\r
 293   if(hi2c == NULL)\r
 294   {\r
 295     return HAL_ERROR;\r
 296   }\r
 297   \r
 298   /* Check the parameters */\r
 299   assert_param(IS_I2C_ALL_INSTANCE(hi2c->Instance));\r
 300   assert_param(IS_I2C_OWN_ADDRESS1(hi2c->Init.OwnAddress1));\r
 301   assert_param(IS_I2C_ADDRESSING_MODE(hi2c->Init.AddressingMode));\r
 302   assert_param(IS_I2C_DUAL_ADDRESS(hi2c->Init.DualAddressMode));\r
 303   assert_param(IS_I2C_OWN_ADDRESS2(hi2c->Init.OwnAddress2));\r
 304   assert_param(IS_I2C_OWN_ADDRESS2_MASK(hi2c->Init.OwnAddress2Masks));\r
 305   assert_param(IS_I2C_GENERAL_CALL(hi2c->Init.GeneralCallMode));\r
 306   assert_param(IS_I2C_NO_STRETCH(hi2c->Init.NoStretchMode));\r
 307 \r
 308   if(hi2c->State == HAL_I2C_STATE_RESET)\r
 309   {\r
 310     /* Allocate lock resource and initialize it */\r
 311     hi2c->Lock = HAL_UNLOCKED;\r
 312     /* Init the low level hardware : GPIO, CLOCK, CORTEX...etc */\r
 313     HAL_I2C_MspInit(hi2c);\r
 314   }\r
 315 \r
 316   hi2c->State = HAL_I2C_STATE_BUSY;\r
 317   \r
 318   /* Disable the selected I2C peripheral */\r
 319   __HAL_I2C_DISABLE(hi2c);\r
 320   \r
 321   /*---------------------------- I2Cx TIMINGR Configuration ------------------*/\r
 322   /* Configure I2Cx: Frequency range */\r
 323   hi2c->Instance->TIMINGR = hi2c->Init.Timing & TIMING_CLEAR_MASK;\r
 324   \r
 325   /*---------------------------- I2Cx OAR1 Configuration ---------------------*/\r
 326   /* Configure I2Cx: Own Address1 and ack own address1 mode */\r
 327   hi2c->Instance->OAR1 &= ~I2C_OAR1_OA1EN;\r
 328   if(hi2c->Init.OwnAddress1 != 0)\r
 329   {\r
 330     if(hi2c->Init.AddressingMode == I2C_ADDRESSINGMODE_7BIT)\r
 331     {\r
 332       hi2c->Instance->OAR1 = (I2C_OAR1_OA1EN | hi2c->Init.OwnAddress1);\r
 333     }\r
 334     else /* I2C_ADDRESSINGMODE_10BIT */\r
 335     {\r
 336       hi2c->Instance->OAR1 = (I2C_OAR1_OA1EN | I2C_OAR1_OA1MODE | hi2c->Init.OwnAddress1);\r
 337     }\r
 338   }\r
 339   \r
 340   /*---------------------------- I2Cx CR2 Configuration ----------------------*/\r
 341   /* Configure I2Cx: Addressing Master mode */\r
 342   if(hi2c->Init.AddressingMode == I2C_ADDRESSINGMODE_10BIT)\r
 343   {\r
 344     hi2c->Instance->CR2 = (I2C_CR2_ADD10);\r
 345   }\r
 346   /* Enable the AUTOEND by default, and enable NACK (should be disable only during Slave process */\r
 347   hi2c->Instance->CR2 |= (I2C_CR2_AUTOEND | I2C_CR2_NACK);\r
 348   \r
 349   /*---------------------------- I2Cx OAR2 Configuration ---------------------*/\r
 350   /* Configure I2Cx: Dual mode and Own Address2 */\r
 351   hi2c->Instance->OAR2 = (hi2c->Init.DualAddressMode | hi2c->Init.OwnAddress2 | (hi2c->Init.OwnAddress2Masks << 8));\r
 352 \r
 353   /*---------------------------- I2Cx CR1 Configuration ----------------------*/\r
 354   /* Configure I2Cx: Generalcall and NoStretch mode */\r
 355   hi2c->Instance->CR1 = (hi2c->Init.GeneralCallMode | hi2c->Init.NoStretchMode);\r
 356   \r
 357   /* Enable the selected I2C peripheral */\r
 358   __HAL_I2C_ENABLE(hi2c);\r
 359   \r
 360   hi2c->ErrorCode = HAL_I2C_ERROR_NONE;\r
 361   hi2c->State = HAL_I2C_STATE_READY;\r
 362   \r
 363   return HAL_OK;\r
 364 }\r
 365 \r
 366 /**\r
 367   * @brief  DeInitializes the I2C peripheral. \r
 368   * @param  hi2c : Pointer to a I2C_HandleTypeDef structure that contains\r
 369   *                the configuration information for the specified I2C.\r
 370   * @retval HAL status\r
 371   */\r
 372 HAL_StatusTypeDef HAL_I2C_DeInit(I2C_HandleTypeDef *hi2c)\r
 373 {\r
 374   /* Check the I2C handle allocation */\r
 375   if(hi2c == NULL)\r
 376   {\r
 377     return HAL_ERROR;\r
 378   }\r
 379   \r
 380   /* Check the parameters */\r
 381   assert_param(IS_I2C_ALL_INSTANCE(hi2c->Instance));\r
 382   \r
 383   hi2c->State = HAL_I2C_STATE_BUSY;\r
 384   \r
 385   /* Disable the I2C Peripheral Clock */\r
 386   __HAL_I2C_DISABLE(hi2c);\r
 387   \r
 388   /* DeInit the low level hardware: GPIO, CLOCK, NVIC */\r
 389   HAL_I2C_MspDeInit(hi2c);\r
 390   \r
 391   hi2c->ErrorCode = HAL_I2C_ERROR_NONE;\r
 392 \r
 393   hi2c->State = HAL_I2C_STATE_RESET;\r
 394   \r
 395   /* Release Lock */\r
 396   __HAL_UNLOCK(hi2c);\r
 397 \r
 398   return HAL_OK;\r
 399 }\r
 400 \r
 401 /**\r
 402   * @brief I2C MSP Init.\r
 403   * @param  hi2c : Pointer to a I2C_HandleTypeDef structure that contains\r
 404   *                the configuration information for the specified I2C.\r
 405   * @retval None\r
 406   */\r
 407  __weak void HAL_I2C_MspInit(I2C_HandleTypeDef *hi2c)\r
 408 {\r
 409   /* NOTE : This function Should not be modified, when the callback is needed,\r
 410             the HAL_I2C_MspInit could be implemented in the user file\r
 411    */ \r
 412 }\r
 413 \r
 414 /**\r
 415   * @brief I2C MSP DeInit\r
 416   * @param  hi2c : Pointer to a I2C_HandleTypeDef structure that contains\r
 417   *                the configuration information for the specified I2C.\r
 418   * @retval None\r
 419   */\r
 420  __weak void HAL_I2C_MspDeInit(I2C_HandleTypeDef *hi2c)\r
 421 {\r
 422   /* NOTE : This function Should not be modified, when the callback is needed,\r
 423             the HAL_I2C_MspDeInit could be implemented in the user file\r
 424    */ \r
 425 }\r
 426 \r
 427 /**\r
 428   * @}\r
 429   */\r
 430 \r
 431 /** @defgroup I2C_Exported_Functions_Group2 Input and Output operation functions\r
 432  *  @brief   Data transfers functions \r
 433  *\r
 434 @verbatim   \r
 435  ===============================================================================\r
 436                       ##### IO operation functions #####\r
 437  ===============================================================================  \r
 438     [..]\r
 439     This subsection provides a set of functions allowing to manage the I2C data \r
 440     transfers.\r
 441 \r
 442     (#) There are two modes of transfer:\r
 443        (++) Blocking mode : The communication is performed in the polling mode. \r
 444             The status of all data processing is returned by the same function \r
 445             after finishing transfer.  \r
 446        (++) No-Blocking mode : The communication is performed using Interrupts \r
 447             or DMA. These functions return the status of the transfer startup.\r
 448             The end of the data processing will be indicated through the \r
 449             dedicated I2C IRQ when using Interrupt mode or the DMA IRQ when \r
 450             using DMA mode.\r
 451 \r
 452     (#) Blocking mode functions are :\r
 453         (++) HAL_I2C_Master_Transmit()\r
 454         (++) HAL_I2C_Master_Receive()\r
 455         (++) HAL_I2C_Slave_Transmit()\r
 456         (++) HAL_I2C_Slave_Receive()\r
 457         (++) HAL_I2C_Mem_Write()\r
 458         (++) HAL_I2C_Mem_Read()\r
 459         (++) HAL_I2C_IsDeviceReady()\r
 460         \r
 461     (#) No-Blocking mode functions with Interrupt are :\r
 462         (++) HAL_I2C_Master_Transmit_IT()\r
 463         (++) HAL_I2C_Master_Receive_IT()\r
 464         (++) HAL_I2C_Slave_Transmit_IT()\r
 465         (++) HAL_I2C_Slave_Receive_IT()\r
 466         (++) HAL_I2C_Mem_Write_IT()\r
 467         (++) HAL_I2C_Mem_Read_IT()\r
 468 \r
 469     (#) No-Blocking mode functions with DMA are :\r
 470         (++) HAL_I2C_Master_Transmit_DMA()\r
 471         (++) HAL_I2C_Master_Receive_DMA()\r
 472         (++) HAL_I2C_Slave_Transmit_DMA()\r
 473         (++) HAL_I2C_Slave_Receive_DMA()\r
 474         (++) HAL_I2C_Mem_Write_DMA()\r
 475         (++) HAL_I2C_Mem_Read_DMA()\r
 476 \r
 477     (#) A set of Transfer Complete Callbacks are provided in non Blocking mode:\r
 478         (++) HAL_I2C_MemTxCpltCallback()\r
 479         (++) HAL_I2C_MemRxCpltCallback()\r
 480         (++) HAL_I2C_MasterTxCpltCallback()\r
 481         (++) HAL_I2C_MasterRxCpltCallback()\r
 482         (++) HAL_I2C_SlaveTxCpltCallback()\r
 483         (++) HAL_I2C_SlaveRxCpltCallback()\r
 484         (++) HAL_I2C_ErrorCallback()\r
 485 \r
 486 @endverbatim\r
 487   * @{\r
 488   */\r
 489 \r
 490 /**\r
 491   * @brief  Transmits in master mode an amount of data in blocking mode.\r
 492   * @param  hi2c : Pointer to a I2C_HandleTypeDef structure that contains\r
 493   *                the configuration information for the specified I2C.\r
 494   * @param  DevAddress: Target device address\r
 495   * @param  pData: Pointer to data buffer\r
 496   * @param  Size: Amount of data to be sent\r
 497   * @param  Timeout: Timeout duration\r
 498   * @retval HAL status\r
 499   */\r
 500 HAL_StatusTypeDef HAL_I2C_Master_Transmit(I2C_HandleTypeDef *hi2c, uint16_t DevAddress, uint8_t *pData, uint16_t Size, uint32_t Timeout)\r
 501 {\r
 502   uint32_t sizetmp = 0;\r
 503 \r
 504   if(hi2c->State == HAL_I2C_STATE_READY)\r
 505   {    \r
 506     if((pData == NULL ) || (Size == 0)) \r
 507     {\r
 508       return  HAL_ERROR;                                    \r
 509     }\r
 510     \r
 511     if(__HAL_I2C_GET_FLAG(hi2c, I2C_FLAG_BUSY) == SET)\r
 512     {\r
 513       return HAL_BUSY;\r
 514     }\r
 515 \r
 516     /* Process Locked */\r
 517     __HAL_LOCK(hi2c);\r
 518     \r
 519     hi2c->State = HAL_I2C_STATE_MASTER_BUSY_TX;\r
 520     hi2c->ErrorCode   = HAL_I2C_ERROR_NONE;\r
 521     \r
 522     /* Send Slave Address */\r
 523     /* Set NBYTES to write and reload if size > 255 and generate RESTART */\r
 524     /* Size > 255, need to set RELOAD bit */\r
 525     if(Size > 255)\r
 526     {\r
 527       I2C_TransferConfig(hi2c,DevAddress,255, I2C_RELOAD_MODE, I2C_GENERATE_START_WRITE);\r
 528       sizetmp = 255;\r
 529     }\r
 530     else\r
 531     {\r
 532       I2C_TransferConfig(hi2c,DevAddress,Size, I2C_AUTOEND_MODE, I2C_GENERATE_START_WRITE);\r
 533       sizetmp = Size;\r
 534     }\r
 535       \r
 536     do\r
 537     {\r
 538       /* Wait until TXIS flag is set */\r
 539       if(I2C_WaitOnTXISFlagUntilTimeout(hi2c, Timeout) != HAL_OK)\r
 540       {\r
 541         if(hi2c->ErrorCode == HAL_I2C_ERROR_AF)\r
 542         {\r
 543           return HAL_ERROR;\r
 544         }\r
 545         else\r
 546         {\r
 547           return HAL_TIMEOUT;\r
 548         }\r
 549       }\r
 550       /* Write data to TXDR */\r
 551       hi2c->Instance->TXDR = (*pData++);\r
 552       sizetmp--;\r
 553       Size--;\r
 554 \r
 555       if((sizetmp == 0)&&(Size!=0))\r
 556       {\r
 557         /* Wait until TXE flag is set */\r
 558         if(I2C_WaitOnFlagUntilTimeout(hi2c, I2C_FLAG_TCR, RESET, Timeout) != HAL_OK)      \r
 559         {\r
 560           return HAL_TIMEOUT;\r
 561         }\r
 562         \r
 563         if(Size > 255)\r
 564         {\r
 565           I2C_TransferConfig(hi2c,DevAddress,255, I2C_RELOAD_MODE, I2C_NO_STARTSTOP);\r
 566           sizetmp = 255;\r
 567         }\r
 568         else\r
 569         {\r
 570           I2C_TransferConfig(hi2c,DevAddress,Size, I2C_AUTOEND_MODE, I2C_NO_STARTSTOP);\r
 571           sizetmp = Size;\r
 572         }\r
 573       }\r
 574 \r
 575     }while(Size > 0);\r
 576     \r
 577     /* No need to Check TC flag, with AUTOEND mode the stop is automatically generated */\r
 578     /* Wait until STOPF flag is set */\r
 579     if(I2C_WaitOnSTOPFlagUntilTimeout(hi2c, Timeout) != HAL_OK)\r
 580     {\r
 581       if(hi2c->ErrorCode == HAL_I2C_ERROR_AF)\r
 582       {\r
 583         return HAL_ERROR;\r
 584       }\r
 585       else\r
 586       {\r
 587         return HAL_TIMEOUT;\r
 588       }\r
 589     }\r
 590     \r
 591     /* Clear STOP Flag */\r
 592     __HAL_I2C_CLEAR_FLAG(hi2c, I2C_FLAG_STOPF);\r
 593         \r
 594     /* Clear Configuration Register 2 */\r
 595     I2C_RESET_CR2(hi2c);\r
 596 \r
 597     hi2c->State = HAL_I2C_STATE_READY;    \r
 598     \r
 599     /* Process Unlocked */\r
 600     __HAL_UNLOCK(hi2c);\r
 601 \r
 602     return HAL_OK;\r
 603   }\r
 604   else\r
 605   {\r
 606     return HAL_BUSY; \r
 607   }\r
 608 }\r
 609 \r
 610 /**\r
 611   * @brief  Receives in master mode an amount of data in blocking mode. \r
 612   * @param  hi2c : Pointer to a I2C_HandleTypeDef structure that contains\r
 613   *                the configuration information for the specified I2C.\r
 614   * @param  DevAddress: Target device address\r
 615   * @param  pData: Pointer to data buffer\r
 616   * @param  Size: Amount of data to be sent\r
 617   * @param  Timeout: Timeout duration\r
 618   * @retval HAL status\r
 619   */\r
 620 HAL_StatusTypeDef HAL_I2C_Master_Receive(I2C_HandleTypeDef *hi2c, uint16_t DevAddress, uint8_t *pData, uint16_t Size, uint32_t Timeout)\r
 621 {\r
 622   uint32_t sizetmp = 0;\r
 623 \r
 624   if(hi2c->State == HAL_I2C_STATE_READY)\r
 625   {    \r
 626     if((pData == NULL ) || (Size == 0)) \r
 627     {\r
 628       return  HAL_ERROR;                                    \r
 629     }\r
 630     \r
 631     if(__HAL_I2C_GET_FLAG(hi2c, I2C_FLAG_BUSY) == SET)\r
 632     {\r
 633       return HAL_BUSY;\r
 634     }\r
 635 \r
 636     /* Process Locked */\r
 637     __HAL_LOCK(hi2c);\r
 638     \r
 639     hi2c->State = HAL_I2C_STATE_MASTER_BUSY_RX;\r
 640     hi2c->ErrorCode   = HAL_I2C_ERROR_NONE;\r
 641     \r
 642     /* Send Slave Address */\r
 643     /* Set NBYTES to write and reload if size > 255 and generate RESTART */\r
 644     /* Size > 255, need to set RELOAD bit */\r
 645     if(Size > 255)\r
 646     {\r
 647       I2C_TransferConfig(hi2c,DevAddress,255, I2C_RELOAD_MODE, I2C_GENERATE_START_READ);\r
 648       sizetmp = 255;\r
 649     }\r
 650     else\r
 651     {\r
 652       I2C_TransferConfig(hi2c,DevAddress,Size, I2C_AUTOEND_MODE, I2C_GENERATE_START_READ);\r
 653       sizetmp = Size;\r
 654     }\r
 655     \r
 656     do\r
 657     {\r
 658       /* Wait until RXNE flag is set */\r
 659       if(I2C_WaitOnFlagUntilTimeout(hi2c, I2C_FLAG_RXNE, RESET, Timeout) != HAL_OK)      \r
 660       {\r
 661         return HAL_TIMEOUT;\r
 662       }\r
 663      \r
 664       /* Write data to RXDR */\r
 665       (*pData++) =hi2c->Instance->RXDR;\r
 666       sizetmp--;\r
 667       Size--;\r
 668 \r
 669       if((sizetmp == 0)&&(Size!=0))\r
 670       {\r
 671         /* Wait until TCR flag is set */\r
 672         if(I2C_WaitOnFlagUntilTimeout(hi2c, I2C_FLAG_TCR, RESET, Timeout) != HAL_OK)      \r
 673         {\r
 674           return HAL_TIMEOUT;\r
 675         }\r
 676         \r
 677         if(Size > 255)\r
 678         {\r
 679           I2C_TransferConfig(hi2c,DevAddress,255, I2C_RELOAD_MODE, I2C_NO_STARTSTOP);\r
 680           sizetmp = 255;\r
 681         }\r
 682         else\r
 683         {\r
 684           I2C_TransferConfig(hi2c,DevAddress,Size, I2C_AUTOEND_MODE, I2C_NO_STARTSTOP);\r
 685           sizetmp = Size;\r
 686         }\r
 687       }\r
 688 \r
 689     }while(Size > 0);\r
 690     \r
 691     /* No need to Check TC flag, with AUTOEND mode the stop is automatically generated */\r
 692     /* Wait until STOPF flag is set */\r
 693     if(I2C_WaitOnSTOPFlagUntilTimeout(hi2c, I2C_TIMEOUT_STOPF) != HAL_OK)\r
 694     {\r
 695       if(hi2c->ErrorCode == HAL_I2C_ERROR_AF)\r
 696       {\r
 697         return HAL_ERROR;\r
 698       }\r
 699       else\r
 700       {\r
 701         return HAL_TIMEOUT;\r
 702       }\r
 703     }\r
 704     \r
 705     /* Clear STOP Flag */\r
 706     __HAL_I2C_CLEAR_FLAG(hi2c, I2C_FLAG_STOPF);\r
 707         \r
 708     /* Clear Configuration Register 2 */\r
 709     I2C_RESET_CR2(hi2c);\r
 710     \r
 711     hi2c->State = HAL_I2C_STATE_READY;    \r
 712     \r
 713     /* Process Unlocked */\r
 714     __HAL_UNLOCK(hi2c);\r
 715     \r
 716     return HAL_OK;\r
 717   }\r
 718   else\r
 719   {\r
 720     return HAL_BUSY; \r
 721   }\r
 722 }\r
 723 \r
 724 /**\r
 725   * @brief  Transmits in slave mode an amount of data in blocking mode. \r
 726   * @param  hi2c : Pointer to a I2C_HandleTypeDef structure that contains\r
 727   *                the configuration information for the specified I2C.\r
 728   * @param  pData: Pointer to data buffer\r
 729   * @param  Size: Amount of data to be sent\r
 730   * @param  Timeout: Timeout duration\r
 731   * @retval HAL status\r
 732   */\r
 733 HAL_StatusTypeDef HAL_I2C_Slave_Transmit(I2C_HandleTypeDef *hi2c, uint8_t *pData, uint16_t Size, uint32_t Timeout)\r
 734 {\r
 735   if(hi2c->State == HAL_I2C_STATE_READY)\r
 736   {    \r
 737     if((pData == NULL ) || (Size == 0)) \r
 738     {\r
 739       return  HAL_ERROR;                                    \r
 740     }\r
 741     \r
 742     /* Process Locked */\r
 743     __HAL_LOCK(hi2c);\r
 744     \r
 745     hi2c->State = HAL_I2C_STATE_SLAVE_BUSY_RX;\r
 746     hi2c->ErrorCode   = HAL_I2C_ERROR_NONE;\r
 747     \r
 748     /* Enable Address Acknowledge */\r
 749     hi2c->Instance->CR2 &= ~I2C_CR2_NACK;\r
 750 \r
 751     /* Wait until ADDR flag is set */\r
 752     if(I2C_WaitOnFlagUntilTimeout(hi2c, I2C_FLAG_ADDR, RESET, Timeout) != HAL_OK)      \r
 753     {\r
 754       /* Disable Address Acknowledge */\r
 755       hi2c->Instance->CR2 |= I2C_CR2_NACK;\r
 756       return HAL_TIMEOUT;\r
 757     }\r
 758     \r
 759     /* Clear ADDR flag */\r
 760     __HAL_I2C_CLEAR_FLAG(hi2c,I2C_FLAG_ADDR);\r
 761 \r
 762     /* If 10bit addressing mode is selected */\r
 763     if(hi2c->Init.AddressingMode == I2C_ADDRESSINGMODE_10BIT)\r
 764     {\r
 765       /* Wait until ADDR flag is set */\r
 766       if(I2C_WaitOnFlagUntilTimeout(hi2c, I2C_FLAG_ADDR, RESET, Timeout) != HAL_OK)      \r
 767       {\r
 768         /* Disable Address Acknowledge */\r
 769         hi2c->Instance->CR2 |= I2C_CR2_NACK;\r
 770         return HAL_TIMEOUT;\r
 771       }\r
 772     \r
 773       /* Clear ADDR flag */\r
 774       __HAL_I2C_CLEAR_FLAG(hi2c,I2C_FLAG_ADDR);\r
 775     }\r
 776 \r
 777     /* Wait until DIR flag is set Transmitter mode */\r
 778     if(I2C_WaitOnFlagUntilTimeout(hi2c, I2C_FLAG_DIR, RESET, Timeout) != HAL_OK)      \r
 779     {\r
 780       /* Disable Address Acknowledge */\r
 781       hi2c->Instance->CR2 |= I2C_CR2_NACK;\r
 782       return HAL_TIMEOUT;\r
 783     }\r
 784 \r
 785     do\r
 786     {\r
 787       /* Wait until TXIS flag is set */\r
 788       if(I2C_WaitOnTXISFlagUntilTimeout(hi2c, Timeout) != HAL_OK)\r
 789       {\r
 790         /* Disable Address Acknowledge */\r
 791         hi2c->Instance->CR2 |= I2C_CR2_NACK;\r
 792 \r
 793         if(hi2c->ErrorCode == HAL_I2C_ERROR_AF)\r
 794         {\r
 795           return HAL_ERROR;\r
 796         }\r
 797         else\r
 798         {\r
 799           return HAL_TIMEOUT;\r
 800         }\r
 801       }\r
 802       \r
 803       /* Read data from TXDR */\r
 804       hi2c->Instance->TXDR = (*pData++);\r
 805       Size--;\r
 806     }while(Size > 0);\r
 807     \r
 808     /* Wait until STOP flag is set */\r
 809     if(I2C_WaitOnSTOPFlagUntilTimeout(hi2c, I2C_TIMEOUT_STOPF) != HAL_OK)\r
 810     {\r
 811       /* Disable Address Acknowledge */\r
 812       hi2c->Instance->CR2 |= I2C_CR2_NACK;\r
 813 \r
 814       if(hi2c->ErrorCode == HAL_I2C_ERROR_AF)\r
 815       {\r
 816         /* Normal use case for Transmitter mode */\r
 817         /* A NACK is generated to confirm the end of transfer */\r
 818         hi2c->ErrorCode = HAL_I2C_ERROR_NONE;\r
 819       }\r
 820       else\r
 821       {\r
 822         return HAL_TIMEOUT;\r
 823       }\r
 824     }\r
 825     \r
 826     /* Clear STOP flag */\r
 827     __HAL_I2C_CLEAR_FLAG(hi2c,I2C_FLAG_STOPF);\r
 828     \r
 829     /* Wait until BUSY flag is reset */ \r
 830     if(I2C_WaitOnFlagUntilTimeout(hi2c, I2C_FLAG_BUSY, SET, Timeout) != HAL_OK)      \r
 831     {\r
 832       /* Disable Address Acknowledge */\r
 833       hi2c->Instance->CR2 |= I2C_CR2_NACK;\r
 834       return HAL_TIMEOUT;\r
 835     }\r
 836     \r
 837     /* Disable Address Acknowledge */\r
 838     hi2c->Instance->CR2 |= I2C_CR2_NACK;\r
 839 \r
 840     hi2c->State = HAL_I2C_STATE_READY;\r
 841     \r
 842     /* Process Unlocked */\r
 843     __HAL_UNLOCK(hi2c);\r
 844     \r
 845     return HAL_OK;\r
 846   }\r
 847   else\r
 848   {\r
 849     return HAL_BUSY; \r
 850   }\r
 851 }\r
 852 \r
 853 /**\r
 854   * @brief  Receive in slave mode an amount of data in blocking mode \r
 855   * @param  hi2c : Pointer to a I2C_HandleTypeDef structure that contains\r
 856   *                the configuration information for the specified I2C.\r
 857   * @param  pData: Pointer to data buffer\r
 858   * @param  Size: Amount of data to be sent\r
 859   * @param  Timeout: Timeout duration\r
 860   * @retval HAL status\r
 861   */\r
 862 HAL_StatusTypeDef HAL_I2C_Slave_Receive(I2C_HandleTypeDef *hi2c, uint8_t *pData, uint16_t Size, uint32_t Timeout)\r
 863 {\r
 864   if(hi2c->State == HAL_I2C_STATE_READY)\r
 865   {  \r
 866     if((pData == NULL ) || (Size == 0)) \r
 867     {\r
 868       return  HAL_ERROR;                                    \r
 869     }\r
 870     \r
 871     /* Process Locked */\r
 872     __HAL_LOCK(hi2c);\r
 873     \r
 874     hi2c->State = HAL_I2C_STATE_SLAVE_BUSY_RX;\r
 875     hi2c->ErrorCode   = HAL_I2C_ERROR_NONE;\r
 876     \r
 877     /* Enable Address Acknowledge */\r
 878     hi2c->Instance->CR2 &= ~I2C_CR2_NACK;\r
 879 \r
 880     /* Wait until ADDR flag is set */\r
 881     if(I2C_WaitOnFlagUntilTimeout(hi2c, I2C_FLAG_ADDR, RESET, Timeout) != HAL_OK)      \r
 882     {\r
 883       /* Disable Address Acknowledge */\r
 884       hi2c->Instance->CR2 |= I2C_CR2_NACK;\r
 885       return HAL_TIMEOUT;\r
 886     }\r
 887 \r
 888     /* Clear ADDR flag */\r
 889     __HAL_I2C_CLEAR_FLAG(hi2c,I2C_FLAG_ADDR);\r
 890     \r
 891     /* Wait until DIR flag is reset Receiver mode */\r
 892     if(I2C_WaitOnFlagUntilTimeout(hi2c, I2C_FLAG_DIR, SET, Timeout) != HAL_OK)      \r
 893     {\r
 894       /* Disable Address Acknowledge */\r
 895       hi2c->Instance->CR2 |= I2C_CR2_NACK;\r
 896       return HAL_TIMEOUT;\r
 897     }\r
 898 \r
 899     while(Size > 0)\r
 900     {\r
 901       /* Wait until RXNE flag is set */\r
 902       if(I2C_WaitOnRXNEFlagUntilTimeout(hi2c, Timeout) != HAL_OK)      \r
 903       {\r
 904         /* Disable Address Acknowledge */\r
 905         hi2c->Instance->CR2 |= I2C_CR2_NACK;\r
 906         if(hi2c->ErrorCode == HAL_I2C_ERROR_TIMEOUT)\r
 907         {\r
 908           return HAL_TIMEOUT;\r
 909         }\r
 910         else\r
 911         {\r
 912           return HAL_ERROR;\r
 913         }\r
 914       }\r
 915       \r
 916       /* Read data from RXDR */\r
 917       (*pData++) = hi2c->Instance->RXDR;\r
 918       Size--;\r
 919     }\r
 920     \r
 921     /* Wait until STOP flag is set */\r
 922     if(I2C_WaitOnSTOPFlagUntilTimeout(hi2c, I2C_TIMEOUT_STOPF) != HAL_OK)\r
 923     {\r
 924       /* Disable Address Acknowledge */\r
 925       hi2c->Instance->CR2 |= I2C_CR2_NACK;\r
 926 \r
 927       if(hi2c->ErrorCode == HAL_I2C_ERROR_AF)\r
 928       {\r
 929         return HAL_ERROR;\r
 930       }\r
 931       else\r
 932       {\r
 933         return HAL_TIMEOUT;\r
 934       }\r
 935     }\r
 936 \r
 937     /* Clear STOP flag */\r
 938     __HAL_I2C_CLEAR_FLAG(hi2c,I2C_FLAG_STOPF);\r
 939     \r
 940     /* Wait until BUSY flag is reset */ \r
 941     if(I2C_WaitOnFlagUntilTimeout(hi2c, I2C_FLAG_BUSY, SET, Timeout) != HAL_OK)      \r
 942     {\r
 943       /* Disable Address Acknowledge */\r
 944       hi2c->Instance->CR2 |= I2C_CR2_NACK;\r
 945       return HAL_TIMEOUT;\r
 946     }\r
 947 \r
 948     \r
 949     /* Disable Address Acknowledge */\r
 950     hi2c->Instance->CR2 |= I2C_CR2_NACK;\r
 951     \r
 952     hi2c->State = HAL_I2C_STATE_READY;\r
 953 \r
 954     /* Process Unlocked */\r
 955     __HAL_UNLOCK(hi2c);\r
 956     \r
 957     return HAL_OK;\r
 958   }\r
 959   else\r
 960   {\r
 961     return HAL_BUSY; \r
 962   } \r
 963 }\r
 964 \r
 965 /**\r
 966   * @brief  Transmit in master mode an amount of data in no-blocking mode with Interrupt\r
 967   * @param  hi2c : Pointer to a I2C_HandleTypeDef structure that contains\r
 968   *                the configuration information for the specified I2C.\r
 969   * @param  DevAddress: Target device address\r
 970   * @param  pData: Pointer to data buffer\r
 971   * @param  Size: Amount of data to be sent\r
 972   * @retval HAL status\r
 973   */\r
 974 HAL_StatusTypeDef HAL_I2C_Master_Transmit_IT(I2C_HandleTypeDef *hi2c, uint16_t DevAddress, uint8_t *pData, uint16_t Size)\r
 975 {   \r
 976   if(hi2c->State == HAL_I2C_STATE_READY)\r
 977   {\r
 978     if((pData == NULL) || (Size == 0)) \r
 979     {\r
 980       return  HAL_ERROR;                                    \r
 981     }\r
 982     \r
 983     if(__HAL_I2C_GET_FLAG(hi2c, I2C_FLAG_BUSY) == SET)\r
 984     {\r
 985       return HAL_BUSY;\r
 986     }\r
 987 \r
 988     /* Process Locked */\r
 989     __HAL_LOCK(hi2c);\r
 990     \r
 991     hi2c->State = HAL_I2C_STATE_MASTER_BUSY_TX;\r
 992     hi2c->ErrorCode   = HAL_I2C_ERROR_NONE;\r
 993     \r
 994     hi2c->pBuffPtr = pData;\r
 995     hi2c->XferCount = Size;\r
 996     if(Size > 255)\r
 997     {\r
 998       hi2c->XferSize = 255;\r
 999     }\r
1000     else\r
1001     {\r
1002       hi2c->XferSize = Size;\r
1003     }\r
1004     \r
1005     /* Send Slave Address */\r
1006     /* Set NBYTES to write and reload if size > 255 and generate RESTART */\r
1007     if( (hi2c->XferSize == 255) && (hi2c->XferSize < hi2c->XferCount) )\r
1008     {\r
1009       I2C_TransferConfig(hi2c,DevAddress,hi2c->XferSize, I2C_RELOAD_MODE, I2C_GENERATE_START_WRITE);\r
1010     }\r
1011     else\r
1012     {\r
1013       I2C_TransferConfig(hi2c,DevAddress,hi2c->XferSize, I2C_AUTOEND_MODE, I2C_GENERATE_START_WRITE);\r
1014     }\r
1015     \r
1016     /* Process Unlocked */\r
1017     __HAL_UNLOCK(hi2c); \r
1018 \r
1019     /* Note : The I2C interrupts must be enabled after unlocking current process \r
1020               to avoid the risk of I2C interrupt handle execution before current\r
1021               process unlock */\r
1022 \r
1023 \r
1024     /* Enable ERR, TC, STOP, NACK, TXI interrupt */\r
1025     /* possible to enable all of these */\r
1026     /* I2C_IT_ERRI | I2C_IT_TCI| I2C_IT_STOPI| I2C_IT_NACKI | I2C_IT_ADDRI | I2C_IT_RXI | I2C_IT_TXI */\r
1027     __HAL_I2C_ENABLE_IT(hi2c,I2C_IT_ERRI | I2C_IT_TCI| I2C_IT_STOPI| I2C_IT_NACKI | I2C_IT_TXI );\r
1028         \r
1029     return HAL_OK;\r
1030   }\r
1031   else\r
1032   {\r
1033     return HAL_BUSY;\r
1034   } \r
1035 }\r
1036 \r
1037 /**\r
1038   * @brief  Receive in master mode an amount of data in no-blocking mode with Interrupt\r
1039   * @param  hi2c : Pointer to a I2C_HandleTypeDef structure that contains\r
1040   *                the configuration information for the specified I2C.\r
1041   * @param  DevAddress: Target device address\r
1042   * @param  pData: Pointer to data buffer\r
1043   * @param  Size: Amount of data to be sent\r
1044   * @retval HAL status\r
1045   */\r
1046 HAL_StatusTypeDef HAL_I2C_Master_Receive_IT(I2C_HandleTypeDef *hi2c, uint16_t DevAddress, uint8_t *pData, uint16_t Size)\r
1047 {\r
1048   if(hi2c->State == HAL_I2C_STATE_READY)\r
1049   {\r
1050     if((pData == NULL) || (Size == 0)) \r
1051     {\r
1052       return  HAL_ERROR;                                    \r
1053     }\r
1054     \r
1055     if(__HAL_I2C_GET_FLAG(hi2c, I2C_FLAG_BUSY) == SET)\r
1056     {\r
1057       return HAL_BUSY;\r
1058     }\r
1059 \r
1060     /* Process Locked */\r
1061     __HAL_LOCK(hi2c);\r
1062     \r
1063     hi2c->State = HAL_I2C_STATE_MASTER_BUSY_RX;\r
1064     hi2c->ErrorCode   = HAL_I2C_ERROR_NONE;\r
1065     \r
1066     hi2c->pBuffPtr = pData;\r
1067     hi2c->XferCount = Size;\r
1068     if(Size > 255)\r
1069     {\r
1070       hi2c->XferSize = 255;\r
1071     }\r
1072     else\r
1073     {\r
1074       hi2c->XferSize = Size;\r
1075     }\r
1076     \r
1077     /* Send Slave Address */\r
1078     /* Set NBYTES to write and reload if size > 255 and generate RESTART */\r
1079     if( (hi2c->XferSize == 255) && (hi2c->XferSize < hi2c->XferCount) )\r
1080     {\r
1081       I2C_TransferConfig(hi2c,DevAddress,hi2c->XferSize, I2C_RELOAD_MODE, I2C_GENERATE_START_READ);\r
1082     }\r
1083     else\r
1084     {\r
1085       I2C_TransferConfig(hi2c,DevAddress,hi2c->XferSize, I2C_AUTOEND_MODE, I2C_GENERATE_START_READ);\r
1086     }\r
1087     \r
1088     /* Process Unlocked */\r
1089     __HAL_UNLOCK(hi2c); \r
1090 \r
1091     /* Note : The I2C interrupts must be enabled after unlocking current process \r
1092               to avoid the risk of I2C interrupt handle execution before current\r
1093               process unlock */\r
1094     \r
1095     /* Enable ERR, TC, STOP, NACK, RXI interrupt */\r
1096     /* possible to enable all of these */\r
1097     /* I2C_IT_ERRI | I2C_IT_TCI| I2C_IT_STOPI| I2C_IT_NACKI | I2C_IT_ADDRI | I2C_IT_RXI | I2C_IT_TXI */\r
1098     __HAL_I2C_ENABLE_IT(hi2c,I2C_IT_ERRI | I2C_IT_TCI | I2C_IT_STOPI | I2C_IT_NACKI | I2C_IT_RXI );\r
1099     \r
1100     return HAL_OK;\r
1101   }\r
1102   else\r
1103   {\r
1104     return HAL_BUSY; \r
1105   } \r
1106 }\r
1107 \r
1108 /**\r
1109   * @brief  Transmit in slave mode an amount of data in no-blocking mode with Interrupt \r
1110   * @param  hi2c : Pointer to a I2C_HandleTypeDef structure that contains\r
1111   *                the configuration information for the specified I2C.\r
1112   * @param  pData: Pointer to data buffer\r
1113   * @param  Size: Amount of data to be sent\r
1114   * @retval HAL status\r
1115   */\r
1116 HAL_StatusTypeDef HAL_I2C_Slave_Transmit_IT(I2C_HandleTypeDef *hi2c, uint8_t *pData, uint16_t Size)\r
1117 {\r
1118   if(hi2c->State == HAL_I2C_STATE_READY)\r
1119   {\r
1120     if((pData == NULL) || (Size == 0)) \r
1121     {\r
1122       return  HAL_ERROR;                                    \r
1123     }\r
1124     \r
1125     /* Process Locked */\r
1126     __HAL_LOCK(hi2c);\r
1127     \r
1128     hi2c->State = HAL_I2C_STATE_SLAVE_BUSY_TX;\r
1129     hi2c->ErrorCode   = HAL_I2C_ERROR_NONE;\r
1130     \r
1131     /* Enable Address Acknowledge */\r
1132     hi2c->Instance->CR2 &= ~I2C_CR2_NACK;\r
1133 \r
1134     hi2c->pBuffPtr = pData;\r
1135     hi2c->XferSize = Size;\r
1136     hi2c->XferCount = Size;\r
1137     \r
1138     /* Process Unlocked */\r
1139     __HAL_UNLOCK(hi2c); \r
1140 \r
1141     /* Note : The I2C interrupts must be enabled after unlocking current process \r
1142               to avoid the risk of I2C interrupt handle execution before current\r
1143               process unlock */\r
1144     \r
1145     /* Enable ERR, TC, STOP, NACK, TXI interrupt */\r
1146     /* possible to enable all of these */\r
1147     /* I2C_IT_ERRI | I2C_IT_TCI| I2C_IT_STOPI| I2C_IT_NACKI | I2C_IT_ADDRI | I2C_IT_RXI | I2C_IT_TXI */\r
1148     __HAL_I2C_ENABLE_IT(hi2c,I2C_IT_ERRI | I2C_IT_TCI| I2C_IT_STOPI | I2C_IT_NACKI | I2C_IT_ADDRI | I2C_IT_TXI );\r
1149     \r
1150     return HAL_OK;\r
1151   }\r
1152   else\r
1153   {\r
1154     return HAL_BUSY; \r
1155   } \r
1156 }\r
1157 \r
1158 /**\r
1159   * @brief  Receive in slave mode an amount of data in no-blocking mode with Interrupt \r
1160   * @param  hi2c : Pointer to a I2C_HandleTypeDef structure that contains\r
1161   *                the configuration information for the specified I2C.\r
1162   * @param  pData: Pointer to data buffer\r
1163   * @param  Size: Amount of data to be sent\r
1164   * @retval HAL status\r
1165   */\r
1166 HAL_StatusTypeDef HAL_I2C_Slave_Receive_IT(I2C_HandleTypeDef *hi2c, uint8_t *pData, uint16_t Size)\r
1167 {\r
1168   if(hi2c->State == HAL_I2C_STATE_READY)\r
1169   {\r
1170     if((pData == NULL) || (Size == 0)) \r
1171     {\r
1172       return  HAL_ERROR;                                    \r
1173     }\r
1174     \r
1175     /* Process Locked */\r
1176     __HAL_LOCK(hi2c);\r
1177     \r
1178     hi2c->State = HAL_I2C_STATE_SLAVE_BUSY_RX;\r
1179     hi2c->ErrorCode   = HAL_I2C_ERROR_NONE;\r
1180     \r
1181     /* Enable Address Acknowledge */\r
1182     hi2c->Instance->CR2 &= ~I2C_CR2_NACK;\r
1183 \r
1184     hi2c->pBuffPtr = pData;\r
1185     hi2c->XferSize = Size;\r
1186     hi2c->XferCount = Size;\r
1187     \r
1188     /* Process Unlocked */\r
1189     __HAL_UNLOCK(hi2c); \r
1190 \r
1191     /* Note : The I2C interrupts must be enabled after unlocking current process \r
1192               to avoid the risk of I2C interrupt handle execution before current\r
1193               process unlock */\r
1194     \r
1195     /* Enable ERR, TC, STOP, NACK, RXI interrupt */\r
1196     /* possible to enable all of these */\r
1197     /* I2C_IT_ERRI | I2C_IT_TCI| I2C_IT_STOPI| I2C_IT_NACKI | I2C_IT_ADDRI | I2C_IT_RXI | I2C_IT_TXI */\r
1198     __HAL_I2C_ENABLE_IT(hi2c,I2C_IT_ERRI | I2C_IT_TCI | I2C_IT_STOPI | I2C_IT_NACKI | I2C_IT_ADDRI | I2C_IT_RXI);\r
1199     \r
1200     return HAL_OK;\r
1201   }\r
1202   else\r
1203   {\r
1204     return HAL_BUSY; \r
1205   }\r
1206 }\r
1207 \r
1208 /**\r
1209   * @brief  Transmit in master mode an amount of data in no-blocking mode with DMA\r
1210   * @param  hi2c : Pointer to a I2C_HandleTypeDef structure that contains\r
1211   *                the configuration information for the specified I2C.\r
1212   * @param  DevAddress: Target device address\r
1213   * @param  pData: Pointer to data buffer\r
1214   * @param  Size: Amount of data to be sent\r
1215   * @retval HAL status\r
1216   */\r
1217 HAL_StatusTypeDef HAL_I2C_Master_Transmit_DMA(I2C_HandleTypeDef *hi2c, uint16_t DevAddress, uint8_t *pData, uint16_t Size)\r
1218 {\r
1219   if(hi2c->State == HAL_I2C_STATE_READY)\r
1220   {\r
1221     if((pData == NULL) || (Size == 0)) \r
1222     {\r
1223       return  HAL_ERROR;                                    \r
1224     }     \r
1225 \r
1226     if(__HAL_I2C_GET_FLAG(hi2c, I2C_FLAG_BUSY) == SET)\r
1227     {\r
1228       return HAL_BUSY;\r
1229     }\r
1230 \r
1231     /* Process Locked */\r
1232     __HAL_LOCK(hi2c);\r
1233     \r
1234     hi2c->State = HAL_I2C_STATE_MASTER_BUSY_TX;\r
1235     hi2c->ErrorCode   = HAL_I2C_ERROR_NONE;\r
1236     \r
1237     hi2c->pBuffPtr = pData;\r
1238     hi2c->XferCount = Size;\r
1239     if(Size > 255)\r
1240     {\r
1241       hi2c->XferSize = 255;\r
1242     }\r
1243     else\r
1244     {\r
1245       hi2c->XferSize = Size;\r
1246     }\r
1247     \r
1248     /* Set the I2C DMA transfer complete callback */\r
1249     hi2c->hdmatx->XferCpltCallback = I2C_DMAMasterTransmitCplt;\r
1250     \r
1251     /* Set the DMA error callback */\r
1252     hi2c->hdmatx->XferErrorCallback = I2C_DMAError;\r
1253     \r
1254     /* Enable the DMA channel */\r
1255     HAL_DMA_Start_IT(hi2c->hdmatx, (uint32_t)pData, (uint32_t)&hi2c->Instance->TXDR, hi2c->XferSize);\r
1256     \r
1257     /* Send Slave Address */\r
1258     /* Set NBYTES to write and reload if size > 255 and generate RESTART */\r
1259     if( (hi2c->XferSize == 255) && (hi2c->XferSize < hi2c->XferCount) )\r
1260     {\r
1261       I2C_TransferConfig(hi2c,DevAddress,hi2c->XferSize, I2C_RELOAD_MODE, I2C_GENERATE_START_WRITE);\r
1262     }\r
1263     else\r
1264     {\r
1265       I2C_TransferConfig(hi2c,DevAddress,hi2c->XferSize, I2C_AUTOEND_MODE, I2C_GENERATE_START_WRITE);\r
1266     }  \r
1267 \r
1268     /* Wait until TXIS flag is set */\r
1269     if(I2C_WaitOnTXISFlagUntilTimeout(hi2c, I2C_TIMEOUT_TXIS) != HAL_OK)\r
1270     {\r
1271       /* Disable Address Acknowledge */\r
1272       hi2c->Instance->CR2 |= I2C_CR2_NACK;\r
1273 \r
1274       if(hi2c->ErrorCode == HAL_I2C_ERROR_AF)\r
1275       {\r
1276         return HAL_ERROR;\r
1277       }\r
1278       else\r
1279       {\r
1280         return HAL_TIMEOUT;\r
1281       }\r
1282     }\r
1283 \r
1284     \r
1285     /* Enable DMA Request */\r
1286     hi2c->Instance->CR1 |= I2C_CR1_TXDMAEN;   \r
1287     \r
1288     /* Process Unlocked */\r
1289     __HAL_UNLOCK(hi2c);\r
1290     \r
1291     return HAL_OK;\r
1292   }\r
1293   else\r
1294   {\r
1295     return HAL_BUSY;\r
1296   }\r
1297 }\r
1298 \r
1299 /**\r
1300   * @brief  Receive in master mode an amount of data in no-blocking mode with DMA \r
1301   * @param  hi2c : Pointer to a I2C_HandleTypeDef structure that contains\r
1302   *                the configuration information for the specified I2C.\r
1303   * @param  DevAddress: Target device address\r
1304   * @param  pData: Pointer to data buffer\r
1305   * @param  Size: Amount of data to be sent\r
1306   * @retval HAL status\r
1307   */\r
1308 HAL_StatusTypeDef HAL_I2C_Master_Receive_DMA(I2C_HandleTypeDef *hi2c, uint16_t DevAddress, uint8_t *pData, uint16_t Size)\r
1309 {\r
1310   if(hi2c->State == HAL_I2C_STATE_READY)\r
1311   {\r
1312     if((pData == NULL) || (Size == 0)) \r
1313     {\r
1314       return  HAL_ERROR;                                    \r
1315     }  \r
1316 \r
1317     if(__HAL_I2C_GET_FLAG(hi2c, I2C_FLAG_BUSY) == SET)\r
1318     {\r
1319       return HAL_BUSY;\r
1320     }\r
1321 \r
1322     /* Process Locked */\r
1323     __HAL_LOCK(hi2c);\r
1324     \r
1325     hi2c->State = HAL_I2C_STATE_MASTER_BUSY_RX;\r
1326     hi2c->ErrorCode   = HAL_I2C_ERROR_NONE;\r
1327     \r
1328     hi2c->pBuffPtr = pData;\r
1329     hi2c->XferCount = Size;\r
1330     if(Size > 255)\r
1331     {\r
1332       hi2c->XferSize = 255;\r
1333     }\r
1334     else\r
1335     {\r
1336       hi2c->XferSize = Size;\r
1337     }\r
1338     \r
1339     /* Set the I2C DMA transfer complete callback */\r
1340     hi2c->hdmarx->XferCpltCallback = I2C_DMAMasterReceiveCplt;\r
1341     \r
1342     /* Set the DMA error callback */\r
1343     hi2c->hdmarx->XferErrorCallback = I2C_DMAError;\r
1344     \r
1345     /* Enable the DMA channel */\r
1346     HAL_DMA_Start_IT(hi2c->hdmarx, (uint32_t)&hi2c->Instance->RXDR, (uint32_t)pData, hi2c->XferSize);\r
1347     \r
1348     /* Send Slave Address */\r
1349     /* Set NBYTES to write and reload if size > 255 and generate RESTART */\r
1350     if( (hi2c->XferSize == 255) && (hi2c->XferSize < hi2c->XferCount) )\r
1351     {\r
1352       I2C_TransferConfig(hi2c,DevAddress,hi2c->XferSize, I2C_RELOAD_MODE, I2C_GENERATE_START_READ);\r
1353     }\r
1354     else\r
1355     {\r
1356       I2C_TransferConfig(hi2c,DevAddress,hi2c->XferSize, I2C_AUTOEND_MODE, I2C_GENERATE_START_READ);\r
1357     }\r
1358 \r
1359     /* Wait until RXNE flag is set */\r
1360     if(I2C_WaitOnFlagUntilTimeout(hi2c, I2C_FLAG_RXNE, RESET, I2C_TIMEOUT_RXNE) != HAL_OK)      \r
1361     {\r
1362       return HAL_TIMEOUT;\r
1363     }\r
1364 \r
1365     \r
1366     /* Enable DMA Request */\r
1367     hi2c->Instance->CR1 |= I2C_CR1_RXDMAEN;   \r
1368     \r
1369     /* Process Unlocked */\r
1370     __HAL_UNLOCK(hi2c);\r
1371     \r
1372     return HAL_OK;\r
1373   }\r
1374   else\r
1375   {\r
1376     return HAL_BUSY;\r
1377   }\r
1378 }\r
1379 \r
1380 /**\r
1381   * @brief  Transmit in slave mode an amount of data in no-blocking mode with DMA \r
1382   * @param  hi2c : Pointer to a I2C_HandleTypeDef structure that contains\r
1383   *                the configuration information for the specified I2C.\r
1384   * @param  pData: Pointer to data buffer\r
1385   * @param  Size: Amount of data to be sent\r
1386   * @retval HAL status\r
1387   */\r
1388 HAL_StatusTypeDef HAL_I2C_Slave_Transmit_DMA(I2C_HandleTypeDef *hi2c, uint8_t *pData, uint16_t Size)\r
1389 {\r
1390   if(hi2c->State == HAL_I2C_STATE_READY)\r
1391   {\r
1392     if((pData == NULL) || (Size == 0)) \r
1393     {\r
1394       return  HAL_ERROR;                                    \r
1395     }   \r
1396     /* Process Locked */\r
1397     __HAL_LOCK(hi2c); \r
1398     \r
1399     hi2c->State = HAL_I2C_STATE_SLAVE_BUSY_TX;\r
1400     hi2c->ErrorCode   = HAL_I2C_ERROR_NONE;\r
1401     \r
1402     hi2c->pBuffPtr = pData;\r
1403     hi2c->XferCount = Size;\r
1404     hi2c->XferSize = Size;\r
1405     \r
1406     /* Set the I2C DMA transfer complete callback */\r
1407     hi2c->hdmatx->XferCpltCallback = I2C_DMASlaveTransmitCplt;\r
1408     \r
1409     /* Set the DMA error callback */\r
1410     hi2c->hdmatx->XferErrorCallback = I2C_DMAError;\r
1411     \r
1412     /* Enable the DMA channel */\r
1413     HAL_DMA_Start_IT(hi2c->hdmatx, (uint32_t)pData, (uint32_t)&hi2c->Instance->TXDR, hi2c->XferSize);\r
1414     \r
1415     /* Enable Address Acknowledge */\r
1416     hi2c->Instance->CR2 &= ~I2C_CR2_NACK;\r
1417 \r
1418     /* Wait until ADDR flag is set */\r
1419     if(I2C_WaitOnFlagUntilTimeout(hi2c, I2C_FLAG_ADDR, RESET, I2C_TIMEOUT_ADDR) != HAL_OK)      \r
1420     {\r
1421       /* Disable Address Acknowledge */\r
1422       hi2c->Instance->CR2 |= I2C_CR2_NACK;\r
1423       return HAL_TIMEOUT;\r
1424     }\r
1425 \r
1426     /* Clear ADDR flag */\r
1427     __HAL_I2C_CLEAR_FLAG(hi2c,I2C_FLAG_ADDR);\r
1428     \r
1429     /* If 10bits addressing mode is selected */\r
1430     if(hi2c->Init.AddressingMode == I2C_ADDRESSINGMODE_10BIT)\r
1431     {\r
1432       /* Wait until ADDR flag is set */\r
1433       if(I2C_WaitOnFlagUntilTimeout(hi2c, I2C_FLAG_ADDR, RESET, I2C_TIMEOUT_ADDR) != HAL_OK)      \r
1434       {\r
1435         /* Disable Address Acknowledge */\r
1436         hi2c->Instance->CR2 |= I2C_CR2_NACK;\r
1437         return HAL_TIMEOUT;\r
1438       }\r
1439 \r
1440       /* Clear ADDR flag */\r
1441       __HAL_I2C_CLEAR_FLAG(hi2c,I2C_FLAG_ADDR);\r
1442     }\r
1443     \r
1444     /* Wait until DIR flag is set Transmitter mode */\r
1445     if(I2C_WaitOnFlagUntilTimeout(hi2c, I2C_FLAG_DIR, RESET, I2C_TIMEOUT_BUSY) != HAL_OK)      \r
1446     {\r
1447       /* Disable Address Acknowledge */\r
1448       hi2c->Instance->CR2 |= I2C_CR2_NACK;\r
1449       return HAL_TIMEOUT;\r
1450     }\r
1451       \r
1452     /* Enable DMA Request */\r
1453     hi2c->Instance->CR1 |= I2C_CR1_TXDMAEN; \r
1454     \r
1455     /* Process Unlocked */\r
1456     __HAL_UNLOCK(hi2c);\r
1457     \r
1458     return HAL_OK;\r
1459   }\r
1460   else\r
1461   {\r
1462     return HAL_BUSY;\r
1463   }\r
1464 }\r
1465 \r
1466 /**\r
1467   * @brief  Receive in slave mode an amount of data in no-blocking mode with DMA \r
1468   * @param  hi2c : Pointer to a I2C_HandleTypeDef structure that contains\r
1469   *                the configuration information for the specified I2C.\r
1470   * @param  pData: Pointer to data buffer\r
1471   * @param  Size: Amount of data to be sent\r
1472   * @retval HAL status\r
1473   */\r
1474 HAL_StatusTypeDef HAL_I2C_Slave_Receive_DMA(I2C_HandleTypeDef *hi2c, uint8_t *pData, uint16_t Size)\r
1475 {\r
1476   if(hi2c->State == HAL_I2C_STATE_READY)\r
1477   {\r
1478     if((pData == NULL) || (Size == 0)) \r
1479     {\r
1480       return  HAL_ERROR;                                    \r
1481     }   \r
1482     /* Process Locked */\r
1483     __HAL_LOCK(hi2c);\r
1484     \r
1485     hi2c->State = HAL_I2C_STATE_SLAVE_BUSY_RX;\r
1486     hi2c->ErrorCode   = HAL_I2C_ERROR_NONE;\r
1487     \r
1488     hi2c->pBuffPtr = pData;\r
1489     hi2c->XferSize = Size;\r
1490     hi2c->XferCount = Size;\r
1491     \r
1492     /* Set the I2C DMA transfer complete callback */\r
1493     hi2c->hdmarx->XferCpltCallback = I2C_DMASlaveReceiveCplt;\r
1494     \r
1495     /* Set the DMA error callback */\r
1496     hi2c->hdmarx->XferErrorCallback = I2C_DMAError;\r
1497     \r
1498     /* Enable the DMA channel */\r
1499     HAL_DMA_Start_IT(hi2c->hdmarx, (uint32_t)&hi2c->Instance->RXDR, (uint32_t)pData, Size);\r
1500     \r
1501     /* Enable Address Acknowledge */\r
1502     hi2c->Instance->CR2 &= ~I2C_CR2_NACK;\r
1503 \r
1504     /* Wait until ADDR flag is set */\r
1505     if(I2C_WaitOnFlagUntilTimeout(hi2c, I2C_FLAG_ADDR, RESET, I2C_TIMEOUT_ADDR) != HAL_OK)      \r
1506     {\r
1507       /* Disable Address Acknowledge */\r
1508       hi2c->Instance->CR2 |= I2C_CR2_NACK;\r
1509       return HAL_TIMEOUT;\r
1510     }\r
1511 \r
1512     /* Clear ADDR flag */\r
1513     __HAL_I2C_CLEAR_FLAG(hi2c,I2C_FLAG_ADDR);\r
1514     \r
1515     /* Wait until DIR flag is set Receiver mode */\r
1516     if(I2C_WaitOnFlagUntilTimeout(hi2c, I2C_FLAG_DIR, SET, I2C_TIMEOUT_DIR) != HAL_OK)      \r
1517     {\r
1518       /* Disable Address Acknowledge */\r
1519       hi2c->Instance->CR2 |= I2C_CR2_NACK;\r
1520       return HAL_TIMEOUT;\r
1521     }\r
1522  \r
1523     /* Enable DMA Request */\r
1524     hi2c->Instance->CR1 |= I2C_CR1_RXDMAEN;  \r
1525     \r
1526     /* Process Unlocked */\r
1527     __HAL_UNLOCK(hi2c);\r
1528     \r
1529     return HAL_OK;\r
1530   }\r
1531   else\r
1532   {\r
1533     return HAL_BUSY;\r
1534   }\r
1535 }\r
1536 /**\r
1537   * @brief  Write an amount of data in blocking mode to a specific memory address\r
1538   * @param  hi2c : Pointer to a I2C_HandleTypeDef structure that contains\r
1539   *                the configuration information for the specified I2C.\r
1540   * @param  DevAddress: Target device address\r
1541   * @param  MemAddress: Internal memory address\r
1542   * @param  MemAddSize: Size of internal memory address\r
1543   * @param  pData: Pointer to data buffer\r
1544   * @param  Size: Amount of data to be sent\r
1545   * @param  Timeout: Timeout duration\r
1546   * @retval HAL status\r
1547   */\r
1548 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)\r
1549 {\r
1550   uint32_t Sizetmp = 0;\r
1551 \r
1552   /* Check the parameters */\r
1553   assert_param(IS_I2C_MEMADD_SIZE(MemAddSize));\r
1554   \r
1555   if(hi2c->State == HAL_I2C_STATE_READY)\r
1556   { \r
1557     if((pData == NULL) || (Size == 0)) \r
1558     {\r
1559       return  HAL_ERROR;                                    \r
1560     }\r
1561 \r
1562     if(__HAL_I2C_GET_FLAG(hi2c, I2C_FLAG_BUSY) == SET)\r
1563     {\r
1564       return HAL_BUSY;\r
1565     }\r
1566 \r
1567     /* Process Locked */\r
1568     __HAL_LOCK(hi2c);\r
1569     \r
1570     hi2c->State = HAL_I2C_STATE_MEM_BUSY_TX;\r
1571     hi2c->ErrorCode = HAL_I2C_ERROR_NONE;\r
1572     \r
1573     /* Send Slave Address and Memory Address */\r
1574     if(I2C_RequestMemoryWrite(hi2c, DevAddress, MemAddress, MemAddSize, Timeout) != HAL_OK)\r
1575     {\r
1576       if(hi2c->ErrorCode == HAL_I2C_ERROR_AF)\r
1577       {\r
1578         /* Process Unlocked */\r
1579         __HAL_UNLOCK(hi2c);\r
1580         return HAL_ERROR;\r
1581       }\r
1582       else\r
1583       {\r
1584         /* Process Unlocked */\r
1585         __HAL_UNLOCK(hi2c);\r
1586         return HAL_TIMEOUT;\r
1587       }\r
1588     }\r
1589 \r
1590     /* Set NBYTES to write and reload if size > 255 */\r
1591     /* Size > 255, need to set RELOAD bit */\r
1592     if(Size > 255)\r
1593     {\r
1594       I2C_TransferConfig(hi2c,DevAddress,255, I2C_RELOAD_MODE, I2C_NO_STARTSTOP);\r
1595       Sizetmp = 255;\r
1596     }\r
1597     else\r
1598     {\r
1599       I2C_TransferConfig(hi2c,DevAddress,Size, I2C_AUTOEND_MODE, I2C_NO_STARTSTOP);\r
1600       Sizetmp = Size;\r
1601     }\r
1602     \r
1603     do\r
1604     {\r
1605       /* Wait until TXIS flag is set */\r
1606       if(I2C_WaitOnTXISFlagUntilTimeout(hi2c, Timeout) != HAL_OK)\r
1607       {\r
1608         if(hi2c->ErrorCode == HAL_I2C_ERROR_AF)\r
1609         {\r
1610           return HAL_ERROR;\r
1611         }\r
1612         else\r
1613         {\r
1614           return HAL_TIMEOUT;\r
1615         }\r
1616       }\r
1617      \r
1618       /* Write data to DR */\r
1619       hi2c->Instance->TXDR = (*pData++);\r
1620       Sizetmp--;\r
1621       Size--;\r
1622 \r
1623       if((Sizetmp == 0)&&(Size!=0))\r
1624       {\r
1625         /* Wait until TCR flag is set */\r
1626         if(I2C_WaitOnFlagUntilTimeout(hi2c, I2C_FLAG_TCR, RESET, Timeout) != HAL_OK)      \r
1627         {\r
1628           return HAL_TIMEOUT;\r
1629         }\r
1630 \r
1631         \r
1632         if(Size > 255)\r
1633         {\r
1634           I2C_TransferConfig(hi2c,DevAddress,255, I2C_RELOAD_MODE, I2C_NO_STARTSTOP);\r
1635           Sizetmp = 255;\r
1636         }\r
1637         else\r
1638         {\r
1639           I2C_TransferConfig(hi2c,DevAddress,Size, I2C_AUTOEND_MODE, I2C_NO_STARTSTOP);\r
1640           Sizetmp = Size;\r
1641         }\r
1642       }\r
1643       \r
1644     }while(Size > 0);\r
1645     \r
1646     /* No need to Check TC flag, with AUTOEND mode the stop is automatically generated */\r
1647     /* Wait until STOPF flag is reset */ \r
1648     if(I2C_WaitOnSTOPFlagUntilTimeout(hi2c, I2C_TIMEOUT_STOPF) != HAL_OK)\r
1649     {\r
1650       if(hi2c->ErrorCode == HAL_I2C_ERROR_AF)\r
1651       {\r
1652         return HAL_ERROR;\r
1653       }\r
1654       else\r
1655       {\r
1656         return HAL_TIMEOUT;\r
1657       }\r
1658     }\r
1659     \r
1660     /* Clear STOP Flag */\r
1661     __HAL_I2C_CLEAR_FLAG(hi2c, I2C_FLAG_STOPF);\r
1662         \r
1663     /* Clear Configuration Register 2 */\r
1664     I2C_RESET_CR2(hi2c);\r
1665 \r
1666     hi2c->State = HAL_I2C_STATE_READY;    \r
1667     \r
1668     /* Process Unlocked */\r
1669     __HAL_UNLOCK(hi2c);\r
1670     \r
1671     return HAL_OK;\r
1672   }\r
1673   else\r
1674   {\r
1675     return HAL_BUSY;\r
1676   }\r
1677 }\r
1678 \r
1679 /**\r
1680   * @brief  Read an amount of data in blocking mode from a specific memory address\r
1681   * @param  hi2c : Pointer to a I2C_HandleTypeDef structure that contains\r
1682   *                the configuration information for the specified I2C.\r
1683   * @param  DevAddress: Target device address\r
1684   * @param  MemAddress: Internal memory address\r
1685   * @param  MemAddSize: Size of internal memory address\r
1686   * @param  pData: Pointer to data buffer\r
1687   * @param  Size: Amount of data to be sent\r
1688   * @param  Timeout: Timeout duration\r
1689   * @retval HAL status\r
1690   */\r
1691 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)\r
1692 {\r
1693   uint32_t Sizetmp = 0;\r
1694 \r
1695   /* Check the parameters */\r
1696   assert_param(IS_I2C_MEMADD_SIZE(MemAddSize));\r
1697   \r
1698   if(hi2c->State == HAL_I2C_STATE_READY)\r
1699   {    \r
1700     if((pData == NULL) || (Size == 0)) \r
1701     {\r
1702       return  HAL_ERROR;                                    \r
1703     }\r
1704 \r
1705     if(__HAL_I2C_GET_FLAG(hi2c, I2C_FLAG_BUSY) == SET)\r
1706     {\r
1707       return HAL_BUSY;\r
1708     }\r
1709 \r
1710     /* Process Locked */\r
1711     __HAL_LOCK(hi2c);\r
1712     \r
1713     hi2c->State = HAL_I2C_STATE_MEM_BUSY_RX;\r
1714     hi2c->ErrorCode = HAL_I2C_ERROR_NONE;\r
1715     \r
1716     /* Send Slave Address and Memory Address */\r
1717     if(I2C_RequestMemoryRead(hi2c, DevAddress, MemAddress, MemAddSize, Timeout) != HAL_OK)\r
1718     {\r
1719       if(hi2c->ErrorCode == HAL_I2C_ERROR_AF)\r
1720       {\r
1721         /* Process Unlocked */\r
1722         __HAL_UNLOCK(hi2c);\r
1723         return HAL_ERROR;\r
1724       }\r
1725       else\r
1726       {\r
1727         /* Process Unlocked */\r
1728         __HAL_UNLOCK(hi2c);\r
1729         return HAL_TIMEOUT;\r
1730       }\r
1731     }\r
1732 \r
1733     /* Send Slave Address */\r
1734     /* Set NBYTES to write and reload if size > 255 and generate RESTART */\r
1735     /* Size > 255, need to set RELOAD bit */\r
1736     if(Size > 255)\r
1737     {\r
1738       I2C_TransferConfig(hi2c,DevAddress,255, I2C_RELOAD_MODE, I2C_GENERATE_START_READ);\r
1739       Sizetmp = 255;\r
1740     }\r
1741     else\r
1742     {\r
1743       I2C_TransferConfig(hi2c,DevAddress,Size, I2C_AUTOEND_MODE, I2C_GENERATE_START_READ);\r
1744       Sizetmp = Size;\r
1745     }\r
1746     \r
1747     do\r
1748     {  \r
1749       /* Wait until RXNE flag is set */\r
1750       if(I2C_WaitOnFlagUntilTimeout(hi2c, I2C_FLAG_RXNE, RESET, Timeout) != HAL_OK)      \r
1751       {\r
1752         return HAL_TIMEOUT;\r
1753       }\r
1754           \r
1755       /* Read data from RXDR */\r
1756       (*pData++) = hi2c->Instance->RXDR;\r
1757 \r
1758       /* Decrement the Size counter */\r
1759       Sizetmp--;\r
1760       Size--;   \r
1761 \r
1762       if((Sizetmp == 0)&&(Size!=0))\r
1763       {\r
1764         /* Wait until TCR flag is set */\r
1765         if(I2C_WaitOnFlagUntilTimeout(hi2c, I2C_FLAG_TCR, RESET, Timeout) != HAL_OK)      \r
1766         {\r
1767           return HAL_TIMEOUT;\r
1768         }\r
1769         \r
1770         if(Size > 255)\r
1771         {\r
1772           I2C_TransferConfig(hi2c,DevAddress,255, I2C_RELOAD_MODE, I2C_NO_STARTSTOP);\r
1773           Sizetmp = 255;\r
1774         }\r
1775         else\r
1776         {\r
1777           I2C_TransferConfig(hi2c,DevAddress,Size, I2C_AUTOEND_MODE, I2C_NO_STARTSTOP);\r
1778           Sizetmp = Size;\r
1779         }\r
1780       }\r
1781 \r
1782     }while(Size > 0);\r
1783 \r
1784     /* No need to Check TC flag, with AUTOEND mode the stop is automatically generated */\r
1785     /* Wait until STOPF flag is reset */ \r
1786     if(I2C_WaitOnSTOPFlagUntilTimeout(hi2c, I2C_TIMEOUT_STOPF) != HAL_OK)\r
1787     {\r
1788       if(hi2c->ErrorCode == HAL_I2C_ERROR_AF)\r
1789       {\r
1790         return HAL_ERROR;\r
1791       }\r
1792       else\r
1793       {\r
1794         return HAL_TIMEOUT;\r
1795       }\r
1796     }\r
1797 \r
1798     /* Clear STOP Flag */\r
1799     __HAL_I2C_CLEAR_FLAG(hi2c, I2C_FLAG_STOPF);\r
1800         \r
1801     /* Clear Configuration Register 2 */\r
1802     I2C_RESET_CR2(hi2c);\r
1803     \r
1804     hi2c->State = HAL_I2C_STATE_READY;\r
1805     \r
1806     /* Process Unlocked */\r
1807     __HAL_UNLOCK(hi2c);\r
1808     \r
1809     return HAL_OK;\r
1810   }\r
1811   else\r
1812   {\r
1813     return HAL_BUSY;\r
1814   }\r
1815 }\r
1816 /**\r
1817   * @brief  Write an amount of data in no-blocking mode with Interrupt to a specific memory address\r
1818   * @param  hi2c : Pointer to a I2C_HandleTypeDef structure that contains\r
1819   *                the configuration information for the specified I2C.\r
1820   * @param  DevAddress: Target device address\r
1821   * @param  MemAddress: Internal memory address\r
1822   * @param  MemAddSize: Size of internal memory address\r
1823   * @param  pData: Pointer to data buffer\r
1824   * @param  Size: Amount of data to be sent\r
1825   * @retval HAL status\r
1826   */\r
1827 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)\r
1828 {\r
1829   /* Check the parameters */\r
1830   assert_param(IS_I2C_MEMADD_SIZE(MemAddSize));\r
1831   \r
1832   if(hi2c->State == HAL_I2C_STATE_READY)\r
1833   {\r
1834     if((pData == NULL) || (Size == 0)) \r
1835     {\r
1836       return  HAL_ERROR;                                    \r
1837     }\r
1838     \r
1839     if(__HAL_I2C_GET_FLAG(hi2c, I2C_FLAG_BUSY) == SET)\r
1840     {\r
1841       return HAL_BUSY;\r
1842     }\r
1843 \r
1844     /* Process Locked */\r
1845     __HAL_LOCK(hi2c);\r
1846     \r
1847     hi2c->State = HAL_I2C_STATE_MEM_BUSY_TX;\r
1848     hi2c->ErrorCode = HAL_I2C_ERROR_NONE;\r
1849     \r
1850     hi2c->pBuffPtr = pData;\r
1851     hi2c->XferCount = Size;\r
1852     if(Size > 255)\r
1853     {\r
1854       hi2c->XferSize = 255;\r
1855     }\r
1856     else\r
1857     {\r
1858       hi2c->XferSize = Size;\r
1859     }\r
1860     \r
1861     /* Send Slave Address and Memory Address */\r
1862     if(I2C_RequestMemoryWrite(hi2c, DevAddress, MemAddress, MemAddSize, I2C_TIMEOUT_FLAG) != HAL_OK)\r
1863     {\r
1864       if(hi2c->ErrorCode == HAL_I2C_ERROR_AF)\r
1865       {\r
1866         /* Process Unlocked */\r
1867         __HAL_UNLOCK(hi2c);\r
1868         return HAL_ERROR;\r
1869       }\r
1870       else\r
1871       {\r
1872         /* Process Unlocked */\r
1873         __HAL_UNLOCK(hi2c);\r
1874         return HAL_TIMEOUT;\r
1875       }\r
1876     }\r
1877 \r
1878     /* Set NBYTES to write and reload if size > 255 */\r
1879     /* Size > 255, need to set RELOAD bit */\r
1880     if( (hi2c->XferSize == 255) && (hi2c->XferSize < hi2c->XferCount) )\r
1881     {\r
1882       I2C_TransferConfig(hi2c,DevAddress,hi2c->XferSize, I2C_RELOAD_MODE, I2C_NO_STARTSTOP);\r
1883     }\r
1884     else\r
1885     {\r
1886       I2C_TransferConfig(hi2c,DevAddress,hi2c->XferSize, I2C_AUTOEND_MODE, I2C_NO_STARTSTOP);\r
1887     }  \r
1888 \r
1889     /* Process Unlocked */\r
1890     __HAL_UNLOCK(hi2c); \r
1891 \r
1892     /* Note : The I2C interrupts must be enabled after unlocking current process \r
1893               to avoid the risk of I2C interrupt handle execution before current\r
1894               process unlock */\r
1895     \r
1896     /* Enable ERR, TC, STOP, NACK, TXI interrupt */\r
1897     /* possible to enable all of these */\r
1898     /* I2C_IT_ERRI | I2C_IT_TCI| I2C_IT_STOPI| I2C_IT_NACKI | I2C_IT_ADDRI | I2C_IT_RXI | I2C_IT_TXI */\r
1899     __HAL_I2C_ENABLE_IT(hi2c,I2C_IT_ERRI | I2C_IT_TCI| I2C_IT_STOPI| I2C_IT_NACKI | I2C_IT_TXI );\r
1900     \r
1901     return HAL_OK;\r
1902   }\r
1903   else\r
1904   {\r
1905     return HAL_BUSY;\r
1906   }\r
1907 }\r
1908 \r
1909 /**\r
1910   * @brief  Read an amount of data in no-blocking mode with Interrupt from a specific memory address\r
1911   * @param  hi2c : Pointer to a I2C_HandleTypeDef structure that contains\r
1912   *                the configuration information for the specified I2C.\r
1913   * @param  DevAddress: Target device address\r
1914   * @param  MemAddress: Internal memory address\r
1915   * @param  MemAddSize: Size of internal memory address\r
1916   * @param  pData: Pointer to data buffer\r
1917   * @param  Size: Amount of data to be sent\r
1918   * @retval HAL status\r
1919   */\r
1920 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)\r
1921 {\r
1922   /* Check the parameters */\r
1923   assert_param(IS_I2C_MEMADD_SIZE(MemAddSize));\r
1924   \r
1925   if(hi2c->State == HAL_I2C_STATE_READY)\r
1926   {\r
1927     if((pData == NULL) || (Size == 0)) \r
1928     {\r
1929       return  HAL_ERROR;                                    \r
1930     }\r
1931     \r
1932     if(__HAL_I2C_GET_FLAG(hi2c, I2C_FLAG_BUSY) == SET)\r
1933     {\r
1934       return HAL_BUSY;\r
1935     }\r
1936 \r
1937     /* Process Locked */\r
1938     __HAL_LOCK(hi2c);\r
1939     \r
1940     hi2c->State = HAL_I2C_STATE_MEM_BUSY_RX;\r
1941     \r
1942     hi2c->pBuffPtr = pData;\r
1943     hi2c->XferCount = Size;\r
1944     if(Size > 255)\r
1945     {\r
1946       hi2c->XferSize = 255;\r
1947     }\r
1948     else\r
1949     {\r
1950       hi2c->XferSize = Size;\r
1951     }\r
1952     \r
1953     /* Send Slave Address and Memory Address */\r
1954     if(I2C_RequestMemoryRead(hi2c, DevAddress, MemAddress, MemAddSize, I2C_TIMEOUT_FLAG) != HAL_OK)\r
1955     {\r
1956       if(hi2c->ErrorCode == HAL_I2C_ERROR_AF)\r
1957       {\r
1958         /* Process Unlocked */\r
1959         __HAL_UNLOCK(hi2c);\r
1960         return HAL_ERROR;\r
1961       }\r
1962       else\r
1963       {\r
1964         /* Process Unlocked */\r
1965         __HAL_UNLOCK(hi2c);\r
1966         return HAL_TIMEOUT;\r
1967       }\r
1968     }\r
1969       \r
1970     /* Set NBYTES to write and reload if size > 255 and generate RESTART */\r
1971     /* Size > 255, need to set RELOAD bit */\r
1972     if( (hi2c->XferSize == 255) && (hi2c->XferSize < hi2c->XferCount) )\r
1973     {\r
1974       I2C_TransferConfig(hi2c,DevAddress,hi2c->XferSize, I2C_RELOAD_MODE, I2C_GENERATE_START_READ);\r
1975     }\r
1976     else\r
1977     {\r
1978       I2C_TransferConfig(hi2c,DevAddress,hi2c->XferSize, I2C_AUTOEND_MODE, I2C_GENERATE_START_READ);\r
1979     }\r
1980 \r
1981     /* Process Unlocked */\r
1982     __HAL_UNLOCK(hi2c); \r
1983 \r
1984     /* Note : The I2C interrupts must be enabled after unlocking current process \r
1985               to avoid the risk of I2C interrupt handle execution before current\r
1986               process unlock */\r
1987     \r
1988     /* Enable ERR, TC, STOP, NACK, RXI interrupt */\r
1989     /* possible to enable all of these */\r
1990     /* I2C_IT_ERRI | I2C_IT_TCI| I2C_IT_STOPI| I2C_IT_NACKI | I2C_IT_ADDRI | I2C_IT_RXI | I2C_IT_TXI */\r
1991     __HAL_I2C_ENABLE_IT(hi2c, I2C_IT_ERRI | I2C_IT_TCI| I2C_IT_STOPI| I2C_IT_NACKI | I2C_IT_RXI );\r
1992     \r
1993     return HAL_OK;\r
1994   }\r
1995   else\r
1996   {\r
1997     return HAL_BUSY; \r
1998   }   \r
1999 }\r
2000 /**\r
2001   * @brief  Write an amount of data in no-blocking mode with DMA to a specific memory address\r
2002   * @param  hi2c : Pointer to a I2C_HandleTypeDef structure that contains\r
2003   *                the configuration information for the specified I2C.\r
2004   * @param  DevAddress: Target device address\r
2005   * @param  MemAddress: Internal memory address\r
2006   * @param  MemAddSize: Size of internal memory address\r
2007   * @param  pData: Pointer to data buffer\r
2008   * @param  Size: Amount of data to be sent\r
2009   * @retval HAL status\r
2010   */\r
2011 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)\r
2012 {\r
2013   /* Check the parameters */\r
2014   assert_param(IS_I2C_MEMADD_SIZE(MemAddSize));\r
2015   \r
2016   if(hi2c->State == HAL_I2C_STATE_READY)\r
2017   {\r
2018     if((pData == NULL) || (Size == 0)) \r
2019     {\r
2020       return  HAL_ERROR;                                    \r
2021     }\r
2022     \r
2023     if(__HAL_I2C_GET_FLAG(hi2c, I2C_FLAG_BUSY) == SET)\r
2024     {\r
2025       return HAL_BUSY;\r
2026     }\r
2027 \r
2028     /* Process Locked */\r
2029     __HAL_LOCK(hi2c);\r
2030     \r
2031     hi2c->State = HAL_I2C_STATE_MEM_BUSY_TX;\r
2032     hi2c->ErrorCode = HAL_I2C_ERROR_NONE;\r
2033     \r
2034     hi2c->pBuffPtr = pData;\r
2035     hi2c->XferCount = Size;\r
2036     if(Size > 255)\r
2037     {\r
2038       hi2c->XferSize = 255;\r
2039     }\r
2040     else\r
2041     {\r
2042       hi2c->XferSize = Size;\r
2043     }\r
2044     \r
2045     /* Set the I2C DMA transfer complete callback */\r
2046     hi2c->hdmatx->XferCpltCallback = I2C_DMAMemTransmitCplt;\r
2047     \r
2048     /* Set the DMA error callback */\r
2049     hi2c->hdmatx->XferErrorCallback = I2C_DMAError;\r
2050     \r
2051     /* Enable the DMA channel */\r
2052     HAL_DMA_Start_IT(hi2c->hdmatx, (uint32_t)pData, (uint32_t)&hi2c->Instance->TXDR, hi2c->XferSize);\r
2053     \r
2054     /* Send Slave Address and Memory Address */\r
2055     if(I2C_RequestMemoryWrite(hi2c, DevAddress, MemAddress, MemAddSize, I2C_TIMEOUT_FLAG) != HAL_OK)\r
2056     {\r
2057       if(hi2c->ErrorCode == HAL_I2C_ERROR_AF)\r
2058       {\r
2059         /* Process Unlocked */\r
2060         __HAL_UNLOCK(hi2c);\r
2061         return HAL_ERROR;\r
2062       }\r
2063       else\r
2064       {\r
2065         /* Process Unlocked */\r
2066         __HAL_UNLOCK(hi2c);\r
2067         return HAL_TIMEOUT;\r
2068       }\r
2069     }\r
2070     \r
2071     /* Send Slave Address */\r
2072     /* Set NBYTES to write and reload if size > 255 */\r
2073     if( (hi2c->XferSize == 255) && (hi2c->XferSize < hi2c->XferCount) )\r
2074     {\r
2075       I2C_TransferConfig(hi2c,DevAddress,hi2c->XferSize, I2C_RELOAD_MODE, I2C_NO_STARTSTOP);\r
2076     }\r
2077     else\r
2078     {\r
2079       I2C_TransferConfig(hi2c,DevAddress,hi2c->XferSize, I2C_AUTOEND_MODE, I2C_NO_STARTSTOP);\r
2080     }\r
2081     \r
2082     /* Wait until TXIS flag is set */\r
2083     if(I2C_WaitOnTXISFlagUntilTimeout(hi2c, I2C_TIMEOUT_TXIS) != HAL_OK)\r
2084     {\r
2085       if(hi2c->ErrorCode == HAL_I2C_ERROR_AF)\r
2086       {\r
2087         return HAL_ERROR;\r
2088       }\r
2089       else\r
2090       {\r
2091         return HAL_TIMEOUT;\r
2092       }\r
2093     }\r
2094 \r
2095     /* Enable DMA Request */\r
2096     hi2c->Instance->CR1 |= I2C_CR1_TXDMAEN;  \r
2097     \r
2098     /* Process Unlocked */\r
2099     __HAL_UNLOCK(hi2c);\r
2100     \r
2101     return HAL_OK;\r
2102   }\r
2103   else\r
2104   {\r
2105     return HAL_BUSY;\r
2106   }\r
2107 }\r
2108 \r
2109 /**\r
2110   * @brief  Reads an amount of data in no-blocking mode with DMA from a specific memory address.\r
2111   * @param  hi2c : Pointer to a I2C_HandleTypeDef structure that contains\r
2112   *                the configuration information for the specified I2C.\r
2113   * @param  DevAddress: Target device address\r
2114   * @param  MemAddress: Internal memory address\r
2115   * @param  MemAddSize: Size of internal memory address\r
2116   * @param  pData: Pointer to data buffer\r
2117   * @param  Size: Amount of data to be read\r
2118   * @retval HAL status\r
2119   */\r
2120 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)\r
2121 {\r
2122   /* Check the parameters */\r
2123   assert_param(IS_I2C_MEMADD_SIZE(MemAddSize));\r
2124   \r
2125   if(hi2c->State == HAL_I2C_STATE_READY)\r
2126   {\r
2127     if((pData == NULL) || (Size == 0)) \r
2128     {\r
2129       return  HAL_ERROR;                                    \r
2130     }\r
2131 \r
2132     if(__HAL_I2C_GET_FLAG(hi2c, I2C_FLAG_BUSY) == SET)\r
2133     {\r
2134       return HAL_BUSY;\r
2135     }\r
2136 \r
2137     /* Process Locked */\r
2138     __HAL_LOCK(hi2c);\r
2139     \r
2140     hi2c->State = HAL_I2C_STATE_MEM_BUSY_RX;\r
2141     \r
2142     hi2c->pBuffPtr = pData;\r
2143     hi2c->XferCount = Size;\r
2144     if(Size > 255)\r
2145     {\r
2146       hi2c->XferSize = 255;\r
2147     }\r
2148     else\r
2149     {\r
2150       hi2c->XferSize = Size;\r
2151     }\r
2152 \r
2153     /* Set the I2C DMA transfer complete callback */\r
2154     hi2c->hdmarx->XferCpltCallback = I2C_DMAMemReceiveCplt;\r
2155     \r
2156     /* Set the DMA error callback */\r
2157     hi2c->hdmarx->XferErrorCallback = I2C_DMAError;\r
2158     \r
2159     /* Enable the DMA channel */\r
2160     HAL_DMA_Start_IT(hi2c->hdmarx, (uint32_t)&hi2c->Instance->RXDR, (uint32_t)pData, hi2c->XferSize);\r
2161     \r
2162     /* Send Slave Address and Memory Address */\r
2163     if(I2C_RequestMemoryRead(hi2c, DevAddress, MemAddress, MemAddSize, I2C_TIMEOUT_FLAG) != HAL_OK)\r
2164     {\r
2165       if(hi2c->ErrorCode == HAL_I2C_ERROR_AF)\r
2166       {\r
2167         /* Process Unlocked */\r
2168         __HAL_UNLOCK(hi2c);\r
2169         return HAL_ERROR;\r
2170       }\r
2171       else\r
2172       {\r
2173         /* Process Unlocked */\r
2174         __HAL_UNLOCK(hi2c);\r
2175         return HAL_TIMEOUT;\r
2176       }\r
2177     }\r
2178     \r
2179     /* Set NBYTES to write and reload if size > 255 and generate RESTART */\r
2180     if( (hi2c->XferSize == 255) && (hi2c->XferSize < hi2c->XferCount) )\r
2181     {\r
2182       I2C_TransferConfig(hi2c,DevAddress,hi2c->XferSize, I2C_RELOAD_MODE, I2C_GENERATE_START_READ);\r
2183     }\r
2184     else\r
2185     {\r
2186       I2C_TransferConfig(hi2c,DevAddress,hi2c->XferSize, I2C_AUTOEND_MODE, I2C_GENERATE_START_READ);\r
2187     }\r
2188 \r
2189     /* Wait until RXNE flag is set */\r
2190     if(I2C_WaitOnFlagUntilTimeout(hi2c, I2C_FLAG_RXNE, RESET, I2C_TIMEOUT_RXNE) != HAL_OK)      \r
2191     {\r
2192       return HAL_TIMEOUT;\r
2193     }\r
2194     \r
2195     /* Enable DMA Request */\r
2196     hi2c->Instance->CR1 |= I2C_CR1_RXDMAEN;  \r
2197     \r
2198     /* Process Unlocked */\r
2199     __HAL_UNLOCK(hi2c);\r
2200     \r
2201     return HAL_OK;\r
2202   }\r
2203   else\r
2204   {\r
2205     return HAL_BUSY;\r
2206   }\r
2207 }\r
2208 \r
2209 /**\r
2210   * @brief  Checks if target device is ready for communication. \r
2211   * @note   This function is used with Memory devices\r
2212   * @param  hi2c : Pointer to a I2C_HandleTypeDef structure that contains\r
2213   *                the configuration information for the specified I2C.\r
2214   * @param  DevAddress: Target device address\r
2215   * @param  Trials: Number of trials\r
2216   * @param  Timeout: Timeout duration\r
2217   * @retval HAL status\r
2218   */\r
2219 HAL_StatusTypeDef HAL_I2C_IsDeviceReady(I2C_HandleTypeDef *hi2c, uint16_t DevAddress, uint32_t Trials, uint32_t Timeout)\r
2220 {  \r
2221   uint32_t tickstart = 0;\r
2222   \r
2223   __IO uint32_t I2C_Trials = 0;\r
2224  \r
2225   if(hi2c->State == HAL_I2C_STATE_READY)\r
2226   {\r
2227     if(__HAL_I2C_GET_FLAG(hi2c, I2C_FLAG_BUSY) == SET)\r
2228     {\r
2229       return HAL_BUSY;\r
2230     }\r
2231 \r
2232     /* Process Locked */\r
2233     __HAL_LOCK(hi2c);\r
2234     \r
2235     hi2c->State = HAL_I2C_STATE_BUSY;\r
2236     hi2c->ErrorCode = HAL_I2C_ERROR_NONE;\r
2237     \r
2238     do\r
2239     {\r
2240       /* Generate Start */\r
2241       hi2c->Instance->CR2 = I2C_GENERATE_START(hi2c->Init.AddressingMode,DevAddress);\r
2242       \r
2243       /* No need to Check TC flag, with AUTOEND mode the stop is automatically generated */\r
2244       /* Wait until STOPF flag is set or a NACK flag is set*/\r
2245       tickstart = HAL_GetTick();\r
2246       while((__HAL_I2C_GET_FLAG(hi2c, I2C_FLAG_STOPF) == RESET) && (__HAL_I2C_GET_FLAG(hi2c, I2C_FLAG_AF) == RESET) && (hi2c->State != HAL_I2C_STATE_TIMEOUT))\r
2247       {\r
2248         if(Timeout != HAL_MAX_DELAY)\r
2249         {\r
2250           if((Timeout == 0)||((HAL_GetTick() - tickstart ) > Timeout))\r
2251           {\r
2252             /* Device is ready */\r
2253             hi2c->State = HAL_I2C_STATE_READY;\r
2254             /* Process Unlocked */\r
2255             __HAL_UNLOCK(hi2c);         \r
2256             return HAL_TIMEOUT;\r
2257           }\r
2258         } \r
2259       }\r
2260       \r
2261       /* Check if the NACKF flag has not been set */\r
2262       if (__HAL_I2C_GET_FLAG(hi2c, I2C_FLAG_AF) == RESET)\r
2263       {\r
2264         /* Wait until STOPF flag is reset */ \r
2265         if(I2C_WaitOnFlagUntilTimeout(hi2c, I2C_FLAG_STOPF, RESET, Timeout) != HAL_OK)\r
2266         {\r
2267           return HAL_TIMEOUT;\r
2268         }\r
2269         \r
2270         /* Clear STOP Flag */\r
2271         __HAL_I2C_CLEAR_FLAG(hi2c, I2C_FLAG_STOPF);\r
2272 \r
2273         /* Device is ready */\r
2274         hi2c->State = HAL_I2C_STATE_READY;\r
2275         \r
2276         /* Process Unlocked */\r
2277         __HAL_UNLOCK(hi2c);\r
2278         \r
2279         return HAL_OK;\r
2280       }\r
2281       else\r
2282       {\r
2283         /* Wait until STOPF flag is reset */ \r
2284         if(I2C_WaitOnFlagUntilTimeout(hi2c, I2C_FLAG_STOPF, RESET, Timeout) != HAL_OK)\r
2285         {\r
2286           return HAL_TIMEOUT;\r
2287         }\r
2288 \r
2289         /* Clear NACK Flag */\r
2290         __HAL_I2C_CLEAR_FLAG(hi2c, I2C_FLAG_AF);\r
2291 \r
2292         /* Clear STOP Flag, auto generated with autoend*/\r
2293         __HAL_I2C_CLEAR_FLAG(hi2c, I2C_FLAG_STOPF);\r
2294       }\r
2295       \r
2296       /* Check if the maximum allowed number of trials has been reached */\r
2297       if (I2C_Trials++ == Trials)\r
2298       {\r
2299         /* Generate Stop */\r
2300         hi2c->Instance->CR2 |= I2C_CR2_STOP;\r
2301         \r
2302         /* Wait until STOPF flag is reset */ \r
2303         if(I2C_WaitOnFlagUntilTimeout(hi2c, I2C_FLAG_STOPF, RESET, Timeout) != HAL_OK)\r
2304         {\r
2305           return HAL_TIMEOUT;\r
2306         }\r
2307         \r
2308         /* Clear STOP Flag */\r
2309         __HAL_I2C_CLEAR_FLAG(hi2c, I2C_FLAG_STOPF);\r
2310       }      \r
2311     }while(I2C_Trials < Trials);\r
2312 \r
2313     hi2c->State = HAL_I2C_STATE_READY;\r
2314 \r
2315     /* Process Unlocked */\r
2316     __HAL_UNLOCK(hi2c);\r
2317         \r
2318     return HAL_TIMEOUT;\r
2319   }\r
2320   else\r
2321   {\r
2322     return HAL_BUSY;\r
2323   }\r
2324 }\r
2325 /**\r
2326   * @}\r
2327   */\r
2328 \r
2329 /** @defgroup IRQ_Handler_and_Callbacks IRQ Handler and Callbacks\r
2330  * @{\r
2331  */   \r
2332 \r
2333 /**\r
2334   * @brief  This function handles I2C event interrupt request.\r
2335   * @param  hi2c : Pointer to a I2C_HandleTypeDef structure that contains\r
2336   *                the configuration information for the specified I2C.\r
2337   * @retval None\r
2338   */\r
2339 void HAL_I2C_EV_IRQHandler(I2C_HandleTypeDef *hi2c)\r
2340 {\r
2341   /* I2C in mode Transmitter ---------------------------------------------------*/\r
2342   if (((__HAL_I2C_GET_FLAG(hi2c, I2C_FLAG_TXIS) == SET) || (__HAL_I2C_GET_FLAG(hi2c, I2C_FLAG_TCR) == SET) || (__HAL_I2C_GET_FLAG(hi2c, I2C_FLAG_TC) == SET) || (__HAL_I2C_GET_FLAG(hi2c, I2C_FLAG_STOPF) == SET) || (__HAL_I2C_GET_FLAG(hi2c, I2C_FLAG_AF) == SET) || (__HAL_I2C_GET_FLAG(hi2c, I2C_FLAG_ADDR) == SET)) && (__HAL_I2C_GET_IT_SOURCE(hi2c, (I2C_IT_TCI | I2C_IT_STOPI | I2C_IT_NACKI | I2C_IT_TXI | I2C_IT_ADDRI)) == SET))\r
2343   {     \r
2344     /* Slave mode selected */\r
2345     if (hi2c->State == HAL_I2C_STATE_SLAVE_BUSY_TX)\r
2346     {\r
2347       I2C_SlaveTransmit_ISR(hi2c);\r
2348     }\r
2349   }\r
2350     \r
2351   if (((__HAL_I2C_GET_FLAG(hi2c, I2C_FLAG_TXIS) == SET) || (__HAL_I2C_GET_FLAG(hi2c, I2C_FLAG_TCR) == SET) || (__HAL_I2C_GET_FLAG(hi2c, I2C_FLAG_TC) == SET) || (__HAL_I2C_GET_FLAG(hi2c, I2C_FLAG_STOPF) == SET) || (__HAL_I2C_GET_FLAG(hi2c, I2C_FLAG_AF) == SET)) && (__HAL_I2C_GET_IT_SOURCE(hi2c, (I2C_IT_TCI | I2C_IT_STOPI | I2C_IT_NACKI | I2C_IT_TXI)) == SET))\r
2352   {     \r
2353     /* Master mode selected */\r
2354     if ((hi2c->State == HAL_I2C_STATE_MASTER_BUSY_TX) || (hi2c->State == HAL_I2C_STATE_MEM_BUSY_TX))\r
2355     {\r
2356       I2C_MasterTransmit_ISR(hi2c);\r
2357     }\r
2358   }\r
2359 \r
2360   /* I2C in mode Receiver ----------------------------------------------------*/\r
2361   if (((__HAL_I2C_GET_FLAG(hi2c, I2C_FLAG_RXNE) == SET) || (__HAL_I2C_GET_FLAG(hi2c, I2C_FLAG_TCR) == SET) || (__HAL_I2C_GET_FLAG(hi2c, I2C_FLAG_TC) == SET) || (__HAL_I2C_GET_FLAG(hi2c, I2C_FLAG_STOPF) == SET) || (__HAL_I2C_GET_FLAG(hi2c, I2C_FLAG_AF) == SET) || (__HAL_I2C_GET_FLAG(hi2c, I2C_FLAG_ADDR) == SET)) && (__HAL_I2C_GET_IT_SOURCE(hi2c, (I2C_IT_TCI| I2C_IT_STOPI| I2C_IT_NACKI | I2C_IT_RXI | I2C_IT_ADDRI)) == SET))\r
2362   {\r
2363     /* Slave mode selected */\r
2364     if (hi2c->State == HAL_I2C_STATE_SLAVE_BUSY_RX)\r
2365     {\r
2366       I2C_SlaveReceive_ISR(hi2c);\r
2367     }\r
2368   } \r
2369   if (((__HAL_I2C_GET_FLAG(hi2c, I2C_FLAG_RXNE) == SET) || (__HAL_I2C_GET_FLAG(hi2c, I2C_FLAG_TCR) == SET) || (__HAL_I2C_GET_FLAG(hi2c, I2C_FLAG_TC) == SET) || (__HAL_I2C_GET_FLAG(hi2c, I2C_FLAG_STOPF) == SET) || (__HAL_I2C_GET_FLAG(hi2c, I2C_FLAG_AF) == SET)) && (__HAL_I2C_GET_IT_SOURCE(hi2c, (I2C_IT_TCI| I2C_IT_STOPI| I2C_IT_NACKI | I2C_IT_RXI)) == SET))\r
2370   {\r
2371     /* Master mode selected */\r
2372     if ((hi2c->State == HAL_I2C_STATE_MASTER_BUSY_RX) || (hi2c->State == HAL_I2C_STATE_MEM_BUSY_RX))\r
2373     {\r
2374       I2C_MasterReceive_ISR(hi2c);\r
2375     }\r
2376   } \r
2377 }\r
2378 \r
2379 /**\r
2380   * @brief  This function handles I2C error interrupt request.\r
2381   * @param  hi2c : Pointer to a I2C_HandleTypeDef structure that contains\r
2382   *                the configuration information for the specified I2C.\r
2383   * @retval None\r
2384   */\r
2385 void HAL_I2C_ER_IRQHandler(I2C_HandleTypeDef *hi2c)\r
2386 {\r
2387   /* I2C Bus error interrupt occurred ------------------------------------*/\r
2388   if((__HAL_I2C_GET_FLAG(hi2c, I2C_FLAG_BERR) == SET) && (__HAL_I2C_GET_IT_SOURCE(hi2c, I2C_IT_ERRI) == SET))\r
2389   { \r
2390     hi2c->ErrorCode |= HAL_I2C_ERROR_BERR;\r
2391    \r
2392     /* Clear BERR flag */\r
2393     __HAL_I2C_CLEAR_FLAG(hi2c, I2C_FLAG_BERR);\r
2394   }\r
2395   \r
2396   /* I2C Over-Run/Under-Run interrupt occurred ----------------------------------------*/\r
2397   if((__HAL_I2C_GET_FLAG(hi2c, I2C_FLAG_OVR) == SET) && (__HAL_I2C_GET_IT_SOURCE(hi2c, I2C_IT_ERRI) == SET))\r
2398   { \r
2399     hi2c->ErrorCode |= HAL_I2C_ERROR_OVR;\r
2400 \r
2401     /* Clear OVR flag */\r
2402     __HAL_I2C_CLEAR_FLAG(hi2c, I2C_FLAG_OVR);\r
2403   }\r
2404 \r
2405   /* I2C Arbitration Loss error interrupt occurred -------------------------------------*/\r
2406   if((__HAL_I2C_GET_FLAG(hi2c, I2C_FLAG_ARLO) == SET) && (__HAL_I2C_GET_IT_SOURCE(hi2c, I2C_IT_ERRI) == SET))\r
2407   { \r
2408     hi2c->ErrorCode |= HAL_I2C_ERROR_ARLO;\r
2409 \r
2410     /* Clear ARLO flag */\r
2411     __HAL_I2C_CLEAR_FLAG(hi2c, I2C_FLAG_ARLO);\r
2412   }\r
2413 \r
2414   /* Call the Error Callback in case of Error detected */\r
2415   if(hi2c->ErrorCode != HAL_I2C_ERROR_NONE)\r
2416   {\r
2417     hi2c->State = HAL_I2C_STATE_READY;\r
2418     \r
2419     HAL_I2C_ErrorCallback(hi2c);\r
2420   }\r
2421 }\r
2422 \r
2423 /**\r
2424   * @brief  Master Tx Transfer completed callbacks.\r
2425   * @param  hi2c : Pointer to a I2C_HandleTypeDef structure that contains\r
2426   *                the configuration information for the specified I2C.\r
2427   * @retval None\r
2428   */\r
2429  __weak void HAL_I2C_MasterTxCpltCallback(I2C_HandleTypeDef *hi2c)\r
2430 {\r
2431   /* NOTE : This function Should not be modified, when the callback is needed,\r
2432             the HAL_I2C_TxCpltCallback could be implemented in the user file\r
2433    */ \r
2434 }\r
2435 \r
2436 /**\r
2437   * @brief  Master Rx Transfer completed callbacks.\r
2438   * @param  hi2c : Pointer to a I2C_HandleTypeDef structure that contains\r
2439   *                the configuration information for the specified I2C.\r
2440   * @retval None\r
2441   */\r
2442 __weak void HAL_I2C_MasterRxCpltCallback(I2C_HandleTypeDef *hi2c)\r
2443 {\r
2444   /* NOTE : This function Should not be modified, when the callback is needed,\r
2445             the HAL_I2C_TxCpltCallback could be implemented in the user file\r
2446    */\r
2447 }\r
2448 \r
2449 /** @brief  Slave Tx Transfer completed callbacks.\r
2450   * @param  hi2c : Pointer to a I2C_HandleTypeDef structure that contains\r
2451   *                the configuration information for the specified I2C.\r
2452   * @retval None\r
2453   */\r
2454  __weak void HAL_I2C_SlaveTxCpltCallback(I2C_HandleTypeDef *hi2c)\r
2455 {\r
2456   /* NOTE : This function Should not be modified, when the callback is needed,\r
2457             the HAL_I2C_TxCpltCallback could be implemented in the user file\r
2458    */ \r
2459 }\r
2460 \r
2461 /**\r
2462   * @brief  Slave Rx Transfer completed callbacks.\r
2463   * @param  hi2c : Pointer to a I2C_HandleTypeDef structure that contains\r
2464   *                the configuration information for the specified I2C.\r
2465   * @retval None\r
2466   */\r
2467 __weak void HAL_I2C_SlaveRxCpltCallback(I2C_HandleTypeDef *hi2c)\r
2468 {\r
2469   /* NOTE : This function Should not be modified, when the callback is needed,\r
2470             the HAL_I2C_TxCpltCallback could be implemented in the user file\r
2471    */\r
2472 }\r
2473 \r
2474 /**\r
2475   * @brief  Memory Tx Transfer completed callbacks.\r
2476   * @param  hi2c : Pointer to a I2C_HandleTypeDef structure that contains\r
2477   *                the configuration information for the specified I2C.\r
2478   * @retval None\r
2479   */\r
2480  __weak void HAL_I2C_MemTxCpltCallback(I2C_HandleTypeDef *hi2c)\r
2481 {\r
2482   /* NOTE : This function Should not be modified, when the callback is needed,\r
2483             the HAL_I2C_TxCpltCallback could be implemented in the user file\r
2484    */ \r
2485 }\r
2486 \r
2487 /**\r
2488   * @brief  Memory Rx Transfer completed callbacks.\r
2489   * @param  hi2c : Pointer to a I2C_HandleTypeDef structure that contains\r
2490   *                the configuration information for the specified I2C.\r
2491   * @retval None\r
2492   */\r
2493 __weak void HAL_I2C_MemRxCpltCallback(I2C_HandleTypeDef *hi2c)\r
2494 {\r
2495   /* NOTE : This function Should not be modified, when the callback is needed,\r
2496             the HAL_I2C_TxCpltCallback could be implemented in the user file\r
2497    */\r
2498 }\r
2499 \r
2500 /**\r
2501   * @brief  I2C error callbacks.\r
2502   * @param  hi2c : Pointer to a I2C_HandleTypeDef structure that contains\r
2503   *                the configuration information for the specified I2C.\r
2504   * @retval None\r
2505   */\r
2506  __weak void HAL_I2C_ErrorCallback(I2C_HandleTypeDef *hi2c)\r
2507 {\r
2508   /* NOTE : This function Should not be modified, when the callback is needed,\r
2509             the HAL_I2C_ErrorCallback could be implemented in the user file\r
2510    */ \r
2511 }\r
2512 \r
2513 /**\r
2514   * @}\r
2515   */\r
2516 \r
2517 /** @defgroup I2C_Exported_Functions_Group3 Peripheral State and Errors functions\r
2518  *  @brief   Peripheral State and Errors functions\r
2519  *\r
2520 @verbatim   \r
2521  ===============================================================================\r
2522             ##### Peripheral State and Errors functions #####\r
2523  ===============================================================================  \r
2524     [..]\r
2525     This subsection permit to get in run-time the status of the peripheral \r
2526     and the data flow.\r
2527 \r
2528 @endverbatim\r
2529   * @{\r
2530   */\r
2531 \r
2532 /**\r
2533   * @brief  Returns the I2C state.\r
2534   * @param  hi2c : Pointer to a I2C_HandleTypeDef structure that contains\r
2535   *                the configuration information for the specified I2C.\r
2536   * @retval HAL state\r
2537   */\r
2538 HAL_I2C_StateTypeDef HAL_I2C_GetState(I2C_HandleTypeDef *hi2c)\r
2539 {\r
2540   return hi2c->State;\r
2541 }\r
2542 \r
2543 /**\r
2544   * @brief  Return the I2C error code\r
2545   * @param  hi2c : Pointer to a I2C_HandleTypeDef structure that contains\r
2546   *              the configuration information for the specified I2C.\r
2547 * @retval I2C Error Code\r
2548 */\r
2549 uint32_t HAL_I2C_GetError(I2C_HandleTypeDef *hi2c)\r
2550 {\r
2551   return hi2c->ErrorCode;\r
2552 }\r
2553 \r
2554 /**\r
2555   * @}\r
2556   */  \r
2557 \r
2558 /**\r
2559   * @}\r
2560   */\r
2561 \r
2562 /** @addtogroup I2C_Private_Functions\r
2563   * @{\r
2564   */\r
2565 \r
2566 /**\r
2567   * @brief  Handle Interrupt Flags Master Transmit Mode\r
2568   * @param  hi2c : Pointer to a I2C_HandleTypeDef structure that contains\r
2569   *                the configuration information for the specified I2C.\r
2570   * @retval HAL status\r
2571   */\r
2572 static HAL_StatusTypeDef I2C_MasterTransmit_ISR(I2C_HandleTypeDef *hi2c) \r
2573 {\r
2574   uint16_t DevAddress;\r
2575   \r
2576   /* Process Locked */\r
2577   __HAL_LOCK(hi2c); \r
2578   \r
2579   if(__HAL_I2C_GET_FLAG(hi2c, I2C_FLAG_TXIS) == SET)\r
2580   {\r
2581     /* Write data to TXDR */\r
2582     hi2c->Instance->TXDR = (*hi2c->pBuffPtr++);\r
2583     hi2c->XferSize--;\r
2584     hi2c->XferCount--;  \r
2585   }\r
2586   else if(__HAL_I2C_GET_FLAG(hi2c, I2C_FLAG_TCR) == SET)\r
2587   {\r
2588     if((hi2c->XferSize == 0)&&(hi2c->XferCount!=0))\r
2589     {\r
2590       DevAddress = (hi2c->Instance->CR2 & I2C_CR2_SADD);\r
2591       \r
2592       if(hi2c->XferCount > 255)\r
2593       {    \r
2594         I2C_TransferConfig(hi2c,DevAddress,255, I2C_RELOAD_MODE, I2C_NO_STARTSTOP);\r
2595         hi2c->XferSize = 255;\r
2596       }\r
2597       else\r
2598       {\r
2599         I2C_TransferConfig(hi2c,DevAddress,hi2c->XferCount, I2C_AUTOEND_MODE, I2C_NO_STARTSTOP);\r
2600         hi2c->XferSize = hi2c->XferCount;\r
2601       }\r
2602     }\r
2603     else\r
2604     {\r
2605       /* Process Unlocked */\r
2606       __HAL_UNLOCK(hi2c);\r
2607       \r
2608       /* Wrong size Status regarding TCR flag event */\r
2609       hi2c->ErrorCode |= HAL_I2C_ERROR_SIZE;\r
2610       HAL_I2C_ErrorCallback(hi2c);\r
2611     }\r
2612   }\r
2613   else if(__HAL_I2C_GET_FLAG(hi2c, I2C_FLAG_TC) == SET)\r
2614   {\r
2615     if(hi2c->XferCount == 0)\r
2616     {\r
2617       /* Generate Stop */\r
2618       hi2c->Instance->CR2 |= I2C_CR2_STOP;\r
2619     }\r
2620     else\r
2621     {\r
2622       /* Process Unlocked */\r
2623       __HAL_UNLOCK(hi2c);\r
2624       \r
2625       /* Wrong size Status regarding TCR flag event */\r
2626       hi2c->ErrorCode |= HAL_I2C_ERROR_SIZE;\r
2627       HAL_I2C_ErrorCallback(hi2c);\r
2628     }\r
2629   }\r
2630   else if(__HAL_I2C_GET_FLAG(hi2c, I2C_FLAG_STOPF) == SET)\r
2631   {\r
2632     /* Disable ERR, TC, STOP, NACK, TXI interrupt */\r
2633     __HAL_I2C_DISABLE_IT(hi2c,I2C_IT_ERRI | I2C_IT_TCI| I2C_IT_STOPI| I2C_IT_NACKI | I2C_IT_TXI );\r
2634 \r
2635     /* Clear STOP Flag */\r
2636     __HAL_I2C_CLEAR_FLAG(hi2c, I2C_FLAG_STOPF);\r
2637 \r
2638     /* Clear Configuration Register 2 */\r
2639     I2C_RESET_CR2(hi2c);\r
2640 \r
2641     hi2c->State = HAL_I2C_STATE_READY;\r
2642 \r
2643     /* Process Unlocked */\r
2644     __HAL_UNLOCK(hi2c);\r
2645 \r
2646     if(hi2c->State == HAL_I2C_STATE_MEM_BUSY_TX)\r
2647     {\r
2648       HAL_I2C_MemTxCpltCallback(hi2c);\r
2649     }\r
2650     else\r
2651     {\r
2652       HAL_I2C_MasterTxCpltCallback(hi2c);\r
2653     }\r
2654   }\r
2655   else if(__HAL_I2C_GET_FLAG(hi2c, I2C_FLAG_AF) == SET)\r
2656   {\r
2657     /* Clear NACK Flag */\r
2658     __HAL_I2C_CLEAR_FLAG(hi2c, I2C_FLAG_AF);\r
2659 \r
2660     /* Process Unlocked */\r
2661     __HAL_UNLOCK(hi2c);\r
2662     \r
2663     hi2c->ErrorCode |= HAL_I2C_ERROR_AF;\r
2664     HAL_I2C_ErrorCallback(hi2c);\r
2665   }\r
2666   \r
2667   /* Process Unlocked */\r
2668   __HAL_UNLOCK(hi2c);\r
2669   \r
2670   return HAL_OK;    \r
2671 }  \r
2672 \r
2673 /**\r
2674   * @brief  Handle Interrupt Flags Master Receive Mode\r
2675   * @param  hi2c : Pointer to a I2C_HandleTypeDef structure that contains\r
2676   *                the configuration information for the specified I2C.\r
2677   * @retval HAL status\r
2678   */\r
2679 static HAL_StatusTypeDef I2C_MasterReceive_ISR(I2C_HandleTypeDef *hi2c) \r
2680 {\r
2681   uint16_t DevAddress;\r
2682 \r
2683   /* Process Locked */\r
2684   __HAL_LOCK(hi2c);\r
2685   \r
2686   if(__HAL_I2C_GET_FLAG(hi2c, I2C_FLAG_RXNE) == SET)\r
2687   {  \r
2688     /* Read data from RXDR */\r
2689     (*hi2c->pBuffPtr++) = hi2c->Instance->RXDR;\r
2690     hi2c->XferSize--;\r
2691     hi2c->XferCount--;\r
2692   }\r
2693   else if(__HAL_I2C_GET_FLAG(hi2c, I2C_FLAG_TCR) == SET)\r
2694   {\r
2695     if((hi2c->XferSize == 0)&&(hi2c->XferCount!=0))\r
2696     {                  \r
2697       DevAddress = (hi2c->Instance->CR2 & I2C_CR2_SADD);\r
2698       \r
2699       if(hi2c->XferCount > 255)\r
2700       {\r
2701         I2C_TransferConfig(hi2c,DevAddress,255, I2C_RELOAD_MODE, I2C_NO_STARTSTOP);\r
2702         hi2c->XferSize = 255;\r
2703       }      \r
2704       else\r
2705       {    \r
2706         I2C_TransferConfig(hi2c,DevAddress,hi2c->XferCount, I2C_AUTOEND_MODE, I2C_NO_STARTSTOP);\r
2707         hi2c->XferSize = hi2c->XferCount;\r
2708       } \r
2709     } \r
2710     else\r
2711     {\r
2712       /* Process Unlocked */\r
2713       __HAL_UNLOCK(hi2c);\r
2714       \r
2715       /* Wrong size Status regarding TCR flag event */\r
2716       hi2c->ErrorCode |= HAL_I2C_ERROR_SIZE;\r
2717       HAL_I2C_ErrorCallback(hi2c);\r
2718     }\r
2719   }\r
2720   else if(__HAL_I2C_GET_FLAG(hi2c, I2C_FLAG_TC) == SET)\r
2721   {\r
2722     if(hi2c->XferCount == 0)\r
2723     {\r
2724       /* Generate Stop */\r
2725       hi2c->Instance->CR2 |= I2C_CR2_STOP;\r
2726     }\r
2727     else\r
2728     {\r
2729       /* Process Unlocked */\r
2730       __HAL_UNLOCK(hi2c);\r
2731       \r
2732       /* Wrong size Status regarding TCR flag event */\r
2733       hi2c->ErrorCode |= HAL_I2C_ERROR_SIZE;\r
2734       HAL_I2C_ErrorCallback(hi2c);\r
2735     }\r
2736   }\r
2737   else if(__HAL_I2C_GET_FLAG(hi2c, I2C_FLAG_STOPF) == SET)\r
2738   {\r
2739     /* Disable ERR, TC, STOP, NACK, TXI interrupt */\r
2740     __HAL_I2C_DISABLE_IT(hi2c,I2C_IT_ERRI | I2C_IT_TCI| I2C_IT_STOPI| I2C_IT_NACKI | I2C_IT_RXI );\r
2741       \r
2742     /* Clear STOP Flag */\r
2743     __HAL_I2C_CLEAR_FLAG(hi2c, I2C_FLAG_STOPF);\r
2744       \r
2745     /* Clear Configuration Register 2 */\r
2746     I2C_RESET_CR2(hi2c);\r
2747     \r
2748     hi2c->State = HAL_I2C_STATE_READY;\r
2749 \r
2750     /* Process Unlocked */\r
2751     __HAL_UNLOCK(hi2c);\r
2752     \r
2753     if(hi2c->State == HAL_I2C_STATE_MEM_BUSY_RX)\r
2754     {\r
2755       HAL_I2C_MemRxCpltCallback(hi2c);\r
2756     }\r
2757     else\r
2758     {\r
2759       HAL_I2C_MasterRxCpltCallback(hi2c);\r
2760     }\r
2761   }\r
2762   else if(__HAL_I2C_GET_FLAG(hi2c, I2C_FLAG_AF) == SET)\r
2763   {\r
2764     /* Clear NACK Flag */\r
2765     __HAL_I2C_CLEAR_FLAG(hi2c, I2C_FLAG_AF);\r
2766 \r
2767     /* Process Unlocked */\r
2768     __HAL_UNLOCK(hi2c);\r
2769     \r
2770     hi2c->ErrorCode |= HAL_I2C_ERROR_AF;\r
2771     HAL_I2C_ErrorCallback(hi2c);\r
2772   }\r
2773     \r
2774   /* Process Unlocked */\r
2775   __HAL_UNLOCK(hi2c); \r
2776   \r
2777   return HAL_OK; \r
2778 \r
2779 }  \r
2780 \r
2781 /**\r
2782   * @brief  Handle Interrupt Flags Slave Transmit Mode\r
2783   * @param  hi2c : Pointer to a I2C_HandleTypeDef structure that contains\r
2784   *                the configuration information for the specified I2C.\r
2785   * @retval HAL status\r
2786   */\r
2787 static HAL_StatusTypeDef I2C_SlaveTransmit_ISR(I2C_HandleTypeDef *hi2c) \r
2788 {\r
2789   /* Process locked */\r
2790   __HAL_LOCK(hi2c);\r
2791   \r
2792   if(__HAL_I2C_GET_FLAG(hi2c, I2C_FLAG_AF) != RESET)\r
2793   {\r
2794     /* Check that I2C transfer finished */\r
2795     /* if yes, normal usecase, a NACK is sent by the MASTER when Transfer is finished */\r
2796     /* Mean XferCount == 0*/\r
2797     /* So clear Flag NACKF only */\r
2798     if(hi2c->XferCount == 0)\r
2799     {\r
2800       /* Clear NACK Flag */\r
2801       __HAL_I2C_CLEAR_FLAG(hi2c, I2C_FLAG_AF);\r
2802 \r
2803       /* Process Unlocked */\r
2804       __HAL_UNLOCK(hi2c);\r
2805     }\r
2806     else\r
2807     {\r
2808       /* if no, error usecase, a Non-Acknowledge of last Data is generated by the MASTER*/\r
2809       /* Clear NACK Flag */\r
2810       __HAL_I2C_CLEAR_FLAG(hi2c, I2C_FLAG_AF);\r
2811 \r
2812       /* Set ErrorCode corresponding to a Non-Acknowledge */\r
2813       hi2c->ErrorCode |= HAL_I2C_ERROR_AF;\r
2814 \r
2815       /* Process Unlocked */\r
2816       __HAL_UNLOCK(hi2c);\r
2817     \r
2818       /* Call the Error callback to prevent upper layer */\r
2819       HAL_I2C_ErrorCallback(hi2c);\r
2820     }\r
2821   }\r
2822   else if(__HAL_I2C_GET_FLAG(hi2c, I2C_FLAG_ADDR) == SET)\r
2823   {\r
2824     /* Clear ADDR flag */\r
2825     __HAL_I2C_CLEAR_FLAG(hi2c, I2C_FLAG_ADDR);\r
2826   }\r
2827   /* Check first if STOPF is set          */\r
2828   /* to prevent a Write Data in TX buffer */\r
2829   /* which is stuck in TXDR until next    */\r
2830   /* communication with Master            */\r
2831   else if(__HAL_I2C_GET_FLAG(hi2c, I2C_FLAG_STOPF) == SET)\r
2832   {\r
2833     /* Disable ERRI, TCI, STOPI, NACKI, ADDRI, RXI, TXI interrupt */\r
2834     __HAL_I2C_DISABLE_IT(hi2c,I2C_IT_ERRI | I2C_IT_TCI| I2C_IT_STOPI| I2C_IT_NACKI | I2C_IT_ADDRI | I2C_IT_RXI | I2C_IT_TXI );\r
2835     \r
2836     /* Disable Address Acknowledge */\r
2837     hi2c->Instance->CR2 |= I2C_CR2_NACK;\r
2838 \r
2839     /* Clear STOP Flag */\r
2840     __HAL_I2C_CLEAR_FLAG(hi2c, I2C_FLAG_STOPF);\r
2841 \r
2842     hi2c->State = HAL_I2C_STATE_READY;\r
2843     \r
2844     /* Process Unlocked */\r
2845     __HAL_UNLOCK(hi2c);\r
2846 \r
2847     HAL_I2C_SlaveTxCpltCallback(hi2c);\r
2848   }\r
2849   else if(__HAL_I2C_GET_FLAG(hi2c, I2C_FLAG_TXIS) == SET)\r
2850   {\r
2851     /* Write data to TXDR only if XferCount not reach "0" */\r
2852     /* A TXIS flag can be set, during STOP treatment      */\r
2853     if(hi2c->XferCount > 0)\r
2854     {\r
2855       /* Write data to TXDR */\r
2856       hi2c->Instance->TXDR = (*hi2c->pBuffPtr++);\r
2857       hi2c->XferCount--;\r
2858     }\r
2859   }\r
2860 \r
2861   /* Process Unlocked */\r
2862   __HAL_UNLOCK(hi2c);\r
2863   \r
2864   return HAL_OK;\r
2865 }  \r
2866 \r
2867 /**\r
2868   * @brief  Handle Interrupt Flags Slave Receive Mode\r
2869   * @param  hi2c : Pointer to a I2C_HandleTypeDef structure that contains\r
2870   *                the configuration information for the specified I2C.\r
2871   * @retval HAL status\r
2872   */\r
2873 static HAL_StatusTypeDef I2C_SlaveReceive_ISR(I2C_HandleTypeDef *hi2c) \r
2874 {\r
2875   /* Process Locked */\r
2876   __HAL_LOCK(hi2c);\r
2877   \r
2878   if(__HAL_I2C_GET_FLAG(hi2c, I2C_FLAG_AF) != RESET)\r
2879   {\r
2880     /* Clear NACK Flag */\r
2881     __HAL_I2C_CLEAR_FLAG(hi2c, I2C_FLAG_AF);\r
2882 \r
2883     /* Process Unlocked */\r
2884     __HAL_UNLOCK(hi2c);\r
2885     \r
2886     hi2c->ErrorCode |= HAL_I2C_ERROR_AF;\r
2887     HAL_I2C_ErrorCallback(hi2c);\r
2888   }\r
2889   else if(__HAL_I2C_GET_FLAG(hi2c, I2C_FLAG_ADDR) == SET)\r
2890   {\r
2891     /* Clear ADDR flag */\r
2892     __HAL_I2C_CLEAR_FLAG(hi2c, I2C_FLAG_ADDR);\r
2893   }\r
2894   else if(__HAL_I2C_GET_FLAG(hi2c, I2C_FLAG_RXNE) == SET)\r
2895   {\r
2896     /* Read data from RXDR */\r
2897     (*hi2c->pBuffPtr++) = hi2c->Instance->RXDR;\r
2898     hi2c->XferSize--;\r
2899     hi2c->XferCount--;\r
2900   }\r
2901   else if(__HAL_I2C_GET_FLAG(hi2c, I2C_FLAG_STOPF) == SET)\r
2902   {\r
2903     /* Disable ERRI, TCI, STOPI, NACKI, ADDRI, RXI, TXI interrupt */\r
2904     __HAL_I2C_DISABLE_IT(hi2c,I2C_IT_ERRI | I2C_IT_TCI| I2C_IT_STOPI| I2C_IT_NACKI | I2C_IT_ADDRI | I2C_IT_RXI | I2C_IT_RXI );\r
2905     \r
2906     /* Disable Address Acknowledge */\r
2907     hi2c->Instance->CR2 |= I2C_CR2_NACK;\r
2908 \r
2909     /* Clear STOP Flag */\r
2910     __HAL_I2C_CLEAR_FLAG(hi2c, I2C_FLAG_STOPF);\r
2911 \r
2912     hi2c->State = HAL_I2C_STATE_READY;\r
2913     \r
2914     /* Process Unlocked */\r
2915     __HAL_UNLOCK(hi2c);\r
2916 \r
2917     HAL_I2C_SlaveRxCpltCallback(hi2c);\r
2918   }\r
2919 \r
2920   /* Process Unlocked */\r
2921   __HAL_UNLOCK(hi2c);\r
2922   \r
2923   return HAL_OK;     \r
2924 }  \r
2925 \r
2926 /**\r
2927   * @brief  Master sends target device address followed by internal memory address for write request.\r
2928   * @param  hi2c : Pointer to a I2C_HandleTypeDef structure that contains\r
2929   *                the configuration information for the specified I2C.\r
2930   * @param  DevAddress: Target device address\r
2931   * @param  MemAddress: Internal memory address\r
2932   * @param  MemAddSize: Size of internal memory address\r
2933   * @param  Timeout: Timeout duration\r
2934   * @retval HAL status\r
2935   */\r
2936 static HAL_StatusTypeDef I2C_RequestMemoryWrite(I2C_HandleTypeDef *hi2c, uint16_t DevAddress, uint16_t MemAddress, uint16_t MemAddSize, uint32_t Timeout)   \r
2937 {\r
2938   I2C_TransferConfig(hi2c,DevAddress,MemAddSize, I2C_RELOAD_MODE, I2C_GENERATE_START_WRITE);\r
2939 \r
2940   /* Wait until TXIS flag is set */\r
2941   if(I2C_WaitOnTXISFlagUntilTimeout(hi2c, Timeout) != HAL_OK)\r
2942   {\r
2943     if(hi2c->ErrorCode == HAL_I2C_ERROR_AF)\r
2944     {\r
2945       return HAL_ERROR;\r
2946     }\r
2947     else\r
2948     {\r
2949       return HAL_TIMEOUT;\r
2950     }\r
2951   }\r
2952 \r
2953   /* If Memory address size is 8Bit */\r
2954   if(MemAddSize == I2C_MEMADD_SIZE_8BIT)\r
2955   {\r
2956     /* Send Memory Address */\r
2957     hi2c->Instance->TXDR = I2C_MEM_ADD_LSB(MemAddress);    \r
2958   }      \r
2959   /* If Memory address size is 16Bit */\r
2960   else\r
2961   {\r
2962     /* Send MSB of Memory Address */\r
2963     hi2c->Instance->TXDR = I2C_MEM_ADD_MSB(MemAddress); \r
2964     \r
2965     /* Wait until TXIS flag is set */\r
2966     if(I2C_WaitOnTXISFlagUntilTimeout(hi2c, Timeout) != HAL_OK)\r
2967     {\r
2968       if(hi2c->ErrorCode == HAL_I2C_ERROR_AF)\r
2969       {\r
2970         return HAL_ERROR;\r
2971       }\r
2972       else\r
2973       {\r
2974         return HAL_TIMEOUT;\r
2975       }\r
2976     }\r
2977     \r
2978     /* Send LSB of Memory Address */\r
2979     hi2c->Instance->TXDR = I2C_MEM_ADD_LSB(MemAddress);  \r
2980   }\r
2981   \r
2982   /* Wait until TCR flag is set */\r
2983   if(I2C_WaitOnFlagUntilTimeout(hi2c, I2C_FLAG_TCR, RESET, Timeout) != HAL_OK)      \r
2984   {\r
2985     return HAL_TIMEOUT;\r
2986   }\r
2987 \r
2988 return HAL_OK;\r
2989 }\r
2990 \r
2991 /**\r
2992   * @brief  Master sends target device address followed by internal memory address for read request.\r
2993   * @param  hi2c : Pointer to a I2C_HandleTypeDef structure that contains\r
2994   *                the configuration information for the specified I2C.\r
2995   * @param  DevAddress: Target device address\r
2996   * @param  MemAddress: Internal memory address\r
2997   * @param  MemAddSize: Size of internal memory address\r
2998   * @param  Timeout: Timeout duration\r
2999   * @retval HAL status\r
3000   */\r
3001 static HAL_StatusTypeDef I2C_RequestMemoryRead(I2C_HandleTypeDef *hi2c, uint16_t DevAddress, uint16_t MemAddress, uint16_t MemAddSize, uint32_t Timeout)\r
3002 {\r
3003   I2C_TransferConfig(hi2c,DevAddress,MemAddSize, I2C_SOFTEND_MODE, I2C_GENERATE_START_WRITE);\r
3004   \r
3005   /* Wait until TXIS flag is set */\r
3006   if(I2C_WaitOnTXISFlagUntilTimeout(hi2c, Timeout) != HAL_OK)\r
3007   {\r
3008     if(hi2c->ErrorCode == HAL_I2C_ERROR_AF)\r
3009     {\r
3010       return HAL_ERROR;\r
3011     }\r
3012     else\r
3013     {\r
3014       return HAL_TIMEOUT;\r
3015     }\r
3016   }\r
3017   \r
3018   /* If Memory address size is 8Bit */\r
3019   if(MemAddSize == I2C_MEMADD_SIZE_8BIT)\r
3020   {\r
3021     /* Send Memory Address */\r
3022     hi2c->Instance->TXDR = I2C_MEM_ADD_LSB(MemAddress);    \r
3023   }      \r
3024   /* If Memory address size is 16Bit */\r
3025   else\r
3026   {\r
3027     /* Send MSB of Memory Address */\r
3028     hi2c->Instance->TXDR = I2C_MEM_ADD_MSB(MemAddress); \r
3029     \r
3030     /* Wait until TXIS flag is set */\r
3031     if(I2C_WaitOnTXISFlagUntilTimeout(hi2c, Timeout) != HAL_OK)\r
3032     {\r
3033       if(hi2c->ErrorCode == HAL_I2C_ERROR_AF)\r
3034       {\r
3035         return HAL_ERROR;\r
3036       }\r
3037       else\r
3038       {\r
3039         return HAL_TIMEOUT;\r
3040       }\r
3041     }\r
3042     \r
3043     /* Send LSB of Memory Address */\r
3044     hi2c->Instance->TXDR = I2C_MEM_ADD_LSB(MemAddress);  \r
3045   }\r
3046   \r
3047   /* Wait until TC flag is set */\r
3048   if(I2C_WaitOnFlagUntilTimeout(hi2c, I2C_FLAG_TC, RESET, Timeout) != HAL_OK)      \r
3049   {\r
3050     return HAL_TIMEOUT;\r
3051   }\r
3052   \r
3053   return HAL_OK;\r
3054 }\r
3055 \r
3056 /**\r
3057   * @brief  DMA I2C master transmit process complete callback.\r
3058   * @param  hdma: DMA handle\r
3059   * @retval None\r
3060   */\r
3061 static void I2C_DMAMasterTransmitCplt(DMA_HandleTypeDef *hdma) \r
3062 {\r
3063   uint16_t DevAddress;\r
3064   I2C_HandleTypeDef* hi2c = (I2C_HandleTypeDef*)((DMA_HandleTypeDef*)hdma)->Parent;\r
3065   \r
3066   /* Check if last DMA request was done with RELOAD */\r
3067   /* Set NBYTES to write and reload if size > 255 */\r
3068   if( (hi2c->XferSize == 255) && (hi2c->XferSize < hi2c->XferCount) )\r
3069   {\r
3070     /* Wait until TCR flag is set */\r
3071     if(I2C_WaitOnFlagUntilTimeout(hi2c, I2C_FLAG_TCR, RESET, I2C_TIMEOUT_TCR) != HAL_OK)      \r
3072     {\r
3073       hi2c->ErrorCode |= HAL_I2C_ERROR_TIMEOUT;\r
3074     }\r
3075 \r
3076     /* Disable DMA Request */\r
3077     hi2c->Instance->CR1 &= ~I2C_CR1_TXDMAEN; \r
3078     \r
3079     /* Check if Errors has been detected during transfer */\r
3080     if(hi2c->ErrorCode != HAL_I2C_ERROR_NONE)\r
3081     {\r
3082       /* No need to Check TC flag, with AUTOEND mode the stop is automatically generated */\r
3083       /* Wait until STOPF flag is reset */ \r
3084       if(I2C_WaitOnSTOPFlagUntilTimeout(hi2c, I2C_TIMEOUT_STOPF) != HAL_OK)\r
3085       {\r
3086         if(hi2c->ErrorCode == HAL_I2C_ERROR_AF)\r
3087         {\r
3088           hi2c->ErrorCode |= HAL_I2C_ERROR_AF;\r
3089         }\r
3090         else\r
3091         {\r
3092           hi2c->ErrorCode |= HAL_I2C_ERROR_TIMEOUT;\r
3093         }\r
3094       }\r
3095     \r
3096       /* Clear STOP Flag */\r
3097       __HAL_I2C_CLEAR_FLAG(hi2c, I2C_FLAG_STOPF);\r
3098           \r
3099       /* Clear Configuration Register 2 */\r
3100       I2C_RESET_CR2(hi2c);\r
3101 \r
3102       hi2c->XferCount = 0;\r
3103     \r
3104       hi2c->State = HAL_I2C_STATE_READY;\r
3105       HAL_I2C_ErrorCallback(hi2c);\r
3106     }\r
3107     else\r
3108     {\r
3109       hi2c->pBuffPtr += hi2c->XferSize;\r
3110       hi2c->XferCount -= hi2c->XferSize;\r
3111       if(hi2c->XferCount > 255)\r
3112       {\r
3113         hi2c->XferSize = 255;\r
3114       }\r
3115       else\r
3116       {\r
3117         hi2c->XferSize = hi2c->XferCount;\r
3118       }\r
3119 \r
3120       DevAddress = (hi2c->Instance->CR2 & I2C_CR2_SADD);\r
3121               \r
3122       /* Enable the DMA channel */\r
3123       HAL_DMA_Start_IT(hi2c->hdmatx, (uint32_t)hi2c->pBuffPtr, (uint32_t)&hi2c->Instance->TXDR, hi2c->XferSize);\r
3124       \r
3125       /* Send Slave Address */\r
3126       /* Set NBYTES to write and reload if size > 255 */\r
3127       if( (hi2c->XferSize == 255) && (hi2c->XferSize < hi2c->XferCount) )\r
3128       {\r
3129         I2C_TransferConfig(hi2c,DevAddress,hi2c->XferSize, I2C_RELOAD_MODE, I2C_NO_STARTSTOP);\r
3130       }\r
3131       else\r
3132       {\r
3133         I2C_TransferConfig(hi2c,DevAddress,hi2c->XferSize, I2C_AUTOEND_MODE, I2C_NO_STARTSTOP);\r
3134       }  \r
3135 \r
3136       /* Wait until TXIS flag is set */\r
3137       if(I2C_WaitOnTXISFlagUntilTimeout(hi2c, I2C_TIMEOUT_TXIS) != HAL_OK)\r
3138       {\r
3139         /* No need to Check TC flag, with AUTOEND mode the stop is automatically generated */\r
3140         /* Wait until STOPF flag is reset */ \r
3141         if(I2C_WaitOnSTOPFlagUntilTimeout(hi2c, I2C_TIMEOUT_STOPF) != HAL_OK)\r
3142         {\r
3143           if(hi2c->ErrorCode == HAL_I2C_ERROR_AF)\r
3144           {\r
3145             hi2c->ErrorCode |= HAL_I2C_ERROR_AF;\r
3146           }\r
3147           else\r
3148           {\r
3149             hi2c->ErrorCode |= HAL_I2C_ERROR_TIMEOUT;\r
3150           }\r
3151         }\r
3152       \r
3153         /* Clear STOP Flag */\r
3154         __HAL_I2C_CLEAR_FLAG(hi2c, I2C_FLAG_STOPF);\r
3155             \r
3156         /* Clear Configuration Register 2 */\r
3157         I2C_RESET_CR2(hi2c);\r
3158 \r
3159         hi2c->XferCount = 0;\r
3160       \r
3161         hi2c->State = HAL_I2C_STATE_READY;\r
3162         HAL_I2C_ErrorCallback(hi2c);\r
3163       }\r
3164       else\r
3165       {\r
3166         /* Enable DMA Request */\r
3167         hi2c->Instance->CR1 |= I2C_CR1_TXDMAEN;\r
3168       }\r
3169     }\r
3170   }\r
3171   else\r
3172   {\r
3173     /* No need to Check TC flag, with AUTOEND mode the stop is automatically generated */\r
3174     /* Wait until STOPF flag is reset */ \r
3175     if(I2C_WaitOnSTOPFlagUntilTimeout(hi2c, I2C_TIMEOUT_STOPF) != HAL_OK)\r
3176     {\r
3177       if(hi2c->ErrorCode == HAL_I2C_ERROR_AF)\r
3178       {\r
3179         hi2c->ErrorCode |= HAL_I2C_ERROR_AF;\r
3180       }\r
3181       else\r
3182       {\r
3183         hi2c->ErrorCode |= HAL_I2C_ERROR_TIMEOUT;\r
3184       }\r
3185     }\r
3186   \r
3187     /* Clear STOP Flag */\r
3188     __HAL_I2C_CLEAR_FLAG(hi2c, I2C_FLAG_STOPF);\r
3189         \r
3190     /* Clear Configuration Register 2 */\r
3191     I2C_RESET_CR2(hi2c);\r
3192 \r
3193     /* Disable DMA Request */\r
3194     hi2c->Instance->CR1 &= ~I2C_CR1_TXDMAEN; \r
3195   \r
3196     hi2c->XferCount = 0;\r
3197   \r
3198     hi2c->State = HAL_I2C_STATE_READY;\r
3199 \r
3200    /* Check if Errors has been detected during transfer */\r
3201     if(hi2c->ErrorCode != HAL_I2C_ERROR_NONE)\r
3202     {\r
3203       HAL_I2C_ErrorCallback(hi2c);\r
3204     }\r
3205     else\r
3206     {\r
3207       HAL_I2C_MasterTxCpltCallback(hi2c);\r
3208     }\r
3209   }\r
3210 }\r
3211 \r
3212 /**\r
3213   * @brief  DMA I2C slave transmit process complete callback. \r
3214   * @param  hdma: DMA handle\r
3215   * @retval None\r
3216   */\r
3217 static void I2C_DMASlaveTransmitCplt(DMA_HandleTypeDef *hdma) \r
3218 {\r
3219   I2C_HandleTypeDef* hi2c = (I2C_HandleTypeDef*)((DMA_HandleTypeDef*)hdma)->Parent;\r
3220   \r
3221   /* Wait until STOP flag is set */\r
3222   if(I2C_WaitOnSTOPFlagUntilTimeout(hi2c, I2C_TIMEOUT_STOPF) != HAL_OK)\r
3223   {\r
3224     if(hi2c->ErrorCode == HAL_I2C_ERROR_AF)\r
3225     {\r
3226       /* Normal Use case, a AF is generated by master */\r
3227       /* to inform slave the end of transfer */\r
3228       hi2c->ErrorCode = HAL_I2C_ERROR_NONE;\r
3229     }\r
3230     else\r
3231     {\r
3232       hi2c->ErrorCode |= HAL_I2C_ERROR_TIMEOUT;\r
3233     }\r
3234   }\r
3235   \r
3236   /* Clear STOP flag */\r
3237   __HAL_I2C_CLEAR_FLAG(hi2c,I2C_FLAG_STOPF);\r
3238   \r
3239   /* Wait until BUSY flag is reset */ \r
3240   if(I2C_WaitOnFlagUntilTimeout(hi2c, I2C_FLAG_BUSY, SET, I2C_TIMEOUT_BUSY) != HAL_OK)      \r
3241   {\r
3242     hi2c->ErrorCode |= HAL_I2C_ERROR_TIMEOUT;\r
3243   }\r
3244   \r
3245   /* Disable DMA Request */\r
3246   hi2c->Instance->CR1 &= ~I2C_CR1_TXDMAEN; \r
3247   \r
3248   hi2c->XferCount = 0;\r
3249   \r
3250   hi2c->State = HAL_I2C_STATE_READY;\r
3251 \r
3252   /* Check if Errors has been detected during transfer */\r
3253   if(hi2c->ErrorCode != HAL_I2C_ERROR_NONE)\r
3254   {\r
3255     HAL_I2C_ErrorCallback(hi2c);\r
3256   }\r
3257   else\r
3258   {\r
3259     HAL_I2C_SlaveTxCpltCallback(hi2c);\r
3260   }\r
3261 }\r
3262 \r
3263 /**\r
3264   * @brief DMA I2C master receive process complete callback \r
3265   * @param  hdma: DMA handle\r
3266   * @retval None\r
3267   */\r
3268 static void I2C_DMAMasterReceiveCplt(DMA_HandleTypeDef *hdma) \r
3269 {\r
3270   I2C_HandleTypeDef* hi2c = (I2C_HandleTypeDef*)((DMA_HandleTypeDef*)hdma)->Parent;\r
3271   uint16_t DevAddress;\r
3272   \r
3273   /* Check if last DMA request was done with RELOAD */\r
3274   /* Set NBYTES to write and reload if size > 255 */\r
3275   if( (hi2c->XferSize == 255) && (hi2c->XferSize < hi2c->XferCount) )\r
3276   {\r
3277     /* Wait until TCR flag is set */\r
3278     if(I2C_WaitOnFlagUntilTimeout(hi2c, I2C_FLAG_TCR, RESET, I2C_TIMEOUT_TCR) != HAL_OK)      \r
3279     {\r
3280       hi2c->ErrorCode |= HAL_I2C_ERROR_TIMEOUT;\r
3281     }\r
3282 \r
3283     /* Disable DMA Request */\r
3284     hi2c->Instance->CR1 &= ~I2C_CR1_RXDMAEN; \r
3285 \r
3286     /* Check if Errors has been detected during transfer */\r
3287     if(hi2c->ErrorCode != HAL_I2C_ERROR_NONE)\r
3288     {\r
3289       /* No need to Check TC flag, with AUTOEND mode the stop is automatically generated */\r
3290       /* Wait until STOPF flag is reset */ \r
3291       if(I2C_WaitOnSTOPFlagUntilTimeout(hi2c, I2C_TIMEOUT_STOPF) != HAL_OK)\r
3292       {\r
3293         if(hi2c->ErrorCode == HAL_I2C_ERROR_AF)\r
3294         {\r
3295           hi2c->ErrorCode |= HAL_I2C_ERROR_AF;\r
3296         }\r
3297         else\r
3298         {\r
3299           hi2c->ErrorCode |= HAL_I2C_ERROR_TIMEOUT;\r
3300         }\r
3301       }\r
3302     \r
3303       /* Clear STOP Flag */\r
3304       __HAL_I2C_CLEAR_FLAG(hi2c, I2C_FLAG_STOPF);\r
3305           \r
3306       /* Clear Configuration Register 2 */\r
3307       I2C_RESET_CR2(hi2c);\r
3308     \r
3309       hi2c->XferCount = 0;\r
3310     \r
3311       hi2c->State = HAL_I2C_STATE_READY;\r
3312       HAL_I2C_ErrorCallback(hi2c);\r
3313     }\r
3314     else\r
3315     {\r
3316       hi2c->pBuffPtr += hi2c->XferSize;\r
3317       hi2c->XferCount -= hi2c->XferSize;\r
3318       if(hi2c->XferCount > 255)\r
3319       {\r
3320         hi2c->XferSize = 255;\r
3321       }\r
3322       else\r
3323       {\r
3324         hi2c->XferSize = hi2c->XferCount;\r
3325       }\r
3326 \r
3327       DevAddress = (hi2c->Instance->CR2 & I2C_CR2_SADD);\r
3328               \r
3329       /* Enable the DMA channel */\r
3330       HAL_DMA_Start_IT(hi2c->hdmarx, (uint32_t)&hi2c->Instance->RXDR, (uint32_t)hi2c->pBuffPtr, hi2c->XferSize);\r
3331       \r
3332       /* Send Slave Address */\r
3333       /* Set NBYTES to write and reload if size > 255 */\r
3334       if( (hi2c->XferSize == 255) && (hi2c->XferSize < hi2c->XferCount) )\r
3335       {\r
3336         I2C_TransferConfig(hi2c,DevAddress,hi2c->XferSize, I2C_RELOAD_MODE, I2C_NO_STARTSTOP);\r
3337       }\r
3338       else\r
3339       {\r
3340         I2C_TransferConfig(hi2c,DevAddress,hi2c->XferSize, I2C_AUTOEND_MODE, I2C_NO_STARTSTOP);\r
3341       }  \r
3342 \r
3343       /* Wait until RXNE flag is set */\r
3344       if(I2C_WaitOnFlagUntilTimeout(hi2c, I2C_FLAG_RXNE, RESET, I2C_TIMEOUT_RXNE) != HAL_OK)      \r
3345       {\r
3346         hi2c->ErrorCode |= HAL_I2C_ERROR_TIMEOUT;\r
3347       }\r
3348       \r
3349       /* Check if Errors has been detected during transfer */\r
3350       if(hi2c->ErrorCode != HAL_I2C_ERROR_NONE)\r
3351       {\r
3352         /* No need to Check TC flag, with AUTOEND mode the stop is automatically generated */\r
3353         /* Wait until STOPF flag is reset */ \r
3354         if(I2C_WaitOnSTOPFlagUntilTimeout(hi2c, I2C_TIMEOUT_STOPF) != HAL_OK)\r
3355         {\r
3356           if(hi2c->ErrorCode == HAL_I2C_ERROR_AF)\r
3357           {\r
3358             hi2c->ErrorCode |= HAL_I2C_ERROR_AF;\r
3359           }\r
3360           else\r
3361           {\r
3362             hi2c->ErrorCode |= HAL_I2C_ERROR_TIMEOUT;\r
3363           }\r
3364         }\r
3365       \r
3366         /* Clear STOP Flag */\r
3367         __HAL_I2C_CLEAR_FLAG(hi2c, I2C_FLAG_STOPF);\r
3368             \r
3369         /* Clear Configuration Register 2 */\r
3370         I2C_RESET_CR2(hi2c);\r
3371       \r
3372         hi2c->XferCount = 0;\r
3373       \r
3374         hi2c->State = HAL_I2C_STATE_READY;\r
3375       \r
3376         HAL_I2C_ErrorCallback(hi2c);\r
3377       }\r
3378       else\r
3379       {\r
3380         /* Enable DMA Request */\r
3381         hi2c->Instance->CR1 |= I2C_CR1_RXDMAEN;\r
3382       }\r
3383     }\r
3384   }\r
3385   else\r
3386   {\r
3387     /* No need to Check TC flag, with AUTOEND mode the stop is automatically generated */\r
3388     /* Wait until STOPF flag is reset */ \r
3389     if(I2C_WaitOnSTOPFlagUntilTimeout(hi2c, I2C_TIMEOUT_STOPF) != HAL_OK)\r
3390     {\r
3391       if(hi2c->ErrorCode == HAL_I2C_ERROR_AF)\r
3392       {\r
3393         hi2c->ErrorCode |= HAL_I2C_ERROR_AF;\r
3394       }\r
3395       else\r
3396       {\r
3397         hi2c->ErrorCode |= HAL_I2C_ERROR_TIMEOUT;\r
3398       }\r
3399     }\r
3400   \r
3401     /* Clear STOP Flag */\r
3402     __HAL_I2C_CLEAR_FLAG(hi2c, I2C_FLAG_STOPF);\r
3403         \r
3404     /* Clear Configuration Register 2 */\r
3405     I2C_RESET_CR2(hi2c);\r
3406   \r
3407     /* Disable DMA Request */\r
3408     hi2c->Instance->CR1 &= ~I2C_CR1_RXDMAEN; \r
3409   \r
3410     hi2c->XferCount = 0;\r
3411   \r
3412     hi2c->State = HAL_I2C_STATE_READY;\r
3413 \r
3414     /* Check if Errors has been detected during transfer */\r
3415     if(hi2c->ErrorCode != HAL_I2C_ERROR_NONE)\r
3416     {\r
3417       HAL_I2C_ErrorCallback(hi2c);\r
3418     }\r
3419     else\r
3420     {\r
3421       HAL_I2C_MasterRxCpltCallback(hi2c);\r
3422     }\r
3423   }\r
3424 }\r
3425 \r
3426 /**\r
3427   * @brief  DMA I2C slave receive process complete callback.\r
3428   * @param  hdma: DMA handle\r
3429   * @retval None\r
3430   */\r
3431 static void I2C_DMASlaveReceiveCplt(DMA_HandleTypeDef *hdma) \r
3432 {  \r
3433   I2C_HandleTypeDef* hi2c = (I2C_HandleTypeDef*)((DMA_HandleTypeDef*)hdma)->Parent;\r
3434   \r
3435   /* Wait until STOPF flag is reset */ \r
3436   if(I2C_WaitOnSTOPFlagUntilTimeout(hi2c, I2C_TIMEOUT_STOPF) != HAL_OK)\r
3437   {\r
3438     if(hi2c->ErrorCode == HAL_I2C_ERROR_AF)\r
3439     {\r
3440       hi2c->ErrorCode |= HAL_I2C_ERROR_AF;\r
3441     }\r
3442     else\r
3443     {\r
3444       hi2c->ErrorCode |= HAL_I2C_ERROR_TIMEOUT;\r
3445     }\r
3446   }\r
3447   \r
3448   /* Clear STOPF flag */\r
3449   __HAL_I2C_CLEAR_FLAG(hi2c, I2C_FLAG_STOPF);\r
3450   \r
3451   /* Wait until BUSY flag is reset */ \r
3452   if(I2C_WaitOnFlagUntilTimeout(hi2c, I2C_FLAG_BUSY, SET, I2C_TIMEOUT_BUSY) != HAL_OK)      \r
3453   {\r
3454     hi2c->ErrorCode |= HAL_I2C_ERROR_TIMEOUT;\r
3455   }\r
3456   \r
3457   /* Disable DMA Request */\r
3458   hi2c->Instance->CR1 &= ~I2C_CR1_RXDMAEN; \r
3459   \r
3460   /* Disable Address Acknowledge */\r
3461   hi2c->Instance->CR2 |= I2C_CR2_NACK;\r
3462 \r
3463   hi2c->XferCount = 0;\r
3464   \r
3465   hi2c->State = HAL_I2C_STATE_READY;\r
3466 \r
3467   /* Check if Errors has been detected during transfer */\r
3468   if(hi2c->ErrorCode != HAL_I2C_ERROR_NONE)\r
3469   {\r
3470     HAL_I2C_ErrorCallback(hi2c);\r
3471   }\r
3472   else\r
3473   {\r
3474     HAL_I2C_SlaveRxCpltCallback(hi2c);\r
3475   }\r
3476 }\r
3477 \r
3478 /**\r
3479   * @brief DMA I2C Memory Write process complete callback \r
3480   * @param hdma : DMA handle\r
3481   * @retval None\r
3482   */\r
3483 static void I2C_DMAMemTransmitCplt(DMA_HandleTypeDef *hdma)   \r
3484 {\r
3485   uint16_t DevAddress;\r
3486   I2C_HandleTypeDef* hi2c = ( I2C_HandleTypeDef* )((DMA_HandleTypeDef* )hdma)->Parent;\r
3487   \r
3488   /* Check if last DMA request was done with RELOAD */\r
3489   /* Set NBYTES to write and reload if size > 255 */\r
3490   if( (hi2c->XferSize == 255) && (hi2c->XferSize < hi2c->XferCount) )\r
3491   {\r
3492     /* Wait until TCR flag is set */\r
3493     if(I2C_WaitOnFlagUntilTimeout(hi2c, I2C_FLAG_TCR, RESET, I2C_TIMEOUT_TCR) != HAL_OK)      \r
3494     {\r
3495       hi2c->ErrorCode |= HAL_I2C_ERROR_TIMEOUT;\r
3496     }\r
3497 \r
3498     /* Disable DMA Request */\r
3499     hi2c->Instance->CR1 &= ~I2C_CR1_TXDMAEN; \r
3500     \r
3501     /* Check if Errors has been detected during transfer */\r
3502     if(hi2c->ErrorCode != HAL_I2C_ERROR_NONE)\r
3503     {\r
3504       /* No need to Check TC flag, with AUTOEND mode the stop is automatically generated */\r
3505       /* Wait until STOPF flag is reset */ \r
3506       if(I2C_WaitOnSTOPFlagUntilTimeout(hi2c, I2C_TIMEOUT_STOPF) != HAL_OK)\r
3507       {\r
3508         if(hi2c->ErrorCode == HAL_I2C_ERROR_AF)\r
3509         {\r
3510           hi2c->ErrorCode |= HAL_I2C_ERROR_AF;\r
3511         }\r
3512         else\r
3513         {\r
3514           hi2c->ErrorCode |= HAL_I2C_ERROR_TIMEOUT;\r
3515         }\r
3516       }\r
3517     \r
3518       /* Clear STOP Flag */\r
3519       __HAL_I2C_CLEAR_FLAG(hi2c, I2C_FLAG_STOPF);\r
3520           \r
3521       /* Clear Configuration Register 2 */\r
3522       I2C_RESET_CR2(hi2c);\r
3523 \r
3524       hi2c->XferCount = 0;\r
3525     \r
3526       hi2c->State = HAL_I2C_STATE_READY;\r
3527       HAL_I2C_ErrorCallback(hi2c);\r
3528     }\r
3529     else\r
3530     {\r
3531       hi2c->pBuffPtr += hi2c->XferSize;\r
3532       hi2c->XferCount -= hi2c->XferSize;\r
3533       if(hi2c->XferCount > 255)\r
3534       {\r
3535         hi2c->XferSize = 255;\r
3536       }\r
3537       else\r
3538       {\r
3539         hi2c->XferSize = hi2c->XferCount;\r
3540       }\r
3541 \r
3542       DevAddress = (hi2c->Instance->CR2 & I2C_CR2_SADD);\r
3543               \r
3544       /* Enable the DMA channel */\r
3545       HAL_DMA_Start_IT(hi2c->hdmatx, (uint32_t)hi2c->pBuffPtr, (uint32_t)&hi2c->Instance->TXDR, hi2c->XferSize);\r
3546       \r
3547       /* Send Slave Address */\r
3548       /* Set NBYTES to write and reload if size > 255 */\r
3549       if( (hi2c->XferSize == 255) && (hi2c->XferSize < hi2c->XferCount) )\r
3550       {\r
3551         I2C_TransferConfig(hi2c,DevAddress,hi2c->XferSize, I2C_RELOAD_MODE, I2C_NO_STARTSTOP);\r
3552       }\r
3553       else\r
3554       {\r
3555         I2C_TransferConfig(hi2c,DevAddress,hi2c->XferSize, I2C_AUTOEND_MODE, I2C_NO_STARTSTOP);\r
3556       }  \r
3557 \r
3558       /* Wait until TXIS flag is set */\r
3559       if(I2C_WaitOnTXISFlagUntilTimeout(hi2c, I2C_TIMEOUT_TXIS) != HAL_OK)\r
3560       {\r
3561         /* No need to Check TC flag, with AUTOEND mode the stop is automatically generated */\r
3562         /* Wait until STOPF flag is reset */ \r
3563         if(I2C_WaitOnSTOPFlagUntilTimeout(hi2c, I2C_TIMEOUT_STOPF) != HAL_OK)\r
3564         {\r
3565           if(hi2c->ErrorCode == HAL_I2C_ERROR_AF)\r
3566           {\r
3567             hi2c->ErrorCode |= HAL_I2C_ERROR_AF;\r
3568           }\r
3569           else\r
3570           {\r
3571             hi2c->ErrorCode |= HAL_I2C_ERROR_TIMEOUT;\r
3572           }\r
3573         }\r
3574       \r
3575         /* Clear STOP Flag */\r
3576         __HAL_I2C_CLEAR_FLAG(hi2c, I2C_FLAG_STOPF);\r
3577             \r
3578         /* Clear Configuration Register 2 */\r
3579         I2C_RESET_CR2(hi2c);\r
3580 \r
3581         hi2c->XferCount = 0;\r
3582       \r
3583         hi2c->State = HAL_I2C_STATE_READY;\r
3584         HAL_I2C_ErrorCallback(hi2c);\r
3585       }\r
3586       else\r
3587       {\r
3588         /* Enable DMA Request */\r
3589         hi2c->Instance->CR1 |= I2C_CR1_TXDMAEN;\r
3590       }\r
3591     }\r
3592   }\r
3593   else\r
3594   {\r
3595     /* No need to Check TC flag, with AUTOEND mode the stop is automatically generated */\r
3596     /* Wait until STOPF flag is reset */ \r
3597     if(I2C_WaitOnSTOPFlagUntilTimeout(hi2c, I2C_TIMEOUT_STOPF) != HAL_OK)\r
3598     {\r
3599       if(hi2c->ErrorCode == HAL_I2C_ERROR_AF)\r
3600       {\r
3601         hi2c->ErrorCode |= HAL_I2C_ERROR_AF;\r
3602       }\r
3603       else\r
3604       {\r
3605         hi2c->ErrorCode |= HAL_I2C_ERROR_TIMEOUT;\r
3606       }\r
3607     }\r
3608   \r
3609     /* Clear STOP Flag */\r
3610     __HAL_I2C_CLEAR_FLAG(hi2c, I2C_FLAG_STOPF);\r
3611         \r
3612     /* Clear Configuration Register 2 */\r
3613     I2C_RESET_CR2(hi2c);\r
3614 \r
3615     /* Disable DMA Request */\r
3616     hi2c->Instance->CR1 &= ~I2C_CR1_TXDMAEN; \r
3617   \r
3618     hi2c->XferCount = 0;\r
3619   \r
3620     hi2c->State = HAL_I2C_STATE_READY;\r
3621 \r
3622     /* Check if Errors has been detected during transfer */\r
3623     if(hi2c->ErrorCode != HAL_I2C_ERROR_NONE)\r
3624     {\r
3625       HAL_I2C_ErrorCallback(hi2c);\r
3626     }\r
3627     else\r
3628     {\r
3629       HAL_I2C_MemTxCpltCallback(hi2c);\r
3630     }\r
3631   }\r
3632 }\r
3633 \r
3634 /**\r
3635   * @brief  DMA I2C Memory Read process complete callback\r
3636   * @param  hdma: DMA handle\r
3637   * @retval None\r
3638   */\r
3639 static void I2C_DMAMemReceiveCplt(DMA_HandleTypeDef *hdma)   \r
3640 {  \r
3641   I2C_HandleTypeDef* hi2c = ( I2C_HandleTypeDef* )((DMA_HandleTypeDef* )hdma)->Parent;  \r
3642   uint16_t DevAddress;\r
3643   \r
3644   /* Check if last DMA request was done with RELOAD */\r
3645   /* Set NBYTES to write and reload if size > 255 */\r
3646   if( (hi2c->XferSize == 255) && (hi2c->XferSize < hi2c->XferCount) )\r
3647   {\r
3648     /* Wait until TCR flag is set */\r
3649     if(I2C_WaitOnFlagUntilTimeout(hi2c, I2C_FLAG_TCR, RESET, I2C_TIMEOUT_TCR) != HAL_OK)      \r
3650     {\r
3651       hi2c->ErrorCode |= HAL_I2C_ERROR_TIMEOUT;\r
3652     }\r
3653 \r
3654     /* Disable DMA Request */\r
3655     hi2c->Instance->CR1 &= ~I2C_CR1_RXDMAEN; \r
3656 \r
3657     /* Check if Errors has been detected during transfer */\r
3658     if(hi2c->ErrorCode != HAL_I2C_ERROR_NONE)\r
3659     {\r
3660       /* No need to Check TC flag, with AUTOEND mode the stop is automatically generated */\r
3661       /* Wait until STOPF flag is reset */ \r
3662       if(I2C_WaitOnSTOPFlagUntilTimeout(hi2c, I2C_TIMEOUT_STOPF) != HAL_OK)\r
3663       {\r
3664         if(hi2c->ErrorCode == HAL_I2C_ERROR_AF)\r
3665         {\r
3666           hi2c->ErrorCode |= HAL_I2C_ERROR_AF;\r
3667         }\r
3668         else\r
3669         {\r
3670           hi2c->ErrorCode |= HAL_I2C_ERROR_TIMEOUT;\r
3671         }\r
3672       }\r
3673     \r
3674       /* Clear STOP Flag */\r
3675       __HAL_I2C_CLEAR_FLAG(hi2c, I2C_FLAG_STOPF);\r
3676           \r
3677       /* Clear Configuration Register 2 */\r
3678       I2C_RESET_CR2(hi2c);\r
3679     \r
3680       hi2c->XferCount = 0;\r
3681     \r
3682       hi2c->State = HAL_I2C_STATE_READY;\r
3683       HAL_I2C_ErrorCallback(hi2c);\r
3684     }\r
3685     else\r
3686     {\r
3687       hi2c->pBuffPtr += hi2c->XferSize;\r
3688       hi2c->XferCount -= hi2c->XferSize;\r
3689       if(hi2c->XferCount > 255)\r
3690       {\r
3691         hi2c->XferSize = 255;\r
3692       }\r
3693       else\r
3694       {\r
3695         hi2c->XferSize = hi2c->XferCount;\r
3696       }\r
3697 \r
3698       DevAddress = (hi2c->Instance->CR2 & I2C_CR2_SADD);\r
3699               \r
3700       /* Enable the DMA channel */\r
3701       HAL_DMA_Start_IT(hi2c->hdmarx, (uint32_t)&hi2c->Instance->RXDR, (uint32_t)hi2c->pBuffPtr, hi2c->XferSize);\r
3702       \r
3703       /* Send Slave Address */\r
3704       /* Set NBYTES to write and reload if size > 255 */\r
3705       if( (hi2c->XferSize == 255) && (hi2c->XferSize < hi2c->XferCount) )\r
3706       {\r
3707         I2C_TransferConfig(hi2c,DevAddress,hi2c->XferSize, I2C_RELOAD_MODE, I2C_NO_STARTSTOP);\r
3708       }\r
3709       else\r
3710       {\r
3711         I2C_TransferConfig(hi2c,DevAddress,hi2c->XferSize, I2C_AUTOEND_MODE, I2C_NO_STARTSTOP);\r
3712       }  \r
3713 \r
3714       /* Wait until RXNE flag is set */\r
3715       if(I2C_WaitOnFlagUntilTimeout(hi2c, I2C_FLAG_RXNE, RESET, I2C_TIMEOUT_RXNE) != HAL_OK)      \r
3716       {\r
3717         hi2c->ErrorCode |= HAL_I2C_ERROR_TIMEOUT;\r
3718       }\r
3719       \r
3720       /* Check if Errors has been detected during transfer */\r
3721       if(hi2c->ErrorCode != HAL_I2C_ERROR_NONE)\r
3722       {\r
3723         /* No need to Check TC flag, with AUTOEND mode the stop is automatically generated */\r
3724         /* Wait until STOPF flag is reset */ \r
3725         if(I2C_WaitOnSTOPFlagUntilTimeout(hi2c, I2C_TIMEOUT_STOPF) != HAL_OK)\r
3726         {\r
3727           if(hi2c->ErrorCode == HAL_I2C_ERROR_AF)\r
3728           {\r
3729             hi2c->ErrorCode |= HAL_I2C_ERROR_AF;\r
3730           }\r
3731           else\r
3732           {\r
3733             hi2c->ErrorCode |= HAL_I2C_ERROR_TIMEOUT;\r
3734           }\r
3735         }\r
3736       \r
3737         /* Clear STOP Flag */\r
3738         __HAL_I2C_CLEAR_FLAG(hi2c, I2C_FLAG_STOPF);\r
3739             \r
3740         /* Clear Configuration Register 2 */\r
3741         I2C_RESET_CR2(hi2c);\r
3742       \r
3743         hi2c->XferCount = 0;\r
3744       \r
3745         hi2c->State = HAL_I2C_STATE_READY;\r
3746         HAL_I2C_ErrorCallback(hi2c);\r
3747       }\r
3748       else\r
3749       {\r
3750         /* Enable DMA Request */\r
3751         hi2c->Instance->CR1 |= I2C_CR1_RXDMAEN;\r
3752       }\r
3753     }\r
3754   }\r
3755   else\r
3756   {\r
3757     /* No need to Check TC flag, with AUTOEND mode the stop is automatically generated */\r
3758     /* Wait until STOPF flag is reset */ \r
3759     if(I2C_WaitOnSTOPFlagUntilTimeout(hi2c, I2C_TIMEOUT_STOPF) != HAL_OK)\r
3760     {\r
3761       if(hi2c->ErrorCode == HAL_I2C_ERROR_AF)\r
3762       {\r
3763         hi2c->ErrorCode |= HAL_I2C_ERROR_AF;\r
3764       }\r
3765       else\r
3766       {\r
3767         hi2c->ErrorCode |= HAL_I2C_ERROR_TIMEOUT;\r
3768       }\r
3769     }\r
3770   \r
3771     /* Clear STOP Flag */\r
3772     __HAL_I2C_CLEAR_FLAG(hi2c, I2C_FLAG_STOPF);\r
3773         \r
3774     /* Clear Configuration Register 2 */\r
3775     I2C_RESET_CR2(hi2c);\r
3776   \r
3777     /* Disable DMA Request */\r
3778     hi2c->Instance->CR1 &= ~I2C_CR1_RXDMAEN; \r
3779   \r
3780     hi2c->XferCount = 0;\r
3781   \r
3782     hi2c->State = HAL_I2C_STATE_READY;\r
3783 \r
3784     /* Check if Errors has been detected during transfer */\r
3785     if(hi2c->ErrorCode != HAL_I2C_ERROR_NONE)\r
3786     {\r
3787       HAL_I2C_ErrorCallback(hi2c);\r
3788     }\r
3789     else\r
3790     {\r
3791       HAL_I2C_MemRxCpltCallback(hi2c);\r
3792     }\r
3793   }\r
3794 }\r
3795 \r
3796 /**\r
3797   * @brief  DMA I2C communication error callback. \r
3798   * @param hdma : DMA handle\r
3799   * @retval None\r
3800   */\r
3801 static void I2C_DMAError(DMA_HandleTypeDef *hdma)   \r
3802 {\r
3803   I2C_HandleTypeDef* hi2c = ( I2C_HandleTypeDef* )((DMA_HandleTypeDef* )hdma)->Parent;\r
3804   \r
3805   /* Disable Acknowledge */\r
3806   hi2c->Instance->CR2 |= I2C_CR2_NACK;\r
3807   \r
3808   hi2c->XferCount = 0;\r
3809   \r
3810   hi2c->State = HAL_I2C_STATE_READY;\r
3811   \r
3812   hi2c->ErrorCode |= HAL_I2C_ERROR_DMA;\r
3813   \r
3814   HAL_I2C_ErrorCallback(hi2c);\r
3815 }\r
3816 \r
3817 /**\r
3818   * @brief  This function handles I2C Communication Timeout.\r
3819   * @param  hi2c : Pointer to a I2C_HandleTypeDef structure that contains\r
3820   *                the configuration information for the specified I2C.\r
3821   * @param  Flag: specifies the I2C flag to check.\r
3822   * @param  Status: The new Flag status (SET or RESET).\r
3823   * @param  Timeout: Timeout duration\r
3824   * @retval HAL status\r
3825   */\r
3826 static HAL_StatusTypeDef I2C_WaitOnFlagUntilTimeout(I2C_HandleTypeDef *hi2c, uint32_t Flag, FlagStatus Status, uint32_t Timeout)  \r
3827 {  \r
3828   uint32_t tickstart = HAL_GetTick();\r
3829      \r
3830   /* Wait until flag is set */\r
3831   if(Status == RESET)\r
3832   {    \r
3833     while(__HAL_I2C_GET_FLAG(hi2c, Flag) == RESET)\r
3834     {\r
3835       /* Check for the Timeout */\r
3836       if(Timeout != HAL_MAX_DELAY)\r
3837       {\r
3838         if((Timeout == 0)||((HAL_GetTick() - tickstart ) > Timeout))\r
3839         {\r
3840           hi2c->State= HAL_I2C_STATE_READY;\r
3841           /* Process Unlocked */\r
3842           __HAL_UNLOCK(hi2c);\r
3843           return HAL_TIMEOUT;\r
3844         }\r
3845       }\r
3846     }\r
3847   }\r
3848   else\r
3849   {\r
3850     while(__HAL_I2C_GET_FLAG(hi2c, Flag) != RESET)\r
3851     {\r
3852       /* Check for the Timeout */\r
3853       if(Timeout != HAL_MAX_DELAY)\r
3854       {\r
3855         if((Timeout == 0)||((HAL_GetTick() - tickstart ) > Timeout))\r
3856         {\r
3857           hi2c->State= HAL_I2C_STATE_READY;\r
3858           /* Process Unlocked */\r
3859           __HAL_UNLOCK(hi2c);\r
3860           return HAL_TIMEOUT;\r
3861         }\r
3862       }\r
3863     }\r
3864   }\r
3865   return HAL_OK;\r
3866 }\r
3867 \r
3868 /**\r
3869   * @brief  This function handles I2C Communication Timeout for specific usage of TXIS flag.\r
3870   * @param  hi2c : Pointer to a I2C_HandleTypeDef structure that contains\r
3871   *                the configuration information for the specified I2C.\r
3872   * @param  Timeout: Timeout duration\r
3873   * @retval HAL status\r
3874   */\r
3875 static HAL_StatusTypeDef I2C_WaitOnTXISFlagUntilTimeout(I2C_HandleTypeDef *hi2c, uint32_t Timeout)  \r
3876 {  \r
3877   uint32_t tickstart = HAL_GetTick();\r
3878   \r
3879   while(__HAL_I2C_GET_FLAG(hi2c, I2C_FLAG_TXIS) == RESET)\r
3880   {\r
3881     /* Check if a NACK is detected */\r
3882     if(I2C_IsAcknowledgeFailed(hi2c, Timeout) != HAL_OK)\r
3883     {\r
3884       return HAL_ERROR;\r
3885     }\r
3886                 \r
3887     /* Check for the Timeout */\r
3888     if(Timeout != HAL_MAX_DELAY)\r
3889     {\r
3890       if((Timeout == 0)||((HAL_GetTick() - tickstart ) > Timeout))\r
3891       {\r
3892         hi2c->ErrorCode |= HAL_I2C_ERROR_TIMEOUT;\r
3893         hi2c->State= HAL_I2C_STATE_READY;\r
3894 \r
3895         /* Process Unlocked */\r
3896         __HAL_UNLOCK(hi2c);\r
3897 \r
3898         return HAL_TIMEOUT;\r
3899       }\r
3900     }\r
3901   }\r
3902   return HAL_OK;      \r
3903 }\r
3904 \r
3905 /**\r
3906   * @brief  This function handles I2C Communication Timeout for specific usage of STOP flag.\r
3907   * @param  hi2c : Pointer to a I2C_HandleTypeDef structure that contains\r
3908   *                the configuration information for the specified I2C.\r
3909   * @param  Timeout: Timeout duration\r
3910   * @retval HAL status\r
3911   */\r
3912 static HAL_StatusTypeDef I2C_WaitOnSTOPFlagUntilTimeout(I2C_HandleTypeDef *hi2c, uint32_t Timeout)\r
3913 {  \r
3914   uint32_t tickstart = 0x00;\r
3915   tickstart = HAL_GetTick();\r
3916   \r
3917   while(__HAL_I2C_GET_FLAG(hi2c, I2C_FLAG_STOPF) == RESET)\r
3918   {\r
3919     /* Check if a NACK is detected */\r
3920     if(I2C_IsAcknowledgeFailed(hi2c, Timeout) != HAL_OK)\r
3921     {\r
3922       return HAL_ERROR;\r
3923     }\r
3924                 \r
3925     /* Check for the Timeout */\r
3926     if((Timeout == 0)||((HAL_GetTick() - tickstart ) > Timeout))\r
3927     {\r
3928       hi2c->ErrorCode |= HAL_I2C_ERROR_TIMEOUT;\r
3929       hi2c->State= HAL_I2C_STATE_READY;\r
3930 \r
3931       /* Process Unlocked */\r
3932       __HAL_UNLOCK(hi2c);\r
3933 \r
3934       return HAL_TIMEOUT;\r
3935     }\r
3936   }\r
3937   return HAL_OK;\r
3938 }\r
3939 \r
3940 /**\r
3941   * @brief  This function handles I2C Communication Timeout for specific usage of RXNE flag.\r
3942   * @param  hi2c : Pointer to a I2C_HandleTypeDef structure that contains\r
3943   *                the configuration information for the specified I2C.\r
3944   * @param  Timeout: Timeout duration\r
3945   * @retval HAL status\r
3946   */\r
3947 static HAL_StatusTypeDef I2C_WaitOnRXNEFlagUntilTimeout(I2C_HandleTypeDef *hi2c, uint32_t Timeout)\r
3948 {  \r
3949   uint32_t tickstart = 0x00;\r
3950   tickstart = HAL_GetTick();\r
3951   \r
3952   while(__HAL_I2C_GET_FLAG(hi2c, I2C_FLAG_RXNE) == RESET)\r
3953   {\r
3954     /* Check if a STOPF is detected */\r
3955     if(__HAL_I2C_GET_FLAG(hi2c, I2C_FLAG_STOPF) == SET)\r
3956     {\r
3957       /* Clear STOP Flag */\r
3958       __HAL_I2C_CLEAR_FLAG(hi2c, I2C_FLAG_STOPF);\r
3959 \r
3960       /* Clear Configuration Register 2 */\r
3961       I2C_RESET_CR2(hi2c);\r
3962 \r
3963       hi2c->ErrorCode = HAL_I2C_ERROR_NONE;\r
3964       hi2c->State= HAL_I2C_STATE_READY;\r
3965 \r
3966       /* Process Unlocked */\r
3967       __HAL_UNLOCK(hi2c);\r
3968 \r
3969       return HAL_ERROR;\r
3970     }\r
3971                 \r
3972     /* Check for the Timeout */\r
3973     if((Timeout == 0)||((HAL_GetTick() - tickstart ) > Timeout))\r
3974     {\r
3975       hi2c->ErrorCode |= HAL_I2C_ERROR_TIMEOUT;\r
3976       hi2c->State= HAL_I2C_STATE_READY;\r
3977 \r
3978       /* Process Unlocked */\r
3979       __HAL_UNLOCK(hi2c);\r
3980 \r
3981       return HAL_TIMEOUT;\r
3982     }\r
3983   }\r
3984   return HAL_OK;\r
3985 }\r
3986 \r
3987 /**\r
3988   * @brief  This function handles Acknowledge failed detection during an I2C Communication.\r
3989   * @param  hi2c : Pointer to a I2C_HandleTypeDef structure that contains\r
3990   *                the configuration information for the specified I2C.\r
3991   * @param  Timeout: Timeout duration\r
3992   * @retval HAL status\r
3993   */\r
3994 static HAL_StatusTypeDef I2C_IsAcknowledgeFailed(I2C_HandleTypeDef *hi2c, uint32_t Timeout)\r
3995 {\r
3996   uint32_t tickstart = 0x00;\r
3997   tickstart = HAL_GetTick();\r
3998 \r
3999   if(__HAL_I2C_GET_FLAG(hi2c, I2C_FLAG_AF) == SET)\r
4000   {\r
4001     /* Generate stop if necessary only in case of I2C peripheral in MASTER mode */\r
4002     if((hi2c->State == HAL_I2C_STATE_MASTER_BUSY_TX) || (hi2c->State == HAL_I2C_STATE_MEM_BUSY_TX)\r
4003        || (hi2c->State == HAL_I2C_STATE_MEM_BUSY_RX))\r
4004     {\r
4005       /* No need to generate the STOP condition if AUTOEND mode is enabled */\r
4006       /* Generate the STOP condition only in case of SOFTEND mode is enabled */\r
4007       if((hi2c->Instance->CR2 & I2C_AUTOEND_MODE) != I2C_AUTOEND_MODE)\r
4008       {\r
4009         /* Generate Stop */\r
4010         hi2c->Instance->CR2 |= I2C_CR2_STOP;\r
4011       }\r
4012     }\r
4013                 \r
4014     /* Wait until STOP Flag is reset */\r
4015     /* AutoEnd should be initiate after AF */\r
4016     while(__HAL_I2C_GET_FLAG(hi2c, I2C_FLAG_STOPF) == RESET)\r
4017     {\r
4018       /* Check for the Timeout */\r
4019       if(Timeout != HAL_MAX_DELAY)\r
4020       {\r
4021       if((Timeout == 0)||((HAL_GetTick() - tickstart ) > Timeout))\r
4022         {\r
4023           hi2c->State= HAL_I2C_STATE_READY;\r
4024           /* Process Unlocked */\r
4025           __HAL_UNLOCK(hi2c);\r
4026           return HAL_TIMEOUT;\r
4027         }\r
4028       }\r
4029     }\r
4030 \r
4031     /* Clear NACKF Flag */\r
4032     __HAL_I2C_CLEAR_FLAG(hi2c, I2C_FLAG_AF);\r
4033 \r
4034     /* Clear STOP Flag */\r
4035     __HAL_I2C_CLEAR_FLAG(hi2c, I2C_FLAG_STOPF);\r
4036 \r
4037     /* Clear Configuration Register 2 */\r
4038     I2C_RESET_CR2(hi2c);\r
4039 \r
4040     hi2c->ErrorCode = HAL_I2C_ERROR_AF;\r
4041     hi2c->State= HAL_I2C_STATE_READY;\r
4042 \r
4043     /* Process Unlocked */\r
4044     __HAL_UNLOCK(hi2c);\r
4045 \r
4046     return HAL_ERROR;\r
4047   }\r
4048   return HAL_OK;\r
4049 }\r
4050 \r
4051 /**\r
4052   * @brief  Handles I2Cx communication when starting transfer or during transfer (TC or TCR flag are set).\r
4053   * @param  hi2c: I2C handle.\r
4054   * @param  DevAddress: specifies the slave address to be programmed.\r
4055   * @param  Size: specifies the number of bytes to be programmed.\r
4056   *   This parameter must be a value between 0 and 255.\r
4057   * @param  Mode: new state of the I2C START condition generation.\r
4058   *   This parameter can be one of the following values:\r
4059   *     @arg I2C_RELOAD_MODE: Enable Reload mode .\r
4060   *     @arg I2C_AUTOEND_MODE: Enable Automatic end mode.\r
4061   *     @arg I2C_SOFTEND_MODE: Enable Software end mode.\r
4062   * @param  Request: new state of the I2C START condition generation.\r
4063   *   This parameter can be one of the following values:\r
4064   *     @arg I2C_NO_STARTSTOP: Don't Generate stop and start condition.\r
4065   *     @arg I2C_GENERATE_STOP: Generate stop condition (Size should be set to 0).\r
4066   *     @arg I2C_GENERATE_START_READ: Generate Restart for read request.\r
4067   *     @arg I2C_GENERATE_START_WRITE: Generate Restart for write request.\r
4068   * @retval None\r
4069   */\r
4070 static void I2C_TransferConfig(I2C_HandleTypeDef *hi2c,  uint16_t DevAddress, uint8_t Size, uint32_t Mode, uint32_t Request)\r
4071 {\r
4072   uint32_t tmpreg = 0;\r
4073   \r
4074   /* Check the parameters */\r
4075   assert_param(IS_I2C_ALL_INSTANCE(hi2c->Instance));\r
4076   assert_param(IS_TRANSFER_MODE(Mode));\r
4077   assert_param(IS_TRANSFER_REQUEST(Request));\r
4078     \r
4079   /* Get the CR2 register value */\r
4080   tmpreg = hi2c->Instance->CR2;\r
4081   \r
4082   /* clear tmpreg specific bits */\r
4083   tmpreg &= (uint32_t)~((uint32_t)(I2C_CR2_SADD | I2C_CR2_NBYTES | I2C_CR2_RELOAD | I2C_CR2_AUTOEND | I2C_CR2_RD_WRN | I2C_CR2_START | I2C_CR2_STOP));\r
4084   \r
4085   /* update tmpreg */\r
4086   tmpreg |= (uint32_t)(((uint32_t)DevAddress & I2C_CR2_SADD) | (((uint32_t)Size << 16 ) & I2C_CR2_NBYTES) | \\r
4087             (uint32_t)Mode | (uint32_t)Request);\r
4088   \r
4089   /* update CR2 register */\r
4090   hi2c->Instance->CR2 = tmpreg;  \r
4091 }  \r
4092 \r
4093 /**\r
4094   * @}\r
4095   */\r
4096 \r
4097 /**\r
4098   * @}\r
4099   */\r
4100 \r
4101 #endif /* HAL_I2C_MODULE_ENABLED */\r
4102 /**\r
4103   * @}\r
4104   */\r
4105 \r
4106 /**\r
4107   * @}\r
4108   */\r
4109 \r
4110 /************************ (C) COPYRIGHT STMicroelectronics *****END OF FILE****/\r