Подключаем кнопку к микроконтроллеру ATtiny2313, простая программа. Подключение микроконтроллера. Ликбез Avr кнопки на управление индикатором

В предыдущих уроках были проведены способы вывода информации из микроконтроллера: подключение светодиода и ЖК индикатора. Но как, же вводить информацию в микроконтроллер? Существует множество вариантов и устройств для этого. Но пока что рассмотрим самый простой вариант, это обычная кнопка. Кнопки бывают двух видов: тактовые и фиксирующие. Тактовые кнопки работают по такому принципу: нажал – контакты замкнулись, отпустил – контакты разомкнулись. Следует учесть, что существуют тактовые кнопки, которые изначально замкнуты, а при нажатии размыкаются. Фиксирующие кнопки (их иногда называют: тумблеры, выключатели, переключатели) в отличии от тактовых фиксируют своё положение при нажатии, то есть: нажал – контакты замкнулись, еще раз нажал – контакты разомкнулись. В общем, с кнопками разобрались, теперь будем разбираться, как подключить эти кнопки к микроконтроллеру. А подключить на самом деле очень даже просто! Смотрим схему:

Возможно, вы спросите: Зачем резистор R1? А затем, что без резистора R1, когда кнопка S1 будет разомкнута, микроконтроллер на порте, к которому всё это подключено, будет видеть то логическую 1, то логический 0 тем самым будут производиться ложные срабатывания кнопки. Чтобы этого не происходило необходимо этот порт “подтягивать” сопротивлением к плюсу питания. Сопротивление резистора R1 может быть в интервале от 4,7кОм до 10кОм. С резистором получается такая картина: кнопка S1 нажата – на порте МК возникает логический 0, кнопка S1 не нажата – на порте МК возникает логическая 1 за счёт сопротивления R1. Конечно, нужно знать, что в некоторых AVR микроконтроллерах есть встроенные подтягивающие резисторы сопротивление порядка 50кОм, по умолчанию они отключены. В BASCOM-AVR эти резисторы можно включить, записав в необходимый порт логическую 1. Но я крайне не рекомендую использовать эти встроенные, гораздо надёжнее использовать внешние, как показано на схеме выше. Ну что, со схематическим решением разобрались, теперь будем разбираться программно. Для работы с кнопкой сначала нужно сконфигурировать порт микроконтроллера на вход, в BASCOM-AVR это делается вот так:
Config (порт микроконтроллера) = input
Пример:
Config PINB.3 = input

Обратите внимание, что для работы порта на вход, имя порта должно начинаться с PIN, а не с PORT как для конфигурации порта на выход!

После конфигурации порта на вход мы можем считать с него значение 1 или 0, в нашем случае 0 – кнопка нажата, 1 – кнопка не нажата. А проверить, что кнопка нажата, мы можем так:
If (порт микроконтроллера) = 0 then
(если кнопка нажата, то выполняем, действия описанные здесь)
End if
Можно и наоборот, проверить, не нажата ли кнопка:
If (порт микроконтроллера) = 1 then
(если кнопка не нажата, то выполняем, действия описанные здесь)
End if
Пример:
If PINB.3 = 0 then
PORTB.2 = 1 "если кнопка нажата, то включаем светодиод подключенный к PB.2
End if

Просто, не правда ли? Итак, теперь попробуем реализовать подключение кнопки к микроконтроллеру в “железе”. За основу возьмём микроконтроллер Attiny13 и для него сделанную немного ранее. Для того кто не делал отладочную плату, вот схема:

Алгоритм работы программы такой: кнопка S1 нажата – светодиод не горит, кнопка S1 не нажата – светодиод горит. А вот и сама программа на BASCOM-AVR:

$regfile = "attiny13.dat" $crystal = 8000000 Config Pinb.3 = Input Config Portb.2 = Output Do If Pinb.3 = 0 Then Portb.2 = 0 If Pinb.3 = 1 Then Portb.2 = 1 Loop End

Вот такая простая программа. Скомпилированная прошивка находится в архиве ниже. Фьюз биты можно не выставлять, так как в такой простой программе тактовая частота не особо важна. Для ленивых собирать в железе есть проект в нашем любимом , скачать можно в архиве ниже. Работа в схемы в симуляторе Proteus:

Скачать файлы для урока (проект в , исходник, прошивка) вы можете ниже

Список радиоэлементов

Обозначение	Тип	Номинал	Количество	Примечание	Магазин	Мой блокнот
IC1	МК AVR 8-бит	ATtiny13	1			В блокнот
R1, R2	Резистор	4.7 кОм	2			В блокнот
R3	Резистор	150 Ом	1			В блокнот
HL1	Светодиод		1

Итак мы добрались до неотъемлемой части большинства проектов на микроконтроллерах - до кнопок. Кнопка достаточно простое устройство, имеющее, как правило, всего два состояния, если говорить языком программирования это состояние логической 1 (контакты замкнуты) и логического 0 (контакты разомкнуты). Рассмотрим схему.

Имеем все туже схему с семисегментными индикаторами, но добавлены 4 кнопки. При помощи кнопок группы A будем увеличивать или уменьшать выводимое значение на первых трех индикаторах, а кнопками группы B – изменять значение на последних двух индикаторах.

Для начала кратко о кнопках. Кнопки применим с нормально разомкнутыми контактами без фиксации. Одним контактом подключим к земле, а другим к отдельным выводам микроконтроллера. Подтягивающий к плюсу резистор устанавливать не будем, так как таковой предусмотрен в самом микроконтроллере. Осталось только написать программу для опроса кнопок (состояния выводов микроконтроллера) и вывода результата на индикаторы. В связи с простотой схемы и затруднениями читателей в понимании программы на C, основной упор в этом разделе направим именно на разбор программы.

Итак программа.

#include //подключаем библиотеки #include #define SPI_SS PB2 //выход SS #define SPI_MOSI PB3 //выход MOSI #define SPI_MISO PB4 //выход MISO #define SPI_SCK PB5 //выход SCK #define BUTTON_AP PD4 //выход кнопки A+ #define BUTTON_AM PD5 //выход кнопки A- #define BUTTON_BP PD6 //выход кнопки B+ #define BUTTON_BM PD7 //выход кнопки B- char di; void spi(char cmd,char data) //Функция передачи двух пакетов по 8 бит по протоколу SPI { PORTB &= ~(1<999)a=999; //проверка достижения максимального значения переменной a if(a<0)a=0; //проверка достижения минимального значения переменной a if(b>99)b=99; //проверка достижения максимального значения переменной b if(b<0)b=0; //проверка достижения минимального значения переменной b } return 0; }

Приступим. Программу на C обычно начинают с подключения внешних библиотек. За это в программе отвечают две строки:

#include #include

avr/io.h это библиотека ввода/вывода которая объяснит компилятору какие порты ввода/вывода есть у микроконтроллера, как они обозначены и на что они способны. И самое интересное что эта библиотека сама выбирает из настроек проекта для какого микроконтроллера нужно применить описания, то позволяет использовать эту библиотеку для разных микроконтроллеров. Эту библиотеку нужно подключать в первую очередь.

Вторая часто используемая библиотека util/delay.h помогает создавать задержки в выполнении программы, что достаточно удобно.

#define BUTTON_AP PD4

указывает что на выводе PD4 ( регистр 4 порта B) мы будем подключать кнопку A+ ( смотрите схему ). Это нужно для того чтобы если мы вдруг надумаем кнопку переключить на другой вывод то нам не понадобится искать по всей программе, просто изменить в define название вывода PD4 на нужный, при этом в программе так и останется BUTTON_AP. Но в случае с выводами для SPI ничего изменить не получится потому что поддержка SPI аппаратная и жестко привязана к выводам микроконтроллера производителем.

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

DDRB |= (1<

Так были переключены на вывод перечисленные разряды порта B (по умолчанию все разряды всех портов настроены на ввод) . Э ту строку можно записать следующим образом без использования макроопределения в define

DDRB |= (1<

Эти записи равноценны и предназначены для подстановки 1 в регистр DDRB в соответствующий разряд BR3 ( разряд 3 ), BR5 ( разряд 5 ) и BR2 ( разряд 2 ). Остальные разряды регистра DDRB остаются без изменения. Также можно записать эту строку вот так

DDRB |= (1<<3)|(1<<5)|(1<<2);

что конечно более запутанно.

Запись 1 <<3 означает что двоичную единицу нужно сдвинуть влево на 3 позиции, позиции справа заполняются нулями.

1 <<3 будет означать 1000 (один ноль ноль ноль) в двоичной системе. И при выполнении операции (1<<3)|(1<<5) мы получим 101000 в двоичной системе.

В следующей строке программы подключаем подтягивающие резисторы для кнопок. Запишем единицы в соответствующие разряды регистра PORTD

PORTD |= (1<

Эти резисторы встроены в микроконтроллер. Их можно подключить на разряды порта с условием что эти разряды определены как ввод. Резисторы подтягивают нужный вывод микроконтроллера к логической 1.

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

Теперь рассмотрим основную часть программы которую микроконтроллер после основных настроек выполняет бесконечно. Эта часть программы заключена в бесконечный цыкл.

While(1) { };

Все заключенное между фигурными скобками строки программы будут выполнятся по кругу. Внутри этого бесконечного цикла происходит поразрядное разбитие десятичного числа для вывода на отдельные разряды семисегментного индикатора. После разбиения отправляем поразрядно данные по SPI для каждого отдельного индикатора.

Delay_ms(100);

для предотвращения ложного срабатывания от «дребезга» контактов кнопки. И второй раз опрашиваем кнопки о их нажатии и сверяем выставленным ранее флагам о нажатии. Если условия соблюдены изменяем значения выводимые на индикаторы. Затем сбрасываем флаги нажатия кнопок в 0. После чего цикл повторяется.

В следующей - заключительной части будет рассмотрен АЦП (аналого-цифровой преобразователь) и применение всего ранее изученного на практике.

Сегодня мы расширим свой кругозор по изучению работы портов микроконтроллера и изучим второе назначение порта — работу на вход. И для изучения работы на вход мы применим обычную тактовую кнопку.

Как всегда, создадим проект в Atmel Studio, выберем Atmega8A, назовем проект Test04 и код также в main.c, как обычно, скопируем с проекта предыдущего урока.

В качестве подопытного порта давайте возьмём порт B. Можно с успехом использовать любой порт. И в качестве ножки возьмем нулевую ножку. Итак у нас ножка B0.

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

Добавим кнопку в протеусе, для этого в поиске компонентов найдём Button

Затем подключим нашу кнопку вот таким вот образом к ножке B0 контроллера

Судя по данной схеме, когда кнопка будет в нажатом состоянии, то Ножка PB0 у нас будет иметь низкий логический уровень, а при отжатом — непонятный уровень, поэтому мы применим подтягивающий к питанию резистор, который можно не паять физически, а подключить опционально определенной командой.

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

DDRD = 0xFF;

DDRB = 0x00;

В случае, когда мы работали с портом D на выход, биты регистра PORTD отвечали за уровень на соответствующих ножках. А в случае, когда порт инициализирован на вход, как наш порт B, то биты регистра PORTB будут уже отвечать за подтягивание к соответствующим ножкам порта резисторов на шину питания. Если будет логическая единица, то регистр будет подтягиваться, а если логический ноль — то не будет. Поэтому мы в 0 бите регистра установим 1

PORTD = 0b00000001;

PORTB = 0b00000001;

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

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

// for(i=0;i<=7;i++)

// {

// PORTD = (1<

// _delay_ms(500);

// }

В данном цикле мы и будем отслеживать состояние ножки PB0. Делается это с помощью определения состояния соответствующего бита в регистре PINB, который собственно за это и отвечает.

Чтобы нам следить за каким-либо действием или состоянием, нам необходимо будет обработать условие.

Условие в языке C добавляется с помощью команды if .

И в качестве условия мы возьмём состояние ножки 0 порта B или состояние бита 0 регистра PINB .

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

Можно пойти на хитрость и применить вот такую конструкцию PINB &0b00000001 .

Данная конструкция нам и проверит нулевой бит. То есть если в регистре PINB также будет 1 в нулевом его бите, то независимо от состояния остальных битов в данном регистре мы получим ненулевой результат, что также является истиной. То есть если ни с чем не сравнивать в условии результат, то условие эквивалентно сравниванием с нулём, только наоборот. Для истинности результат должен быть ненулевым — (результат!=0 ).

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

while (1)

if (!( PINB &0b00000001))

{

}

else

{

}

Теперь нам необходимо добавить тело условия. При выполнении условия, что кнопка нажата, мы будем зажигать светодиод на ножке D0. А если условие не будет выполняться (кнопка будет отжата), то мы будем его гасить. Также мы погасим данный светодиод и в начале программы. Поэтому получим следующий код

DDRB =0x00;

PORTD =0b00000000 ;

PORTB =0b00000001;

while (1)

If (!(PINB &0b00000001))

PORTD =0b00000001;

Else

PORTD =0b00000000;

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

Чтобы у нас при сборке не было даже предупреждений, уберём объявление переменной i, так как она в коде не используется

int main ( void )

// unsigned char i;

Unsigned char butcount =0;

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

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

И чтобы это как-то отследить и определить, что это было именно нажатие, а не дребезг, то мы будим отслеживать нажатие некоторое время, ну или некоторое количество тактов или циклов. Для этого в начале функции main() до бесконечного цикла мы добавим другую переменную (i нам ещё пригодится и мы её портить не будем). Назовём мы переменную butcount , так как имя переменной должно как-то само за себя говорить и тем самым достигается ещё большая читабельность кода

// unsigned char i;

unsigned char butcount =0;

И чтобы воспользоваться данной переменной, мы применим ещё одно условие. И у нас будет условие в условии. Это всё допустимо и очень широко используется. И в зависимости от этого условия мы данную переменную будем наращивать (инкрементировать). Условием будет у нас достижение данной переменной определённой величины. То есть попробуем сделать так, чтобы значение переменной не достигало 5

if (!( PINB &0b00000001))

if ( butcount < 5)

{

butcount ++;

}

А когда значение данной переменной достигнет значения 5, то мы уже в данный цикл не попадём, а попадём мы в тело оператора else , который мы сейчас и добавим и в его теле напишем следующий код

Butcount ++;

else

PORTD =0b00000001;

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

По идее, здесь мы должны обнулить нашу переменную, но мы это будем делать также постепенно, используя тело оператора else, только другого — того, который у нас был и тело которого выполняется при низком уровне на ножке, к которой подключена кнопка. Вот таким будет его тело

else

if (butcount >0)

{

butcount —;

}

else

{

PORTD =0b00000000;

}

Данный код чем то похож на предыдущий, только здесь у нас идёт, наоборот декрементирование переменной, и как только её значение опять достигнет нуля, то мы и попадём в обработку отжатия кнопки, тем самым полностью избавимся от дребезга. И чем старее и некачественнее будет наша тактовая кнопка, тем большее значение переменной в условии мы будем применять.

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

Смотреть ВИДЕОУРОК

Post Views: 13 084

В предыдущих уроках я рассказывал, как с мк вывести информацию: и . А в этом уроке мы будем вводить информацию при помощи кнопок. Кнопки бывают нескольких видов: фиксирующие и тактовые.Из названия кнопки понятен принцип ее работы: тактовая - нажал, контакты замкнулись, разжал - разомкнулись; фиксирующие фиксируют своё состояние: нажал - замкнулись контакты, еще раз нажал - разомкнулись.

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

Идея работы такова: на ножку через резистор 10к подается напряжение 5 вольт, на ножке логическая единица. Но когда мы нажимаем кнопку, мы ножку замыкаем на землю, а ток-то через резистор потечет маленький, и он будет не в состоянии удержать 5 вольт, и на ножке напряжение просядет до 0 вольт, а это логический 0.Эти моменты мы и будем отлавливать в программе. Напишем программу, которая будет при нажатии кнопки включать светодиод, при отжатой - выключать

#include #include void main(void) { // инициализация порта D PORTD=0b00000000; DDRD=0b10000000; while (1) { if (PIND & 0b00000100) /*проверяем, какой логический уровень у нас на ножке знак & - означает побитовое "И" например в PIND в нас находится 0b00000100, тогда 0b00000100 & 0b00000100 = 0b00000100, то есть true, а если в PIND у нас 0b00000000, то 0b00000000 & 0b00000100 = 0b00000000 а это false */ PORTD=0b00000000; // записываем ноль в седьмой бит порта D else PORTD=0b10000000; // записываем единицу в седьмой бит порта D }; delay_ms(100); // делаем задержку в 100 милисекунд для защиты от дребезга контактов }

В большинстве современных микроконтроллеров есть встроенный подтягивающий резистор R1, поэтому внешний можно и не ставить
Чтобы включить внутренний подтягивающий резистор нужно при инициализации порта в регистре PORTD выставить соответствующий бит, на котором висит кнопка, в единицу: PORTD=0b00000100;
А что же произойдет, если вывод будет сконфигурирован как выход:

• Если на выводе логический ноль, ничего страшного не случится
• если на выводе вдруг окажется логическая единица, то при нажатии кнопки мы попросту закоротим вывод на землю, и через него потечет ток, который ножка не выдержит (ток через ножку не должен превышать 40 милиампер), и вероятнее всего, она перегорит

Поэтому для защити желательно поставить между выводом микроконтроллера и кнопкой резистор ом на 300
Есть еще много способов как подключить кнопки к микроконтроллеру, например с помощью диодов или с помощью ацп, но я их описывать не буду, так как курс рассчитан для начинающих. Если надо, то найдете сами.

В МК ATMega16 есть три таймера/счетчика – два 8-битных (Timer/Counter0, Timer/Counter2) и один 16-битный (Timer/Counter1). Каждый из них содержит специальные регистры, одним из которых является счетный регистр TCNTn (n – это число 0, 1 или 2). Каждый раз, когда процессор выполняет одну команду, содержимое этого регистра увеличивается на единицу (либо каждые 8, 64, 256 или 1024 тактов). Потому он и называется счетным. Помимо него, есть еще и регистр сравнения OCRn (Output Compare Register), в который мы можем сами записать какое-либо число. У 8-битного счетчика эти регистры 8-битные. По мере выполнения программы содержимое TCNTn растет и в какой-то момент оно совпадет с содержимым OCRn. Тогда (если заданы специальные параметры) в регистре флагов прерываний TIFR (Timer/Counter Interrupt Flag Register) один из битов становится равен единице и процессор, видя запрос на прерывание, сразу же отрывается от выполнения бесконечного цикла и идет обслуживать прерывание таймера. После этого процесс повторяется.

Ниже представлена временная диаграмма режима CTC (Clear Timer on Compare). В этом режиме счетный регистр очищается в момент совпадения содержимого TCNTn и OCRn, соответственно меняется и период вызова прерывания.

Это далеко не единственных режим работы таймера/счетчика. Можно не очищать счетный регистр в момент совпадения, тогда это будет режим генерации широтно-импульсной модуляции, который мы рассмотрим в следующей статье. Можно менять направление счета, т. е. содержимое счетного регистра будет уменьшаться по мере выполнения программы. Также возможно производить счет не по количеству выполненных процессором команд, а по количеству изменений уровня напряжения на «ножке» T0 или T1 (режим счетчика), можно автоматически, без участия процессора, менять состояние ножек OCn в зависимости от состояния таймера. Таймер/Счетчик1 умеет производить сравнение сразу по двум каналам – А или В.

Для запуска таймера нужно выставить соответствующие биты в регистре управления таймером TCCRn (Timer/Counter Control Register), после чего он сразу же начинает свою работу.

Мы рассмотрим лишь некоторые режимы работы таймера. Если вам потребуется работа в другом режиме, то читайте Datasheet к ATMega16 – там все подробнейше по-английски написано, даны даже примеры программ на С и ассемблере (недаром же он занимает 357 страниц печатного текста!).

Теперь займемся кнопками.

Если мы собираемся использовать небольшое количество кнопок (до 9 штук), то подключать их следует между «землей» и выводами какого-либо порта микроконтроллера. При этом следует сделать эти выводы входами, для чего установить соответствующие биты в регистре DDRx и включить внутренний подтягивающий резистор установкой битов в регистре PORTx. При этом на данных «ножках» окажется напряжение 5 В. При нажатии кнопки вход МК замыкается на GND и напряжение на нем падает до нуля (а может быть и наоборот – вывод МК замкнут на землю в отжатом состоянии). При этом меняется регистр PINx, в котором хранится текущее состояние порта (в отличие от PORTx, в котором установлено состояние порта при отсутствии нагрузки, т. е. до нажатия каких-либо кнопок). Считывая периодически состояние PINx, можно определить, что нажата кнопка.

ВНИМАНИЕ! Если соответствующий бит в регистре DDRx будет установлен в 1 для вашей кнопки, то хорошее нажатие на кнопку может привести к небольшому пиротехническому эффекту – возникновению дыма вокруг МК. Естественно, МК после этого придется отправить в мусорное ведро…

Перейдем к практической части. Создайте в IAR новое рабочее пространство и новый проект с именем, например, TimerButton. Установите опции проекта так, как это описано в предыдущей статье. А теперь наберем следующий небольшой код.

#include "iom16.h" void init_timer0(void ) //Инициализация таймера/счетчика0 { OCR0 = 255; //Содержимое регистра сравнения //Задаем режим работы таймера TCCR0 = (1 void init_timer2(void ) //Инициализация таймера/счетчика2 { OCR2 = 255; TCCR2 = (1 //Устанавливаем для него прерывание совпадения } void main (void ) { DDRB = 255; init_timer0(); init_timer2(); while (1) { } } #pragma vector = TIMER2_COMP_vect //Прерывание по таймеру2 __interrupt void flashing() { if ((PORTB & 3) == 1) { PORTB &= (0xFF // Отключение выводов PB0, PB1 PORTB |= 2; // Включение PB1 } else { PORTB &= (0xFF // Отключение выводов PB0, PB1 PORTB |= 1; // Включение PB0 } }

Давайте посмотрим, как это работает. В функциях init_timern задаются биты в регистрах TCCRn, OCRn и TIMSK, причем такой способ может кому-нибудь показаться странным или незнакомым. Придется объяснить сначала, что означает запись «(1

где a – это то число, двоичное представление которого нужно сдвинуть, а b показывает, на сколько битов нужно его сдвинуть. При этом возможна потеря значения, хранящегося в a (т.е. не всегда возможно восстановить из С то, что было в а). Рассмотрим пример:

Что окажется в С после выполнения строки C = (22

2 в двоичном коде будет выглядеть как 00010110, а после сдвига влево на 3 бита получим С = 10110000.

Аналогично существует и сдвиг вправо. Еще пример:

char C; … C = ((0xFF > 2);

Сначала выполнится действие во внутренних скобках (0xFF – это 255 в шестнадцатеричном коде), из 11111111 получится 11111100, потом произойдет сдвиг вправо и получим С = 00111111. Как видим, здесь две взаимно обратные операции привели к другому числу, т. к. мы потеряли два бита. Этого не произошло бы, если бы переменная С была типа int, т. к. int занимает 16 бит.

Теперь рассмотрим еще два битовых оператора, широко применяющиеся при программировании МК. Это оператор «побитовое и» (&) и «побитовое или» (|). Как они действуют, думаю, будет понятно из примеров:

Действие: Результат (в двоичном коде): С = 0; // C = 00000000 C = (1 // C = 00100101 C |= (1 // C = 00101101 C &= (0xF0 >> 2); // C = 00101100 C = (C & 4) | 3; // C = 00000111

Чуть не забыл! Есть еще «побитовое исключающее или» (^). Оно сравнивает соответствующие биты в числе, и, если они одинаковые, возвращает 0, иначе единицу.

Вернемся к нашей программе. Там написано «(1

/* Timer/Counter 0 Control Register */ #define FOC0 7 #define WGM00 6 #define COM01 5 #define COM00 4 #define WGM01 3 #define CS02 2 #define CS01 1 #define CS00 0

При компиляции программы запись WGM01 просто заменяется на число 3, и в результате получается уже корректная запись. WGM01 называется макросом и он, в отличие от переменной, не занимает места в памяти (разве что в памяти программиста:-).

Если заглянуть теперь в Datasheet, но нетрудно будет увидеть, что WGM01 – это имя третьего бита в регистре TCCR0. То же самое касается и остальных битов этого регистра. Это совпадение не случайно и относится ко всем регистрам МК (или почти ко всем). Т. е., написав «(1

Итого, строчка

означает, что включен режим СТС, при срабатывании таймера0 меняется состояние «ножки» ОС0 (Она же PB3), содержимое счетчика увеличивается каждые 1024 такта.

Аналогично для таймера2: TCCR2 = (1

В регистре TIMSK (Timer/counter Interrupt MaSK register) задается режим прерываний. Мы написали

что означает прерывание таймера2 по совпадении TCNT2 и OCR2. Самая последняя функция – это собственно функция прерывания совпадения таймера2. Прерывания объявляются следующим образом:

#pragma vector = ВЕКТОР __interrupt ТИП ИМЯ()

где ВЕКТОР – это макрос вектора прерывания (по смыслу просто число, характеризующее это прерывание); эти макросы в порядке снижения приоритета перечислены в файле iom16.h. ТИП – тип возвращаемого функцией значения, в нашем случае void (ничего). ИМЯ – произвольное имя для этой функции. С прерываниями мы еще успеем наработаться в будущем.

При выполнении нашей функции должны по очереди моргать светодиоды, подключенные к PB0 и PB1. Судя по всему, частота равна 11059200/(256*1024) = 42 Гц. Это быстро, но будет заметно невооруженным глазом. Кстати, применение таймеров дает возможность отсчитывать точные временные интервалы, не зависящие от сложности вашей программы и порядка ее выполнения (но если у Вас не более одного прерывания).

Итак, сохраняем файл как «TimerDebug.c», добавляем его в проект, компилируем, прошиваем МК. Что же мы видим? Светодиод, подключенный к выводу PB3, будет активно моргать, а на PB0 и PB1 нет ни каких изменений. В чем же дело? Неужели что-то неверно?

Чтобы это выяснить, придется отладить нашу программу. Поскольку в IAR нет Debuggerа, придется использовать AVR Studio. Эту среду разработки можно скачать с сайта производителя http://atmel.com . Проблем с ее установкой, думаю, не должно быть. Перед запуском AVR Studio выберите в IAR режим Debug и создайте отладочный cof-файл (все опции проекта должны быть выставлены, как описано в предыдущей статье).

Открыв AVR Studio, мы увидим окно приветствия, в котором выберем «Open». Теперь лезем в папку с проектом, там в Debug\Exe, выбираем там «TimerDebug.cof», создаем проект там, где предложат, выбираем дивайс ATMega16 и режим отладки Simulator. После этого, если все сделали правильно, сразу же идет процесс отладки

Среда отладки здесь очень удобная, т.к. позволяет просматривать содержимое всех регистров МК, а также вручную устанавливать значения для них щелчками мыши. Например, если установить флаг прерывания в регистре TIFR в бите 7 (под черным квадратом в TIMSK), то следующим шагом программы (нажатие F10 или F11) должна быть обработка прерывания (флаг будет установлен автоматически и при совпадении регистров TCNT2 и OCR2). Но, к нашему удивлению, прерывания не будет!

Возникает вопрос: почему?

Откроем регистр CPU, SREG. Этот регистр определяет работу процессора, а конкретно седьмой его бит (I-бит, Interrupt bit) ответственен за обработку всех прерываний в МК. У нас он не установлен. Стоит его выставить, как сразу же пойдет выполняться прерывание (если одновременно установлен седьмой бит в TIFR).

Можно заметить одну интересную особенность: как только процессор уходит в обработку прерывания, этот бит (флаг разрешения обработки прерываний) снимается, а при выходе из функции прерывания вновь автоматически устанавливается. Это не позволяет процессору, не выполнив одного прерывания, схватиться за другое (ведь ориентируется он в программе именно таким образом – по флагам).

Значит, нужно добавить строчку кода для установки этого бита в единичное состояние. Добавим мы его в функцию init_timer2. Получится следующее:

void init_timer2(void ) { SREG |= (1 //Добавили эту строчку OCR2 = 255; TCCR2 = (1

Теперь, выбрав конфигурацию Release и прошив МК нажатием F7 и запуском AVReal32.exe, с радостью увидим, что все работает как надо.

Замечание: при отладке программы следует уменьшать интервалы таймеров, если они слишком длинные, т. к. в процессе отладки в AVR Studio программа выполняется в тысячи раз медленнее, чем внутри МК и вы не дождетесь срабатывания таймера. В целом отладка полностью аналогична таковой в других системах программирования, таких, как Visual C++.

Теперь, научившись отлаживать программы, создадим в IAR новый файл (а старый сохраним и удалим из проекта) и наберем следующий код:

#include "iom16.h" long unsigned int counter = 0; //Счетчик для формирования временных интервалов unsigned char B0Pressed = 0; //Здесь хранится состояние кнопки0 (0 - не нажата, 1 - нажата) unsigned char B1Pressed = 0; //Здесь хранится состояние кнопки1 (0 - не нажата, 1 - нажата) //Инициализация таймера2 //Нужно каждые 11059 такта (1 мс) увеличивать counter. У нас получается каждые 1,001175 мс void init_timer2() { OCR2 = 173; TCCR2 = (1 //Инициализация портов ввода/вывода init_io_ports() { DDRA =(1//формирование задержки в Pause_ms миллисекунд void delay(long unsigned int Pause_ms) { counter = 0; while (counter void main() { SREG |= (1 //Разрешаем прерывания init_timer2(); //Включаем таймер2 на каждые 64 такта, считать до 173 init_io_ports(); //Включаем порты ввода/вывода while (1) { //Обработка кнопки 0 if (B0Pressed == 1) { // уведичивает PORTB, ждет отпускания PORTB++; B0Pressed = 0; while ((PINC & (1 else { if ((PINC & (1 //Фиксирует нажатие { delay(50); if ((PINC & (1 //Проверяет нажатие { B0Pressed = 1; } } } //Обработка кнопки 1 if (B1Pressed == 1) //Если произошло нажатие на кнопку, { // уменьшает PORTB, ждет отпускания PORTB--; B1Pressed = 0; while ((PINC & (1 else { if ((PINC & (1 //Фиксирует нажатие { delay(200); //Устранение "дребезга клавиш" if ((PINC & (1 //Проверяет нажатие { B1Pressed = 1; //Устанавливает флаг "кнопка нажата" } } } } } //Прерывание по таймеру 2, прн этом увеличение счетчика counter #pragma vector = TIMER2_COMP_vect __interrupt void inc_delay_counter() { counter++; }

Сначала предлагаю взять уже готовый файл прошивки (файлы к статье, папка Release, файл TimerButton.hex или откомпилировать этот текст) и записать его в МК. После чего вынуть кабель прошивки, подключить к PC0 и PC1 кнопки и попробовать их понажимать. Увидим, что при нажатии на одну из кнопок увеличивается регистр PORTB (загораются светодиоды), а при нажатии на другую – уменьшается. Если не работает – попробуйте понажимать одну кнопку, удерживая другую – будет действовать. Дело в том, что я подключал кнопки следующим образом: при нажатии на кнопку вывод МК «болтается» в воздухе, а при отпускании замыкается на землю. Если вы подключили кнопки по-другому, то придется лишь чуть модернизировать программу.

Давайте разберемся с кодом. Здесь работа с таймером организована несколько иначе. Он срабатывает каждые 11072 такта (то есть каждые 1,001175 мс) и увеличивает содержимое переменной counter. Есть еще функция delay(long unsigned int Pause_ms), которая берет в качестве параметра количество миллисекунд Pause_ms, сбрасывает counter и ждет, когда counter достигнет значения Pause_ms, после чего продолжает работу МК. Таким образом, написав delay(1500), мы сформируем задержку в программе в 1,5 секунды. Это очень удобно для формирования временных интервалов.

С таймером вроде все понятно. Но для чего он используется? Рассмотрим бесконечный цикл while(1) в main(). В этом цикле проверяется состояние кнопок путем анализа содержимого регистра PINB. А зачем там стоит задержка на 50 мс? Это устранение т. н. «дребезга клавиш». Дело в том, что при нажатии на кнопку происходит удар одного контакта о другой, и, поскольку контакты металлические, удар этот упругий. Контакты, пружиня, замыкаются и размыкаются несколько раз, несмотря на то, что палец сделал лишь одно нажатие. Это приводит к тому, что МК фиксирует несколько нажатий. Давайте рассмотрим график зависимости напряжения на выходе PC0 от времени. Он может выглядеть так:

Точка А – момент нажатия кнопки. Он может быть зафиксирован МК. Затем идут несколько замыканий и размыканий (их может и не быть, а может быть и 12 штук – это явление можно считать случайным). В точке B контакт уже надежно зафиксирован. Между A и B в среднем около 10 мс. Наконец, в точке D происходит размыкание. Как же избавиться от этого неприятного явления? Оказывается, очень просто. Нужно зафиксировать момент нажатия кнопки (точка А), через какое-то время, например, 50 мс (точка С) проверить, что кнопка действительно нажата, сделать действие, соответствующее этой кнопке и ждать момент ее отпускания (точка D). То есть нужно сделать паузу от А до С, такую, чтобы весь «дребезг» оказался внутри этой паузы. А попробуйте теперь убрать строчку, формирующую задержку, откомпилировать программу и зашить ее в МК. Путем простых нажиманий на кнопки сможете легко убедиться, что все эти «мучения» не были напрасными.

А что же делать, если к МК нужно подключить, скажем, 40 кнопок? Ведь у него всего лишь 32 вывода. Казалось бы, никак. На самом деле это возможно. В таком случае используют алгоритм, называемый стробированием. Для этого нужно кнопки соединить в виде матрицы, как это показано на рисунке (рисунок взят из книги Мортона «МК AVR, вводный курс», где написано про программирование AVR на ассемблере).

При подаче на вывод PB0 лог. 1 (+5В), а на выводы PB1 и PB2 лог. 0 разрешается обработка кнопок 1, 4 и 7. После этого состояние каждой из них можно узнать, проверив напряжение на одном из выводов PB3..PB5. Таким образом, подавая последовательно на выводы PB0..PB2 лог. 1, можно определить состояние всех кнопок. Понятное дело, что выводы PB0..PB2 должны быть выходами, а PB0..PB2 входами. Чтобы определить, какое количество выводов потребуется для массива из Х кнопок, нужно найти пару сомножителей Х, сумма которых наименьшая (для нашего случая с 40 кнопками это будут числа 5 и 8). Это означает, что к одному МК можно подключить до 256 кнопок (а с применение дешифраторов и того больше, но о дешифраторах потом). Лучше сделать меньшее число выводов выходами, а большее – входами. В этом случае опрос всех строк матрицы займет меньше времени. Подобный способ подключения (стробирование) свойственен не только для кнопок. Там можно подключать самые разнообразные устройства, начиная от матриц светодиодов и заканчивая микросхемами flash-памяти.

© Киселев Роман
Июнь 2007