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

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

AVR. Учебный курс. Стартовая инициализация

Инициализация памяти

Мало кто подозревает о том, что при включении в оперативке далеко не

всегда все байты равны 0xFF. Они могут, но не обязаны. Равно как и

регистры РОН не всегда равны нулю при запуске. Обычно да, все обнулено,

но я несколько раз сталкивался со случаями, когда после перезапуска и/или

включения-выключения питания, микроконтроллер начинал творить не

пойми что. Особенно часто возникает, когда питание выключаешь, а потом,

спустя некоторое время, пара минут, не больше, включаешь. А всему виной

остаточные значения в регистрах.

Итак, возьмите себе за правило после каждого включения, в разделе

инициализации, еще даже до инициализации стека, делать обнуление памяти

и очистку всех регистров. Разумеется, делается это все в цикле. Вот

примерный вариант кода:

RAM_Flush:

LDI

ZL,

Low

(

SRAM_START

)

; Адрес начала ОЗУ в индекс

LDI ZH,High(SRAM_START)

CLR R16 ; Очищаем R16

Flush: ST Z+,R16 ; Сохраняем 0 в ячейку памяти

CPI ZH,High(RAMEND+1) ; Достигли конца оперативки?

BRNE Flush ; Нет? Крутимся дальше!

CPI ZL,Low(RAMEND+1) ; А младший байт достиг конца?

BRNE Flush

CLR ZL ; Очищаем индекс

CLR ZH

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

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

в младшем байте адреса.

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

к работе.

LDI

ZL, 30 ; Адрес самого старшего регистра

CLR ZH ; А тут у нас будет ноль

DEC ZL ; Уменьшая адрес

ST Z, ZH ; Записываем в регистр 0

BRNE PC-2 ; Пока не перебрали все не успокоились

За процедуру обнуления регистров спасибо. Либо значения сразу же

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

пляшу. Поэтому обнуляю все.

P.S. Кстати, о оперативке. Нашёл я недавно планку оперативной памяти на

1килобайт, древнюю как кости мамонта, еще на ферромагнитных кольцах.

AVR. Учебный курс. Скелет программы

При написании прошивки надо очень внимательно подходить к процессу

организации архитектуры будущей программы. Программа должна быть

быстрой, не допускать задержек главного цикла и легко расширяться.

Оптимально использовать аппаратные ресурсы и стараться выжать максимум

возможного из имеющихся ресурсов.

Вообще, архитектура программ это отдельная тема и ближе к концу курса, в

его Сишной части я подробней рассказываю о разных типах организации

прошивки. Можешь забежать вперед и поглядеть, что да как.

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

— флаговом автомате, а позже, когда ты уже будешь вовсю ориентироваться

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

описанием его работы.

Суперцикл

Все программы на микроконтроллерах обычно зацикленные. Т.е. у нас есть

какой то главный цикл, который вращается непрерывно.

Структура же программы при этом следующая:

•

Макросы и макроопредения

•

Сегмент ОЗУ

•

Точка входа - ORG 0000

•

Таблица векторов - и вектора, ведущие в секцию обработчиков

прерываний

•

Обработчики прерываний - тела обработчиков, возврат отсюда

только по RETI

•

Инициализация памяти - а вот уже отсюда начинается активная часть

программы

•

Инициализация стека

•

Инициализация внутренней периферии - программирование и

запуск в работу всяких таймеров, интерфейсов, выставление портов

ввода-вывода в нужные уровни. Разрешение прерываний.

•

Инициализация внешней периферии - инициализация дисплеев,

внешней памяти, разных аппаратных примочек, что подключены к

микроконтроллеру извне.

•

Запуск фоновых процессов - процессы работающие непрерывно, вне

зависимости от условий. Такие как сканирование клавиатуры,

обновление экрана и так далее.

•

Главный цикл - тут уже идет вся управляющая логика программы.

•

Сегмент ЕЕПРОМ

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

.include "m16def.inc" ; Используем ATMega16

;= Start macro.inc ========================================

.macro OUTI

LDI R16,@1

.if @0 < 0x40

OUT @0,R16

.else

STS @0,R16

.endif

.endm

.macro UOUT

.if @0 < 0x40

OUT @0,@1

.else

STS @0,@1

.endif

.endm

;= End macro.inc =======================================

В оперативке пока ничего не размечаем. Нечего.

; RAM ===================================================

.DSEG

; END RAM ===============================================

С точкой входа и таблицей векторов все понятно, следуя нашему давнему

шаблону, берем его оттуда:

; FLASH ======================================================

.CSEG

.ORG $000 ; (RESET)

RJMP Reset

.ORG $002

RETI ; (INT0) External Interrupt Request 0

.ORG $004

RETI ; (INT1) External Interrupt Request 1

.ORG $006

RETI ; (TIMER2 COMP) Timer/Counter2 Compare Match

.ORG $008

RETI ; (TIMER2 OVF) Timer/Counter2 Overflow

.ORG $00A

RETI ; (TIMER1 CAPT) Timer/Counter1 Capture Event

.ORG $00C

RETI ; (TIMER1 COMPA) Timer/Counter1 Compare Match A

.ORG $00E

RETI ; (TIMER1 COMPB) Timer/Counter1 Compare Match B

.ORG $010

RETI ; (TIMER1 OVF) Timer/Counter1 Overflow

.ORG $012

RETI ; (TIMER0 OVF) Timer/Counter0 Overflow

.ORG $014

RETI ; (SPI,STC) Serial Transfer Complete

.ORG $016

RETI ; (USART,RXC) USART, Rx Complete

.ORG $018

RETI ; (USART,UDRE) USART Data Register Empty

.ORG $01A

RETI ; (USART,TXC) USART, Tx Complete

.ORG $01C

RETI ; (ADC) ADC Conversion Complete

.ORG $01E

RETI ; (EE_RDY) EEPROM Ready

.ORG $020

RETI ; (ANA_COMP) Analog Comparator

.ORG $022

RETI ; (TWI) 2-wire Serial Interface

.ORG $024

RETI ; (INT2) External Interrupt Request 2

.ORG $026

RETI ; (TIMER0 COMP) Timer/Counter0 Compare Match

.ORG $028

RETI ; (SPM_RDY) Store Program Memory Ready

.ORG INT_VECTORS_SIZE ; Конец таблицы прерываний

Обработчики пока тоже пусты, но потом добавим

; Interrupts ==============================================

; End Interrupts ==========================================

Инициализация ядра. Память, стек, регистры:

Reset: LDI R16,Low(RAMEND) ; Инициализация стека

OUT SPL,R16 ; Обязательно!!!

LDI R16,High(RAMEND)

OUT SPH,R16

; Start coreinit.inc

RAM_Flush: LDI ZL,Low(SRAM_START) ; Адрес начала ОЗУ в индекс

LDI ZH,High(SRAM_START)

CLR R16 ; Очищаем R16

Flush: ST Z+,R16 ; Сохраняем 0 в ячейку памяти

CPI ZH,High(RAMEND) ; Достигли конца оперативки?

BRNE Flush ; Нет? Крутимся дальше!

CPI ZL,Low(RAMEND) ; А младший байт достиг

конца?

BRNE Flush

CLR ZL ; Очищаем индекс

CLR ZH

CLR R0

CLR R1

CLR R2

CLR R3

CLR R4

CLR R5

CLR R6

CLR R7

CLR R8

CLR R9

CLR R10

CLR R11

CLR R12

CLR R13

CLR R14

CLR R15

CLR R16

CLR R17

CLR R18

CLR R19

CLR R20

CLR R21

CLR R22

CLR R23

CLR R24

CLR R25

CLR R26

CLR R27

CLR R28

CLR R29

; End coreinit.inc

Всю эту портянку можно и нужно спрятать в inc файл и больше не трогать.

Секции внешней и внутренней инициализации переферии пока пусты, но

ненадолго. Равно как и запуск фоновых программ. Потом я просто буду

говорить, что мол добавьте эту ботву в секцию Internal Hardware Init и все :)

; Internal Hardware Init ======================================

; End Internal Hardware Init ===================================

; External Hardware Init ======================================

; End Internal Hardware Init ===================================

; Run ==========================================================

; End Run ======================================================

А теперь, собственно, сам главный цикл

; Main =========================================================

Main:

JMP Main

; End Main =====================================================

Все процедуры располагаются в отдельной секции, не смешиваясь с главным

циклом. Так удобней, потом можно их по частям вынести в библиотечные

файлы и разделить исходник на несколько файлов. Но мы пока это делать не

будем. Разделим их просто логически.

; Procedure ====================================================

; End Procedure ================================================

Ну и вот тебе файлик с уже готовым проектом под этот шаблон.

AVR. Учебный курс. Операционная система. Введение.

Рано или поздно наступает момент когда сложность алгоритма становится

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

нетривиальную задачу. Очень легко запутаться и тяжело отлаживать эту

портянку. Многие бегут от этих сложностей в языки высокого уровня,

впрочем это не особо спасает — разница минимальна на самом деле и проще

не становится.

Самое верное решение в данном случае — внедрение в проект операционной

системы. Которая бы предоставляла API для решения задач, а также

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

В результате было написано микроядро. Камрад Serg2×2 подглядел

концепцию в прошивке сотового телефона Motorola и портировал на

микроконтроллер АТ89С2051, после ее перенесли на AVR, а я привел все в

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

также подробно описал и задокументировал. Так что теперь интеграция ядра

операционки в проект под микроконтроллер AVR занимает буквально пару

минут работы Copy-Paste.

Ядро обеспечивает очередь задач (пока без приоритетов, но это в планах) и

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

соответствующие ограничения на стиль написания. Фактически, каждую

процедуру мы пишем как прерывание, максимально коротко и быстро, все

задержки вешая на службу таймеров.

Параметры и системные требования микроядра:

•

Занимаемый обьем в Flash - 500 байт, при желании можно ужать до

400 байт, выкинув ненужные функции.

•

Рекомендуемый объем RAM - не менее 20 байт+стек, впрочем, можно

еще ужать если нагрузка небольшая.

•

Крайне желательная поддержка команд STS и LDS, можно и без них,

но неудобно. Впрочем, макросы решают.

Суть всех заморочек

Представь что ты пишешь простейшую программу — мигнуть светодиодом.

Как ты это будешь реализовывать?

На ум сразу же приходит следующий алгоритм:

•

Зажечь диод.

•

Потупить в цикле

•

Погасить диод.

Просто, логично, понятно.

А если усложнить? Мигать будем не одним диодом, а тремя, да еще чтобы

первый мигал с частотой в 1кГц, второй в 500Гц, а третий 200Гц. Представил

сразу же в голове алгоритм? Наверняка тут же получил переклин мозга и

немудрено. Линейно развернуть такую структуру весьма сложно, даже если

применить таймеры. Да, на таймерах выкрутишься, но это пока диодов три, а

если десять?

Как то же самое делается на микроядре:

Главный цикл

•

Вызов задачи 1

•

Вызов задачи 3

•

Вызов задачи 5

•

Бесконечный цикл ожидания с опросом очереди

Таблица задач

•

Задача_1: Зажечь диод 1. Поставить вызов задачи 2 в очередь с

задержкой 1мс

•

Задача_2: Погасить диод 1. Поставить вызов задачи 1 в очередь с

задержкой 1мс

•

Задача_3: Зажечь диод 2. Поставить вызов задачи 4 в очередь с

задержкой 2мс

•

Задача_4: Погасить диод 2. Поставить вызов задачи 3 в очередь с

задержкой 2мс

•

Задача_5: Зажечь диод 3. Поставить вызов задачи 6 в очередь с

задержкой 5мс

•

Задача_6: Погасить диод 3. Поставить вызов задачи 5 в очередь с

задержкой 5мс

Все. Основной алгоритм получается практически линейным. Остальное

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

любом порядке. И это практически не повлияет на выполнение остального

кода, разве что придется немного скорректировать настройки таймера.

По договоренности с издательством Gameland я, до выхода журнала не буду

раскрывать всех подробностей. В мартовском журнале Хакер будет статья по

микроядру, после выхода журнала я еще немного подожду и со спокойной

душой продолжу.

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

там как. Может разберётесь.

AVR. Учебный курс. Операционная система. Диспетчер задач.

В прошлой части возник вопрос организации программы по задачам. Чтобы

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

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

Затык, конечно может быть, это все же не вытесняющая многозадачность с

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

Общая диаграмма работы ОС

Что из себя представляет задача

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

RCALL с тремя отличиями:

•

Вызывается она не мгновенно, а в порядке очереди.

•

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

таблице переходов.

•

Возврат из нее идет не в то же место откуда вызывали, а в цикл

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

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

либо замудреностей.