Золотовский Д.В. Учебный курс для новичков по микроконтроллерам AVR. Часть 1
Подождите немного. Документ загружается.
.macro GetNextProc
LDI R16, $FF
STS TempProc, R16 ; В TempProc пишем $FF
LDS R16, CurProc ; Инькаем CurProc
INC R16
LDS R17, LastItem ; Сравниваем с последним
INC R17
CP R16, R17
BRCS NoDec ; Если больше - пишем 0
LDI R16, 0
NoDec:
STS CurProc, R16 ; сохраняем в CurProc
LDI ZL, low(taskQueue) ; Грузим номер из очереди...
LDI ZH, High(taskQueue) ; (было выше)
ADD ZL, R16
LDI R16, 0
ADC ZH, R16
LD R16, Z
LDI ZL, low(ProcTable) ; Берем из таблицы адрес
процесса...
LDI ZH, High(ProcTable)
LSL R16
ADD ZL, R16
LDI R16, 0
ADC ZH, R16
LD R16, Z+
LD R17, Z+
MOV ZL, R16 ; И пихаем его в Z!
MOV ZH, R17
.endm
Тут тоже все просто до жути. Увеличиваем CurProc, если ушло за конец
очереди - пишем 0, вынимаем из очереди номер процесса, идем в таблицу,
достаем адрес возврата и пишем его в Z пару.
И последний макрос:
; Макрос пересчета таймеров
.macro DecTimers
LDI ZL, Low(TimerQueue) ; Грузим начало очереди таймеров
LDI ZH, High(TimerQueue)
LDI R16, 0
Decrease: ; Цикл уменьшения таймеров
LD R17, Z+ ; Таймеры 2х-байтные
LD R18, Z
CPI R17, 0 ; побайтово сравниваем
BRNE Decr ; Если 0 - то не надо уменьшать
CPI R18, 0
BREQ NoDecrease
Decr:
SUBI R17, 1 ; уменьшаем на 1
SBCI R18, 0
LD R0, -Z ; и переписываем старые значения
ST Z+, R17
ST Z, R18
CPI R17, 0 ; если стало равно нулю - надо
BRNE NoDecrease ; запускать процесс
CPI R18, 0
BRNE NoDecrease
MOV R17, R16 ; в R17 номер процесса
RCALL StartProcess ; API StartProcess
NoDecrease:
LD R0, Z+ ; переход к следующей ячейке
INC R16 ; Inc R16; если стал равен кол-ву
CPI R16, ProcNum ; процессов - значит выход.
BRNE Decrease
.endm
Тут мы проходимся по всему массиву таймеров, уменьшаем все на 1 (если
они не равны нулю конечно), и, если таймер достиг нуля, то запускаем
соответствующий ему процесс. Алгоритм, думаю, достаточно
прокомментирован.
Да, вспомнил. Таймер в моей операционке - далеко не точный. Как понятно
из кода, число в таймере - количество переключений процессов до
следующего запуска. Его можно использовать лишь чтобы, например
примерно каждые 20 миллисекунд параллельно основной программе
сканировать клавиатуру, каждые 40мс обновлять дисплей и т.п. Вообщем
там, где точность не важна. По моим подсчетам точность варьируется в
пределах 0.1мс.
Вот и вся операционка. Если вдуматься, ничего сложного тут нет. В
скомпилированном виде вместе с АПИ (см. ниже) весит 1190 байт. Для
вытесняющей операционки немного.
Если ты до сих пор не устал, то сейчас я покажу тебе API.
Application Programming Interface (API) я сделал из 5ти функций. Просто
чтобы было легко потом дописать загрузку процесса например из EEPROM
или еще чего. Можно конечно использовать его в своих целях.
CreateProcess:
функция вызывается так:
LDI R17, N
RCALL CreateProcess
N - номер процесса в таблице Proctable (помни, адреса давно остались в
прошлом, у нас номера:))
Сама функция такая:
;Создание нового процесса
CreateProcess: ; R17 - номер процесса в таблице адресов
LDS R16, LastItem ; Увеличим номер последнего элемента
INC R16
CPI R16, ProcNum ; Если больше размера очереди - выходим
BREQ Exit
STS LastItem, R16 ; увеличим конец очереди
; Инициализация нового процесса
LDI YL, Low(ProcData) ; Начало области данных
LDI YH, High(ProcData)
INC R17
LDI R16, ProcDataSize ; Получаем начало данных след. процесса
MUL R16, R17
ADD YL, R0
ADC YH, R1
DEC R17
LD R16, -Y ; Уменьшим на 1 - конец данных нужного
; В Y пару сохраняем этот адрес -
; Это будет стек
LDI ZL, Low(ProcData) ; Начало области данных
LDI ZH, High(ProcData)
LDI R16, ProcDataSize ; Получаем начало данных нужного процесса
MUL R16, R17
ADD ZL, R0
ADC ZH, R1
LDI R16, 33 ; Очищаем место регистров - 32 регистра,
LDI R18, 0 ; флаг состояния => пишем 33 нуля
Clear:
ST Z+, R18
DEC R16
BRNE Clear
ST Z+, YL ; Пишем адрес стека
ST Z+, YH
; Запуск процесса - ставим в очередь
LDS R16, LastItem
LDI ZL, Low(TaskQueue) ; Загружаем адрес в очереди
LDI ZH, High(TaskQueue); Исходя из номера последнего элемента
ADD ZL, R16
LDI R16, 0
ADC ZH, R16
ST Z+, R17 ; И пишем туда наш номер процесса,
LDI R16, $FF ; потом FF
ST Z+, R16
Exit:
RET
Сначала увеличим указатель на последний элемент очереди. Дальше
очищаем память процесса. Адрес начала стека - это адрес начала данных
следующего процесса минус единица. Чистим 33 байта для регистров (чтоб
при старте у процесса все регистры обнулились, включая SREG), и
вписываем после 33х нулей адрес стека процесса. Вот и
проинициализировали (слово-то какое!). Пишем в конец очереди наш номер
процесса - и все готово. Как хорошо работать с номерами: так бы пришлось
постоянно возиться с двубайтными адресами, переписывать их в очереди и
т.д. Вообщем, была бы полная неразбериха.
Следующая АПИ-функция:
; Запуск процесса после паузы
; Используется системой, но, думаю, можно и самому попробовать :)
StartProcess: ; R17 - номер процесса
PUSH ZL
PUSH ZH
PUSH R16
LDS R16, LastItem ; Увеличим номер последнего элемента
INC R16
CPI R16, ProcNum ; Если больше размера очереди - выходим
BREQ ExitS
Push R17
STS LastItem, R16
LDI ZL, Low(TaskQueue) ; Далее надо сдвинуть очередь
LDI ZH, High(TaskQueue); что мы и делаем
ADD ZL, R16 ; получаем адрес конца очереди
CLR R17
ADC ZH, R17
MOV R17, R16 ; сдвигать надо от конца и до текущего
LDS R18, CurProc ; т.к. вставляем процесс после текущего
SUB R17, R18 ; В R17 - количесво сдвигов
ShellS: ; Сдвигаем (да, криво, я знаю)
LD R18, Z+
ST Z, R18
LD R0, -Z
LD R0, -Z
DEC R17
BRNE ShellS
LD R0, Z+ ; и пишем в освободившееся место
интересующий
POP R17 ; номер процесса
ST Z, R17
ExitS:
POP R16
POP ZH
POP ZL
RET
Функция ставит уже созданный процесс в очередь после текущего. Как?
Увеличиваем указатель на последний элемент, как и в CreateProcess. Потом
сдвигаем очередь — с текущего элемента и до конца, и пишем на
освободившееся места нужный номер процеса. Надеюсь, это понятно.
Самая сложная функция: пауза процесса. Что для этого нужно?
Нужно убрать интересующий процесс из очереди. Вроде все просто. НО если
мы убираем текущий процесс - надо немедленно перейти к следующему. А
если другой — то ни в коем случае нельзя сохранять регистры. Это я и
делаю:
;Поставить процесс на паузу
;Удаление - вечная пауза :)
; Внимание! Перед функцией ОБЯЗАТЕЛЬНО необходимо запретить прерывания,
; а после - разрешить. Иначе возможно будет плохо.
SuspendProcess: ;R17 - номер процесса
LDI ZL, Low(TaskQueue) ; начало очереди
LDI ZH, High(TaskQueue)
LDI R16, 0
Seek: ; Ищем процесс с таким номером в очереди
LD R18, Z+
CP R18, R17
BREQ EOSeek ; Нашли - идем дальше
INC R16
CPI R16, LastItem
BRNE Seek
RJMP NotFound ; А если нет такого - выходим
EOSeek:
LDI R19, 0 ; для распознания в макросе
STS TempProc, R17
MOV R17, R16 ; Сохраняем номер в очереди
LDS R16, CurProc
CP R16, R17 ; Если не равен текущему -
BRNE TNoSave ; то не сохраняем регистры
TSave:
LDI R19, 1 ; тоже для распознания в дальнейшем
RJMP NoDec ; первое, что пришло в голову :)
TNoSave:
CP R16, R17 ; Если меньше текущего -
BRCS NoDec ; То уменьшаем номер текущего в очереди
LDS R16, CurProc
DEC R16
STS CurProc, R16
NoDec
:
LDI ZL, Low(TaskQueue) ; Далее надо сдвинуть очередь
LDI ZH, High(TaskQueue); что мы и делаем
INC R17 ; От текущего и до конца
ADD ZL, R17
LDI R16, 0
ADC ZH, R16
DEC R17
LDS R16, LastItem
SUB R16, R17
INC R16
Shell: ; Сдвигаем (да, криво, я знаю)
LD R18, Z
ST -Z, R18
LD R0, Z+
LD R0, Z+
DEC R16
BRNE Shell
LDS R16, LastItem ; уменьшаем номер последнего элемента
DEC R16
STS LastItem, R16
CPI R19, 0
BREQ NotFound ; и если стопим текущий процесс - то переключим
RJMP TM0_OVF
NotFound: ; Иначе - с вещами на выход
RET
Ищу в очереди процесс с нужным номером, определяю, сейвить регистры
или нет. Потом сдвигаю очередь, уменьшаю указатель и в конце смотрю, что
определил заранее: если текущий процесс останавливаем - то сохраняем
регистры и переключаемся. Если нет - то переключать не надо, и сохранять
регистры тем более.
Теперь рассмотрим таймеры:
;Поставить таймер
/*
Внимание! данная функция должна использоваться вместе с Suspend porcess
Иначе через установленную задержку запустится второй экземпляр процесса,
имеющий тот же адрес, ту же память и тот же стек, НО работающий парал -
лельно первому, Соответственно их регистры будут мешаться друг с другом,
указатель стека будет прыгать туда-сюда - вообщем, не очень приятно.
делается так:
...
CLI
Rcall SetTimer
Rcall Suspend process
STI
...
*/
SetTimer: ;R17 - номер процесса, R18(L), R19(H)-
задержка
PUSH R16
PUSH R17
LDI ZL, Low(TimerQueue) ; начало массива таймеров
LDI ZH, High(TimerQueue)
LDI R16, 0
ROL R17 ; умножим адрес на два - таймеры
двухбайтные
ROL R16 ; а вдруг кто-то 129 процессов замутит:)
ADD ZL, R17 ; получаем адрес
ADC ZH, R16
ST Z+, R18 ; Ставим таймер
ST Z+, R19 ; Ставим таймер
POP R17
POP R16
RET ; выход
Функция проста — ищем нужный элемент в массиве и пишем туда значения
таймера. ВСЕ! Остальное будет делать диспетчер.
А теперь подумай: раз таймер измеряется в количестве переключений, разве
может он точно работать? Может. НО только в случае, если ты НИГДЕ
больше не используешь CLI/STI, SuspendProcess и таймеры других
процессов. Потому что в первом случае (cli/sti) просто диспетчер может
запоздать, во втором - тоже диспетчер опоздает, но уже намного (т.к.
большой кусок кода в CLI/SEI), а в третьем - если несколько таймеров
дотикают до нуля одновременно, то процессы поставятся в очередь по
возрастанию, и неизвестно, когда очередь дойдет до твоего процесса.
Я считал - вроде можно поставить двумя байтами задержку до 5.5 секунд.
Думаю, этого достаточно. Если хочешь - можно переписать под 3х байтовые
таймеры. Тогда будет до 1408 секунд.
И самая простая АПИ из всех, состоит из одной команды :D
; Процедура "Перейти к след. процессу" ------------------------------
/*
Usage:
надо, чтобы следующим процессом в очереди стал такой-то?
Ну просто позарез надо? Да еще чтоб запустился немедленно?
Тогда эта функция для вас!
Делаем так:
...
LDI R18, 1 ; Если задержка = 1 - процесс запустится
LDI R19, 0 ; при следущем переключении. Нам это и надо.
CLI
RCALL SetTimer ; Ставим таймер
RCALL SuspendProcess ; Отключим тот процесс, который надо поставить - он
уберется из очереди
RCALL GoToNextProc ; А функция - типа API ^_^ при переключении таймер
дотикает дло нуля
; и поставит процеес следующим в очереди
SEI ; чисто для приличия - RETI сам это сделает
*/
GoToNextProc:
CLI ; Защита (на всякий)
RJMP TM0_OVF ; Валим на прерывание таймера (не пашет? убери R)
RET ; Сюда вернется процесс, поэтому RET нужен.
Гениальнейшая функция!
Вот и все. Я детально описал всю свою операционку. Оптимизацией почти не
занимался, это думаю видно.
Конечно, на каком-нибудь АТМЕГА8/16 использовать такое не особенно
нужно. Однако, как я писал выше, основной целью написания этой
операционки было ознакомление с механизмом переключения процессов.
Искренне надеюсь, что ты понял все, что я писал.
На реальном девайсе я это ни разу не запускал, работал только с тремя
процессами в эмуляторе. Там ничего не слетало. Однако совершенно не
исключено, что там есть баги. Так что если кто все же надумает построить на
этом девайс - поаккуратнее. Сам исходник лежит по ссылке. Предупреждаю
— весь код в одном файле. Я очень не люблю структурность и раскидывание
на много файлов.
•
Архив с проектом
AVR. Учебный курс. Конечный автомат
Каждый кто пытался разбираться с конечными автоматами наверняка
натыкался на всякие замудреные графы, какие то графики. Многие посчитав
это слишком сложным плюнули и забили. А зря!
С простейшим конечным автоматом каждый из нас сталкивался с самого
детства — это механическая авторучка. Объект с единственной функцией
“Нажатие кнопки”, но в зависимости от очередности результат разный.
Стержень то прячется, то вылазит.
Так и в нашем случае — конечный автомат это функция которая запоминает
свое состояние и при следующем вызове делает свое черное дело исходя из
прошлого опыта. Простой пример — мигалка (псевдокод):
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
; Глобальные переменные
u08 Blink_State;
void Blink(void)
{
if (Blink_State == 1)
{
Led_On();
Blink_State = 0;
Return;
}
if (Blink_State == 0)
{
Led_Off();
Blink_State = 1;
Return;
}
}
Вызывая эту функцию подряд, мы заставим диодик менять свое состояние
при каждом вызове.
Но никто не мешает взять и сделать автомат куда сложней, на несколько
десятков состояний. Никто не запрещает использовать вложенные конечные
автоматы, никто не запрещает менять состояние автомата извне. В общем,