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@183:46ae3190e86c, 2014-05-07 (annotated)

Committer:
mbed_official
Date:
Wed May 07 17:45:07 2014 +0100
Revision:
183:46ae3190e86c
Parent:
181:a4cbdfbbd2f4
Child:
185:e752b4ee7de1
Synchronized with git revision 152b58673f64d18174038282d90ca97e67d44ae2



Full URL: https://github.com/mbedmicro/mbed/commit/152b58673f64d18174038282d90ca97e67d44ae2/



Ensure the NVIC table gets copied to RAM even when it is not at 0x0000

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