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