STM32. Использование I2C.

Огромное спасибо! Давно ждал примера использования шины I2C.

Попробую завтра изменить на
I2C_DeInit(I2C2);
I2C_Param.I2C_ClockSpeed = 100000;
I2C_Param.I2C_Mode = I2C_Mode_I2C;
I2C_Param.I2C_DutyCycle = I2C_DutyCycle_2;
I2C_Param.I2C_OwnAddress1 = 0×00;
I2C_Param.I2C_Ack = I2C_Ack_Enable;
I2C_Param.I2C_AcknowledgedAddress = I2C_AcknowledgedAddress_7bit;

I2C_Cmd(I2C2, ENABLE);
I2C_Init(I2C2, &I2C_Param);
I2C_AcknowledgeConfig(I2C2, ENABLE);
Вдруг что измениться. И какой из режимов для настройки скорости выбирать _2 или _16_9. Может микруха не успевает

отправляю на 0x41, но в отладке на DR идет 0x40 и так вне зависимости от адреса, то есть запись 0x(**-1). И устанавливается бит ADD0, но судя по исходникам, он должен устанавливаться только в случае приема, но не передачи.
void I2C_Send7bitAddress(I2C_TypeDef* I2Cx, uint8_t Address, uint8_t I2C_Direction)
{
/* Check the parameters */
assert_param(IS_I2C_ALL_PERIPH(I2Cx));
assert_param(IS_I2C_DIRECTION(I2C_Direction));
/* Test on the direction to set/reset the read/write bit */
if (I2C_Direction != I2C_Direction_Transmitter)
{
/* Set the address bit0 for read */
Address |= OAR1_ADD0_Set;
}
else
{
/* Reset the address bit0 for write */
Address &= OAR1_ADD0_Reset;
}
/* Send the address */
I2Cx->DR = Address;
}

I2C в режиме мастера полно. Сейчас разбираюсь как сделать с STM32F4 Discovery I2C slave,намного сложнее…И рабочых примеров в инт. почти нет…

Александр, выложите, пожалуйста, проект для TIC32.

Мне нужно было организовать связь по I2C между двумя stm32f407. Поэтому пришлось написать код для мастера и для маргариты) . Все функции полностью рабочие, я проверял.

I2C master stm32f4
Для МАСТЕРА!!!!!!!!!!

/*** Функции передачи и чтения информации по I2C.
****
**** WRITE_I2C( (1<<1), 0x20, 0xAA); //записываем в устройство с адресом 0х01 в регистр с адресом 0х20 байт 0хАА.
**** WRITE_MULTI_I2C( (2<<1), 0x70, 5); //записываем в устройство с адресом 0х02 в регистры с адресом 0х70…0х74 байты, записанные в массиве TxBuffer_I2C.
**** Data_I2C = READ_I2C( (1<<1), 0x26);//прочитаем из устройства с адресом 0х01 регистр с адресом 0х26.
**** READ_MULTI_I2C( (2< 10));
if (Timeout 10));
if (Timeout max_data_Tx) ) return 0; //если записали отправить 0 байт или больше максимального, то выход.

//ждем пока шина освободится.
Timeout = Timeout_for_I2C1;
while(I2C_GetFlagStatus(I2C1, I2C_FLAG_BUSY) && (Timeout– > 10));
if (Timeout<=10) {return 0; }///ошибка связи

//генерируем старт-бит.
I2C_GenerateSTART(I2C1, ENABLE);
//ждем флага "Start condition generated". (EV5).
Timeout = Timeout_for_I2C1;
while (!I2C_GetFlagStatus(I2C1, I2C_FLAG_SB))
{ if(Timeout!=0) Timeout–; else {return 0;} }

//посылаем адрес устройства подчиненному.
I2C_Send7bitAddress(I2C1, Slave_addr, I2C_Direction_Transmitter);
//ждем флага "Address sent". (EV6).
Timeout = Timeout_for_I2C1;
while (!I2C_GetFlagStatus(I2C1, I2C_FLAG_ADDR))
{ if(Timeout != 0) Timeout–; else {I2C_GenerateSTOP(I2C1, ENABLE); return 0;} }

I2C_ReadRegister(I2C1,I2C_Register_SR1); //убираем флаг для этого читаем SR1 и SR2. (cleared by software sequence).
I2C_ReadRegister(I2C1,I2C_Register_SR2);

//ждем флага "Data register empty". (EV8_1).
Timeout = Timeout_for_I2C1;
while (!I2C_GetFlagStatus(I2C1, I2C_FLAG_TXE))
{ if(Timeout != 0) Timeout–; else {return 0;} }

//посылаем адрес регистра подчиненному.
I2C_SendData(I2C1, Reg_addr);
//ждем флага "Data register empty". (EV8).
Timeout = Timeout_for_I2C1;
while ((!I2C_GetFlagStatus(I2C1, I2C_FLAG_TXE)) || (!I2C_GetFlagStatus(I2C1, I2C_FLAG_BTF)))
{ if(Timeout != 0) Timeout–; else {return 0;} }

//посылаем новые данные подчиненному.
for(cnt_i2c = 0; cnt_i2c max_data_Rx) ) return 0; //если записали прочитать 0 байт или больше максимального, то выход.

//ждем пока шина освободится.
Timeout = Timeout_for_I2C1;
while(I2C_GetFlagStatus(I2C1, I2C_FLAG_BUSY)&& (Timeout– > 10));
if (Timeout<=10) {return 0;}///ошибка связи

//генерируем старт-бит.
I2C_GenerateSTART(I2C1, ENABLE);
//ждем флага "Start condition generated". (EV5).
Timeout = Timeout_for_I2C1;
while (!I2C_GetFlagStatus(I2C1, I2C_FLAG_SB))
{ if(Timeout != 0) Timeout–; else {return 0;} }

I2C_AcknowledgeConfig(I2C1, ENABLE); //ACK выкл.

//посылаем адрес устройства подчиненному.
I2C_Send7bitAddress(I2C1, Slave_addr, I2C_Direction_Transmitter);
//ждем флага "Address sent". (EV6).
Timeout = Timeout_for_I2C1;
while (!I2C_GetFlagStatus(I2C1, I2C_FLAG_ADDR))
{ if(Timeout != 0) Timeout–; else {I2C_GenerateSTOP(I2C1, ENABLE); I2C_AcknowledgeConfig(I2C1, ENABLE); return 0;} }

I2C_ReadRegister(I2C1,I2C_Register_SR1); //убираем флаг для этого читаем SR1 и SR2. (cleared by software sequence).
I2C_ReadRegister(I2C1,I2C_Register_SR2);

//ждем флага "Data register empty". (EV8_1).
Timeout = Timeout_for_I2C1;
while (!I2C_GetFlagStatus(I2C1, I2C_FLAG_TXE))
{ if(Timeout != 0) Timeout–; else {return 0;} }

//посылаем адрес регистра подчиненному.
I2C_SendData(I2C1, Reg_addr);
//ждем флага "Data register empty". (EV8).
Timeout = Timeout_for_I2C1;
while ((!I2C_GetFlagStatus(I2C1, I2C_FLAG_TXE)) || (!I2C_GetFlagStatus(I2C1, I2C_FLAG_BTF)))
{ if(Timeout != 0) Timeout–; else {return 0;} }

//генерируем старт-бит второй раз.
I2C_GenerateSTART(I2C1, ENABLE);
//ждем флага "Start condition generated". (EV5).
Timeout = Timeout_for_I2C1;
while (!I2C_GetFlagStatus(I2C1, I2C_FLAG_SB))
{ if(Timeout != 0) Timeout–; else {return 0;} }

//посылаем адрес устройства подчиненному.
I2C_Send7bitAddress(I2C1, Slave_addr, I2C_Direction_Receiver);
//ждем флага "Address sent". (EV6).
Timeout = Timeout_for_I2C1;
while (!I2C_GetFlagStatus(I2C1, I2C_FLAG_ADDR))
{ if(Timeout != 0) Timeout–; else {return 0;} }

I2C_ReadRegister(I2C1,I2C_Register_SR1); //убираем флаг для этого читаем SR1 и SR2. (cleared by software sequence).
I2C_ReadRegister(I2C1,I2C_Register_SR2);

for(cnt_i2c = 0; cnt_i2c = Cnt)
{
// ACK disable
I2C_AcknowledgeConfig(I2C1, DISABLE);
//генерируем стоп-бит.
I2C_GenerateSTOP(I2C1, ENABLE);
}
//ждем флага “Data register not empty”. (EV7).
Timeout = Timeout_for_I2C1;
while (!I2C_GetFlagStatus(I2C1, I2C_FLAG_RXNE))
{ if(Timeout != 0) Timeout–;
else {return 0;} }
//чтение данных.
RxBuffer_I2C[cnt_i2c] = I2C_ReceiveData(I2C1);
}

//ждем флага “Data register not empty”. (EV7).
Timeout = Timeout_for_I2C1;
while (!I2C_GetFlagStatus(I2C1, I2C_FLAG_RXNE))
{ if(Timeout != 0) Timeout–; else {return 0;} }

//генерируем стоп-бит.
//I2C_GenerateSTOP(I2C1, ENABLE);

I2C_AcknowledgeConfig(I2C1, ENABLE); //ACK вкл.

return tmp;
}

I2C slave stm32f4
Для СЛЕЙВА!!!!!!!!!!

/*** Функции передачи и чтения информации по I2C.
**** все действия происходят по прерываниям.
****
*/

#include “stm32f4xx.h”
#include “stm32f4xx_i2c.h”
#include “I2C_slave.h”

GPIO_InitTypeDef GPIO_Init_I2C_Slave;
I2C_InitTypeDef I2C_Init_Slave;
NVIC_InitTypeDef NVIC_Init_I2C;

extern uint8_t GA_Adress; //адрес нашего устройства.

extern uint8_t TxBuffer[10]; //массив для передачи данных мастеру.
extern uint8_t Tx_Idx;
extern uint8_t RxBuffer[10]; //массив для приема данных от мастера.
extern uint8_t Rx_Idx;

//============================================================================
// Инициализация I2C в режиме Слейва.
//============================================================================
//I2C с кросс платой.
#define PORT_I2C_OUT GPIOB
#define I2C_SCL_OUT GPIO_Pin_10
#define I2C_SDA_OUT GPIO_Pin_11 //I2C интерфейс с кросс-платой.
#define I2C_READY GPIO_Pin_12 //флаг готовности I2C с буфера.
void Init_I2C_Slave(void)
{
RCC_AHB1PeriphClockCmd(RCC_AHB1Periph_GPIOB, ENABLE);
RCC_APB2PeriphClockCmd(RCC_APB2Periph_SYSCFG, ENABLE);

//ЦИФРОВЫЕ ВХОДЫ:
GPIO_Init_I2C_Slave.GPIO_Mode = GPIO_Mode_IN; //IN -вход цифровой //OUT -выход цифровой //AN-аналоговый //AF-альтернативные функции
GPIO_Init_I2C_Slave.GPIO_OType = GPIO_OType_PP ; //PP-с полным размахом //OD -открытый коллектор
GPIO_Init_I2C_Slave.GPIO_Speed = GPIO_Speed_2MHz; //100MHz 50MHz 25MHz 2MHz
GPIO_Init_I2C_Slave.GPIO_PuPd = GPIO_PuPd_NOPULL; //NOPULL-подтяжки нет // UP-подтяжка к плюсу //DOWN-подтяжка к земле
GPIO_Init_I2C_Slave.GPIO_Pin = I2C_READY;
GPIO_Init(PORT_I2C_OUT, &GPIO_Init_I2C_Slave);

//конфигурация выводов PB10-SCL, PB11-SDA.
GPIO_Init_I2C_Slave.GPIO_OType = GPIO_OType_OD;
GPIO_Init_I2C_Slave.GPIO_PuPd = GPIO_PuPd_NOPULL;
GPIO_Init_I2C_Slave.GPIO_Mode = GPIO_Mode_AF;
GPIO_Init_I2C_Slave.GPIO_Speed = GPIO_Speed_100MHz;
GPIO_Init_I2C_Slave.GPIO_Pin = I2C_SCL_OUT | I2C_SDA_OUT;
GPIO_Init(PORT_I2C_OUT, &GPIO_Init_I2C_Slave);

GPIO_PinAFConfig(PORT_I2C_OUT, GPIO_PinSource10, GPIO_AF_I2C2); //указываем альтернативные функции для пинов.
GPIO_PinAFConfig(PORT_I2C_OUT, GPIO_PinSource11, GPIO_AF_I2C2);

RCC_APB1PeriphClockCmd(RCC_APB1Periph_I2C2, ENABLE); // затактировали I2C2

//I2C_InitTypeDef I2C_InitStructure;
I2C_Init_Slave.I2C_ClockSpeed = 50000; //скорость 100 КГц.
I2C_Init_Slave.I2C_Mode = I2C_Mode_I2C;
I2C_Init_Slave.I2C_DutyCycle = I2C_DutyCycle_2;
I2C_Init_Slave.I2C_OwnAddress1 = (GA_Adress << 1); //адрес нашей платы (задаем географическую адресацию).
I2C_Init_Slave.I2C_Ack = I2C_Ack_Enable;
I2C_Init_Slave.I2C_AcknowledgedAddress = I2C_AcknowledgedAddress_7bit;
I2C_Init(I2C2, &I2C_Init_Slave);

//Configure the I2C event priority//
NVIC_Init_I2C.NVIC_IRQChannel = I2C2_EV_IRQn;
NVIC_Init_I2C.NVIC_IRQChannelPreemptionPriority = 1;
NVIC_Init_I2C.NVIC_IRQChannelSubPriority = 0;
NVIC_Init_I2C.NVIC_IRQChannelCmd = ENABLE;
NVIC_Init(&NVIC_Init_I2C);

//Configure I2C error interrupt to have the higher priority.
NVIC_Init_I2C.NVIC_IRQChannel = I2C2_ER_IRQn;
NVIC_Init(&NVIC_Init_I2C);

I2C_ITConfig(I2C2, I2C_IT_ERR, ENABLE);
I2C_ITConfig(I2C2, I2C_IT_EVT, ENABLE);
I2C_ITConfig(I2C2, I2C_IT_BUF, ENABLE);

I2C_Cmd(I2C2, ENABLE); // включили I2C2
I2C_AcknowledgeConfig(I2C2, ENABLE);
}

//===============================================================================
//===============================================================================
// ПРЕРЫВАНИЯ
//===============================================================================
//===============================================================================

//=============================================================================
// Прерывания по событию I2C2
//=============================================================================
//процедура записи у мастера: старт – посылаем адрес устройства – посылаем адрес регистра – посылаем новые данные – стоп.
//процедура чтения у мастера: старт – посылаем адрес устройства – посылаем адрес регистра – второй старт- посылаем адрес устройства – читаем данные – стоп.

//=========================== Slave Events ================================
void I2C2_EV_IRQHandler(void)
{
uint32_t event = 0;
event = I2C_GetLastEvent(I2C2); //возвращаем переменной оба статус регистра.

switch (event)
{
//EV1: ADDR=1, cleared by reading SR1 followed by reading SR2
//EV3_1: TxE=1, shift register empty,data register empty, write Data1 in DR.
case I2C_EVENT_SLAVE_TRANSMITTER_ADDRESS_MATCHED: //совпадение адреса.
Tx_Idx = 0;
I2C_ReadRegister(I2C2,I2C_Register_SR1); //убираем флаг ADDR для этого читаем SR1 и SR2. (cleared by software sequence).
I2C_ReadRegister(I2C2,I2C_Register_SR2);
I2C_SendData(I2C2, TxBuffer[Tx_Idx]); //передаем данные мастеру.
break;

//EV3: TxE=1, shift register not empty,data register empty, cleared by writing DR.
case I2C_EVENT_SLAVE_BYTE_TRANSMITTED:
Tx_Idx++;
I2C_SendData(I2C2, TxBuffer[Tx_Idx]);
//сделать ограничение на передачу: выдавать ошибку если мастер просит передачи, а байты уже закончились.
break;

//EV1: ADDR=1, cleared by reading SR1 followed by reading SR2.
case I2C_EVENT_SLAVE_RECEIVER_ADDRESS_MATCHED : //совпадение адреса.
Rx_Idx = 0x00;
I2C_ReadRegister(I2C2,I2C_Register_SR1); //убираем флаг ADDR для этого читаем SR1 и SR2. (cleared by software sequence).
I2C_ReadRegister(I2C2,I2C_Register_SR2);
break;

//EV2: RxNE=1, cleared by reading DR register.
case I2C_EVENT_SLAVE_BYTE_RECEIVED: //читаем данные от мастера.
RxBuffer[Rx_Idx++] = I2C_ReceiveData(I2C2);
break;

//EV4: STOPF=1, cleared by reading SR1 register followed by writing to the CR1 register.
case I2C_EVENT_SLAVE_STOP_DETECTED:
I2C_GetFlagStatus(I2C2, I2C_FLAG_STOPF); //STOPF (STOP detection) is cleared by software sequence: a read operation to I2C_SR1 register (I2C_GetFlagStatus())
I2C_Cmd(I2C2, ENABLE); //followed by a write operation to I2C_CR1 register (I2C_Cmd() to re-enable the I2C peripheral).
break;

default:
break;
}
}

//=========================== Slave Erors =================================
//Отслеживаем NACK.
void I2C2_ER_IRQHandler(void)
{
//EV3_2: AF=1, AF is cleared by writing '0' in AF bit of SR1 register.
if (I2C_GetITStatus(I2C2, I2C_IT_AF)) I2C_ClearITPendingBit(I2C2, I2C_IT_AF);
}

Aveal, для stm32f3 может есть где примеры для связи по i2c двух мконтроллеров? Или ссылки подскажете?

Приветствую! Прочитал, спасибо, и хорошо бы тот же пример для F303 дискавери на Кубе сгенерировать и проверить. Если автор выдаст такую статью, я буду готов его благодарить сколько попросит.