Интерфейс I2C для ATmega328(Без библиотек, только Си и регистры). На примере подключения акселерометра MPU6050

О чём будет и для кого

I2C (IIC - Inter-Integrated Circuit) - двухпроводной последовательный интерфейс, который позволяет общаться датчикам, сенсорам, микроконтроллерам между собой.

Максимальная скорость передачи зависит конкретно от устройств, которые используют данный интерфейс. Но стандарт это 100 и 400kHz. Некоторые устройства поддерживают и большие скорости, Fast Mode Plus (Fm+): до 1 МГц (1000 кГц) и High-Speed Mode (Hs-Mode): до 3.4 МГц (3400 кГц)

Данная статья не о Wire.h или I2Cdev.h библиотеках. Эта статья о регистрах, простой побитовой математики и логики общения с периферией через I2C интерфейс.

Про I2C в целом, теория

Роли в I2C, процесс общения

Так принято называть устройства, где есть некоторая контролирующая схема. Тот кто контролирует, называется Мастером, а тот кто подчиняется Рабом.

В этой статье я затрону только два режима для мастера (передатчик и приёмник), так как датчики я ещё не в силах сделать и тем более запрограммировать. Но, думаю поняв суть работы I2C протокола можно легко разобраться с тем как работать и в режиме раба приёмника и раба передатчика.

Настройка битрейта

// Устанавливаем бит масштаба в 1. Мне не нужно слишком малая частота общения TWSR = 0x00; // Это формула (стр. 180 стр 21.5.2) для просчёта бит-рейта между Master и Slave 400kHz TWBR = (F_CPU - TARGET_FREQUENCY * 16)/TARGET_FREQUENCY*2*pow(4,TWSR);

Кроме того, что TWSR используется для выяснения появившихся ошибок и результата выполнения определённых шагов в коммуникации через I2C, он ещё и устанавливает бит масштаба.

Режим мастера передатчика

1. Start - Условие начала передачи
2. Stop - Условие конца передачи
3. Adr  - Адрес раба
4. RAdr - Адрес регистра
5. +W - Бит записи
6. Ack - Сигнал принят
7. Data - Данные

Дальше будет очень много регистров и побитовой математики. Описание всех необходимых регистров можно прочитать в главе по ссылке, а побитовая математика будет объяснена в этой главе постепенно.

Так же после каждого шага коммуникации мастера с рабом возможно проверять регистр TWSR на код состояния передачи. Все коды и то как это можно сделать описано в этой главе.

Побитовое ИЛИ проверяет два операнда. Если хотя бы один из них равен 1, то результатом побитового ИЛИ будет 1

Помнишь я говорил, что общение между рабом и мастером происходит пакетами по 8 бит каждый? Так вот, следующий пакет, согласно интерфейсу I2C, это адрес раба + режим чтения/записи. Так как режим чтения займёт 1 бит, для адреса останется 7 битов, или 127 возможных адресов для рабов. Ну это на тот случай, если ты гадал, почему именно 127 адресов поддерживает I2C.

// Сохраняем данные в специальный регистр TWDR = data; // Обновляем контрольный регистр TWCR = ((1 << TWINT) | (1 << TWEN));

Сигнал Repeated Start позволяет переключиться между режимами или между рабами, которых может быть до 127, не отпуская при этом SDA линию.

Режим мастера/ведущего приёмника

1. Start - Условие начала передачи
2. Stop - Условие конца передачи
3. Adr - Адрес раба
4. RAdr - Адрес регистра
5. +W - Бит записи
6. +R - Бит чтения
7. Ack - Сигнал принят
8. NAck - Сигнал не принят
9. Data - Данные

Дальше будет очень много регистров и побитовой математики. Описание всех необходимых регистров можно прочитать в этой главе, а побитовая математика будет объяснена в этой главе.

Так же после каждого шага коммуникации мастера с рабом возможно проверять регистр TWSR на код состояния передачи. Все коды и то как это можно сделать описано в этой главе.

// Сохраняем адрес целевого регистра у раба TWDR = addres_of_register; // Обновляем контрольный регистр, отправляем байт с адресом регистра TWCR = ((1 << TWINT) | (1 << TWEN)); // Ждем Ack сигнал while (!(TWCR & (1 << TWINT))); // 0x28 это успешный статус отправки данных с подтверждением от Slave (бит ACK в конце) if ((TWSR & 0xF8) != 0x28){ // Обрабатываем ошибку отправки данных }

TWDR = (0x68 << 1) | 1; // Говорим МК, чтобы он отправил данные из TWI Data Register т.е. из TWDR TWCR = (1 << TWINT) | (1 << TWEN);

Я, опять же, немного забегаю вперёд, но проверка на то, были ли отправленные данные происходит путём чтения регистра TWCR. А если быть более конкретным, когда бит TWINT убирается (1 -> 0), внутренней логикой схемы TWI(I2C). Именно поэтому мы всегда его должны проставлять, когда делаем какой-нибудь шаг в процессе общения по I2C. Что схема могла его потом убрать.

// Если это последний байт который ведущий хочет получить // То настраиваем контрольный регистр соответственно TWCR = (1<<TWINT) | (1<<TWEN); // Ожидаем пока не произойдёт сдвиг в регистре данных while (!(TWCR & (1<<TWINT))); //Теперь можно получить данные и, например, сохранить их в SRAM uint8_t byte = TWDR;

Коды ответов

Данные коды соответствуют только семейству микроконтроллеров от Arduino. То есть ATmega8/32/328 например. По этому, если у тебя другой микроконтроллер посмотри документацию к нему и там должны быть указаны уже кода для тебя.

Используемы регистры на стороне Мастера (ATmega328P)

Более подробно о флагах в каждом регистре можно ознакомиться в документации. Что я и настоятельно рекомендую. Стр 198. глава 21.9.

Про подключение рабов через I2C

Кстати, эта схема валидна если ты работаешь с уже распаянным на отдельной плате чипом. Но если ты работаешь с голым чипом, то нужно ещё подключить подтягивающий резистор ну хотя бы на 4.7 кОм к 5V, SCL и SDA линиям. Если этого не сделать, ничего не заработает.

Давай пообщаемся, или то как работать с периферией через I2C

Подготовка (Заголовки и структуры)

#include <avr/io.h> #include <stdio.h> #include <stdbool.h> #include <math.h> #include "UARTMessanger.h"

typedef struct { int16_t accel_x; int16_t accel_y; int16_t accel_z; int16_t temp; int16_t gyro_x; int16_t gyro_y; int16_t gyro_z; } MPU6050; MPU6050 getData(){ MPU6050 data; return data; }

Настраиваем протокол I2C + немного абстракций

void setup(){ // Настраиваем скорость общения с приёмником (т.е. на машине, на которой пишется код) uart_init(57600); // Инициализируем I2C интерфейс i2c_init(); // MODE: Запись одного байта в регистр 0x6B (У MPU6500 это Power Manager 1 регистр) i2c_start(MPU_6050_W_ADDR); i2c_write(0x6B); // Это означает что мы передвинем один бит в лево на 3 позиции. Т.е Было 0000 0001 стало 0000 1000 i2c_write(0x00 | 1 << 3); // Под 3 подразумевается бит управления температурным датчиком. Допустим нам он не нужен, поэтому проставим 1 на соответ. место // MODE: Чтение одного байта из регистра 0x75 (У MPU6500 это WHO_AM_i регистр) i2c_start(MPU_6050_W_ADDR); i2c_write(0x75); i2c_start(MPU_6050_R_ADDR); uint8_t byte = i2c_read(true); sprintf(uart_buffer, "WHO_AM_I(0x75) - 0x%x\n", byte); uart_transmit_string(uart_buffer); }

Про небольшую надстройку над I2C интерфейсом (абстракция)

void i2c_init() { // Устанавливаем бит масштаба в 1. Мне не нужно слишком малая частота общения TWSR = 0x00; // Это формула (стр. 180 стр 21.5.2) для просчёта бит-рейта между Master и Slave 400kHz TWBR = (F_CPU - TARGET_FREQUENCY * 16)/TARGET_FREQUENCY*2*pow(4,TWSR); // Активируем TWI TWCR = (1<<TWEN); }

uint8_t i2c_start(uint8_t address) { // 1. Посылаем сигнал о том, что готовы начать общение с периферией, START сигнал // (1000 0000 | 0010 0000 | 0000 0100) -> Это означает что мы начинаем передачу данных START. TW сам уберёт флаг TWINT и в итоге будет 0010 0100 (0х24) TWCR = ((1<<TWINT)|(1<<TWSTA)|(1<<TWEN)); // !(0010 0100 & 1000 0000) -> Это означает что TW будет посылать сигнал на SCL до тех пор пока влаг TWINT не проставлен в регистре TWCR while (!(TWCR & (1<<TWINT))); // Происходит проверка кода статуса отправки байта (данных) // 0х08 Означает что ведущее устройство успешно послал сигнал START и готов продолжать общение // 0х10 Означает что ведущее устр. успешно послал сигнал REPEATED START и готов продолжать общение if ((TWSR & 0xF8) != 0x08 && (TWSR & 0xF8) != 0x10){ sprintf(uart_buffer, "Init START or REPEATED START error: 0x%x\n", TWSR & 0xF8); uart_transmit_string(uart_buffer); } // 2. Записываем адрес устройства в соответствующий регистр TWDR // Так как адреса 7-битные, необходимо произвести сдвиг на один бит и записать в конец 0 // То есть было 0110 1000 после шифта стало 1101 0000 // 0 говорит о том, что мы будем записывать (write mode) TWDR = address; // Говорим МК, чтобы он отправил данные из TWI Data Register т.е. из TWDR TWCR = (1 << TWINT) | (1 << TWEN); while (!(TWCR & (1 << TWINT))); // Происходит проверка кода статуса отправки байта (данных). Так как это первая отправка, отправляется адрес Slave // 0x18 Означает, что адрес с битом записи были отправлены успешно и Slave добавил ACK бит в конец // 0x40 Означает, что адрес с битом чтения были отправлены успешно и Slave добавил ACK бит в конец if ((TWSR & 0xF8) != 0x18 && (TWSR & 0xF8) != 0x40){// 0x18 - SLA+W | 0x40 - SLA+R ACK sprintf(uart_buffer, "Send address error: 0x%x\n", TWSR & 0xF8); uart_transmit_string(uart_buffer); } return TWSR & 0xF8; }

uint8_t i2c_write(uint8_t data){ // Сохраняем данные в специальный регистр TWDR = data; // Отправляем данные, поставив соответствующие флаги TWINT и TWEN TWCR = (1<<TWINT) | (1<<TWEN); // Ждём пока не CPU не сбросит флаг TWINT, что значит данные отправлены while (!(TWCR & (1<<TWINT))); // 0x28 это успешный статус отправки данных с подтверждением от Slave (бит ACK в конце) if ((TWSR & 0xF8) != 0x28){ sprintf(uart_buffer, "Data write error: 0x%x\n", TWSR & 0xF8); uart_transmit_string(uart_buffer); } return 1; }

uint8_t i2c_read(bool isLast) { // Указываем, что мы хотим читать данные дальше if (!isLast) TWCR = (1<<TWINT) | (1<<TWEN) | (1<<TWEA); // Иначе, в последнем чтении необходимо убрать бит TWEA, чтобы сказать (сообщить Slave Transmitter) что мы закончили чтение else TWCR = (1<<TWINT) | (1<<TWEN); // Ожидаем пока МК сбросит наш TWINT флаг, что значит данные были получены while (!(TWCR & (1<<TWINT))); // 0x50 это успешный статус полученных данных с подтверждением от Slave (бит ACK в конце) // 0x58 это успешный статус полученных данных без подтверждения от Slave (бит NACK в конце) if (((TWSR & 0xF8) != 0x50) && ((TWSR & 0xF8) != 0x58)){ sprintf(uart_buffer, "Data read error: 0x%x\n", TWSR & 0xF8); uart_transmit_string(uart_buffer); } // Возвращаем полученные данные return TWDR; }

Заметь как я использую статусы ответов. По сути все эти проверки как бы говорят, что если кроме указанных статусов будет ещё что-то, то возникла какая-то ошибка и мы входим в процедуру, где и выводим по UART интерфейсу сообщение об ошибке.

Разберём подробнее инициализирующий код

#define MPU_6050_W_ADDR 0xD0 // (0x68 << 1) | 0 (Write) #define MPU_6050_R_ADDR 0xD1 // (0x68 << 1) | 1 (Read) #define TARGET_FREQUENCY 400000L // Максимальная скорость обмена данными может быть 400kHz

// MODE: Чтение одного байта из регистра 0x75 (У MPU6500 это WHO_AM_i регистр) i2c_start(MPU_6050_W_ADDR); i2c_write(0x75); i2c_start(MPU_6050_R_ADDR); uint8_t byte = i2c_read(true); sprintf(uart_buffer, "WHO_AM_I(0x75) - 0x%x\n", byte); uart_transmit_string(uart_buffer);

Ты, скорее всего, получишь не 0x68, но 0x70. Почему? Потому что у тебя не MPU6050 а MPU6500, немного улучшенная версия датчика, у которого минимум отличий в регистрах с MPU6050. Просто знай, что это нормально и всё с твоим I2C в порядке.

Прочтём данные с датчика

void loop(){ // MODE: Чтение последовательности байтов, начиная с 0x3B регистра и заканчивая 0x48 (Итого 14 байтов) // 0x3B это регистр акселерометра по X оси. Дальше идут accel_y(H,L), accel_z(H,L), temperature(H,L), gyro_x(H,L), gyro_y(H,L), gyro_z(H,L) // NOTE: Значения хранятся в 2 байтах, старший - H и младший - L // Итого 7 датчиков по два байта каждый i2c_start(MPU_6050_W_ADDR); // <- START условие i2c_write(0x3B); // Собираем данные с 7 датчиков i2c_start(MPU_6050_R_ADDR); // <- REPEATED START условие MPU6050 data = getData(); // Просто вывожу данные sprintf(uart_buffer, "accel_x=%d\taccel_y=%d\taccel_z=%d\t", data.accel_x, data.accel_y, data.accel_z); uart_transmit_string(uart_buffer); sprintf(uart_buffer, "temp=%d\t", data.temp); uart_transmit_string(uart_buffer); sprintf(uart_buffer, "gyro_x=%d\tgyro_y=%d\tgyro_z=%d\n", data.gyro_x, data.gyro_y, data.gyro_z); uart_transmit_string(uart_buffer); // Отпускаю шину. После этого данные с датчиков обновятся, и на следующем цикле будут новые. // Не отпустив шину, чип MPU6500 не будет обновлять данные в своих регистрах i2c_stop(); }

А почему бы не отправить сигнал REPEATED START и не повторить чтение? Так можно сделать, но данные на датчиках не обновятся и будут висеть старые значения.

MPU6050 getData(){ MPU6050 data; // NOTE: Для того чтобы правильно сохранить данные с регисров MPU6500 // необходимо их поместить в 2 байта. // Для этого прочитав 1 байт с шины, мы помещаем его в int16_t используя побитовый сдвиг в лево // То есть было [0000 0000 1001 1111] а стало [1001 1111 0000 0000] // Accel X data.accel_x = (int16_t)((i2c_read(false) << 8) | i2c_read(false)); // Accel Y data.accel_y = (int16_t)((i2c_read(false) << 8) | i2c_read(false)); // Accel Z data.accel_z = (int16_t)((i2c_read(false) << 8) | i2c_read(false)); // temp data.temp = (int16_t)((i2c_read(false) << 8) | i2c_read(false)); // Gyro X data.gyro_x = (int16_t)((i2c_read(false) << 8) | i2c_read(false)); // Gyro Y data.gyro_y = (int16_t)((i2c_read(false) << 8) | i2c_read(false)); // Gyro Z // Заметь, читая последний байт мастеру необходимо отправить NACK сигнал, чтобы уведомить // раба о завершении чтения. Иначе мы не сможем инициировать сигналы START или в моём случае REPEATED START data.gyro_z = (int16_t)((i2c_read(false) << 8) | i2c_read(true)); return data; }

В заключение