Золотовский Д.В. Учебный курс для новичков по микроконтроллерам AVR. Часть 1
Подождите немного. Документ загружается.
скорости и текущую команду. А в OutBuff показания датчиков и, например, показания с
АЦП висящем на блоке аккумуляторов. И при обмене данными с головным контроллером
он сливает ему OutBuff, а от него принимает InBuff
•
i2c_Buffer– Это выходной буфер мастера. Если наш контроллер в качестве мастера
ломанется куда-нибудь, то он сюда загрузит всю необходимую инфу и пнет ее слейву.
•
i2c_ByteCount — важный параметр. Число передаваемых байт мастером. Можно сделать
константой (проще, но не гибче) я сделал переменной, чтобы гонять данные туды сюды.
•
i2c_SlaveAddress — Адрес подчиненного. То куда мы будем обращаться в режиме мастера.
•
i2c_PageAddress — Буфер адреса страниц. Если вы помните режим обмена со всякими
ЕЕПРОМ, то для чтения произвольного байта мы должны сначала записать в ЕЕПРОМ
адрес этого байта, потом, вызвав ReStart считать данные. Вот тут у нас буфер где хранится
адрес страницы для чтения ЕЕПРОМ. Сделан он буфером для универсальности. Т.к. у
некоторых ЕЕПРОМ адрес страницы двухбайтный, а у некоторых однобайтный. Более того,
есть куча устройств которые выглядят с точки зрения мастера как EEPROM, но не являются
ими. Например часы RTC или цифровые акселерометры. У них, обычно, адрес страницы
однобайтный.
•
i2c_PageAddrCount — Число байт в адресе страницы для текущего Slave
Указатели выхода из автомата. У меня выход из автомата сделан на функцию, адрес
которой передается при вызове Master обмена или при включении Slave ожидания. Их три
вида.
•
IIC_F MasterOutFunc — выход из автомата для мастера
•
IIC_F ErrorOutFunc — выход из автомата в резултате ошибки в режиме Master
•
IIC_F SlaveOutFunc — выход из автомата в режиме Slave
Обычно я первые два обьединяю под одну функцию, а там уже проверяю на ошибки. Но,
для оптимальности, можно и разделить их. Причем сам выход записан в исходнике в
форме макроса. Что позволяет, не лазая в дебрях автомата подправить в хидере этот
макрос на что угодно. Например, на выставление флажка, если у вас не диспетчер, а
флаговый автомат.
Режимы
•
i2c_sarp (Start-Addr_R-Read-Stop) Это режим простого чтения. Например из слейва или из
епрома с текущего адреса
•
i2c_sawp (Start-Addr_W-Write-Stop) Это режим простой записи. В том числе и запись с
адресом страницы.
•
i2c_sawsarp ( Start-Addr_W-WrPageAdr-rStart-Addr_R-Read-Stop) Это режим с
предварительной записью текущего адреса страницы. Например, через нее из EEPROM
читают данные.
Коды ошибок
•
i2c_Err_NO All Right! — Все окей, передача успешна.
•
i2c_ERR_NA — Device No Answer Слейв не отвечает. Т.к. либо занят, либо его нет на линии.
•
i2c_ERR_LP — Low Priority нас перехватили собственным адресом, либо мы проиграли
арбитраж
•
i2c_ERR_NK — Received NACK. End Transmittion. Был получен NACK. Бывает и так.
•
i2c_ERR_BF — BUS FAIL Автобус сломался. И этим все сказано. Можно попробовать сделать
переинициализацию шины
Также есть флаги состояний
•
i2c_Interrupted — передачу мастера прервали запросом собственного адреса от другого
мастера
•
i2c_Busy – Передатчик занят другим процессом отправки/приема, руками не трогать.
…
— А есть любовь к доминированию или, наоборот, подчинению. Это называется
садомазохизм.
— Слайды давай, слайды!
…
Слайды
А сейчас, дабы не быть голословным, я покажу вам извращенную групповую садомазо
оргию с участием одного мазохиста и двух садо-мазохистов.
Итак, у нас есть одна большая крова… эмм шина IIC. На ней висят два контроллера и одна
EEPROM.
Посмотреть крупней
Контроллер1 получет из космоса бредовую мысль (байт по UART) и жестко
домогась(master) до EEPROM(slave) забивает эту мысль ей в башку по адресу 0×00FF. Но
его не отпускает. Он решает поделиться мыслью и с Контроллером2. Но не просто так, а с
подвывертом, будто это не ему в голову пришла бредовая мысль. Контроллер1(Master)
ломится к Контроллеру2(Slave) и говорит ему — чувак, там у EEPROM по адресу 0×00FF
в бошке засела умная мысль. Нуко достань! Контроллер2, получив адрес (0×00FF) жесто
домогается (Master) до EEPROM(slave) вбивает ей в мозги адрес, потом вытягивает
бредовую мысль (тот самый байт). Додумывает к ней подробностей (прибавляет 1) и
ломится(Master) со своей находкой к Контроллеру1(slave). Контроллер1, внемлет второму,
принимает его бредовые идеи, и отправляет их обратно в космос (по UART). Все
успокаиваются до новой посылки из космоса.
Причем все, кроме забитой еепромки, страдают манией и если кто то не отвечает —
начинают настойчиво до него долбиться до тех пор, пока получат желаемое. Епромка же
отличается тормознутостью. Умная мысль вгоняет ее в такой ступор (а шо ви хотели, flash
медленная штука), что она целых 20мс не отвечает на домогания контроллера2. А он же
ломится до тех пор, пока не ответят.
Код
Инициализация Master режима заключается лишь в настройке скорости передачи, да
включении.
1
2
3
4
5
6
7
8
void Init_i2c(void) // Настройка режима мастера
{
i2c_PORT |= 1<<i2c_SCL|1<<i2c_SDA; // Включим подтяжку на ноги, вдруг
юзер на резисторы пожмотился
i2c_DDR &=~(1<<i2c_SCL|1<<i2c_SDA);
TWBR = 0x80; // Настроим битрейт
TWSR = 0x00;
}
Для Slave режима надо задать параметры ведомого. Адреса, а также точки выхода. Ну и
включить передатчик соответствующим образом. Чтобы принимал свой адрес и отдавал
ACK. Разумеется должны быть разрешены прерывания
1
2
3
4
5
6
7
8
9
10
11
12
13
void Init_Slave_i2c(IIC_F Addr) // Настройка режима слейва (если
нужно)
{
TWAR = i2c_MasterAddress; // Внесем в регистр свой адрес, на который
будем отзываться.
// 1 в нулевом бите означает, что мы
отзываемся на широковещательные пакеты
SlaveOutFunc = Addr; // Присвоим указателю выхода по слейву
функцию выхода
TWCR = 0<<TWSTA|
0<<TWSTO|
0<<TWINT|
1<<TWEA|
1<<TWEN|
1<<TWIE; // Включаем агрегат и начинаем слушать шину.
}
Код библиотеки лучше смотреть в исходниках примеров, т.к. он слишком громоздок. Хотя
и прост. Т.к. там нет ни одного замороченного алгоритма, а самое сложное что там есть —
проверка битов режима. Т.к. все остальное делает автомат TWI.
IIC_ultimate.c
IIC_ultimate.h
Опишу лучше работу с ней на примере управляющей логики нашей садомазо группы
Контроллер 1
Он начинает первый.
Его main функция выглядит вообще просто:
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
int main(void)
{
InitAll(); // Инициализируем периферию
Init_i2c(); // Запускаем и конфигурируем i2c
Init_Slave_i2c(&SlaveControl); // Настраиваем событие выхода при
сработке как Slave
/*
WorkIndex=0; // Лог с начала
WorkLog[WorkIndex]=1; // Записываем метку старта
WorkIndex++;
*/
InitRTOS(); // Инициализируем ядро
RunRTOS(); // Старт ядра.
_delay_ms(1); // Небольшая выдержка, чтобы второй
контроллер успел встать на адресацию
while(1) // Главный цикл диспетчера
{
wdt_reset(); // Сброс собачьего таймера
TaskManager(); // Вызов диспетчера
}
return 0;
}
Как видим — нет ничего кроме инициализации. Никакие задачи не страртуют. Экшн
начинается когда приходит байт по UART
1
2
3
4
5
ISR(USART_RXC_vect)
{
UART_RX = UDR; // Сгребаем принятый байт в буфер
SetTask(StartWrite2EPP); // Запускаем процесс записи в ЕЕПРОМ.
}
Сохраняется принятый байт и через диспетчер запускается процедура отправки байта в
EEPROM
1
2
3
4
5
6
7
void StartWrite2EPP(void)
{
if (!i2c_eep_WriteByte(0xA0,0x00FF,UART_RX,&Writed2EEP)) // Если байт не
записался
{
SetTimerTask(StartWrite2EPP,50); // Повторить
попытку через 50мс
}
}
Функция i2c_eep_WriteByte отдает 1 если шина была свободна и процесс пошел. Если
шина была занята обменом с другими участниками групповухи, то повтор попытки.
Просто перезагрузка задачи через таймер. В параметрах функции у нас адрес EEPROM на
шине i2c (0xA0) и адрес страницы по которой мы будем писать данные (0х00FF),
передаваемый байт из UART_RX, а также адрес процедуры выхода из автомата
(Writed2EEP).
Когда автомат отработает все, мы туда и попадем
1
2
3
4
5
6
7
8
9
10
11
12
13
void Writed2EEP(void)
{
i2c_Do &= i2c_Free; // Освобождаем шину
if(i2c_Do & (i2c_ERR_NA|i2c_ERR_BF)) // Если запись не удалась
{
SetTimerTask(StartWrite2EPP,20); // повторяем попытку
}
else
{
SetTask(SendAddrToSlave); // Если все ок, то идем на следующий
} // Пункт задания - передача данных
слейву 2
}
Тут все просто. Проверим, что все ок и переходим к другому Slave девайсу.
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
// Обращение к SLAVE контроллеру
void SendAddrToSlave(void)
{
if (i2c_Do & i2c_Busy) // Если передатчик занят
{
SetTimerTask(SendAddrToSlave,100); // То повторить через 100мс
return;
}
i2c_index = 0; // Сброс индекса
i2c_ByteCount = 2; // Шлем два байта
i2c_SlaveAddress = 0xB0; // Адрес контроллера 0xB0
i2c_Buffer[0] = 0x00; // Те самые два байта, что мы шлем
подчиненному
i2c_Buffer[1] = 0xFF;
i2c_Do = i2c_sawp; // Режим = простая запись, адрес+два
байта данных
MasterOutFunc = &SendedAddrToSlave; // Точка выхода из автомата если все
хорошо
ErrorOutFunc = &SendedAddrToSlave; // И если все плохо.
TWCR = 1<<TWSTA|
0<<TWSTO|
1<<TWINT|
0<<TWEA|
1<<TWEN|
1<<TWIE; // Поехали!
i2c_Do |= i2c_Busy;
// Шина занята!
}
Как я и описывал в разделе опций, мы тут полностью определяем параметры будущей
передачи. Сколько байт передаем (i2c_ByteCount) кому передаем (i2c_SlaveAddress), что
передаем (i2c_Buffer), а также задаем режим передачи - простая запись ( i2c_sawp) . И
точку выхода (SendedAddrToSlave).
Когда автомат отработает, то мы вываливаемся в принимающую задачу.
1
2
3
4
5
6
7
8
9
void SendedAddrToSlave(void)
{
i2c_Do &= i2c_Free; // Освобождаем шину
if(i2c_Do & (i2c_ERR_NA|i2c_ERR_BF)) // Если адресат нас не ус
лышал
или был сбой на линии
{
SetTimerTask(SendAddrToSlave,20); // Повторить попытку
}
}
Тут все просто. Главное проверить, что все прошло хорошо. И перезапустить в случае
косяка.
Остается подчиненная часть. Тут все еще проще. Только одна функция, точнее точка
выхода из автомата:
1
2
3
4
5
void SlaveControl(void)
{
i2c_Do &= i2c_Free; // Освобождаем шину
UDR = i2c_InBuff[0]; // Выгружаем принятый байт
}
Освобождаем шину и загребаем байт из приемного буфера.
Контроллер 2
Тут тоже все подобным образом, но в другом порядке. Тон тут задает не прерывание
UART, а приход адресных байтов от Контроллера 1.
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
int main(void)
{
InitAll(); // Инициализируем периферию
Init_i2c(); // Настроили мастер режим
Init_Slave_i2c(&SlaveControl); // Настроили слейв режим
/*
WorkLog[WorkIndex]=1;
WorkIndex++;
*/
InitRTOS(); // Инициализируем ядро
RunRTOS(); // Старт ядра.
while(1) // Главный цикл диспетчера
{
wdt_reset(); // Сброс собачьего таймера
TaskManager(); // Вызов диспетчера
}
22
23
24
return 0;
}
Только настроили точку выхода из TWI (SlaveControl)
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
void SlaveControl(void) // Точка выхода из автомата слейва
{
i2c_Do &= i2c_Free; // Осовобождаем шину
SetTask(ReadEEPROM); // Готовим запись в ЕЕПРОМ
}
Байты получены. Можно запускать чтение из EEPROM.
void ReadEEPROM(void) // Читаем из еепром
{
u16 Addr;
Addr = (i2c_InBuff[0]<<8)|(i2c_InBuff[1]); // Адрес
возьмем из буфера слейва
if (!i2c_eep_ReadByte(0xA0,Addr,1,&EepromReaded) ) // Читаем
{
SetTimerTask(ReadEEPROM,50); // Если
процесс не пошел (шина занята), то повтор через 50мс.
}
}
Все аналогичным же образом. Разница лишь в том, что тут мы читаем из памяти. И точка
выхода у нас другая (EepromReaded)
1
2
3
4
5
6
7
8
9
10
11
12
13
14
void EepromReaded(void) // Была попытка чтения
{
i2c_Do &= i2c_Free; // Освобождаем шину
if(i2c_Do & (i2c_ERR_NA|i2c_ERR_BF)) // Ошибки при четнии
были?
{
SetTimerTask(ReadEEPROM,20); // Тогда повтор
}
else
{
ReadedByte = i2c_Buffer[0];
// Иначе считаный байт
из буфера копируем в переменную
SetTask(SendByteToSlave); // И запускаем отсылку ее
контроллеру 1
}
}
Когда EEPROM будет успешно прочитана, то мы загоним задачу отправки байта
контроллеру 1 (SendByteToSlave) . Вот эта задача:
1
2
3
4
5
6
7
8
void SendByteToSlave(void) // Возвращаем контроллеру 1
его байт
{
if (i2c_Do & i2c_Busy) // Если шина занята
{
SetTimerTask(SendByteToSlave,100); // То повторяем попытку
return;
}
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
i2c_index = 0; // Сброс индекса
i2c_ByteCount = 1; // Шлем 1 байт
i2c_SlaveAddress = 0x32; // Адрес контроллера 1 на
шине
i2c_Buffer[0] = ReadedByte+1; // Загружаем в буфер число,
увеличив его на 1.
// +1 чтобы понять, что число
прошло через МК и было обработано
i2c_Do = i2c_sawp; // Режим - простая запись
MasterOutFunc = &SendedByteToSlave; // Задаем точку выхода
ErrorOutFunc = &SendedByteToSlave;
TWCR = 1<<TWSTA|
0<<TWSTO|
1<<TWINT|
0<<TWEA|
1<<TWEN|
1<<TWIE; // Поехали!
i2c_Do |= i2c_Busy; // Флаг занятости поставим
}
Все полностью по аналогии.
1
2
3
4
5
6
7
8
9
10
void SendedByteToSlave(void) // Байт был послан
{
i2c_Do &= i2c_Free; // Осовбождаем шину
if(i2c_Do & (i2c_ERR_NA|i2c_ERR_BF)) // Если посылка не удалась
{
SetTimerTask(SendByteToSlave,20); // Пробуем еще раз.
}
}
И все. Тупо ждем следующего экшна. Т.е .в принцип работы заложена основа, что у нас
обмен делается посредством связки из двух функций. Запускающей и выходящей.
EEPROM
Поскольку ей в мозги не заглянешь, то покажу тут содержимое библиотечки, через
которую мы к ней стучались. Тоже накорябал на днях. Если IIC_ultimate.c это своего рода
полуфабрикат, то это уже ближе к финальному продукту, для непосредственной работы.
Там все очень и очень просто, смотрите сами:
1
2
3
4
5
6
7
#include <i2c_AT24C_EEP.h>
#define HI(X) (X>>8) // Макросы разделения слова на байты
#define LO(X) (X & 0xFF)
u08 i2c_eep_WriteByte(u08 SAddr,u16 Addr, u08 Byte, IIC_F WhatDo)
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
{
if (i2c_Do & i2c_Busy) return 0; // Если шина занята, то возвращаем 0
i2c_index = 0; // Зануляем индексы
i2c_ByteCount = 3;
// Запись байта всего делается за три
байта.
// Два байта --
адрес страницы и байт
данных.
i2c_SlaveAddress = SAddr; // Какой именно EEPROM будем слать.
i2c_Buffer[0] = HI(Addr); // В буфер кладем адрес страницы
i2c_Buffer[1] = LO(Addr); // Старший и младший байты, по
очереди. Старший впереди
i2c_Buffer[2] = Byte; // Ну и байт данных
i2c_Do = i2c_sawp; // Режим простой записи
MasterOutFunc = WhatDo; // Точка выхода которую нам
передадут
ErrorOutFunc = WhatDo;
TWCR = 1<<TWSTA|0<<TWSTO|1<<TWINT|0<<TWEA|1<<TWEN|1<<TWIE; // ПЦ!
i2c_Do |= i2c_Busy; // Занимаем шину
return 1; // Возвращаем 1, мол процесс пошел.
}
// Это чтение из EEPROM Тут чуточку сложней
u08 i2c_eep_ReadByte(u08 SAddr, u16 Addr, u08 ByteNumber, IIC_F WhatDo)
{
if (i2c_Do & i2c_Busy) return 0; // Если шина занята
i2c_index = 0; // Индексы в ноль
i2c_ByteCount = ByteNumber; // Число считываемых байт
i2c_SlaveAddress = SAddr; // Адрес EEPROM на шине IIC
i2c_PageAddress[0] = HI(Addr); // На этот раз грузим адрес страницы
i2c_PageAddress[1] = LO(Addr); // В специальный буфер
i2c_PageAddrIndex = 0; // Обнуляем индексы
i2c_PageAddrCount = 2; // Адрес страницы из 2 байт
i2c_Do = i2c_sawsarp; // Режим чтения с заносом адреса
MasterOutFunc = WhatDo; // Точка выхода
ErrorOutFunc = WhatDo;
TWCR = 1<<TWSTA|0<<TWSTO|1<<TWINT|0<<TWEA|1<<TWEN|1<<TWIE; //ПЦ!
i2c_Do |= i2c_Busy;
// Заняли шину, чтобы никто не мешал.
return 1; // Вернули 1, мол процесс пошел.
}
Вот так вот.
Железо
Чтобы такое по быстрому слабать на коленке я заюзал свою маленькую прелесть… Дада
вы уже догадались. Pinboard. Там есть почти все необходимое для нашей вакханалии. Два
контроллера и макетное поле в которое мы засадим микросхему памяти.
Один контроллер, правда, это JTAG адаптер. Но это не страшно. На борту есть FTBB
программатор, поэтому нам ничего не стоит прошить его тем же бутлоадером, превратив в
рядовой контроллер, подобный главному (обратно вернуть просто, достаточно запустить
батник зашивки кода JTAG см. документацию по самопрограммированию)
Подключите FTBB выводы к порту прошивки JTAG контроллера и выполните батник
PBSelf16.cmd после чего контроллер также начнет отвечать на бутлоадер. Надо будет
только подсоединить его к порту джамперами JTAG (отключив переключатели UART).
Да, для прошивки обеих контроллеров вы тумблерочками этими туда-сюда нащелкаетесь
:)
Потом снимите шлейфик и пользуйтесь им как главным, т.е. через бутлоадер. А чтобы
вернуть JTAG адаптер на место то просто оденьте шлейф обратно, и запустите батник
PBSelfJT.cmd и прошивка JTAG’a будет возвращена на место.
Также, в некоторых версиях возможно придется перепаять один резистор на плате. Дело в
том, что изначально JTAG контроллер планировался как отладочный JTAG интерфейс и
не более того. Однако куда интересней когда мы его можем использовать в любых целях.
Но осознание этого пришло несколько позже :(. Так что в старых ревизиях версии 1.1 на
линии SCL у нижней меги стоит резистор в 100ом, что слишком мало для подтяжки. Нога
может не придавить и шина работать не будет. Его надо аккуратно выпаять и впаять туда
резистор на 10к. Отпаивается smd резистор довольно просто — кладем на него паяльник
плашмя, так чтобы прогреть его весь, да сдвигаем зубочисткой. В новых версиях там уже
везде идут другие номиналы.
Резисторы которые надо заменить показаны на картинке: