По сути, таймер микроконтроллера - это цифровой счетчик, только "навороченый". На вход счетчика подается тактовый сигнал, по перепадам которого счетчик увеличивает свое значение. При возникновении событий - переполнение счетчика или совпадение его значения с заданным - генерируется запрос на прерывание.
Давайте разберем, как пользоваться таймером Т0 в режиме Normal. В этом режиме таймер считает от какого-то начального значения счетного регистра до максимально возможного (до 255 или 0xFF). Когда таймер Т0 досчитывает до максимума, то в следующий такт таймера возникает переполнение счетного регистра TCNT0 - он обнуляется и устанавливается флаг TOV0. Если в программе разрешены прерывания глобально (флаг I регистра SREG) и прерывание таймера Т0 по переполнению (флаг TOIE0 регистра TIMSK), то микроконтроллер вызовет соответствующий обработчик. Если значение счетного регистра совпадет с регистром сравнения OCR0, то установится флаг OCF0 и при разрешенном прерывании по событию совпадение, запустится его обработчик.
Таймер Т0 в режиме Normal
Рассмотрим практическую задачу - нам нужно каждые 20 мс опрашивать кнопку. Частота микроконтроллера 8 МГц, микроконтроллер ATmega16.
Первое, что нужно сделать - это определиться с выбором коэффициента предделителя таймера и рассчитать начальное значение для счетного регистра TCNT0.
Таймер Т0 может тактироваться от внутреннего тактового сигнала микроконтроллера или от внешнего, который подается на вывод Т0. При работе от внутреннего тактового сигнала пользователь может выбирать коэффициенты деления частоты этого сигнала. У таймера Т0 есть пять возможных вариантов коэффициента предделителя - 1, 8, 64, 256, 1024.
Для решения поставленной задачи, я рассуждаю следующим образом. Если бы один такт таймера Т0 имел период 1 мс, то мне бы это подошло. 20 тактов дают 20 мс. Какой коэффициент предделителя таймера позволит получить близкий к 1 мс период тактовой частоты? Можно посчитать.
Тактовая частота микроконтроллера Fcpu = 8000000 Гц
Период тактового сигнала микроконтроллера Tcpu = 1/Fcpu
Период тактового сигнала таймера Т0 равен Tt0 = (1/Fcpu)/k = k/Fcpu
При k = 1024 период тактовой частоты таймера Т0 будет равен Tt0 = 1024/8000000 = 0.128 мс
Это максимальный период тактового сигнала таймера, который мы можем получить при наших условиях (Fcpu = 8 МГц). При меньших коэффициентах - период получится еще меньше.
Ну хорошо, пусть один такт таймера это 0.128 мс, хватит ли разрядности счетного регистра, чтобы отсчитать этот временной интервал и сколько для этого понадобится тактов? Делим требуемый интервал времени (20 мс) на длительность одного такта таймера и получаем ответ.
n = t/Tto = 20 мс/ 0.128 мс = 156.25
Округлив до целого, получаем 156 тактов. Это меньше 255 (максимального значения счетного регистра), значит разрядности счетного регистра TCNT0 хватит.
Начальное значение для счетного регистра TCNT0 вычисляем как разницу между максимальным числом тактов таймера Т0 и требуемым, то есть 256 - 156 = 100. (256 - это максимальное количество временных интервалов, которые может отсчитать любой 8-и разрядный таймер.)
Думаю, теперь понятно, как рассчитывать начальное значение TCNT0 для режима Normal :
Вычисляем период одного такта таймера Tt0 = k/Fcpu,
- вычисляем требуемое количество тактов для заданного интервала n = t/Tto,
- вычисляем начальное значение для счетного регистра TCNT0 = 256 - n.
Можно автоматизировать эту процедуру с помощью макросов. Например, так:
#define F_CPU 8000000UL
#define TIME_MS(time, k) (256L - ((time)*(F_CPU))/(1000L*(k)))
Но с таким макросом нужно быть начеку, при определенных значениях time и k могут возникать ошибки.
Теперь переходим к коду. Чтобы использовать таймер Т0 (да и любой другой тоже), его нужно настроить (инициализировать) и описать обработчик прерывания (если они используются).
Инициализация таймера состоит из следующих шагов:
Остановка таймера,
- задание режима Normal в TCCR0 без старта,
- установка начального значения TCNT0,
- сброс флагов в регистре TIFR,
- разрешение прерывания по переполнению в TIMSK,
- установка предделителя в TCCR0, то есть старт таймера
В данной последовательности возможны вариации.
Для нашей задачи код инициализации будет выглядеть так:
/*значение для счетного регистра*/
#define T_POLL 100
TCCR0 = 0;
TCCR0 = (0<
TIFR = (1<
Вторая строчка инициализации, по сути, бесполезна, она добавлена для наглядности. Чтобы четко видеть, какой режим таймера устанавливается.
Сброс флагов прерываний в регистре TIFR выполняется записью 1 в соответствующий разряд. Эту операцию нужно выполнять именно перезаписью регистра, а не с помощью побитового ИЛИ. И вот почему.
Допустим, в регистре TIFR устанавлены два флага прерывания - TOV1 и TOV0. TOV0 нам нужно сбросить. При установке требуемого разряда с помощью ИЛИ
происходит примерно следующая вещь.
//TIFR имеет значение 0b00000101
//установлены флаги
TOV1 и TOV0
//выполняется код
TIFR |= (1<
//TIFR копируется в R16
IN R16, 0x38
//в R16 устанавливается разряд TOV0
//хотя он и так уже установлен
ORI R16, 0x02
//R16, равный 0b00000101, записывается в регистр TIFR
OUT 0x38, R16
В результате сброшены оба флага, а мы хотели сбросить один.
Продолжаем.
Синтаксис описания обработчиков прерывания у разных компиляторов немного отличается. Для IAR`a обработчик прерывания таймера Т0 по событию переполнение будет выглядеть так:
{
TCNT0 = T_POLL;
/*здесь должен быть опрос кнопки*/
TIMER0_OVF_vect - это адрес вектора прерывания по событию переполнение. Он берется из заголовочных файлов на микроконтроллер. В данном случае я взял его из файла iom16.h.
Первая строка обработчика (TCNT0 = T_POLL;) выполняет перезапись счетного регистра, то устанавливает его начальное значение. Если этого не сделать, таймер продолжит счет с 0. Перезапись счетного регистра нужно выполнять в начале обработчика прерывания.
Весь код для нашей задачи будет выглядеть примерно так. (Код приведен для IAR`a. Для других компиляторов нужно изменить заголовочные файлы и обработчик прерывания.)
#include
#include
#include
#define T_POLL 100
int main(void)
{
/*инициализация таймера*/
TCCR0 = 0; /*инициализация остальной периферии*/ Enable_interrupt(); /*обработчик прерывания T0 /*опрос кнопки*/ /*инверсия PB0 для отладки*/ В режиме Normal таймер Т0 может изменять состояние вывода OC0 при совпадении счетного регистра и регистра сравнения. Причем даже без прерываний. Варианты управления определяются разрядами COM01 и COM00 регистра TCCR0. Вот пример программы, генерирующей прямоугольный сигнала на выводе ОС0. #include int main(void) TCCR0 = 0; /*инициализация OC0*/ While(1); Вывод ОС0 будет менять свое состояние на противоположное при нулевом значении счетного регистра. Обработчик прерывания таймера (да и любой другой периферии) нужно делать как можно короче. И последнее. Может случится ситуация, что обработка прерывания таймера задержится (например, по вине другого обработчика) и регистр TCNT0 уже посчитает несколько тактов. Если просто перезаписать значение TCNT0, то следующее прерывание вызовется позже, чем нужно. Получится, что предыдущее (задержанное) и новое прерывания не выдержат требуемый интервал. Эту ситуацию можно сгладить, если выполнять перезапись счетного регистра вот так: TCNT0 = TCNT0 + startValue; Сложение текущего значения счетного регистра с инициализируемым, учтет эти лишние такты.
Правда есть одно НО! При больших значения startValue операция сложения может вызвать переполнение счетного регистра. Например, startValue =
250, а таймер успел досчитать до 10. Тогда операция сложения приведет к такому результату: 10 + 250 = 260 Берем 8 разрядов от 260 получаем 4. В TCNT0 запишется 4.
/*
ISR_Blink
Те же фрукты, только в другом ракурсе
Мигание светодиодом с использованием механизма прерываний
(переполнение таймера/счетчика 2)
*/
volatile long mks100;
volatile long ms10;
volatile int cntr;
long tmillis,tms10=0;
char flip;
void setup() {
mks100 = 0; // счетчик сотен микросекунд, переполнение счетчика примерно через 5 суток
ms10 = 0; // счетчик десятков миллисекунд, переполнение счетчика примерно через 16 месяцев
cntr = 0;
flip = 0;
// мигаем стандартным светодиодом.
// На большинстве плат Arduino он подключен к 13-му выводу:
pinMode(13, OUTPUT);
Serial.begin(9600);
// Включаем нужный нам режим таймера/счетчика - нормальный
TCCR2A = 0; //нормальный режим (по умолчанию 1 - ШИМ с коррекцией фазы?)
// Предделитель таймера/счетчика настраиваем на 16 -
// это позволит "тикать" таймером каждую микросекунду
// (в предположении, что сердце микроконтроллера стучит с
// частотой 16.000.000 ударов в секунду)
TCCR2B = 2; // 010 - fclk/8 (по умолчанию 100 - fclk/64)
//TCCR2B = 7; // 111 - fclk/1024 (по умолчанию 100 - fclk/64)
TCNT2=59;//55;
TIMSK2 |= (1 << TOIE2); // разрешаем прерывание таймера/счетчика 2 по переполнению
}
ISR(TIMER2_OVF_vect) {
// прежде всего взводим счетчик
TCNT2=59;//55;
// прошли очередные 100 мксек - увеличиваем счетчик сотен микросекунд
mks100++;
// if(mks100%100==0) ms10++;
cntr++;
// прошли очередные 10 мсек? - увеличиваем счетчик десятков миллисекунд
if(cntr>99) {
ms10++;
cntr = 0;
}
}
void loop() {
if (ms10>tms10) {
tmillis = millis();
tms10 = ms10;
if (tms10%100==0) {
if(flip) digitalWrite(13, HIGH); // set the LED on
else digitalWrite(13, LOW); // set the LED off
flip = !flip;
}
if (tms10%1000==0) { // выполнение каждые 10 сек
Serial.print(tmillis,DEC);
Serial.print(" milliseconnds, ");
Serial.println(tms10,DEC);
}
}
} С счетчиком итераций главного цикла мы разобрались и выяснили, что для точных временных отсчетов он не годится совершенно — выдержка плавает, да и считать ее сложно. Что делать? Очевидно, что нужен какой то внешний счетчик, который тикал бы независимо от работы процессора, а процессор мог в любой момент посмотреть что в нем такое натикало. Либо чтобы счетчик выдавал события по переполнению или опустошению — флажок поднимал или прерывание генерил. А проц это прочухает и обработает. И такой счетчик есть, даже не один — это периферийные таймеры. В AVR их может быть несколько штук да еще с разной разрядностью. В ATmega16 три, в ATmega128 четыре. А в новых МК серии AVR может даже еще больше, не узнавал. Причем таймер может быть не просто тупым счетчиком, таймер является одним из самых навороченных (в плане альтернативных функций) периферийных девайсов. Что умееют таймеры
Разные таймеры имеют разную функциональность и разную разрядность. Это подробней смотреть в даташите. Погляди внимательно на распиновку ног ATmega16, видишь там ножки T1 и T0? Так вот это и есть счетные входы Timer 0 и Timer 1. При соответствующей настройке Т/С будет считать либо передний (перепад с 0-1), либо задний (перепад 1-0) фронт импульсов, пришедших на эти входы. Главное, чтобы частота входящих импульсов не превышала тактовую частоту процессора, иначе он не успеет обработать импульсы. Кроме того, Т/С2 способен работать в асинхронном режиме. То есть Т/С считает не тактовые импульсы процессора, не входящие импульсы на ножки, а импульсы своего собственного собственного генератора, работающего от отдельного кварца. Для этого у Т/С2 есть входы TOSC1 и TOSC2, на которые можно повесить кварцевый резонатор. Зачем это вообще надо? Да хотя бы организовать часы реального времени. Повесил на них часовой кварц на 32768 Гц да считай время — за секунду произойдет 128 переполнений (т.к. Т/С2 восьми разрядный). Так что одно переполнение это 1/128 секунды. Причем на время обработки прерывания по переполнению таймер не останавливается, он также продолжает считать. Так что часы сделать плевое дело! Предделитель
То есть еще до попадания в счетный регистр частота импульсов будет делиться. Делить можно на 8, 32, 64, 128, 256, 1024. Так что если повесишь на Т/С2 часовой кварц, да пропустишь через предделитель на 128, то таймер у тебя будет тикать со скоростью один тик в секунду. Удобно! Также удобно юзать предделитель когда надо просто получить большой интервал, а единственный источник тиков это тактовый генератор процессора на 8Мгц, считать эти мегагерцы задолбаешься, а вот если пропустить через предделитель, на 1024 то все уже куда радужней. Но тут есть одна особенность, дело в том, что если мы запустим Т/С с каким нибудь зверским предделителем, например на 1024, то первый тик на счетный регистр придет не обязательно через 1024 импульса. Это зависит от того в каком состоянии находился предделитель, а вдруг он к моменту нашего включения уже досчитал почти до 1024? Значит тик будет сразу же. Предделитель работает все время, вне зависимости от того включен таймер или нет. Поэтому предделители можно и нужно сбрасывать. Также надо учитывать и то, что предделитель един для всех счетчиков, поэтому сбрасывая его надо учитывать то, что у другого таймера собьется выдержка до следующего тика, причем может сбиться конкретно так. Например первый таймер работает на выводе 1:64, а второй на выводе 1:1024 предделителя. У второго почти дотикало в предделителе до 1024 и вот вот должен быть тик таймера, но тут ты взял и сбросил предделитель, чтобы запустить первый таймер точно с нуля. Что произойдет? Правильно, у второго делилка тут же скинется в 0 (предделитель то единый, регистр у него один) и второму таймеру придется ждать еще 1024 такта, чтобы получить таки вожделенный импульс! А если ты будешь сбрасывать предделитель в цикле, во благо первого таймера, чаще чем раз в 1024 такта, то второй таймер так никогда и не тикнет, а ты будешь убиваться головой об стол, пытаясь понять чего это у тебя второй таймер не работает, хотя должен. Для сброса предделителей достаточно записать бит PSR10 в регистре SFIOR. Бит PSR10 будет сброшен автоматически на следующем такте. Счетный регистр
Причем тут есть подвох, если в восьмиразрядный регистр надо положить число, то нет проблем OUT TCNT0,Rx и никаких гвоздей, то с двухбайтными придется поизвращаться. А дело все в чем - таймер считает независимо от процессора, поэтому мы можем положить вначале один байт, он начнет считаться, потом второй, и начнется пересчет уже с учетом второго байта. Чувствуете лажу? Вот! Таймер точное устройство, поэтому грузить его счетные регистры надо одновременно! Но как? А инженеры из Atmel решили проблему просто: Что в итоге получается: Записываем старший байт в регистр TEMP (для нас это один хрен TCNTxH), а затем записываем младший байт. В этот момент, в реальный TCNTxH, заносится ранее записанное нами значение. То есть два байта, старший и младший, записываются одновременно! Менять порядок нельзя! Только так Выглядит это так: CLI ; Запрещаем прерывания, в обязательном порядке!
OUT TCNT1H,R16 ; Старшей байт записался вначале в TEMP
OUT TCNT1L,R17 ; А теперь записалось и в старший и младший!
SEI ; Разрешаем прерывания Зачем запрещать прерывания? Да чтобы после записи первого байта, прога случайно не умчалась не прерывание, а там кто нибудь наш таймер не изнасиловал. Тогда в его регистрах будет не то что мы послали тут (или в прерывании), а черти что. Вот и попробуй потом такую багу отловить! А ведь она может вылезти в самый неподходящий момент, да хрен поймаешь, ведь прерывание это почти случайная величина. Так что такие моменты надо просекать сразу же. Читается все также, только в обратном порядке. Сначала младший байт (при этом старший пихается в TEMP), потом старший. Это гарантирует то, что мы считаем именно тот байт который был на данный момент в счетном регистре, а не тот который у нас натикал пока мы выковыривали его побайтно из счетного регистра. Контрольные регистры
Итак, главным регистром является TCCRx Нас пока интересуют только первые три бита этого регистра: У разных таймеров немного по разному, поэтому опишу биты CS02..CS00 только для таймера 0 Прерывания
За прерывания от таймеров отвечают регистры TIMSК, TIFR. А у более крутых AVR, таких как ATMega128, есть еще ETIFR и ETIMSK — своего рода продолжение, так как таймеров там поболее будет. TIMSK это регистр масок. То есть биты, находящиеся в нем, локально разрешают прерывания. Если бит установлен, значит конкретное прерывание разрешено. Если бит в нуле, значит данное прерывание накрывается тазиком. По дефолту все биты в нуле. На данный момент нас тут интересуют только прерывания по переполнению. За них отвечают биты О остальных фичах и прерываниях таймера мы поговорим попозжа, когда будем разбирать ШИМ. Регистр TIFR это непосредственно флаговый регистр. Когда какое то прерывание срабатывает, то выскакивает там флаг, что у нас есть прерывание. Этот флаг сбрасывается аппаратно когда программа уходит по вектору. Если прерывания запрещены, то флаг так и будет стоять до тех пор пока прерывания не разрешат и программа не уйдет на прерывание. Чтобы этого не произошло флаг можно сбросить вручную. Для этого в регистре TIFR в него нужно записать 1! А теперь похимичим
ORG $010
RETI ; (TIMER1 OVF) Timer/Counter1 Overflow
.ORG $012
RJMP Timer0_OV ; (TIMER0 OVF) Timer/Counter0 Overflow
.ORG $014
RETI ; (SPI,STC) Serial Transfer Complete Добавим обработчик прерывания по переполнению таймера 0, в секцию Interrupt. Так как наш тикающий макрос активно работает с регистрами и портит флаги, то надо это дело все сохранить в стеке сначала: Кстати, давайте создадим еще один макрос, пихающий в стек флаговый регистр SREG и второй — достающий его оттуда. MACRO PUSHF
PUSH R16
IN R16,SREG
PUSH R16
.ENDM
.MACRO POPF
POP R16
OUT SREG,R16
POP R16
.ENDM Как побочный эффект он еще сохраняет и R16, помним об этом:) Timer0_OV: PUSHF
PUSH R17
PUSH R18
PUSH R19
INCM TCNT
POP R19
POP R18
POP R17
POPF
RETI Теперь инициализация таймера. Добавь ее в секцию инита локальной периферии (Internal Hardware Init). ; Internal Hardware Init ======================================
SETB DDRD,4,R16 ; DDRD.4 = 1
SETB DDRD,5,R16 ; DDRD.5 = 1
SETB DDRD,7,R16 ; DDRD.7 = 1
SETB PORTD,6,R16 ; Вывод PD6 на вход с подтягом
CLRB DDRD,6,R16 ; Чтобы считать кнопку
SETB TIMSK,TOIE0,R16 ; Разрешаем прерывание таймера
OUTI TCCR0,1< Осталось переписать наш блок сравнения и пересчитать число. Теперь все просто, один тик один такт. Без всяких заморочек с разной длиной кода. Для одной секунды на 8Мгц должно быть сделано 8 миллионов тиков. В хексах это 7A 12 00 с учетом, что младший байт у нас TCNT0, то на наш счетчик остается 7А 12 ну и еще старшие два байта 00 00, их можно не проверять. Маскировать не нужно, таймер мы потом переустановим все равно. Одна только проблема — младший байт, тот что в таймере. Он тикает каждый такт и проверить его на соответствие будет почти невозможно. Т.к. малейшее несовпадение и условие сравнение выпадет в NoMatch, а подгадать так, чтобы проверка его значения совпала именно с этим тактом… Проще иголку из стога сена вытащить с первой попытки наугад. Так что точность и в этом случае ограничена — надо успеть проверить значение до того как оно уйдет из диапазона. В данном случае диапазон будет, для простоты, 255 — величина младшего байта, того, что в таймере. Тогда наша секунда обеспечивается с точностью 8000 000 плюс минус 256 тактов. Не велика погрешность, всего 0,003%. ; Main =========================================================
Main: SBIS PIND,6 ; Если кнопка нажата - переход
RJMP BT_Push
SETB PORTD,5 ; Зажгем LED2
CLRB PORTD,4 ; Погасим LED1
Next: LDS R16,TCNT ; Грузим числа в регистры
LDS R17,TCNT+1
CPI R16,0x12 ; Сравниванем побайтно. Первый байт
BRCS NoMatch ; Если меньше -- значит не натикало.
CPI R17,0x7A ; Второй байт
BRCS NoMatch ; Если меньше -- значит не натикало.
; Если совпало то делаем экшн
Match: INVB PORTD,7,R16,R17 ; Инвертировали LED3
; Теперь надо обнулить счетчик, иначе за эту же итерацию главного цикла; мы сюда попадем еще не один раз -- таймер то не успеет натикать 255 значений,
; чтобы число в первых двух байтах счетчика изменилось и условие сработает.
; Конечно, можно обойти это доп флажком, но проще сбросить счетчик:)
CLR R16 ; Нам нужен ноль
CLI ; Доступ к многобайтной переменной; одновременно из прерывания и фона; нужен атомарный доступ. Запрет прерываний
OUTU TCNT0,R16 ; Ноль в счетный регистр таймера
STS TCNT,R16 ; Ноль в первый байт счетчика в RAM
STS TCNT+1,R16 ; Ноль в второй байт счетчика в RAM
STS TCNT+2,R16 ; Ноль в третий байт счетчика в RAM
STS TCNT+3,R16 ; Ноль в первый байт счетчика в RAM
SEI ; Разрешаем прерывания снова.
; Не совпало - не делаем:)
NoMatch: NOP
INCM CCNT ; Счетчик циклов по тикает; Пускай, хоть и не используется.
JMP Main
BT_Push: SETB PORTD,4 ; Зажгем LED1
CLRB PORTD,5 ; Погасим LED2
RJMP Next
; End Main ===================================================== Вот как это выглядит в работе А если надо будет помигать вторым диодиком с другим периодом, то мы смело можем влепить в программу еще одну переменную, а в обработчике прерывания таймера инкрементировать сразу две пееременных. Проверяя их по очереди в главном цикле программы. Можно еще немного оптимизировать процесс проверки. Сделать его более быстрым. Надо только сделать счет не на повышение, а на понижение. Т.е. загружаем в переменную число и начинаем его декрементировать в прерывании. И там же, в обработчике, проверяем его на ноль. Если ноль, то выставляем в памяти флажок. А наша фоновая программа этот флажок ловит и запускает экшн, попутно переустанавливая выдержку. А что если надо точней? Ну тут вариант только один — заюзать обработку события прям в обработчике прерывания, а значение в TCNT:TCNT0 каждый раз подстраивать так, чтобы прерывание происходило точно в нужное время. В последнее время все больше и больше начинающих сталкиваются с проблемой освоения Таймеров/Счетчиков (далее Т/С) на этапе изучения микроконтроллеров. В данной статье я постараюсь развеять страхи перед данными модулями и доступно объяснить, как и с чем употребляют те самые Т/С. За основу мы возьмем очень популярную среди разработчиков устройств на МК книгу, автором которой является А.В. Евстифеев. По ссылкам в конце статьи Вы сможете найти проект в и проект в . В этой статье мы разберем работу 8-ми битного Т/С Т2, который входит в состав Т/С МК Atmega8. Итак, что же такое Таймер/Счетчик? Т/С - это один из модулей МК AVR с помощью которого можно отмерять определенные промежутки времени, организовать ШИМ и многие другие задачи. В зависимости от модели МК, количество Т/С может составлять 4 и более. Пример тому - МК Atmega640х, 1280х/1281х, 2560х/2561х, которые содержат на своем борту 6 Т/С: два 8-ми битных и четыре 16-ти битных. МК Atmega8 содержит в себе три Т/С: Т0 и Т2 с разрядностью 8 бит, Т1 с разрядностью 16 бит. Давайте подробнее рассмотрим Т/С Т2 микроконтроллера Atmega8. Этот таймер может работать в нескольких режимах: Normal, Phase correct PWM, CTC (сброс при совпадении), Fast PWM. Подробнее о каждом режиме Вы можете прочитать в книге. Данный Т/С состоит из регистра управления, счетного регистра, регистра сравнения, регистра состояния асинхронного режима. Структурная схема Т2 приведена на рис.1 Рассмотрим в теории как же работает данный модуль. Чтобы для начала Вам было понятнее, мы не будем рассматривать все лишние примочки таймера и рассмотрим самый обычный его режим - NORMAL. Для себя определим что МК тактируется от внутреннего RC-генератора с частотой 1МГц и таймер настроен на работу в режиме NORMAL. Тактовые импульсы поступают на вход clk i\o и попадают в предделитель таймера. Предделитель может быть настроен, по Вашим потребностям, на прямой проход тактовых импульсов или делить входящие импульсы, пропуская только их определенную часть. Поделить входящие импульсы можно на /8, /64, /256, /1024. Так как у нас Т\С может работать в асинхронном режиме, то при включении его в этот режим количество предделителей существенно вырастает, но мы их рассматривать пока не будем. С предделителя тактовые импульсы поступают в блок управления и уже с него попадают в счетный регистр. Счетный регистр в свою очередь совершает инкремент на каждый входящий импульс. Счетный регистр Т2 8-ми битный, поэтому он может считать только до 255. Когда наступает переполнение счетного регистра, он сбрасывается в 0 и в этом же такте начинает считать заново. Так же в момент переполнения счетного регистра устанавливается флаг TOV2 (флаг прерывания по переполнению) регистра TIFR. Теперь, раз уж мы затронули такие слова, как РЕГИСТР, самое время с ними познакомится. Для начала мы затронем только те регистры, с которыми будем непосредственно работать, дабы не забивать мозг лишней информацией. TCNT2 - счетный регистр, о его работе мы уже говорили. TCCR2 - регистр управления таймером. TIMSK - регистр маски прерываний(в Atmega8 этот регистр является единственным для всех таймеров). TIFR - регистр флагов прерываний(в Atmega8 этот регистр является единственным для всех таймеров).
А теперь о каждом подробно:
Регистр управления TCCR2. Содержимое этого регистра вы можете посмотреть на рис.2.
рис.2
Биты 0-2 отвечают за тактирование таймера. Установка определенных комбинаций в этих битах настраивает предделитель данного таймера. Если все три бита сброшены - таймер выключен.
Биты 3,6 отвечают за режим работы таймера.
Биты 4,5 нужны для настройки поведения вывода ОСn (проще говоря, используются при настройке ШИМ) И последний бит этого регистра - бит 7. С его помощью мы можем принудительно изменять состояние вывода ОСn. Регистр маски прерываний - TIMSK. Его мы видим на рисунке №3 Из этого регистра нас интересуют только два последних бита, биты 6 и 7. Этими битами мы разрешаем работу прерываний. Бит 6, если в него записать единицу, разрешает прерывание по событию "Переполнение Т\С Т2" Бит 7, если в него записать еди
ницу, разрешает прерывание по событию "Совпадение счетного регистра с регистром сравнения"
Регистр флагов прерываний TIFR. Его мы видим на рисунке №4
рис.4
В этом регистре нас так же интересуют два последних бита: биты 6 и 7.
Бит 6 - флаг, устанавливается по событию "Переполнение Т\С Т2" Эти биты сбрасываются автоматически при выходе из обработчика прерывания, но для надежности их можно сбрасывать самостоятельно, сбрасывая эти биты в "0". Остальные биты регистров TIMSK и TIFR используются Т\С Т0 и Т1. Как вы уже заметили, у битов этих регистров даже названия совпадают, за исключением цифры в конце названия, которая и указывает к какому таймеру данный бит применИм. Осталось рассмотреть две несложные таблички, а именно: таблица, в которой описано управление тактовым сигналом (рис. 6), и таблица, в которой описано, как в общем настроить таймер (рис.5). О том, что находится в этих таблицах, я писал выше, однако привожу Вам их для наглядности. Вот мы и закончили с теорией, и пора приступить к практической части. Сразу оговорюсь. ЧАСЫ, КОТОРЫЕ ПОЛУЧАТСЯ В ХОДЕ ИЗУЧЕНИЯ ДАННОЙ СТАТЬИ, НЕ ОБЛАДАЮТ ВЫСОКОЙ ТОЧНОСТЬЮ. ДАННАЯ СТАТЬЯ ОРИЕНТИРОВАННА НА ОБЩИЕ ПРИНЦИПЫ РАБОТЫ С ТАЙМЕРАМИ.
Открываем Studio 6, создаем проект и выбираем Atmega8. В самом начале указываем частоту тактирования и подключаем нужные нам для работы библиотеки < avr/io.h >
#include < avr/interrupt.h >
В первой строчке мы указываем частоту. Это необходимо для того, чтобы компилятор нас лучше понимал, если вдруг мы захотим использовать функции _delay_(). Во второй строчке кода подключается библиотека с общим описанием регистров нашего МК. Так же в ней всем регистрам присвоены читабельные имена. В третьей строке подключается библиотека для работы с векторами прерываний. TIMSK |= (1< < TOIE2);
TCCR2 |= (1< < CS22)|(1< < CS20);
SREG |= (1< < 7);
На этом настройка нашего таймера закончена. Давайте подробнее рассмотрим последние три строки кода. В первой строке мы разрешили прерывания по событию "Переполнение таймера\счетчика Т2" И в третьей строкой мы глобально разрешили прерывания. Это можно было также написать следующим образом: Asm("sei");
Остается добавить обработчик прерывания и код наших часов реального времени. ISR (TIMER2_OVF_vect)
{
takt++;
if (takt>=4){sek++; takt=0x00;}
if (sek>=60) {min++; sek=0x00;}
if (min>=60) {hour++; min=0x00;}
if (hour>=24) {hour=0х00};
}
В коде, который находится в обработчике прерывания, нет ничего сложного и нового для Вас. Внимание обратим только на переменную takt и волшебную цифру "4". Откуда взялась эта цифра? Давайте рассмотрим подробно этот момент. Мы знаем, что наш МК работает от внутреннего генератора с частотой 1МГц, таймер тактируется с предделителем \1024, считать наш таймер может до 255. Зная эти параметры мы можем посчитать сколько переполнений он совершит за 1 секунду 1 000 000 \ 1024 \ 256 = 3,814697..... Ну, а так как мы учимся работать с таймерами и не ставили цель получить суперточный ход часов, мы округляем наш результат и получаем "4". Т.е. за 1 секунду таймер переполнится ~4 раза. Почему мы делили на 256 если таймер считает только до 255? Потому что "0" это тоже число. Думаю, здесь все понятно. Не забываем, что все переменные нужно объявить как глобальные. Вот весь листинг программы которая у нас получилась.
#define F_CPU 1000000UL
#include < avr/io.h >
#include < avr/interrupt.h >
unsigned char takt = 0;
unsigned char sek = 0;
unsigned char min=0;
unsigned char hour=0;
ISR (TIMER2_OVF_vect)
{
takt++;
if (takt>=4){sek++; takt=0x00;}
if (sek>=60) {min++; sek=0x00;}
if (min>=60) {hour++; min=0x00;}
if (hour>=24) {hour=0х00};
}
int main(void)
{
TIMSK |= (1< < TOIE2);
TCCR2 |= (1< < CS22)|(1< < CS20);
SREG |= (1< < 7);
while(1)
{
}
}
А как же вывод информации пользователю? А тут кому как нравится. Можете использовать семисегментные индикаторы, графические или знакогенерирующие дисплеи и т.д. В архиве Вы найдете проект с выводом информации на дисплей от nokia5110, проект в Proteus 7 и все нужные файлы и библиотеки для работы. Обращаю внимание на то, что библиотека LCD_5110 для работы с дисплеем написана участником форума и предоставлена с его разрешения.
И приведем пример использования функции Arduino attachInterrupt()
. Прерывание – это сигнал, который сообщает процессору о наступлении какого-либо события, которое требует незамедлительного внимания. Процессор должен отреагировать на этот сигнал, прервав выполнение текущих инструкций и передав управление обработчику прерывания (ISR, Interrupt Service Routine). Обработчик – это обычная функция, которую мы пишем сами и помещаем туда тот код, который должен отреагировать на событие. После обслуживания прерывания ISR функция завершает свою работу и процессор с удовольствием возвращается к прерванным занятиям – продолжает выполнять код с того места, в котором остановился. Все это происходит автоматически, поэтому наша задача заключается только в том, чтобы написать обработчик прерывания, ничего при этом не сломав и не заставляя процессор слишком часто отвлекаться на нас. Понадобится понимание схемы, принципов работы подключаемых устройств и представление о том, как часто может вызываться прерывание, каковы особенности его возникновения. Все это и составляет основную сложность работы с прерываниями. Прерывания в Ардуино можно разделить на несколько видов: Аппаратные прерывания возникают в ответ на внешнее событие и исходят от внешнего аппаратного устройства. В Ардуино представлены 4 типа аппаратных прерываний. Все они различаются сигналом на контакте прерывания: Прерывания полезны в программах Ардуино, так как помогают решать проблемы синхронизации. Например, при работе с UART прерывания позволяют не отслеживать поступление каждого символа. Внешнее аппаратное устройство подает сигнал прерывания, процессор сразу же вызывает обработчик прерывания, который вовремя захватывает символ. Это позволяет экономить процессорное время, которое без прерываний тратилось бы на проверку статуса UART, вместо этого все необходимые действия выполняются обработчиком прерывания, не затрагивая главную программу. Особых возможностей от аппаратного устройства не требуется. Основными причинами, по которым необходимо вызвать прерывание, являются: При поступлении сигнала прерывания работа приостанавливается. Начинается выполнение функции, которая объявляется на выполнение при прерывании. Объявленная функция не может принимать входные значения и возвращать значения при завершении работы. На сам код в основном цикле программы прерывание не влияет. Для работы с прерываниями в Ардуино используется стандартная функция attachInterrupt()
. На других платах число прерываний выше. Например, плата имеет 6 пинов, которые могут обрабатывать внешние прерывания. Для всех плат Ардуино при работе с функцией attachInterrupt (interrupt, function, mode) аргумент Inerrupt 0 связан с цифровым пином 2. Теперь давайте перейдем к практике и поговорим о том, как использовать прерывания в своих проектах. Синтаксис attachInterrupt()
Функция attachInterrupt используется для работы с прерываниями. Она служит для соединения внешнего прерывания с обработчиком. Синтаксис вызова: attachInterrupt(interrupt, function, mode) Аргументы функции: Возможна установка следующих вариантов условий срабатывания: При работе с прерываниями нужно обязательно учитывать следующие важные ограничения: Давайте приступим к практике и рассмотрим простейший пример использования прерываний. В примере мы определяем функцию-обработчик, которая при изменении сигнала на 2 пине Arduino Uno переключит состояние пина 13, к которому мы традиционно подключим светодиод. #define PIN_LED 13
volatile boolean actionState = LOW;
void setup() {
pinMode(PIN_LED, OUTPUT);
// Устанавливаем прерывание
// Функция myEventListener вызовется тогда, когда
// на 2 пине (прерываниие 0 связано с пином 2)
// изменится сигнал (не важно, в какую сторону)
attachInterrupt(0, myEventListener, CHANGE);
}
void loop() {
// В функции loop мы ничего не делаем, т.к. весь код обработки событий будет в функции myEventListener
}
void myEventListener() {
actionState != actionState; //
// Выполняем другие действия, например, включаем или выключаем светодиод
digitalWrite(PIN_LED, actionState);
}
Давайте рассмотрим несколько примеров более сложных прерываний и их обработчиков: для таймера и кнопок. При прерывании возникает – перед тем, как контакты плотно соприкоснутся при нажатии кнопки, они будут колебаться, порождая несколько срабатываний. Бороться с дребезгом можно двумя способами – аппаратно, то есть, припаивая к кнопке конденсатора, и программно. Избавиться от дребезга можно при помощи функции – она позволяет засечь время, прошедшее от первого срабатывания кнопки. If(digitalRead(2)==HIGH) { //при нажатии кнопки
//Если от предыдущего нажатия прошло больше 100 миллисекунд
if (millis() - previousMillis >= 100) {
//Запоминается время первого срабатывания
previousMillis = millis();
if (led==oldled) { //происходит проверка того, что состояние кнопки не изменилось
led=!led;
}
Этот код позволяет удалить дребезг и не блокирует исполнение программы, как в случае с функцией delay, которая недопустима в прерываниях. Таймером называется счетчик, который производит счет с некоторой частотой, получаемой из процессорных 16 МГц. Можно произвести конфигурацию делителя частоты для получения нужного режима счета. Также можно настроить счетчик для генерации прерываний при достижении заданного значения. И прерывание по таймеру позволяет выполнять прерывание один раз в миллисекунду. В Ардуино имеется 3 таймера – Timer0, Timer1 и Timer2. Timer0 используется для генерации прерываний один раз в миллисекунду, при этом происходит обновление счетчика, который передается в функцию millis (). Этот таймер является восьмибитным и считает от 0 до 255. Прерывание генерируется при достижении значения 255. По умолчанию используется тактовый делитель на 65, чтобы получить частоту, близкую к 1 кГц. Для сравнения состояния на таймере и сохраненных данных используются регистры сравнения. В данном примере код будет генерировать прерывание при достижении значения 0xAF на счетчике. TIMSK0 |= _BV(OCIE0A); Требуется определить обработчик прерывания для вектора прерывания по таймеру. Вектором прерывания называется указатель на адрес расположения команды, которая будет выполняться при вызове прерывания. Несколько векторов прерывания объединяются в таблицу векторов прерываний. Таймер в данном случае будет иметь название TIMER0_COMPA_vect. В этом обработчике будут производиться те же действия, что и в loop (). SIGNAL(TIMER0_COMPA_vect) {
unsigned long currentMillis = millis();
sweeper1.Update(currentMillis);
if(digitalRead(2) == HIGH) {
sweeper2.Update(currentMillis);
led1.Update(currentMillis);
}
led2.Update(currentMillis);
led3.Update(currentMillis);
}
//Функция loop () останется пустой.
void loop()
{
}
Прерывание в Ардуино – довольно сложная тема, потому что приходится думать сразу обо всей архитектуре проекта, представлять как выполняется код, какие возможны события, что происходит, когда основной код прерывается. Мы не ставили задачу раскрыть все особенности работы с этой конструкцией языка, главная цель была познакомить с основными вариантами использования. В следующих статьях мы продолжим разговор о прерываниях более подробне.
TCCR0 = (0<
TIFR |= (1<
DDRB |= (1<
while(1);
по событию переполнение*/
#pragma vector = TIMER0_OVF_vect
__interrupt void TimerT0Ovf(void)
{
/*перезапись счетного регистра*/
TCNT0 = T_POLL;
PORTB ^= (1<Управление выводом OC0
#include
{
/*инициализация таймера Т0*/
TCCR0 = (0<
OCR0 = 0;
TIMSK = 0;
TCCR0 |= (1<
DDRB |= (1<
return 0;
}Несколько моментов относительно использования таймера
Если расчетное значение для счетного регистра (или регистра сравнения) округляется, то временной интервал будет отсчитываться таймером с погрешностью. One comment
Источник тиков таймера
Таймер/Счетчик (далее буду звать его Т/С) считает либо тактовые импульсы от встроенного тактового генератора, либо со счетного входа.
Если таймер считает импульсы от тактового генератора, или от своего внутреннего, то их еще можно пропустить через предделитель.
Весь результат мучений, описанных выше, накапливается в счетном регистре TCNTх, где вместо х номер таймера. он может быть как восьмиразрядным, так и шестнадцати разрядным, в таком случае он состоит из двух регистров TCNTxH и TCNTxL — старший и младший байты соответственно.
Запись в старший регистр (TCNTxH) ведется вначале в регистр TEMP. Этот регистр чисто служебный, и нам никак недоступен.
Всех функций таймеров я расписывать не буду, а то получится неподьемный трактат, лучше расскажу о основной — счетной, а всякие ШИМ и прочие генераторы будут в другой статье. Так что наберитесь терпения, ну или грызите даташит, тоже полезно.
Для Т/С0 и Т/С2 это TCCR0 и TCCR2 соответственно, а для Т/С1 это TCCR1B
CSx2.. CSx0, вместо х подставляется номер таймера.
Они отвечают за установку предделителя и источник тактового сигнала.
У каждого аппаратного события есть прерывание, вот и таймер не исключение. Как только происходит переполнение или еще какое любопытное событие, так сразу же вылазит прерывание.
Ну перекроим программу на работу с таймером. Введем программный таймер. Шарманка так и останется, пускай тикает. А мы добавим вторую переменную, тоже на четыре байта: 1
2
3
4
5
6
7
8
9
10
11
12
.MACRO PUSHF
PUSH R16
IN R16,SREG
PUSH R16
.ENDM
.MACRO POPF
POP R16
OUT SREG,R16
POP R16
.ENDM
1
2
3
4
5
6
7
8
9
10
11
12
13
Timer0_OV: PUSHF
PUSH R17
PUSH R18
PUSH R19
INCM TCNT
POP R19
POP R18
POP R17
POPF
RETI
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
; Main =========================================================
Main: SBIS PIND,6 ; Если кнопка нажата - переход
RJMP BT_Push
SETB PORTD,5 ; Зажгем LED2
CLRB PORTD,4 ; Погасим LED1
Next: LDS R16,TCNT ; Грузим числа в регистры
LDS R17,TCNT+1
CPI R16,0x12 ; Сравниванем побайтно. Первый байт
BRCS NoMatch ; Если меньше -- значит не натикало.
CPI R17,0x7A ; Второй байт
BRCS NoMatch ; Если меньше -- значит не натикало.
; Если совпало то делаем экшн
Match: INVB PORTD,7,R16,R17 ; Инвертировали LED3
; Теперь надо обнулить счетчик, иначе за эту же итерацию главного цикла; мы сюда попадем еще не один раз -- таймер то не успеет натикать 255 значений,
; чтобы число в первых двух байтах счетчика изменилось и условие сработает.
; Конечно, можно обойти это доп флажком, но проще сбросить счетчик:)
CLR R16 ; Нам нужен ноль
CLI ; Доступ к многобайтной переменной; одновременно из прерывания и фона; нужен атомарный доступ. Запрет прерываний
OUTU TCNT0,R16 ; Ноль в счетный регистр таймера
STS TCNT,R16 ; Ноль в первый байт счетчика в RAM
STS TCNT+1,R16 ; Ноль в второй байт счетчика в RAM
STS TCNT+2,R16 ; Ноль в третий байт счетчика в RAM
STS TCNT+3,R16 ; Ноль в первый байт счетчика в RAM
SEI ; Разрешаем прерывания снова.
; Не совпало - не делаем:)
NoMatch: NOP
INCM CCNT ; Счетчик циклов по тикает; Пускай, хоть и не используется.
JMP Main
BT_Push: SETB PORTD,4 ; Зажгем LED1
CLRB PORTD,5 ; Погасим LED2
RJMP Next
; End Main =====================================================
Бит 7 - флаг, устанавливается
по событию "Совпадение счетного регистра с регистром сравнения"
Аппаратные и программные прерывания
Зачем нужны аппаратные прерывания
Как реализуются прерывания в Ардуино
Отличие реализации прерываний в разных платах Ардуино
В зависимости от аппаратной реализации конкретной модели микроконтроллера есть несколько прерываний. Плата Arduino Uno имеет 2 прерывания на втором и третьем пине, но если требуется более двух выходов, плата поддерживает специальный режим «pin-change». Этот режим работает по изменению входа для всех пинов. Отличие режима прерывания по изменению входа заключается в том, что прерывания могут генерироваться на любом из восьми контактов. Обработка в таком случае будет сложнее и дольше, так как придется отслеживать последнее состояние на каждом из контактов.Прерывания в языке Arduino
Важные замечания
Примеры использования attachInterrupt
Прерывания по нажатию кнопки с антидребезгом
Прерывания по таймеру
Подведение итогов