mbed official / 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 librarymbed

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

Last commit 20 Feb 2019 by mbed official

targets/cmsis/TARGET_STM/TARGET_DISCO_L053C8/stm32l0xx_hal_i2c.c@376:cb4d9db17537, 2014-10-31 (annotated)

Committer:
mbed_official
Date:
Fri Oct 31 11:00:10 2014 +0000
Revision:
376:cb4d9db17537
Synchronized with git revision 07b49da75eac883fc8916d3d6b6962664b8db29e



Full URL: https://github.com/mbedmicro/mbed/commit/07b49da75eac883fc8916d3d6b6962664b8db29e/



Targets: DISCO_L053C8 - new platform - STM32L0 Discovery board

Who changed what in which revision?

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