Полное руководство по I2C в STM32: подключение, настройка, отладка

// Объявление структуры для конфигурации I2C
I2C_HandleTypeDef hi2c1;

void I2C_Init(void)
{
// Настройка тактирования GPIO
__HAL_RCC_GPIOB_CLK_ENABLE();

// Настройка тактирования I2C1
__HAL_RCC_I2C1_CLK_ENABLE();

// Настройка пинов для I2C1 (PB6 – SCL, PB7 – SDA)
GPIO_InitTypeDef GPIO_InitStruct = {0};
GPIO_InitStruct.Pin = GPIO_PIN_6 | GPIO_PIN_7;
GPIO_InitStruct.Mode = GPIO_MODE_AF_OD; // Открытый коллектор
GPIO_InitStruct.Pull = GPIO_PULLUP;
GPIO_InitStruct.Speed = GPIO_SPEED_FREQ_HIGH;
HAL_GPIO_Init(GPIOB, &GPIO_InitStruct);

// Настройка параметров I2C
hi2c1.Instance = I2C1;
hi2c1.Init.ClockSpeed = 100000; // 100 кГц
hi2c1.Init.DutyCycle = I2C_DUTYCYCLE_2; // Скважность 50%
hi2c1.Init.OwnAddress1 = 0x00; // Адрес в режиме ведомого
hi2c1.Init.AddressingMode = I2C_ADDRESSINGMODE_7BIT;
hi2c1.Init.DualAddressMode = I2C_DUALADDRESS_DISABLE;
hi2c1.Init.OwnAddress2 = 0x00;
hi2c1.Init.GeneralCallMode = I2C_GENERALCALL_DISABLE;
hi2c1.Init.NoStretchMode = I2C_NOSTRETCH_DISABLE;

// Инициализация I2C
if(HAL_I2C_Init(&hi2c1) != HAL_OK)
{
Error_Handler();
}
}

void I2C_Init_Registers(void)
{
// Включение тактирования портов и периферии
RCC->APB2ENR |= RCC_APB2ENR_IOPBEN; // Включаем тактирование GPIOB
RCC->APB1ENR |= RCC_APB1ENR_I2C1EN; // Включаем тактирование I2C1

// Настройка пинов в режим альтернативной функции с открытым коллектором
// PB6 (SCL), PB7 (SDA)
GPIOB->CRL &= ~(GPIO_CRL_MODE6 | GPIO_CRL_CNF6 | GPIO_CRL_MODE7 | GPIO_CRL_CNF7);
GPIOB->CRL |= GPIO_CRL_MODE6 | GPIO_CRL_CNF6; // PB6 как выход, альтернативная функция с открытым коллектором
GPIOB->CRL |= GPIO_CRL_MODE7 | GPIO_CRL_CNF7; // PB7 как выход, альтернативная функция с открытым коллектором

// Сброс I2C
I2C1->CR1 |= I2C_CR1_SWRST;
I2C1->CR1 &= ~I2C_CR1_SWRST;

// Настройка частоты APB1
uint32_t pclk1 = 36000000; // Предполагаем PCLK1 = 36 МГц
I2C1->CR2 = (pclk1 / 1000000); // Устанавливаем частоту в МГц

// Настройка скорости I2C
// CCR = PCLK1 / (I2C_FREQ * 2) для режима Sm с 50% скважностью
I2C1->CCR = (pclk1 / (100000 * 2));

// Настройка времени нарастания (TRISE)
I2C1->TRISE = ((pclk1 / 1000000) + 1);

// Включение I2C
I2C1->CR1 |= I2C_CR1_PE;
}

// Запись одного байта по адресу устройства
HAL_StatusTypeDef I2C_WriteByte(uint8_t device_address, uint8_t data)
{
return HAL_I2C_Master_Transmit(&hi2c1, device_address << 1, &data, 1, 100);
}

// Запись нескольких байтов по адресу устройства
HAL_StatusTypeDef I2C_WriteData(uint8_t device_address, uint8_t *data, uint16_t size)
{
return HAL_I2C_Master_Transmit(&hi2c1, device_address << 1, data, size, 100);
}

// Запись данных в конкретный регистр устройства (типичный сценарий)
HAL_StatusTypeDef I2C_WriteRegister(uint8_t device_address, uint8_t reg_address, uint8_t data)
{
uint8_t buffer[2];
buffer[0] = reg_address;
buffer[1] = data;
return HAL_I2C_Master_Transmit(&hi2c1, device_address << 1, buffer, 2, 100);
}

// Чтение одного байта от устройства
HAL_StatusTypeDef I2C_ReadByte(uint8_t device_address, uint8_t *data)
{
return HAL_I2C_Master_Receive(&hi2c1, device_address << 1, data, 1, 100);
}

// Чтение нескольких байтов от устройства
HAL_StatusTypeDef I2C_ReadData(uint8_t device_address, uint8_t *data, uint16_t size)
{
return HAL_I2C_Master_Receive(&hi2c1, device_address << 1, data, size, 100);
}

// Чтение из конкретного регистра устройства
HAL_StatusTypeDef I2C_ReadRegister(uint8_t device_address, uint8_t reg_address, uint8_t *data)
{
// Сначала отправляем адрес регистра
HAL_StatusTypeDef status;
status = HAL_I2C_Master_Transmit(&hi2c1, device_address << 1, &reg_address, 1, 100);
if (status != HAL_OK)
return status;

// Затем читаем данные
return HAL_I2C_Master_Receive(&hi2c1, device_address << 1, data, 1, 100);
}

// Отправка START-бита
void I2C_Start(void)
{
I2C1->CR1 |= I2C_CR1_START;
while (!(I2C1->SR1 & I2C_SR1_SB));
}

// Отправка адреса устройства (запись)
void I2C_SendAddress_Write(uint8_t address)
{
I2C1->DR = address << 1; // Сдвиг влево для записи (LSB = 0)
while (!(I2C1->SR1 & I2C_SR1_ADDR)); // Ждем подтверждения адреса
uint32_t temp = I2C1->SR2; // Чтение SR2 для сброса флага ADDR
}

// Отправка адреса устройства (чтение)
void I2C_SendAddress_Read(uint8_t address)
{
I2C1->DR = (address << 1) | 0x01; // Сдвиг влево и установка бита чтения (LSB = 1)
while (!(I2C1->SR1 & I2C_SR1_ADDR));
uint32_t temp = I2C1->SR2;
}

// Отправка данных
void I2C_SendData(uint8_t data)
{
while (!(I2C1->SR1 & I2C_SR1_TXE)); // Ожидаем, пока буфер передачи не станет пустым
I2C1->DR = data;
while (!(I2C1->SR1 & I2C_SR1_BTF)); // Ожидаем завершения передачи байта
}

// Чтение данных с подтверждением (для множественного чтения)
uint8_t I2C_ReadDataACK(void)
{
I2C1->CR1 |= I2C_CR1_ACK; // Установка бита подтверждения
while (!(I2C1->SR1 & I2C_SR1_RXNE)); // Ожидание получения данных
return I2C1->DR;
}

// Чтение данных без подтверждения (для последнего байта)
uint8_t I2C_ReadDataNACK(void)
{
I2C1->CR1 &= ~I2C_CR1_ACK; // Сброс бита подтверждения
while (!(I2C1->SR1 & I2C_SR1_RXNE));
return I2C1->DR;
}

// Отправка STOP-бита
void I2C_Stop(void)
{
I2C1->CR1 |= I2C_CR1_STOP;
}

// Запись регистра через прямой доступ
void I2C_Register_Write(uint8_t device_addr, uint8_t reg_addr, uint8_t data)
{
I2C_Start();
I2C_SendAddress_Write(device_addr);
I2C_SendData(reg_addr);
I2C_SendData(data);
I2C_Stop();
}

// Чтение регистра через прямой доступ
uint8_t I2C_Register_Read(uint8_t device_addr, uint8_t reg_addr)
{
uint8_t data;

I2C_Start();
I2C_SendAddress_Write(device_addr);
I2C_SendData(reg_addr);

I2C_Start(); // Repeated start
I2C_SendAddress_Read(device_addr);
data = I2C_ReadDataNACK();
I2C_Stop();

return data;
}

#define BME280_ADDR 0x76 // Адрес по умолчанию (может быть 0x77)

// Регистры BME280
#define BME280_REG_ID 0xD0
#define BME280_REG_CTRL_HUM 0xF2
#define BME280_REG_CTRL_MEAS 0xF4
#define BME280_REG_CONFIG 0xF5
#define BME280_REG_PRESS_MSB 0xF7
#define BME280_REG_PRESS_LSB 0xF8
#define BME280_REG_PRESS_XLSB 0xF9
#define BME280_REG_TEMP_MSB 0xFA
#define BME280_REG_TEMP_LSB 0xFB
#define BME280_REG_TEMP_XLSB 0xFC
#define BME280_REG_HUM_MSB 0xFD
#define BME280_REG_HUM_LSB 0xFE

// Инициализация BME280
HAL_StatusTypeDef BME280_Init(void)
{
uint8_t chipId;
HAL_StatusTypeDef status;

// Проверяем ID датчика
status = I2C_ReadRegister(BME280_ADDR, BME280_REG_ID, &chipId);
if (status != HAL_OK || chipId != 0x60)
return HAL_ERROR;

// Настройка режима измерения влажности (oversampling x1)
status = I2C_WriteRegister(BME280_ADDR, BME280_REG_CTRL_HUM, 0x01);
if (status != HAL_OK) return status;

// Настройка режима измерения температуры и давления (oversampling x1) и нормальный режим
status = I2C_WriteRegister(BME280_ADDR, BME280_REG_CTRL_MEAS, 0x27);
if (status != HAL_OK) return status;

// Настройка фильтра и standby duration
status = I2C_WriteRegister(BME280_ADDR, BME280_REG_CONFIG, 0x00);
return status;
}

// Чтение необработанных данных температуры
int32_t BME280_ReadRawTemperature(void)
{
uint8_t data[3];
int32_t raw_temp;

// Чтение 3 байт из регистра температуры
I2C_ReadRegister(BME280_ADDR, BME280_REG_TEMP_MSB, &data[0]);
I2C_ReadRegister(BME280_ADDR, BME280_REG_TEMP_LSB, &data[1]);
I2C_ReadRegister(BME280_ADDR, BME280_REG_TEMP_XLSB, &data[2]);

// Комбинирование байтов в 20-битное значение
raw_temp = ((int32_t)data[0] << 12) | ((int32_t)data[1] << 4) | ((int32_t)data[2] >> 4);

return raw_temp;
}

// Для конвертации в градусы Цельсия требуются калибровочные коэффициенты
// и соответствующая формула из даташита BME280

#define SSD1306_ADDR 0x3C // Адрес по умолчанию

// Команды SSD1306
#define SSD1306_COMMAND 0x00
#define SSD1306_DATA 0x40
#define SSD1306_DISPLAYOFF 0xAE
#define SSD1306_DISPLAYON 0xAF

// Отправка команды на SSD1306
HAL_StatusTypeDef SSD1306_Command(uint8_t command)
{
uint8_t buffer[2] = {SSD1306_COMMAND, command};
return HAL_I2C_Master_Transmit(&hi2c1, SSD1306_ADDR << 1, buffer, 2, 100);
}

// Отправка данных на SSD1306
HAL_StatusTypeDef SSD1306_Data(uint8_t *data, uint16_t size)
{
uint8_t *buffer = malloc(size + 1);
if (buffer == NULL) return HAL_ERROR;

buffer[0] = SSD1306_DATA;
memcpy(buffer + 1, data, size);

HAL_StatusTypeDef status = HAL_I2C_Master_Transmit(&hi2c1, SSD1306_ADDR << 1, buffer, size + 1, 100);
free(buffer);

return status;
}

// Инициализация SSD1306 (для дисплея 128x64)
void SSD1306_Init(void)
{
// Рекомендуется пауза перед инициализацией
HAL_Delay(100);

// Последовательность инициализации
SSD1306_Command(0xAE); // Display off
SSD1306_Command(0xD5); // Set display clock division ratio/oscillator frequency
SSD1306_Command(0x80); // Recommended value
SSD1306_Command(0xA8); // Set multiplex ratio
SSD1306_Command(0x3F); // 1/64 duty
SSD1306_Command(0xD3); // Set display offset
SSD1306_Command(0x00); // No offset
SSD1306_Command(0x40); // Set start line address
SSD1306_Command(0x8D); // Set charge pump setting
SSD1306_Command(0x14); // Enable charge pump
SSD1306_Command(0x20); // Set memory addressing mode
SSD1306_Command(0x00); // Horizontal addressing mode
SSD1306_Command(0xA1); // Set segment re-map
SSD1306_Command(0xC8); // Set COM output scan direction
SSD1306_Command(0xDA); // Set COM pins hardware configuration
SSD1306_Command(0x12); // Alternative COM pin config
SSD1306_Command(0x81); // Set contrast control
SSD1306_Command(0xCF); // Medium contrast
SSD1306_Command(0xD9); // Set pre-charge period
SSD1306_Command(0xF1); // Default
SSD1306_Command(0xDB); // Set VCOMH deselect level
SSD1306_Command(0x40); // Default
SSD1306_Command(0xA4); // Entire display ON, output follows RAM content
SSD1306_Command(0xA6); // Set normal display (not inverse)
SSD1306_Command(0xAF); // Display on
}

#define MPU6050_ADDR 0x68 // Адрес по умолчанию
#define MPU6050_WHO_AM_I 0x75 // Регистр идентификации устройства
#define MPU6050_PWR_MGMT_1 0x6B // Регистр управления питанием
#define MPU6050_ACCEL_XOUT_H 0x3B // Начальный регистр данных акселерометра

// Инициализация MPU6050
HAL_StatusTypeDef MPU6050_Init(void)
{
uint8_t check;
HAL_StatusTypeDef status;

// Проверка идентификатора устройства
status = I2C_ReadRegister(MPU6050_ADDR, MPU6050_WHO_AM_I, &check);
if (status != HAL_OK || check != 0x68) // MPU6050 должен вернуть 0x68
return HAL_ERROR;

// Выход из режима сна
status = I2C_WriteRegister(MPU6050_ADDR, MPU6050_PWR_MGMT_1, 0x00);
return status;
}

// Структура для данных акселерометра
typedef struct {
int16_t x;
int16_t y;
int16_t z;
} MPU6050_AccelData;

// Чтение данных акселерометра
HAL_StatusTypeDef MPU6050_ReadAccel(MPU6050_AccelData *accel)
{
uint8_t data[6];
HAL_StatusTypeDef status;

// Чтение 6 байт данных начиная с регистра ACCEL_XOUT_H
status = HAL_I2C_Mem_Read(&hi2c1, MPU6050_ADDR << 1, MPU6050_ACCEL_XOUT_H, 1, data, 6, 100);
if (status != HAL_OK) return status;

// Комбинирование байтов в 16-битные значения
accel->x = (int16_t)(data[0] << 8 | data[1]);
accel->y = (int16_t)(data[2] << 8 | data[3]);
accel->z = (int16_t)(data[4] << 8 | data[5]);

return HAL_OK;
}

// Сканирование всех доступных устройств на шине I2C
void I2C_ScanBus(void)
{
printf("Сканирование I2C-шины...\n");
uint8_t devices_found = 0;

for (uint8_t address = 1; address < 128; address++)
{
// Попытка отправки адреса и проверки ACK
if (HAL_I2C_IsDeviceReady(&hi2c1, address << 1, 3, 10) == HAL_OK)
{
printf("Устройство найдено по адресу 0x%02X\n", address);
devices_found++;
}
}

if (devices_found == 0)
printf("Устройств на шине не обнаружено!\n");
else
printf("Всего найдено устройств: %d\n", devices_found);
}

void I2C_BusRecovery(void)
{
GPIO_InitTypeDef GPIO_InitStruct;

// Отключаем I2C
I2C1->CR1 &= ~I2C_CR1_PE;

// Настраиваем SCL и SDA как выходы с открытым стоком
GPIO_InitStruct.Pin = GPIO_PIN_6 | GPIO_PIN_7; // PB6=SCL, PB7=SDA
GPIO_InitStruct.Mode = GPIO_MODE_OUTPUT_OD;
GPIO_InitStruct.Pull = GPIO_PULLUP;
GPIO_InitStruct.Speed = GPIO_SPEED_FREQ_HIGH;
HAL_GPIO_Init(GPIOB, &GPIO_InitStruct);

// Генерируем 9 тактов на SCL для освобождения шины
for (int i = 0; i < 9; i++)
{
// SCL high
HAL_GPIO_WritePin(GPIOB, GPIO_PIN_6, GPIO_PIN_SET);
HAL_Delay(1);
// SCL low
HAL_GPIO_WritePin(GPIOB, GPIO_PIN_6, GPIO_PIN_RESET);
HAL_Delay(1);
}

// Генерируем STOP-условие: SDA с низкого на высокий при высоком SCL
HAL_GPIO_WritePin(GPIOB, GPIO_PIN_7, GPIO_PIN_RESET); // SDA low
HAL_Delay(1);
HAL_GPIO_WritePin(GPIOB, GPIO_PIN_6, GPIO_PIN_SET); // SCL high
HAL_Delay(1);
HAL_GPIO_WritePin(GPIOB, GPIO_PIN_7, GPIO_PIN_SET); // SDA high
HAL_Delay(1);

// Возвращаем пины в режим I2C
__HAL_RCC_I2C1_FORCE_RESET();
HAL_Delay(1);
__HAL_RCC_I2C1_RELEASE_RESET();

// Переинициализируем I2C
I2C_Init();
}

// Получение статуса ошибки I2C
void I2C_ErrorAnalysis(void)
{
uint32_t error = HAL_I2C_GetError(&hi2c1);

if (error & HAL_I2C_ERROR_BERR)
printf("Bus error – неправильное START или STOP условие\n");

if (error & HAL_I2C_ERROR_ARLO)
printf("Arbitration lost – потеря арбитража в мультимастерном режиме\n");

if (error & HAL_I2C_ERROR_AF)
printf("Acknowledge failure – устройство не отвечает или отвергает данные\n");

if (error & HAL_I2C_ERROR_OVR)
printf("Overrun/Underrun – потеря данных из-за переполнения или опустошения\n");

if (error & HAL_I2C_ERROR_TIMEOUT)
printf("Timeout – превышение времени ожидания ответа\n");
}