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_NUCLEO_F401RE/i2c_api.c@305:1f0269907d8b, 2014-08-29 (annotated)

Committer:
mbed_official
Date:
Fri Aug 29 20:45:07 2014 +0100
Revision:
305:1f0269907d8b
Parent:
247:135e3186a638
Child:
402:09075a3b15e3
Synchronized with git revision f304c6ba83591678388024d30440e94781fa8d65



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



[NUCLEOs] enhance i2c api

Who changed what in which revision?

UserRevisionLine numberNew contents of line
mbed_official 87:085cde657901 1 /* mbed Microcontroller Library
mbed_official 87:085cde657901 2 *******************************************************************************
mbed_official 87:085cde657901 3 * Copyright (c) 2014, STMicroelectronics
mbed_official 87:085cde657901 4 * All rights reserved.
mbed_official 87:085cde657901 5 *
mbed_official 87:085cde657901 6 * Redistribution and use in source and binary forms, with or without
mbed_official 87:085cde657901 7 * modification, are permitted provided that the following conditions are met:
mbed_official 87:085cde657901 8 *
mbed_official 87:085cde657901 9 * 1. Redistributions of source code must retain the above copyright notice,
mbed_official 87:085cde657901 10 * this list of conditions and the following disclaimer.
mbed_official 87:085cde657901 11 * 2. Redistributions in binary form must reproduce the above copyright notice,
mbed_official 87:085cde657901 12 * this list of conditions and the following disclaimer in the documentation
mbed_official 87:085cde657901 13 * and/or other materials provided with the distribution.
mbed_official 87:085cde657901 14 * 3. Neither the name of STMicroelectronics nor the names of its contributors
mbed_official 87:085cde657901 15 * may be used to endorse or promote products derived from this software
mbed_official 87:085cde657901 16 * without specific prior written permission.
mbed_official 87:085cde657901 17 *
mbed_official 87:085cde657901 18 * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS"
mbed_official 87:085cde657901 19 * AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
mbed_official 87:085cde657901 20 * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE
mbed_official 87:085cde657901 21 * DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR CONTRIBUTORS BE LIABLE
mbed_official 87:085cde657901 22 * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
mbed_official 87:085cde657901 23 * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR
mbed_official 87:085cde657901 24 * SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER
mbed_official 87:085cde657901 25 * CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY,
mbed_official 87:085cde657901 26 * OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
mbed_official 87:085cde657901 27 * OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
mbed_official 87:085cde657901 28 *******************************************************************************
mbed_official 87:085cde657901 29 */
mbed_official 227:7bd0639b8911 30 #include "mbed_assert.h"
mbed_official 87:085cde657901 31 #include "i2c_api.h"
mbed_official 87:085cde657901 32
mbed_official 87:085cde657901 33 #if DEVICE_I2C
mbed_official 87:085cde657901 34
mbed_official 87:085cde657901 35 #include "cmsis.h"
mbed_official 87:085cde657901 36 #include "pinmap.h"
mbed_official 87:085cde657901 37
mbed_official 87:085cde657901 38 /* Timeout values for flags and events waiting loops. These timeouts are
mbed_official 172:2f4f8c56b261 39 not based on accurate values, they just guarantee that the application will
mbed_official 172:2f4f8c56b261 40 not remain stuck if the I2C communication is corrupted. */
mbed_official 87:085cde657901 41 #define FLAG_TIMEOUT ((int)0x1000)
mbed_official 87:085cde657901 42 #define LONG_TIMEOUT ((int)0x8000)
mbed_official 87:085cde657901 43
mbed_official 87:085cde657901 44 static const PinMap PinMap_I2C_SDA[] = {
mbed_official 115:4f0cb9cdc478 45 {PB_3, I2C_2, STM_PIN_DATA(STM_MODE_AF_OD, GPIO_NOPULL, GPIO_AF9_I2C2)},
mbed_official 115:4f0cb9cdc478 46 {PB_4, I2C_3, STM_PIN_DATA(STM_MODE_AF_OD, GPIO_NOPULL, GPIO_AF9_I2C3)},
mbed_official 125:23cc3068a9e4 47 {PB_7, I2C_1, STM_PIN_DATA(STM_MODE_AF_OD, GPIO_NOPULL, GPIO_AF4_I2C1)},
mbed_official 125:23cc3068a9e4 48 {PB_9, I2C_1, STM_PIN_DATA(STM_MODE_AF_OD, GPIO_NOPULL, GPIO_AF4_I2C1)},
mbed_official 125:23cc3068a9e4 49 {PC_9, I2C_3, STM_PIN_DATA(STM_MODE_AF_OD, GPIO_NOPULL, GPIO_AF4_I2C3)},
mbed_official 87:085cde657901 50 {NC, NC, 0}
mbed_official 87:085cde657901 51 };
mbed_official 87:085cde657901 52
mbed_official 87:085cde657901 53 static const PinMap PinMap_I2C_SCL[] = {
mbed_official 125:23cc3068a9e4 54 {PA_8, I2C_3, STM_PIN_DATA(STM_MODE_AF_OD, GPIO_NOPULL, GPIO_AF4_I2C3)},
mbed_official 125:23cc3068a9e4 55 {PB_6, I2C_1, STM_PIN_DATA(STM_MODE_AF_OD, GPIO_NOPULL, GPIO_AF4_I2C1)},
mbed_official 88:81f18c97d490 56 {PB_8, I2C_1, STM_PIN_DATA(STM_MODE_AF_OD, GPIO_NOPULL, GPIO_AF4_I2C1)},
mbed_official 115:4f0cb9cdc478 57 {PB_10, I2C_2, STM_PIN_DATA(STM_MODE_AF_OD, GPIO_NOPULL, GPIO_AF4_I2C2)},
mbed_official 87:085cde657901 58 {NC, NC, 0}
mbed_official 87:085cde657901 59 };
mbed_official 87:085cde657901 60
mbed_official 87:085cde657901 61 I2C_HandleTypeDef I2cHandle;
mbed_official 87:085cde657901 62
mbed_official 305:1f0269907d8b 63 int i2c1_inited = 0;
mbed_official 305:1f0269907d8b 64 int i2c2_inited = 0;
mbed_official 305:1f0269907d8b 65 int i2c3_inited = 0;
mbed_official 305:1f0269907d8b 66
mbed_official 172:2f4f8c56b261 67 void i2c_init(i2c_t *obj, PinName sda, PinName scl) {
mbed_official 87:085cde657901 68 // Determine the I2C to use
mbed_official 87:085cde657901 69 I2CName i2c_sda = (I2CName)pinmap_peripheral(sda, PinMap_I2C_SDA);
mbed_official 87:085cde657901 70 I2CName i2c_scl = (I2CName)pinmap_peripheral(scl, PinMap_I2C_SCL);
mbed_official 87:085cde657901 71
mbed_official 87:085cde657901 72 obj->i2c = (I2CName)pinmap_merge(i2c_sda, i2c_scl);
mbed_official 227:7bd0639b8911 73 MBED_ASSERT(obj->i2c != (I2CName)NC);
mbed_official 87:085cde657901 74
mbed_official 305:1f0269907d8b 75 // Enable I2C1 clock and pinout if not done
mbed_official 305:1f0269907d8b 76 if ((obj->i2c == I2C_1)&& !i2c1_inited) {
mbed_official 305:1f0269907d8b 77 i2c1_inited = 1;
mbed_official 87:085cde657901 78 __I2C1_CLK_ENABLE();
mbed_official 305:1f0269907d8b 79 // Configure I2C pins
mbed_official 305:1f0269907d8b 80 pinmap_pinout(sda, PinMap_I2C_SDA);
mbed_official 305:1f0269907d8b 81 pinmap_pinout(scl, PinMap_I2C_SCL);
mbed_official 305:1f0269907d8b 82 pin_mode(sda, OpenDrain);
mbed_official 305:1f0269907d8b 83 pin_mode(scl, OpenDrain);
mbed_official 115:4f0cb9cdc478 84 }
mbed_official 305:1f0269907d8b 85 // Enable I2C2 clock and pinout if not done
mbed_official 305:1f0269907d8b 86 if ((obj->i2c == I2C_2)&& !i2c2_inited) {
mbed_official 305:1f0269907d8b 87 i2c2_inited = 1;
mbed_official 305:1f0269907d8b 88 __I2C2_CLK_ENABLE();
mbed_official 305:1f0269907d8b 89 // Configure I2C pins
mbed_official 305:1f0269907d8b 90 pinmap_pinout(sda, PinMap_I2C_SDA);
mbed_official 305:1f0269907d8b 91 pinmap_pinout(scl, PinMap_I2C_SCL);
mbed_official 305:1f0269907d8b 92 pin_mode(sda, OpenDrain);
mbed_official 305:1f0269907d8b 93 pin_mode(scl, OpenDrain);
mbed_official 115:4f0cb9cdc478 94 }
mbed_official 305:1f0269907d8b 95 // Enable I2C3 clock and pinout if not done
mbed_official 305:1f0269907d8b 96 if ((obj->i2c == I2C_3)&& !i2c3_inited) {
mbed_official 305:1f0269907d8b 97 i2c3_inited = 1;
mbed_official 305:1f0269907d8b 98 __I2C3_CLK_ENABLE();
mbed_official 305:1f0269907d8b 99 // Configure I2C pins
mbed_official 305:1f0269907d8b 100 pinmap_pinout(sda, PinMap_I2C_SDA);
mbed_official 305:1f0269907d8b 101 pinmap_pinout(scl, PinMap_I2C_SCL);
mbed_official 305:1f0269907d8b 102 pin_mode(sda, OpenDrain);
mbed_official 305:1f0269907d8b 103 pin_mode(scl, OpenDrain);
mbed_official 305:1f0269907d8b 104 }
mbed_official 172:2f4f8c56b261 105
mbed_official 87:085cde657901 106 // Reset to clear pending flags if any
mbed_official 87:085cde657901 107 i2c_reset(obj);
mbed_official 172:2f4f8c56b261 108
mbed_official 87:085cde657901 109 // I2C configuration
mbed_official 172:2f4f8c56b261 110 i2c_frequency(obj, 100000); // 100 kHz per default
mbed_official 215:83cf97a28428 111
mbed_official 181:a4cbdfbbd2f4 112 // I2C master by default
mbed_official 181:a4cbdfbbd2f4 113 obj->slave = 0;
mbed_official 87:085cde657901 114 }
mbed_official 87:085cde657901 115
mbed_official 87:085cde657901 116 void i2c_frequency(i2c_t *obj, int hz) {
mbed_official 227:7bd0639b8911 117 MBED_ASSERT((hz != 0) && (hz <= 400000));
mbed_official 87:085cde657901 118 I2cHandle.Instance = (I2C_TypeDef *)(obj->i2c);
mbed_official 305:1f0269907d8b 119 int timeout;
mbed_official 305:1f0269907d8b 120
mbed_official 305:1f0269907d8b 121 // wait before init
mbed_official 305:1f0269907d8b 122 timeout = LONG_TIMEOUT;
mbed_official 305:1f0269907d8b 123 while((__HAL_I2C_GET_FLAG(&I2cHandle, I2C_FLAG_BUSY)) && (timeout-- != 0));
mbed_official 172:2f4f8c56b261 124
mbed_official 227:7bd0639b8911 125 // I2C configuration
mbed_official 227:7bd0639b8911 126 I2cHandle.Init.AddressingMode = I2C_ADDRESSINGMODE_7BIT;
mbed_official 227:7bd0639b8911 127 I2cHandle.Init.ClockSpeed = hz;
mbed_official 227:7bd0639b8911 128 I2cHandle.Init.DualAddressMode = I2C_DUALADDRESS_DISABLED;
mbed_official 227:7bd0639b8911 129 I2cHandle.Init.DutyCycle = I2C_DUTYCYCLE_2;
mbed_official 227:7bd0639b8911 130 I2cHandle.Init.GeneralCallMode = I2C_GENERALCALL_DISABLED;
mbed_official 227:7bd0639b8911 131 I2cHandle.Init.NoStretchMode = I2C_NOSTRETCH_DISABLED;
mbed_official 227:7bd0639b8911 132 I2cHandle.Init.OwnAddress1 = 0;
mbed_official 227:7bd0639b8911 133 I2cHandle.Init.OwnAddress2 = 0;
mbed_official 227:7bd0639b8911 134 HAL_I2C_Init(&I2cHandle);
mbed_official 227:7bd0639b8911 135 if (obj->slave) {
mbed_official 227:7bd0639b8911 136 /* Enable Address Acknowledge */
mbed_official 227:7bd0639b8911 137 I2cHandle.Instance->CR1 |= I2C_CR1_ACK;
mbed_official 87:085cde657901 138 }
mbed_official 227:7bd0639b8911 139
mbed_official 87:085cde657901 140 }
mbed_official 87:085cde657901 141
mbed_official 87:085cde657901 142 inline int i2c_start(i2c_t *obj) {
mbed_official 87:085cde657901 143 I2C_TypeDef *i2c = (I2C_TypeDef *)(obj->i2c);
mbed_official 87:085cde657901 144 int timeout;
mbed_official 172:2f4f8c56b261 145
mbed_official 87:085cde657901 146 I2cHandle.Instance = (I2C_TypeDef *)(obj->i2c);
mbed_official 172:2f4f8c56b261 147
mbed_official 87:085cde657901 148 // Clear Acknowledge failure flag
mbed_official 87:085cde657901 149 __HAL_I2C_CLEAR_FLAG(&I2cHandle, I2C_FLAG_AF);
mbed_official 172:2f4f8c56b261 150
mbed_official 87:085cde657901 151 // Generate the START condition
mbed_official 87:085cde657901 152 i2c->CR1 |= I2C_CR1_START;
mbed_official 172:2f4f8c56b261 153
mbed_official 87:085cde657901 154 // Wait the START condition has been correctly sent
mbed_official 87:085cde657901 155 timeout = FLAG_TIMEOUT;
mbed_official 87:085cde657901 156 while (__HAL_I2C_GET_FLAG(&I2cHandle, I2C_FLAG_SB) == RESET) {
mbed_official 172:2f4f8c56b261 157 if ((timeout--) == 0) {
mbed_official 172:2f4f8c56b261 158 return 1;
mbed_official 172:2f4f8c56b261 159 }
mbed_official 87:085cde657901 160 }
mbed_official 172:2f4f8c56b261 161
mbed_official 87:085cde657901 162 return 0;
mbed_official 87:085cde657901 163 }
mbed_official 87:085cde657901 164
mbed_official 87:085cde657901 165 inline int i2c_stop(i2c_t *obj) {
mbed_official 87:085cde657901 166 I2C_TypeDef *i2c = (I2C_TypeDef *)(obj->i2c);
mbed_official 172:2f4f8c56b261 167
mbed_official 87:085cde657901 168 // Generate the STOP condition
mbed_official 87:085cde657901 169 i2c->CR1 |= I2C_CR1_STOP;
mbed_official 87:085cde657901 170
mbed_official 87:085cde657901 171 return 0;
mbed_official 87:085cde657901 172 }
mbed_official 87:085cde657901 173
mbed_official 172:2f4f8c56b261 174 int i2c_read(i2c_t *obj, int address, char *data, int length, int stop) {
mbed_official 183:46ae3190e86c 175 I2C_TypeDef *i2c = (I2C_TypeDef *)(obj->i2c);
mbed_official 183:46ae3190e86c 176 I2cHandle.Instance = (I2C_TypeDef *)(obj->i2c);
mbed_official 183:46ae3190e86c 177 int timeout;
mbed_official 183:46ae3190e86c 178 int count;
mbed_official 183:46ae3190e86c 179 int value;
mbed_official 183:46ae3190e86c 180
mbed_official 183:46ae3190e86c 181 i2c_start(obj);
mbed_official 87:085cde657901 182
mbed_official 183:46ae3190e86c 183 // Wait until SB flag is set
mbed_official 183:46ae3190e86c 184 timeout = FLAG_TIMEOUT;
mbed_official 183:46ae3190e86c 185 while (__HAL_I2C_GET_FLAG(&I2cHandle, I2C_FLAG_SB) == RESET) {
mbed_official 183:46ae3190e86c 186 timeout--;
mbed_official 183:46ae3190e86c 187 if (timeout == 0) {
mbed_official 247:135e3186a638 188 return -1;
mbed_official 183:46ae3190e86c 189 }
mbed_official 87:085cde657901 190 }
mbed_official 215:83cf97a28428 191
mbed_official 215:83cf97a28428 192 i2c->DR = __HAL_I2C_7BIT_ADD_READ(address);
mbed_official 215:83cf97a28428 193
mbed_official 215:83cf97a28428 194
mbed_official 183:46ae3190e86c 195 // Wait address is acknowledged
mbed_official 183:46ae3190e86c 196 timeout = FLAG_TIMEOUT;
mbed_official 183:46ae3190e86c 197 while (__HAL_I2C_GET_FLAG(&I2cHandle, I2C_FLAG_ADDR) == RESET) {
mbed_official 183:46ae3190e86c 198 timeout--;
mbed_official 183:46ae3190e86c 199 if (timeout == 0) {
mbed_official 247:135e3186a638 200 return -1;
mbed_official 183:46ae3190e86c 201 }
mbed_official 183:46ae3190e86c 202 }
mbed_official 183:46ae3190e86c 203 __HAL_I2C_CLEAR_ADDRFLAG(&I2cHandle);
mbed_official 183:46ae3190e86c 204
mbed_official 183:46ae3190e86c 205 // Read all bytes except last one
mbed_official 183:46ae3190e86c 206 for (count = 0; count < (length - 1); count++) {
mbed_official 183:46ae3190e86c 207 value = i2c_byte_read(obj, 0);
mbed_official 183:46ae3190e86c 208 data[count] = (char)value;
mbed_official 183:46ae3190e86c 209 }
mbed_official 183:46ae3190e86c 210
mbed_official 183:46ae3190e86c 211 // If not repeated start, send stop.
mbed_official 183:46ae3190e86c 212 // Warning: must be done BEFORE the data is read.
mbed_official 183:46ae3190e86c 213 if (stop) {
mbed_official 183:46ae3190e86c 214 i2c_stop(obj);
mbed_official 183:46ae3190e86c 215 }
mbed_official 183:46ae3190e86c 216
mbed_official 183:46ae3190e86c 217 // Read the last byte
mbed_official 183:46ae3190e86c 218 value = i2c_byte_read(obj, 1);
mbed_official 183:46ae3190e86c 219 data[count] = (char)value;
mbed_official 87:085cde657901 220
mbed_official 87:085cde657901 221 return length;
mbed_official 87:085cde657901 222 }
mbed_official 87:085cde657901 223
mbed_official 87:085cde657901 224 int i2c_write(i2c_t *obj, int address, const char *data, int length, int stop) {
mbed_official 183:46ae3190e86c 225 I2C_TypeDef *i2c = (I2C_TypeDef *)(obj->i2c);
mbed_official 183:46ae3190e86c 226 I2cHandle.Instance = (I2C_TypeDef *)(obj->i2c);
mbed_official 183:46ae3190e86c 227 int timeout;
mbed_official 183:46ae3190e86c 228 int count;
mbed_official 172:2f4f8c56b261 229
mbed_official 183:46ae3190e86c 230 i2c_start(obj);
mbed_official 87:085cde657901 231
mbed_official 183:46ae3190e86c 232 // Wait until SB flag is set
mbed_official 183:46ae3190e86c 233 timeout = FLAG_TIMEOUT;
mbed_official 183:46ae3190e86c 234 while (__HAL_I2C_GET_FLAG(&I2cHandle, I2C_FLAG_SB) == RESET) {
mbed_official 183:46ae3190e86c 235 timeout--;
mbed_official 183:46ae3190e86c 236 if (timeout == 0) {
mbed_official 247:135e3186a638 237 return -1;
mbed_official 183:46ae3190e86c 238 }
mbed_official 183:46ae3190e86c 239 }
mbed_official 215:83cf97a28428 240
mbed_official 183:46ae3190e86c 241 i2c->DR = __HAL_I2C_7BIT_ADD_WRITE(address);
mbed_official 215:83cf97a28428 242
mbed_official 183:46ae3190e86c 243
mbed_official 183:46ae3190e86c 244 // Wait address is acknowledged
mbed_official 183:46ae3190e86c 245 timeout = FLAG_TIMEOUT;
mbed_official 183:46ae3190e86c 246 while (__HAL_I2C_GET_FLAG(&I2cHandle, I2C_FLAG_ADDR) == RESET) {
mbed_official 183:46ae3190e86c 247 timeout--;
mbed_official 183:46ae3190e86c 248 if (timeout == 0) {
mbed_official 247:135e3186a638 249 return -1;
mbed_official 183:46ae3190e86c 250 }
mbed_official 183:46ae3190e86c 251 }
mbed_official 183:46ae3190e86c 252 __HAL_I2C_CLEAR_ADDRFLAG(&I2cHandle);
mbed_official 215:83cf97a28428 253
mbed_official 183:46ae3190e86c 254 for (count = 0; count < length; count++) {
mbed_official 183:46ae3190e86c 255 if (i2c_byte_write(obj, data[count]) != 1) {
mbed_official 183:46ae3190e86c 256 i2c_stop(obj);
mbed_official 247:135e3186a638 257 return -1;
mbed_official 183:46ae3190e86c 258 }
mbed_official 87:085cde657901 259 }
mbed_official 172:2f4f8c56b261 260
mbed_official 183:46ae3190e86c 261 // If not repeated start, send stop.
mbed_official 183:46ae3190e86c 262 if (stop) {
mbed_official 183:46ae3190e86c 263 i2c_stop(obj);
mbed_official 183:46ae3190e86c 264 }
mbed_official 183:46ae3190e86c 265
mbed_official 183:46ae3190e86c 266 return count;
mbed_official 87:085cde657901 267 }
mbed_official 87:085cde657901 268
mbed_official 87:085cde657901 269 int i2c_byte_read(i2c_t *obj, int last) {
mbed_official 87:085cde657901 270 I2C_TypeDef *i2c = (I2C_TypeDef *)(obj->i2c);
mbed_official 87:085cde657901 271 int timeout;
mbed_official 172:2f4f8c56b261 272
mbed_official 87:085cde657901 273 if (last) {
mbed_official 87:085cde657901 274 // Don't acknowledge the last byte
mbed_official 87:085cde657901 275 i2c->CR1 &= ~I2C_CR1_ACK;
mbed_official 87:085cde657901 276 } else {
mbed_official 87:085cde657901 277 // Acknowledge the byte
mbed_official 87:085cde657901 278 i2c->CR1 |= I2C_CR1_ACK;
mbed_official 87:085cde657901 279 }
mbed_official 87:085cde657901 280
mbed_official 87:085cde657901 281 // Wait until the byte is received
mbed_official 87:085cde657901 282 timeout = FLAG_TIMEOUT;
mbed_official 87:085cde657901 283 while (__HAL_I2C_GET_FLAG(&I2cHandle, I2C_FLAG_RXNE) == RESET) {
mbed_official 172:2f4f8c56b261 284 if ((timeout--) == 0) {
mbed_official 247:135e3186a638 285 return -1;
mbed_official 172:2f4f8c56b261 286 }
mbed_official 87:085cde657901 287 }
mbed_official 172:2f4f8c56b261 288
mbed_official 87:085cde657901 289 return (int)i2c->DR;
mbed_official 87:085cde657901 290 }
mbed_official 87:085cde657901 291
mbed_official 87:085cde657901 292 int i2c_byte_write(i2c_t *obj, int data) {
mbed_official 87:085cde657901 293 I2C_TypeDef *i2c = (I2C_TypeDef *)(obj->i2c);
mbed_official 87:085cde657901 294 int timeout;
mbed_official 87:085cde657901 295
mbed_official 87:085cde657901 296 i2c->DR = (uint8_t)data;
mbed_official 87:085cde657901 297
mbed_official 87:085cde657901 298 // Wait until the byte is transmitted
mbed_official 172:2f4f8c56b261 299 timeout = FLAG_TIMEOUT;
mbed_official 87:085cde657901 300 while ((__HAL_I2C_GET_FLAG(&I2cHandle, I2C_FLAG_TXE) == RESET) &&
mbed_official 215:83cf97a28428 301 (__HAL_I2C_GET_FLAG(&I2cHandle, I2C_FLAG_BTF) == RESET)) {
mbed_official 87:085cde657901 302 if ((timeout--) == 0) {
mbed_official 87:085cde657901 303 return 0;
mbed_official 87:085cde657901 304 }
mbed_official 87:085cde657901 305 }
mbed_official 172:2f4f8c56b261 306
mbed_official 87:085cde657901 307 return 1;
mbed_official 87:085cde657901 308 }
mbed_official 87:085cde657901 309
mbed_official 87:085cde657901 310 void i2c_reset(i2c_t *obj) {
mbed_official 305:1f0269907d8b 311 int timeout;
mbed_official 305:1f0269907d8b 312
mbed_official 305:1f0269907d8b 313 // wait before reset
mbed_official 305:1f0269907d8b 314 timeout = LONG_TIMEOUT;
mbed_official 305:1f0269907d8b 315 while((__HAL_I2C_GET_FLAG(&I2cHandle, I2C_FLAG_BUSY)) && (timeout-- != 0));
mbed_official 305:1f0269907d8b 316
mbed_official 172:2f4f8c56b261 317 if (obj->i2c == I2C_1) {
mbed_official 87:085cde657901 318 __I2C1_FORCE_RESET();
mbed_official 87:085cde657901 319 __I2C1_RELEASE_RESET();
mbed_official 87:085cde657901 320 }
mbed_official 115:4f0cb9cdc478 321 if (obj->i2c == I2C_2) {
mbed_official 115:4f0cb9cdc478 322 __I2C2_FORCE_RESET();
mbed_official 115:4f0cb9cdc478 323 __I2C2_RELEASE_RESET();
mbed_official 115:4f0cb9cdc478 324 }
mbed_official 115:4f0cb9cdc478 325 if (obj->i2c == I2C_3) {
mbed_official 115:4f0cb9cdc478 326 __I2C3_FORCE_RESET();
mbed_official 115:4f0cb9cdc478 327 __I2C3_RELEASE_RESET();
mbed_official 115:4f0cb9cdc478 328 }
mbed_official 87:085cde657901 329 }
mbed_official 87:085cde657901 330
mbed_official 87:085cde657901 331 #if DEVICE_I2CSLAVE
mbed_official 87:085cde657901 332
mbed_official 87:085cde657901 333 void i2c_slave_address(i2c_t *obj, int idx, uint32_t address, uint32_t mask) {
mbed_official 87:085cde657901 334 I2C_TypeDef *i2c = (I2C_TypeDef *)(obj->i2c);
mbed_official 181:a4cbdfbbd2f4 335 uint16_t tmpreg = 0;
mbed_official 87:085cde657901 336
mbed_official 87:085cde657901 337 // Get the old register value
mbed_official 87:085cde657901 338 tmpreg = i2c->OAR1;
mbed_official 87:085cde657901 339 // Reset address bits
mbed_official 87:085cde657901 340 tmpreg &= 0xFC00;
mbed_official 87:085cde657901 341 // Set new address
mbed_official 87:085cde657901 342 tmpreg |= (uint16_t)((uint16_t)address & (uint16_t)0x00FE); // 7-bits
mbed_official 87:085cde657901 343 // Store the new register value
mbed_official 87:085cde657901 344 i2c->OAR1 = tmpreg;
mbed_official 87:085cde657901 345 }
mbed_official 87:085cde657901 346
mbed_official 87:085cde657901 347 void i2c_slave_mode(i2c_t *obj, int enable_slave) {
mbed_official 181:a4cbdfbbd2f4 348 I2cHandle.Instance = (I2C_TypeDef *)(obj->i2c);
mbed_official 215:83cf97a28428 349 if (enable_slave) {
mbed_official 181:a4cbdfbbd2f4 350 obj->slave = 1;
mbed_official 181:a4cbdfbbd2f4 351 /* Enable Address Acknowledge */
mbed_official 181:a4cbdfbbd2f4 352 I2cHandle.Instance->CR1 |= I2C_CR1_ACK;
mbed_official 181:a4cbdfbbd2f4 353 }
mbed_official 87:085cde657901 354 }
mbed_official 87:085cde657901 355
mbed_official 87:085cde657901 356 // See I2CSlave.h
mbed_official 87:085cde657901 357 #define NoData 0 // the slave has not been addressed
mbed_official 87:085cde657901 358 #define ReadAddressed 1 // the master has requested a read from this slave (slave = transmitter)
mbed_official 87:085cde657901 359 #define WriteGeneral 2 // the master is writing to all slave
mbed_official 87:085cde657901 360 #define WriteAddressed 3 // the master is writing to this slave (slave = receiver)
mbed_official 87:085cde657901 361
mbed_official 87:085cde657901 362 int i2c_slave_receive(i2c_t *obj) {
mbed_official 181:a4cbdfbbd2f4 363 int retValue = NoData;
mbed_official 215:83cf97a28428 364
mbed_official 215:83cf97a28428 365 if (__HAL_I2C_GET_FLAG(&I2cHandle, I2C_FLAG_BUSY) == 1) {
mbed_official 215:83cf97a28428 366 if (__HAL_I2C_GET_FLAG(&I2cHandle, I2C_FLAG_ADDR) == 1) {
mbed_official 215:83cf97a28428 367 if (__HAL_I2C_GET_FLAG(&I2cHandle, I2C_FLAG_TRA) == 1)
mbed_official 215:83cf97a28428 368 retValue = ReadAddressed;
mbed_official 181:a4cbdfbbd2f4 369 else
mbed_official 215:83cf97a28428 370 retValue = WriteAddressed;
mbed_official 215:83cf97a28428 371
mbed_official 181:a4cbdfbbd2f4 372 __HAL_I2C_CLEAR_FLAG(&I2cHandle, I2C_FLAG_ADDR);
mbed_official 215:83cf97a28428 373 }
mbed_official 181:a4cbdfbbd2f4 374 }
mbed_official 215:83cf97a28428 375
mbed_official 215:83cf97a28428 376 return (retValue);
mbed_official 87:085cde657901 377 }
mbed_official 87:085cde657901 378
mbed_official 87:085cde657901 379 int i2c_slave_read(i2c_t *obj, char *data, int length) {
mbed_official 181:a4cbdfbbd2f4 380 uint32_t Timeout;
mbed_official 181:a4cbdfbbd2f4 381 int size = 0;
mbed_official 172:2f4f8c56b261 382
mbed_official 87:085cde657901 383 I2cHandle.Instance = (I2C_TypeDef *)(obj->i2c);
mbed_official 87:085cde657901 384
mbed_official 215:83cf97a28428 385 while (length > 0) {
mbed_official 181:a4cbdfbbd2f4 386 /* Wait until RXNE flag is set */
mbed_official 181:a4cbdfbbd2f4 387 // Wait until the byte is received
mbed_official 181:a4cbdfbbd2f4 388 Timeout = FLAG_TIMEOUT;
mbed_official 181:a4cbdfbbd2f4 389 while (__HAL_I2C_GET_FLAG(&I2cHandle, I2C_FLAG_RXNE) == RESET) {
mbed_official 181:a4cbdfbbd2f4 390 Timeout--;
mbed_official 181:a4cbdfbbd2f4 391 if (Timeout == 0) {
mbed_official 247:135e3186a638 392 return -1;
mbed_official 181:a4cbdfbbd2f4 393 }
mbed_official 215:83cf97a28428 394 }
mbed_official 181:a4cbdfbbd2f4 395
mbed_official 181:a4cbdfbbd2f4 396 /* Read data from DR */
mbed_official 181:a4cbdfbbd2f4 397 (*data++) = I2cHandle.Instance->DR;
mbed_official 181:a4cbdfbbd2f4 398 length--;
mbed_official 181:a4cbdfbbd2f4 399 size++;
mbed_official 181:a4cbdfbbd2f4 400
mbed_official 215:83cf97a28428 401 if ((__HAL_I2C_GET_FLAG(&I2cHandle, I2C_FLAG_BTF) == SET) && (length != 0)) {
mbed_official 181:a4cbdfbbd2f4 402 /* Read data from DR */
mbed_official 181:a4cbdfbbd2f4 403 (*data++) = I2cHandle.Instance->DR;
mbed_official 181:a4cbdfbbd2f4 404 length--;
mbed_official 181:a4cbdfbbd2f4 405 size++;
mbed_official 181:a4cbdfbbd2f4 406 }
mbed_official 87:085cde657901 407 }
mbed_official 87:085cde657901 408
mbed_official 181:a4cbdfbbd2f4 409 /* Wait until STOP flag is set */
mbed_official 181:a4cbdfbbd2f4 410 Timeout = FLAG_TIMEOUT;
mbed_official 181:a4cbdfbbd2f4 411 while (__HAL_I2C_GET_FLAG(&I2cHandle, I2C_FLAG_STOPF) == RESET) {
mbed_official 181:a4cbdfbbd2f4 412 Timeout--;
mbed_official 181:a4cbdfbbd2f4 413 if (Timeout == 0) {
mbed_official 247:135e3186a638 414 return -1;
mbed_official 181:a4cbdfbbd2f4 415 }
mbed_official 215:83cf97a28428 416 }
mbed_official 215:83cf97a28428 417
mbed_official 181:a4cbdfbbd2f4 418 /* Clear STOP flag */
mbed_official 181:a4cbdfbbd2f4 419 __HAL_I2C_CLEAR_STOPFLAG(&I2cHandle);
mbed_official 181:a4cbdfbbd2f4 420
mbed_official 181:a4cbdfbbd2f4 421 /* Wait until BUSY flag is reset */
mbed_official 181:a4cbdfbbd2f4 422 Timeout = FLAG_TIMEOUT;
mbed_official 181:a4cbdfbbd2f4 423 while (__HAL_I2C_GET_FLAG(&I2cHandle, I2C_FLAG_BUSY) == SET) {
mbed_official 181:a4cbdfbbd2f4 424 Timeout--;
mbed_official 181:a4cbdfbbd2f4 425 if (Timeout == 0) {
mbed_official 247:135e3186a638 426 return -1;
mbed_official 181:a4cbdfbbd2f4 427 }
mbed_official 181:a4cbdfbbd2f4 428 }
mbed_official 181:a4cbdfbbd2f4 429
mbed_official 181:a4cbdfbbd2f4 430 return size;
mbed_official 87:085cde657901 431 }
mbed_official 87:085cde657901 432
mbed_official 87:085cde657901 433 int i2c_slave_write(i2c_t *obj, const char *data, int length) {
mbed_official 181:a4cbdfbbd2f4 434 uint32_t Timeout;
mbed_official 181:a4cbdfbbd2f4 435 int size = 0;
mbed_official 172:2f4f8c56b261 436
mbed_official 87:085cde657901 437 I2cHandle.Instance = (I2C_TypeDef *)(obj->i2c);
mbed_official 87:085cde657901 438
mbed_official 215:83cf97a28428 439 while (length > 0) {
mbed_official 181:a4cbdfbbd2f4 440 /* Wait until TXE flag is set */
mbed_official 181:a4cbdfbbd2f4 441 Timeout = FLAG_TIMEOUT;
mbed_official 181:a4cbdfbbd2f4 442 while (__HAL_I2C_GET_FLAG(&I2cHandle, I2C_FLAG_TXE) == RESET) {
mbed_official 181:a4cbdfbbd2f4 443 Timeout--;
mbed_official 181:a4cbdfbbd2f4 444 if (Timeout == 0) {
mbed_official 247:135e3186a638 445 return -1;
mbed_official 181:a4cbdfbbd2f4 446 }
mbed_official 215:83cf97a28428 447 }
mbed_official 181:a4cbdfbbd2f4 448
mbed_official 181:a4cbdfbbd2f4 449
mbed_official 181:a4cbdfbbd2f4 450 /* Write data to DR */
mbed_official 181:a4cbdfbbd2f4 451 I2cHandle.Instance->DR = (*data++);
mbed_official 181:a4cbdfbbd2f4 452 length--;
mbed_official 181:a4cbdfbbd2f4 453 size++;
mbed_official 215:83cf97a28428 454
mbed_official 215:83cf97a28428 455 if ((__HAL_I2C_GET_FLAG(&I2cHandle, I2C_FLAG_BTF) == SET) && (length != 0)) {
mbed_official 215:83cf97a28428 456 /* Write data to DR */
mbed_official 215:83cf97a28428 457 I2cHandle.Instance->DR = (*data++);
mbed_official 215:83cf97a28428 458 length--;
mbed_official 215:83cf97a28428 459 size++;
mbed_official 215:83cf97a28428 460 }
mbed_official 181:a4cbdfbbd2f4 461 }
mbed_official 215:83cf97a28428 462
mbed_official 181:a4cbdfbbd2f4 463 /* Wait until AF flag is set */
mbed_official 181:a4cbdfbbd2f4 464 Timeout = FLAG_TIMEOUT;
mbed_official 181:a4cbdfbbd2f4 465 while (__HAL_I2C_GET_FLAG(&I2cHandle, I2C_FLAG_AF) == RESET) {
mbed_official 181:a4cbdfbbd2f4 466 Timeout--;
mbed_official 181:a4cbdfbbd2f4 467 if (Timeout == 0) {
mbed_official 247:135e3186a638 468 return -1;
mbed_official 181:a4cbdfbbd2f4 469 }
mbed_official 215:83cf97a28428 470 }
mbed_official 181:a4cbdfbbd2f4 471
mbed_official 215:83cf97a28428 472
mbed_official 181:a4cbdfbbd2f4 473 /* Clear AF flag */
mbed_official 181:a4cbdfbbd2f4 474 __HAL_I2C_CLEAR_FLAG(&I2cHandle, I2C_FLAG_AF);
mbed_official 181:a4cbdfbbd2f4 475
mbed_official 181:a4cbdfbbd2f4 476
mbed_official 181:a4cbdfbbd2f4 477 /* Wait until BUSY flag is reset */
mbed_official 181:a4cbdfbbd2f4 478 Timeout = FLAG_TIMEOUT;
mbed_official 181:a4cbdfbbd2f4 479 while (__HAL_I2C_GET_FLAG(&I2cHandle, I2C_FLAG_BUSY) == SET) {
mbed_official 181:a4cbdfbbd2f4 480 Timeout--;
mbed_official 181:a4cbdfbbd2f4 481 if (Timeout == 0) {
mbed_official 247:135e3186a638 482 return -1;
mbed_official 181:a4cbdfbbd2f4 483 }
mbed_official 87:085cde657901 484 }
mbed_official 87:085cde657901 485
mbed_official 181:a4cbdfbbd2f4 486 I2cHandle.State = HAL_I2C_STATE_READY;
mbed_official 181:a4cbdfbbd2f4 487
mbed_official 181:a4cbdfbbd2f4 488 /* Process Unlocked */
mbed_official 181:a4cbdfbbd2f4 489 __HAL_UNLOCK(&I2cHandle);
mbed_official 181:a4cbdfbbd2f4 490
mbed_official 181:a4cbdfbbd2f4 491 return size;
mbed_official 87:085cde657901 492 }
mbed_official 87:085cde657901 493
mbed_official 87:085cde657901 494
mbed_official 87:085cde657901 495 #endif // DEVICE_I2CSLAVE
mbed_official 87:085cde657901 496
mbed_official 87:085cde657901 497 #endif // DEVICE_I2C