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@274:6937b19af361, 2014-08-06 (annotated)

Committer:
mbed_official
Date:
Wed Aug 06 08:15:07 2014 +0100
Revision:
274:6937b19af361
Parent:
247:135e3186a638
Child:
305:1f0269907d8b
Synchronized with git revision 5b145e4f6c509376173c3ea2aa35a6da879a2124



Full URL: https://github.com/mbedmicro/mbed/commit/5b145e4f6c509376173c3ea2aa35a6da879a2124/



[TARGET_LPC11UXX] PeripheralNames.h and PinMap definitions separation for LPC11UXX platforms

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 172:2f4f8c56b261 63 void i2c_init(i2c_t *obj, PinName sda, PinName scl) {
mbed_official 87:085cde657901 64 // Determine the I2C to use
mbed_official 87:085cde657901 65 I2CName i2c_sda = (I2CName)pinmap_peripheral(sda, PinMap_I2C_SDA);
mbed_official 87:085cde657901 66 I2CName i2c_scl = (I2CName)pinmap_peripheral(scl, PinMap_I2C_SCL);
mbed_official 87:085cde657901 67
mbed_official 87:085cde657901 68 obj->i2c = (I2CName)pinmap_merge(i2c_sda, i2c_scl);
mbed_official 227:7bd0639b8911 69 MBED_ASSERT(obj->i2c != (I2CName)NC);
mbed_official 87:085cde657901 70
mbed_official 87:085cde657901 71 // Enable I2C clock
mbed_official 172:2f4f8c56b261 72 if (obj->i2c == I2C_1) {
mbed_official 87:085cde657901 73 __I2C1_CLK_ENABLE();
mbed_official 87:085cde657901 74 }
mbed_official 115:4f0cb9cdc478 75 if (obj->i2c == I2C_2) {
mbed_official 115:4f0cb9cdc478 76 __I2C2_CLK_ENABLE();
mbed_official 115:4f0cb9cdc478 77 }
mbed_official 115:4f0cb9cdc478 78 if (obj->i2c == I2C_3) {
mbed_official 115:4f0cb9cdc478 79 __I2C3_CLK_ENABLE();
mbed_official 115:4f0cb9cdc478 80 }
mbed_official 87:085cde657901 81
mbed_official 87:085cde657901 82 // Configure I2C pins
mbed_official 87:085cde657901 83 pinmap_pinout(sda, PinMap_I2C_SDA);
mbed_official 87:085cde657901 84 pinmap_pinout(scl, PinMap_I2C_SCL);
mbed_official 87:085cde657901 85 pin_mode(sda, OpenDrain);
mbed_official 87:085cde657901 86 pin_mode(scl, OpenDrain);
mbed_official 172:2f4f8c56b261 87
mbed_official 87:085cde657901 88 // Reset to clear pending flags if any
mbed_official 87:085cde657901 89 i2c_reset(obj);
mbed_official 172:2f4f8c56b261 90
mbed_official 87:085cde657901 91 // I2C configuration
mbed_official 172:2f4f8c56b261 92 i2c_frequency(obj, 100000); // 100 kHz per default
mbed_official 215:83cf97a28428 93
mbed_official 181:a4cbdfbbd2f4 94 // I2C master by default
mbed_official 181:a4cbdfbbd2f4 95 obj->slave = 0;
mbed_official 87:085cde657901 96 }
mbed_official 87:085cde657901 97
mbed_official 87:085cde657901 98 void i2c_frequency(i2c_t *obj, int hz) {
mbed_official 227:7bd0639b8911 99 MBED_ASSERT((hz != 0) && (hz <= 400000));
mbed_official 87:085cde657901 100 I2cHandle.Instance = (I2C_TypeDef *)(obj->i2c);
mbed_official 172:2f4f8c56b261 101
mbed_official 227:7bd0639b8911 102 // I2C configuration
mbed_official 227:7bd0639b8911 103 I2cHandle.Init.AddressingMode = I2C_ADDRESSINGMODE_7BIT;
mbed_official 227:7bd0639b8911 104 I2cHandle.Init.ClockSpeed = hz;
mbed_official 227:7bd0639b8911 105 I2cHandle.Init.DualAddressMode = I2C_DUALADDRESS_DISABLED;
mbed_official 227:7bd0639b8911 106 I2cHandle.Init.DutyCycle = I2C_DUTYCYCLE_2;
mbed_official 227:7bd0639b8911 107 I2cHandle.Init.GeneralCallMode = I2C_GENERALCALL_DISABLED;
mbed_official 227:7bd0639b8911 108 I2cHandle.Init.NoStretchMode = I2C_NOSTRETCH_DISABLED;
mbed_official 227:7bd0639b8911 109 I2cHandle.Init.OwnAddress1 = 0;
mbed_official 227:7bd0639b8911 110 I2cHandle.Init.OwnAddress2 = 0;
mbed_official 227:7bd0639b8911 111 HAL_I2C_Init(&I2cHandle);
mbed_official 227:7bd0639b8911 112 if (obj->slave) {
mbed_official 227:7bd0639b8911 113 /* Enable Address Acknowledge */
mbed_official 227:7bd0639b8911 114 I2cHandle.Instance->CR1 |= I2C_CR1_ACK;
mbed_official 87:085cde657901 115 }
mbed_official 227:7bd0639b8911 116
mbed_official 87:085cde657901 117 }
mbed_official 87:085cde657901 118
mbed_official 87:085cde657901 119 inline int i2c_start(i2c_t *obj) {
mbed_official 87:085cde657901 120 I2C_TypeDef *i2c = (I2C_TypeDef *)(obj->i2c);
mbed_official 87:085cde657901 121 int timeout;
mbed_official 172:2f4f8c56b261 122
mbed_official 87:085cde657901 123 I2cHandle.Instance = (I2C_TypeDef *)(obj->i2c);
mbed_official 172:2f4f8c56b261 124
mbed_official 87:085cde657901 125 // Clear Acknowledge failure flag
mbed_official 87:085cde657901 126 __HAL_I2C_CLEAR_FLAG(&I2cHandle, I2C_FLAG_AF);
mbed_official 172:2f4f8c56b261 127
mbed_official 87:085cde657901 128 // Generate the START condition
mbed_official 87:085cde657901 129 i2c->CR1 |= I2C_CR1_START;
mbed_official 172:2f4f8c56b261 130
mbed_official 87:085cde657901 131 // Wait the START condition has been correctly sent
mbed_official 87:085cde657901 132 timeout = FLAG_TIMEOUT;
mbed_official 87:085cde657901 133 while (__HAL_I2C_GET_FLAG(&I2cHandle, I2C_FLAG_SB) == RESET) {
mbed_official 172:2f4f8c56b261 134 if ((timeout--) == 0) {
mbed_official 172:2f4f8c56b261 135 return 1;
mbed_official 172:2f4f8c56b261 136 }
mbed_official 87:085cde657901 137 }
mbed_official 172:2f4f8c56b261 138
mbed_official 87:085cde657901 139 return 0;
mbed_official 87:085cde657901 140 }
mbed_official 87:085cde657901 141
mbed_official 87:085cde657901 142 inline int i2c_stop(i2c_t *obj) {
mbed_official 87:085cde657901 143 I2C_TypeDef *i2c = (I2C_TypeDef *)(obj->i2c);
mbed_official 172:2f4f8c56b261 144
mbed_official 87:085cde657901 145 // Generate the STOP condition
mbed_official 87:085cde657901 146 i2c->CR1 |= I2C_CR1_STOP;
mbed_official 87:085cde657901 147
mbed_official 87:085cde657901 148 return 0;
mbed_official 87:085cde657901 149 }
mbed_official 87:085cde657901 150
mbed_official 172:2f4f8c56b261 151 int i2c_read(i2c_t *obj, int address, char *data, int length, int stop) {
mbed_official 183:46ae3190e86c 152 I2C_TypeDef *i2c = (I2C_TypeDef *)(obj->i2c);
mbed_official 183:46ae3190e86c 153 I2cHandle.Instance = (I2C_TypeDef *)(obj->i2c);
mbed_official 183:46ae3190e86c 154 int timeout;
mbed_official 183:46ae3190e86c 155 int count;
mbed_official 183:46ae3190e86c 156 int value;
mbed_official 183:46ae3190e86c 157
mbed_official 183:46ae3190e86c 158 i2c_start(obj);
mbed_official 87:085cde657901 159
mbed_official 183:46ae3190e86c 160 // Wait until SB flag is set
mbed_official 183:46ae3190e86c 161 timeout = FLAG_TIMEOUT;
mbed_official 183:46ae3190e86c 162 while (__HAL_I2C_GET_FLAG(&I2cHandle, I2C_FLAG_SB) == RESET) {
mbed_official 183:46ae3190e86c 163 timeout--;
mbed_official 183:46ae3190e86c 164 if (timeout == 0) {
mbed_official 247:135e3186a638 165 return -1;
mbed_official 183:46ae3190e86c 166 }
mbed_official 87:085cde657901 167 }
mbed_official 215:83cf97a28428 168
mbed_official 215:83cf97a28428 169 i2c->DR = __HAL_I2C_7BIT_ADD_READ(address);
mbed_official 215:83cf97a28428 170
mbed_official 215:83cf97a28428 171
mbed_official 183:46ae3190e86c 172 // Wait address is acknowledged
mbed_official 183:46ae3190e86c 173 timeout = FLAG_TIMEOUT;
mbed_official 183:46ae3190e86c 174 while (__HAL_I2C_GET_FLAG(&I2cHandle, I2C_FLAG_ADDR) == RESET) {
mbed_official 183:46ae3190e86c 175 timeout--;
mbed_official 183:46ae3190e86c 176 if (timeout == 0) {
mbed_official 247:135e3186a638 177 return -1;
mbed_official 183:46ae3190e86c 178 }
mbed_official 183:46ae3190e86c 179 }
mbed_official 183:46ae3190e86c 180 __HAL_I2C_CLEAR_ADDRFLAG(&I2cHandle);
mbed_official 183:46ae3190e86c 181
mbed_official 183:46ae3190e86c 182 // Read all bytes except last one
mbed_official 183:46ae3190e86c 183 for (count = 0; count < (length - 1); count++) {
mbed_official 183:46ae3190e86c 184 value = i2c_byte_read(obj, 0);
mbed_official 183:46ae3190e86c 185 data[count] = (char)value;
mbed_official 183:46ae3190e86c 186 }
mbed_official 183:46ae3190e86c 187
mbed_official 183:46ae3190e86c 188 // If not repeated start, send stop.
mbed_official 183:46ae3190e86c 189 // Warning: must be done BEFORE the data is read.
mbed_official 183:46ae3190e86c 190 if (stop) {
mbed_official 183:46ae3190e86c 191 i2c_stop(obj);
mbed_official 183:46ae3190e86c 192 }
mbed_official 183:46ae3190e86c 193
mbed_official 183:46ae3190e86c 194 // Read the last byte
mbed_official 183:46ae3190e86c 195 value = i2c_byte_read(obj, 1);
mbed_official 183:46ae3190e86c 196 data[count] = (char)value;
mbed_official 87:085cde657901 197
mbed_official 87:085cde657901 198 return length;
mbed_official 87:085cde657901 199 }
mbed_official 87:085cde657901 200
mbed_official 87:085cde657901 201 int i2c_write(i2c_t *obj, int address, const char *data, int length, int stop) {
mbed_official 183:46ae3190e86c 202 I2C_TypeDef *i2c = (I2C_TypeDef *)(obj->i2c);
mbed_official 183:46ae3190e86c 203 I2cHandle.Instance = (I2C_TypeDef *)(obj->i2c);
mbed_official 183:46ae3190e86c 204 int timeout;
mbed_official 183:46ae3190e86c 205 int count;
mbed_official 172:2f4f8c56b261 206
mbed_official 183:46ae3190e86c 207 i2c_start(obj);
mbed_official 87:085cde657901 208
mbed_official 183:46ae3190e86c 209 // Wait until SB flag is set
mbed_official 183:46ae3190e86c 210 timeout = FLAG_TIMEOUT;
mbed_official 183:46ae3190e86c 211 while (__HAL_I2C_GET_FLAG(&I2cHandle, I2C_FLAG_SB) == RESET) {
mbed_official 183:46ae3190e86c 212 timeout--;
mbed_official 183:46ae3190e86c 213 if (timeout == 0) {
mbed_official 247:135e3186a638 214 return -1;
mbed_official 183:46ae3190e86c 215 }
mbed_official 183:46ae3190e86c 216 }
mbed_official 215:83cf97a28428 217
mbed_official 183:46ae3190e86c 218 i2c->DR = __HAL_I2C_7BIT_ADD_WRITE(address);
mbed_official 215:83cf97a28428 219
mbed_official 183:46ae3190e86c 220
mbed_official 183:46ae3190e86c 221 // Wait address is acknowledged
mbed_official 183:46ae3190e86c 222 timeout = FLAG_TIMEOUT;
mbed_official 183:46ae3190e86c 223 while (__HAL_I2C_GET_FLAG(&I2cHandle, I2C_FLAG_ADDR) == RESET) {
mbed_official 183:46ae3190e86c 224 timeout--;
mbed_official 183:46ae3190e86c 225 if (timeout == 0) {
mbed_official 247:135e3186a638 226 return -1;
mbed_official 183:46ae3190e86c 227 }
mbed_official 183:46ae3190e86c 228 }
mbed_official 183:46ae3190e86c 229 __HAL_I2C_CLEAR_ADDRFLAG(&I2cHandle);
mbed_official 215:83cf97a28428 230
mbed_official 183:46ae3190e86c 231 for (count = 0; count < length; count++) {
mbed_official 183:46ae3190e86c 232 if (i2c_byte_write(obj, data[count]) != 1) {
mbed_official 183:46ae3190e86c 233 i2c_stop(obj);
mbed_official 247:135e3186a638 234 return -1;
mbed_official 183:46ae3190e86c 235 }
mbed_official 87:085cde657901 236 }
mbed_official 172:2f4f8c56b261 237
mbed_official 183:46ae3190e86c 238 // If not repeated start, send stop.
mbed_official 183:46ae3190e86c 239 if (stop) {
mbed_official 183:46ae3190e86c 240 i2c_stop(obj);
mbed_official 183:46ae3190e86c 241 }
mbed_official 183:46ae3190e86c 242
mbed_official 183:46ae3190e86c 243 return count;
mbed_official 87:085cde657901 244 }
mbed_official 87:085cde657901 245
mbed_official 87:085cde657901 246 int i2c_byte_read(i2c_t *obj, int last) {
mbed_official 87:085cde657901 247 I2C_TypeDef *i2c = (I2C_TypeDef *)(obj->i2c);
mbed_official 87:085cde657901 248 int timeout;
mbed_official 172:2f4f8c56b261 249
mbed_official 87:085cde657901 250 if (last) {
mbed_official 87:085cde657901 251 // Don't acknowledge the last byte
mbed_official 87:085cde657901 252 i2c->CR1 &= ~I2C_CR1_ACK;
mbed_official 87:085cde657901 253 } else {
mbed_official 87:085cde657901 254 // Acknowledge the byte
mbed_official 87:085cde657901 255 i2c->CR1 |= I2C_CR1_ACK;
mbed_official 87:085cde657901 256 }
mbed_official 87:085cde657901 257
mbed_official 87:085cde657901 258 // Wait until the byte is received
mbed_official 87:085cde657901 259 timeout = FLAG_TIMEOUT;
mbed_official 87:085cde657901 260 while (__HAL_I2C_GET_FLAG(&I2cHandle, I2C_FLAG_RXNE) == RESET) {
mbed_official 172:2f4f8c56b261 261 if ((timeout--) == 0) {
mbed_official 247:135e3186a638 262 return -1;
mbed_official 172:2f4f8c56b261 263 }
mbed_official 87:085cde657901 264 }
mbed_official 172:2f4f8c56b261 265
mbed_official 87:085cde657901 266 return (int)i2c->DR;
mbed_official 87:085cde657901 267 }
mbed_official 87:085cde657901 268
mbed_official 87:085cde657901 269 int i2c_byte_write(i2c_t *obj, int data) {
mbed_official 87:085cde657901 270 I2C_TypeDef *i2c = (I2C_TypeDef *)(obj->i2c);
mbed_official 87:085cde657901 271 int timeout;
mbed_official 87:085cde657901 272
mbed_official 87:085cde657901 273 i2c->DR = (uint8_t)data;
mbed_official 87:085cde657901 274
mbed_official 87:085cde657901 275 // Wait until the byte is transmitted
mbed_official 172:2f4f8c56b261 276 timeout = FLAG_TIMEOUT;
mbed_official 87:085cde657901 277 while ((__HAL_I2C_GET_FLAG(&I2cHandle, I2C_FLAG_TXE) == RESET) &&
mbed_official 215:83cf97a28428 278 (__HAL_I2C_GET_FLAG(&I2cHandle, I2C_FLAG_BTF) == RESET)) {
mbed_official 87:085cde657901 279 if ((timeout--) == 0) {
mbed_official 87:085cde657901 280 return 0;
mbed_official 87:085cde657901 281 }
mbed_official 87:085cde657901 282 }
mbed_official 172:2f4f8c56b261 283
mbed_official 87:085cde657901 284 return 1;
mbed_official 87:085cde657901 285 }
mbed_official 87:085cde657901 286
mbed_official 87:085cde657901 287 void i2c_reset(i2c_t *obj) {
mbed_official 172:2f4f8c56b261 288 if (obj->i2c == I2C_1) {
mbed_official 87:085cde657901 289 __I2C1_FORCE_RESET();
mbed_official 87:085cde657901 290 __I2C1_RELEASE_RESET();
mbed_official 87:085cde657901 291 }
mbed_official 115:4f0cb9cdc478 292 if (obj->i2c == I2C_2) {
mbed_official 115:4f0cb9cdc478 293 __I2C2_FORCE_RESET();
mbed_official 115:4f0cb9cdc478 294 __I2C2_RELEASE_RESET();
mbed_official 115:4f0cb9cdc478 295 }
mbed_official 115:4f0cb9cdc478 296 if (obj->i2c == I2C_3) {
mbed_official 115:4f0cb9cdc478 297 __I2C3_FORCE_RESET();
mbed_official 115:4f0cb9cdc478 298 __I2C3_RELEASE_RESET();
mbed_official 115:4f0cb9cdc478 299 }
mbed_official 87:085cde657901 300 }
mbed_official 87:085cde657901 301
mbed_official 87:085cde657901 302 #if DEVICE_I2CSLAVE
mbed_official 87:085cde657901 303
mbed_official 87:085cde657901 304 void i2c_slave_address(i2c_t *obj, int idx, uint32_t address, uint32_t mask) {
mbed_official 87:085cde657901 305 I2C_TypeDef *i2c = (I2C_TypeDef *)(obj->i2c);
mbed_official 181:a4cbdfbbd2f4 306 uint16_t tmpreg = 0;
mbed_official 87:085cde657901 307
mbed_official 87:085cde657901 308 // Get the old register value
mbed_official 87:085cde657901 309 tmpreg = i2c->OAR1;
mbed_official 87:085cde657901 310 // Reset address bits
mbed_official 87:085cde657901 311 tmpreg &= 0xFC00;
mbed_official 87:085cde657901 312 // Set new address
mbed_official 87:085cde657901 313 tmpreg |= (uint16_t)((uint16_t)address & (uint16_t)0x00FE); // 7-bits
mbed_official 87:085cde657901 314 // Store the new register value
mbed_official 87:085cde657901 315 i2c->OAR1 = tmpreg;
mbed_official 87:085cde657901 316 }
mbed_official 87:085cde657901 317
mbed_official 87:085cde657901 318 void i2c_slave_mode(i2c_t *obj, int enable_slave) {
mbed_official 181:a4cbdfbbd2f4 319 I2cHandle.Instance = (I2C_TypeDef *)(obj->i2c);
mbed_official 215:83cf97a28428 320 if (enable_slave) {
mbed_official 181:a4cbdfbbd2f4 321 obj->slave = 1;
mbed_official 181:a4cbdfbbd2f4 322 /* Enable Address Acknowledge */
mbed_official 181:a4cbdfbbd2f4 323 I2cHandle.Instance->CR1 |= I2C_CR1_ACK;
mbed_official 181:a4cbdfbbd2f4 324 }
mbed_official 87:085cde657901 325 }
mbed_official 87:085cde657901 326
mbed_official 87:085cde657901 327 // See I2CSlave.h
mbed_official 87:085cde657901 328 #define NoData 0 // the slave has not been addressed
mbed_official 87:085cde657901 329 #define ReadAddressed 1 // the master has requested a read from this slave (slave = transmitter)
mbed_official 87:085cde657901 330 #define WriteGeneral 2 // the master is writing to all slave
mbed_official 87:085cde657901 331 #define WriteAddressed 3 // the master is writing to this slave (slave = receiver)
mbed_official 87:085cde657901 332
mbed_official 87:085cde657901 333 int i2c_slave_receive(i2c_t *obj) {
mbed_official 181:a4cbdfbbd2f4 334 int retValue = NoData;
mbed_official 215:83cf97a28428 335
mbed_official 215:83cf97a28428 336 if (__HAL_I2C_GET_FLAG(&I2cHandle, I2C_FLAG_BUSY) == 1) {
mbed_official 215:83cf97a28428 337 if (__HAL_I2C_GET_FLAG(&I2cHandle, I2C_FLAG_ADDR) == 1) {
mbed_official 215:83cf97a28428 338 if (__HAL_I2C_GET_FLAG(&I2cHandle, I2C_FLAG_TRA) == 1)
mbed_official 215:83cf97a28428 339 retValue = ReadAddressed;
mbed_official 181:a4cbdfbbd2f4 340 else
mbed_official 215:83cf97a28428 341 retValue = WriteAddressed;
mbed_official 215:83cf97a28428 342
mbed_official 181:a4cbdfbbd2f4 343 __HAL_I2C_CLEAR_FLAG(&I2cHandle, I2C_FLAG_ADDR);
mbed_official 215:83cf97a28428 344 }
mbed_official 181:a4cbdfbbd2f4 345 }
mbed_official 215:83cf97a28428 346
mbed_official 215:83cf97a28428 347 return (retValue);
mbed_official 87:085cde657901 348 }
mbed_official 87:085cde657901 349
mbed_official 87:085cde657901 350 int i2c_slave_read(i2c_t *obj, char *data, int length) {
mbed_official 181:a4cbdfbbd2f4 351 uint32_t Timeout;
mbed_official 181:a4cbdfbbd2f4 352 int size = 0;
mbed_official 172:2f4f8c56b261 353
mbed_official 87:085cde657901 354 I2cHandle.Instance = (I2C_TypeDef *)(obj->i2c);
mbed_official 87:085cde657901 355
mbed_official 215:83cf97a28428 356 while (length > 0) {
mbed_official 181:a4cbdfbbd2f4 357 /* Wait until RXNE flag is set */
mbed_official 181:a4cbdfbbd2f4 358 // Wait until the byte is received
mbed_official 181:a4cbdfbbd2f4 359 Timeout = FLAG_TIMEOUT;
mbed_official 181:a4cbdfbbd2f4 360 while (__HAL_I2C_GET_FLAG(&I2cHandle, I2C_FLAG_RXNE) == RESET) {
mbed_official 181:a4cbdfbbd2f4 361 Timeout--;
mbed_official 181:a4cbdfbbd2f4 362 if (Timeout == 0) {
mbed_official 247:135e3186a638 363 return -1;
mbed_official 181:a4cbdfbbd2f4 364 }
mbed_official 215:83cf97a28428 365 }
mbed_official 181:a4cbdfbbd2f4 366
mbed_official 181:a4cbdfbbd2f4 367 /* Read data from DR */
mbed_official 181:a4cbdfbbd2f4 368 (*data++) = I2cHandle.Instance->DR;
mbed_official 181:a4cbdfbbd2f4 369 length--;
mbed_official 181:a4cbdfbbd2f4 370 size++;
mbed_official 181:a4cbdfbbd2f4 371
mbed_official 215:83cf97a28428 372 if ((__HAL_I2C_GET_FLAG(&I2cHandle, I2C_FLAG_BTF) == SET) && (length != 0)) {
mbed_official 181:a4cbdfbbd2f4 373 /* Read data from DR */
mbed_official 181:a4cbdfbbd2f4 374 (*data++) = I2cHandle.Instance->DR;
mbed_official 181:a4cbdfbbd2f4 375 length--;
mbed_official 181:a4cbdfbbd2f4 376 size++;
mbed_official 181:a4cbdfbbd2f4 377 }
mbed_official 87:085cde657901 378 }
mbed_official 87:085cde657901 379
mbed_official 181:a4cbdfbbd2f4 380 /* Wait until STOP flag is set */
mbed_official 181:a4cbdfbbd2f4 381 Timeout = FLAG_TIMEOUT;
mbed_official 181:a4cbdfbbd2f4 382 while (__HAL_I2C_GET_FLAG(&I2cHandle, I2C_FLAG_STOPF) == RESET) {
mbed_official 181:a4cbdfbbd2f4 383 Timeout--;
mbed_official 181:a4cbdfbbd2f4 384 if (Timeout == 0) {
mbed_official 247:135e3186a638 385 return -1;
mbed_official 181:a4cbdfbbd2f4 386 }
mbed_official 215:83cf97a28428 387 }
mbed_official 215:83cf97a28428 388
mbed_official 181:a4cbdfbbd2f4 389 /* Clear STOP flag */
mbed_official 181:a4cbdfbbd2f4 390 __HAL_I2C_CLEAR_STOPFLAG(&I2cHandle);
mbed_official 181:a4cbdfbbd2f4 391
mbed_official 181:a4cbdfbbd2f4 392 /* Wait until BUSY flag is reset */
mbed_official 181:a4cbdfbbd2f4 393 Timeout = FLAG_TIMEOUT;
mbed_official 181:a4cbdfbbd2f4 394 while (__HAL_I2C_GET_FLAG(&I2cHandle, I2C_FLAG_BUSY) == SET) {
mbed_official 181:a4cbdfbbd2f4 395 Timeout--;
mbed_official 181:a4cbdfbbd2f4 396 if (Timeout == 0) {
mbed_official 247:135e3186a638 397 return -1;
mbed_official 181:a4cbdfbbd2f4 398 }
mbed_official 181:a4cbdfbbd2f4 399 }
mbed_official 181:a4cbdfbbd2f4 400
mbed_official 181:a4cbdfbbd2f4 401 return size;
mbed_official 87:085cde657901 402 }
mbed_official 87:085cde657901 403
mbed_official 87:085cde657901 404 int i2c_slave_write(i2c_t *obj, const char *data, int length) {
mbed_official 181:a4cbdfbbd2f4 405 uint32_t Timeout;
mbed_official 181:a4cbdfbbd2f4 406 int size = 0;
mbed_official 172:2f4f8c56b261 407
mbed_official 87:085cde657901 408 I2cHandle.Instance = (I2C_TypeDef *)(obj->i2c);
mbed_official 87:085cde657901 409
mbed_official 215:83cf97a28428 410 while (length > 0) {
mbed_official 181:a4cbdfbbd2f4 411 /* Wait until TXE flag is set */
mbed_official 181:a4cbdfbbd2f4 412 Timeout = FLAG_TIMEOUT;
mbed_official 181:a4cbdfbbd2f4 413 while (__HAL_I2C_GET_FLAG(&I2cHandle, I2C_FLAG_TXE) == RESET) {
mbed_official 181:a4cbdfbbd2f4 414 Timeout--;
mbed_official 181:a4cbdfbbd2f4 415 if (Timeout == 0) {
mbed_official 247:135e3186a638 416 return -1;
mbed_official 181:a4cbdfbbd2f4 417 }
mbed_official 215:83cf97a28428 418 }
mbed_official 181:a4cbdfbbd2f4 419
mbed_official 181:a4cbdfbbd2f4 420
mbed_official 181:a4cbdfbbd2f4 421 /* Write data to DR */
mbed_official 181:a4cbdfbbd2f4 422 I2cHandle.Instance->DR = (*data++);
mbed_official 181:a4cbdfbbd2f4 423 length--;
mbed_official 181:a4cbdfbbd2f4 424 size++;
mbed_official 215:83cf97a28428 425
mbed_official 215:83cf97a28428 426 if ((__HAL_I2C_GET_FLAG(&I2cHandle, I2C_FLAG_BTF) == SET) && (length != 0)) {
mbed_official 215:83cf97a28428 427 /* Write data to DR */
mbed_official 215:83cf97a28428 428 I2cHandle.Instance->DR = (*data++);
mbed_official 215:83cf97a28428 429 length--;
mbed_official 215:83cf97a28428 430 size++;
mbed_official 215:83cf97a28428 431 }
mbed_official 181:a4cbdfbbd2f4 432 }
mbed_official 215:83cf97a28428 433
mbed_official 181:a4cbdfbbd2f4 434 /* Wait until AF flag is set */
mbed_official 181:a4cbdfbbd2f4 435 Timeout = FLAG_TIMEOUT;
mbed_official 181:a4cbdfbbd2f4 436 while (__HAL_I2C_GET_FLAG(&I2cHandle, I2C_FLAG_AF) == RESET) {
mbed_official 181:a4cbdfbbd2f4 437 Timeout--;
mbed_official 181:a4cbdfbbd2f4 438 if (Timeout == 0) {
mbed_official 247:135e3186a638 439 return -1;
mbed_official 181:a4cbdfbbd2f4 440 }
mbed_official 215:83cf97a28428 441 }
mbed_official 181:a4cbdfbbd2f4 442
mbed_official 215:83cf97a28428 443
mbed_official 181:a4cbdfbbd2f4 444 /* Clear AF flag */
mbed_official 181:a4cbdfbbd2f4 445 __HAL_I2C_CLEAR_FLAG(&I2cHandle, I2C_FLAG_AF);
mbed_official 181:a4cbdfbbd2f4 446
mbed_official 181:a4cbdfbbd2f4 447
mbed_official 181:a4cbdfbbd2f4 448 /* Wait until BUSY flag is reset */
mbed_official 181:a4cbdfbbd2f4 449 Timeout = FLAG_TIMEOUT;
mbed_official 181:a4cbdfbbd2f4 450 while (__HAL_I2C_GET_FLAG(&I2cHandle, I2C_FLAG_BUSY) == SET) {
mbed_official 181:a4cbdfbbd2f4 451 Timeout--;
mbed_official 181:a4cbdfbbd2f4 452 if (Timeout == 0) {
mbed_official 247:135e3186a638 453 return -1;
mbed_official 181:a4cbdfbbd2f4 454 }
mbed_official 87:085cde657901 455 }
mbed_official 87:085cde657901 456
mbed_official 181:a4cbdfbbd2f4 457 I2cHandle.State = HAL_I2C_STATE_READY;
mbed_official 181:a4cbdfbbd2f4 458
mbed_official 181:a4cbdfbbd2f4 459 /* Process Unlocked */
mbed_official 181:a4cbdfbbd2f4 460 __HAL_UNLOCK(&I2cHandle);
mbed_official 181:a4cbdfbbd2f4 461
mbed_official 181:a4cbdfbbd2f4 462 return size;
mbed_official 87:085cde657901 463 }
mbed_official 87:085cde657901 464
mbed_official 87:085cde657901 465
mbed_official 87:085cde657901 466 #endif // DEVICE_I2CSLAVE
mbed_official 87:085cde657901 467
mbed_official 87:085cde657901 468 #endif // DEVICE_I2C