Золотовский Д.В. Учебный курс для новичков по микроконтроллерам AVR. Часть 1
Подождите немного. Документ загружается.
Распологается там, где обычно прописаны вызываемые процедуры. В этом
отношении ничего не поменялось. В принципе, вызывать можно код и из
внешнего файла, главное правильно прописать все это в таблице переходов.
В тестовом примере это выглядит так:
Расположение: Trash-rtos.asm - главный файл программы
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
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
;=========================================================
;Tasks
;=========================================================
Idle: RET ; Задача пустого цикла, но ничего
; не мешает сунуть сюда любой код.
; Он будет выполнен. В последнюю очередь.
;-------------------------------------------------------
Fire: LDS OSRG,U_B ; Это код задачи "Fire"
OUTI UDR,'A' ; Выдрано из реального проекта
; Суть данного кода не важна
CBI PORTD,7 ; Поэтому можешь не вникать. Тут
NOP ; Может быть абсолютно любой
NOP ; код -- код твоей задачи!
SBI PORTD,7
; Если любопытно, то тут обычное
LDS Counter,PovCT ; заполнение сдвигового регистра
LDPA Lines ; из трех микросхем 74HC164
; средствами SPI передатчика
CLR OSRG ; Оставил его лишь для примера.
; Чтобы наглядно показать, что
ADD ZL,Counter ; Из себя представляет задача.
ADC ZH,OSRG
LPM OSRG,Z+
OUT SPDR,OSRG
Wait0: SBIS SPSR,SPIF
RJMP Wait0
INC Counter
CPI Counter,150
BRSH Clear
STS PovCT,Counter
RET
Clear: CLR Counter
STS PovCT,Counter
RET ; Выход из задачи только по RET!!!
;-------------------------------------------------------
Task2: RET ; Это пустые заглушки. На этом месте
; могла бы быть ваша задача! :)
;-------------------------------------------------------
Task3: RET ; Аналогично, надо будет задействую.
;-------------------------------------------------------
Task4
: RET ; Названия в стиле Task4 тоже живут
; недолго. Обычно переименовываю
;-------------------------------------------------------
50
51
52
53
54
55
56
57
58
Task5: RET ; Как с задачей "Fire"
;-------------------------------------------------------
Task6: RET
;-------------------------------------------------------
Task7: RET
;-------------------------------------------------------
Task8: RET
;-------------------------------------------------------
Task9: RET
Таблица переходов
После всего кода задач располагается таблица переходов и код самой ОС.
Расположение: Trash-rtos.asm - главный файл программы, в самом низу, в
конце ПЗУ
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
;========================================================================
; RTOS Here
;========================================================================
.include "kerneldef.asm" ; Настройки ядра -
переменные
и ряд макросов.
.include "kernel.asm" ; Подклчюаем ядро ОС.
;Это таблица переходов.
TaskProcs: .dw Idle ; [00] Она содержит в себе реальные
адреса задач
.dw Fire ; [01] Как видишь, 0 тут у задачи
пустого цикла,
.dw Task2 ; [02] 01 у "Fire", ну и дальше
.dw Task3 ; [03] По порядку.
.dw Task4 ; [04]
.dw Task5 ; [05]
.dw Task6 ; [06]
.dw Task7 ; [07]
.dw Task8 ; [08]
.dw Task9 ; [09]
Причем, в таблице задач не обязательно должны быть разные задачи. Можно
делать одну, но на разные ячейки, например так:
1
2
3
4
5
6
7
8
9
10
TaskProcs: .dw Idle ; [00]
.dw Fire ; [01]
.dw Task2 ; [02]
.dw Task3
; [03]
.dw Task4 ; [04]
.dw Fire ; [05]
.dw Task6 ; [06]
.dw Idle ; [07]
.dw Idle ; [08]
.dw Task9 ; [09]
Это иногда бывает удобно.
Таблица переходов нужна для того, чтобы можно было любому адресу в
программе дать адрес-смещение относительно начала таблицы перехода.
То есть, теперь, чтобы перейти на Task4 нам не нужно знать точный адрес
этой задачи, достаточно лишь знать, что ее адрес записан в таблице
переходов в четвертой ячейке. Адрес начала таблицы переходов у нас
фиксированный, поэтому просто прибавляем к нему смещение (равное
номеру задачи*2) и берем оттуда искомый адрес. Благодаря этому, мы можем
в очереди задач держать не двубайтные адреса переходов, а однобайтные
номера под которыми эти адреса размещены в таблице.
А чтобы не путаться под каким номером какая задача спрятана, то введем для
них символическое обозначение:
Расположение: kerneldef.asm - файл макроопределений ядра
1
2
3
4
5
6
7
8
9
10
.equ TS_Idle = 0 ; Просто нумерация. Не более того
.equ TS_Fire = 1 ; Зато теперь можно смело отправлять в очередь
.equ TS_Task2 = 2 ; задачу с именем TS_Fire и не париться на счет
того,
.equ TS_Task3 = 3 ; что запишется что то не то.
.equ TS_Task4 = 4 ; Тут все по порядку, жестко привязано к ячейкам
таблицы!
.equ TS_Task5 = 5 ; Так что если в таблице и можно делать одинаковые
задачи,
.equ TS_Task6 = 6 ; то тут у них идентификаторы должны быть разные!!!
.equ TS_Task7 = 7 ; А имена можно придумывать любые, они не привязаны
ни к чему,
.equ TS_Task8 = 8 ; Главное самому не забыть что где.
.equ TS_Task9 = 9
Очередь задач.
Логически выглядит как строка в памяти, где каждый байт это номер
задачи. Два числа 0 и FF зарезервированы системой. 0 - это Idle, холостой
цикл диспетчера. FF - нет задачи, конец очереди.
В коде это выглядит так:
Расположение: Trash-rtos.asm - главный файл программы, самое начало. Где
идет разметка ОЗУ
1
2
3
.DSEG
.equ TaskQueueSize = 11 ; Длина очереди задач
TaskQueue: .byte TaskQueueSize
; Адрес очереди сотытий
в SRAM
Длина очереди задается с запасом, чтобы не произошло ее срыва.
Располагать ее лучше после остальных данных, чтобы она тянулась
навстречу стеку.
Диспетчер задач
Это небольшая процедурка, которая берет из очереди байт, сравнивает его с
FF. Если равно, значит очередь пуста и происходит выход в главный цикл.
Если же там есть какое либо число отличное от FF, то оно загружается в
регистр, происходит вычисление адреса по таблице переходов и прыжок на
адрес задачи и выполнение кода. Перед прыжком текущий номер задачи
удаляется из очереди, а вся очередь сдвигается на один байт вперед. При
следующем заходе в диспетчер все повторяется заново до полного
опустошения очереди. При этом в очередь можно добавлять новые задачи.
Главный цикл программы при этом выглядит следующим образом:
Расположение: Trash-rtos.asm - главный файл программы
1
2
3
4
5
Main: SEI ; Разрешаем прерывания.
WDR ; Reset Watch DOG
RCALL ProcessTaskQueue ; Обработка очереди
процессов (Диспетчер)
RCALL Idle ; Простой Ядра
RJMP Main
Сам обработчик очереди несложен. Распологается в файле kernel.asm
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
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
ProcessTaskQueue:
ldi ZL, low(TaskQueue) ; Берем адрес начала очереди
задач
ldi ZH, high(TaskQueue) ; Напомню, что это в ОЗУ.
ld OSRG, Z ; Берем первый байт (OSRG = R17
рабочий
cpi OSRG, $FF ; регистр OS) Сравниваем с FF
breq PTQL02 ; Равно? Значит очередь пуста -
выход.
clr ZH ; Сбрасываем старший байт
lsl OSRG ; А взятый номер задачи умножаем на 2
mov ZL, OSRG ; Так как адреса у нас двубайтные, а
значит
; И ячейки в таблице перехода
двубайтные
; Получается смещение по
таблице
subi ZL, low(-TaskProcs*2) ; Прибавляем получившееся
смещение к адресу
sbci ZH, high(-TaskProcs*2) ; начала таблицы
переходов. Ну и что, что AVR
; не умеет
; складывать регистр с числом
+ перенос.
; Зато умеет вычитать, а минус на
минус дают плюс! :)
; Математика царица всех наук!
; Теперь в Z у нас адрес где лежит
адрес перехода.
lpm ; Берем этот адрес! Сначала в R0
mov OSRG, r0 ; Потом в OSRG
ld r0, Z+ ; Эта команда ничего ценного на
грузит, мы ее применили
; Ради "Z+" чтобы увеличить адрес в Z
и взять второй байт
; Целевого адреса по которому мы
перейдем.
lpm ; Берем в R0 второй байт адреса.
mov ZL, OSRG ; А из OSRG перекладываем в ZL
mov ZH, r0 ; И из R0 в ZH. Теперь у нас в Z
полный адрес перехода.
; Можно драпать, в смысле IJMP -
индексный переход по Z
49
50
51
52
53
54
55
56
57
58
59
60
61
62
; Но пока рано! Надо же еще очередь в
порядок привести!
push ZL ; Спрячем наш адрес, наше сокровище,
в стек...
push ZH ; Глубоко зароем нашу прелесссть....
; Займемся грязной работой.
Продвинем очередь.
ldi Counter, TaskQueueSize-1; Загрузим длинну очереди.
Иначе мы всю память
ldi ZL, low(TaskQueue) ; подвинем. И хапнем в Z
начало очереди.
ldi ZH, high(TaskQueue)
cli ; Запретим прерывания. А то если
очередь сорвет получим
; армагедец.
PTQL01: ldd OSRG, Z+1 ; Грузим из следующего Z+1 байта и
перекладываем
st Z+, OSRG ; все в Z, а Z после этого
увеличиваем на 1
dec Counter ; Уменьшаем счетчик (там длинна
очереди!)
brne PTQL01 ; Если не конец, то в цикле.
ldi OSRG, $FF ; А если конец, то по последнему
адресу записываем FF
st Z+, OSRG ; Который является признаком конца
очереди.
sei ; Разрешаем прерывания. Можно
расслабиться
pop ZH ; Достаем из стека нашу прелессть...
наш адрес перехода
pop ZL ; Оба байта, старший и младший.
ijmp ; Переходим в задачу!!!
; Обрати внимание - сюда мы пришли по RCALL из
главного цикла
; Значит в стеке у нас лежит адрес возврата. А ушли
мы в задачу по IJMP
; который стек не меняет. Но это не страшно! Ведь из
задачи мы
; выходим по RET!
PTQL02: ret
Для большей понятности нарисовал диаграммку со стрелочками разными,
про то как формируется адрес в таблице переходов:
Задачи кладутся в очередь другой процедурой:
1
2
ldi
OSRG, TS_Task4 ; Запускаем в очередь задачу Task4
rcall SendTask
Делать это можно где угодно, хоть в прерывании, хоть в другой задаче.
Для удобства был написан макрос:
1
SetTask [task]
Сама процедура SendTask работает тоже несложно, она всего лишь ставит
задачу в очередь.
Расположение: kernel.asm
1
2
3
4
5
6
7
8
; OSRG - Event ; В рабочем регистре ОС - номер задачи
SendTask: push ZL ; Сохраняем все что используется
push ZH ; в стеке
push Tmp2
push Counter
in Tmp2,SREG ; Сохраняем значение флагов
push Tmp2
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
ldi ZL, low(TaskQueue) ; Грузим в Z адрес очереди задач.
ldi ZH, high(TaskQueue)
ldi Counter, TaskQueueSize ; А в счетчик длинну очереди,
чтобы
; не начать всю память
засаживать.
cli ; запрещаем прерывания.
SEQL01: ld Tmp2, Z+ ; Грузим в темп байт из очереди
cpi Tmp2, $FF ; и ищем ближайшее пустое место = FF
breq SEQL02 ; Если нашли, то переходим на сохранение
dec Counter ; Либо конец очереди по счетчику.
breq SEQL03
rjmp SEQL01
SEQL02: st -Z, OSRG ; Нашли? Сохраняем в очереди номер
задачи.
SEQL03: pop Tmp2 ; Возвращаем флаги. Если там прерывание было
out SREG,Tmp2 ; разрешено, то оно вернется в это
значение.
pop Counter ; Выходим, достав все заныченное.
pop Tmp2
pop ZH
pop ZL
ret
Архив с исходниками и работающим проектом для ATMega8
P.S.Ух, ну накатал телегу. Аж самому страшно. А там еще столько же, про
таймерную службу, да пошаговые руководства по инсталляции и
использованию. Но это после. Пока переварите это.
AVR. Учебный курс. Операционная система. Таймерная служба
Итак, у нас есть очередь задач и общая логика работы системы. Но одной
очереди задач с диспетчером мало. Нужно распределять задачи по времени,
задавать интервалы, запускать отложенные задачи. Всем этим будет
заниматься служба таймеров.
В чем ее суть ее работы:
Время разбивается на интервалы, скажем, по 1мс. Такой выдержки хватает
для большинства задач. Также у нас должна быть очередь программных
таймеров, размещенных в ОЗУ. На каждый таймер отводится три байта:
Первый — идентификатор задачи. Два других — выдержка в миллисекундах.
Два байта позволяют организовать выдержку в 65.5 секунд. Конечно, можно
сделать и больше, если отвести на временную выдержку три или даже четыре
байта, но такие большие временные интервалы пригождаются редко, поэтому
проще перехватиться через дополнительную переменную для конкретной
задачи, а не нагружать таймерную службу обсчетом дополнительных байт.
Один из свободных аппаратных таймеров программируем на то, чтобы он
генерировал прерывание каждые 0.001с
О работе аппаратных таймеров написано в разделе про программирование
встроенной периферии. Пока можешь не заморачиваться. Суть лишь в том,
что настроенный таймер тикает независимо от главной программы и в
заданное время выдает прерывание.
По прерыванию мы берем из очереди таймеров первый байт и сравниваем
его с 0xFF, за 0xFF принято неактивное состояние. Если же там не 0xFF, то
значит это идентификатор задачи, а таймер активен. Поэтому берем третий
байт, декрементируем его, если он стал равен нулю декрементируем второй
байт и если оба байта не стали равны нулю переходим к проверке
следующего байта. В случае если время истекло, то идентификатор задачи
пихается в очередь задач на исполнение.
Обработчик прерывания таймера:
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
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
push
OSRG ; Прячем OSRG в стек
in OSRG,SREG ;
push OSRG ; Сохранение регистра OSRG и регистра
состояния SREG
push ZL
push ZH ; сохранение Регистра Z
push Counter ; сохранение Регистра Counter
ldi ZL,low(TimersPool) ; Загрузка с регистр Z адреса
таймерной очереди,
ldi ZH,high(TimersPool) ; по которому находится
информация о таймерах
ldi Counter,TimersPoolSize ; Берем максимальное
количество таймеров
Comp1L01: ld OSRG,Z ; OSRG = [Z] ; Получить номер
события
cpi OSRG,$FF ; Проверить на "NOP = FF"
breq Comp1L03 ; Если NOP то переход к
следующей позиции
clt ; Флаг T используется для информации об
окончании счёта
ldd OSRG,Z+1 ; Грузим в OSRG первый байт времени
subi OSRG,low(1) ; Уменьшение младшей части счётчика на
1
std Z+1,OSRG ; И сохраняем ее обратно туда откуда
взяли
breq Comp1L02 ; Если образовался 0 то флаг T не
устанавл
иваем
set ; А если байт не закончился, то ставим Т
Comp1L02: ldd OSRG,Z+2 ; Берем второй байт времени.
sbci OSRG,High(1) ; Уменьшение старшей части счётчика на
1
std Z+2,OSRG ; Сохраняем где взяли
brne Comp1L03 ; Счёт не окончен
brts Comp1L03 ; Счёт не окончен (по T)
ld OSRG,Z ; Получить номер задачи
rcall SendTask ; послать в системную очередь
задач
ldi OSRG,$FF ; = NOP (задача выполнена, таймер
самоудаляется)
st Z, OSRG ; Прописываем в заголовок таймера FF
Comp1L03
: subi ZL,Low(-3) ; Пропуск таймера.
sbci ZH,High(-3) ; Z+=3 - переход к следующему таймеру
dec Counter ; счетчик таймеров