Lancaster University / mbed-src

Important changes to repositories hosted on mbed.com

Mbed hosted mercurial repositories are deprecated and are due to be permanently deleted in July 2026.

To keep a copy of this software download the repository Zip archive or clone locally using Mercurial.

It is also possible to export all your personal repositories from the account settings page.

Fork of mbed-src by mbed official

targets/hal/TARGET_STM/TARGET_STM32F4/i2c_api.c@641:be9b2017785a, 2016-07-13 (annotated)

Committer:
LancasterUniversity
Date:
Wed Jul 13 12:52:54 2016 +0100
Revision:
641:be9b2017785a
Parent:
442:d916d321e60f 
Synchronized with git rev 1fb8ab4c

Author: James Devine

mbed-classic: BUGFIX for timer when using wait_ms from interrupt context



Previously if a user used wait[_ms,_us] in interrupt context the device would

hang indefinitely. This was due to incrementing overflowCount from

interrupt context only.



This meant that if a user used wait[_ms,_us] in an ISR with

the same or greater interrupt priority, it would result in an infinite

loop as the overflowCount variable would never be incremented, and

wait[_ms,_us] would never return.



This patch simply applies a better solution for the race condition

mentioned in the previous commit. It instead disables the timer1

interrupt and increments the overflowCount variable, preventing

the race condition whilst supporting wait[_ms,_us] in interrupt

context.

Who changed what in which revision?

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