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

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

а значит выбирается адрес ячейки где лежит адрес на Way0. Следом за ней в памяти

сразу же

находится адрес Way1, Разница между ними два байта (так как сами адреса

двубайтные).

Таким образом, если в R20 будет число 1, то команда LSL умножит его на 2 и будет

указан на

адрес ячейки с Way1 и так далее. А что же дальше? А дальше, конечно же: */

IJMP ; Обана и переход на наш выбранный Way.

Понравилось?

; То ли еще будет :)

Но если хотите поломать себе мозг, то попробуйте исходник который я писал

для статьи про трояна в мобильный телефон на базе Атмеги. Там конвейер за

конвейером. Текстовые строки превращаются в последовательности АТ

команд, воспроизводящие буквы на сотовом телефоне (Б, например, это два

нажатия на двойку и так далее). И вся это бодяга в виде кучи адресных

таблиц хранится в памяти.

Товарищи тут напоминают, что данный метод может быть реализован далеко

не во всех AVR. Да, это так, дело в том, что система команд у разных AVR

немного отличается, например некоторые младшие модели (вроде Tiny 11/12)

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

внимательно систему команд на конкретный контроллер. Но обычно такая

фича есть.

Также, можно объединять конструкцию из CPI/BREQ с таблицами

переходов. Чтобы получать неравномерные таблицы, в которых значения

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

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

обрабатываем отдельными CPI/BR** конструкциями.

В результате получаем очень компактный и быстрый код. Который не

сможет переплюнуть по оптимальности ни один оптимизирующий

компилятор.

Командные конвейеры.

Еще мощнейшим инструментом является конструкция под названием

командный конвейер. Термин я сам придумал , так что не придирайтесь.

Идея в чем — у нас есть множество процедур, делающий какие либо

односложные операции. Если, например, это ЧПУ станок то операции могут

быть такие:

•

Поднять резец

•

Опустить резец

•

Включить подачу

•

Включить привод

•

Подать на один шаг вперед

•

Подать на один шаг назад

•

Подать влево

•

Подать вправо.

А нам надо выточить деталь. И для этого есть ТЗ, где сказано, в какой

последовательности эти операции должны быть выполнены, чтобы получить

нужную деталь. Причем программа то у нас одна, а последовательности

разные.

Не переписывать же код каждый раз. В этом случае можно сделать

командный конвейер.

Команды у нас четко определены, так что мы их можем записать в виде

процедур ассемблерных:

BladeUP:

NOP

RET

BladeDN: NOP

NOP

RET

DriveON: NOP

NOP

RET

DriveOFF: NOP

NOP

RET

Forward: NOP

NOP

RET

Back: NOP

NOP

RET

И так далее, все нужные команды.

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

адресами процедур.

Index: .

BladeUP, BladeDN, DriveON, DriveOFF, Forward, Back

А в памяти ОЗУ заводится очередь задач. Обычный строковый массив

нужной длины:

TaskList: .

byte

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

в виде последовательности кодов этих действий. Всего лишь смещение по

таблице! Очень быстрое и компактное! И вызывается диспетчер очереди.

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

нее номера подпрограмм, по таблице, смещением, вычислять адреса

переходов на реальные процедуры, переходить по ним, делать полезное

действие, возвращаться обратно и брать новое значение из таблицы.

Чуете, куда я клоню? Получается своеобразная виртуальная машина.

Процессор в процессоре. Более того, сами задачи, вызываемые из очереди, не

обязательно должны быть тупо выполняющими конкретное действие. Они же

тоже могут набрасывать в эту самую очередь новых кодов, сортировать и на

ходу их переделывать. Получается мощный полиморфный алгоритм,

который может сам менять свою логику исходя из условий.

Позже, я на этом принципе покажу прообраз операционной системы. С

диспетчером задач и кучей потоков, вызывающих друг друга по цепочке.

А еще на индексных переходах можно делать очень компактные конечные

автоматы. Причем даже адрес не надо будет вычислять т.к. в виде текущего

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

автомата.

Если не понял о чем идёт речь, то не забивай пока голову. Дальше будет на

это дело отдельная статья. Или помучай вопросами интернет на предмет

того, что такое конечные автоматы и как они реализуются.

AVR. Учебный Курс. Типовые конструкции

При написании программ постоянно приходится использовать разные

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

сравнения. Всякие там if-then-else или case-switch. В высокоуровневых

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

раз заново.

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

тропинке применяются везде, где потребуется. Заодно и оптимизируются по

ходу процесса.

Условие if-then-else

Тут проще всего методом последовательной проверки проложить маршрут до

нужного блока кода. Приведу пример:

if (А>=B)

{

action_a

}

else

{

action_b

}

next_action

Как это проще всего сделать на ассемблере?

Считаем, что А в R16,B в R17, а полезные действия, которые могли бы быть

там, заменяем на NOP,NOP,NOP.

Сравнение делается путем вычитания. По итогам вычитания выставляются

флаги. Заем (когда A стало меньше B) означает, что условие не выполнилось.

R16,R17 ; Сравниваем два значения

BRCS action_b ; когда A>=B флага С не будет

; Перехода не произойдет

action_a: NOP ; и выполнится действие А

NOP

RJMP next_action ; Но чтобы действие B не произошло

; в ходе естественного выполнения

; кода -- его надо перепрыгнуть.

action_b: NOP ; Действие B

NOP

next_action

: NOP

NOP

Но надо учитывать тот момент, что в случае А=B флаг С не вылезет, зато

будет флаг Z. Но переход то у нас исходя из какого-нибудь одного флага (по

С=0 или по С=1). И, исходя из выбора команды для построения конструкции

if-then-else (BRCC или BRCS), будет разная трактовка результата условия if

(А>=B) в случае А=B.

В одном случае (нашем), где переход идет на else по С=1, А=B будет

эквивалентно А>B — флага C не будет. И в том и другом случае услове if

(А>=B) даст True и переход по BRCS на then.

Если перестроить конструкцию наизнанку, через команду BRCC то условия

(А>=B) уже не получится. При A=B не будет флага С и произойдет переход

по BRCC на else.

Для создания строгих неравенств нужна проверка на ноль.

Теперь А больше B:

if (А>B)

{

action_a

}

else

{

action_b

}

next_action

Получили:

R16,R17 ; Сравниваем два значения

BREQ action_b ; Если равно (флаг Z), то переход сразу.

; Потом проверяем второе условие.

BRCS action_b ; когда A>B флага С не будет

; Перехода не произойдет

action_a: NOP ; и выполнится действие А

NOP

RJMP next_action ; Но чтобы действие B не произошло

; в ходе естественного выполнения

; кода -- его надо перепрыгнуть.

action_b: NOP ; Действие B

NOP

next_action: NOP

NOP

Сложно? Думаю нет.

Усложним еще раз наше условие:

if (C<A AND A<B)

{

action_a

}

else

{

action_b

}

next_action

Считаем, что A=R16, B=R17, С=R18

;IF

CP R16,R18 ; Сравниваем С и А

BREQ action_b ; Переход сразу на ELSE если С=А

BRCS action_b ; Если А оказалось меньше, то будет С

; и сразу выходим отсюда на else

; Но если C<A то идем дальше и

проверяем

; Второе условие (A<B)

CP R16,R17 ; Сравниваем два значения

; BREQ action_b ; Переход на ELSE если B=А. Команда BREQ

специально

; закомментирована -- она тут не нужна.

Я ее поставил

; для наглядности. Ведь в случае А=B

; флага С не будет и однозначно будет

переход по BRCC.

BRCC action_b ; Когда A>B флага С не будет

; А переход по условию С clear сработает.

;THEN

action_a: NOP ; Выполнится действие А

NOP

RJMP next_action ; Но чтобы действие B не произошло

; в ходе естественного выполнения

; кода -- его надо перепрыгнуть.

;ELSE

action_b: NOP ; Действие B

NOP

next_action: NOP

NOP

Просто же! Вот так вот, комбинируя условия, можно размотать любую

логическую конструкцию.

Битовые операции.

Но, пожалуй, самые распространенные операции в контроллере — битовые.

Включить выключить какой-нибудь параметр, инвертировать его, проверить

есть или нет. Да масса случаев где это нужно. Основная масса операций идет

через битовые маски.

Есть замечательные команды SBI и CBI первая ставит указанный бит в

порту, вторая сбрасывает. Например:

CBI PORT,7 - обнулить 7й бит в регистре ввода-вывода PORT

SBI PORT,6 - выставить 6й бит в регистре ввода-вывода PORT

Все замечательно, но работают эти команды только в пределах первых 31

адресов в пространстве регистров ввода вывода. Для мега16 это:

.equ EEARH = 0x1f

.equ EEDR = 0x1d

.equ EECR = 0x1c

.equ PORTA = 0x1b

.equ DDRA = 0x1a

.equ PINA = 0x19

.equ PORTB = 0x18

.equ DDRB = 0x17

.equ PINB = 0x16

.equ PORTC = 0x15

.equ DDRC = 0x14

.equ PINC = 0x13

.equ PORTD = 0x12

.equ DDRD = 0x11

.equ PIND = 0x10

.equ SPDR = 0x0f

.equ SPSR = 0x0e

.equ SPCR = 0x0d

.equ UDR = 0x0c

.equ UCSRA = 0x0b

.equ UCSRB = 0x0a

.equ UBRRL = 0x09

.equ ACSR = 0x08

.equ ADMUX = 0x07

.equ ADCSRA = 0x06

.equ ADCH = 0x05

.equ ADCL = 0x04

.equ TWDR = 0x03

.equ TWAR = 0x02

.equ TWSR = 0x01

.equ TWBR = 0x00

И ни байтом дальше. А с более старшими адресами — облом.

Ну ничего, что нам мешает взять и записать в регистр ввода-вывода (далее

РВВ, а то я уже замучился). Этот бит самому?

Только то, что доступ там к порту идет не побитный, а сразу целыми

байтами.

Казалось бы, в чем проблема? Надо выставить биты 1 и 3 в регистре TWCR,

например, взял да записал двоичное число 00001010 и выставил.

LDI

R16,1<<3|1<<1

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

а то ведь мы их все накроем сразу.

В таком случае, алгоритм у нас такой:

•

Взять старое значение

•

Подправить в нем биты

•

Записать обратно

Запишем это в коде. Взять значение просто:

R16,TWCR

А установить нужные биты нам поможет битовая маска и операция OR. В

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

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

ORI

R16,1<<3|1<<1 ; Битовая маска 00001010

А затем записать уже измененный байт обратно

OUT

TWCR,R16

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

AND. И там где мы хотим сбросить нам надо поставить в маске 0, а где не

хотим менять 1

Удобней делать инверсную маску. Для инверсии маски применяется

операция побитового НЕ ~

Выглядеть будет так:

R16,TWCR

ANDI R16,~(1<<3|1<<1)

OUT TWCR,R16

Обрати внимание, для сброса у нас внутри конструкции используется 1. Ведь

байт то потом инвертируется! Для инверсии битов применяется маска по

XOR. Нули в этой маске не меняют биты, а единичка по XOR бит

инвертирует. Смотри сам, вверху произвольное число, внизу маска:

1100 1100

XOR

1111 0000

_________

0011 1100

Правда есть одно ограничение — нет команды XOR маски по числу, поэтому

через регистр.