mbed official / mbed-src

mbed library sources

Dependents:   Encrypted my_mbed lklk CyaSSL_DTLS_Cellular ... more

Superseded

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

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

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

Import librarymbed

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

Last commit 20 Feb 2019 by mbed official

targets/cmsis/TARGET_STM/TARGET_STM32L0/stm32l0xx_hal_i2c.c@579:53297373a894, 2015-07-01 (annotated)

Committer:
mbed_official
Date:
Wed Jul 01 09:45:11 2015 +0100
Revision:
579:53297373a894
Parent:
489:119543c9f674 
Synchronized with git revision d5b4d2ab9c47edb4dc5776e7177b0c2263459081



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



Initial version of drivers for SAMR21

Who changed what in which revision?

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