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_STM32F7/stm32f7xx_hal_i2c.c@579:53297373a894, 2015-07-01 (annotated)

Committer:
mbed_official
Date:
Wed Jul 01 09:45:11 2015 +0100
Revision:
579:53297373a894
Parent:
573:ad23fe03a082
Child:
610:813dcc80987e
Synchronized with git revision d5b4d2ab9c47edb4dc5776e7177b0c2263459081



Full URL: https://github.com/mbedmicro/mbed/commit/d5b4d2ab9c47edb4dc5776e7177b0c2263459081/



Initial version of drivers for SAMR21

Who changed what in which revision?

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