Золотовский Д.В. Учебный курс для новичков по микроконтроллерам AVR. Часть 1
Подождите немного. Документ загружается.
Работа диспетчера.
Когда наступает прерывание переполнения таймера — включается
диспетчер. Работает он на процессоре в 8МГЦ 58.5 микросекунд, так что не
мешает ни передачам данных (если конечно скорость не запредельная), ни
работе процессов. Диспетчер сохраняет все регистры текущего процесса,
адрес возврата, пересчитывает таймеры, запускает новые процессы (если их
таймер дотикал до нуля), после чего загружает регистры следующего
процесса из очереди, достает его адрес возврата и прыгает туда.
Схематично можно изобразить так:
Код
Примечание: крупные куски кода я распихал в макросы по смыслу - иначе
функция становилась абсолютно нечитаемой, разобраться было невозможно.
Поэтому не надо хвататься за голову и искать макросы - названия все говорят
сами за себя, а устройство потом опишу.
В коде полно мусора. Я это знаю. Писал операционку давно, много раз
апгрейдил, переделывал, оттуда столько и осталось.
Начну с подробного описания переменных.
В суть этой части переменных можно не вдаваться - это всего лишь
временные переменные. Весь прикол в том, что при переключении SP тоже
меняется, и использование стека становится до ужаса неудобным. К тому же
прогружать и без того некрупный стек не стоит.
.equ ProcDataSize = 64 ; память процесса
.equ ProcNum = 8 ; колчиество процессов
; Куча временных переменных, по большей части для перекидывания данных
TempProc: .byte 1 ; для распознания
SREGT: .byte 1 ; временная переменная под SREG
SPTL: .byte 1 ; под SPL
SPTH: .byte 1 ; под SPH
R16T: .byte 1 ; под R16 :)
ZLT: .byte 1 ; ZL
ZHT: .byte 1 ; ZH
ADDRL: .byte 1 ; адрес
ADDRH: .byte 1
TCurp: .byte 1 ; временный CurProc (см. ниже)
Дальше переменные очереди:
•
TasqQueue — очередь процессов. В ней находятся номера процессов в
определенном порядке.
•
LastItem — “указатель” на последний элемент очереди (именно
поэтому FF в конце очереди не используется: через указатель намного
удобнее работать).
•
CurProc — текущий номер процесса. Используется при переключении
и в SuspendProcess.
•
TimerQueue — МАССИВ таймеров. Да-да, именно массив. Саначала я
хотел делать очередь, но потом решил, что массив проще в реализации.
А имя осталось старым.
•
Proctable — таблица процессов. В нее при старте заносятся адреса всех
процессов, чтобы далее работать не с адресами, а с номерами, что
значительно упрощает программу.
; Очередь и все, что с ней связано
CurProc: .byte 1 ; Системная переменная, хранит номер
процесса
LastItem: .Byte 1 ; Номер последнего элемента
очереди (для удобства)
TaskQueue: .byte ProcNum+1 ; Очередь процессов
TimerQueue: .byte ProcNum*2 ; Массив таймеров
Proctable: .dw 1 ; Таблица адресов процессов
.dw 1 ; для наглядности - 8 процессов отдельно
.dw 1
.dw 1
.dw 1
.dw 1
.dw 1
.dw 1
И, пожалуй, самая важная часть операционки — место под данные
процессов. То самое, что описано в теории.
; Самое важное: место под стек и регистры.
; Сколько процессов - столько и этих записей
ProcData: .byte ProcDataSize
.byte ProcDataSize
.byte ProcDataSize
.byte ProcDataSize
.byte ProcDataSize
.byte ProcDataSize
.byte ProcDataSize
.byte ProcDataSize
Диспетчер.
Код диспетчера, как ни странно, прост. К тому же я его прокомментировал
достаточно подробно. Пробегись глазами.
TM0_OVF:
STS R16T, R16 ; Выковыриваем из стека адрес
POP R16 ; в переменные ADDRx
STS ADDRL, R16 ; предварительно сохранив регистр
R16
POP R16
STS ADDRH, R16
LDS R16, R16T
SaveRegs CurProc ; Сейвим регистры
SaveAddr CurProc
; Сохраняем адрес возврата
DecTimers ; Декаем таймеры
GetNextProc ; Берем следующуий процесс
STS ADDRL, ZL ; Сейвим адрес в ADDRx
STS ADDRH, ZH
loadRegs ; Грузим регистры
STS ZLT, ZL ; сохраняем Z, лишний раз не грузим стек
STS ZHT, ZH
LDS ZL, ADDRL ; ADDRx в Z
LDS ZH, ADDRH
PUSH ZL ; Пишем в стек адрес возврата
PUSH ZH
LDS ZL, ZLT ; и респим регистры Z
LDS ZH, ZHT
STS R16T,R16 ; сейвим R16
LDS R16, SREGT ; восстанавливаем SREG. ДАЛЕЕ НИКАКОЙ
МАТЕМАТИКИ!!!
OUT SREG, R16 ; а то испортим
OUTI TCNT0, 0 ; Обнуляем таймер
OUTI TIFR, 1 ; и его флаг прерывания
LDS R16, R16T ; вернем многостарадальный R16
RETI ; Валим нафиг
Первое, что я делаю — достаю из стека адрес возврата и сохраняю в
переменные. Зачем? А затем, что после некоторых манипуляций стек
переключится на другой процесс, а там будут уже совершенно другие
данные. Сохранится он потом в ProcTable. Сейчас ВРОДЕ БЫ код написан
так, что это не обязательно. Однако так надежнее, и, если что, проще
дописать новые возможности.
Далее пресловутое сохранение регистров, адреса, пересчет таймеров, переход
к следующей процедуре в очереди (доставание ее адреса), загрузка регистров
нового процесса. Под конец пишем в стек НОВЫЙ адрес возврата, для
другого процесса, и RETI прыгает туда.
Обрати внимание, что восстановление SREG из переменной идет в самом
конце диспетчера. Иначе при первой же математической операции (будь то
Add, Sub или даже INC) испортятся флаги. А я этого не хочу. Также в конце
сбрасывается таймер - одному Богу известно, сколько он там натикал за
время работы диспетчера, и сколько осталось до следующего вызова.
Чтож, настал час, когда я покажу тебе самое сложное для восприятия во всей
операционке — макросы. Вкратце со смыслом каждого думаю ты
ознакомился, прочитав комментарии к коду выше (или нет?).
3…2…1… Поехали!
; Макрос сохранения регистров процесса
.macro SaveRegs
STS ZLT, ZL ; Спасаем регистры
STS ZHT, ZH ; стараемся как можно меньше использовать
стек
STS R16T, R16
IN R16, SREG
STS SREGT, R16
LDS R16, TempProc ; Определяем, где этот макрос
применен
CPI R16, $FF ; В SuspendProcess или в
переключении
BRNE NoLoadNum
LDI ZL, low(TaskQueue) ; Получаем номер процесса из
очереди
LDI ZH, High(TaskQueue)
LDS R16, @0
ADD ZL, R16
LDI R16, 0
ADC ZH, R16
LD R16, Z
NoLoadNum:
STS TCurP, R16 ; И сохраняем в переменную
LDI ZL, low(Procdata) ; Получим адрес памяти процессора:
LDI ZH, High(Procdata)
Push R17 ; Снова спасаем регитсры
Push R0
Push R1
LDS R16, TCurP ; Получаем адрес памяти процесса
LDI R17, ProcDataSize
MUL R16, R17
ADD ZL, R0
ADC ZH, R1
Pop R1 ; Вернем регистры
Pop R0
Pop R17
LDS R16, R16T
ST Z+,R0 ; Долго и нудно их сейвим
ST Z+,R1
ST Z+,R2
ST Z+,R3
ST Z+,R4
ST Z+,R5
ST Z+,R6
ST Z+,R7
ST Z+,R8
ST Z+,R9
ST Z+,R10
ST Z+,R11
ST Z+,R12
ST Z+,R13
ST Z+,R14
ST Z+,R15
ST Z+,R16
ST Z+,R17
ST Z+,R18
ST Z+,R19
ST Z+,R20
ST Z+,R21
ST Z+,R22
ST Z+,R23
ST Z+,R24
ST Z+,R25
ST Z+,R26
ST Z+,R27
ST Z+,R28
ST Z+,R29
MOV YL, ZL ; Перекидываем адрес в Y
пару
MOV YH, ZH
LDS ZH, ZHT ; Достаем Z
LDS ZL, ZLT
ST Y+, R30 ; И сейвим его
ST Y+, R31
LDS R16, SREGT ; Сейвим SREG
ST Y+, R16
IN R16, SPL ; и Stack Pointer
ST Y+, R16
IN R16, SPH
ST Y+, R16
.endm
В самом начале я использую временные переменные для сохранения
регистров, чтобы лишний раз не нагружать стек. Потом идет распознание,
откуда его вызывали по переменной TempProc.
– Почему бы не использовать параметры макроса? - спросишь ты.
– А потому что переключение процессов иногда вызывается по прерыванию,
а иногда - в функции SuspendProcess. Получается, что макрос вызывается из
одного и того же места, но “это место” срабатывает по разным причинам:) и
надо как-то это отслеживать. — отвечу я.
Если TempProc = $FF - значит вызывали переключение по прерыванию, тогда
выполняется полный код: т.е. получаем номер процесса по текущему индексу
элемента в очереди. Если же нет - то не надо загружать номер процесса. Это
для SuspendProcess.
Сейвим регистры в стек — как раз те самые 3 байта. Здесь можно
использовать и временные переменные, но все равно макрос загрузки
регистров грузит стек на 3 байта. Можно и там использовать переменные, но
код становится совсем нечитаем, даже относительно того, чтоо счас. К тому
же это тоже остатки мусора.
Как получаю адрес памяти процесса — беру номер, умножаю на размер 1й
ячейки (64 байта) и получаю смещение. Прибавляю адрес первой и получаю
то, что надо.
И вот мы дошли до самого сохранения регистров. Я думаю, понятно, как оно
происходит до R29 :) Чтобы сохранить Z пару, делаю просто: Y пару менять
не страшно, ведь Y уже сохранен. Поэтому перекидываю туда адрес,
лежащий в Z, и сохраняю Z. Достаю заготовленный в самом начале макроса
SREG и пишу в память. И наконец, сохраняю стек.
Процедура загрузки похожа на сохранение, только все с точностью до
наоборот.
; Макрос загрузки регистров процесса
.macro LoadRegs
LDI ZL, low(TaskQueue) ; Грузим номер процесса из
очереди:
LDI ZH, High(TaskQueue) ; В Z - адрес очереди
процессов
LDS R16, CurProc ; В R16 - номер текущего
процесса в очереди
ADD ZL, R16 ; Прибавляем его к адресу
CLR R16
ADC ZH, R16 ; и грузим реальный номер
LD R16, Z
LDI ZL, low(Procdata) ; Вычисляем адрес данных
процесса
LDI ZH, High(ProcData)
LDI R17, ProcDataSize ; Address = ProcData +
ProcDataSize*N
MUL R16, R17 ; где N = R16, только что
грузили
ADD ZL, R0
ADC ZH, R1
LD R0, Z+ ; Респим регистры
LD R1, Z+
LD R2, Z+
LD R3, Z+
LD R4, Z+
LD R5, Z+
LD R6, Z+
LD R7, Z+
LD R8, Z+
LD R9, Z+
LD R10, Z+
LD R11, Z+
LD R12, Z+
LD R13, Z+
LD R14, Z+
LD R15, Z+
LD R16, Z+
LD R17, Z+
LD R18, Z+
LD R19, Z+
LD R20, Z+
LD R21, Z+
LD R22, Z+
LD R23, Z+
LD R24, Z+
LD R25, Z+
LD R26, Z+
LD R27, Z+
LD R28, Z+
LD R29, Z+
PUSH YL ; Сейвим Y пару
PUSH YH
MOV YL, ZL ; Перекидываем туды Z
MOV YH, ZH
LD R30, Y+ ; И восстанавливаем Z
LD R31, Y+
PUSH R16 ; Сейвим R16
LD R16, Y+
STS SREGT, R16 ; Грузим SREG
LD R16, Y+ ; ВНИМАНИЕ, ИЗВРАТ!
; (Ну почему изврат.
Нормальные будни ассемблерщика прим. DI HALT)
STS SPTL, R16 ; Сохраняем SP в
переменные
LD R16, Y+ ; это будет использоваться
далее
STS SPTH, R16 ; делается потому, что
нельзя здесь
; менять SP - в стеке наши
регистры
POP R16 ; Откапываем в
стеке сокровища
POP YH
POP YL
STS R16T, R16 ; Сейвим R16 в переменную
LDS R16, SPTL
OUT SPL, R16 ; Из переменных для SP
грузим SP
LDS R16, SPTH
OUT SPH, R16
LDS R16, R16T ; И возвращаем R16
; Всё, изврат закончился.
.endm ; Итог: восстановили все
регистры и SP
Здесь уже с предварительным сохранением регистров можно не париться.
Мы же их все равно загружаем. Начало то же самое, что и в сохранении
после проверки TempProc. Загружаем все регистры, так же перекидываем Z в
Y и т.д. А вот в конце интересная вещь: если загружать значения SP прямо по
ходу, то получится, что Y положится в стек одного процесса, а вынется из
стека другого! Естественно, это будет полный бред. Поэтому гружу значения
SP в переменные, достаю Y и R16, и только потом переношу в SP.
Поздравляю, мы уже на пол-пути.
; Макрос сохранения адреса возврата в таблицу
.macro SaveAddr
LDS R16, TempProc ; Определим, откуда
вызвали
CPI R16, $FF
BRNE NoLoadNumA
LDS R16, @0
LDI ZL, low(taskQueue) ; берем номер процесса из
очереди
LDI ZH, High(taskQueue)
ADD ZL, R16
LDI R16, 0
ADC ZH, R16
LD R16, Z
NoLoadNumA:
LDS YL, ADDRL ; грузим засейвенный адрес
LDS YH, ADDRH
LDI ZL, low(Proctable) ; И сейвим его!
LDI ZH, High(ProcTable)
LSL R16
ADD ZL, R16
LDI R16, 0
ADC ZH, R16
ST Z+, YH
ST Z+, YL
.endm
Все просто, только много кода. Если вызывается из диспетчера — то достаем
номер процесса из очереди, идем в таблицу и пишем туда наш адрес из
ADDRx. О SuspendProcess - позже.
Идем дальше:
; Макрос получения след. процесса по очереди-------------------