Paul Paterson / mbed-src-CanNucleoF0

mbed library sources, include can_api for nucleo-f091rc

Dependents:   CanNucleoF0_example

Fork of mbed-src by mbed official

targets/cmsis/TARGET_STM/TARGET_STM32F7/stm32f7xx_hal_i2c.c@645:13c87cbecd54, 2016-01-07 (annotated)

Committer:
ptpaterson
Date:
Thu Jan 07 05:49:05 2016 +0000
Revision:
645:13c87cbecd54
Parent:
610:813dcc80987e 
corrected freeze on CAN_RECEIVE_IT

Who changed what in which revision?

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