2 ******************************************************************************
\r
3 * @file stm32f7xx_hal_i2c.c
\r
4 * @author MCD Application Team
\r
6 * @date 24-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
15 ==============================================================================
\r
16 ##### How to use this driver #####
\r
17 ==============================================================================
\r
19 The I2C HAL driver can be used as follows:
\r
21 (#) Declare a I2C_HandleTypeDef handle structure, for example:
\r
22 I2C_HandleTypeDef hi2c;
\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
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
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
46 (#) To check if target device is ready for communication, use the function HAL_I2C_IsDeviceReady()
\r
48 (#) For I2C IO and IO MEM operations, three operation modes are available within this driver :
\r
50 *** Polling mode IO operation ***
\r
51 =================================
\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
58 *** Polling mode IO MEM operation ***
\r
59 =====================================
\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
65 *** Interrupt mode IO operation ***
\r
66 ===================================
\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
83 *** Interrupt mode IO MEM operation ***
\r
84 =======================================
\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
97 *** DMA mode IO operation ***
\r
98 ==============================
\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
119 *** DMA mode IO MEM operation ***
\r
120 =================================
\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
134 *** I2C HAL driver macros list ***
\r
135 ==================================
\r
137 Below the list of most used macros in I2C HAL driver.
\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
147 (@) You can refer to the I2C HAL driver header file for more useful macros
\r
150 ******************************************************************************
\r
153 * <h2><center>© COPYRIGHT(c) 2015 STMicroelectronics</center></h2>
\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
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
177 ******************************************************************************
\r
180 /* Includes ------------------------------------------------------------------*/
\r
181 #include "stm32f7xx_hal.h"
\r
183 /** @addtogroup STM32F7xx_HAL_Driver
\r
187 /** @defgroup I2C I2C
\r
188 * @brief I2C HAL module driver
\r
192 #ifdef HAL_I2C_MODULE_ENABLED
\r
194 /* Private typedef -----------------------------------------------------------*/
\r
195 /* Private constants ---------------------------------------------------------*/
\r
196 /** @addtogroup I2C_Private_Constants I2C Private Constants
\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
213 /* Private macro -------------------------------------------------------------*/
\r
214 /* Private variables ---------------------------------------------------------*/
\r
215 /* Private function prototypes -----------------------------------------------*/
\r
216 /** @addtogroup I2C_Private_Functions I2C Private Functions
\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
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
235 static HAL_StatusTypeDef I2C_MasterTransmit_ISR(I2C_HandleTypeDef *hi2c);
\r
236 static HAL_StatusTypeDef I2C_MasterReceive_ISR(I2C_HandleTypeDef *hi2c);
\r
238 static HAL_StatusTypeDef I2C_SlaveTransmit_ISR(I2C_HandleTypeDef *hi2c);
\r
239 static HAL_StatusTypeDef I2C_SlaveReceive_ISR(I2C_HandleTypeDef *hi2c);
\r
241 static void I2C_TransferConfig(I2C_HandleTypeDef *hi2c, uint16_t DevAddress, uint8_t Size, uint32_t Mode, uint32_t Request);
\r
246 /* Exported functions --------------------------------------------------------*/
\r
248 /** @defgroup I2C_Exported_Functions I2C Exported Functions
\r
252 /** @defgroup I2C_Exported_Functions_Group1 Initialization and de-initialization functions
\r
253 * @brief Initialization and Configuration functions
\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
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
265 (+) Call the function HAL_I2C_Init() to configure the selected device with
\r
266 the selected configuration:
\r
269 (++) Addressing mode (Master, Slave)
\r
270 (++) Dual Addressing mode
\r
272 (++) Own Address 2 Mask
\r
273 (++) General call mode
\r
274 (++) Nostretch mode
\r
276 (+) Call the function HAL_I2C_DeInit() to restore the default configuration
\r
277 of the selected I2Cx peripheral.
\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
290 HAL_StatusTypeDef HAL_I2C_Init(I2C_HandleTypeDef *hi2c)
\r
292 /* Check the I2C handle allocation */
\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
308 if(hi2c->State == HAL_I2C_STATE_RESET)
\r
310 /* Init the low level hardware : GPIO, CLOCK, CORTEX...etc */
\r
311 HAL_I2C_MspInit(hi2c);
\r
314 hi2c->State = HAL_I2C_STATE_BUSY;
\r
316 /* Disable the selected I2C peripheral */
\r
317 __HAL_I2C_DISABLE(hi2c);
\r
319 /*---------------------------- I2Cx TIMINGR Configuration ------------------*/
\r
320 /* Configure I2Cx: Frequency range */
\r
321 hi2c->Instance->TIMINGR = hi2c->Init.Timing & TIMING_CLEAR_MASK;
\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
328 if(hi2c->Init.AddressingMode == I2C_ADDRESSINGMODE_7BIT)
\r
330 hi2c->Instance->OAR1 = (I2C_OAR1_OA1EN | hi2c->Init.OwnAddress1);
\r
332 else /* I2C_ADDRESSINGMODE_10BIT */
\r
334 hi2c->Instance->OAR1 = (I2C_OAR1_OA1EN | I2C_OAR1_OA1MODE | hi2c->Init.OwnAddress1);
\r
338 /*---------------------------- I2Cx CR2 Configuration ----------------------*/
\r
339 /* Configure I2Cx: Addressing Master mode */
\r
340 if(hi2c->Init.AddressingMode == I2C_ADDRESSINGMODE_10BIT)
\r
342 hi2c->Instance->CR2 = (I2C_CR2_ADD10);
\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
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
351 /*---------------------------- I2Cx CR1 Configuration ----------------------*/
\r
352 /* Configure I2Cx: Generalcall and NoStretch mode */
\r
353 hi2c->Instance->CR1 = (hi2c->Init.GeneralCallMode | hi2c->Init.NoStretchMode);
\r
355 /* Enable the selected I2C peripheral */
\r
356 __HAL_I2C_ENABLE(hi2c);
\r
358 hi2c->ErrorCode = HAL_I2C_ERROR_NONE;
\r
359 hi2c->State = HAL_I2C_STATE_READY;
\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
370 HAL_StatusTypeDef HAL_I2C_DeInit(I2C_HandleTypeDef *hi2c)
\r
372 /* Check the I2C handle allocation */
\r
378 /* Check the parameters */
\r
379 assert_param(IS_I2C_ALL_INSTANCE(hi2c->Instance));
\r
381 hi2c->State = HAL_I2C_STATE_BUSY;
\r
383 /* Disable the I2C Peripheral Clock */
\r
384 __HAL_I2C_DISABLE(hi2c);
\r
386 /* DeInit the low level hardware: GPIO, CLOCK, NVIC */
\r
387 HAL_I2C_MspDeInit(hi2c);
\r
389 hi2c->ErrorCode = HAL_I2C_ERROR_NONE;
\r
391 hi2c->State = HAL_I2C_STATE_RESET;
\r
394 __HAL_UNLOCK(hi2c);
\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
405 __weak void HAL_I2C_MspInit(I2C_HandleTypeDef *hi2c)
\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
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
418 __weak void HAL_I2C_MspDeInit(I2C_HandleTypeDef *hi2c)
\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
429 /** @defgroup I2C_Exported_Functions_Group2 Input and Output operation functions
\r
430 * @brief Data transfers functions
\r
433 ===============================================================================
\r
434 ##### IO operation functions #####
\r
435 ===============================================================================
\r
437 This subsection provides a set of functions allowing to manage the I2C data
\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
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
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
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
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
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
498 HAL_StatusTypeDef HAL_I2C_Master_Transmit(I2C_HandleTypeDef *hi2c, uint16_t DevAddress, uint8_t *pData, uint16_t Size, uint32_t Timeout)
\r
500 uint32_t sizetmp = 0;
\r
502 if(hi2c->State == HAL_I2C_STATE_READY)
\r
504 if((pData == NULL ) || (Size == 0))
\r
509 if(__HAL_I2C_GET_FLAG(hi2c, I2C_FLAG_BUSY) == SET)
\r
514 /* Process Locked */
\r
517 hi2c->State = HAL_I2C_STATE_MASTER_BUSY_TX;
\r
518 hi2c->ErrorCode = HAL_I2C_ERROR_NONE;
\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
525 I2C_TransferConfig(hi2c,DevAddress,255, I2C_RELOAD_MODE, I2C_GENERATE_START_WRITE);
\r
530 I2C_TransferConfig(hi2c,DevAddress,Size, I2C_AUTOEND_MODE, I2C_GENERATE_START_WRITE);
\r
536 /* Wait until TXIS flag is set */
\r
537 if(I2C_WaitOnTXISFlagUntilTimeout(hi2c, Timeout) != HAL_OK)
\r
539 if(hi2c->ErrorCode == HAL_I2C_ERROR_AF)
\r
545 return HAL_TIMEOUT;
\r
548 /* Write data to TXDR */
\r
549 hi2c->Instance->TXDR = (*pData++);
\r
553 if((sizetmp == 0)&&(Size!=0))
\r
555 /* Wait until TXE flag is set */
\r
556 if(I2C_WaitOnFlagUntilTimeout(hi2c, I2C_FLAG_TCR, RESET, Timeout) != HAL_OK)
\r
558 return HAL_TIMEOUT;
\r
563 I2C_TransferConfig(hi2c,DevAddress,255, I2C_RELOAD_MODE, I2C_NO_STARTSTOP);
\r
568 I2C_TransferConfig(hi2c,DevAddress,Size, I2C_AUTOEND_MODE, I2C_NO_STARTSTOP);
\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
579 if(hi2c->ErrorCode == HAL_I2C_ERROR_AF)
\r
585 return HAL_TIMEOUT;
\r
589 /* Clear STOP Flag */
\r
590 __HAL_I2C_CLEAR_FLAG(hi2c, I2C_FLAG_STOPF);
\r
592 /* Clear Configuration Register 2 */
\r
593 I2C_RESET_CR2(hi2c);
\r
595 hi2c->State = HAL_I2C_STATE_READY;
\r
597 /* Process Unlocked */
\r
598 __HAL_UNLOCK(hi2c);
\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
618 HAL_StatusTypeDef HAL_I2C_Master_Receive(I2C_HandleTypeDef *hi2c, uint16_t DevAddress, uint8_t *pData, uint16_t Size, uint32_t Timeout)
\r
620 uint32_t sizetmp = 0;
\r
622 if(hi2c->State == HAL_I2C_STATE_READY)
\r
624 if((pData == NULL ) || (Size == 0))
\r
629 if(__HAL_I2C_GET_FLAG(hi2c, I2C_FLAG_BUSY) == SET)
\r
634 /* Process Locked */
\r
637 hi2c->State = HAL_I2C_STATE_MASTER_BUSY_RX;
\r
638 hi2c->ErrorCode = HAL_I2C_ERROR_NONE;
\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
645 I2C_TransferConfig(hi2c,DevAddress,255, I2C_RELOAD_MODE, I2C_GENERATE_START_READ);
\r
650 I2C_TransferConfig(hi2c,DevAddress,Size, I2C_AUTOEND_MODE, I2C_GENERATE_START_READ);
\r
656 /* Wait until RXNE flag is set */
\r
657 if(I2C_WaitOnFlagUntilTimeout(hi2c, I2C_FLAG_RXNE, RESET, Timeout) != HAL_OK)
\r
659 return HAL_TIMEOUT;
\r
662 /* Write data to RXDR */
\r
663 (*pData++) =hi2c->Instance->RXDR;
\r
667 if((sizetmp == 0)&&(Size!=0))
\r
669 /* Wait until TCR flag is set */
\r
670 if(I2C_WaitOnFlagUntilTimeout(hi2c, I2C_FLAG_TCR, RESET, Timeout) != HAL_OK)
\r
672 return HAL_TIMEOUT;
\r
677 I2C_TransferConfig(hi2c,DevAddress,255, I2C_RELOAD_MODE, I2C_NO_STARTSTOP);
\r
682 I2C_TransferConfig(hi2c,DevAddress,Size, I2C_AUTOEND_MODE, I2C_NO_STARTSTOP);
\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
693 if(hi2c->ErrorCode == HAL_I2C_ERROR_AF)
\r
699 return HAL_TIMEOUT;
\r
703 /* Clear STOP Flag */
\r
704 __HAL_I2C_CLEAR_FLAG(hi2c, I2C_FLAG_STOPF);
\r
706 /* Clear Configuration Register 2 */
\r
707 I2C_RESET_CR2(hi2c);
\r
709 hi2c->State = HAL_I2C_STATE_READY;
\r
711 /* Process Unlocked */
\r
712 __HAL_UNLOCK(hi2c);
\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
731 HAL_StatusTypeDef HAL_I2C_Slave_Transmit(I2C_HandleTypeDef *hi2c, uint8_t *pData, uint16_t Size, uint32_t Timeout)
\r
733 if(hi2c->State == HAL_I2C_STATE_READY)
\r
735 if((pData == NULL ) || (Size == 0))
\r
740 /* Process Locked */
\r
743 hi2c->State = HAL_I2C_STATE_SLAVE_BUSY_RX;
\r
744 hi2c->ErrorCode = HAL_I2C_ERROR_NONE;
\r
746 /* Enable Address Acknowledge */
\r
747 hi2c->Instance->CR2 &= ~I2C_CR2_NACK;
\r
749 /* Wait until ADDR flag is set */
\r
750 if(I2C_WaitOnFlagUntilTimeout(hi2c, I2C_FLAG_ADDR, RESET, Timeout) != HAL_OK)
\r
752 /* Disable Address Acknowledge */
\r
753 hi2c->Instance->CR2 |= I2C_CR2_NACK;
\r
754 return HAL_TIMEOUT;
\r
757 /* Clear ADDR flag */
\r
758 __HAL_I2C_CLEAR_FLAG(hi2c,I2C_FLAG_ADDR);
\r
760 /* If 10bit addressing mode is selected */
\r
761 if(hi2c->Init.AddressingMode == I2C_ADDRESSINGMODE_10BIT)
\r
763 /* Wait until ADDR flag is set */
\r
764 if(I2C_WaitOnFlagUntilTimeout(hi2c, I2C_FLAG_ADDR, RESET, Timeout) != HAL_OK)
\r
766 /* Disable Address Acknowledge */
\r
767 hi2c->Instance->CR2 |= I2C_CR2_NACK;
\r
768 return HAL_TIMEOUT;
\r
771 /* Clear ADDR flag */
\r
772 __HAL_I2C_CLEAR_FLAG(hi2c,I2C_FLAG_ADDR);
\r
775 /* Wait until DIR flag is set Transmitter mode */
\r
776 if(I2C_WaitOnFlagUntilTimeout(hi2c, I2C_FLAG_DIR, RESET, Timeout) != HAL_OK)
\r
778 /* Disable Address Acknowledge */
\r
779 hi2c->Instance->CR2 |= I2C_CR2_NACK;
\r
780 return HAL_TIMEOUT;
\r
785 /* Wait until TXIS flag is set */
\r
786 if(I2C_WaitOnTXISFlagUntilTimeout(hi2c, Timeout) != HAL_OK)
\r
788 /* Disable Address Acknowledge */
\r
789 hi2c->Instance->CR2 |= I2C_CR2_NACK;
\r
791 if(hi2c->ErrorCode == HAL_I2C_ERROR_AF)
\r
797 return HAL_TIMEOUT;
\r
801 /* Read data from TXDR */
\r
802 hi2c->Instance->TXDR = (*pData++);
\r
806 /* Wait until STOP flag is set */
\r
807 if(I2C_WaitOnSTOPFlagUntilTimeout(hi2c, I2C_TIMEOUT_STOPF) != HAL_OK)
\r
809 /* Disable Address Acknowledge */
\r
810 hi2c->Instance->CR2 |= I2C_CR2_NACK;
\r
812 if(hi2c->ErrorCode == HAL_I2C_ERROR_AF)
\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
820 return HAL_TIMEOUT;
\r
824 /* Clear STOP flag */
\r
825 __HAL_I2C_CLEAR_FLAG(hi2c,I2C_FLAG_STOPF);
\r
827 /* Wait until BUSY flag is reset */
\r
828 if(I2C_WaitOnFlagUntilTimeout(hi2c, I2C_FLAG_BUSY, SET, Timeout) != HAL_OK)
\r
830 /* Disable Address Acknowledge */
\r
831 hi2c->Instance->CR2 |= I2C_CR2_NACK;
\r
832 return HAL_TIMEOUT;
\r
835 /* Disable Address Acknowledge */
\r
836 hi2c->Instance->CR2 |= I2C_CR2_NACK;
\r
838 hi2c->State = HAL_I2C_STATE_READY;
\r
840 /* Process Unlocked */
\r
841 __HAL_UNLOCK(hi2c);
\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
860 HAL_StatusTypeDef HAL_I2C_Slave_Receive(I2C_HandleTypeDef *hi2c, uint8_t *pData, uint16_t Size, uint32_t Timeout)
\r
862 if(hi2c->State == HAL_I2C_STATE_READY)
\r
864 if((pData == NULL ) || (Size == 0))
\r
869 /* Process Locked */
\r
872 hi2c->State = HAL_I2C_STATE_SLAVE_BUSY_RX;
\r
873 hi2c->ErrorCode = HAL_I2C_ERROR_NONE;
\r
875 /* Enable Address Acknowledge */
\r
876 hi2c->Instance->CR2 &= ~I2C_CR2_NACK;
\r
878 /* Wait until ADDR flag is set */
\r
879 if(I2C_WaitOnFlagUntilTimeout(hi2c, I2C_FLAG_ADDR, RESET, Timeout) != HAL_OK)
\r
881 /* Disable Address Acknowledge */
\r
882 hi2c->Instance->CR2 |= I2C_CR2_NACK;
\r
883 return HAL_TIMEOUT;
\r
886 /* Clear ADDR flag */
\r
887 __HAL_I2C_CLEAR_FLAG(hi2c,I2C_FLAG_ADDR);
\r
889 /* Wait until DIR flag is reset Receiver mode */
\r
890 if(I2C_WaitOnFlagUntilTimeout(hi2c, I2C_FLAG_DIR, SET, Timeout) != HAL_OK)
\r
892 /* Disable Address Acknowledge */
\r
893 hi2c->Instance->CR2 |= I2C_CR2_NACK;
\r
894 return HAL_TIMEOUT;
\r
899 /* Wait until RXNE flag is set */
\r
900 if(I2C_WaitOnRXNEFlagUntilTimeout(hi2c, Timeout) != HAL_OK)
\r
902 /* Disable Address Acknowledge */
\r
903 hi2c->Instance->CR2 |= I2C_CR2_NACK;
\r
904 if(hi2c->ErrorCode == HAL_I2C_ERROR_TIMEOUT)
\r
906 return HAL_TIMEOUT;
\r
914 /* Read data from RXDR */
\r
915 (*pData++) = hi2c->Instance->RXDR;
\r
919 /* Wait until STOP flag is set */
\r
920 if(I2C_WaitOnSTOPFlagUntilTimeout(hi2c, I2C_TIMEOUT_STOPF) != HAL_OK)
\r
922 /* Disable Address Acknowledge */
\r
923 hi2c->Instance->CR2 |= I2C_CR2_NACK;
\r
925 if(hi2c->ErrorCode == HAL_I2C_ERROR_AF)
\r
931 return HAL_TIMEOUT;
\r
935 /* Clear STOP flag */
\r
936 __HAL_I2C_CLEAR_FLAG(hi2c,I2C_FLAG_STOPF);
\r
938 /* Wait until BUSY flag is reset */
\r
939 if(I2C_WaitOnFlagUntilTimeout(hi2c, I2C_FLAG_BUSY, SET, Timeout) != HAL_OK)
\r
941 /* Disable Address Acknowledge */
\r
942 hi2c->Instance->CR2 |= I2C_CR2_NACK;
\r
943 return HAL_TIMEOUT;
\r
947 /* Disable Address Acknowledge */
\r
948 hi2c->Instance->CR2 |= I2C_CR2_NACK;
\r
950 hi2c->State = HAL_I2C_STATE_READY;
\r
952 /* Process Unlocked */
\r
953 __HAL_UNLOCK(hi2c);
\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
972 HAL_StatusTypeDef HAL_I2C_Master_Transmit_IT(I2C_HandleTypeDef *hi2c, uint16_t DevAddress, uint8_t *pData, uint16_t Size)
\r
974 if(hi2c->State == HAL_I2C_STATE_READY)
\r
976 if((pData == NULL) || (Size == 0))
\r
981 if(__HAL_I2C_GET_FLAG(hi2c, I2C_FLAG_BUSY) == SET)
\r
986 /* Process Locked */
\r
989 hi2c->State = HAL_I2C_STATE_MASTER_BUSY_TX;
\r
990 hi2c->ErrorCode = HAL_I2C_ERROR_NONE;
\r
992 hi2c->pBuffPtr = pData;
\r
993 hi2c->XferCount = Size;
\r
996 hi2c->XferSize = 255;
\r
1000 hi2c->XferSize = Size;
\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
1007 I2C_TransferConfig(hi2c,DevAddress,hi2c->XferSize, I2C_RELOAD_MODE, I2C_GENERATE_START_WRITE);
\r
1011 I2C_TransferConfig(hi2c,DevAddress,hi2c->XferSize, I2C_AUTOEND_MODE, I2C_GENERATE_START_WRITE);
\r
1014 /* Process Unlocked */
\r
1015 __HAL_UNLOCK(hi2c);
\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
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
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
1044 HAL_StatusTypeDef HAL_I2C_Master_Receive_IT(I2C_HandleTypeDef *hi2c, uint16_t DevAddress, uint8_t *pData, uint16_t Size)
\r
1046 if(hi2c->State == HAL_I2C_STATE_READY)
\r
1048 if((pData == NULL) || (Size == 0))
\r
1050 return HAL_ERROR;
\r
1053 if(__HAL_I2C_GET_FLAG(hi2c, I2C_FLAG_BUSY) == SET)
\r
1058 /* Process Locked */
\r
1061 hi2c->State = HAL_I2C_STATE_MASTER_BUSY_RX;
\r
1062 hi2c->ErrorCode = HAL_I2C_ERROR_NONE;
\r
1064 hi2c->pBuffPtr = pData;
\r
1065 hi2c->XferCount = Size;
\r
1068 hi2c->XferSize = 255;
\r
1072 hi2c->XferSize = Size;
\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
1079 I2C_TransferConfig(hi2c,DevAddress,hi2c->XferSize, I2C_RELOAD_MODE, I2C_GENERATE_START_READ);
\r
1083 I2C_TransferConfig(hi2c,DevAddress,hi2c->XferSize, I2C_AUTOEND_MODE, I2C_GENERATE_START_READ);
\r
1086 /* Process Unlocked */
\r
1087 __HAL_UNLOCK(hi2c);
\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
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
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
1114 HAL_StatusTypeDef HAL_I2C_Slave_Transmit_IT(I2C_HandleTypeDef *hi2c, uint8_t *pData, uint16_t Size)
\r
1116 if(hi2c->State == HAL_I2C_STATE_READY)
\r
1118 if((pData == NULL) || (Size == 0))
\r
1120 return HAL_ERROR;
\r
1123 /* Process Locked */
\r
1126 hi2c->State = HAL_I2C_STATE_SLAVE_BUSY_TX;
\r
1127 hi2c->ErrorCode = HAL_I2C_ERROR_NONE;
\r
1129 /* Enable Address Acknowledge */
\r
1130 hi2c->Instance->CR2 &= ~I2C_CR2_NACK;
\r
1132 hi2c->pBuffPtr = pData;
\r
1133 hi2c->XferSize = Size;
\r
1134 hi2c->XferCount = Size;
\r
1136 /* Process Unlocked */
\r
1137 __HAL_UNLOCK(hi2c);
\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
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
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
1164 HAL_StatusTypeDef HAL_I2C_Slave_Receive_IT(I2C_HandleTypeDef *hi2c, uint8_t *pData, uint16_t Size)
\r
1166 if(hi2c->State == HAL_I2C_STATE_READY)
\r
1168 if((pData == NULL) || (Size == 0))
\r
1170 return HAL_ERROR;
\r
1173 /* Process Locked */
\r
1176 hi2c->State = HAL_I2C_STATE_SLAVE_BUSY_RX;
\r
1177 hi2c->ErrorCode = HAL_I2C_ERROR_NONE;
\r
1179 /* Enable Address Acknowledge */
\r
1180 hi2c->Instance->CR2 &= ~I2C_CR2_NACK;
\r
1182 hi2c->pBuffPtr = pData;
\r
1183 hi2c->XferSize = Size;
\r
1184 hi2c->XferCount = Size;
\r
1186 /* Process Unlocked */
\r
1187 __HAL_UNLOCK(hi2c);
\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
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
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
1215 HAL_StatusTypeDef HAL_I2C_Master_Transmit_DMA(I2C_HandleTypeDef *hi2c, uint16_t DevAddress, uint8_t *pData, uint16_t Size)
\r
1217 if(hi2c->State == HAL_I2C_STATE_READY)
\r
1219 if((pData == NULL) || (Size == 0))
\r
1221 return HAL_ERROR;
\r
1224 if(__HAL_I2C_GET_FLAG(hi2c, I2C_FLAG_BUSY) == SET)
\r
1229 /* Process Locked */
\r
1232 hi2c->State = HAL_I2C_STATE_MASTER_BUSY_TX;
\r
1233 hi2c->ErrorCode = HAL_I2C_ERROR_NONE;
\r
1235 hi2c->pBuffPtr = pData;
\r
1236 hi2c->XferCount = Size;
\r
1239 hi2c->XferSize = 255;
\r
1243 hi2c->XferSize = Size;
\r
1246 /* Set the I2C DMA transfer complete callback */
\r
1247 hi2c->hdmatx->XferCpltCallback = I2C_DMAMasterTransmitCplt;
\r
1249 /* Set the DMA error callback */
\r
1250 hi2c->hdmatx->XferErrorCallback = I2C_DMAError;
\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
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
1259 I2C_TransferConfig(hi2c,DevAddress,hi2c->XferSize, I2C_RELOAD_MODE, I2C_GENERATE_START_WRITE);
\r
1263 I2C_TransferConfig(hi2c,DevAddress,hi2c->XferSize, I2C_AUTOEND_MODE, I2C_GENERATE_START_WRITE);
\r
1266 /* Wait until TXIS flag is set */
\r
1267 if(I2C_WaitOnTXISFlagUntilTimeout(hi2c, I2C_TIMEOUT_TXIS) != HAL_OK)
\r
1269 /* Disable Address Acknowledge */
\r
1270 hi2c->Instance->CR2 |= I2C_CR2_NACK;
\r
1272 if(hi2c->ErrorCode == HAL_I2C_ERROR_AF)
\r
1278 return HAL_TIMEOUT;
\r
1283 /* Enable DMA Request */
\r
1284 hi2c->Instance->CR1 |= I2C_CR1_TXDMAEN;
\r
1286 /* Process Unlocked */
\r
1287 __HAL_UNLOCK(hi2c);
\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
1306 HAL_StatusTypeDef HAL_I2C_Master_Receive_DMA(I2C_HandleTypeDef *hi2c, uint16_t DevAddress, uint8_t *pData, uint16_t Size)
\r
1308 if(hi2c->State == HAL_I2C_STATE_READY)
\r
1310 if((pData == NULL) || (Size == 0))
\r
1312 return HAL_ERROR;
\r
1315 if(__HAL_I2C_GET_FLAG(hi2c, I2C_FLAG_BUSY) == SET)
\r
1320 /* Process Locked */
\r
1323 hi2c->State = HAL_I2C_STATE_MASTER_BUSY_RX;
\r
1324 hi2c->ErrorCode = HAL_I2C_ERROR_NONE;
\r
1326 hi2c->pBuffPtr = pData;
\r
1327 hi2c->XferCount = Size;
\r
1330 hi2c->XferSize = 255;
\r
1334 hi2c->XferSize = Size;
\r
1337 /* Set the I2C DMA transfer complete callback */
\r
1338 hi2c->hdmarx->XferCpltCallback = I2C_DMAMasterReceiveCplt;
\r
1340 /* Set the DMA error callback */
\r
1341 hi2c->hdmarx->XferErrorCallback = I2C_DMAError;
\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
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
1350 I2C_TransferConfig(hi2c,DevAddress,hi2c->XferSize, I2C_RELOAD_MODE, I2C_GENERATE_START_READ);
\r
1354 I2C_TransferConfig(hi2c,DevAddress,hi2c->XferSize, I2C_AUTOEND_MODE, I2C_GENERATE_START_READ);
\r
1357 /* Wait until RXNE flag is set */
\r
1358 if(I2C_WaitOnFlagUntilTimeout(hi2c, I2C_FLAG_RXNE, RESET, I2C_TIMEOUT_RXNE) != HAL_OK)
\r
1360 return HAL_TIMEOUT;
\r
1364 /* Enable DMA Request */
\r
1365 hi2c->Instance->CR1 |= I2C_CR1_RXDMAEN;
\r
1367 /* Process Unlocked */
\r
1368 __HAL_UNLOCK(hi2c);
\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
1386 HAL_StatusTypeDef HAL_I2C_Slave_Transmit_DMA(I2C_HandleTypeDef *hi2c, uint8_t *pData, uint16_t Size)
\r
1388 if(hi2c->State == HAL_I2C_STATE_READY)
\r
1390 if((pData == NULL) || (Size == 0))
\r
1392 return HAL_ERROR;
\r
1394 /* Process Locked */
\r
1395 __HAL_LOCK(hi2c);
\r
1397 hi2c->State = HAL_I2C_STATE_SLAVE_BUSY_TX;
\r
1398 hi2c->ErrorCode = HAL_I2C_ERROR_NONE;
\r
1400 hi2c->pBuffPtr = pData;
\r
1401 hi2c->XferCount = Size;
\r
1402 hi2c->XferSize = Size;
\r
1404 /* Set the I2C DMA transfer complete callback */
\r
1405 hi2c->hdmatx->XferCpltCallback = I2C_DMASlaveTransmitCplt;
\r
1407 /* Set the DMA error callback */
\r
1408 hi2c->hdmatx->XferErrorCallback = I2C_DMAError;
\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
1413 /* Enable Address Acknowledge */
\r
1414 hi2c->Instance->CR2 &= ~I2C_CR2_NACK;
\r
1416 /* Wait until ADDR flag is set */
\r
1417 if(I2C_WaitOnFlagUntilTimeout(hi2c, I2C_FLAG_ADDR, RESET, I2C_TIMEOUT_ADDR) != HAL_OK)
\r
1419 /* Disable Address Acknowledge */
\r
1420 hi2c->Instance->CR2 |= I2C_CR2_NACK;
\r
1421 return HAL_TIMEOUT;
\r
1424 /* Clear ADDR flag */
\r
1425 __HAL_I2C_CLEAR_FLAG(hi2c,I2C_FLAG_ADDR);
\r
1427 /* If 10bits addressing mode is selected */
\r
1428 if(hi2c->Init.AddressingMode == I2C_ADDRESSINGMODE_10BIT)
\r
1430 /* Wait until ADDR flag is set */
\r
1431 if(I2C_WaitOnFlagUntilTimeout(hi2c, I2C_FLAG_ADDR, RESET, I2C_TIMEOUT_ADDR) != HAL_OK)
\r
1433 /* Disable Address Acknowledge */
\r
1434 hi2c->Instance->CR2 |= I2C_CR2_NACK;
\r
1435 return HAL_TIMEOUT;
\r
1438 /* Clear ADDR flag */
\r
1439 __HAL_I2C_CLEAR_FLAG(hi2c,I2C_FLAG_ADDR);
\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
1445 /* Disable Address Acknowledge */
\r
1446 hi2c->Instance->CR2 |= I2C_CR2_NACK;
\r
1447 return HAL_TIMEOUT;
\r
1450 /* Enable DMA Request */
\r
1451 hi2c->Instance->CR1 |= I2C_CR1_TXDMAEN;
\r
1453 /* Process Unlocked */
\r
1454 __HAL_UNLOCK(hi2c);
\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
1472 HAL_StatusTypeDef HAL_I2C_Slave_Receive_DMA(I2C_HandleTypeDef *hi2c, uint8_t *pData, uint16_t Size)
\r
1474 if(hi2c->State == HAL_I2C_STATE_READY)
\r
1476 if((pData == NULL) || (Size == 0))
\r
1478 return HAL_ERROR;
\r
1480 /* Process Locked */
\r
1483 hi2c->State = HAL_I2C_STATE_SLAVE_BUSY_RX;
\r
1484 hi2c->ErrorCode = HAL_I2C_ERROR_NONE;
\r
1486 hi2c->pBuffPtr = pData;
\r
1487 hi2c->XferSize = Size;
\r
1488 hi2c->XferCount = Size;
\r
1490 /* Set the I2C DMA transfer complete callback */
\r
1491 hi2c->hdmarx->XferCpltCallback = I2C_DMASlaveReceiveCplt;
\r
1493 /* Set the DMA error callback */
\r
1494 hi2c->hdmarx->XferErrorCallback = I2C_DMAError;
\r
1496 /* Enable the DMA channel */
\r
1497 HAL_DMA_Start_IT(hi2c->hdmarx, (uint32_t)&hi2c->Instance->RXDR, (uint32_t)pData, Size);
\r
1499 /* Enable Address Acknowledge */
\r
1500 hi2c->Instance->CR2 &= ~I2C_CR2_NACK;
\r
1502 /* Wait until ADDR flag is set */
\r
1503 if(I2C_WaitOnFlagUntilTimeout(hi2c, I2C_FLAG_ADDR, RESET, I2C_TIMEOUT_ADDR) != HAL_OK)
\r
1505 /* Disable Address Acknowledge */
\r
1506 hi2c->Instance->CR2 |= I2C_CR2_NACK;
\r
1507 return HAL_TIMEOUT;
\r
1510 /* Clear ADDR flag */
\r
1511 __HAL_I2C_CLEAR_FLAG(hi2c,I2C_FLAG_ADDR);
\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
1516 /* Disable Address Acknowledge */
\r
1517 hi2c->Instance->CR2 |= I2C_CR2_NACK;
\r
1518 return HAL_TIMEOUT;
\r
1521 /* Enable DMA Request */
\r
1522 hi2c->Instance->CR1 |= I2C_CR1_RXDMAEN;
\r
1524 /* Process Unlocked */
\r
1525 __HAL_UNLOCK(hi2c);
\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
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
1548 uint32_t Sizetmp = 0;
\r
1550 /* Check the parameters */
\r
1551 assert_param(IS_I2C_MEMADD_SIZE(MemAddSize));
\r
1553 if(hi2c->State == HAL_I2C_STATE_READY)
\r
1555 if((pData == NULL) || (Size == 0))
\r
1557 return HAL_ERROR;
\r
1560 if(__HAL_I2C_GET_FLAG(hi2c, I2C_FLAG_BUSY) == SET)
\r
1565 /* Process Locked */
\r
1568 hi2c->State = HAL_I2C_STATE_MEM_BUSY_TX;
\r
1569 hi2c->ErrorCode = HAL_I2C_ERROR_NONE;
\r
1571 /* Send Slave Address and Memory Address */
\r
1572 if(I2C_RequestMemoryWrite(hi2c, DevAddress, MemAddress, MemAddSize, Timeout) != HAL_OK)
\r
1574 if(hi2c->ErrorCode == HAL_I2C_ERROR_AF)
\r
1576 /* Process Unlocked */
\r
1577 __HAL_UNLOCK(hi2c);
\r
1582 /* Process Unlocked */
\r
1583 __HAL_UNLOCK(hi2c);
\r
1584 return HAL_TIMEOUT;
\r
1588 /* Set NBYTES to write and reload if size > 255 */
\r
1589 /* Size > 255, need to set RELOAD bit */
\r
1592 I2C_TransferConfig(hi2c,DevAddress,255, I2C_RELOAD_MODE, I2C_NO_STARTSTOP);
\r
1597 I2C_TransferConfig(hi2c,DevAddress,Size, I2C_AUTOEND_MODE, I2C_NO_STARTSTOP);
\r
1603 /* Wait until TXIS flag is set */
\r
1604 if(I2C_WaitOnTXISFlagUntilTimeout(hi2c, Timeout) != HAL_OK)
\r
1606 if(hi2c->ErrorCode == HAL_I2C_ERROR_AF)
\r
1612 return HAL_TIMEOUT;
\r
1616 /* Write data to DR */
\r
1617 hi2c->Instance->TXDR = (*pData++);
\r
1621 if((Sizetmp == 0)&&(Size!=0))
\r
1623 /* Wait until TCR flag is set */
\r
1624 if(I2C_WaitOnFlagUntilTimeout(hi2c, I2C_FLAG_TCR, RESET, Timeout) != HAL_OK)
\r
1626 return HAL_TIMEOUT;
\r
1632 I2C_TransferConfig(hi2c,DevAddress,255, I2C_RELOAD_MODE, I2C_NO_STARTSTOP);
\r
1637 I2C_TransferConfig(hi2c,DevAddress,Size, I2C_AUTOEND_MODE, I2C_NO_STARTSTOP);
\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
1648 if(hi2c->ErrorCode == HAL_I2C_ERROR_AF)
\r
1654 return HAL_TIMEOUT;
\r
1658 /* Clear STOP Flag */
\r
1659 __HAL_I2C_CLEAR_FLAG(hi2c, I2C_FLAG_STOPF);
\r
1661 /* Clear Configuration Register 2 */
\r
1662 I2C_RESET_CR2(hi2c);
\r
1664 hi2c->State = HAL_I2C_STATE_READY;
\r
1666 /* Process Unlocked */
\r
1667 __HAL_UNLOCK(hi2c);
\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
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
1691 uint32_t Sizetmp = 0;
\r
1693 /* Check the parameters */
\r
1694 assert_param(IS_I2C_MEMADD_SIZE(MemAddSize));
\r
1696 if(hi2c->State == HAL_I2C_STATE_READY)
\r
1698 if((pData == NULL) || (Size == 0))
\r
1700 return HAL_ERROR;
\r
1703 if(__HAL_I2C_GET_FLAG(hi2c, I2C_FLAG_BUSY) == SET)
\r
1708 /* Process Locked */
\r
1711 hi2c->State = HAL_I2C_STATE_MEM_BUSY_RX;
\r
1712 hi2c->ErrorCode = HAL_I2C_ERROR_NONE;
\r
1714 /* Send Slave Address and Memory Address */
\r
1715 if(I2C_RequestMemoryRead(hi2c, DevAddress, MemAddress, MemAddSize, Timeout) != HAL_OK)
\r
1717 if(hi2c->ErrorCode == HAL_I2C_ERROR_AF)
\r
1719 /* Process Unlocked */
\r
1720 __HAL_UNLOCK(hi2c);
\r
1725 /* Process Unlocked */
\r
1726 __HAL_UNLOCK(hi2c);
\r
1727 return HAL_TIMEOUT;
\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
1736 I2C_TransferConfig(hi2c,DevAddress,255, I2C_RELOAD_MODE, I2C_GENERATE_START_READ);
\r
1741 I2C_TransferConfig(hi2c,DevAddress,Size, I2C_AUTOEND_MODE, I2C_GENERATE_START_READ);
\r
1747 /* Wait until RXNE flag is set */
\r
1748 if(I2C_WaitOnFlagUntilTimeout(hi2c, I2C_FLAG_RXNE, RESET, Timeout) != HAL_OK)
\r
1750 return HAL_TIMEOUT;
\r
1753 /* Read data from RXDR */
\r
1754 (*pData++) = hi2c->Instance->RXDR;
\r
1756 /* Decrement the Size counter */
\r
1760 if((Sizetmp == 0)&&(Size!=0))
\r
1762 /* Wait until TCR flag is set */
\r
1763 if(I2C_WaitOnFlagUntilTimeout(hi2c, I2C_FLAG_TCR, RESET, Timeout) != HAL_OK)
\r
1765 return HAL_TIMEOUT;
\r
1770 I2C_TransferConfig(hi2c,DevAddress,255, I2C_RELOAD_MODE, I2C_NO_STARTSTOP);
\r
1775 I2C_TransferConfig(hi2c,DevAddress,Size, I2C_AUTOEND_MODE, I2C_NO_STARTSTOP);
\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
1786 if(hi2c->ErrorCode == HAL_I2C_ERROR_AF)
\r
1792 return HAL_TIMEOUT;
\r
1796 /* Clear STOP Flag */
\r
1797 __HAL_I2C_CLEAR_FLAG(hi2c, I2C_FLAG_STOPF);
\r
1799 /* Clear Configuration Register 2 */
\r
1800 I2C_RESET_CR2(hi2c);
\r
1802 hi2c->State = HAL_I2C_STATE_READY;
\r
1804 /* Process Unlocked */
\r
1805 __HAL_UNLOCK(hi2c);
\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
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
1827 /* Check the parameters */
\r
1828 assert_param(IS_I2C_MEMADD_SIZE(MemAddSize));
\r
1830 if(hi2c->State == HAL_I2C_STATE_READY)
\r
1832 if((pData == NULL) || (Size == 0))
\r
1834 return HAL_ERROR;
\r
1837 if(__HAL_I2C_GET_FLAG(hi2c, I2C_FLAG_BUSY) == SET)
\r
1842 /* Process Locked */
\r
1845 hi2c->State = HAL_I2C_STATE_MEM_BUSY_TX;
\r
1846 hi2c->ErrorCode = HAL_I2C_ERROR_NONE;
\r
1848 hi2c->pBuffPtr = pData;
\r
1849 hi2c->XferCount = Size;
\r
1852 hi2c->XferSize = 255;
\r
1856 hi2c->XferSize = Size;
\r
1859 /* Send Slave Address and Memory Address */
\r
1860 if(I2C_RequestMemoryWrite(hi2c, DevAddress, MemAddress, MemAddSize, I2C_TIMEOUT_FLAG) != HAL_OK)
\r
1862 if(hi2c->ErrorCode == HAL_I2C_ERROR_AF)
\r
1864 /* Process Unlocked */
\r
1865 __HAL_UNLOCK(hi2c);
\r
1870 /* Process Unlocked */
\r
1871 __HAL_UNLOCK(hi2c);
\r
1872 return HAL_TIMEOUT;
\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
1880 I2C_TransferConfig(hi2c,DevAddress,hi2c->XferSize, I2C_RELOAD_MODE, I2C_NO_STARTSTOP);
\r
1884 I2C_TransferConfig(hi2c,DevAddress,hi2c->XferSize, I2C_AUTOEND_MODE, I2C_NO_STARTSTOP);
\r
1887 /* Process Unlocked */
\r
1888 __HAL_UNLOCK(hi2c);
\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
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
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
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
1920 /* Check the parameters */
\r
1921 assert_param(IS_I2C_MEMADD_SIZE(MemAddSize));
\r
1923 if(hi2c->State == HAL_I2C_STATE_READY)
\r
1925 if((pData == NULL) || (Size == 0))
\r
1927 return HAL_ERROR;
\r
1930 if(__HAL_I2C_GET_FLAG(hi2c, I2C_FLAG_BUSY) == SET)
\r
1935 /* Process Locked */
\r
1938 hi2c->State = HAL_I2C_STATE_MEM_BUSY_RX;
\r
1940 hi2c->pBuffPtr = pData;
\r
1941 hi2c->XferCount = Size;
\r
1944 hi2c->XferSize = 255;
\r
1948 hi2c->XferSize = Size;
\r
1951 /* Send Slave Address and Memory Address */
\r
1952 if(I2C_RequestMemoryRead(hi2c, DevAddress, MemAddress, MemAddSize, I2C_TIMEOUT_FLAG) != HAL_OK)
\r
1954 if(hi2c->ErrorCode == HAL_I2C_ERROR_AF)
\r
1956 /* Process Unlocked */
\r
1957 __HAL_UNLOCK(hi2c);
\r
1962 /* Process Unlocked */
\r
1963 __HAL_UNLOCK(hi2c);
\r
1964 return HAL_TIMEOUT;
\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
1972 I2C_TransferConfig(hi2c,DevAddress,hi2c->XferSize, I2C_RELOAD_MODE, I2C_GENERATE_START_READ);
\r
1976 I2C_TransferConfig(hi2c,DevAddress,hi2c->XferSize, I2C_AUTOEND_MODE, I2C_GENERATE_START_READ);
\r
1979 /* Process Unlocked */
\r
1980 __HAL_UNLOCK(hi2c);
\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
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
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
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
2011 /* Check the parameters */
\r
2012 assert_param(IS_I2C_MEMADD_SIZE(MemAddSize));
\r
2014 if(hi2c->State == HAL_I2C_STATE_READY)
\r
2016 if((pData == NULL) || (Size == 0))
\r
2018 return HAL_ERROR;
\r
2021 if(__HAL_I2C_GET_FLAG(hi2c, I2C_FLAG_BUSY) == SET)
\r
2026 /* Process Locked */
\r
2029 hi2c->State = HAL_I2C_STATE_MEM_BUSY_TX;
\r
2030 hi2c->ErrorCode = HAL_I2C_ERROR_NONE;
\r
2032 hi2c->pBuffPtr = pData;
\r
2033 hi2c->XferCount = Size;
\r
2036 hi2c->XferSize = 255;
\r
2040 hi2c->XferSize = Size;
\r
2043 /* Set the I2C DMA transfer complete callback */
\r
2044 hi2c->hdmatx->XferCpltCallback = I2C_DMAMemTransmitCplt;
\r
2046 /* Set the DMA error callback */
\r
2047 hi2c->hdmatx->XferErrorCallback = I2C_DMAError;
\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
2052 /* Send Slave Address and Memory Address */
\r
2053 if(I2C_RequestMemoryWrite(hi2c, DevAddress, MemAddress, MemAddSize, I2C_TIMEOUT_FLAG) != HAL_OK)
\r
2055 if(hi2c->ErrorCode == HAL_I2C_ERROR_AF)
\r
2057 /* Process Unlocked */
\r
2058 __HAL_UNLOCK(hi2c);
\r
2063 /* Process Unlocked */
\r
2064 __HAL_UNLOCK(hi2c);
\r
2065 return HAL_TIMEOUT;
\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
2073 I2C_TransferConfig(hi2c,DevAddress,hi2c->XferSize, I2C_RELOAD_MODE, I2C_NO_STARTSTOP);
\r
2077 I2C_TransferConfig(hi2c,DevAddress,hi2c->XferSize, I2C_AUTOEND_MODE, I2C_NO_STARTSTOP);
\r
2080 /* Wait until TXIS flag is set */
\r
2081 if(I2C_WaitOnTXISFlagUntilTimeout(hi2c, I2C_TIMEOUT_TXIS) != HAL_OK)
\r
2083 if(hi2c->ErrorCode == HAL_I2C_ERROR_AF)
\r
2089 return HAL_TIMEOUT;
\r
2093 /* Enable DMA Request */
\r
2094 hi2c->Instance->CR1 |= I2C_CR1_TXDMAEN;
\r
2096 /* Process Unlocked */
\r
2097 __HAL_UNLOCK(hi2c);
\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
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
2120 /* Check the parameters */
\r
2121 assert_param(IS_I2C_MEMADD_SIZE(MemAddSize));
\r
2123 if(hi2c->State == HAL_I2C_STATE_READY)
\r
2125 if((pData == NULL) || (Size == 0))
\r
2127 return HAL_ERROR;
\r
2130 if(__HAL_I2C_GET_FLAG(hi2c, I2C_FLAG_BUSY) == SET)
\r
2135 /* Process Locked */
\r
2138 hi2c->State = HAL_I2C_STATE_MEM_BUSY_RX;
\r
2140 hi2c->pBuffPtr = pData;
\r
2141 hi2c->XferCount = Size;
\r
2144 hi2c->XferSize = 255;
\r
2148 hi2c->XferSize = Size;
\r
2151 /* Set the I2C DMA transfer complete callback */
\r
2152 hi2c->hdmarx->XferCpltCallback = I2C_DMAMemReceiveCplt;
\r
2154 /* Set the DMA error callback */
\r
2155 hi2c->hdmarx->XferErrorCallback = I2C_DMAError;
\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
2160 /* Send Slave Address and Memory Address */
\r
2161 if(I2C_RequestMemoryRead(hi2c, DevAddress, MemAddress, MemAddSize, I2C_TIMEOUT_FLAG) != HAL_OK)
\r
2163 if(hi2c->ErrorCode == HAL_I2C_ERROR_AF)
\r
2165 /* Process Unlocked */
\r
2166 __HAL_UNLOCK(hi2c);
\r
2171 /* Process Unlocked */
\r
2172 __HAL_UNLOCK(hi2c);
\r
2173 return HAL_TIMEOUT;
\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
2180 I2C_TransferConfig(hi2c,DevAddress,hi2c->XferSize, I2C_RELOAD_MODE, I2C_GENERATE_START_READ);
\r
2184 I2C_TransferConfig(hi2c,DevAddress,hi2c->XferSize, I2C_AUTOEND_MODE, I2C_GENERATE_START_READ);
\r
2187 /* Wait until RXNE flag is set */
\r
2188 if(I2C_WaitOnFlagUntilTimeout(hi2c, I2C_FLAG_RXNE, RESET, I2C_TIMEOUT_RXNE) != HAL_OK)
\r
2190 return HAL_TIMEOUT;
\r
2193 /* Enable DMA Request */
\r
2194 hi2c->Instance->CR1 |= I2C_CR1_RXDMAEN;
\r
2196 /* Process Unlocked */
\r
2197 __HAL_UNLOCK(hi2c);
\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
2217 HAL_StatusTypeDef HAL_I2C_IsDeviceReady(I2C_HandleTypeDef *hi2c, uint16_t DevAddress, uint32_t Trials, uint32_t Timeout)
\r
2219 uint32_t tickstart = 0;
\r
2221 __IO uint32_t I2C_Trials = 0;
\r
2223 if(hi2c->State == HAL_I2C_STATE_READY)
\r
2225 if(__HAL_I2C_GET_FLAG(hi2c, I2C_FLAG_BUSY) == SET)
\r
2230 /* Process Locked */
\r
2233 hi2c->State = HAL_I2C_STATE_BUSY;
\r
2234 hi2c->ErrorCode = HAL_I2C_ERROR_NONE;
\r
2238 /* Generate Start */
\r
2239 hi2c->Instance->CR2 = I2C_GENERATE_START(hi2c->Init.AddressingMode,DevAddress);
\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
2246 if(Timeout != HAL_MAX_DELAY)
\r
2248 if((Timeout == 0)||((HAL_GetTick() - tickstart ) > Timeout))
\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
2259 /* Check if the NACKF flag has not been set */
\r
2260 if (__HAL_I2C_GET_FLAG(hi2c, I2C_FLAG_AF) == RESET)
\r
2262 /* Wait until STOPF flag is reset */
\r
2263 if(I2C_WaitOnFlagUntilTimeout(hi2c, I2C_FLAG_STOPF, RESET, Timeout) != HAL_OK)
\r
2265 return HAL_TIMEOUT;
\r
2268 /* Clear STOP Flag */
\r
2269 __HAL_I2C_CLEAR_FLAG(hi2c, I2C_FLAG_STOPF);
\r
2271 /* Device is ready */
\r
2272 hi2c->State = HAL_I2C_STATE_READY;
\r
2274 /* Process Unlocked */
\r
2275 __HAL_UNLOCK(hi2c);
\r
2281 /* Wait until STOPF flag is reset */
\r
2282 if(I2C_WaitOnFlagUntilTimeout(hi2c, I2C_FLAG_STOPF, RESET, Timeout) != HAL_OK)
\r
2284 return HAL_TIMEOUT;
\r
2287 /* Clear NACK Flag */
\r
2288 __HAL_I2C_CLEAR_FLAG(hi2c, I2C_FLAG_AF);
\r
2290 /* Clear STOP Flag, auto generated with autoend*/
\r
2291 __HAL_I2C_CLEAR_FLAG(hi2c, I2C_FLAG_STOPF);
\r
2294 /* Check if the maximum allowed number of trials has been reached */
\r
2295 if (I2C_Trials++ == Trials)
\r
2297 /* Generate Stop */
\r
2298 hi2c->Instance->CR2 |= I2C_CR2_STOP;
\r
2300 /* Wait until STOPF flag is reset */
\r
2301 if(I2C_WaitOnFlagUntilTimeout(hi2c, I2C_FLAG_STOPF, RESET, Timeout) != HAL_OK)
\r
2303 return HAL_TIMEOUT;
\r
2306 /* Clear STOP Flag */
\r
2307 __HAL_I2C_CLEAR_FLAG(hi2c, I2C_FLAG_STOPF);
\r
2309 }while(I2C_Trials < Trials);
\r
2311 hi2c->State = HAL_I2C_STATE_READY;
\r
2313 /* Process Unlocked */
\r
2314 __HAL_UNLOCK(hi2c);
\r
2316 return HAL_TIMEOUT;
\r
2327 /** @defgroup IRQ_Handler_and_Callbacks IRQ Handler and Callbacks
\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
2337 void HAL_I2C_EV_IRQHandler(I2C_HandleTypeDef *hi2c)
\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
2342 /* Slave mode selected */
\r
2343 if (hi2c->State == HAL_I2C_STATE_SLAVE_BUSY_TX)
\r
2345 I2C_SlaveTransmit_ISR(hi2c);
\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
2351 /* Master mode selected */
\r
2352 if ((hi2c->State == HAL_I2C_STATE_MASTER_BUSY_TX) || (hi2c->State == HAL_I2C_STATE_MEM_BUSY_TX))
\r
2354 I2C_MasterTransmit_ISR(hi2c);
\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
2361 /* Slave mode selected */
\r
2362 if (hi2c->State == HAL_I2C_STATE_SLAVE_BUSY_RX)
\r
2364 I2C_SlaveReceive_ISR(hi2c);
\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
2369 /* Master mode selected */
\r
2370 if ((hi2c->State == HAL_I2C_STATE_MASTER_BUSY_RX) || (hi2c->State == HAL_I2C_STATE_MEM_BUSY_RX))
\r
2372 I2C_MasterReceive_ISR(hi2c);
\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
2383 void HAL_I2C_ER_IRQHandler(I2C_HandleTypeDef *hi2c)
\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
2388 hi2c->ErrorCode |= HAL_I2C_ERROR_BERR;
\r
2390 /* Clear BERR flag */
\r
2391 __HAL_I2C_CLEAR_FLAG(hi2c, I2C_FLAG_BERR);
\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
2397 hi2c->ErrorCode |= HAL_I2C_ERROR_OVR;
\r
2399 /* Clear OVR flag */
\r
2400 __HAL_I2C_CLEAR_FLAG(hi2c, I2C_FLAG_OVR);
\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
2406 hi2c->ErrorCode |= HAL_I2C_ERROR_ARLO;
\r
2408 /* Clear ARLO flag */
\r
2409 __HAL_I2C_CLEAR_FLAG(hi2c, I2C_FLAG_ARLO);
\r
2412 /* Call the Error Callback in case of Error detected */
\r
2413 if(hi2c->ErrorCode != HAL_I2C_ERROR_NONE)
\r
2415 hi2c->State = HAL_I2C_STATE_READY;
\r
2417 HAL_I2C_ErrorCallback(hi2c);
\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
2427 __weak void HAL_I2C_MasterTxCpltCallback(I2C_HandleTypeDef *hi2c)
\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
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
2440 __weak void HAL_I2C_MasterRxCpltCallback(I2C_HandleTypeDef *hi2c)
\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
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
2452 __weak void HAL_I2C_SlaveTxCpltCallback(I2C_HandleTypeDef *hi2c)
\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
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
2465 __weak void HAL_I2C_SlaveRxCpltCallback(I2C_HandleTypeDef *hi2c)
\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
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
2478 __weak void HAL_I2C_MemTxCpltCallback(I2C_HandleTypeDef *hi2c)
\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
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
2491 __weak void HAL_I2C_MemRxCpltCallback(I2C_HandleTypeDef *hi2c)
\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
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
2504 __weak void HAL_I2C_ErrorCallback(I2C_HandleTypeDef *hi2c)
\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
2515 /** @defgroup I2C_Exported_Functions_Group3 Peripheral State and Errors functions
\r
2516 * @brief Peripheral State and Errors functions
\r
2519 ===============================================================================
\r
2520 ##### Peripheral State and Errors functions #####
\r
2521 ===============================================================================
\r
2523 This subsection permit to get in run-time the status of the peripheral
\r
2524 and the data flow.
\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
2536 HAL_I2C_StateTypeDef HAL_I2C_GetState(I2C_HandleTypeDef *hi2c)
\r
2538 return hi2c->State;
\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
2547 uint32_t HAL_I2C_GetError(I2C_HandleTypeDef *hi2c)
\r
2549 return hi2c->ErrorCode;
\r
2560 /** @addtogroup I2C_Private_Functions
\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
2570 static HAL_StatusTypeDef I2C_MasterTransmit_ISR(I2C_HandleTypeDef *hi2c)
\r
2572 uint16_t DevAddress;
\r
2574 /* Process Locked */
\r
2575 __HAL_LOCK(hi2c);
\r
2577 if(__HAL_I2C_GET_FLAG(hi2c, I2C_FLAG_TXIS) == SET)
\r
2579 /* Write data to TXDR */
\r
2580 hi2c->Instance->TXDR = (*hi2c->pBuffPtr++);
\r
2582 hi2c->XferCount--;
\r
2584 else if(__HAL_I2C_GET_FLAG(hi2c, I2C_FLAG_TCR) == SET)
\r
2586 if((hi2c->XferSize == 0)&&(hi2c->XferCount!=0))
\r
2588 DevAddress = (hi2c->Instance->CR2 & I2C_CR2_SADD);
\r
2590 if(hi2c->XferCount > 255)
\r
2592 I2C_TransferConfig(hi2c,DevAddress,255, I2C_RELOAD_MODE, I2C_NO_STARTSTOP);
\r
2593 hi2c->XferSize = 255;
\r
2597 I2C_TransferConfig(hi2c,DevAddress,hi2c->XferCount, I2C_AUTOEND_MODE, I2C_NO_STARTSTOP);
\r
2598 hi2c->XferSize = hi2c->XferCount;
\r
2603 /* Process Unlocked */
\r
2604 __HAL_UNLOCK(hi2c);
\r
2606 /* Wrong size Status regarding TCR flag event */
\r
2607 hi2c->ErrorCode |= HAL_I2C_ERROR_SIZE;
\r
2608 HAL_I2C_ErrorCallback(hi2c);
\r
2611 else if(__HAL_I2C_GET_FLAG(hi2c, I2C_FLAG_TC) == SET)
\r
2613 if(hi2c->XferCount == 0)
\r
2615 /* Generate Stop */
\r
2616 hi2c->Instance->CR2 |= I2C_CR2_STOP;
\r
2620 /* Process Unlocked */
\r
2621 __HAL_UNLOCK(hi2c);
\r
2623 /* Wrong size Status regarding TCR flag event */
\r
2624 hi2c->ErrorCode |= HAL_I2C_ERROR_SIZE;
\r
2625 HAL_I2C_ErrorCallback(hi2c);
\r
2628 else if(__HAL_I2C_GET_FLAG(hi2c, I2C_FLAG_STOPF) == SET)
\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
2633 /* Clear STOP Flag */
\r
2634 __HAL_I2C_CLEAR_FLAG(hi2c, I2C_FLAG_STOPF);
\r
2636 /* Clear Configuration Register 2 */
\r
2637 I2C_RESET_CR2(hi2c);
\r
2639 hi2c->State = HAL_I2C_STATE_READY;
\r
2641 /* Process Unlocked */
\r
2642 __HAL_UNLOCK(hi2c);
\r
2644 if(hi2c->State == HAL_I2C_STATE_MEM_BUSY_TX)
\r
2646 HAL_I2C_MemTxCpltCallback(hi2c);
\r
2650 HAL_I2C_MasterTxCpltCallback(hi2c);
\r
2653 else if(__HAL_I2C_GET_FLAG(hi2c, I2C_FLAG_AF) == SET)
\r
2655 /* Clear NACK Flag */
\r
2656 __HAL_I2C_CLEAR_FLAG(hi2c, I2C_FLAG_AF);
\r
2658 /* Process Unlocked */
\r
2659 __HAL_UNLOCK(hi2c);
\r
2661 hi2c->ErrorCode |= HAL_I2C_ERROR_AF;
\r
2662 HAL_I2C_ErrorCallback(hi2c);
\r
2665 /* Process Unlocked */
\r
2666 __HAL_UNLOCK(hi2c);
\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
2677 static HAL_StatusTypeDef I2C_MasterReceive_ISR(I2C_HandleTypeDef *hi2c)
\r
2679 uint16_t DevAddress;
\r
2681 /* Process Locked */
\r
2684 if(__HAL_I2C_GET_FLAG(hi2c, I2C_FLAG_RXNE) == SET)
\r
2686 /* Read data from RXDR */
\r
2687 (*hi2c->pBuffPtr++) = hi2c->Instance->RXDR;
\r
2689 hi2c->XferCount--;
\r
2691 else if(__HAL_I2C_GET_FLAG(hi2c, I2C_FLAG_TCR) == SET)
\r
2693 if((hi2c->XferSize == 0)&&(hi2c->XferCount!=0))
\r
2695 DevAddress = (hi2c->Instance->CR2 & I2C_CR2_SADD);
\r
2697 if(hi2c->XferCount > 255)
\r
2699 I2C_TransferConfig(hi2c,DevAddress,255, I2C_RELOAD_MODE, I2C_NO_STARTSTOP);
\r
2700 hi2c->XferSize = 255;
\r
2704 I2C_TransferConfig(hi2c,DevAddress,hi2c->XferCount, I2C_AUTOEND_MODE, I2C_NO_STARTSTOP);
\r
2705 hi2c->XferSize = hi2c->XferCount;
\r
2710 /* Process Unlocked */
\r
2711 __HAL_UNLOCK(hi2c);
\r
2713 /* Wrong size Status regarding TCR flag event */
\r
2714 hi2c->ErrorCode |= HAL_I2C_ERROR_SIZE;
\r
2715 HAL_I2C_ErrorCallback(hi2c);
\r
2718 else if(__HAL_I2C_GET_FLAG(hi2c, I2C_FLAG_TC) == SET)
\r
2720 if(hi2c->XferCount == 0)
\r
2722 /* Generate Stop */
\r
2723 hi2c->Instance->CR2 |= I2C_CR2_STOP;
\r
2727 /* Process Unlocked */
\r
2728 __HAL_UNLOCK(hi2c);
\r
2730 /* Wrong size Status regarding TCR flag event */
\r
2731 hi2c->ErrorCode |= HAL_I2C_ERROR_SIZE;
\r
2732 HAL_I2C_ErrorCallback(hi2c);
\r
2735 else if(__HAL_I2C_GET_FLAG(hi2c, I2C_FLAG_STOPF) == SET)
\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
2740 /* Clear STOP Flag */
\r
2741 __HAL_I2C_CLEAR_FLAG(hi2c, I2C_FLAG_STOPF);
\r
2743 /* Clear Configuration Register 2 */
\r
2744 I2C_RESET_CR2(hi2c);
\r
2746 hi2c->State = HAL_I2C_STATE_READY;
\r
2748 /* Process Unlocked */
\r
2749 __HAL_UNLOCK(hi2c);
\r
2751 if(hi2c->State == HAL_I2C_STATE_MEM_BUSY_RX)
\r
2753 HAL_I2C_MemRxCpltCallback(hi2c);
\r
2757 HAL_I2C_MasterRxCpltCallback(hi2c);
\r
2760 else if(__HAL_I2C_GET_FLAG(hi2c, I2C_FLAG_AF) == SET)
\r
2762 /* Clear NACK Flag */
\r
2763 __HAL_I2C_CLEAR_FLAG(hi2c, I2C_FLAG_AF);
\r
2765 /* Process Unlocked */
\r
2766 __HAL_UNLOCK(hi2c);
\r
2768 hi2c->ErrorCode |= HAL_I2C_ERROR_AF;
\r
2769 HAL_I2C_ErrorCallback(hi2c);
\r
2772 /* Process Unlocked */
\r
2773 __HAL_UNLOCK(hi2c);
\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
2785 static HAL_StatusTypeDef I2C_SlaveTransmit_ISR(I2C_HandleTypeDef *hi2c)
\r
2787 /* Process locked */
\r
2790 if(__HAL_I2C_GET_FLAG(hi2c, I2C_FLAG_AF) != RESET)
\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
2798 /* Clear NACK Flag */
\r
2799 __HAL_I2C_CLEAR_FLAG(hi2c, I2C_FLAG_AF);
\r
2801 /* Process Unlocked */
\r
2802 __HAL_UNLOCK(hi2c);
\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
2810 /* Set ErrorCode corresponding to a Non-Acknowledge */
\r
2811 hi2c->ErrorCode |= HAL_I2C_ERROR_AF;
\r
2813 /* Process Unlocked */
\r
2814 __HAL_UNLOCK(hi2c);
\r
2816 /* Call the Error callback to prevent upper layer */
\r
2817 HAL_I2C_ErrorCallback(hi2c);
\r
2820 else if(__HAL_I2C_GET_FLAG(hi2c, I2C_FLAG_ADDR) == SET)
\r
2822 /* Clear ADDR flag */
\r
2823 __HAL_I2C_CLEAR_FLAG(hi2c, I2C_FLAG_ADDR);
\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
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
2834 /* Disable Address Acknowledge */
\r
2835 hi2c->Instance->CR2 |= I2C_CR2_NACK;
\r
2837 /* Clear STOP Flag */
\r
2838 __HAL_I2C_CLEAR_FLAG(hi2c, I2C_FLAG_STOPF);
\r
2840 hi2c->State = HAL_I2C_STATE_READY;
\r
2842 /* Process Unlocked */
\r
2843 __HAL_UNLOCK(hi2c);
\r
2845 HAL_I2C_SlaveTxCpltCallback(hi2c);
\r
2847 else if(__HAL_I2C_GET_FLAG(hi2c, I2C_FLAG_TXIS) == SET)
\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
2853 /* Write data to TXDR */
\r
2854 hi2c->Instance->TXDR = (*hi2c->pBuffPtr++);
\r
2855 hi2c->XferCount--;
\r
2859 /* Process Unlocked */
\r
2860 __HAL_UNLOCK(hi2c);
\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
2871 static HAL_StatusTypeDef I2C_SlaveReceive_ISR(I2C_HandleTypeDef *hi2c)
\r
2873 /* Process Locked */
\r
2876 if(__HAL_I2C_GET_FLAG(hi2c, I2C_FLAG_AF) != RESET)
\r
2878 /* Clear NACK Flag */
\r
2879 __HAL_I2C_CLEAR_FLAG(hi2c, I2C_FLAG_AF);
\r
2881 /* Process Unlocked */
\r
2882 __HAL_UNLOCK(hi2c);
\r
2884 hi2c->ErrorCode |= HAL_I2C_ERROR_AF;
\r
2885 HAL_I2C_ErrorCallback(hi2c);
\r
2887 else if(__HAL_I2C_GET_FLAG(hi2c, I2C_FLAG_ADDR) == SET)
\r
2889 /* Clear ADDR flag */
\r
2890 __HAL_I2C_CLEAR_FLAG(hi2c, I2C_FLAG_ADDR);
\r
2892 else if(__HAL_I2C_GET_FLAG(hi2c, I2C_FLAG_RXNE) == SET)
\r
2894 /* Read data from RXDR */
\r
2895 (*hi2c->pBuffPtr++) = hi2c->Instance->RXDR;
\r
2897 hi2c->XferCount--;
\r
2899 else if(__HAL_I2C_GET_FLAG(hi2c, I2C_FLAG_STOPF) == SET)
\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
2904 /* Disable Address Acknowledge */
\r
2905 hi2c->Instance->CR2 |= I2C_CR2_NACK;
\r
2907 /* Clear STOP Flag */
\r
2908 __HAL_I2C_CLEAR_FLAG(hi2c, I2C_FLAG_STOPF);
\r
2910 hi2c->State = HAL_I2C_STATE_READY;
\r
2912 /* Process Unlocked */
\r
2913 __HAL_UNLOCK(hi2c);
\r
2915 HAL_I2C_SlaveRxCpltCallback(hi2c);
\r
2918 /* Process Unlocked */
\r
2919 __HAL_UNLOCK(hi2c);
\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
2934 static HAL_StatusTypeDef I2C_RequestMemoryWrite(I2C_HandleTypeDef *hi2c, uint16_t DevAddress, uint16_t MemAddress, uint16_t MemAddSize, uint32_t Timeout)
\r
2936 I2C_TransferConfig(hi2c,DevAddress,MemAddSize, I2C_RELOAD_MODE, I2C_GENERATE_START_WRITE);
\r
2938 /* Wait until TXIS flag is set */
\r
2939 if(I2C_WaitOnTXISFlagUntilTimeout(hi2c, Timeout) != HAL_OK)
\r
2941 if(hi2c->ErrorCode == HAL_I2C_ERROR_AF)
\r
2947 return HAL_TIMEOUT;
\r
2951 /* If Memory address size is 8Bit */
\r
2952 if(MemAddSize == I2C_MEMADD_SIZE_8BIT)
\r
2954 /* Send Memory Address */
\r
2955 hi2c->Instance->TXDR = I2C_MEM_ADD_LSB(MemAddress);
\r
2957 /* If Memory address size is 16Bit */
\r
2960 /* Send MSB of Memory Address */
\r
2961 hi2c->Instance->TXDR = I2C_MEM_ADD_MSB(MemAddress);
\r
2963 /* Wait until TXIS flag is set */
\r
2964 if(I2C_WaitOnTXISFlagUntilTimeout(hi2c, Timeout) != HAL_OK)
\r
2966 if(hi2c->ErrorCode == HAL_I2C_ERROR_AF)
\r
2972 return HAL_TIMEOUT;
\r
2976 /* Send LSB of Memory Address */
\r
2977 hi2c->Instance->TXDR = I2C_MEM_ADD_LSB(MemAddress);
\r
2980 /* Wait until TCR flag is set */
\r
2981 if(I2C_WaitOnFlagUntilTimeout(hi2c, I2C_FLAG_TCR, RESET, Timeout) != HAL_OK)
\r
2983 return HAL_TIMEOUT;
\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
2999 static HAL_StatusTypeDef I2C_RequestMemoryRead(I2C_HandleTypeDef *hi2c, uint16_t DevAddress, uint16_t MemAddress, uint16_t MemAddSize, uint32_t Timeout)
\r
3001 I2C_TransferConfig(hi2c,DevAddress,MemAddSize, I2C_SOFTEND_MODE, I2C_GENERATE_START_WRITE);
\r
3003 /* Wait until TXIS flag is set */
\r
3004 if(I2C_WaitOnTXISFlagUntilTimeout(hi2c, Timeout) != HAL_OK)
\r
3006 if(hi2c->ErrorCode == HAL_I2C_ERROR_AF)
\r
3012 return HAL_TIMEOUT;
\r
3016 /* If Memory address size is 8Bit */
\r
3017 if(MemAddSize == I2C_MEMADD_SIZE_8BIT)
\r
3019 /* Send Memory Address */
\r
3020 hi2c->Instance->TXDR = I2C_MEM_ADD_LSB(MemAddress);
\r
3022 /* If Memory address size is 16Bit */
\r
3025 /* Send MSB of Memory Address */
\r
3026 hi2c->Instance->TXDR = I2C_MEM_ADD_MSB(MemAddress);
\r
3028 /* Wait until TXIS flag is set */
\r
3029 if(I2C_WaitOnTXISFlagUntilTimeout(hi2c, Timeout) != HAL_OK)
\r
3031 if(hi2c->ErrorCode == HAL_I2C_ERROR_AF)
\r
3037 return HAL_TIMEOUT;
\r
3041 /* Send LSB of Memory Address */
\r
3042 hi2c->Instance->TXDR = I2C_MEM_ADD_LSB(MemAddress);
\r
3045 /* Wait until TC flag is set */
\r
3046 if(I2C_WaitOnFlagUntilTimeout(hi2c, I2C_FLAG_TC, RESET, Timeout) != HAL_OK)
\r
3048 return HAL_TIMEOUT;
\r
3055 * @brief DMA I2C master transmit process complete callback.
\r
3056 * @param hdma: DMA handle
\r
3059 static void I2C_DMAMasterTransmitCplt(DMA_HandleTypeDef *hdma)
\r
3061 uint16_t DevAddress;
\r
3062 I2C_HandleTypeDef* hi2c = (I2C_HandleTypeDef*)((DMA_HandleTypeDef*)hdma)->Parent;
\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
3068 /* Wait until TCR flag is set */
\r
3069 if(I2C_WaitOnFlagUntilTimeout(hi2c, I2C_FLAG_TCR, RESET, I2C_TIMEOUT_TCR) != HAL_OK)
\r
3071 hi2c->ErrorCode |= HAL_I2C_ERROR_TIMEOUT;
\r
3074 /* Disable DMA Request */
\r
3075 hi2c->Instance->CR1 &= ~I2C_CR1_TXDMAEN;
\r
3077 /* Check if Errors has been detected during transfer */
\r
3078 if(hi2c->ErrorCode != HAL_I2C_ERROR_NONE)
\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
3084 if(hi2c->ErrorCode == HAL_I2C_ERROR_AF)
\r
3086 hi2c->ErrorCode |= HAL_I2C_ERROR_AF;
\r
3090 hi2c->ErrorCode |= HAL_I2C_ERROR_TIMEOUT;
\r
3094 /* Clear STOP Flag */
\r
3095 __HAL_I2C_CLEAR_FLAG(hi2c, I2C_FLAG_STOPF);
\r
3097 /* Clear Configuration Register 2 */
\r
3098 I2C_RESET_CR2(hi2c);
\r
3100 hi2c->XferCount = 0;
\r
3102 hi2c->State = HAL_I2C_STATE_READY;
\r
3103 HAL_I2C_ErrorCallback(hi2c);
\r
3107 hi2c->pBuffPtr += hi2c->XferSize;
\r
3108 hi2c->XferCount -= hi2c->XferSize;
\r
3109 if(hi2c->XferCount > 255)
\r
3111 hi2c->XferSize = 255;
\r
3115 hi2c->XferSize = hi2c->XferCount;
\r
3118 DevAddress = (hi2c->Instance->CR2 & I2C_CR2_SADD);
\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
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
3127 I2C_TransferConfig(hi2c,DevAddress,hi2c->XferSize, I2C_RELOAD_MODE, I2C_NO_STARTSTOP);
\r
3131 I2C_TransferConfig(hi2c,DevAddress,hi2c->XferSize, I2C_AUTOEND_MODE, I2C_NO_STARTSTOP);
\r
3134 /* Wait until TXIS flag is set */
\r
3135 if(I2C_WaitOnTXISFlagUntilTimeout(hi2c, I2C_TIMEOUT_TXIS) != HAL_OK)
\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
3141 if(hi2c->ErrorCode == HAL_I2C_ERROR_AF)
\r
3143 hi2c->ErrorCode |= HAL_I2C_ERROR_AF;
\r
3147 hi2c->ErrorCode |= HAL_I2C_ERROR_TIMEOUT;
\r
3151 /* Clear STOP Flag */
\r
3152 __HAL_I2C_CLEAR_FLAG(hi2c, I2C_FLAG_STOPF);
\r
3154 /* Clear Configuration Register 2 */
\r
3155 I2C_RESET_CR2(hi2c);
\r
3157 hi2c->XferCount = 0;
\r
3159 hi2c->State = HAL_I2C_STATE_READY;
\r
3160 HAL_I2C_ErrorCallback(hi2c);
\r
3164 /* Enable DMA Request */
\r
3165 hi2c->Instance->CR1 |= I2C_CR1_TXDMAEN;
\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
3175 if(hi2c->ErrorCode == HAL_I2C_ERROR_AF)
\r
3177 hi2c->ErrorCode |= HAL_I2C_ERROR_AF;
\r
3181 hi2c->ErrorCode |= HAL_I2C_ERROR_TIMEOUT;
\r
3185 /* Clear STOP Flag */
\r
3186 __HAL_I2C_CLEAR_FLAG(hi2c, I2C_FLAG_STOPF);
\r
3188 /* Clear Configuration Register 2 */
\r
3189 I2C_RESET_CR2(hi2c);
\r
3191 /* Disable DMA Request */
\r
3192 hi2c->Instance->CR1 &= ~I2C_CR1_TXDMAEN;
\r
3194 hi2c->XferCount = 0;
\r
3196 hi2c->State = HAL_I2C_STATE_READY;
\r
3198 /* Check if Errors has been detected during transfer */
\r
3199 if(hi2c->ErrorCode != HAL_I2C_ERROR_NONE)
\r
3201 HAL_I2C_ErrorCallback(hi2c);
\r
3205 HAL_I2C_MasterTxCpltCallback(hi2c);
\r
3211 * @brief DMA I2C slave transmit process complete callback.
\r
3212 * @param hdma: DMA handle
\r
3215 static void I2C_DMASlaveTransmitCplt(DMA_HandleTypeDef *hdma)
\r
3217 I2C_HandleTypeDef* hi2c = (I2C_HandleTypeDef*)((DMA_HandleTypeDef*)hdma)->Parent;
\r
3219 /* Wait until STOP flag is set */
\r
3220 if(I2C_WaitOnSTOPFlagUntilTimeout(hi2c, I2C_TIMEOUT_STOPF) != HAL_OK)
\r
3222 if(hi2c->ErrorCode == HAL_I2C_ERROR_AF)
\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
3230 hi2c->ErrorCode |= HAL_I2C_ERROR_TIMEOUT;
\r
3234 /* Clear STOP flag */
\r
3235 __HAL_I2C_CLEAR_FLAG(hi2c,I2C_FLAG_STOPF);
\r
3237 /* Wait until BUSY flag is reset */
\r
3238 if(I2C_WaitOnFlagUntilTimeout(hi2c, I2C_FLAG_BUSY, SET, I2C_TIMEOUT_BUSY) != HAL_OK)
\r
3240 hi2c->ErrorCode |= HAL_I2C_ERROR_TIMEOUT;
\r
3243 /* Disable DMA Request */
\r
3244 hi2c->Instance->CR1 &= ~I2C_CR1_TXDMAEN;
\r
3246 hi2c->XferCount = 0;
\r
3248 hi2c->State = HAL_I2C_STATE_READY;
\r
3250 /* Check if Errors has been detected during transfer */
\r
3251 if(hi2c->ErrorCode != HAL_I2C_ERROR_NONE)
\r
3253 HAL_I2C_ErrorCallback(hi2c);
\r
3257 HAL_I2C_SlaveTxCpltCallback(hi2c);
\r
3262 * @brief DMA I2C master receive process complete callback
\r
3263 * @param hdma: DMA handle
\r
3266 static void I2C_DMAMasterReceiveCplt(DMA_HandleTypeDef *hdma)
\r
3268 I2C_HandleTypeDef* hi2c = (I2C_HandleTypeDef*)((DMA_HandleTypeDef*)hdma)->Parent;
\r
3269 uint16_t DevAddress;
\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
3275 /* Wait until TCR flag is set */
\r
3276 if(I2C_WaitOnFlagUntilTimeout(hi2c, I2C_FLAG_TCR, RESET, I2C_TIMEOUT_TCR) != HAL_OK)
\r
3278 hi2c->ErrorCode |= HAL_I2C_ERROR_TIMEOUT;
\r
3281 /* Disable DMA Request */
\r
3282 hi2c->Instance->CR1 &= ~I2C_CR1_RXDMAEN;
\r
3284 /* Check if Errors has been detected during transfer */
\r
3285 if(hi2c->ErrorCode != HAL_I2C_ERROR_NONE)
\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
3291 if(hi2c->ErrorCode == HAL_I2C_ERROR_AF)
\r
3293 hi2c->ErrorCode |= HAL_I2C_ERROR_AF;
\r
3297 hi2c->ErrorCode |= HAL_I2C_ERROR_TIMEOUT;
\r
3301 /* Clear STOP Flag */
\r
3302 __HAL_I2C_CLEAR_FLAG(hi2c, I2C_FLAG_STOPF);
\r
3304 /* Clear Configuration Register 2 */
\r
3305 I2C_RESET_CR2(hi2c);
\r
3307 hi2c->XferCount = 0;
\r
3309 hi2c->State = HAL_I2C_STATE_READY;
\r
3310 HAL_I2C_ErrorCallback(hi2c);
\r
3314 hi2c->pBuffPtr += hi2c->XferSize;
\r
3315 hi2c->XferCount -= hi2c->XferSize;
\r
3316 if(hi2c->XferCount > 255)
\r
3318 hi2c->XferSize = 255;
\r
3322 hi2c->XferSize = hi2c->XferCount;
\r
3325 DevAddress = (hi2c->Instance->CR2 & I2C_CR2_SADD);
\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
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
3334 I2C_TransferConfig(hi2c,DevAddress,hi2c->XferSize, I2C_RELOAD_MODE, I2C_NO_STARTSTOP);
\r
3338 I2C_TransferConfig(hi2c,DevAddress,hi2c->XferSize, I2C_AUTOEND_MODE, I2C_NO_STARTSTOP);
\r
3341 /* Wait until RXNE flag is set */
\r
3342 if(I2C_WaitOnFlagUntilTimeout(hi2c, I2C_FLAG_RXNE, RESET, I2C_TIMEOUT_RXNE) != HAL_OK)
\r
3344 hi2c->ErrorCode |= HAL_I2C_ERROR_TIMEOUT;
\r
3347 /* Check if Errors has been detected during transfer */
\r
3348 if(hi2c->ErrorCode != HAL_I2C_ERROR_NONE)
\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
3354 if(hi2c->ErrorCode == HAL_I2C_ERROR_AF)
\r
3356 hi2c->ErrorCode |= HAL_I2C_ERROR_AF;
\r
3360 hi2c->ErrorCode |= HAL_I2C_ERROR_TIMEOUT;
\r
3364 /* Clear STOP Flag */
\r
3365 __HAL_I2C_CLEAR_FLAG(hi2c, I2C_FLAG_STOPF);
\r
3367 /* Clear Configuration Register 2 */
\r
3368 I2C_RESET_CR2(hi2c);
\r
3370 hi2c->XferCount = 0;
\r
3372 hi2c->State = HAL_I2C_STATE_READY;
\r
3374 HAL_I2C_ErrorCallback(hi2c);
\r
3378 /* Enable DMA Request */
\r
3379 hi2c->Instance->CR1 |= I2C_CR1_RXDMAEN;
\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
3389 if(hi2c->ErrorCode == HAL_I2C_ERROR_AF)
\r
3391 hi2c->ErrorCode |= HAL_I2C_ERROR_AF;
\r
3395 hi2c->ErrorCode |= HAL_I2C_ERROR_TIMEOUT;
\r
3399 /* Clear STOP Flag */
\r
3400 __HAL_I2C_CLEAR_FLAG(hi2c, I2C_FLAG_STOPF);
\r
3402 /* Clear Configuration Register 2 */
\r
3403 I2C_RESET_CR2(hi2c);
\r
3405 /* Disable DMA Request */
\r
3406 hi2c->Instance->CR1 &= ~I2C_CR1_RXDMAEN;
\r
3408 hi2c->XferCount = 0;
\r
3410 hi2c->State = HAL_I2C_STATE_READY;
\r
3412 /* Check if Errors has been detected during transfer */
\r
3413 if(hi2c->ErrorCode != HAL_I2C_ERROR_NONE)
\r
3415 HAL_I2C_ErrorCallback(hi2c);
\r
3419 HAL_I2C_MasterRxCpltCallback(hi2c);
\r
3425 * @brief DMA I2C slave receive process complete callback.
\r
3426 * @param hdma: DMA handle
\r
3429 static void I2C_DMASlaveReceiveCplt(DMA_HandleTypeDef *hdma)
\r
3431 I2C_HandleTypeDef* hi2c = (I2C_HandleTypeDef*)((DMA_HandleTypeDef*)hdma)->Parent;
\r
3433 /* Wait until STOPF flag is reset */
\r
3434 if(I2C_WaitOnSTOPFlagUntilTimeout(hi2c, I2C_TIMEOUT_STOPF) != HAL_OK)
\r
3436 if(hi2c->ErrorCode == HAL_I2C_ERROR_AF)
\r
3438 hi2c->ErrorCode |= HAL_I2C_ERROR_AF;
\r
3442 hi2c->ErrorCode |= HAL_I2C_ERROR_TIMEOUT;
\r
3446 /* Clear STOPF flag */
\r
3447 __HAL_I2C_CLEAR_FLAG(hi2c, I2C_FLAG_STOPF);
\r
3449 /* Wait until BUSY flag is reset */
\r
3450 if(I2C_WaitOnFlagUntilTimeout(hi2c, I2C_FLAG_BUSY, SET, I2C_TIMEOUT_BUSY) != HAL_OK)
\r
3452 hi2c->ErrorCode |= HAL_I2C_ERROR_TIMEOUT;
\r
3455 /* Disable DMA Request */
\r
3456 hi2c->Instance->CR1 &= ~I2C_CR1_RXDMAEN;
\r
3458 /* Disable Address Acknowledge */
\r
3459 hi2c->Instance->CR2 |= I2C_CR2_NACK;
\r
3461 hi2c->XferCount = 0;
\r
3463 hi2c->State = HAL_I2C_STATE_READY;
\r
3465 /* Check if Errors has been detected during transfer */
\r
3466 if(hi2c->ErrorCode != HAL_I2C_ERROR_NONE)
\r
3468 HAL_I2C_ErrorCallback(hi2c);
\r
3472 HAL_I2C_SlaveRxCpltCallback(hi2c);
\r
3477 * @brief DMA I2C Memory Write process complete callback
\r
3478 * @param hdma : DMA handle
\r
3481 static void I2C_DMAMemTransmitCplt(DMA_HandleTypeDef *hdma)
\r
3483 uint16_t DevAddress;
\r
3484 I2C_HandleTypeDef* hi2c = ( I2C_HandleTypeDef* )((DMA_HandleTypeDef* )hdma)->Parent;
\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
3490 /* Wait until TCR flag is set */
\r
3491 if(I2C_WaitOnFlagUntilTimeout(hi2c, I2C_FLAG_TCR, RESET, I2C_TIMEOUT_TCR) != HAL_OK)
\r
3493 hi2c->ErrorCode |= HAL_I2C_ERROR_TIMEOUT;
\r
3496 /* Disable DMA Request */
\r
3497 hi2c->Instance->CR1 &= ~I2C_CR1_TXDMAEN;
\r
3499 /* Check if Errors has been detected during transfer */
\r
3500 if(hi2c->ErrorCode != HAL_I2C_ERROR_NONE)
\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
3506 if(hi2c->ErrorCode == HAL_I2C_ERROR_AF)
\r
3508 hi2c->ErrorCode |= HAL_I2C_ERROR_AF;
\r
3512 hi2c->ErrorCode |= HAL_I2C_ERROR_TIMEOUT;
\r
3516 /* Clear STOP Flag */
\r
3517 __HAL_I2C_CLEAR_FLAG(hi2c, I2C_FLAG_STOPF);
\r
3519 /* Clear Configuration Register 2 */
\r
3520 I2C_RESET_CR2(hi2c);
\r
3522 hi2c->XferCount = 0;
\r
3524 hi2c->State = HAL_I2C_STATE_READY;
\r
3525 HAL_I2C_ErrorCallback(hi2c);
\r
3529 hi2c->pBuffPtr += hi2c->XferSize;
\r
3530 hi2c->XferCount -= hi2c->XferSize;
\r
3531 if(hi2c->XferCount > 255)
\r
3533 hi2c->XferSize = 255;
\r
3537 hi2c->XferSize = hi2c->XferCount;
\r
3540 DevAddress = (hi2c->Instance->CR2 & I2C_CR2_SADD);
\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
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
3549 I2C_TransferConfig(hi2c,DevAddress,hi2c->XferSize, I2C_RELOAD_MODE, I2C_NO_STARTSTOP);
\r
3553 I2C_TransferConfig(hi2c,DevAddress,hi2c->XferSize, I2C_AUTOEND_MODE, I2C_NO_STARTSTOP);
\r
3556 /* Wait until TXIS flag is set */
\r
3557 if(I2C_WaitOnTXISFlagUntilTimeout(hi2c, I2C_TIMEOUT_TXIS) != HAL_OK)
\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
3563 if(hi2c->ErrorCode == HAL_I2C_ERROR_AF)
\r
3565 hi2c->ErrorCode |= HAL_I2C_ERROR_AF;
\r
3569 hi2c->ErrorCode |= HAL_I2C_ERROR_TIMEOUT;
\r
3573 /* Clear STOP Flag */
\r
3574 __HAL_I2C_CLEAR_FLAG(hi2c, I2C_FLAG_STOPF);
\r
3576 /* Clear Configuration Register 2 */
\r
3577 I2C_RESET_CR2(hi2c);
\r
3579 hi2c->XferCount = 0;
\r
3581 hi2c->State = HAL_I2C_STATE_READY;
\r
3582 HAL_I2C_ErrorCallback(hi2c);
\r
3586 /* Enable DMA Request */
\r
3587 hi2c->Instance->CR1 |= I2C_CR1_TXDMAEN;
\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
3597 if(hi2c->ErrorCode == HAL_I2C_ERROR_AF)
\r
3599 hi2c->ErrorCode |= HAL_I2C_ERROR_AF;
\r
3603 hi2c->ErrorCode |= HAL_I2C_ERROR_TIMEOUT;
\r
3607 /* Clear STOP Flag */
\r
3608 __HAL_I2C_CLEAR_FLAG(hi2c, I2C_FLAG_STOPF);
\r
3610 /* Clear Configuration Register 2 */
\r
3611 I2C_RESET_CR2(hi2c);
\r
3613 /* Disable DMA Request */
\r
3614 hi2c->Instance->CR1 &= ~I2C_CR1_TXDMAEN;
\r
3616 hi2c->XferCount = 0;
\r
3618 hi2c->State = HAL_I2C_STATE_READY;
\r
3620 /* Check if Errors has been detected during transfer */
\r
3621 if(hi2c->ErrorCode != HAL_I2C_ERROR_NONE)
\r
3623 HAL_I2C_ErrorCallback(hi2c);
\r
3627 HAL_I2C_MemTxCpltCallback(hi2c);
\r
3633 * @brief DMA I2C Memory Read process complete callback
\r
3634 * @param hdma: DMA handle
\r
3637 static void I2C_DMAMemReceiveCplt(DMA_HandleTypeDef *hdma)
\r
3639 I2C_HandleTypeDef* hi2c = ( I2C_HandleTypeDef* )((DMA_HandleTypeDef* )hdma)->Parent;
\r
3640 uint16_t DevAddress;
\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
3646 /* Wait until TCR flag is set */
\r
3647 if(I2C_WaitOnFlagUntilTimeout(hi2c, I2C_FLAG_TCR, RESET, I2C_TIMEOUT_TCR) != HAL_OK)
\r
3649 hi2c->ErrorCode |= HAL_I2C_ERROR_TIMEOUT;
\r
3652 /* Disable DMA Request */
\r
3653 hi2c->Instance->CR1 &= ~I2C_CR1_RXDMAEN;
\r
3655 /* Check if Errors has been detected during transfer */
\r
3656 if(hi2c->ErrorCode != HAL_I2C_ERROR_NONE)
\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
3662 if(hi2c->ErrorCode == HAL_I2C_ERROR_AF)
\r
3664 hi2c->ErrorCode |= HAL_I2C_ERROR_AF;
\r
3668 hi2c->ErrorCode |= HAL_I2C_ERROR_TIMEOUT;
\r
3672 /* Clear STOP Flag */
\r
3673 __HAL_I2C_CLEAR_FLAG(hi2c, I2C_FLAG_STOPF);
\r
3675 /* Clear Configuration Register 2 */
\r
3676 I2C_RESET_CR2(hi2c);
\r
3678 hi2c->XferCount = 0;
\r
3680 hi2c->State = HAL_I2C_STATE_READY;
\r
3681 HAL_I2C_ErrorCallback(hi2c);
\r
3685 hi2c->pBuffPtr += hi2c->XferSize;
\r
3686 hi2c->XferCount -= hi2c->XferSize;
\r
3687 if(hi2c->XferCount > 255)
\r
3689 hi2c->XferSize = 255;
\r
3693 hi2c->XferSize = hi2c->XferCount;
\r
3696 DevAddress = (hi2c->Instance->CR2 & I2C_CR2_SADD);
\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
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
3705 I2C_TransferConfig(hi2c,DevAddress,hi2c->XferSize, I2C_RELOAD_MODE, I2C_NO_STARTSTOP);
\r
3709 I2C_TransferConfig(hi2c,DevAddress,hi2c->XferSize, I2C_AUTOEND_MODE, I2C_NO_STARTSTOP);
\r
3712 /* Wait until RXNE flag is set */
\r
3713 if(I2C_WaitOnFlagUntilTimeout(hi2c, I2C_FLAG_RXNE, RESET, I2C_TIMEOUT_RXNE) != HAL_OK)
\r
3715 hi2c->ErrorCode |= HAL_I2C_ERROR_TIMEOUT;
\r
3718 /* Check if Errors has been detected during transfer */
\r
3719 if(hi2c->ErrorCode != HAL_I2C_ERROR_NONE)
\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
3725 if(hi2c->ErrorCode == HAL_I2C_ERROR_AF)
\r
3727 hi2c->ErrorCode |= HAL_I2C_ERROR_AF;
\r
3731 hi2c->ErrorCode |= HAL_I2C_ERROR_TIMEOUT;
\r
3735 /* Clear STOP Flag */
\r
3736 __HAL_I2C_CLEAR_FLAG(hi2c, I2C_FLAG_STOPF);
\r
3738 /* Clear Configuration Register 2 */
\r
3739 I2C_RESET_CR2(hi2c);
\r
3741 hi2c->XferCount = 0;
\r
3743 hi2c->State = HAL_I2C_STATE_READY;
\r
3744 HAL_I2C_ErrorCallback(hi2c);
\r
3748 /* Enable DMA Request */
\r
3749 hi2c->Instance->CR1 |= I2C_CR1_RXDMAEN;
\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
3759 if(hi2c->ErrorCode == HAL_I2C_ERROR_AF)
\r
3761 hi2c->ErrorCode |= HAL_I2C_ERROR_AF;
\r
3765 hi2c->ErrorCode |= HAL_I2C_ERROR_TIMEOUT;
\r
3769 /* Clear STOP Flag */
\r
3770 __HAL_I2C_CLEAR_FLAG(hi2c, I2C_FLAG_STOPF);
\r
3772 /* Clear Configuration Register 2 */
\r
3773 I2C_RESET_CR2(hi2c);
\r
3775 /* Disable DMA Request */
\r
3776 hi2c->Instance->CR1 &= ~I2C_CR1_RXDMAEN;
\r
3778 hi2c->XferCount = 0;
\r
3780 hi2c->State = HAL_I2C_STATE_READY;
\r
3782 /* Check if Errors has been detected during transfer */
\r
3783 if(hi2c->ErrorCode != HAL_I2C_ERROR_NONE)
\r
3785 HAL_I2C_ErrorCallback(hi2c);
\r
3789 HAL_I2C_MemRxCpltCallback(hi2c);
\r
3795 * @brief DMA I2C communication error callback.
\r
3796 * @param hdma : DMA handle
\r
3799 static void I2C_DMAError(DMA_HandleTypeDef *hdma)
\r
3801 I2C_HandleTypeDef* hi2c = ( I2C_HandleTypeDef* )((DMA_HandleTypeDef* )hdma)->Parent;
\r
3803 /* Disable Acknowledge */
\r
3804 hi2c->Instance->CR2 |= I2C_CR2_NACK;
\r
3806 hi2c->XferCount = 0;
\r
3808 hi2c->State = HAL_I2C_STATE_READY;
\r
3810 hi2c->ErrorCode |= HAL_I2C_ERROR_DMA;
\r
3812 HAL_I2C_ErrorCallback(hi2c);
\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
3824 static HAL_StatusTypeDef I2C_WaitOnFlagUntilTimeout(I2C_HandleTypeDef *hi2c, uint32_t Flag, FlagStatus Status, uint32_t Timeout)
\r
3826 uint32_t tickstart = HAL_GetTick();
\r
3828 /* Wait until flag is set */
\r
3829 if(Status == RESET)
\r
3831 while(__HAL_I2C_GET_FLAG(hi2c, Flag) == RESET)
\r
3833 /* Check for the Timeout */
\r
3834 if(Timeout != HAL_MAX_DELAY)
\r
3836 if((Timeout == 0)||((HAL_GetTick() - tickstart ) > Timeout))
\r
3838 hi2c->State= HAL_I2C_STATE_READY;
\r
3839 /* Process Unlocked */
\r
3840 __HAL_UNLOCK(hi2c);
\r
3841 return HAL_TIMEOUT;
\r
3848 while(__HAL_I2C_GET_FLAG(hi2c, Flag) != RESET)
\r
3850 /* Check for the Timeout */
\r
3851 if(Timeout != HAL_MAX_DELAY)
\r
3853 if((Timeout == 0)||((HAL_GetTick() - tickstart ) > Timeout))
\r
3855 hi2c->State= HAL_I2C_STATE_READY;
\r
3856 /* Process Unlocked */
\r
3857 __HAL_UNLOCK(hi2c);
\r
3858 return HAL_TIMEOUT;
\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
3873 static HAL_StatusTypeDef I2C_WaitOnTXISFlagUntilTimeout(I2C_HandleTypeDef *hi2c, uint32_t Timeout)
\r
3875 uint32_t tickstart = HAL_GetTick();
\r
3877 while(__HAL_I2C_GET_FLAG(hi2c, I2C_FLAG_TXIS) == RESET)
\r
3879 /* Check if a NACK is detected */
\r
3880 if(I2C_IsAcknowledgeFailed(hi2c, Timeout) != HAL_OK)
\r
3885 /* Check for the Timeout */
\r
3886 if(Timeout != HAL_MAX_DELAY)
\r
3888 if((Timeout == 0)||((HAL_GetTick() - tickstart ) > Timeout))
\r
3890 hi2c->ErrorCode |= HAL_I2C_ERROR_TIMEOUT;
\r
3891 hi2c->State= HAL_I2C_STATE_READY;
\r
3893 /* Process Unlocked */
\r
3894 __HAL_UNLOCK(hi2c);
\r
3896 return HAL_TIMEOUT;
\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
3910 static HAL_StatusTypeDef I2C_WaitOnSTOPFlagUntilTimeout(I2C_HandleTypeDef *hi2c, uint32_t Timeout)
\r
3912 uint32_t tickstart = 0x00;
\r
3913 tickstart = HAL_GetTick();
\r
3915 while(__HAL_I2C_GET_FLAG(hi2c, I2C_FLAG_STOPF) == RESET)
\r
3917 /* Check if a NACK is detected */
\r
3918 if(I2C_IsAcknowledgeFailed(hi2c, Timeout) != HAL_OK)
\r
3923 /* Check for the Timeout */
\r
3924 if((Timeout == 0)||((HAL_GetTick() - tickstart ) > Timeout))
\r
3926 hi2c->ErrorCode |= HAL_I2C_ERROR_TIMEOUT;
\r
3927 hi2c->State= HAL_I2C_STATE_READY;
\r
3929 /* Process Unlocked */
\r
3930 __HAL_UNLOCK(hi2c);
\r
3932 return HAL_TIMEOUT;
\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
3945 static HAL_StatusTypeDef I2C_WaitOnRXNEFlagUntilTimeout(I2C_HandleTypeDef *hi2c, uint32_t Timeout)
\r
3947 uint32_t tickstart = 0x00;
\r
3948 tickstart = HAL_GetTick();
\r
3950 while(__HAL_I2C_GET_FLAG(hi2c, I2C_FLAG_RXNE) == RESET)
\r
3952 /* Check if a STOPF is detected */
\r
3953 if(__HAL_I2C_GET_FLAG(hi2c, I2C_FLAG_STOPF) == SET)
\r
3955 /* Clear STOP Flag */
\r
3956 __HAL_I2C_CLEAR_FLAG(hi2c, I2C_FLAG_STOPF);
\r
3958 /* Clear Configuration Register 2 */
\r
3959 I2C_RESET_CR2(hi2c);
\r
3961 hi2c->ErrorCode = HAL_I2C_ERROR_NONE;
\r
3962 hi2c->State= HAL_I2C_STATE_READY;
\r
3964 /* Process Unlocked */
\r
3965 __HAL_UNLOCK(hi2c);
\r
3970 /* Check for the Timeout */
\r
3971 if((Timeout == 0)||((HAL_GetTick() - tickstart ) > Timeout))
\r
3973 hi2c->ErrorCode |= HAL_I2C_ERROR_TIMEOUT;
\r
3974 hi2c->State= HAL_I2C_STATE_READY;
\r
3976 /* Process Unlocked */
\r
3977 __HAL_UNLOCK(hi2c);
\r
3979 return HAL_TIMEOUT;
\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
3992 static HAL_StatusTypeDef I2C_IsAcknowledgeFailed(I2C_HandleTypeDef *hi2c, uint32_t Timeout)
\r
3994 uint32_t tickstart = 0x00;
\r
3995 tickstart = HAL_GetTick();
\r
3997 if(__HAL_I2C_GET_FLAG(hi2c, I2C_FLAG_AF) == SET)
\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
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
4007 /* Generate Stop */
\r
4008 hi2c->Instance->CR2 |= I2C_CR2_STOP;
\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
4016 /* Check for the Timeout */
\r
4017 if(Timeout != HAL_MAX_DELAY)
\r
4019 if((Timeout == 0)||((HAL_GetTick() - tickstart ) > Timeout))
\r
4021 hi2c->State= HAL_I2C_STATE_READY;
\r
4022 /* Process Unlocked */
\r
4023 __HAL_UNLOCK(hi2c);
\r
4024 return HAL_TIMEOUT;
\r
4029 /* Clear NACKF Flag */
\r
4030 __HAL_I2C_CLEAR_FLAG(hi2c, I2C_FLAG_AF);
\r
4032 /* Clear STOP Flag */
\r
4033 __HAL_I2C_CLEAR_FLAG(hi2c, I2C_FLAG_STOPF);
\r
4035 /* Clear Configuration Register 2 */
\r
4036 I2C_RESET_CR2(hi2c);
\r
4038 hi2c->ErrorCode = HAL_I2C_ERROR_AF;
\r
4039 hi2c->State= HAL_I2C_STATE_READY;
\r
4041 /* Process Unlocked */
\r
4042 __HAL_UNLOCK(hi2c);
\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
4068 static void I2C_TransferConfig(I2C_HandleTypeDef *hi2c, uint16_t DevAddress, uint8_t Size, uint32_t Mode, uint32_t Request)
\r
4070 uint32_t tmpreg = 0;
\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
4077 /* Get the CR2 register value */
\r
4078 tmpreg = hi2c->Instance->CR2;
\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
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
4087 /* update CR2 register */
\r
4088 hi2c->Instance->CR2 = tmpreg;
\r
4099 #endif /* HAL_I2C_MODULE_ENABLED */
\r
4108 /************************ (C) COPYRIGHT STMicroelectronics *****END OF FILE****/
\r