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

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

Рассмотрим режим работы, когда при каждом клике ногой CLK происходит

сдвиг битов влево по направлению к старшему (S0 поднята, S1 опущена).

Взглянем на сдвиговый регистр U1. При каждом дрыге ногой CLK, бит,

который находится на выводе Qn, перемещается на вывод Qn+1, тоесть

сдвигается в сторону старшего бита (влево). Но так как биту, который

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

пропасть. Чтобы этого не произошло, мы посылаем его на следующий

сдвиговй регистр U2, подключив Q7 регистра U1 к ноге SR SER регистра U2.

Объясню, что же это за нога. В рассматриваемом нами режиме работы

сдвигового регистра (S0 поднята, S1 опущена) биты смещаются в cторону

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

находится на ноге SR SER. Так как два наших сдвиговых регистра

тактируются от одного источка (микроконтроллера), то бит на ноге Q7

сдвигового регистра U1, при сдвиге не теряется, а перескакивает на

сдвиговый регистр U2, где продолжает свой путь в микроконтроллер.

Помимо SR SER, существует нога SL SER. Она обладает практически

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

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

S0 опущена, S1 поднята. В данном режиме биты будут двигаться по

направлению к младшему байту, т.е вправо).

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

16-ти битный, поведение которого абсолютно идентично 8-ми битному, за

исключением того, что каждый раз нам необходимо считывать не 8, а 16 бит.

Как я уже говорил в первой статье, время на сканирования такой клавиатуры

возрастает примерно в 2 раза. Безболезненно к данной схеме можно

добавлять все новые и новые сдвиговые регистры, подключая Q7 пин

предыдущего к SR SER последующего. В данной статье мы ограничимся

лишь двумя.

Ниже представлена схема данного устройства

крупным планом

Схема упрощенная, показано только подключение клавиатуры и LCD.

Питание и прочая обвязка контроллера как обычно.

Повторюсь, немаловажная деталь - подтягивающие резисторы R1 - R16. Если

вы не знаете их назначения, прочитайте еще раз пункт “Описание кнопок” в

первой части.

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

кнопок и что-то делать.

Програмная часть

За основу программы я возьму микроядро (простая операционная система),

описанное на этом сайте. Подробности его установки и работы с ним вы

можете прочитать в соответствующих

статьях AVR курса, тут же я не буду

подробно останавливаться на тонкостях его работы.

Начинаю программы я всегда с пустого шаблона, в котором данная ОС уже

готова к работе, а нам лишь нужно добавить задачи и инициализировать их

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

файлы, в каждом из которых находятся разные части нашей программы.

Например инициализация, макросы, векторы прерываний, дополнительные

функции и т.п. По ходу статьи я буду пояснять отдельные куски кода,

показывать что откуда вышло, и для чего мы что-то делаем. Проект вцелом

вы можете скачать по ссылке в конце статьи, и по нему отслеживать

описание всех функций. В проекте весь код достаточно подробно

прокоментирован.

Итак, у нас есть заготовка (ее вы тоже можете скачать вконце статьи),

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

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

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

проектом и инклудим их в соответствующих местах кода.

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

обычно инклудю вконце (см. проект)

•

библиотека для работы с LCD (lcd4,asm, lcd4_macro.inc, от DI HALT’a)

•

Функция для прекодирования кирилических символов в ANSI

кодировке, в символы, которые будут понятны дисплею. (ansi2lcd.asm)

Данное решение встретил на форуме. Переписал его с Си на Асм и

пользуюсь).

•

Функция для сканирования нашей клавиатуры. Собственно ее я опишу

в этой статье. Я ее вынес отдельным файлом, для удобства ее

последующего использования (keyb_scan_init.asm, keyb_scan.asm)

Сканирование клавиатуры

Принцип сканирования клавиатуры я описал в предыдущей статье. В данном

случае у нас будет небольшое отличие, т.к. нам нужно считать не 8, а 16 бит,

т.е. 2 байта, со сдвиговых регистров.

Общий план действий

1. Устанавливаем бит T в регистре SREG. (Это пользовательский бит,

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

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

нашей клавиатуры, если при проверке этот бит будет сброшен, то

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

байта).

2. В цикле считываем 8 бит из сдвигового регистра.

3. Проверяем бит T:

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

прячем его в закрома, сбрасываем бит T и возвращаемся на пункт

Если он сброшен, то мы только что считали второй байт. Задача

выполнена, выходим.

Код

.equ BTN_PORT = PORTA

.equ BTN_DDR = DDRA

.equ BTN_PIN = PINA

.equ BTN_DATA_IN = 0

.equ BTN_HOLD = 1

.equ BTN_CLK = 2

btn_start: SBI BTN_PORT,BTN_HOLD ; поднимаем S1

SBI BTN_PORT,BTN_CLK ; Кликаем

CBI BTN_PORT,BTN_CLK

CBI BTN_PORT,BTN_HOLD ; опускаем S1

SET

; устанавливаем бит T в регистре

SREG.

; данный бит мы устанавливаем

как флаг того, что мы считываем первый байт.

btn_again:

LDI

R17,0 ; в этом регистре будет

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

LDI R18,8 ; счетчик. цикл будем

проделывать 8 раз

btn_loop: LSL R17 ; если мы проходим тут, первый

раз, то данна

я команда с нулем ничего не

; сделает, если же нет, то

двигаем все биты влево

SBIC BTN_PIN,BTN_DATA_IN ; если к нам на вход пришла 1,

INC R17 ; записываем 1 в самый младший

разряд регистра R17

SBI BTN_PORT,BTN_CLK ; кликаем

CBI BTN_PORT,BTN_CLK

DEC R18 ; уменьшаем счетчик

BREQ btn_loop_end ; если счетчик досчитал до нуля,

то переходим в btn_loop_end

Rjmp btn_loop ; иначе повторяем цикл, где первой же

командой сдвигаем все биты влево.

;Таким образом старые старшие

байты постепенно сдвигаются на свое место.

btn_loop_end: BRTC btn_exit ; если бит T сброшен (а это значит, что

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

CLT ; иначе сбрасываем бит T (это

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

; принимать второй

MOV R16,R17 ; сохраняем первый принятый

байт в регистре R16

RJMP btn_again ; и возвращаемся к считыванию

байта

btn_exit: RET

Сохраняем данную функция в файл keyb_scan.asm и кидаем в папку с

проектом.

Далее нам необходимо проинициализировать ноги контроллера. Это дело

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

что можно не писать. Создадим файл keyb_scan_init.asm и напишем в нем

следующее:

SBI

BTN_DDR,BTN_HOLD ;выход HOLD

SBI BTN_DDR,BTN_CLK ;Выход CLK

SBI BTN_PORT,BTN_DATA_IN ;вход

DATA_IN

Этот файл просто подключаем к проекту в разделе инициализации, ничего в

нем не меняя.

include

"init.asm" ; в данном файле хранится общая

инициализация

.include "keyb_scan_init.asm" ; инициализация ног для сканирования

клавиатуры

Итак, функция сканирования клавиатуры у нас готова, далее нужно

обрабатывать приходящие данные. Но прежде я добавлю две задачи, которые

будут служить индикацией работы нашей ОС. Ибо в процессе отладки кода,

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

время на локализацию проблемы, я делаю моргалку диодом. Диод моргает -

ОС работает.

Создаем две задачи. Одна зажигает диод, другая гасит. Причем обе вызывают

друг друга с задержкой 500 мс.

SysLedOn: SetTimerTask TS_SysLedOff,500

SBI PORTD,5

RET

;-----------------------------------------------------------------------------

SysLedOff: SetTimerTask TS_SysLedOn,500

CBI PORTD,5

RET

И запустим их во время старта в области Background

RCALL

SysLedOn

Я не буду полностью описывать как добавить задачу в микроядро. Это достаточно

подробно описано в соответствующих статьях, ссылки на которые я дал выше.

Далее перейдем в сканированию клавиатуры. Создадим задачу KeyScan и запустим ее в

области Background

Background:

RCALL

SysLedOn

RCALL KeyScan

Функция KeyScan будет обрабатывать два байта последовательно, пришедших с

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

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

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

Code_Table: .

Key1, Key2, Key3, Key4, Key5, Key6, Key7,

Key8

Code_Table2: .dw Key9, Key10, Key11, Key12, Key13, Key14, Key15,

Key16

Это две таблицы, одна для клавиш с 1 по 8, другая - с 9 по 16. В ней

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

выполнять в зависимости от того, какая кнопка нажата.

Для этого мы заранее загрузим адрес начала таблицы в регистровую пару Z,

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

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

содержится адрес функции, которую нужно выполнить. Звучит немного

сложно, но на самом деле, все достаточно просто и понятно. Главно

вчитаться в предыдущее предложение.

Обратите внимание, что в таблице адреса занимают по 2 байта, а смещение у

нас будет увеличиваться на один, поэтому нам необходимо будет умножить

смещение на два. Вы увидете это в коде. Знайте, что это из за того, что адрес

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

Другая особенность:

При отсутствии нажатий с клавиатуры приходит 0b11111111. Тоесть

ненажатая кнопка - высокий уровень. К примеру нажмем кнопку 3, и к нам

придет число 0b11110111 (соответствующий бит сброшен). Поэтому выведем

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

0b11111110, потом с 0b11111101, затем 0b11111011 и т.д. Мы просто будем в

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

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

счетчике будет номер нажатой кнопки. Что нам собственно и требуется.

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

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

.DSEG

KeyFlag

: .byte 1

В нем будет храниться последнее зарегестрированное нажатие. После записи

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

200 мс. Это сделано для того, чтобы повторная обработка нажатия этой

кнопки не производилась ранее этого времени, т.е. только до того, как

KeyFlag будет сброшен. Это делается для защиты от случайных двойных

нажатий.

Итак, код сканирования:

KeyScan: SetTimerTask TS_KeyScan,50

RCALL btn_start ; сканируем клавиатуру. результат приходит в

регистрах R16 и R17

SET ; ставим флаг T в регистре SREG. Он

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

LDI ZL,low(Code_Table*2) ; берем адрес первой таблицы с

переходами

; (для кнопок 1-8)

LDI ZH,high(Code_Table*2)

KS_loop: CPI R16,0xFF ; если байт равен 0xFF, то

нажатия не было,

BREQ KS_loop_exit ; переходим на обработку

следующего байта с клавиатуры

LDS R18,KeyFlag ; берем последнее

зарегестрированное нажатие

CP R16, R18 ; сравниваем с текущим

BREQ KS_loop_exit ; если одинаковы, переходим на

обработку следующего

; байта с клавиатуры

STS KeyFlag,R16 ; иначе сохраняем в RAM текущее

нажатие

; как последнее

зарегестрированное

PUSH R16

PUSH R17

SetTimerTask TS_ClearFlag, 200 ; ставим на запуск через 200 мс

функцию очистки

; посл

еднего зарегестрированного

нажатия

POP R17 ; данная функция использует R16

POP

R16 ; R17, поэтому сохраняем их в

стеке

RJMP KS_got_smth ; если мы дошли до этого места,

то у нас

; есть нажатие, которое нужно

обработать. идем на обработку

KS_loop_exit: BRTC KS_exit ; проверяем флаг T в регистре

SREG. Если он

; не сброшен, а значит мы

считали только

; один байт с клавиатуры, то

идем

; дальше, иначе выходим

CLT ; сбрасываем флаг T.Это

означает что мы считали

; первый байт с клавиатуры, и

готовы

; ко второму.

LDI ZL,low(Code_Table2*2) ; берем адрес второй

таблицы с

LDI ZH,high(Code_Table2*2) ; переходами (для кнопок

9-16)

MOV R16,R17 ; второй принятый байт

перекидываем в R16

RJMP KS_loop ; и возвращаемся в цикл

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

;

KS_got_smth: CLR R18 ; R18 будет счетчиком. Нужно

сравнить 8 возможных состояний пришедшего байта,

; поэтому будем считать до 8

LDI R19,0b11111110 ; первоначальная маска для

сравнения ее с пришедшим битом, и дальнейшего сдвигания влево

KS_loop2: CP R16,R19 ; сравниваем маску с пришедшим байтом

BREQ KS_equal ; если равны, то переходим на действие

INC R18 ; иначе увеличиваем счетчик

CPI R18,8 ; сравниваем его с восьмеркой

BREQ KS_exit ; если досчитали до 8, то выходим

SEC ; тут двигаем нашу маску влево. так как

младшие байты нам нужно заполнять

; единицами, а функция ROL

устанавливаем эту единицу только при наличии флага C,

;то устанавливаем этот флаг

ROL R19 ; двигаем биты в маске

RJMP KS_loop2 ; и переходим опять на цикл