В этом уроке мы поговорим о таймерах.
Данная тема непосредственно связана с темой тактирования микроконтроллера. Поэтому рекомендую перед прочтением данного урока ознакомиться с предыдущим.
Итак, зачем нам таймер?
При построении проектов на микроконтроллерах очень часто возникает необходимость измерение точных временных промежутков. Например, желание мигать светодиодом с определенной частотой, или опрашивать состояние кнопки с необходимыми временными промежутками.
Решить поставленные задачи помогают именно таймеры. Но таймеры микроконтроллеров 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
С Таймером 1 и Таймером 2 связаны три
вектора прерывания: Прерывание переполнения таймера -
Timer Overflow Interrupt (INT00,2000H); Прерывание переполнения Таймера 2 -
Timer 2 Overflow Interrupt (INT12,2038H); Прерывание фиксатора Таймера 2 - Timer
2 Capture Interrupt (INT11,2036H). Регистр IOS1 содержит флажки, которые
указывают какое событие вызвало
прерывание. Обращение к битам регистра
IOS1 по командам JBC или JBS обнуляет биты
0-5. По этой причине, мы рекомендуем чтобы
Вы копировали содержимое регистра IOS1
в промежуточный регистр и затем выполняли
команды проверки разрядов типа JBC или
JBS на промежуточном регистре. И Таймер 1 и Таймер 2 могут вызвать
прерывание переполнения Таймера (INT00).
Установите INT_MASK.0 ,чтобы разрешить это
прерывание. Установите или IOC1.2 (Таймер
1) или IOC1.3 (Таймер 2) чтобы выбрать
источник прерывания. Когда происходит
переполнение, устанавливается флажок
состояния в регистре IOS1. Переполнение
Таймера 1 устанавливает IOS1.5, а переполнение
Таймера 2 устанавливает IOS1.4. HWindow 0 (Write), HWindow 15 (Read) Hwindow 0 (Write), HWindow 15 (Read) Таймер 2 может генерировать прерывание
переполнения Таймера 2 (INT12, адрес вектора
- 2038H) вместо стандартного прерывания
переполнения Таймера. Это прерывание
разрешается установкой INT_MASK1.4. Переполнение
Таймера 2 устанавливает IOS1.4. Таймер 2
может генерировать прерывание переполнения
Таймера 2 или на границе 7FFFH/8000H или на
границе 0FFFFH/0000H. Переполнение может
происходить в любом направлении. IOC2.5
выбирает границу переполнения. Когда
IOC2.5 установлен, Таймер 2 прерывается на
границе 7FFFH/8000H. Иначе, он прерывается
на границе 0FFFFH/0000H. Положительный переход на контакте
T2CAPTURE (P2.7) заставляет значение Таймера
2 загружаться в регистр T2CAPTURE
. Это
событие генерирует прерывание фиксатора
Таймера 2 (INT11), если установлен INT_MASK1.3 и
T2CAPTURE утверждается в течение более двух
времен состояний. Hwindow 15(Read /Write) При использовании таймеров как датчиков
времени для HSI или HSO, следующие руководящие
принципы помогут Вам избежать потенциальных
проблем. Будьте осторожны при записи в регистры
таймера TIMER1 и TIMER2:
Изменение значения TIMER1 после инициализизации
HSI модуля может разрушить относительные
ссылки между HSI событиями. Также,
изменение значения соответствующего
таймера (TIMER1 или TIMER2), после инициализизации
HSO модуля, может заставить HSO пропускать
запрограммированные события или
выполнять их в неправильном порядке. Конфигурируйте Таймер 2 для
функционирования в нормальном режиме
(не в быстром режиме приращения):
Так как для полного сканирования CAM,
HSO требует восьми времен состояния,
Таймер 2, когда он используется как
датчик времени для HSO, должен
функционировать в нормальном режиме
приращения (не в быстром режиме приращения) . Очистите бит FAST_T2_ENA(IOC2.0) для выбора
нормального режима работы таймера. Конфигурируйте Таймер 2 для счета
только в одном направлении.
Таймер 2 , когда он используется как
датчик времени для HSO, должен считать
только в одном направлении, поскольку,
если Таймер 2 колеблется вокруг отметки
времени выполнения команды, блокировка
входов может происходить несколько
раз. Очистите бит T2UD_ENA(IOC2.1), чтобы сконфигурировать
Таймер 2 как суммирующий счетчик. Используйте предостережение при
сбросе Таймера 2.
Не сбрасывайте Tаймер 2 до того, как
его значение достигнет самого наибольшего
времени, запрограммированного в CAM. CAM
задерживает ожидание события до
соответствующего времени. Если
запрограммированное значение Таймера
2 никогда не достигается, событие будет
оставаться отложенным, пока устройство
не сбросится или CAM не очистится. Когда Таймер 2 сконфигурирован для
сброса внешним контактом, события
программы должны происходить когда
Таймер 2 равен единице, а не нулю:
Когда Таймер 2 сконфигурирован, чтобы
сбрасываться внешним контактом сброса
(IOC0.3 =1), программные события не должны
происходить, когда Таймер 2 равен нулю.
Если HSI.0 или T2RST (P2.3) сбрасывают Таймер
2, событие может не произойти. Внешние
контакты сбрасывают Таймер 2 асинхронно,
и Таймер 2 может увеличиться до 1 до того,
как HSO может сравнить и распознать CAM
запись. Программируйте события так,
чтобы они происходили, когда Таймер 2
равен 1, это гарантирует,что HSO имеет
достаточное время, чтобы распознать
команду, записанную в CAM . ФРАГМЕНТ ПРОГРАММЫ ИЗУЧЕНИЯ ПРОГРАММИРОВАНИЯ
ТАЙМЕРОВ ;**Исследование пpoгpаммных задеpжек с
использованием Timer1* ldb wsr,#15 ; Пеpеключиться в HWindow 15 ld timer1,#0c000h ; Загpузить значение счетчика ldb wsr,#0 ; Пеpеключиться в HWindow 0 jbc ios1, 5, $ ; Ожидание пеpеполнения Timer ;*********************************************************** В
данном разделе будет описано на использование программного таймера 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 Узнаем, как работать с прерываниями по таймеру. Напишем простую программу с параллельными процессами. В реальной программе надо одновременно совершать много действий. Во введении я приводил пример . Перечислю, какие действия она совершает: Операция Все эти операции выполняются циклически, у всех разные периоды циклов. Ни какую из них нельзя приостановить. Любое, даже кратковременное, изменение времени периода операции приведет к неприятностям: значительной погрешности измерения, неправильной работе стабилизаторов, мерцанию индикаторов, неустойчивой реакции нажатий на кнопки и т.п. В программе контроллера холодильника существует несколько параллельных процессов, которые и совершают все эти действия, каждое в цикле со своим временем периода. Параллельные процессы - это процессы, действия которых выполняются одновременно.
В предыдущих уроках мы создали класс для объекта кнопка. Мы сказали, что это класс для обработки сигнала в параллельном процессе. Что для его нормальной работы необходимо вызывать функцию (метод) обработки сигнала в цикле с регулярным периодом (мы выбрали время 2 мс). И тогда в любом месте программы доступны признаки, показывающие текущее состояние кнопки или сигнала. В одном цикле мы поместили код обработки состояния кнопок и управление светодиодами. А в конце цикла поставили функцию задержки delay(2). Но, время на выполнение программы в цикле меняет общее время цикла. И период цикла явно не равен 2 мс. К тому же, во время выполнения функции delay() программа зависает и не может производить других действий. На сложной программе получится полный хаос. Выход - вызывать функцию обработки состояния кнопки по прерыванию от аппаратного таймера. Каждые 2 мс основной цикл программы должен прерываться, происходить обработка сигнала кнопки и управление возвращаться в основной цикл на код, где он был прерван. Короткое время на обработку сигнала кнопки не будет значительно влиять на выполнение основного цикла. Т.е. обработка кнопки будет происходить параллельно, незаметно для основной программы. Аппаратное прерывание от таймера.
Аппаратное прерывание это сигнал, сообщающий о каком-то событии. По его приходу выполнение программы приостанавливается, и управление переходит на обработчик прерываний. После обработки управление возвращается в прерванный код программы. С точки зрения программы прерывание это вызов функции по внешнему, не связанному напрямую с программным кодом, событию. Сигнал прерывания от таймера вырабатывается циклически, с заданным временем периода. Формирует его аппаратный таймер – счетчик с логикой, сбрасывающий его код при достижении определенного значения. Программно установив код для логики сброса, мы можем задать время периода прерывания от таймера. Установка режима и времени периода таймера Ардуино производится через аппаратные регистры микроконтроллера. При желании можете разобраться, как это делается. Но я предлагаю более простой вариант – использование библиотеки MsTimer2. Тем более, что установка режима таймера происходит редко, а значит, использование библиотечных функций не приведет к замедлению работы программы. Библиотека MsTimer2.
Библиотека предназначена для конфигурирования аппаратного прерывания от Таймера 2 микроконтроллера. Она имеет всего три функции: Эта функция устанавливает время периода прерывания в мс. С таким периодом будет вызываться обработчик прерывания f. Он должен быть объявлен как void (не возвращает ничего) и не иметь аргументов. * f – это указатель на функцию. Вместо него надо написать имя функции. Функция разрешает прерывания от таймера. Функция запрещает прерывания от таймера. Перед именем функций надо писать MsTimer2::, т.к. библиотека написана с использованием директивы пространства имен namespace. Для установки библиотеки скопируйте каталог MsTimer2 в папку libraries в рабочей папке Arduino IDE. За тем запустите программу Arduino IDE, откройте Скетч -> Подключить библиотеку
и посмотрите, что в списке библиотек присутствует библиотека MsTimer2. Загрузить библиотеку MsTimer2 в zip-архиве можно . Для установки его надо распаковать. Простая программа с параллельной обработкой сигнала кнопки.
Теперь напишем простую программу с одной кнопкой и светодиодом из урока 6. К плате Ардуино подключена одна кнопка по схеме: Выглядит это так: На каждое нажатие кнопки светодиод на плате Ардуино меняет свое состояние. Необходимо чтобы были установлены библиотеки MsTimer2 и Button: MsTimer2
И оплатите. Всего 25 руб. в месяц за доступ ко всем ресурсам сайта!
// sketch_10_1 урока 10
#include #define LED_1_PIN 13 //
Button button1(BUTTON_1_PIN, 15); // создание объекта - кнопка
void setup() {
void loop() {
// управление светодиодом
// обработчик прерывания
В функции setup()
задаем время цикла прерывания по таймеру 2 мс и указываем имя обработчика прерывания timerInterrupt
. Функция обработки сигнала кнопки button1.scanState()
вызывается в обработчике прерывания таймера каждые 2 мс. Таким образом, состояние кнопки мы обрабатываем параллельным процессом. А в основном цикле программы проверяем признак клика кнопки и меняем состояние светодиода. Квалификатор volatile.
Давайте изменим цикл loop() в предыдущей программе. void loop() {
while(true) {
// был клик кнопки
Логически ничего не поменялось. Разница только в том, в каком цикле крутится программа в loop или в while. Но если мы запустим последний вариант программы, то увидим, что светодиод не реагирует на нажатие кнопки. Давайте уберем класс, упростим программу. #include void setup() {
void loop() {
while (true) {
count= 0;
// обработчик прерывания
В этой программе счетчик count увеличивается на 1 в обработчике прерывания каждые 500 мс. В цикле while он анализируется, по break выходим из цикла и инвертируем состояние светодиода. Проще программы не придумаешь, но она тоже не работает. Дело в том, что компилятор языка C++ по мере своего интеллекта оптимизирует программу. Иногда это не идет на пользу. Компилятор видит, что в цикле while никакие операции с переменной count не производятся. Поэтому он считает, что достаточно проверить состояние count только один раз. Зачем в цикле проверять, то, что никогда не может измениться. Компилятор корректирует код, оптимизируя его по времени исполнения. Проще говоря убирает из цикла код проверки переменной. Понять, что переменная count меняет свое состояние в обработчике прерывания, компилятор не может. В результате мы зависаем в цикле while. В вариантах программы с выполнением цикла loop до конца компилятор считает, что все переменные могут измениться и оставляет код проверки. Если в цикл while вставить вызов любой системной функции, то компилятор также решит, что переменные могут измениться. Если, например, добавить в цикл while вызов функции delay(), то программа заработает. while (true) {
Хороший стиль – разрабатывать программы, в которых цикл loop выполняется до конца и программа нигде не подвисает. В следующем уроке будет единственный код с анализом флагов в бесконечных циклах while. Дальше я планирую во всех программах выполнять loop до конца. Иногда это сделать непросто или не так эффективно. Тогда надо использовать квалификатор volatile. Он указывается при объявлении переменной и сообщает компилятору, что не надо пытаться оптимизировать ее использование. Он запрещает компилятору делать предположения по поводу значения переменной, так как переменная может быть изменена в другом программном блоке, например, в параллельном процессе. Также компилятор размещает переменную в ОЗУ, а не в регистрах общего назначения. Достаточно в программе при объявлении count написать volatile int count=0;
и все варианты будут работать. Для программы с управлением кнопкой надо объявить, что свойства экземпляра класса Button могут измениться. volatile Button button1(BUTTON_1_PIN, 15); // создание объекта - кнопка
По моим наблюдениям применение квалификатора volatile никак не увеличивает длину кода программы. Сравнение метода обработки сигнала кнопки с библиотекой Bounce.
Существует готовая библиотека для устранения дребезга кнопок Bounce. Проверка состояния кнопки происходит при вызове функции update(). В этой функции: В сложных программах эту библиотеку лучше не использовать. В следующем уроке напишем более сложную программу с параллельными процессами. Узнаем, как реализовывать выполнение блоков программы в циклах с различными временными интервалами от одного прерывания по таймеру. В последнее время все больше и больше начинающих сталкиваются с проблемой освоения Таймеров/Счетчиков (далее Т/С) на этапе изучения микроконтроллеров. В данной статье я постараюсь развеять страхи перед данными модулями и доступно объяснить, как и с чем употребляют те самые Т/С. За основу мы возьмем очень популярную среди разработчиков устройств на МК книгу, автором которой является А.В. Евстифеев. По ссылкам в конце статьи Вы сможете найти проект в и проект в . В этой статье мы разберем работу 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 для работы с дисплеем написана участником форума и предоставлена с его разрешения.
1.3.1. Прерывание переполнения таймера
Input/Output Control Register 1
Input/Output Status Register 1
1.3.2. Прерывание переполнения Таймера 2
1.3.3. Прерывание фиксатора Таймера 2
Timer 2 Capture Register
1.4. Предосторожности при работе с Таймерами
Прерывание по таймеру
Таймеры на Arduino
Загрузка микроконтроллера прерываниями
Измерение загрузки прерываниями
Использование прерываний в Arduino
Время цикла
Опрашивает 3 кнопки, обрабатывает сигналы с них для устранения дребезга
2 мс
Регенерирует данные семисегментных светодиодных индикаторов
2 мс
Вырабатывает сигналы управления для 2 датчиков температуры DS18B20 и считывает данные с них. Датчики имеют последовательный интерфейс 1-wire.
100 мкс для каждого бита,
1 сек общий цикл чтения
Чтение аналоговых значений тока и напряжения на элементе Пельтье, напряжения питания
100 мкс
Цифровая фильтрация аналоговых значений тока и напряжения
10 мс
Вычисление мощности на элементе Пельтье
10 мс
ПИД (пропорционально интегрально дифференциальный) регулятор стабилизации тока и напряжения
100 мкс
Регулятор мощности
10 мс
Регулятор температуры
1 сек
Защитные функции, контроль целостности данных
1 сек
Управление, общая логика работы системы
10 мс
// Нажатие на кнопку меняет состояние светодиода
#include
#define BUTTON_1_PIN 12 // кнопка подключена к выводу 12
MsTimer2::set(2, timerInterupt); // задаем период прерывания по таймеру 2 мс
MsTimer2::start(); //
}
if (button1.flagClick == true) {
// был клик кнопки
}
}
void timerInterupt() {
button1.scanState(); // вызов метода ожидания стабильного состояния для кнопки
}
if (button1.flagClick == true) break;
}
button1.flagClick= false; // сброс признака
digitalWrite(LED_1_PIN, ! digitalRead(LED_1_PIN)); // инверсия светодиода
}
#define LED_1_PIN 13 // светодиод подключен к выводу 13
int count=0;
pinMode(LED_1_PIN, OUTPUT); // определяем вывод светодиода как выход
MsTimer2::set(500, timerInterupt); // задаем период прерывания по таймеру 500 мс
MsTimer2::start(); // разрешаем прерывание по таймеру
}
if (count != 0) break;
}
digitalWrite(LED_1_PIN, ! digitalRead(LED_1_PIN)); // инверсия состояния светодиода
}
void timerInterupt() {
count++;
}
if (count != 0) break;
delay(1);
}
Бит 7 - флаг, устанавливается
по событию "Совпадение счетного регистра с регистром сравнения"
