mbed official / mbed-src

mbed library sources

Dependents:   Encrypted my_mbed lklk CyaSSL_DTLS_Cellular ... more

Superseded

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

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

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

Import librarymbed

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

Last commit 20 Feb 2019 by mbed official

targets/hal/TARGET_STM/TARGET_STM32F7/i2c_api.c@582:a89625bcd809, 2015-07-06 (annotated)

Committer:
mbed_official
Date:
Mon Jul 06 09:00:34 2015 +0100
Revision:
582:a89625bcd809
Parent:
573:ad23fe03a082 
Synchronized with git revision 45004fb61e4af8f74f4e916318df5207fcf6076d



Full URL: https://github.com/mbedmicro/mbed/commit/45004fb61e4af8f74f4e916318df5207fcf6076d/



DISCO_F746NG - Fix several issues

Who changed what in which revision?

UserRevisionLine numberNew contents of line
mbed_official 573:ad23fe03a082 1 /* mbed Microcontroller Library
mbed_official 573:ad23fe03a082 2 *******************************************************************************
mbed_official 573:ad23fe03a082 3 * Copyright (c) 2015, STMicroelectronics
mbed_official 573:ad23fe03a082 4 * All rights reserved.
mbed_official 573:ad23fe03a082 5 *
mbed_official 573:ad23fe03a082 6 * Redistribution and use in source and binary forms, with or without
mbed_official 573:ad23fe03a082 7 * modification, are permitted provided that the following conditions are met:
mbed_official 573:ad23fe03a082 8 *
mbed_official 573:ad23fe03a082 9 * 1. Redistributions of source code must retain the above copyright notice,
mbed_official 573:ad23fe03a082 10 * this list of conditions and the following disclaimer.
mbed_official 573:ad23fe03a082 11 * 2. Redistributions in binary form must reproduce the above copyright notice,
mbed_official 573:ad23fe03a082 12 * this list of conditions and the following disclaimer in the documentation
mbed_official 573:ad23fe03a082 13 * and/or other materials provided with the distribution.
mbed_official 573:ad23fe03a082 14 * 3. Neither the name of STMicroelectronics nor the names of its contributors
mbed_official 573:ad23fe03a082 15 * may be used to endorse or promote products derived from this software
mbed_official 573:ad23fe03a082 16 * without specific prior written permission.
mbed_official 573:ad23fe03a082 17 *
mbed_official 573:ad23fe03a082 18 * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS"
mbed_official 573:ad23fe03a082 19 * AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
mbed_official 573:ad23fe03a082 20 * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE
mbed_official 573:ad23fe03a082 21 * DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR CONTRIBUTORS BE LIABLE
mbed_official 573:ad23fe03a082 22 * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
mbed_official 573:ad23fe03a082 23 * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR
mbed_official 573:ad23fe03a082 24 * SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER
mbed_official 573:ad23fe03a082 25 * CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY,
mbed_official 573:ad23fe03a082 26 * OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
mbed_official 573:ad23fe03a082 27 * OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
mbed_official 573:ad23fe03a082 28 *******************************************************************************
mbed_official 573:ad23fe03a082 29 */
mbed_official 573:ad23fe03a082 30 #include "mbed_assert.h"
mbed_official 573:ad23fe03a082 31 #include "i2c_api.h"
mbed_official 573:ad23fe03a082 32
mbed_official 573:ad23fe03a082 33 #if DEVICE_I2C
mbed_official 573:ad23fe03a082 34
mbed_official 573:ad23fe03a082 35 #include "cmsis.h"
mbed_official 573:ad23fe03a082 36 #include "pinmap.h"
mbed_official 573:ad23fe03a082 37 #include "PeripheralPins.h"
mbed_official 582:a89625bcd809 38 #include "mbed_error.h"
mbed_official 573:ad23fe03a082 39
mbed_official 573:ad23fe03a082 40 /* Timeout values for flags and events waiting loops. These timeouts are
mbed_official 573:ad23fe03a082 41 not based on accurate values, they just guarantee that the application will
mbed_official 573:ad23fe03a082 42 not remain stuck if the I2C communication is corrupted. */
mbed_official 582:a89625bcd809 43 #define FLAG_TIMEOUT ((int)0x4000)
mbed_official 573:ad23fe03a082 44 #define LONG_TIMEOUT ((int)0x8000)
mbed_official 573:ad23fe03a082 45
mbed_official 573:ad23fe03a082 46 I2C_HandleTypeDef I2cHandle;
mbed_official 573:ad23fe03a082 47
mbed_official 573:ad23fe03a082 48 int i2c1_inited = 0;
mbed_official 582:a89625bcd809 49 /* Ready for next F7 devices
mbed_official 573:ad23fe03a082 50 int i2c2_inited = 0;
mbed_official 573:ad23fe03a082 51 int i2c3_inited = 0;
mbed_official 582:a89625bcd809 52 int i2c4_inited = 0;
mbed_official 582:a89625bcd809 53 */
mbed_official 573:ad23fe03a082 54
mbed_official 573:ad23fe03a082 55 void i2c_init(i2c_t *obj, PinName sda, PinName scl)
mbed_official 573:ad23fe03a082 56 {
mbed_official 573:ad23fe03a082 57 // Determine the I2C to use
mbed_official 573:ad23fe03a082 58 I2CName i2c_sda = (I2CName)pinmap_peripheral(sda, PinMap_I2C_SDA);
mbed_official 573:ad23fe03a082 59 I2CName i2c_scl = (I2CName)pinmap_peripheral(scl, PinMap_I2C_SCL);
mbed_official 573:ad23fe03a082 60
mbed_official 573:ad23fe03a082 61 obj->i2c = (I2CName)pinmap_merge(i2c_sda, i2c_scl);
mbed_official 573:ad23fe03a082 62 MBED_ASSERT(obj->i2c != (I2CName)NC);
mbed_official 573:ad23fe03a082 63
mbed_official 582:a89625bcd809 64 // Enable I2C clock and pinout if not done
mbed_official 573:ad23fe03a082 65 if ((obj->i2c == I2C_1) && !i2c1_inited) {
mbed_official 573:ad23fe03a082 66 i2c1_inited = 1;
mbed_official 582:a89625bcd809 67 __HAL_RCC_I2C1_CONFIG(RCC_I2C1CLKSOURCE_PCLK1);
mbed_official 582:a89625bcd809 68 __HAL_RCC_I2C1_CLK_ENABLE();
mbed_official 582:a89625bcd809 69 // Configure I2C1 pins
mbed_official 573:ad23fe03a082 70 pinmap_pinout(sda, PinMap_I2C_SDA);
mbed_official 573:ad23fe03a082 71 pinmap_pinout(scl, PinMap_I2C_SCL);
mbed_official 573:ad23fe03a082 72 pin_mode(sda, OpenDrain);
mbed_official 573:ad23fe03a082 73 pin_mode(scl, OpenDrain);
mbed_official 573:ad23fe03a082 74 }
mbed_official 573:ad23fe03a082 75
mbed_official 582:a89625bcd809 76 /* Ready for next F7 devices
mbed_official 582:a89625bcd809 77 #if defined(I2C2_BASE)
mbed_official 582:a89625bcd809 78 if ((obj->i2c == I2C_2) && !i2c2_inited) {
mbed_official 582:a89625bcd809 79 i2c2_inited = 1;
mbed_official 582:a89625bcd809 80 __HAL_RCC_I2C2_CONFIG(RCC_I2C2CLKSOURCE_PCLK1);
mbed_official 582:a89625bcd809 81 __HAL_RCC_I2C2_CLK_ENABLE();
mbed_official 582:a89625bcd809 82 // Configure I2C2 pins
mbed_official 582:a89625bcd809 83 pinmap_pinout(sda, PinMap_I2C_SDA);
mbed_official 582:a89625bcd809 84 pinmap_pinout(scl, PinMap_I2C_SCL);
mbed_official 582:a89625bcd809 85 pin_mode(sda, OpenDrain);
mbed_official 582:a89625bcd809 86 pin_mode(scl, OpenDrain);
mbed_official 582:a89625bcd809 87 }
mbed_official 582:a89625bcd809 88 #endif
mbed_official 582:a89625bcd809 89
mbed_official 582:a89625bcd809 90 #if defined(I2C3_BASE)
mbed_official 582:a89625bcd809 91 if ((obj->i2c == I2C_3) && !i2c3_inited) {
mbed_official 582:a89625bcd809 92 i2c3_inited = 1;
mbed_official 582:a89625bcd809 93 __HAL_RCC_I2C3_CONFIG(RCC_I2C3CLKSOURCE_PCLK1);
mbed_official 582:a89625bcd809 94 __HAL_RCC_I2C3_CLK_ENABLE();
mbed_official 582:a89625bcd809 95 // Configure I2C3 pins
mbed_official 582:a89625bcd809 96 pinmap_pinout(sda, PinMap_I2C_SDA);
mbed_official 582:a89625bcd809 97 pinmap_pinout(scl, PinMap_I2C_SCL);
mbed_official 582:a89625bcd809 98 pin_mode(sda, OpenDrain);
mbed_official 582:a89625bcd809 99 pin_mode(scl, OpenDrain);
mbed_official 582:a89625bcd809 100 }
mbed_official 582:a89625bcd809 101 #endif
mbed_official 582:a89625bcd809 102
mbed_official 582:a89625bcd809 103 #if defined(I2C4_BASE)
mbed_official 582:a89625bcd809 104 if ((obj->i2c == I2C_4) && !i2c4_inited) {
mbed_official 582:a89625bcd809 105 i2c4_inited = 1;
mbed_official 582:a89625bcd809 106 __HAL_RCC_I2C4_CONFIG(RCC_I2C4CLKSOURCE_PCLK1);
mbed_official 582:a89625bcd809 107 __HAL_RCC_I2C4_CLK_ENABLE();
mbed_official 582:a89625bcd809 108 // Configure I2C4 pins
mbed_official 582:a89625bcd809 109 pinmap_pinout(sda, PinMap_I2C_SDA);
mbed_official 582:a89625bcd809 110 pinmap_pinout(scl, PinMap_I2C_SCL);
mbed_official 582:a89625bcd809 111 pin_mode(sda, OpenDrain);
mbed_official 582:a89625bcd809 112 pin_mode(scl, OpenDrain);
mbed_official 582:a89625bcd809 113 }
mbed_official 582:a89625bcd809 114 #endif
mbed_official 582:a89625bcd809 115 */
mbed_official 582:a89625bcd809 116
mbed_official 573:ad23fe03a082 117 // Reset to clear pending flags if any
mbed_official 573:ad23fe03a082 118 i2c_reset(obj);
mbed_official 573:ad23fe03a082 119
mbed_official 573:ad23fe03a082 120 // I2C configuration
mbed_official 573:ad23fe03a082 121 i2c_frequency(obj, 100000); // 100 kHz per default
mbed_official 573:ad23fe03a082 122 }
mbed_official 573:ad23fe03a082 123
mbed_official 573:ad23fe03a082 124 void i2c_frequency(i2c_t *obj, int hz)
mbed_official 573:ad23fe03a082 125 {
mbed_official 582:a89625bcd809 126 uint32_t tim = 0;
mbed_official 582:a89625bcd809 127
mbed_official 582:a89625bcd809 128 MBED_ASSERT((hz == 100000) || (hz == 400000) || (hz == 1000000));
mbed_official 582:a89625bcd809 129
mbed_official 573:ad23fe03a082 130 I2cHandle.Instance = (I2C_TypeDef *)(obj->i2c);
mbed_official 573:ad23fe03a082 131 int timeout;
mbed_official 573:ad23fe03a082 132
mbed_official 573:ad23fe03a082 133 // wait before init
mbed_official 573:ad23fe03a082 134 timeout = LONG_TIMEOUT;
mbed_official 582:a89625bcd809 135 while ((__HAL_I2C_GET_FLAG(&I2cHandle, I2C_FLAG_BUSY)) && (timeout-- != 0)) {}
mbed_official 582:a89625bcd809 136
mbed_official 582:a89625bcd809 137 /*
mbed_official 582:a89625bcd809 138 Values calculated with I2C_Timing_Configuration tool (excel file)
mbed_official 582:a89625bcd809 139 * Standard mode (up to 100 kHz)
mbed_official 582:a89625bcd809 140 * Fast Mode (up to 400 kHz)
mbed_official 582:a89625bcd809 141 * Fast Mode Plus (up to 1 MHz)
mbed_official 582:a89625bcd809 142 Below values obtained with:
mbed_official 582:a89625bcd809 143 - I2Cx clock source = APB1CLK = 54 MHz
mbed_official 582:a89625bcd809 144 - Analog filter delay = ON
mbed_official 582:a89625bcd809 145 - Digital filter coefficient = 0
mbed_official 582:a89625bcd809 146 */
mbed_official 582:a89625bcd809 147 switch (hz) {
mbed_official 582:a89625bcd809 148 case 100000:
mbed_official 582:a89625bcd809 149 tim = 0x10916998; // Standard mode with Rise time = 120ns, Fall time = 120ns
mbed_official 582:a89625bcd809 150 break;
mbed_official 582:a89625bcd809 151 case 400000:
mbed_official 582:a89625bcd809 152 tim = 0x00B11B54; // Fast Mode with Rise time = 120ns, Fall time = 120ns
mbed_official 582:a89625bcd809 153 break;
mbed_official 582:a89625bcd809 154 case 1000000:
mbed_official 582:a89625bcd809 155 tim = 0x0090091B; // Fast Mode Plus with Rise time = 120ns, Fall time = 10ns
mbed_official 582:a89625bcd809 156 break;
mbed_official 582:a89625bcd809 157 default:
mbed_official 582:a89625bcd809 158 break;
mbed_official 582:a89625bcd809 159 }
mbed_official 573:ad23fe03a082 160
mbed_official 573:ad23fe03a082 161 // I2C configuration
mbed_official 582:a89625bcd809 162 I2cHandle.Init.Timing = tim;
mbed_official 582:a89625bcd809 163 I2cHandle.Init.AddressingMode = I2C_ADDRESSINGMODE_7BIT;
mbed_official 582:a89625bcd809 164 I2cHandle.Init.DualAddressMode = I2C_DUALADDRESS_DISABLE;
mbed_official 582:a89625bcd809 165 I2cHandle.Init.GeneralCallMode = I2C_GENERALCALL_DISABLE;
mbed_official 582:a89625bcd809 166 I2cHandle.Init.NoStretchMode = I2C_NOSTRETCH_DISABLE;
mbed_official 582:a89625bcd809 167 I2cHandle.Init.OwnAddress1 = 0;
mbed_official 582:a89625bcd809 168 I2cHandle.Init.OwnAddress2 = 0;
mbed_official 582:a89625bcd809 169 I2cHandle.Init.OwnAddress2Masks = I2C_OA2_NOMASK;
mbed_official 582:a89625bcd809 170
mbed_official 582:a89625bcd809 171 if (HAL_I2C_Init(&I2cHandle) != HAL_OK) {
mbed_official 582:a89625bcd809 172 error("Cannot initialize I2C");
mbed_official 573:ad23fe03a082 173 }
mbed_official 573:ad23fe03a082 174 }
mbed_official 573:ad23fe03a082 175
mbed_official 573:ad23fe03a082 176 inline int i2c_start(i2c_t *obj)
mbed_official 573:ad23fe03a082 177 {
mbed_official 573:ad23fe03a082 178 I2C_TypeDef *i2c = (I2C_TypeDef *)(obj->i2c);
mbed_official 573:ad23fe03a082 179 int timeout;
mbed_official 573:ad23fe03a082 180
mbed_official 573:ad23fe03a082 181 I2cHandle.Instance = (I2C_TypeDef *)(obj->i2c);
mbed_official 573:ad23fe03a082 182
mbed_official 573:ad23fe03a082 183 // Clear Acknowledge failure flag
mbed_official 573:ad23fe03a082 184 __HAL_I2C_CLEAR_FLAG(&I2cHandle, I2C_FLAG_AF);
mbed_official 573:ad23fe03a082 185
mbed_official 573:ad23fe03a082 186 // Generate the START condition
mbed_official 582:a89625bcd809 187 i2c->CR2 |= I2C_CR2_START;
mbed_official 573:ad23fe03a082 188
mbed_official 573:ad23fe03a082 189 // Wait the START condition has been correctly sent
mbed_official 573:ad23fe03a082 190 timeout = FLAG_TIMEOUT;
mbed_official 582:a89625bcd809 191 while (__HAL_I2C_GET_FLAG(&I2cHandle, I2C_FLAG_BUSY) == RESET) {
mbed_official 573:ad23fe03a082 192 if ((timeout--) == 0) {
mbed_official 573:ad23fe03a082 193 return 1;
mbed_official 573:ad23fe03a082 194 }
mbed_official 573:ad23fe03a082 195 }
mbed_official 573:ad23fe03a082 196
mbed_official 573:ad23fe03a082 197 return 0;
mbed_official 573:ad23fe03a082 198 }
mbed_official 573:ad23fe03a082 199
mbed_official 573:ad23fe03a082 200 inline int i2c_stop(i2c_t *obj)
mbed_official 573:ad23fe03a082 201 {
mbed_official 573:ad23fe03a082 202 I2C_TypeDef *i2c = (I2C_TypeDef *)(obj->i2c);
mbed_official 573:ad23fe03a082 203
mbed_official 573:ad23fe03a082 204 // Generate the STOP condition
mbed_official 582:a89625bcd809 205 i2c->CR2 |= I2C_CR2_STOP;
mbed_official 573:ad23fe03a082 206
mbed_official 573:ad23fe03a082 207 return 0;
mbed_official 573:ad23fe03a082 208 }
mbed_official 573:ad23fe03a082 209
mbed_official 573:ad23fe03a082 210 int i2c_read(i2c_t *obj, int address, char *data, int length, int stop)
mbed_official 573:ad23fe03a082 211 {
mbed_official 573:ad23fe03a082 212 I2C_TypeDef *i2c = (I2C_TypeDef *)(obj->i2c);
mbed_official 573:ad23fe03a082 213 I2cHandle.Instance = (I2C_TypeDef *)(obj->i2c);
mbed_official 573:ad23fe03a082 214 int timeout;
mbed_official 573:ad23fe03a082 215 int count;
mbed_official 573:ad23fe03a082 216 int value;
mbed_official 573:ad23fe03a082 217
mbed_official 582:a89625bcd809 218 /* update CR2 register */
mbed_official 582:a89625bcd809 219 i2c->CR2 = (i2c->CR2 & (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 582:a89625bcd809 220 | (uint32_t)(((uint32_t)address & I2C_CR2_SADD) | (((uint32_t)length << 16) & I2C_CR2_NBYTES) | (uint32_t)I2C_SOFTEND_MODE | (uint32_t)I2C_GENERATE_START_READ);
mbed_official 573:ad23fe03a082 221
mbed_official 582:a89625bcd809 222 // Read all bytes
mbed_official 582:a89625bcd809 223 for (count = 0; count < length; count++) {
mbed_official 582:a89625bcd809 224 value = i2c_byte_read(obj, 0);
mbed_official 582:a89625bcd809 225 data[count] = (char)value;
mbed_official 582:a89625bcd809 226 }
mbed_official 582:a89625bcd809 227
mbed_official 582:a89625bcd809 228 // Wait transfer complete
mbed_official 582:a89625bcd809 229 timeout = LONG_TIMEOUT;
mbed_official 582:a89625bcd809 230 while (__HAL_I2C_GET_FLAG(&I2cHandle, I2C_FLAG_TC) == RESET) {
mbed_official 573:ad23fe03a082 231 timeout--;
mbed_official 573:ad23fe03a082 232 if (timeout == 0) {
mbed_official 573:ad23fe03a082 233 return -1;
mbed_official 573:ad23fe03a082 234 }
mbed_official 573:ad23fe03a082 235 }
mbed_official 573:ad23fe03a082 236
mbed_official 582:a89625bcd809 237 __HAL_I2C_CLEAR_FLAG(&I2cHandle, I2C_FLAG_TC);
mbed_official 573:ad23fe03a082 238
mbed_official 573:ad23fe03a082 239 // If not repeated start, send stop.
mbed_official 573:ad23fe03a082 240 if (stop) {
mbed_official 573:ad23fe03a082 241 i2c_stop(obj);
mbed_official 582:a89625bcd809 242 /* Wait until STOPF flag is set */
mbed_official 582:a89625bcd809 243 timeout = FLAG_TIMEOUT;
mbed_official 582:a89625bcd809 244 while (__HAL_I2C_GET_FLAG(&I2cHandle, I2C_FLAG_STOPF) == RESET) {
mbed_official 582:a89625bcd809 245 timeout--;
mbed_official 582:a89625bcd809 246 if (timeout == 0) {
mbed_official 582:a89625bcd809 247 return -1;
mbed_official 582:a89625bcd809 248 }
mbed_official 582:a89625bcd809 249 }
mbed_official 582:a89625bcd809 250 /* Clear STOP Flag */
mbed_official 582:a89625bcd809 251 __HAL_I2C_CLEAR_FLAG(&I2cHandle, I2C_FLAG_STOPF);
mbed_official 573:ad23fe03a082 252 }
mbed_official 573:ad23fe03a082 253
mbed_official 573:ad23fe03a082 254 return length;
mbed_official 573:ad23fe03a082 255 }
mbed_official 573:ad23fe03a082 256
mbed_official 573:ad23fe03a082 257 int i2c_write(i2c_t *obj, int address, const char *data, int length, int stop)
mbed_official 573:ad23fe03a082 258 {
mbed_official 573:ad23fe03a082 259 I2C_TypeDef *i2c = (I2C_TypeDef *)(obj->i2c);
mbed_official 573:ad23fe03a082 260 I2cHandle.Instance = (I2C_TypeDef *)(obj->i2c);
mbed_official 573:ad23fe03a082 261 int timeout;
mbed_official 573:ad23fe03a082 262 int count;
mbed_official 573:ad23fe03a082 263
mbed_official 582:a89625bcd809 264 /* update CR2 register */
mbed_official 582:a89625bcd809 265 i2c->CR2 = (i2c->CR2 & (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 582:a89625bcd809 266 | (uint32_t)(((uint32_t)address & I2C_CR2_SADD) | (((uint32_t)length << 16) & I2C_CR2_NBYTES) | (uint32_t)I2C_SOFTEND_MODE | (uint32_t)I2C_GENERATE_START_WRITE);
mbed_official 573:ad23fe03a082 267
mbed_official 582:a89625bcd809 268 for (count = 0; count < length; count++) {
mbed_official 582:a89625bcd809 269 i2c_byte_write(obj, data[count]);
mbed_official 582:a89625bcd809 270 }
mbed_official 582:a89625bcd809 271
mbed_official 582:a89625bcd809 272 // Wait transfer complete
mbed_official 573:ad23fe03a082 273 timeout = FLAG_TIMEOUT;
mbed_official 582:a89625bcd809 274 while (__HAL_I2C_GET_FLAG(&I2cHandle, I2C_FLAG_TC) == RESET) {
mbed_official 573:ad23fe03a082 275 timeout--;
mbed_official 573:ad23fe03a082 276 if (timeout == 0) {
mbed_official 573:ad23fe03a082 277 return -1;
mbed_official 573:ad23fe03a082 278 }
mbed_official 573:ad23fe03a082 279 }
mbed_official 573:ad23fe03a082 280
mbed_official 582:a89625bcd809 281 __HAL_I2C_CLEAR_FLAG(&I2cHandle, I2C_FLAG_TC);
mbed_official 573:ad23fe03a082 282
mbed_official 573:ad23fe03a082 283 // If not repeated start, send stop.
mbed_official 573:ad23fe03a082 284 if (stop) {
mbed_official 573:ad23fe03a082 285 i2c_stop(obj);
mbed_official 582:a89625bcd809 286 /* Wait until STOPF flag is set */
mbed_official 582:a89625bcd809 287 timeout = FLAG_TIMEOUT;
mbed_official 582:a89625bcd809 288 while (__HAL_I2C_GET_FLAG(&I2cHandle, I2C_FLAG_STOPF) == RESET) {
mbed_official 582:a89625bcd809 289 timeout--;
mbed_official 582:a89625bcd809 290 if (timeout == 0) {
mbed_official 582:a89625bcd809 291 return -1;
mbed_official 582:a89625bcd809 292 }
mbed_official 582:a89625bcd809 293 }
mbed_official 582:a89625bcd809 294 /* Clear STOP Flag */
mbed_official 582:a89625bcd809 295 __HAL_I2C_CLEAR_FLAG(&I2cHandle, I2C_FLAG_STOPF);
mbed_official 573:ad23fe03a082 296 }
mbed_official 573:ad23fe03a082 297
mbed_official 573:ad23fe03a082 298 return count;
mbed_official 573:ad23fe03a082 299 }
mbed_official 573:ad23fe03a082 300
mbed_official 573:ad23fe03a082 301 int i2c_byte_read(i2c_t *obj, int last)
mbed_official 573:ad23fe03a082 302 {
mbed_official 573:ad23fe03a082 303 I2C_TypeDef *i2c = (I2C_TypeDef *)(obj->i2c);
mbed_official 573:ad23fe03a082 304 int timeout;
mbed_official 573:ad23fe03a082 305
mbed_official 573:ad23fe03a082 306 // Wait until the byte is received
mbed_official 573:ad23fe03a082 307 timeout = FLAG_TIMEOUT;
mbed_official 573:ad23fe03a082 308 while (__HAL_I2C_GET_FLAG(&I2cHandle, I2C_FLAG_RXNE) == RESET) {
mbed_official 573:ad23fe03a082 309 if ((timeout--) == 0) {
mbed_official 573:ad23fe03a082 310 return -1;
mbed_official 573:ad23fe03a082 311 }
mbed_official 573:ad23fe03a082 312 }
mbed_official 573:ad23fe03a082 313
mbed_official 582:a89625bcd809 314 return (int)i2c->RXDR;
mbed_official 573:ad23fe03a082 315 }
mbed_official 573:ad23fe03a082 316
mbed_official 573:ad23fe03a082 317 int i2c_byte_write(i2c_t *obj, int data)
mbed_official 573:ad23fe03a082 318 {
mbed_official 573:ad23fe03a082 319 I2C_TypeDef *i2c = (I2C_TypeDef *)(obj->i2c);
mbed_official 573:ad23fe03a082 320 int timeout;
mbed_official 573:ad23fe03a082 321
mbed_official 582:a89625bcd809 322 // Wait until the previous byte is transmitted
mbed_official 573:ad23fe03a082 323 timeout = FLAG_TIMEOUT;
mbed_official 582:a89625bcd809 324 while (__HAL_I2C_GET_FLAG(&I2cHandle, I2C_FLAG_TXIS) == RESET) {
mbed_official 573:ad23fe03a082 325 if ((timeout--) == 0) {
mbed_official 573:ad23fe03a082 326 return 0;
mbed_official 573:ad23fe03a082 327 }
mbed_official 573:ad23fe03a082 328 }
mbed_official 573:ad23fe03a082 329
mbed_official 582:a89625bcd809 330 i2c->TXDR = (uint8_t)data;
mbed_official 582:a89625bcd809 331
mbed_official 573:ad23fe03a082 332 return 1;
mbed_official 573:ad23fe03a082 333 }
mbed_official 573:ad23fe03a082 334
mbed_official 573:ad23fe03a082 335 void i2c_reset(i2c_t *obj)
mbed_official 573:ad23fe03a082 336 {
mbed_official 573:ad23fe03a082 337 int timeout;
mbed_official 573:ad23fe03a082 338
mbed_official 573:ad23fe03a082 339 // wait before reset
mbed_official 573:ad23fe03a082 340 timeout = LONG_TIMEOUT;
mbed_official 573:ad23fe03a082 341 while ((__HAL_I2C_GET_FLAG(&I2cHandle, I2C_FLAG_BUSY)) && (timeout-- != 0));
mbed_official 573:ad23fe03a082 342
mbed_official 582:a89625bcd809 343 __I2C1_FORCE_RESET();
mbed_official 582:a89625bcd809 344 __I2C1_RELEASE_RESET();
mbed_official 573:ad23fe03a082 345 }
mbed_official 573:ad23fe03a082 346
mbed_official 573:ad23fe03a082 347 #if DEVICE_I2CSLAVE
mbed_official 573:ad23fe03a082 348
mbed_official 573:ad23fe03a082 349 void i2c_slave_address(i2c_t *obj, int idx, uint32_t address, uint32_t mask)
mbed_official 573:ad23fe03a082 350 {
mbed_official 573:ad23fe03a082 351 I2C_TypeDef *i2c = (I2C_TypeDef *)(obj->i2c);
mbed_official 582:a89625bcd809 352 uint16_t tmpreg;
mbed_official 573:ad23fe03a082 353
mbed_official 582:a89625bcd809 354 // disable
mbed_official 582:a89625bcd809 355 i2c->OAR1 &= (uint32_t)(~I2C_OAR1_OA1EN);
mbed_official 573:ad23fe03a082 356 // Get the old register value
mbed_official 573:ad23fe03a082 357 tmpreg = i2c->OAR1;
mbed_official 573:ad23fe03a082 358 // Reset address bits
mbed_official 573:ad23fe03a082 359 tmpreg &= 0xFC00;
mbed_official 573:ad23fe03a082 360 // Set new address
mbed_official 573:ad23fe03a082 361 tmpreg |= (uint16_t)((uint16_t)address & (uint16_t)0x00FE); // 7-bits
mbed_official 573:ad23fe03a082 362 // Store the new register value
mbed_official 573:ad23fe03a082 363 i2c->OAR1 = tmpreg;
mbed_official 582:a89625bcd809 364 // enable
mbed_official 582:a89625bcd809 365 i2c->OAR1 |= I2C_OAR1_OA1EN;
mbed_official 573:ad23fe03a082 366 }
mbed_official 573:ad23fe03a082 367
mbed_official 573:ad23fe03a082 368 void i2c_slave_mode(i2c_t *obj, int enable_slave)
mbed_official 573:ad23fe03a082 369 {
mbed_official 582:a89625bcd809 370
mbed_official 582:a89625bcd809 371 I2C_TypeDef *i2c = (I2C_TypeDef *)(obj->i2c);
mbed_official 582:a89625bcd809 372 uint16_t tmpreg;
mbed_official 582:a89625bcd809 373
mbed_official 582:a89625bcd809 374 // Get the old register value
mbed_official 582:a89625bcd809 375 tmpreg = i2c->OAR1;
mbed_official 582:a89625bcd809 376
mbed_official 582:a89625bcd809 377 // Enable / disable slave
mbed_official 582:a89625bcd809 378 if (enable_slave == 1) {
mbed_official 582:a89625bcd809 379 tmpreg |= I2C_OAR1_OA1EN;
mbed_official 582:a89625bcd809 380 } else {
mbed_official 582:a89625bcd809 381 tmpreg &= (uint32_t)(~I2C_OAR1_OA1EN);
mbed_official 573:ad23fe03a082 382 }
mbed_official 582:a89625bcd809 383
mbed_official 582:a89625bcd809 384 // Set new mode
mbed_official 582:a89625bcd809 385 i2c->OAR1 = tmpreg;
mbed_official 582:a89625bcd809 386
mbed_official 573:ad23fe03a082 387 }
mbed_official 573:ad23fe03a082 388
mbed_official 573:ad23fe03a082 389 // See I2CSlave.h
mbed_official 573:ad23fe03a082 390 #define NoData 0 // the slave has not been addressed
mbed_official 573:ad23fe03a082 391 #define ReadAddressed 1 // the master has requested a read from this slave (slave = transmitter)
mbed_official 573:ad23fe03a082 392 #define WriteGeneral 2 // the master is writing to all slave
mbed_official 573:ad23fe03a082 393 #define WriteAddressed 3 // the master is writing to this slave (slave = receiver)
mbed_official 573:ad23fe03a082 394
mbed_official 573:ad23fe03a082 395 int i2c_slave_receive(i2c_t *obj)
mbed_official 573:ad23fe03a082 396 {
mbed_official 582:a89625bcd809 397 I2cHandle.Instance = (I2C_TypeDef *)(obj->i2c);
mbed_official 573:ad23fe03a082 398 int retValue = NoData;
mbed_official 573:ad23fe03a082 399
mbed_official 573:ad23fe03a082 400 if (__HAL_I2C_GET_FLAG(&I2cHandle, I2C_FLAG_BUSY) == 1) {
mbed_official 573:ad23fe03a082 401 if (__HAL_I2C_GET_FLAG(&I2cHandle, I2C_FLAG_ADDR) == 1) {
mbed_official 582:a89625bcd809 402 if (__HAL_I2C_GET_FLAG(&I2cHandle, I2C_FLAG_DIR) == 1)
mbed_official 573:ad23fe03a082 403 retValue = ReadAddressed;
mbed_official 573:ad23fe03a082 404 else
mbed_official 573:ad23fe03a082 405 retValue = WriteAddressed;
mbed_official 573:ad23fe03a082 406 __HAL_I2C_CLEAR_FLAG(&I2cHandle, I2C_FLAG_ADDR);
mbed_official 573:ad23fe03a082 407 }
mbed_official 573:ad23fe03a082 408 }
mbed_official 573:ad23fe03a082 409
mbed_official 573:ad23fe03a082 410 return (retValue);
mbed_official 573:ad23fe03a082 411 }
mbed_official 573:ad23fe03a082 412
mbed_official 573:ad23fe03a082 413 int i2c_slave_read(i2c_t *obj, char *data, int length)
mbed_official 573:ad23fe03a082 414 {
mbed_official 582:a89625bcd809 415 char size = 0;
mbed_official 573:ad23fe03a082 416
mbed_official 582:a89625bcd809 417 while (size < length) data[size++] = (char)i2c_byte_read(obj, 0);
mbed_official 573:ad23fe03a082 418
mbed_official 573:ad23fe03a082 419 return size;
mbed_official 573:ad23fe03a082 420 }
mbed_official 573:ad23fe03a082 421
mbed_official 573:ad23fe03a082 422 int i2c_slave_write(i2c_t *obj, const char *data, int length)
mbed_official 573:ad23fe03a082 423 {
mbed_official 582:a89625bcd809 424 char size = 0;
mbed_official 573:ad23fe03a082 425 I2cHandle.Instance = (I2C_TypeDef *)(obj->i2c);
mbed_official 573:ad23fe03a082 426
mbed_official 582:a89625bcd809 427 do {
mbed_official 582:a89625bcd809 428 i2c_byte_write(obj, data[size]);
mbed_official 573:ad23fe03a082 429 size++;
mbed_official 582:a89625bcd809 430 } while (size < length);
mbed_official 573:ad23fe03a082 431
mbed_official 573:ad23fe03a082 432 return size;
mbed_official 573:ad23fe03a082 433 }
mbed_official 573:ad23fe03a082 434
mbed_official 573:ad23fe03a082 435
mbed_official 573:ad23fe03a082 436 #endif // DEVICE_I2CSLAVE
mbed_official 573:ad23fe03a082 437
mbed_official 573:ad23fe03a082 438 #endif // DEVICE_I2C