Создаём библиотеку I²C/TWI для микроконтроллера ATmega8
Выводы I²C/TWI ATmega8
- PC4 — SDA: линия данных.
- PC5 — SCL: линия тактового сигнала.
Регистр TWCR
Основное управление аппаратным TWI выполняется через регистр 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
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;
• выходить по ошибке, а не оставлять микроконтроллер навечно в цикле ожидания.