Joris Aerts / mbed-src

mbed library sources

Dependents:   Marvino mbot

Fork of mbed-src by mbed official

targets/cmsis/TARGET_STM/TARGET_STM32L4/stm32l4xx_hal_i2c.c@637:ed69428d4850, 2015-12-22 (annotated)

Committer:
jaerts
Date:
Tue Dec 22 13:22:16 2015 +0000
Revision:
637:ed69428d4850
Parent:
610:813dcc80987e 
Add very shady LPC1768 CAN Filter implementation

Who changed what in which revision?

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