Создаём библиотеку I²C/TWI для микроконтроллера ATmega8

В этом уроке разберём аппаратный интерфейс TWI микроконтроллера ATmega8. TWI у AVR практически соответствует шине I²C. Мы рассмотрим основные регистры, настроим частоту шины и создадим собственную библиотеку для работы ATmega8 в режиме Master.

Выводы I²C/TWI ATmega8

  • PC4 — SDA: линия данных.
  • PC5 — SCL: линия тактового сигнала.
Важно: SDA и SCL должны иметь подтягивающие резисторы к положительному питанию. Для небольшой учебной схемы часто используются резисторы порядка 4,7 кОм, но окончательный номинал зависит от напряжения питания, частоты и ёмкости шины.

Регистр TWCR

Основное управление аппаратным TWI выполняется через регистр TWCR.

Регистр TWCR ATmega8
Регистр TWCR
  • TWINT — флаг завершения текущей операции TWI. Когда операция завершена, аппаратно устанавливается в 1. Для запуска следующей операции флаг необходимо очистить, причём у AVR это делается записью логической 1 в TWINT.
  • TWEA — разрешает формирование ACK микроконтроллером, когда ATmega8 работает приёмником.
  • TWSTA — формирует условие START.
  • TWSTO — формирует условие STOP.
  • TWWC — флаг конфликта записи. Устанавливается, если попытаться записать TWDR, когда регистр занят.
  • TWEN — включает аппаратный модуль TWI.
  • TWIE — разрешает аппаратное прерывание TWI. В нашей библиотеке используем обычный блокирующий режим, поэтому TWIE не требуется.

Регистр TWSR

В регистре TWSR находятся:

  • TWPS1 и TWPS0 — устанавливают предделитель генератора частоты TWI.
  • Биты TWS7...TWS3 содержат код состояния последней выполненной операции.

Для получения кода состояния удобно использовать:

uint8_t status = TWSR & 0xF8;

Два младших бита исключаются, потому что это биты предделителя, а не код состояния.

Предделитель TWI

TWPS1 TWPS0 Prescaler
0 0 1
0 1 4
1 0 16
1 1 64

Настройка скорости I²C

Частота SCL рассчитывается по формуле:

F_SCL =
F_CPU /
(
    16 +
    2 * TWBR * Prescaler
)

Отсюда значение TWBR:

TWBR =
(
    (F_CPU / F_SCL) - 16
)
/
(
    2 * Prescaler
)

Для нашего примера:

F_CPU = 4 000 000 Гц

F_SCL = 100 000 Гц

Prescaler = 1


TWBR =
((4 000 000 / 100 000) - 16) / 2

TWBR =
(40 - 16) / 2

TWBR = 12
Для ATmega8 с частотой 4 МГц и шины I²C 100 кГц устанавливаем:

TWBR = 12
TWPS1 = 0
TWPS0 = 0

Регистр TWDR

Регистр TWDR используется для непосредственной передачи и приёма данных.

При передаче в него записывается очередной байт. При приёме из него считывается полученный байт.

Почему старую библиотеку стоит улучшить

В простом варианте ожидание выглядело так:

while (!(TWCR & (1 << TWINT)))
{
    ;
}

Если ведомое устройство неисправно, отсутствует питание, оборвана линия или возникла другая проблема, программа потенциально может застрять в ожидании.

Поэтому в новой библиотеке:

• используем тайм-аут;
• проверяем код состояния TWI;
• различаем ACK и NACK;
• используем 7-битный адрес устройства;
• функция сообщает вызывающей программе, успешно ли прошла операция.

Заголовочный файл i2c.h

#ifndef I2C_H_
#define I2C_H_


#include <avr/io.h>
#include <stdint.h>


/* ----------------------------------------------------------
   Частота шины
   ---------------------------------------------------------- */

#ifndef F_CPU
#define F_CPU 4000000UL
#endif


#define I2C_SCL_FREQ   100000UL


/* ----------------------------------------------------------
   Направление передачи
   ---------------------------------------------------------- */

#define I2C_WRITE   0
#define I2C_READ    1


/* ----------------------------------------------------------
   Коды результата
   ---------------------------------------------------------- */

typedef enum
{
    I2C_OK = 0,

    I2C_ERROR_TIMEOUT,

    I2C_ERROR_START,

    I2C_ERROR_ADDRESS,

    I2C_ERROR_DATA,

    I2C_ERROR_READ

} I2C_Result;


/* ----------------------------------------------------------
   Основные функции
   ---------------------------------------------------------- */

void I2C_Init(void);

I2C_Result I2C_Start(
    uint8_t address,
    uint8_t direction
);

void I2C_Stop(void);

I2C_Result I2C_Write(
    uint8_t data
);

I2C_Result I2C_ReadACK(
    uint8_t *data
);

I2C_Result I2C_ReadNACK(
    uint8_t *data
);


/* ----------------------------------------------------------
   Готовые функции высокого уровня
   ---------------------------------------------------------- */

I2C_Result I2C_WriteByte(
    uint8_t address,
    uint8_t data
);

I2C_Result I2C_WriteRegister(
    uint8_t address,
    uint8_t reg,
    uint8_t data
);

I2C_Result I2C_ReadRegister(
    uint8_t address,
    uint8_t reg,
    uint8_t *data
);


#endif /* I2C_H_ */

Рабочий файл i2c.c

#include "i2c.h"

#include <util/twi.h>


/* ----------------------------------------------------------
   Защита от бесконечного ожидания

   Это программный счётчик,
   а не точное время.
   ---------------------------------------------------------- */

#define I2C_TIMEOUT   60000UL


/* ----------------------------------------------------------
   Ожидание TWINT
   ---------------------------------------------------------- */

static uint8_t I2C_Wait(void)
{
    uint32_t timeout = I2C_TIMEOUT;


    while (!(TWCR & (1 << TWINT)))
    {
        if (--timeout == 0)
        {
            return 0;
        }
    }


    return 1;
}


/* ----------------------------------------------------------
   Получить статус TWI
   ---------------------------------------------------------- */

static uint8_t I2C_Status(void)
{
    return TWSR & 0xF8;
}


/* ----------------------------------------------------------
   Инициализация
   ---------------------------------------------------------- */

void I2C_Init(void)
{
    /*
        Prescaler = 1

        TWPS1 = 0
        TWPS0 = 0
    */
    TWSR &=
        ~((1 << TWPS1) |
          (1 << TWPS0));


    /*
        Для:
        F_CPU = 4 МГц
        SCL = 100 кГц

        TWBR = 12
    */
    TWBR =
        (uint8_t)
        (
            (
                (F_CPU / I2C_SCL_FREQ)
                - 16UL
            )
            / 2UL
        );


    /*
        Включаем TWI
    */
    TWCR =
        (1 << TWEN);
}


/* ----------------------------------------------------------
   START + адрес устройства

   address —
   обычный 7-битный адрес.

   Например:
   адрес устройства 0x68
   передаём именно 0x68,
   а не 0xD0.
   ---------------------------------------------------------- */

I2C_Result I2C_Start(
    uint8_t address,
    uint8_t direction
)
{
    uint8_t status;


    /*
        Формируем START
    */
    TWCR =
        (1 << TWINT) |
        (1 << TWSTA) |
        (1 << TWEN);


    if (!I2C_Wait())
    {
        return I2C_ERROR_TIMEOUT;
    }


    status = I2C_Status();


    /*
        Допустим обычный START
        или повторный START.
    */
    if ((status != TW_START) &&
        (status != TW_REP_START))
    {
        return I2C_ERROR_START;
    }


    /*
        Формируем байт адреса:

        bits 7...1 = адрес
        bit 0      = R/W
    */
    TWDR =
        (address << 1) |
        (direction & 0x01);


    /*
        Запускаем передачу адреса
    */
    TWCR =
        (1 << TWINT) |
        (1 << TWEN);


    if (!I2C_Wait())
    {
        return I2C_ERROR_TIMEOUT;
    }


    status = I2C_Status();


    /*
        Проверяем ACK адреса.
    */
    if (direction == I2C_WRITE)
    {
        if (status != TW_MT_SLA_ACK)
        {
            return I2C_ERROR_ADDRESS;
        }
    }
    else
    {
        if (status != TW_MR_SLA_ACK)
        {
            return I2C_ERROR_ADDRESS;
        }
    }


    return I2C_OK;
}


/* ----------------------------------------------------------
   STOP
   ---------------------------------------------------------- */

void I2C_Stop(void)
{
    TWCR =
        (1 << TWINT) |
        (1 << TWSTO) |
        (1 << TWEN);
}


/* ----------------------------------------------------------
   Передача одного байта
   ---------------------------------------------------------- */

I2C_Result I2C_Write(
    uint8_t data
)
{
    TWDR = data;


    TWCR =
        (1 << TWINT) |
        (1 << TWEN);


    if (!I2C_Wait())
    {
        return I2C_ERROR_TIMEOUT;
    }


    /*
        Данные переданы,
        ведомый ответил ACK.
    */
    if (I2C_Status() !=
        TW_MT_DATA_ACK)
    {
        return I2C_ERROR_DATA;
    }


    return I2C_OK;
}


/* ----------------------------------------------------------
   Чтение байта + ACK

   Используется,
   если после этого байта
   хотим принять ещё один.
   ---------------------------------------------------------- */

I2C_Result I2C_ReadACK(
    uint8_t *data
)
{
    TWCR =
        (1 << TWINT) |
        (1 << TWEN) |
        (1 << TWEA);


    if (!I2C_Wait())
    {
        return I2C_ERROR_TIMEOUT;
    }


    if (I2C_Status() !=
        TW_MR_DATA_ACK)
    {
        return I2C_ERROR_READ;
    }


    *data = TWDR;


    return I2C_OK;
}


/* ----------------------------------------------------------
   Чтение последнего байта + NACK

   Последний принятый байт
   должен завершаться NACK.
   ---------------------------------------------------------- */

I2C_Result I2C_ReadNACK(
    uint8_t *data
)
{
    TWCR =
        (1 << TWINT) |
        (1 << TWEN);


    if (!I2C_Wait())
    {
        return I2C_ERROR_TIMEOUT;
    }


    if (I2C_Status() !=
        TW_MR_DATA_NACK)
    {
        return I2C_ERROR_READ;
    }


    *data = TWDR;


    return I2C_OK;
}


/* ----------------------------------------------------------
   Отправка одного байта устройству
   ---------------------------------------------------------- */

I2C_Result I2C_WriteByte(
    uint8_t address,
    uint8_t data
)
{
    I2C_Result result;


    result =
        I2C_Start(
            address,
            I2C_WRITE
        );


    if (result != I2C_OK)
    {
        I2C_Stop();

        return result;
    }


    result =
        I2C_Write(data);


    I2C_Stop();


    return result;
}


/* ----------------------------------------------------------
   Запись регистра устройства

   Пример:

   устройство 0x68
   регистр    0x10
   данные     0x55
   ---------------------------------------------------------- */

I2C_Result I2C_WriteRegister(
    uint8_t address,
    uint8_t reg,
    uint8_t data
)
{
    I2C_Result result;


    result =
        I2C_Start(
            address,
            I2C_WRITE
        );


    if (result != I2C_OK)
    {
        I2C_Stop();

        return result;
    }


    result =
        I2C_Write(reg);


    if (result != I2C_OK)
    {
        I2C_Stop();

        return result;
    }


    result =
        I2C_Write(data);


    I2C_Stop();


    return result;
}


/* ----------------------------------------------------------
   Чтение регистра устройства
   ---------------------------------------------------------- */

I2C_Result I2C_ReadRegister(
    uint8_t address,
    uint8_t reg,
    uint8_t *data
)
{
    I2C_Result result;


    /*
        Сначала передаём
        номер регистра.
    */
    result =
        I2C_Start(
            address,
            I2C_WRITE
        );


    if (result != I2C_OK)
    {
        I2C_Stop();

        return result;
    }


    result =
        I2C_Write(reg);


    if (result != I2C_OK)
    {
        I2C_Stop();

        return result;
    }


    /*
        Повторный START.

        Теперь переключаемся
        в режим чтения.
    */
    result =
        I2C_Start(
            address,
            I2C_READ
        );


    if (result != I2C_OK)
    {
        I2C_Stop();

        return result;
    }


    /*
        Читаем один последний байт.

        Поэтому завершаем NACK.
    */
    result =
        I2C_ReadNACK(data);


    I2C_Stop();


    return result;
}

Почему адрес сдвигается влево

В библиотеку передаём обычный 7-битный адрес устройства.

Например, если в документации адрес устройства указан как:

0x68

именно это значение передаём функции:

I2C_Start(0x68, I2C_WRITE);

Библиотека сама формирует адресный байт:

TWDR =
    (address << 1) |
    direction;
При записи:

0x68 << 1 = 0xD0

При чтении:

0xD0 | 1 = 0xD1

Таким образом, 0x68 — это адрес устройства, а 0xD0 / 0xD1 — уже полные адресные байты с битом R/W.

Пример записи данных

#define F_CPU 4000000UL

#include <avr/io.h>
#include <util/delay.h>

#include "i2c.h"


int main(void)
{
    I2C_Init();


    while (1)
    {
        /*
            Устройство:
            адрес 0x68

            Регистр:
            0x10

            Записываем:
            0x55
        */

        I2C_WriteRegister(
            0x68,
            0x10,
            0x55
        );


        _delay_ms(1000);
    }
}

Пример чтения регистра

#define F_CPU 4000000UL

#include <avr/io.h>

#include "i2c.h"


int main(void)
{
    uint8_t value;


    I2C_Init();


    while (1)
    {
        if (
            I2C_ReadRegister(
                0x68,
                0x10,
                &value
            )
            ==
            I2C_OK
        )
        {
            /*
                В value находится
                принятый байт.
            */
        }
        else
        {
            /*
                Ошибка обмена I2C.
            */
        }
    }
}

Последний байт при чтении

При чтении нескольких байтов Master подтверждает промежуточные байты сигналом ACK.

Поэтому для них используется:

I2C_ReadACK(&data);

Последний необходимый байт принимается с NACK:

I2C_ReadNACK(&data);

После этого Master формирует STOP.

Что мы получили

Теперь наша библиотека умеет:

• настраивать аппаратный TWI;
• формировать START и повторный START;
• формировать STOP;
• передавать адрес ведомого устройства;
• передавать байты;
• принимать байты с ACK и NACK;
• проверять ответ ведомого;
• проверять состояние аппаратного TWI;
• выходить по ошибке, а не оставлять микроконтроллер навечно в цикле ожидания.
Важно для реального проекта: отсутствие ACK нельзя игнорировать. Если ведомое устройство не отвечает, функция должна вернуть ошибку, а основная программа уже решает, что делать дальше: повторить запрос, сообщить об ошибке, перезапустить устройство или выполнить другое восстановление.