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