В этом уроке мы поговорим о таймерах.
Данная тема непосредственно связана с темой тактирования микроконтроллера. Поэтому рекомендую перед прочтением данного урока ознакомиться с предыдущим.
Итак, зачем нам таймер?
При построении проектов на микроконтроллерах очень часто возникает необходимость измерение точных временных промежутков. Например, желание мигать светодиодом с определенной частотой, или опрашивать состояние кнопки с необходимыми временными промежутками.
Решить поставленные задачи помогают именно таймеры. Но таймеры микроконтроллеров AVR не знают что такое секунда, минута, час. Однако они прекрасно знают, что такое такт! Работают они именно благодаря наличию тактирования контроллера. То есть, таймер считает количество тактов контроллера, отмеряя тем самым промежутки времени. Допустим, контроллер работает при тактовой частоте 8МГц, то есть когда таймер досчитает до 8 000 000, пройдет одна секунда, досчитав до 16 000 000, пройдет 2 секунды и так далее.
Однако, тут возникает первое препятствие. Регистры то у нас 8 битные, то есть досчитать мы можем максимум до 255, а взяв 16 битный таймер, мы, досчитаем максимум до 65535. То есть за одну секунду мы должны обнулить таймер огромное количество раз! Конечно, можно заняться этим, если больше заняться нечем. Но ведь просто измерять время, используя мощный микроконтроллер совсем не интересно, хочется сделать нечто большее. Тут нам на помощь приходит предделитель. В общем виде это промежуточное звено между таймером и тактовой частотой контроллера. Предделитель облегчает нашу задачу позволяя поделить тактовую частоту на определенное число, перед подачей её на таймер. То есть установив предделитель на 8, за 1 секунду наш таймер досчитает до 1 000 000, вместо 8 000 000 (Разумеется, при частоте тактирования контроллера 8МГц). Уже интереснее, не так ли? А поделить мы можем и не только на 8, но и на 64 и даже на 1024.
Теперь настало время собрать схему, настроить наш таймер, предделитель, и сделать уже хоть что-то полезное!
А делать мы сегодня будем “бегущие огни” из светодиодов. То есть поочередно будем зажигать 3 светодиода, с периодом 0.75 секунды (То есть время работы одного светодиода 0.25 секунды). Соберем следующую схему:
Номиналы резисторов R 1-R 3 рассчитайте самостоятельно.
Далее, рассмотрим регистры отвечающие за работу таймеров. Всего AtMega 8 имеет в своем составе 3 таймера.Два 8 битных(Timer 0,Timer 2) и один 16 битный(Timer 1).Рассматривать будем на примере 16 битного таймера 1.
Пара регистров 8 битных регистров TCNT 1H и TCNT 1L , вместе образуют 16 битный регистр TCNT 1. Данный регистр открыт как для записи, так и для чтения. При работе таймера 1, значение данного регистра при каждом счете изменяется на единицу. То есть в регистре TCNT 1 записано число тактов, которые сосчитал таймер. Так же мы можем записать сюда любое число в диапазоне от 0 до 2 в 16 степени. В таком случае отсчет тактов будет вестись не с 0, а с записанного нами числа.
Регистр TIMSK отвечает за прерывания, генерируемые при работе таймеров микроконтроллера. Прерывание – обработчик специального сигнала, поступающего при изменении чего либо . Любое прерывания микроконтроллера может быть разрешено или запрещено. При возникновении разрешенного прерывания, ход основной программы прерывается, и происходит обработка данного сигнала. При возникновении запрещенного прерывания, ход программы не прерывается, а прерывание игнорируется. За разрешение прерывания переполнения счетного регистра TCNT 1 таймера 1 отвечает бит TOIE 1(Timer 1 Overflow Interrupt Enable ).При записи 1 в данный бит прерывание разрешено, а при записи 0 – запрещено. Данное прерывание генерируется таймером 1 при достижении максимального значения регистра TCNT 1. Подробнее о прерываниях поговорим в следующем уроке.
Регистр TCCR 1B отвечает за конфигурацию таймера 1. В данном случае битами CS 10-CS 12 мы задаем значение предделителя согласно следующей таблицы.
Остальные биты пока нас не интересуют.
Так же существует регистр TCCR 1A , который позволяет настроить другие режимы работы таймера, например ШИМ, но о них в отдельной статье.
А теперь код на C :
#define F_CPU 16000000UL
#include #define F_CPU 16000000UL
#include #include uint8_t
num
=
;
ISR
(TIMER1_OVF_vect
)
PORTD
=
(1
<<
num
)
;
num
++
;
if
(num
>
2
)
num
=
;
TCNT1
=
61630
;
//Начальное значение таймера
int
main
(void
)
DDRD
|=
(1
<<
PD0
)
|
(1
<<
PD1
)
|
(1
<<
PD2
)
;
TCCR1B
|=
(1
<<
CS12
)
|
(1
<<
CS10
)
;
//Предделитель = 1024
TIMSK
|=
(1
<<
TOIE1
)
;
//Разрешить прерывание по переполнению таймера 1
TCNT1
=
61630
;
//Начальное значение таймера
sei
()
;
//Разрешить прерывания
while
(1
)
//Основной цикл программы, он пуст, так как вся работа в прерывании
Код на ASM
: Assembly (x86)
Include "m8def.inc"
rjmp start
.org OVF1addr
rjmp TIM1_OVF
start:
ldi R16,LOW(RamEnd)
out SPL,R16
ldi R16,HIGH(RamEnd)
out SPH,R16
ldi R16,1
ldi R17,0b00000111
out DDRD,R17
ldi R17,0b00000101
out TCCR1B,R17
ldi R17,0b11110000
out TCNT1H,R17
ldi R17,0b10111110
out TCNT1l,R17
ldi R17,0b00000100
out TIMSK,R17
sei
main_loop:
nop
rjmp main_loop
TIM1_OVF:
out PORTD,R16
lsl R16
cpi R16,8
brlo label_1
ldi R16,1
label_1:
ldi R17,0b10111110
out TCNT1L,R17
ldi R17,0b11110000
out TCNT1H,R17
reti Include
"m8def.inc"
Rjmp
start
Org
OVF
1addr
Rjmp
TIM
1_
OVF
start
:
Ldi
R
16,
LOW
(RamEnd
)
Out
SPL
,
R
16 Ldi
R
16,
HIGH
(RamEnd
)
Out
SPH
,
R
16 Ldi
R
16,
1
Ldi
R
17,
0b00000111
Out
DDRD
,
R
17 Ldi
R
17,
0b00000101
Out
TCCR
1B
,
R
17 Ldi
R
17,
0b11110000
Out
TCNT
1H
,
R
17 Ldi
R
17,
0b10111110
По сути, таймер микроконтроллера - это цифровой счетчик, только "навороченый". На вход счетчика подается тактовый сигнал, по перепадам которого счетчик увеличивает свое значение. При возникновении событий - переполнение счетчика или совпадение его значения с заданным - генерируется запрос на прерывание. Давайте разберем, как пользоваться таймером Т0 в режиме Normal. В этом режиме таймер считает от какого-то начального значения счетного регистра до максимально возможного (до 255 или 0xFF). Когда таймер Т0 досчитывает до максимума, то в следующий такт таймера возникает переполнение счетного регистра TCNT0 - он обнуляется и устанавливается флаг TOV0. Если в программе разрешены прерывания глобально (флаг I регистра SREG) и прерывание таймера Т0 по переполнению (флаг TOIE0 регистра TIMSK), то микроконтроллер вызовет соответствующий обработчик. Если значение счетного регистра совпадет с регистром сравнения OCR0, то установится флаг OCF0 и при разрешенном прерывании по событию совпадение, запустится его обработчик. Рассмотрим практическую задачу - нам нужно каждые 20 мс опрашивать кнопку. Частота микроконтроллера 8 МГц, микроконтроллер ATmega16. Первое, что нужно сделать - это определиться с выбором коэффициента предделителя таймера и рассчитать начальное значение для счетного регистра TCNT0. Таймер Т0 может тактироваться от внутреннего тактового сигнала микроконтроллера или от внешнего, который подается на вывод Т0. При работе от внутреннего тактового сигнала пользователь может выбирать коэффициенты деления частоты этого сигнала. У таймера Т0 есть пять возможных вариантов коэффициента предделителя - 1, 8, 64, 256, 1024. Для решения поставленной задачи, я рассуждаю следующим образом. Если бы один такт таймера Т0 имел период 1 мс, то мне бы это подошло. 20 тактов дают 20 мс. Какой коэффициент предделителя таймера позволит получить близкий к 1 мс период тактовой частоты? Можно посчитать. Тактовая частота микроконтроллера Fcpu = 8000000 Гц При 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, Можно автоматизировать эту процедуру с помощью макросов. Например, так: #define F_CPU 8000000UL Но с таким макросом нужно быть начеку, при определенных значениях time и k могут возникать ошибки. Теперь переходим к коду. Чтобы использовать таймер Т0 (да и любой другой тоже), его нужно настроить (инициализировать) и описать обработчик прерывания (если они используются).
Инициализация таймера состоит из следующих шагов:
Остановка таймера, В данной последовательности возможны вариации. Для нашей задачи код инициализации будет выглядеть так: TCCR0 = 0; Вторая строчка инициализации, по сути, бесполезна, она добавлена для наглядности. Чтобы четко видеть, какой режим таймера устанавливается. Сброс флагов прерываний в регистре TIFR выполняется записью 1 в соответствующий разряд.
Эту операцию нужно выполнять именно перезаписью регистра, а не с помощью побитового ИЛИ. И вот почему. Допустим, в регистре TIFR устанавлены два флага прерывания - TOV1 и TOV0. TOV0 нам нужно сбросить. При установке требуемого разряда с помощью ИЛИ
происходит примерно следующая вещь. //в R16 устанавливается разряд TOV0 //R16, равный 0b00000101, записывается в регистр TIFR В результате сброшены оба флага, а мы хотели сбросить один. Продолжаем. Синтаксис описания обработчиков прерывания у разных компиляторов немного отличается. Для IAR`a обработчик прерывания таймера Т0 по событию переполнение будет выглядеть так: /*здесь должен быть опрос кнопки*/ TIMER0_OVF_vect - это адрес вектора прерывания по событию переполнение. Он берется из заголовочных файлов на микроконтроллер. В данном случае я взял его из файла iom16.h. Первая строка обработчика (TCNT0 = T_POLL;) выполняет перезапись счетного регистра, то устанавливает его начальное значение. Если этого не сделать, таймер продолжит счет с 0. Перезапись счетного регистра нужно выполнять в начале обработчика прерывания. Весь код для нашей задачи будет выглядеть примерно так. (Код приведен для IAR`a. Для других компиляторов нужно изменить заголовочные файлы и обработчик прерывания.) #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.
Урок 10
Сегодня мы узнаем, что такое таймеры-счётчики
в микроконтроллерах и для чего они нужны, а также что такое прерывания
и для чего они тоже нужны. Таймеры-счётчики
— это такие устройства или модули в микроконтроллере, которые, как видно из названия, постоянно что-то считают. Считают они либо до определённой величины, либо до такой величины, сколько они битности. Считают они постоянно с одной скоростью, со скоростью тактовой частоты микроконтроллера, поправленной на делители частоты, которые мы будем конфигурировать в определённых регистрах. И вот эти таймеры-счётчики постоянно считают, если мы их инициализируем. Таймеров в МК Atmega8
три. Два из них — это восьмибитные
таймеры, то есть такие, которые могут максимально досчитать только до 255. Данной величины нам будет маловато. Даже если мы применим максимальный делитель частоты, то мы не то что секунду не отсчитаем, мы даже полсекунды не сможем посчитать. А у нас задача именно такая, чтобы досчитывать до 1 секунды, чтобы управлять наращиванием счёта светодиодного индикатора. Можно конечно применить ещё наращивание переменной до определенной величины, но хотелось бы полностью аппаратного счёта. Но есть ещё один таймер — это полноправный 16-битный
таймер. Он не только 16-битный
, но есть в нём ещё определённые прелести, которых нет у других таймеров. С данными опциями мы познакомимся позже. Вот этот 16-битный таймер мы и будем сегодня изучать и использовать. Также, познакомившись с данным таймером, вам ничего не будет стоить самостоятельно изучить работу двух других, так как они значительно проще. Но тем не менее 8-битные таймеры в дальнейшем мы также будем рассматривать, так как для достижения более сложных задач нам одного таймера будет недостаточно. Теперь коротко о прерываниях. Прерывания
(Interrupts
) — это такие механизмы, которые прерывают код в зависимости от определённых условий или определённой обстановки, которые будут диктовать некоторые устройства, модули и шины, находящиеся в микроконтроллере. В нашем контроллере Atmega8 существует 19 видов прерываний. Вот они все находятся в таблице в технической документации на контроллер Какого типа могут быть условия? В нашем случае, например, досчитал таймер до определённой величины, либо например в какую-нибудь шину пришёл байт и другие условия. На данный момент мы будем обрабатывать прерывание, которое находится в таблице, размещённой выше на 7 позиции — TIMER1 COMPA
, вызываемое по адресу 0x006. Теперь давайте рассмотрим наш 16-битный таймер или TIMER1
. Вот его структурная схема Мы видим там регистр TCNTn
, в котором постоянно меняется число, то есть оно постоянно наращивается. Практически это и есть счётчик. То есть данный регистр и хранит число, до которого и досчитал таймер. А в регистры OCRnA
и OCRnB
(буквы n — это номер таймера, в нашем случае будет 1) — это регистры, в которые мы заносим число, с которым будет сравниваться чило в регистре TCNTn. Например, занесли мы какое-нибудь число в регистр OCRnA и как только данное число совпало со значением в регистре счёта, то возникнет прерывание и мы его сможем обработать. Таймеры с прерываниями очень похожи на обычную задержку в коде, только когда мы находимся в задержке, то мы в это время не можем выполнять никакой код (ну опять же образно "мы", на самом деле АЛУ). А когда считает таймер, то весь код нашей программы в это время спокойно выполняется. Так что мы выигрываем колоссально, не давая простаивать огромным ресурсам контроллера по секунде или даже по полсекунды. В это время мы можем обрабатывать нажатия кнопок, которые мы также можем обрабатывать в таймере и многое другое. Есть также регистр TCCR. Данный регистр — это регистр управления. Там настраиваются определенные биты, отвечающие за конфигурацию таймера. Также у таймера существует несколько режимов, с которыми мы также познакомимся немного позденее. Он состоит из двух половинок, так как у нас конотроллер 8-битный и в нем не может быть 16-битных регистров. Поэтому в одной половинке регистра (а физически в одном регистре) хранится старшая часть регистра, а в другом — младшая. Можно также назвать это регистровой парой, состоящей из двух отдельных регистров TCCR1A и TCCR1B. Цифра 1 означает то, что регистр принадлежит именно таймеру 1. Даный регист TCCR отвечает за установку делителя, чтобы таймер не так быстро считал, также он отвечает (вернее его определённые биты) за установку определённого режима. За установку режима отвечают биты WGM Мы видим здесь очень много разновидностей режимов. Normal
— это обычный режим, таймер считает до конца. PWM
— это ШИМ
только разные разновидности, то есть таймер может играть роль широтно-импульсного модулятора
. С данной технологией мы будем знакомиться в более поздних занятиях. CTC
— это сброс по совпадению, как раз то что нам будет нужно. Здесь то и сравнивются регистры TCNT и OCR. Таких режима два, нам нужен первый, второй работает с другим регистром. Все разновидности режимов мы в данном занятии изучать не будем. Когда нам эти режимы потребуются, тогда и разберёмся. Ну давайте не будем томить себя документацией и наконец-то попробуем что-то в какие-нибудь регистры занести. Код, как всегда, был создан из прошлого проекта. Для протеуса также код был скопирован и переименован с прошлого занятия, также в свойствах контроллера был указан путь к новой прошивке. Проекты мы назовем Test07
. Попробуем как всегда скомпилировать код и запустить его в протеусе. Если всё нормально работает, то начинаем добавлять новый код. Добавим ещё одну функцию, благо добавлять функции мы на прошлом занятии научились. Код функции разместим после функции segchar и до функции main. После из-за того, что мы будем внутри нашей новой функции вызывать функцию segchar. Мало того, мы создадим не одну функцию, а целых две. В одну функцию мы разместим весь код инициализации нашего таймеру, а другая функция будет являться обработчиком прерывания от таймера, а такие функции они специфичны и вызывать их не требуется. Когда возникнет необходимость, они вызовутся сами в зависимости от определённых условий, которые были оговорены выше. Поэтому первую функцию мы назвовём timer_ini
//———————————————
void
timer_ini
(
void
)
{
}
//———————————————
Также давайте наши функции, а также какие-то законченные блоки с объявлением глобальных переменных, с прототипами функций будем отделять друг от друга вот такими чёрточками, которые за счет наличия двух слешей впереди компилятор обрабатывать не будет и примет их за комментарии. За счёт этих отчерчиваний мы будем видеть, где заканчивается одна функция и начинается другая. Данная функция, как мы видим не имеет ни каких аргументов — ни входных, не возвращаемых. Давайте сразу данную функцию вызовем в функции main() unsigned
char
butcount=0,
butstate=0;
timer_ini
();
Теперь мы данную функцию начнём потихонечку наполнять кодом. Начнем с регистра управления таймером, например с TCCR1B. Используя нашу любимую операцию "ИЛИ", мы в определённый бит регистра занесём единичку void
timer_ini
(
void
)
TCCR1B
|=
(1<<
WGM12
);
Из комментария мы видим, что мы работает с битами режима, и установим мы из них только бит WGM12, остальные оставим нули. Исходя из этого мы сконфигурировали вот такой режим: Также у таймера существует ещё вот такой регистр — TIMSK
. Данный регистр отвечает за маски прерываний — Interrupt Mask
. Доступен данный регистр для всех таймеров, не только для первого, он общий. В данном регистре мы установим бит OCIE1A
, который включит нужный нам тип прерывания TIMER1 COMPA
TCCR1B
|=
(1<<
WGM12
);
// устанавливаем режим СТС (сброс по совпадению)
TIMSK
|=
(1<<
OCIE1A
);
Теперь давайте поиграемся с самими регистрами сравнения OCR1A(H и L)
. Для этого придётся немного посчитать. Регистр OCR1AH
хранит старшую часть числа для сравнения, а регистр OCR1AL
— младшую. Но прежде чем посчитать, давайте пока напишем код с любыми значениями данного регистра и потом поправим, так как дальше мы будем инициализировать делитель и он тоже будет учавствовать в расчёте требуемого времени счёта. Без делителя таймер будет слишком быстро считать. TIMSK
|=
(1<<
OCIE1A
);
//устанавливаем бит разрешения прерывания 1ого счетчика по совпадению с OCR1A(H и L)
OCR1AH
=
0b10000000;
OCR1AL
=
0b00000000;
TCCR1B
|=
(
);
//установим делитель.
Пока никакой делитель не устанавливаем, так как мы его ещё не посчитали. Давайте мы этим и займёмся. Пока у нас в регистре OCR1A
находится число 0b1000000000000000, что соответствует десятичному числу 32768. Микроконтроллер у нас работает, как мы договорились, на частоте 8000000 Гц. Разделим 8000000 на 32768, получим приблизительно 244,14. Вот с такой частотой в герцах и будет работать наш таймер, если мы не применим делитель. То есть цифры наши будут меняться 244 раза в секунду, поэтому мы их даже не увидим. Поэтому нужно будет применить делитель частоты таймера. Выберем делитель на 256. Он нам как раз подойдёт, а ровно до 1 Гц мы скорректируем затем числом сравнения. Вот какие существуют делители для 1 таймера Я выделил в таблице требуемый нам делитель. Мы видим, что нам требуется установить только бит CS12
. Так как делитель частоты у нас 256, то на этот делитель мы поделим 8000000, получится 31250, вот такое вот мы и должны занести число в TCNT. До такого числа и будет считать наш таймер, чтобы досчитать до 1 секунды. Число 31250 — это в двоичном представлении 0b0111101000010010. Занесём данное число в регистровую пару, и также применим делитель OCR1AH
=
0b01111010
;
//записываем в регистр число для сравнения
OCR1AL
=
0b00010010
;
TCCR1B
|=
(1<<
CS12
);
//установим делитель.
С данной функцией всё. Теперь следующая функция — обработчик прерывания от таймера по совпадению. Пишется она вот так ISR
(
TIMER1_COMPA_vect
)
{
}
И тело этой функции будет выполняться само по факту наступления совпадения чисел. Нам нужна будет переменная. Объявим её глобально, в начале файла #include
//———————————————
unsigned
char
i
;
//———————————————
Соответственно, из кода в функции main() мы такую же переменную уберём int
main
(
void
)
unsigned
char
i
;
Также закомментируем весь код в бесконечном цикле. Его роль теперь у нас будет выполнять таймер, и, я думаю, он с этим справится не хуже, а даже лучше, "никому" при этом не мешая. while
(1)
{
// for(i=0;i<10;i++)
// {
// while (butstate==0)
// {
// if (!(PINB&0b00000001))
// {
// if(butcount < 5)
// {
// butcount++;
// }
// else
// {
// i=0;
// butstate=1;
// }
// }
// else
// {
// if(butcount > 0)
// {
// butcount—;
// }
// else
// {
// butstate=1;
// }
// }
// }
// segchar(i);
// _delay_ms(500);
// butstate=0;
// }
Теперь, собственно, тело функции-обработчика. Здесь мы будем вызывать функцию segchar. Затем будем наращивать на 1 переменную i
. И чтобы она не ушла за пределы однозначного числа, будем её обнулять при данном условии ISR
(
TIMER1_COMPA_vect
)
if
(
i
>9)
i
=0;
segchar
(
i
);
i
++;
Теперь немного исправим код вначале функции main(). Порт D
, отвечающий за состояние сегментов, забьём единичками, чтобы при включении у нас не светился индикатор, так как он с общим анодом. Затем мы здесь занесём число 0 в глобавльную переменную i, просто для порядка. Вообще, как правило, при старте в неициализированных переменных и так всегда нули. Но мы всё же проинициализируем её. И, самое главное, чтобы прерывание от таймера работало, её недостаточно включить в инициализации таймера. Также вообще для работы всех прерываний необходимо разрешить глобальные прерывания. Для этого существует специальная функция sei() — Set Interrupt
. Теперь код будет вот таким DDRB
=
0x00;
PORTD
=
0b11111111
;
PORTB
=
0b00000001;
i
=0;
sei
();
while
(1)
Также ещё мы обязаны подключить файл библиотеки прерываний вначале файла #include
#include
#include
Также переменные для кнопки нам пока не потребуются, так как с кнопкой мы сегодня работать не будем. Закомментируем их int
main
(
void
)
//unsigned char butcount=0, butstate=0;
timer_ini
();
Соберём наш код и проверим его работоспособность сначала в протеусе. Если всё нормально работает, то проверим также в живой схеме Всё у нас работает. Отлично! Вот такой вот получился секундомер. Но так как у нас даже нет кварцевого резонатора, то данный секундомер нельзя назвать точным. Тем не менее сегодня мы с вами много чему научились. Мы узнали о прерываниях, также научились их обрабатывать, Научились работать с таймерами, конфигурировать несколько новых регистров микроконтроллера, до этого мы работали только с регистрами портов. Также за счёт всего этого мы значительно разгрузили арифметическо-логическое устройство нашего микроконтроллера. Смотреть ВИДЕОУРОК Post Views:
17 258
В
данном разделе будет описано на использование программного таймера 2 для периодических прерываний. Исходная идея состояла в использовании этого таймера для генерации частоты биений в звуковых проектах Arduino. Чтобы выводить тон или частоту нам нужно переключать порт ввода-вывода на согласованной частоте. Это можно делать с использованием циклов задержки. Это просто, но означает, что наш процессор будет занят, ничего не выполняя, но ожидая точного времени переключения вывода. С использованием прерывания по таймеру мы можем заняться другими делами, а вывод пусть переключает ISR, когда таймер подаст сигнал, что время пришло. Необходимо только установить таймер, чтобы подавал сигнал с прерыванием в нужное время. Вместо прокрутки бесполезного цикла для задержки по времени, главная программа может делать что-то другое, например, контролировать датчик движения или управлять электроприводом. Что бы ни требовалось проекту, больше нам не нужно процессорное время для получения задержек. Далее будет описано ISR в общем только то, что касается прерываний таймера 2. Более подробно об использовании прерываний в процессорах AVR можно прочитать в руководстве пользователя avr-libc(англ). На данном этапе не требуется полного понимания, но, в конечном счете, вы можете захотеть получить возможность ускорить использование прерываний, раз это важный инструмент для приложений на микроконтроллерах. Arduino пользуется всеми тремя таймерами ATMega168: 1) Таймер 0 (Системное время, ШИМ 5 and 6) Используется для хранения счетчика времени работы программы. Функция millis() возвращает число миллисекунд с момента запуск программы, используя ISR глобального приращения таймера 0. Таймер 0 также используется для реализации ШИМ на выводах 5 и 6. 2) Таймер 1 (ШИМ 9 и 10) Используется для реализации ШИМ для цифровых выводах 9 и 10. 3)Таймер 2 (ШИМ 3 и 11) Используется для управления выходами ШИМ для цифровых выводов 3 и 11. Хотя все таймеры используются, только Таймер 0 имеет назначенную таймеру ISR. Это означает, что можно захватить Таймер 1 и/или Таймер2 под свои нужды. Однако в результате нельзя будет использовать ШИМ на некоторых портах ввода-вывода. Если планируется использовать ШИМ, необходимо помнить об этом. Чтобы
дать представление об эффекте, предположим, что таймер ISR запускался бы каждые 20 мкс. Процессор, работающий на 16 МГц, может выполнить около 1 машинной команды каждые 63 мс или около 320 машинных команд для каждого цикла прерывания (20 мкс). Предположим также, что исполнение каждой строки программы на С может занять много машинных команд. Каждая инструкция, используемая в ISR, отнимает время, доступное для исполнения любой другой программы. Если бы ISR использовала около 150 машинных циклов, было бы потрачено половина доступного процессорного времени. При активных прерываниях главная программа откладывалась бы около? времени, занимаемого ей в других случаях. 150 машинных команд - не очень большая программа на С, поэтому необходимо быть внимательны. Если будет слишком длинная ISR, то главная программа будет исполняться крайне медленно, если же ISR будет длиннее, чем продолжительность цикла таймера, то практически никогда не выполнится ваша главная программа, и, кроме того, в конце концов произойдет сбой системного стека. Поскольку
необходимо иметь очень быстрый таймер ISR, то нужно измерить, насколько загружены доступные ресурсы. Для этого необходим некоторый метод. Таймер не был установлен в режим, когда он перезагружается автоматически. Это значит, что ISR должна перезагрузить таймер для следующего интервала счета. Было бы точнее иметь автоматически перезагружаемый таймер, но, используя этот режим, можно измерить время, проводимое в ISR, и соответственно исправить время, загружаемое в таймер. Ключ в том, что при помощи этой коррекции при разумной точности, также получаем и число, показывающее, сколько времени проводим в ISR. Метод заключается в том, что таймер хранит время, даже если он переполнен и прерван. В конце ISR можно захватить текущее значение счетчика таймера. Это значение представляет то время, которое он отнял у разработчика до следующей точки программы. Это суммарное время, затраченное на переход в процедуру прерывания и выполнение программы в ISR. Небольшая ошибка будет оттого, что не подсчитывается время, затраченное на команду перезагрузки таймера, но эту ошибку можно исправить эмпирически. Фактически именно поэтому используется в формуле подсчета загружаемого значения 257 вместо 256. Было обнаружено опытным путем, что это дает лучший результат. Лишний такт компенсирует команду перезагрузки таймера. Часто при работе с проектами на микроконтроллерах требуется запускать фоновую функцию через равные промежутки времени. Это часто реализуется установкой аппаратного таймера для выработки прерывания. Это прерывание запускает программу обработки прерываний (Interrupt Service Routine, ISR) для управления периодическим прерыванием. В настоящей статье я описываю установку 8-битного таймера 2 для выработки прерываний на микроконтроллере ATMega168 Arduino. Я пройдусь по этапам, требуемым для установки программы обработки прерываний и внутри нее самой. Arduino подразумевает процессор ATMega168. Этот микроконтроллер имеет несколько систем ввода-вывода, которые доступны каждому пользователю Arduino, поскольку библиотека Arduino облегчает их использование. К примеру, цифровой ввод-вывод, ШИМ, аналого-цифровые входы и последовательный порт. ATMega168 также имеет три внутренних аппаратных таймера. Хотя библиотека Arduino позволяет использовать некоторые свойства таймеров, нельзя напрямую использовать таймер для выработки периодических прерываний. таймер память цоколевка stepper /*
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);
}
}
}
Таймер Т0 в режиме Normal
Период тактового сигнала микроконтроллера Tcpu = 1/Fcpu
Период тактового сигнала таймера Т0 равен Tt0 = (1/Fcpu)/k = k/Fcpu
- вычисляем требуемое количество тактов для заданного интервала n = t/Tto,
- вычисляем начальное значение для счетного регистра TCNT0 = 256 - n.
#define TIME_MS(time, k) (256L - ((time)*(F_CPU))/(1000L*(k)))
- задание режима Normal в TCCR0 без старта,
- установка начального значения TCNT0,
- сброс флагов в регистре TIFR,
- разрешение прерывания по переполнению в TIMSK,
- установка предделителя в TCCR0, то есть старт таймера
/*значение для счетного регистра*/
#define T_POLL 100
TCCR0 = (0<
TIFR = (1<
//TIFR имеет значение 0b00000101
//установлены флаги
TOV1 и TOV0
//выполняется код
TIFR |= (1<
//TIFR копируется в R16
IN R16, 0x38
//хотя он и так уже установлен
ORI R16, 0x02
OUT 0x38, R16
{
TCNT0 = T_POLL;
#include
#include
{
/*инициализация таймера*/
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;
}Несколько моментов относительно использования таймера
Если расчетное значение для счетного регистра (или регистра сравнения) округляется, то временной интервал будет отсчитываться таймером с погрешностью. Таймеры-счетчики. Прерывания
Прерывание по таймеру
Таймеры на Arduino
Загрузка микроконтроллера прерываниями
Измерение загрузки прерываниями
Использование прерываний в Arduino
One comment
