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

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

; End Main

=====================================================

; Procedure

====================================================

.equ LowByte = 255

.equ MedByte = 255

.equ HighByte = 255

Delay: LDI R16,LowByte ; Грузим три байта

LDI R17,MedByte ; Нашей выдержки

LDI R18,HighByte

loop: SUBI R16,1 ; Вычитаем 1

SBCI R17,0 ; Вычитаем только С

SBCI R18,0 ; Вычитаем только С

BRCC Loop ; Если нет переноса - переход

RET

; End Procedure

================================================

Прошили, запустили… О да, теперь мигание будет заметно.

При параметрах 255.255.255 длительность выдержки на 8Мгц будет около 2.1

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

Тогда можно хоть час зарядить.

Но этот метод ущербен, сейчас покажу почему.

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

что когда кнопка нажата у нас горит LED1, а когда отпущена горит LED2.

В качестве кнопки возьмем тактовую A, подключим ее к порту PD6.

Проверка кнопки делается командой SBIC, но вначале ее надо

инициализировать. Сделать DDR=0, PORT=1 — вход с подтяжкой.

Добавляем в секцию инициализации (Internal Hardware Init) эти строчки:

SETB

PORTD,6,R16

CLRB DDRD,6,R16

Всё, всё настроено как надо.

Осталось теперь проверить нажата ли кнопка или нет. Если нажата, то в бите

PIND.6 будет 0.

; Main

=======================================================

Main: SBIS PIND,6 ; Если кнопка нажата - переход

RJMP BT_Push

SETB PORTD,5 ; Зажгем LED2

CLRB PORTD,4 ; Погасим LED1

Next: INVB PORTD,7,R16,R17 ; Инвертировали LED3

RCALL Delay

JMP Main

BT_Push: SETB PORTD,4 ; Зажгем LED1

CLRB PORTD,5 ; Погасим LED2

RJMP Next

; End Main

=====================================================

Ну что, работает! Кнопочка жмётся - диодики меняются. Третий же бодро

подмигивает. Но есть один неприятный нюанс (смотри видео):

Влияние тупых задержек на работу программы

Тормозит программка то! Я кнопочку нажал, а картинка не сменилась, нужно

подождать, подержать… Почему? А это из-за нашего тупого кодинга.

Помнишь, я тебе говорил, что тупые задержки, в которых МК ничего не

делает это адское зло? Вот! Теперь ты в этом убедился сам. Чтож, со злом

надо бороться. Как? Ну это я тоже уже говорил — делать непрерывный цикл

с флажками. Хотя бы внести в нашу задержку полезную работу.

Шарманка.

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

как она устроена?

Там барабан с торчащими гвоздями и пружинки на разные тона. Гвозди

вращаются, дергают пружинки - они звякают. Получается расколбасный

музон. А что если нашу шарманку развернуть в ленту. Не правда ли гвозди

похожи на единички ? ;))))

Лентой будет счетчик, считающий от нуля, скажем, до FF.FF.FF.FF и потом

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

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

— сравнивая свою константу с текущим значением счетчика.

Совпало? Делаем “ДРЫНЬ!”

Осталось только прописать на временном цикле нашей шарманки где и что

должно запускаться. И тут есть одна очень удобная особенность — для

построения циклических последовательностей нам достаточно отлавливать

один разряд.

Скажем, считает шарманка от 0 до 1000, а нам надо 10 раз мигнуть диодом.

Не обязательно втыкать 10 обработчиков с разными значениями. Достаточно

одного, но чтобы он ловил значение **10. Все, остальное нам не важно. И

сработает он на 0010, 0110, 0210, 0310, 0410, 0510, 0610, 0710, 0810, 0910.

Более частые интервалы также делятся как нам надо, достаточно влезть в

другой разряд. Тут надо только не забыть отрезать нафиг старшие разряды,

чтобы не мешались.

А учитывая, что считать мы там будем в двоичном системе, то ловить

кодовую посылку станет еще приятней — хлоп ее по битмаске и все. Даже

проверять все байты не нужно.

Приступим. Вначале создадим наш счетчик в сегменте данных:

; RAM

========================================================

.DSEG

CCNT: .byte 4

Дальше сформируем цикл счетчика, нам надо чтобы он тикал каждый

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

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

LDS

R16,CCNT

LDS R17,CCNT+1

LDS R18,CCNT+2

LDS R19,CCNT+3

Все, теперь в R16 самый младший байт нашего счетчика, а в R19 самый

старший.

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

другой совет — когда пишешь программу, продумывай алгоритм так, чтобы

использовать регистры как сплошной TEMP данные которого актуальны

только здесь и сейчас. А что будет с ними в следующей процедуре уже не

важно — все что нужно должно будет сохранено в оперативке.

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

учесть все переполнения.

По можно сделать так:

LDI

R20,1 ; Нам нужна единичка

CLR R15 ; А еще нолик.

ADD R16,R20 ; Прибавляем 1 если в регистре 255, то будет С

ADC R17,R15 ; Прибавляем 0+С

ADC R18,R15 ; Прибавляем 0+С

ADC R19,R15 ; Прибавляем 0+С

Пришлось потратить еще два регистра на хранение констант нашего

сложения. Все от того, что AVR не умеет складывать регистры с

непосредственным числом. Зато умеет вычитать.

Я уже показывал, что R-(-1)=R+1, а ведь никто не запрещает нам этот же

прием устроить и тут — сделать сложение через вычитание.

SUBI

R16,

(

-1

)

SBCI R17,(-1)

SBCI R18,(-1)

SBCI R19,(-1)

Даст нам инкремент четырехбайтного числа R19:R18:R17:R16

А теперь я вам покажу немного целочисленной магии

Почему это будет работать? Смотри сам:

SUBI R16,(-1) это, по факту R16 - 255 и почти при всех раскладах она нам

даст нам заём из следующего разряда - С. А в регистре останется то число на

которое больше.

Т.е. смотри как работает эта математика, вспомним про число в доп кодах.

Покажу на четырехрязрядном десятичном примере. У Нас есть ВСЕГО

ЧЕТЫРЕ РАЗРЯДА, ни больше ни меньше. Отрицательное число это 0-1 так?

Окей.

0000-1=9999+C

Т.е. мы как бы взяли как бы из пятиразрядной 1

0000 отняли 1, но разрядов

то у нас всего четыре! Получили доп код 9999 и флаг заема С

(сигнализирующий о том, что был заем)

Т.е. в нашей целочисленной математике 9999=-1 :) Проверить легко -1+1 = 0

Верно?

9999+1 = 1

0000 Верно! :))) А 1 старшего разряда банально не влезла в

разрядность и ушла в флаг переноса C, сигнализирующего еще и о

переполнении.

Оки, а теперь возьмем и сделаем R-(-1). Пусть R=4

0004-9999 = 0005+С

Вот так вот взяли и сложили через вычитание. Просто магия, да? ;)

Прикол ассемблера в том, что это всего лишь команды, а не доктрина и не

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

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

Вот и тут — наш счетчик он же беззнаковый, но мы используем особенности

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

Флаг С не выскочит лишь когда у нас дотикает до 255 (9999 в десятичном

примере), тогда будет 255-255 = 0 и вскочит лишь Z, но нам он не нужен.

А дальше, вторая команда работает также, только с учетом знака

SBCI

R17,

(

-1

)

Т.е. R17-(-1)-1

, а поскольку С у нас всегда (кроме последнего случая перед

переполнением), то до тех пор пока значение R16 не достигнет 255 (и флаг C

не пропадет) у нас будет R17+1-1

=R17. Как только флаг пропадет, тогда и

случится инкремент второго байта R17+1-0

. А там по цепочке и все

остальные.

Короче, хоть 100 байтную переменную создавай и таким образом ее

прощелкивай.

А потом выгружаешь регистры обратно в память:

STS

CCNT,R16

STS CCNT+1,R17

STS CCNT+2,R18

STS CCNT+3,R19

Код Инкремента четырехбайтной константы в памяти можно свернуть в

макрос, чтобы не загромождать код

MACRO

INCM

LDS R16,@0

LDS R17,@0+1

LDS R18,@0+2

LDS R19,@0+3

SUBI R16,(-1)

SBCI R17,(-1)

SBCI R18,(-1)

SBCI R19,(-1)

STS @0,R16

STS @0+1,R17

STS @0+2,R18

STS @0+3,R19

.ENDM

Теперь осталось прикинуть как будет мигать наш диодик по шарманке. Для

этого давай посчитаем длительность цикла.

; Main

========================================================

Main: SETB PORTD,4 ; Зажгли LED1

INVB PORTD,7,R16,R17 ; Инвертировали LED3

Next: INCM CCNT

JMP Main

Запусти режим отладки и поставь точку останова (F9) на метку Main и загони

курсор на первый брейкпоинт.

Увеличить

Сбрось StopWatch и Cycle Counter, а потом сделай одну итерацию цикла. У

меня студия показала 25 машинных циклов и 3.3 микросекунды времени. Это

длительность одной итерации.

Теперь посчитаем сколько нам надо таких итераций на секунду. 1/0.75E-6 =

303 030 оборота. Что дофига :) Посчитаем это в байтах нашей шарманки,

просто переведем в 16тиричную систему. Получим 0х049FB6 или, если

побайтно, то

0хB6

(

CCNT

)

0х9F(CCNT+1)

0х04(CCNT+2)

0x00

(

CCNT+3

)

Осталось теперь только сравнить число с этим слепком.

Как сравнивать? Да довольно просто. Все зависит от того что мы хотим

получить. Если ОДНО событие за ВЕСЬ период глобального счетчика нашей

шарманки, то тупо, побайтно. В этом случае у тебя диодик моргнет через

секунду после старта, а дальше ты будешь ждать пол часа до переполнения

всего четырехбайтного счетчика.

Чтобы он моргал каждую секунду тебе надо при сравнении замаскировать

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

меньше (и переполняется он чаще).

Младшие байты сравниваем как есть, а самый старший только до его

максимального разряда, остальные надо отрезать.

Т.е. самый старший разряд для этого случая это CCNT+2=0х04 если в

двоичном представлении то 0х04 = 00000100 так вот, счетчик у нас четырех

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

00 04 9F B6 (00000000 00000100 10011111 10110110)

до переполнения возникнет дофига число раз. Видишь я нули жирным

шрифтом выделил. Старший самый у мы вообще сравнивать не будем, а вот

пред старший надо через AND по маске 00000111 продавить, чтобы отсечь

старшие биты.

Их еще надо заполнить до переполнения и обнуления счетчика. Но если мы

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

второго пришествия тикает — нам плевать.

LDS

R16,CCNT ; Грузим числа в регистры

LDS R17,CCNT+1

LDS R18,CCNT+2