shao ziyang / mbed-src-kl05

mbed library sources

Dependents:   frdm_kl05z_gpio_test

Fork of mbed-src by mbed official

targets/cmsis/TARGET_STM/TARGET_NUCLEO_L053R8/stm32l0xx_hal_i2c.c@323:9e901b0a5aa1, 2014-09-13 (annotated)

Committer:
shaoziyang
Date:
Sat Sep 13 14:25:46 2014 +0000
Revision:
323:9e901b0a5aa1
Parent:
181:a4cbdfbbd2f4 
test with CLOCK_SETUP = 0

Who changed what in which revision?

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