Золотовский Д.В. Учебный курс для новичков по микроконтроллерам AVR. Часть 1
Подождите немного. Документ загружается.
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
for(i=0;i!=Max_Numbers_of_Timer;i++) //Прочесываем очередь
таймеров. Ищем нет ли уже там такого
{
if(SoftTimer[i].Number == NewNumber) // Если уже есть
запись с таким флагом
{
SoftTimer[i].Time = NewTime; // Перезаписываем ей
выдержку
InterruptRestore();
return; // Выходим.
}
}
for(i=0;i!=Max_Numbers_of_Timer;i++) //Если не находим, то ищем
любой пустой
{
if (SoftTimer[i].Number == 255)
{
SoftTimer[i].Number = NewNumber; // Заполняем поле
флага
SoftTimer[i].Time = NewTime; // И поле выдержки
времени
InterruptRestore();
return; // Выход.
}
}
InterruptRestore(); // Восстанавливаем прерывания как было.
// тут можно сделать return c кодом ошибки - нет свободных таймеров
}
Работает тоже не сложно.
На входе у нас два значения — время NewTime и флаг который мы должны
воткнуть.
Мы прочесываем нашу очередь таймеров, в поисках свободной ячейки либо
таймера на то же событие с еще не истекшим сроком. Если находим такой же
таймер — апдейтим его на новое время. Если не находим, то втыкаем данные
впервую свободную ячейку. А если не нашли и свободной ячейки, то
получаем Timer Fail. Это ошибка, ее надо учитывать делая очередь с запасом,
либо точно высчитывая сколько таймеров нам надо.
Теперь, вооруженные знанием о софтверных таймерах, рассмотрим как будет
организована наша мигалка (псевдокод):
1
2
3
4
5
6
7
8
9
10
11
12
13
void LED_ON(void)
{
flag.led_On=0; // Отработали, флаг можно сбросить
SET_BIT_LED(); // Собственно, зажгли что то там
SetTimer(OFF_LED_FLAG,1000); // Поставить флаг на погашение
через 1с
}
void LED_OFF(void)
{
flag.led_Off=0; // Отработали, флаг можно сбросить
CLR_BIT_LED(); // Собственно, погасили что то там
SetTimer(ON_LED_FLAG,1000); // Поставить флаг на зажжение
через 1с
}
Все! Видите, какие простые и линейные получаются кусочки. И насовать в
эту систему еще с полтора десятка цепочек не составит труда. Добавляем
флаги и условия, происываем таймеры и вперед. Причем флаги мы можем
ставить как в задачах, так и в прерываниях. А главный цикл будет с хрустом
это пережевывать.
Думаю понятно, что в такой организации скорость работы главного цикла
является критичной. В том плане что всякие хардверные тупые задержки
вроде delay_ms(****) в ней КРАЙНЕ НЕЖЕЛАТЕЛЬНЫ. Т.к. они тормозят
весь конвейер. Все должно быть сделано через службу таймеров. Если нужны
очень короткие задержки, то можно завести второй аппаратный таймер с
такой же байдой, но тикающий чаще. Но тут надо думать и смотреть.
Еще одним недостатком такой организации является жесткий порядок
выполнения операций. Т.е. пока мы не пробежим по всей цепочке
if(flag.***==1), мы не сможем выполнить какую либо операцию заново (хотя
если цепь быстрая, то редко когда критично).
Это частично решается переходом на конструкцию на базе SWITCH-CASE
конструкции с выходом в корень после каждой операции. В этом случае у нас
возникает другая пакость— часто вызываемые задачи могут заблокировать
выполнение более медленных.
Думаю, принцип понятен, поэтому я не буду приводить работающий пример
кода. Мне просто лень :) Если кто то пойдет таким путем то я с радостью
выложу его проект в статью. Дело в том, что я предпочитаю другую
организацию — динамический диспетчер. Или просто диспетчер. И вот для
нее я и приведу пример реального кода. На нём же будут дальнейшие
примеры курса.
AVR. Учебный Курс. Архитектура Программ Часть 2
Диспетчер
Данная организация программы требует чуть большего количества кода чем
флаговый автомат (Хотя это еще как посмотреть. С увеличением числа задач
служебный код динамического диспетчра не увеличивается, а вот флаговый
автомат разрастается за счет большего числа флагов и проверок этих флагов,
плюс быстродейтсвие снижается, чего нет в диспетчере) , но зато лишена
ряда недостатков.
Во первых тут очередь выполнения задач не жестко заданная, а
динамическая, конвеерного типа. То есть у нас есть в памяти массив из
указателей на задачи-функции. Диспетчер берет указатель и, если он не
указывает на Idle, осуществлет переход по этому адресу. Предварительно
удалив его из очереди и подкинув очередь.
Заброс указателей-задач в очередь осуществляется другими задачами и
прерываниями, а также программными таймерами. Собственно, принцип
передачи управления от задачи к задаче похож на флаговый автомат —
работаем через посредника. Только у нас тут отстутствуют проверки флагов,
а переход делается диспетчером. За счет этого увеличение числа задач не
сказывается на увеличении размера управляющей структуры.
Благодаря такой системе управляющую структуру можно вынести в
отдельную библиотеку, сварганить к ней конфиг и таскать за собой ее туда
сюда. Очень удобно.
А теперь подробно распишу тот диспетчер, который стоит в 90% моих
проектов на Си.
Очередь задач
Основа основ. С нее все начинается.
Первым делом определяем тип TPTR - Task Pointer. Это обычный указатель
пустышка. Просто адрес, без типа.
1
typedef void (*TPTR)(void);
Потом рисуем очередь задач. Она у нас как глобальная переменная,
защищенная от посягательств оптимизатора.
1
volatile static TPTR TaskQueue[TaskQueueSize+1]; // очередь указателей
TaskQueueSize это предельное число задач в очереди. Надо делать с
некоторым запасом. Задается в дефайнах конфига диспетчера.
Диспетчер задач
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
inline
void TaskManager(void)
{
u08 index=0;
TPTR GoToTask = Idle; // Инициализируем переменные
// Как видишь, тут есть указатель Idle - ведущий на процедуру простоя ядра.
// На нее можно повесить что нибудь совсем фоновое, например отладочные
примочки =)
// И локальная переменная-указатель GoToTask куда мы будем жрать адреса
переходов
Disable_Interrupt
// Запрещаем прерывания!!! Это макрос. Поэтому без ; в конце.
// Почему не CLI()? Это команда AVR, а я хотел сделать максимально
// платформонезависимый диспетчер. Прерывания надо запрещать потому, что
// Идет обращение к глобальной очереди диспетчера. Ее могут менять и прерывания
// Поэтому заботимся об атомарности операции.
GoToTask = TaskQueue[0]; // Хватаем первое значение из очереди
if (GoToTask==Idle) // Если там пусто
{
Enable_Interrupt // Разрешаем прерывания
(Idle)(); // Переходим на обработку пустого цикла
}
else
{
for(index=0;index!=TaskQueueSize;index++) // В противном случае сдвигаем
всю очередь
{
TaskQueue[index]=TaskQueue[index+1];
32
33
34
} TaskQueue[TaskQueueSize]= Idle; // В последнюю запись
пихаем затычку Idle
Enable_Interrupt // Разрешаем прерывания
(GoToTask)(); // Переходим к задаче
}
}
Постановщик в очередь
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
void SetTask(TPTR TS)
{
u08 index = 0;
u08 nointerrupted = 0;
if (STATUS_REG & (1<<Interrupt_Flag)) // Если прерывания разрешены, то запрещаем
их.
{
Disable_Interrupt
nointerrupted = 1; // И ставим флаг, что мы не в прерывании.
}
// Это бодояга вида ATOMIС RESTORSTATE только собственной выделки с закосом
под
// мультиплатформенность. Как видишь, тут SREG явно не указыватеся, он прописан
в
// дефайнах. При переносе на другой микроконтроллер, например, на С51 мне только
// пару файлов поправить. А прерывания надо однозначно запретить. Ибо нужно
// обеспечить атомарность операций.
// А вот и постановка задачи в очередь.
while(TaskQueue[index]!=Idle) // Прочесываем очередь задач на предмет
свободной ячейки
{ // с значением Idle - конец очереди.
index++;
if (index==TaskQueueSize+1)
// Если очередь переполнена то выходим не
солоно хлебавши
{
if (nointerrupted) Enable_Interrupt // Если мы не в прерывании, то
разрешаем прерывания
return; // Раньше функция возвращала код ошибки -
очередь
переполнена. Пока убрал.
}
}
// Если нашли свободное место, то
TaskQueue[index] = TS; // Записываем в очередь задачу
if (nointerrupted) Enable_Interrupt // И включаем прерывания если не в обработчике
прерывания.
}
Используется просто — если хотим вызывать другую задачу, то мы не
ставим флаг, как в флаговом автомате, а пихаем ее адрес в очередь.
1
SetTask(Task1);
А сама задача выглядит как обычная функция:
1
2
3
4
void Task1(void)
{
DoSomething();
}
Причем, естественно можно из задачи делать вызов функций напрямую. Но
не стоит надолго затягивать выполнение задачи. Тут как с прерываниями —
лучше как можно быстрей передать управление диспетчеру. И по
возможности вызовы делать через него. Да, это потребует большей длинны
конвеера, но зато код будет работать равномерней.
Очередь таймеров.
Разумеется, тут нужен и софтверный таймер. Без которого жизнь уже не
мила. Начинается он естстественно с очереди таймеров, которая сделана в
виде массива структур. Глобальная переменная, также защищенная от
посягательств оптимизатора.
1
2
3
4
5
6
volatile static struct
{
TPTR GoToTask; // Указатель перехода
u16 Time; // Выдержка в мс
}
MainTimer[MainTimerQueueSize+1]; // Очередь таймеров
Состоит из двубайтного счетчика времени и указателя TPTR.
Служба таймера
В прерывании таймера, вызываемого каждую 1мс выполняетя функция
обработчика таймера. Обьявлена как инлайновая, что встраивает ее прям в
обработчик прерывания, без лишних переходов. Экономим стек, ага
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
inline
void TimerService(void)
{
u08 index;
for(index=0;index!=MainTimerQueueSize+1;index++) // Прочесываем очередь
таймеров
{
if(MainTimer[index].GoToTask == Idle) continue; // Если нашли пустышку -
щелкаем следующую итерацию
if(MainTimer[index].Time !=1) // Если таймер не выщелкал, то щелкаем
еще раз.
{ // To Do: Вычислить по тактам, что
лучш;е !=1 или !=0.
MainTimer[index].Time --; // Уменьшаем число в ячейке если не конец.
}
else
{
SetTask(MainTimer[index].GoToTask); // Дощелкали до нуля? Пихаем в
очередь задачу
MainTimer[index].GoToTask = Idle; // А в ячейку пишем затычку
}
}
}
Прерывание таймера
Служба таймеров пихается в обработчик прерывания от таймера. Каким
образом будет делаться прерывание это уже частности. Я сделал на ШИМ
таймере по достижении сравнения. Впрочем, можно было повесить и на
самый глупый таймер, например на таймер0, который только тикать и умеет.
А большего нам и не надо. Но тут придется перезагружать его значение в
каждом заходе, чтобы поддерживать постоянное время. А на ШИМе это
автоматом идет. Разумеется вывод ШИМа не подключен к выводу
контроллера. Тикает внутри.
1
2
3
4
ISR(RTOS_ISR)
{
TimerService();
}
RTOS_ISR это тоже макроопределение. У меня оно привязано на
TIMER2_COMP_vect, но можно в конфигах диспетчера привязать на что
угодно. Сделано так опять же для того чтобы при переносе на другую
архитектуру можно было пару строк подправить и все.
Постановщик таймеров
Функция устанавливающая задачу в очередь по таймеру. На входе адрес
перехода (имя задачи) и время в тиках службы таймера — миллисекундах.
Время двубайтное, т.е. от 1 до 65535. Если в очереди таймеров уже есть
таймер с такой задачей, то происходит апдейт времени. Две одинаковых
задачи в очереди таймеров не возможны. Это можно было бы реализовать, но
на практике удобней апдейтить. Число таймеров выбирается исходя из
одновременно устанавливаемых в очередь задач. Так как работа с глобальной
очередью таймеров, то надо соблюдать атомарность добавления в очередь.
Причем не тупо запрещать/разрешать прерывания, а восстанавливать
состояние прерываний.
//
Время выдержки в тиках системного таймера.
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
void SetTimerTask(TPTR TS, u16 NewTime)
{
u08 index=0;
u08 nointerrupted = 0;
if (STATUS_REG & (1<<Interrupt_Flag)) // Проверка запрета прерывания, аналогично
функции выше
{
Disable_Interrupt
nointerrupted = 1;
}
for(index=0;index!=MainTimerQueueSize+1;++index) //Прочесываем очередь таймеров
{
if(MainTimer[index].GoToTask == TS)
// Если уже есть запись с
таким адресом
{
MainTimer[index].Time = NewTime; // Перезаписываем ей выдержку
if (nointerrupted) Enable_Interrupt // Разрешаем прерывания (если не были
запрещены).
return; // Выходим. Раньше был код успешной операции.
Пока убрал
}
}
26
27
28
29
30
31
32
33
34
35
// Алгоритм, в данном случае не очень оптимален. В прошлом цикле можно было
запомнить
// положение первого Idle и сейчас не искать его.
for(index=0;index!=MainTimerQueueSize+1;++index) // Если не находим похожий
таймер, то ищем любой пустой
{
if (MainTimer[index].GoToTask == Idle)
{
MainTimer[index].GoToTask = TS; // Заполняем поле перехода задачи
MainTimer[index].Time = NewTime; // И поле выдержки
времени
if (nointerrupted) Enable_Interrupt // Разрешаем прерывания
return; // Выход.
}
}
// тут можно сделать return c кодом ошибки - нет свободных таймеров
}
Постановка задачи по таймера идет следующим образом:
1
SetTimerTask(Task1,1000);
Вот и все.
Инициализация диспетчера:
В отличие от флагового автомата, где только флаги установить, тут требуется
при старте сделать инициализацию очередей и очистку таймеров.
Функция выполняется один раз, потому инлайновая:
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
inline
void InitRTOS(void)
{
u08 index;
for(index=0;index!=TaskQueueSize+1;index++) // Во все позиции записываем Idle
{
TaskQueue[index] = Idle;
}
for(index=0;index!=MainTimerQueueSize+1;index++) // Обнуляем все таймеры.
{
MainTimer[index].GoToTask = Idle;
MainTimer[index].Time = 0;
}
}
//Потом роисходит запуск диспетчера. Собственно запускать то там надо таймер.
//RTOS Запуск системного таймера