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_L053R8/i2c_api.c@489:119543c9f674, 2015-03-12 (annotated)

Committer:
mbed_official
Date:
Thu Mar 12 14:30:49 2015 +0000
Revision:
489:119543c9f674
Parent:
414:4ec4c5b614b0 
Synchronized with git revision 051854181516992fb498d51f9ee6e70cbad9e083



Full URL: https://github.com/mbedmicro/mbed/commit/051854181516992fb498d51f9ee6e70cbad9e083/



Fix ksdk mcu HAL - stopbit

Who changed what in which revision?

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