mbed-src - mbed library sources

Users » mbed_official » Code » mbed-src

mbed library sources

Dependents: Encrypted my_mbed lklk CyaSSL_DTLS_Cellular ... more

Superseded

This library was superseded by mbed-dev - https://os.mbed.com/users/mbed_official/code/mbed-dev/.

Development branch of the mbed library sources. This library is kept in synch with the latest changes from the mbed SDK and it is not guaranteed to work.

If you are looking for a stable and tested release, please import one of the official mbed library releases:

Import library mbed

The official Mbed 2 C/C++ SDK provides the software platform and libraries to build your applications.

targets/cmsis/TARGET_STM/TARGET_STM32L4/stm32l4xx_hal_i2c.c@610:813dcc80987e, 2015-08-14 (annotated)

Committer:: mbed_official
Date:: Fri Aug 14 13:15:17 2015 +0100
Revision:: 610:813dcc80987e

Synchronized with git revision 6d84db41c6833e0b9b024741eb0616a5f62d5599

Full URL: https://github.com/mbedmicro/mbed/commit/6d84db41c6833e0b9b024741eb0616a5f62d5599/

DISCO_F746NG - Improvements

Who changed what in which revision?

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