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_STM32F3/stm32f3xx_hal_i2c.c@634:ac7d6880524d, 2015-09-28 (annotated)

Committer:
mbed_official
Date:
Mon Sep 28 20:15:09 2015 +0100
Revision:
634:ac7d6880524d
Parent:
632:7687fb9c4f91 
Synchronized with git revision 9b7d23d47153c298a6d24de9a415202705889d11



Full URL: https://github.com/mbedmicro/mbed/commit/9b7d23d47153c298a6d24de9a415202705889d11/



Revert "[NUCLEO_F303K8] add support of the STM32F303K8"

Who changed what in which revision?

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