long dao / mbed-src

Mbed for VNG board

Fork of mbed-src by mbed official

targets/hal/TARGET_STM/TARGET_NUCLEO_F302R8/i2c_api.c@414:4ec4c5b614b0, 2014-11-25 (annotated)

Committer:
mbed_official
Date:
Tue Nov 25 07:15:09 2014 +0000
Revision:
414:4ec4c5b614b0
Parent:
402:09075a3b15e3 
Synchronized with git revision fbc74e874ac089c6cb05add312fb5422be628886



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



Targets: NUCLEOs - Add PeripheralPins files for all nucleo targets

Who changed what in which revision?

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