Золотовский Д.В. Учебный курс для новичков по микроконтроллерам AVR. Часть 1

Подождите немного. Документ загружается.

Конечный автомат, висящий на прерывании сравнения состоит из двух

таблиц с данными:

#define MaxServo 8 // Число сервомашинок

u08 servo_state=0; // Состояние конечного автомата.

u08 ServoPortState[MaxServo+1]; // Значение порта которое надо вывести

u08 ServoNextOCR[MaxServo+1]; // Время вывода значения

ServoPortState — содержит биты которые надо сбросить при каждом

временном интервале. То есть если у нас два сервоканала имеют одинаковую

длительность импульсов (т.е. сервы выставлены в одно и то же положение),

то они будут сброшены одновременно. За один проход.

ServoNextOCR — таблица длительностей сигналов. Тут в порядке

возрастания собраны длительности отчетных интервалов.

И код автомата:

ISR(TIMER0_COMP_vect) // Прерывание по совпадению

{

if (servo_state) // Если не нулевое состояние то

{

OCR0 = ServoNextOCR[servo_state]; // В регистр сравнения кладем

следующий интервал

PORTA &= ~ServoPortState[servo_state]; // Сбрасываем биты в порту, в

соответствии с маской в массиве масок.

servo_state++; // Увеличиваем состояние

автомата

if (OCR0 == 0xFF) // Если значение

сравнения равно FF значит это заглушка

{ // И мы достигли конца таблицы.

И пора обнулить автомат

servo_state = 0; // Выставляем нулевое состояние.

TCNT0 = 105; // Программируем задержку в

20мс (на предделителе 1024)

TCCR0 &= 0b11111000; // Сбрасываем предделитель

таймера

TCCR0 |= 0x05; // Устанавливаем предделитель

на 1024

if (servo_need_update) // Если поступил приказ обновить

таблицы автомата

{

Servo_upd(); // Обновляем таблицы.

servo_need_update = 0; // Сбрасываем сигнал обновления.

}

else // Нулевое состояние автомата.

Новый цикл

{

OCR0 = ServoNextOCR[servo_state]; // Берем первую

выдержку.

TCCR0 &= 0b11111000; // Сбрасываем предделитель

TCCR0 |= 0x04; // Предделитель на 256

PORTA = 0xFF; // Выставялем все сервоканалы в

1 - начало импульса

servo_state++; // Увеличиваем состояние

конечного автомата.

}

Вот такой вот незамысловатый алгоритм. Это касаемо генерации самих

импульсов. Но ведь нам надо еще каким то образом сделать таблицы

длительностей и битмасок, которые будут формировать сигнал. Да еще

обеспечить человеческий интерфейс взаимодействия с конечным автоматом.

Этим и займемся. Управление сервомашинками осуществляется через

структуру, под которую мы даже зарядил свой тип:

typedef struct {

u08 Position;

u08 Bit;

} SArray_def;

SArray_def Servo[MaxServo];

SArray_def *Servo_sorted[MaxServo];

Servo.bit — содержит бит порта,который нам надо сбросить. Просто

единичка в нужном разряде.

Servo.Position — это позиция сервопривода. В моем случае может принимать

значения от 26 до 76. Если больше-меньше, то серва уйдет за границы

допустимых положений, что черевато. Можно было поиграться с частотой

процессора и предделителями, чтобы выбрать диапазон побольше, но мне

было лень. В конце концов, для демонстрации возможностей 50 положений

вполне хватит. А желающие могут и на 16ти разрядный таймер все

перевесить, и будет у них точность до долей градуса.

Так как сервомашинки надо сортировать, то я сделал еще массив указателей

Servo_sorted. Чем ворочать в памяти неповоротливые структуры, я лучше

перетасую в порядке возрастания поля Position их указатели. Сожрёт

лишнюю память, но выиграет вы быстродействии.

Впрочем, в данном случае, когда структура имеет всего два восьмибитных

поля, экономия выглядит сомнительной, т.к. тот же указатель занимает те же

самые два байта. В лучшем случае баш на баш. Но кто сказал, что структура

будет неизменной? Может, что еще захотим добавить! Поэтому пусть лучше

сортируются указатели.

Для начала указатели и структуры инициализируются нужными данными:

// Присваиваем указателям адреса наших структур.

Servo_sorted[0] = &Servo[0];

Servo_sorted[1] = &Servo[1];

Servo_sorted[2] = &Servo[2];

Servo_sorted[3] = &Servo[3];

Servo_sorted[4] = &Servo[4];

Servo_sorted[5] = &Servo[5];

Servo_sorted[6] = &Servo[6];

Servo_sorted[7] = &Servo[7];

// Заполняем битмаски

Servo[0].Bit = 0b00000001;

Servo[1].Bit = 0b00000010;

Servo[2].Bit = 0b00000100;

Servo[3].Bit = 0b00001000;

Servo[4].Bit = 0b00010000;

Servo[5].Bit = 0b00100000;

Servo[6].Bit = 0b01000000;

Servo[7].Bit = 0b10000000;

// Выставляем все положения на нейтраль --

точно посредине диапазона.

Servo[0].Position = 50;

Servo[1].Position = 50;

Servo[2].Position = 50;

Servo

[3].Position = 50;

Servo[4].Position = 50;

Servo[5].Position = 50;

Servo[6].Position = 50;

Servo[7].Position = 50;

Теперь можно писать из прикладной программы любые произвольные

значения (26…76 в данном случае) в поле Position, задавая произвольное

положение любой из восьми сервомашинок.

После изменения любого из полей, перед отправкой таблиц в конечный

автомат, данные надо упорядочить по длительности. Это делает специальная

функция.

//Простейший алгоритм сортировки вставкой. Недалеко ушел от пузырька, но на

столь малых количествах

// данных являетя наиболее эффективным.

void Servo_sort(void)

{

u08 i,k;

SArray_def *tmp;

// Сортируем массив указателей.

for(i=1;i<MaxServo;i++)

{

for(k=i;((k>0)&&(Servo_sorted[k]->Position < Servo_sorted[k-1]->Position));k--)

{

tmp = Servo_sorted[k]; // Swap

[k,k-1]

Servo_sorted[k]=Servo_sorted[k-1];

Servo_sorted[k-1]=tmp;

}

Массив отсортирован. Теперь надо его обработать и сформировать таблицы

для автомата. Обработка заключается в склейке совпадающих полей. Т.е.

если у нас есть, например, 5 каналов с длительностью 20, то их надо склеить

в одно значение таблицы, а биты слепить в единую битмаску. А потом

загрузить все в массивы конечного автомата.

Обновление идет в функции Servo_upd

void Servo_upd(void)

{

u08 i,j,k;

for(i=0,k=0;i<MaxServo;i++,k++)

{

if(Servo_sorted[i]->Position!=Servo_sorted[i+1]->Position) //Если значения

уникальные

{

ServoNextOCR[k] = Servo_sorted[i]->Position; //

Записываем их как есть

ServoPortState[k+1] = Servo_sorted[i]->Bit; // И битмаску

туда же

}

else // Но

если совпадает со следующим

{

ServoNextOCR[k] = Servo_sorted[i]->Position; //

Позицию записываем

ServoPortState[k+1] = Servo_sorted[i]->Bit; // Записываем

битмаску

// И в цикле ищем все аналогичные позиции, склеивая их битмаски в одну.

for(j=1;(Servo_sorted[i]->Position == Servo_sorted[i+j]-

>Position)&&(i+j<MaxServo);j++)

{

ServoPortState[k+1] |= Servo_sorted[i+j]->Bit;

}

i+=j-1; // Перед выходом

корректируем индекс

}

// На глубину зарывания в

повторы

}

ServoNextOCR[k] = 0xFF; // В последний элемент

вписываем заглушку FF.

}

Т.к. менять таблицы автомата до тех пор пока он не отработает до конца

черевато глюками и ахтунг работой, то делать обновление можно только

только тогда, когда автомат выйдет на нулевое положение. Поэтому я

повесил это дело в прерывание. А в прикладной программе оставил только

обновление структур и их сортировку. И добавил флаг готовности

servo_need_update.

Т.е. если нам надо изменить позицию сервомашинки, то мы пишем

следующую комбинацию:

Servo[Б].Position =А

Servo_sort();

servo_need_update = 1;

И при следующем проходе автомата сервомашинка Б выйдет на позицию А.

Можно одновременно менять хоть все машинки сразу.

Я сделал небольшую демонстрашку этой программы. Через диспетчер пустил

по восьми сервам синусоидальные волны. Если сделать робоглиста

подобного тому, что уже описывался в моем блоге, то наверное он поползет

по змеиному. Впрочем, я не уверен в этом. Т.к. сколько я не наблюдал змей

никак не могу понять физическое обоснование их движению. Она словно по

земле течет.

Сама программа, гонящая синус по сервам, сделана на диспетчере и

выглядит так:

//Sinus

u08 SinState=0; // Состояние генератора

// Таблица синуса, приведенная к нашим допустимым значениям

u08 SinTable

[] PROGMEM = {76,74,68,60,50,41,33,27,26,29,35,43,53,62,70,75};

1 void Sinus(void)

{

SetTimerTask(Sinus,100); // Перезапуск

задачи через 100мс

Servo[0].Position =

pgm_read_byte(&SinTable[SinState&0x0F]);

Servo[1].Position =

pgm_read_byte(&SinTable[(SinState+1)&0x0F]);

Servo[2].Position =

pgm_read_byte(&SinTable[(SinState+2)&0x0F]);

Servo[3].Position =

pgm_read_byte(&SinTable[(SinState+3)&0x0F]);

Servo[4].Position =

pgm_read_byte(&SinTable[(SinState+4)&0x0F]);

Servo[5].Position =

pgm_read_byte(&SinTable[(SinState+5)&0x0F]);

Servo[6].Position =

pgm_read_byte(&SinTable[(SinState+6)&0x0F]);

Servo[7].Position =

pgm_read_byte(&SinTable[(SinState+7)&0x0F]);

SinState++; //

Увеличиваем состояние

Servo_sort(); //

Сортируем таблицы

servo_need_update = 1; //

Запрос на обновление автомата

}

Обратите внимание на реализацию генерации синуса. У меня в таблице

синуса (вообще то там косинус, но пофигу) есть только один период. Из 16

значений. А у нас восемь серв на которые должны идти последовательные

значения из этого ряда:

•

n+1

•

n+2

•

n+3

•

n+4

•

n+5

•

n+6

•

n+7

Но т.к. период всего один и вывод надо закольцовывать. Т.е. если n+m

вылазит за границу длины нашего масива, то его надо завернуть в начало.

Если делать это математическим методом условий, то будет каша с кучей

проверок.

Я, как бывалый ассемблерщик, решил все проще, применив трюк с

ограничением разрядности битмасками. Т.е. в массиве у нас 16 значений.

Поэтому если мы n+m обрежем до 4 бит маской, то оно в принципе не

сможет вылезти за границы в 16 (0×0F) элементов и так и будет вращаться по

кругу. Даже проверку на if (n==7) n=0; делать не надо. Усе будет

автоматически!

Данный метод должен прорулить и в кольцевых буферах, кратных 4, 8, 16,

32, 64, 128, 256 байтам. Просто записываем базу, а потом имеем смещения

головы и хвоста, ограниченные в разрядности, чтобы они автоматом не

вылезали за пределы кольца.

Конструкция pgm_read_byte - это чтение из флеша. Подробно я ее уже

расписывал в статье про работу с памятью

Проблемы

Главная проблема при такой генерации — это джиттер. Т.е. дрожание

фронтов. Возникает из-за того, что прерывания в AVR имеют одинаковый

приоритет и кто раньше встал того и тапки. А если в системе есть еще один

таймер, генерящий свое прерывание? То он будет создавать задержки для

конечного автомата, из-за чего поплывут фронты. Что черевато. У меня такое

прерывание есть — таймер диспетчера задач с его службой времени. Я решил

проблему просто — диспетчер рулит прикладными задачами, поэтому его

приоритет может быть и ниже автомата, который обеспечивает хардверную

реализацию фичи.

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

Получились вложенные прерывания. В принципе ничего страшного, главное

понимать, чем это грозит. А грозит это зарыванием в прерываниями — это

когда прерывание вызывается чаще, чем обрабатывается. И более глубоким

загрузом стека. Зарывание исключено — Служба таймеров обрабатывается в

пару порядков быстрей чем вызывается, а вот от двойной нагрузки на стек

никуда не деться. Но это можно просто учесть.

Архив с проектом для WinAVR+GCC

Скомпилировали, зашили, запустили. Получается такая картина на выходах

портов:

Дофига серв у меня, к сожалению, нет. Есть всего одна. Зато есть

осциллограф с логическим анализатором. Поэтому я его просто подключил к

схеме и снял видяшку:

Работа с множеством сервомашинок

Данную программную конструкцию можно легко расширить хоть до сотни

серв. Главное лишь бы портов хватило. Надо всего лишь изменить

разрядность данных отвечающих за битмаски, а в конструкции автомата, в

части где идет вывод:

PORTA &= ~ServoPortState[servo_state];

Добавить еще портов и выводить на них соответствующие байты

многобайтной битмаски. Можно это сделать маской-сдвигом, но наверное,

лучше будет через указатель вытаскивать нужные байты.

И при этом у нас остается еще куча процессорного времени на выполнение

других задач!

P.S. Оптимизацией кода практически не занимался, так что там еще многое

что следует доделать. Начиная от механизма инверсии битов и заканчивая

оптимизацией всех структур.

Подключение клавиатуры к МК по трем проводам на

сдвиговых регистрах

Часто возникает

необходимость использования

в своем проекте большого

количества кнопок для

различный целей. Существуют

разные варианты реализации

данной задачи. Сегодня я

расскажу вам о решении,

которое пришло мне в голову однажды вечером. Тогда мне нужно было

повесить клавиатуру на контроллер с ограниченным количеством свободных

ножек. Скорее всего данное решение уже описывалось и использовалось где-

либо ранее, но упоминаний в интернете я не нашел.

Суть

Подключение клавиатуры осуществляется по трем сигнальным проводам.

Дополнительные элементы: сдвиговые регистры sn74198n и несколько