STM32F030 HAL库I2C Slave问题

beijisnow

想用一片STM32F030来模拟AT24C02
支持I2C Host读取256个字节
可以不用支持I2C host的写操作

使用中断来实现
主机一次读取16个字节，循环读取16次

现在的问题是主机读取第一个16字节没问题
读取第二个16字节就开始有问题了.

请高手帮忙支招，万分感谢









"stm32f0xx_it.c

1. /**
   
2. * @brief This function handles I2C1 global interrupt.
   
3. */
   
4. void I2C1_IRQHandler(void)
   
5. {
   
6.   /* USER CODE BEGIN I2C1_IRQn 0 */
   
7. 
   
8.   /* USER CODE END I2C1_IRQn 0 */
   
9.   if (hi2c1.Instance->ISR & (I2C_FLAG_BERR | I2C_FLAG_ARLO | I2C_FLAG_OVR))
   
10.         {
    
11.     HAL_I2C_ER_IRQHandler(&hi2c1);
    
12.   }
    
13.         else
    
14.         {
    
15.     HAL_I2C_EV_IRQHandler(&hi2c1);
    
16.   }
    
17.   /* USER CODE BEGIN I2C1_IRQn 1 */
    
18. 
    
19.   /* USER CODE END I2C1_IRQn 1 */
    
20. }

复制代码

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

复制代码

1. int main(void)
   
2. {
   
3. 
   
4.   /* USER CODE BEGIN 1 */
   
5. 
   
6.   /* USER CODE END 1 */
   
7. 
   
8.   /* MCU Configuration----------------------------------------------------------*/
   
9. 
   
10.   /* Reset of all peripherals, Initializes the Flash interface and the Systick. */
    
11.   HAL_Init();
    
12. 
    
13.   /* Configure the system clock */
    
14.   SystemClock_Config();
    
15. 
    
16.   /* Initialize all configured peripherals */
    
17.   MX_GPIO_Init();
    
18.   MX_I2C1_Init();
    
19.   MX_SPI1_Init();
    
20.   //MX_USART1_UART_Init();
    
21.                 i2c_status=HAL_I2C_Slave_Transmit_IT(&hi2c1,&EDID_Default[0],256);
    
22.   /* USER CODE BEGIN 2 */
    
23. 
    
24.   /* USER CODE END 2 */
    
25. 
    
26.   /* Infinite loop */
    
27.   /* USER CODE BEGIN WHILE */
    
28.   while (1)
    
29.   {
    
30.   /* USER CODE END WHILE */
    
31.        
    
32.   /* USER CODE BEGIN 3 */
    
33.        
    
34.   }
    
35.   /* USER CODE END 3 */
    
36. 
    
37. }

复制代码

1. /* Includes ------------------------------------------------------------------*/
   
2. #include "i2c.h"
   
3. 
   
4. #include "gpio.h"
   
5. 
   
6. /* USER CODE BEGIN 0 */
   
7. 
   
8. /* USER CODE END 0 */
   
9. 
   
10. I2C_HandleTypeDef hi2c1;
    
11. 
    
12. /* I2C1 init function */
    
13. void MX_I2C1_Init(void)
    
14. {
    
15. 
    
16.   hi2c1.Instance = I2C1;
    
17.   hi2c1.Init.Timing = 0x00201D2B;//0x2000090E;
    
18.   hi2c1.Init.OwnAddress1 = 0xA0;
    
19.   hi2c1.Init.AddressingMode = I2C_ADDRESSINGMODE_7BIT;
    
20.   hi2c1.Init.DualAddressMode = I2C_DUALADDRESS_DISABLED;
    
21.   hi2c1.Init.OwnAddress2 = 0;
    
22.   hi2c1.Init.OwnAddress2Masks = I2C_OA2_NOMASK;
    
23.   hi2c1.Init.GeneralCallMode = I2C_GENERALCALL_DISABLED;
    
24.   hi2c1.Init.NoStretchMode = I2C_NOSTRETCH_DISABLED;
    
25.   HAL_I2C_Init(&hi2c1);
    
26. 
    
27.     /**Configure Analogue filter
    
28.     */
    
29.   HAL_I2CEx_AnalogFilter_Config(&hi2c1, I2C_ANALOGFILTER_ENABLED);
    
30. 
    
31. }
    
32. 
    
33. void HAL_I2C_MspInit(I2C_HandleTypeDef* hi2c)
    
34. {
    
35. 
    
36.   GPIO_InitTypeDef GPIO_InitStruct;
    
37.   if(hi2c->Instance==I2C1)
    
38.   {
    
39.   /* USER CODE BEGIN I2C1_MspInit 0 */
    
40. 
    
41.   /* USER CODE END I2C1_MspInit 0 */
    
42.   
    
43.     /**I2C1 GPIO Configuration   
    
44.     PA9     ------> I2C1_SCL
    
45.     PA10     ------> I2C1_SDA
    
46.     */
    
47.     GPIO_InitStruct.Pin = GPIO_PIN_9|GPIO_PIN_10;
    
48.     GPIO_InitStruct.Mode = GPIO_MODE_AF_OD;
    
49.     GPIO_InitStruct.Pull = GPIO_PULLUP;
    
50.     GPIO_InitStruct.Speed = GPIO_SPEED_HIGH;
    
51.     GPIO_InitStruct.Alternate = GPIO_AF4_I2C1;
    
52.     HAL_GPIO_Init(GPIOA, &GPIO_InitStruct);
    
53. 
    
54.     /* Peripheral clock enable */
    
55.     __I2C1_CLK_ENABLE();
    
56. 
    
57.     /* Peripheral interrupt init*/
    
58.     HAL_NVIC_SetPriority(I2C1_IRQn, 1, 0);
    
59.     HAL_NVIC_EnableIRQ(I2C1_IRQn);
    
60.   /* USER CODE BEGIN I2C1_MspInit 1 */
    
61. 
    
62.   /* USER CODE END I2C1_MspInit 1 */
    
63.   }
    
64. }
    
65. 
    
66. void HAL_I2C_MspDeInit(I2C_HandleTypeDef* hi2c)
    
67. {
    
68. 
    
69.   if(hi2c->Instance==I2C1)
    
70.   {
    
71.   /* USER CODE BEGIN I2C1_MspDeInit 0 */
    
72. 
    
73.   /* USER CODE END I2C1_MspDeInit 0 */
    
74.     /* Peripheral clock disable */
    
75.     __I2C1_CLK_DISABLE();
    
76.   
    
77.     /**I2C1 GPIO Configuration   
    
78.     PA9     ------> I2C1_SCL
    
79.     PA10     ------> I2C1_SDA
    
80.     */
    
81.     HAL_GPIO_DeInit(GPIOA, GPIO_PIN_9|GPIO_PIN_10);
    
82. 
    
83.     /* Peripheral interrupt Deinit*/
    
84.     HAL_NVIC_DisableIRQ(I2C1_IRQn);
    
85. 
    
86.   }
    
87.   /* USER CODE BEGIN I2C1_MspDeInit 1 */
    
88. 
    
89.   /* USER CODE END I2C1_MspDeInit 1 */
    
90. }
    
91. 
    
92. /* USER CODE BEGIN 1 */
    
93. 
    
94. /* USER CODE END 1 */
    
95. 
    
96. /**

复制代码

beijisnow

自问自答

库貌似有问题

I2C 从机NOSTRETCH 模式必须在在使能I2C 外设之前配置。 参见： I2C 从机初始化。

void MX_I2C1_Init(void)
{

  hi2c1.Instance = I2C1;
  hi2c1.Init.Timing = 0x2000090E;//0x00201D2B;
  hi2c1.Init.OwnAddress1 = 0xA0;
  hi2c1.Init.AddressingMode = I2C_ADDRESSINGMODE_7BIT;
  hi2c1.Init.DualAddressMode = I2C_DUALADDRESS_DISABLED;
  hi2c1.Init.OwnAddress2 = 0;
  hi2c1.Init.OwnAddress2Masks = I2C_OA2_NOMASK;
  hi2c1.Init.GeneralCallMode = I2C_GENERALCALL_DISABLED;
  hi2c1.Init.NoStretchMode = I2C_NOSTRETCH_DISABLED;
  HAL_I2C_Init(&hi2c1);

    /**Configure Analogue filter
    */
  HAL_I2CEx_AnalogFilter_Config(&hi2c1, I2C_ANALOGFILTER_ENABLED);
        __I2C1_CLK_ENABLE();
}




将__I2C1_CLK_ENABLE();放在初始化最后，测试通过!

MegaHealth

是不是你没有重写HAL_I2C_MspInit(hi2c);这个函数？所以你添加了CLK enable就好了，在I2C_MspInit中会有关于硬件匹配的设置，例如：

                /* Peripheral clock enable */
                __I2C2_CLK_ENABLE();
                __GPIOB_CLK_ENABLE();

                /**I2C2 GPIO Configuration   
                   PB3     ------> I2C2_SDA
                   PB4     ------> I2C2_SCL
                */
                GPIO_InitStruct.Pin = GPIO_PIN_3;
                GPIO_InitStruct.Mode = GPIO_MODE_AF_OD;
                GPIO_InitStruct.Pull = GPIO_NOPULL;
                GPIO_InitStruct.Speed = GPIO_SPEED_LOW;
                GPIO_InitStruct.Alternate = GPIO_AF9_I2C2;
                HAL_GPIO_Init(GPIOB, &GPIO_InitStruct);

                GPIO_InitStruct.Pin = GPIO_PIN_4;
                GPIO_InitStruct.Mode = GPIO_MODE_AF_OD;
                GPIO_InitStruct.Pull = GPIO_NOPULL;
                GPIO_InitStruct.Speed = GPIO_SPEED_LOW;
                GPIO_InitStruct.Alternate = GPIO_AF4_I2C2;
                HAL_GPIO_Init(GPIOB, &GPIO_InitStruct);
        }

这些是需要你自己添加的。

beijisnow

MegaHealth 发表于 2016-3-8 09:42
是不是你没有重写HAL_I2C_MspInit(hi2c);这个函数？所以你添加了CLK enable就好了，在I2C_MspInit中会有关 ...

这些是有的

库生成的c
是先enable clock再配置analog filter的

要把这两个顺序对调才行

可以通讯了   但发送大量数据会有误码
这还是一个问题

Lucifer科

请问下楼主调通误码的问题了么。我在用stm32L081的做i2c从机的时候也遇到了同样的情况。。主机第一次读没问题，第二次读的时候发完地址，读了1个byte后时钟线就一直被拉低。

yick

这个长度啊！我是用手机看的。IIC每发送一个字节，必须要有一个ACK响应的。

ujewm

楼主后面解决STM32硬件I2C的问题了吗？我新手，最近在尝试使用ST的I2C，处于崩溃边缘徘徊。想问一下HAL_I2C_SLAVE_Receive()和HAL_I2C_SLAVE_Receive_IT()以及HAL_I2C_SLAVE_Receive_DMA()在使用上的区别在哪里？现在使用HAL_I2C_SLAVE_Receive()放在主程序while(1)中可以接收数据，但很容易受到delay()的影响导致通讯错误，然后I2C锁死，把它放入中断函数中不知道会不会能避免这样的错误