AVR. Учебный курс. Таймеры | Электроника для всех

С счетчиком итераций главного цикла мы разобрались и выяснили, что для точных временных отсчетов он не годится совершенно — выдержка плавает, да и считать ее сложно. Что делать?

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

И такой счетчик есть, даже не один — это периферийные таймеры. В AVR их может быть несколько штук да еще с разной разрядностью. В ATmega16 три, в ATmega128 четыре. А в новых МК серии AVR может даже еще больше, не узнавал.

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

Что умееют таймеры

• Тикать с разной скоростью, подсчитывая время
• Считать входящие извне импульсы (режим счетчика)
• Тикать от внешнего кварца на 32768гц
• Генерировать несколько видов ШИМ сигнала
• Выдавать прерывания (по полудесятку разных событий) и устанавливать флаги

Разные таймеры имеют разную функциональность и разную разрядность. Это подробней смотреть в даташите.

Источник тиков таймера
Таймер/Счетчик (далее буду звать его Т/С) считает либо тактовые импульсы от встроенного тактового генератора, либо со счетного входа.

Погляди внимательно на распиновку ног 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 будет сброшен автоматически на следующем такте.

Счетный регистр
Весь результат мучений, описанных выше, накапливается в счетном регистре TCNTх, где вместо х номер таймера. он может быть как восьмиразрядным, так и шестнадцати разрядным, в таком случае он состоит из двух регистров TCNTxH и TCNTxL — старший и младший байты соответственно.

Причем тут есть подвох, если в восьмиразрядный регистр надо положить число, то нет проблем OUT TCNT0,Rx и никаких гвоздей, то с двухбайтными придется поизвращаться.

А дело все в чем — таймер считает независимо от процессора, поэтому мы можем положить вначале один байт, он начнет считаться, потом второй, и начнется пересчет уже с учетом второго байта.

Чувствуете лажу? Вот! Таймер точное устройство, поэтому грузить его счетные регистры надо одновременно! Но как? А инженеры из Atmel решили проблему просто:
Запись в старший регистр (TCNTxH) ведется вначале в регистр TEMP. Этот регистр чисто служебный, и нам никак недоступен.

Что в итоге получается: Записываем старший байт в регистр TEMP (для нас это один хрен TCNTxH), а затем записываем младший байт. В этот момент, в реальный TCNTxH, заносится ранее записанное нами значение. То есть два байта, старший и младший, записываются одновременно! Менять порядок нельзя! Только так

Выглядит это так:

1
2
3
4

	CLI 			; Запрещаем прерывания, в обязательном порядке!
	OUT	TCNT1H,R16	; Старшей байт записался вначале в TEMP
	OUT	TCNT1L,R17	; А теперь записалось и в старший и младший!
	SEI 			; Разрешаем прерывания

CLI ; Запрещаем прерывания, в обязательном порядке! OUT TCNT1H,R16 ; Старшей байт записался вначале в TEMP OUT TCNT1L,R17 ; А теперь записалось и в старший и младший! SEI ; Разрешаем прерывания

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

Читается все также, только в обратном порядке. Сначала младший байт (при этом старший пихается в TEMP), потом старший. Это гарантирует то, что мы считаем именно тот байт который был на данный момент в счетном регистре, а не тот который у нас натикал пока мы выковыривали его побайтно из счетного регистра.

Контрольные регистры
Всех функций таймеров я расписывать не буду, а то получится неподьемный трактат, лучше расскажу о основной — счетной, а всякие ШИМ и прочие генераторы будут в другой статье. Так что наберитесь терпения, ну или грызите даташит, тоже полезно.

Итак, главным регистром является TCCRx
Для Т/С0 и Т/С2 это TCCR0 и TCCR2 соответственно, а для Т/С1 это TCCR1B

Нас пока интересуют только первые три бита этого регистра:
CSx2.. CSx0, вместо х подставляется номер таймера.
Они отвечают за установку предделителя и источник тактового сигнала.

У разных таймеров немного по разному, поэтому опишу биты CS02..CS00 только для таймера 0

• 000 — таймер остановлен
• 001 — предделитель равен 1, то есть выключен. таймер считает тактовые импульсы
• 010 — предделитель равен 8, тактовая частота делится на 8
• 011 — предделитель равен 64, тактовая частота делится на 64
• 100 — предделитель равен 256, тактовая частота делится на 256
• 101 — предделитель равен 1024, тактовая частота делится на 1024
• 110 — тактовые импульсы идут от ножки Т0 на переходе с 1 на 0
• 111 — тактовые импульсы идут от ножки Т0 на переходе с 0 на 1

Прерывания

За прерывания от таймеров отвечают регистры TIMSК, TIFR. А у более крутых AVR, таких как ATMega128, есть еще ETIFR и ETIMSK — своего рода продолжение, так как таймеров там поболее будет.

TIMSK это регистр масок. То есть биты, находящиеся в нем, локально разрешают прерывания. Если бит установлен, значит конкретное прерывание разрешено. Если бит в нуле, значит данное прерывание накрывается тазиком. По дефолту все биты в нуле.

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

• TOIE0 — разрешение на прерывание по переполнению таймера 0
• TOIE1 — разрешение на прерывание по переполнению таймера 1
• TOIE2 — разрешение на прерывание по переполнению таймера 2

О остальных фичах и прерываниях таймера мы поговорим попозжа, когда будем разбирать ШИМ.

Регистр TIFR это непосредственно флаговый регистр. Когда какое то прерывание срабатывает, то выскакивает там флаг, что у нас есть прерывание. Этот флаг сбрасывается аппаратно когда программа уходит по вектору. Если прерывания запрещены, то флаг так и будет стоять до тех пор пока прерывания не разрешат и программа не уйдет на прерывание.

Чтобы этого не произошло флаг можно сбросить вручную. Для этого в регистре TIFR в него нужно записать 1!

А теперь похимичим
Ну перекроим программу на работу с таймером. Введем программный таймер. Шарманка так и останется, пускай тикает. А мы добавим вторую переменную, тоже на четыре байта:

1
2
3
4

; RAM ========================================================
		.DSEG
CCNT:	.byte	4
TCNT:	.byte	4

; RAM ======================================================== .DSEG CCNT: .byte 4 TCNT: .byte 4

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

Делаем RJMP на обработчик с вектора.

1
2
3
4
5
6

         .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

.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 и второй — достающий его оттуда.

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

.MACRO PUSHF PUSH R16 IN R16,SREG PUSH R16 .ENDM .MACRO POPF POP R16 OUT SREG,R16 POP R16 .ENDM

Как побочный эффект он еще сохраняет и R16, помним об этом 🙂

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

Timer0_OV: PUSHF PUSH R17 PUSH R18 PUSH R19 INCM TCNT POP R19 POP R18 POP R17 POPF RETI

Теперь инициализация таймера. Добавь ее в секцию инита локальной периферии (Internal Hardware Init).

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15

; 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<<CS00		; Запускаем таймер. Предделитель=1
					; Т.е. тикаем с тактовой частотой.
 
	SEI				; Разрешаем глобальные прерывания
; End 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<<CS00 ; Запускаем таймер. Предделитель=1 ; Т.е. тикаем с тактовой частотой. SEI ; Разрешаем глобальные прерывания ; End Internal Hardware Init ===================================

Осталось переписать наш блок сравнения и пересчитать число. Теперь все просто, один тик один такт. Без всяких заморочек с разной длиной кода. Для одной секунды на 8Мгц должно быть сделано 8 миллионов тиков. В хексах это 7A 12 00 с учетом, что младший байт у нас TCNT0, то на наш счетчик остается 7А 12 ну и еще старшие два байта 00 00, их можно не проверять. Маскировать не нужно, таймер мы потом переустановим все равно.

Одна только проблема — младший байт, тот что в таймере. Он тикает каждый такт и проверить его на соответствие будет почти невозможно. Т.к. малейшее несовпадение и условие сравнение выпадет в NoMatch, а подгадать так, чтобы проверка его значения совпала именно с этим тактом… Проще иголку из стога сена вытащить с первой попытки наугад.

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

Тогда наша секунда обеспечивается с точностью 8000 000 плюс минус 256 тактов. Не велика погрешность, всего 0,003%.

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 =====================================================

; 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 каждый раз подстраивать так, чтобы прерывание происходило точно в нужное время.

Учебный курс AVR. Таймер — счетчик Т0. Регистры. Ч1

   Таймер-счетчик является одним из самых ходовых ресурсов AVR микроконтроллера. Его основное назначение — отсчитывать заданные временные интервалы. Кроме того, таймеры-счетчики могут выполнять ряд дополнительных функций, как то — формирование ШИМ сигналов, подсчет длительности и количества входящих импульсов. Для этого существуют специальные режимы работы таймера-счетчика. 

   В зависимости от модели микроконтроллера количество таймеров и набор их функций может отличаться. Например, у микроконтроллера Atmega16 три таймера-счетчика — два 8-ми разрядных таймера-счетчика Т0 и Т2, и один 16-ти разрядный — Т1. В этой статье, на примере ATmega16, мы разберем как использовать таймер-счетчик Т0.

   Таймер-счетчик Т0 использует два вывода микроконтроллера ATmega16. Вывод T0 (PB0) — это вход внешнего тактового сигнала. Он может применяться, например, для подсчета импульсов. Вывод OC0 (PB3) — это выход схемы сравнения таймера-счетчика. На этом выводе с помощью таймера может формировать меандр или ШИМ сигнал. Также он может просто менять свое состояние при срабатывании схемы сравнения, но об этом поговорим позже. 

   
   Выводы T0 и OC0 задействуются только при соответствующих настройках таймера, в обычном состоянии это выводы общего назначения. 

   Хоть это и скучно, но регистры — это то, без чего невозможно программировать микроконтроллеры, конечно, если вы не сидите плотно на Arduino. Так вот, таймер Т0 имеет в своем составе три регистра:

— счетный регистр TCNT0,
— регистр сравнения OCR0,
— конфигурационный регистр TCCR0.

Кроме того, есть еще три регистра, относящиеся ко всем трем таймерам ATmega16:

— конфигурационный регистр TIMSK,
— статусный регистр TIFR.
— регистр специальных функций SFIOR

Начнем с самого простого.

TCNT0

   Это 8-ми разрядный счетный регистр. Когда таймер работает, по каждому импульсу тактового сигнала значение TCNT0 изменяется на единицу. В зависимости от режима работы таймера, счетный регистр может или увеличиваться, или уменьшаться.
   Регистр TCNT0 можно как читать, так и записывать. Последнее используется когда требуется задать его начальное значение. Когда таймер работает, изменять его содержимое TCNT0 не рекомендуется, так как это блокирует схему сравнения на один такт.

OCR0  

   Это 8-ми разрядный регистр сравнения. Его значение постоянно сравнивается со счетным регистром TCNT0, и в случае совпадения таймер может выполнять какие-то действия — вызывать прерывание, менять состояние вывода OC0 и т.д. в зависимости от режима работы.

   Значение OCR0 можно как читать, так и записывать.

TCCR0 (Timer/Counter Control Register)

   Это конфигурационный регистр таймера-счетчика Т0, он определяет источник тактирования таймера, коэффициент предделителя, режим работы таймера-счетчика Т0 и поведение вывода OC0. По сути, самый важный регистр. 

   Биты CS02, CS01, CS00 (Clock Select) — определяют источник тактовой частоты для таймера Т0 и задают коэффициент предделителя. Все возможные состояния описаны в таблице ниже.

   
   Как видите, таймер-счетчик может быть остановлен, может тактироваться от внутренней частоты и также может тактироваться от сигнала на выводе Т0. 

   Биты WGM10, WGM00 (Wave Generator Mode) — определяют режим работы таймера-счетчика Т0. Всего их может быть четыре — нормальный режим (normal), сброс таймера при совпадении (CTC), и два режима широтно-импульсной модуляции (FastPWM и Phase Correct PWM). Все возможные значения описаны в таблице ниже.

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

   Биты COM01, COM00 (Compare Match Output Mode) — определяют поведение вывода OC0. Если хоть один из этих битов установлен в 1, то вывод OC0 перестает функционировать как обычный вывод общего назначения и подключается к схеме сравнения таймера счетчика Т0. Однако при этом он должен быть еще настроен как выход.
   Поведение вывода OC0 зависит от режима работы таймера-счетчика Т0. В режимах normal и СTC вывод OC0 ведет себя одинаково, а вот в режимах широтно-импульсной модуляции его поведение отличается. Не будем сейчас забивать себе голову всеми этими вариантами и разбирать таблицы для каждого режима, оставим это на практическую часть.

   И последний бит регистра TCCR0 — это бит FOC0 (Force Output Compare). Этот бит предназначен для принудительного изменения состояния вывода OC0. Он работает только для режимов Normal и CTC. При установки бита FOC0 в единицу состояние вывода меняется соответственно значениям битов COM01, COM00. FOC0 бит не вызывает прерывания и не сбрасывает таймер в CTC режиме.

TIMSK (Timer/Counter Interrupt Mask Register)

   Общий регистр для всех трех таймеров ATmega16, он содержит флаги разрешения прерываний. Таймер Т0 может вызывать прерывания при переполнении счетного регистра TCNT0 и при совпадении счетного регистра с регистром сравнения OCR0. Соответственно для таймера Т0 в регистре TIMSK зарезервированы два бита — это TOIE0 и OCIE0. Остальные биты относятся к другим таймерам.

TOIE0 — 0-е значение бита запрещает прерывание по событию переполнение, 1 — разрешает. 
OCIE0 — 0-е значение запрещает прерывания по событию совпадение, а 1 разрешает.

   Естественно прерывания будут вызываться, только если установлен бит глобального разрешения прерываний — бит I регистра SREG.

TIFR (Timer/Counter0 Interrupt Flag Register)

   Общий для всех трех таймеров-счетчиков регистр. Содержит статусные флаги, которые устанавливаются при возникновении событий. Для таймера Т0 — это переполнение счетного регистра TCNT0 и совпадение счетного регистра с регистром сравнения OCR0. 

Если в эти моменты в регистре TIMSK разрешены прерывания и установлен бит I, то микроконтроллер вызовет соответствующий обработчик.
   Флаги автоматически очищаются при запуске обработчика прерывания. Также это можно сделать программно, записав 1 в соответствующий флаг.

TOV0 — устанавливается в 1 при переполнении счетного регистра.
OCF0 — устанавливается в 1 при совпадении счетного регистра с регистром сравнения

SFIOR (Special Function IO Register)

   
    Начинающему про этот регистр в принципе можно и не знать, один из его разрядов сбросывает 10-ти разрядный двоичный счетчик, который делит входную частоту для таймера Т0 и таймера Т1. 

   Сброс осуществляется при установке бита PSR10 (Prescaler Reset Timer/Counter1 и Timer/Counter0) в единицу.

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

Микроконтроллеры AVR: Режимы работы таймеров/счетчиков

• Обычный режим работы. Самый распространенный режим, когда таймер просто считает приходящие импульсы и при переполнении счетного регистра устанавливает флаг прерывания по переполнению. При этом счетный регистр сбрасывается в 0 и подсчет импульсов начинается сначала.
• Режим подсчета импульсов (Сброс при совпадении).  Также называется CTC. В этом режиме при совпадении счетного регистра с одним из регистров сравнения выставляется флаг прерывания по совпадению, счетный регистр обнуляется и подсчет начинается сначала. При этом по совпадению может меняться сигнал на выходе таймера, соответствующего используемому регистру совпадения. 
• Режим ШИМ. В данном режиме изменяется ширина импульса в зависимости от значения, записанного в регистр совпадения. Для 8-битного таймера, к примеру, если записать в регистр совпадения число 10, состояние логической единицы на выходе совпадения будет 10 тактов из 256, а логический 0 246 тактов из 256 (для неинверсного режима). В инверсном же режиме 10 тактов будет состояние логического 0 и 246 тактов логической единицы. 
• Режим коррекции фазы ШИМ. В обычном режиме ШИМ мы получаем плавающую фазу выходного сигнала. Для того, чтобы этого избежать, в режиме коррекции фазы ШИМ при достижении максимального значения, счетный регистр таймера/счетчика начинает уменьшатся. Это происходит циклически.

• Асинхронный режим работы. В асинхронном режиме работы к микроконтроллеру подключается внешний кварцевый резонатор 32 кГц. Чаще всего этот режим используется для работы таймера/счетчика T2 в качестве часов реального времени.

• Режим коррекции фазы и частоты ШИМ. Отличается от режима коррекции фазы ШИМ лишь моментом обновления регистра сравнения. Регистр сравнения обновляется когда значение счетного регистра достигает минимума.
• Режим захвата. При поступлении сигнала от аналогового компаратора, а также на вывод ICP1 (14 ножка) значение счетного регистра сохраняется в регистре захвата, устанавливая при этом флаг прерывания по захвату.

Микроконтроллеры AVR: Таймер/счетчик T2 (8 бит)

• Два независимых выхода по совпадению 
• Таймер сброса при совпадении
• Изменяемый период ШИМ сигнала 
• Фазовый корректор ШИМ сигнала
• Тактовый генератор
• Возможность работы от независимого внешнего часового тактового генератора 32 кГц
• Три независимых источника прерывания
• Делитель частоты 10-бит
• Асинхронный режим

Регистры таймера/счетчика T2:

• TCNT2 — счетный регистр таймера/счетчика T2
• OCR2A — регистр сравнения A
• OCR2B — регистр сравнения B
• TIMSK2 — регистр маски прерываний для таймера/счетчика T2
• TIFR2 — регистр флагов прерываний для таймера/счетчика T2
• TCCR2A — регистр управления A
• TCCR2B — регистр управления B
• ASSR — регистр асинхронного режима 
• GTCCR — главный регистр всех таймеров/счетчиков

Источником тактового сигнала для таймера/счетчика T2 может быть тактовый сигнал используемый для всего микроконтроллера с использованием предделителя. Если не выбран коэффициент деления, то таймер/счетчик останавливается. 

Регистр TCCR2B:

• 000 — таймер остановлен
• 001 — CLK
• 010 — CLK/8
• 011 — CLK/32
• 100 — CLK/64
• 101 — CLK/128
• 110 — CLK/256
• 111 — CLK/1024

Регистр ASSR:

Бит EXCLK (6) регистра ASSR разрешает использование внешнего тактового сигнала от кварцевого резонатора 32 кГц при записи в него 1.

Бит  AS2 (5) регистра ASSR управляет способом тактирования (1 — от внешнего резонатора 32 кГц, подключенного к TOSC1 (9 ножка) / 0 — от внутреннего генератора CLK)/

Бит TCN2UB (4) регистра ASSR показывает доступен ли для записи регистр TCNT2 (1-недоступен / 0 — доступен).

Бит OCR2AUB (3) регистра ASSR показывает доступен ли для записи регистр OCR2A (1-недоступен / 0 — доступен).

Бит OCR2BUB (2) регистра ASSR показывает доступен ли для записи регистр OCR2B (1-недоступен / 0 — доступен).

Бит TCR2AUB (1) регистра ASSR показывает доступен ли для записи регистр TCCR2A (1-недоступен / 0 — доступен).

Регистр GTCCR:

Бит PSRASY (1) регистра GTCCR сбрасывает предделитель таймера/счетчика T2 если установить в 1, после этого бит сбрасывается в 0  автоматически.

Бит PSRASYNC (0) регистра GTCCR сбрасывает предделитель таймера/счетчика T0 и T1 если установить в 1, после этого бит сбрасывается в 0  автоматически.

Бит TSM (0) регистра GTCCR запрещает автоматический сброс битов PSRASY и PSRASYNC регистра GTCCR.

AVR. Учебный курс | Электроника для всех

Про шину IIC я писал уже неоднократно. Вначале было описание протокола, потом пример работы в лоб, а недавно камрад Ultrin выложил пример работы с i²c на базе блока USI. Да и в интернете полно статей по использованию этой шины в своих целях. Одно плохо — все они какие то однобокие. В подавляющем большинстве случаев используется конфигурация «Контроллер-Master & EEPROM-Slave». Да еще и на программном мастере. И ни разу я не встречал материала, чтобы кто то сделал Контроллер-Slave или описал многомастерную систему, когда несколько контроллеров сидят на шине и решают арбитражем конфликты передачи. Пустоту пора заполнять, решил я и завязал узелок на память… Да только веревочку пролюбил 🙂

Обещаного три года ждут, вот я таки пересилил лень, выкроил время и сообразил полноценную библиотеку для работы с аппаратным модулем TWI, встроенным во все контроллеры серии MegaAVR. Давно грозился.

Кошмар на крыльях ночи
Во-первых, я сразу же отказался от концепции тупого последовательного кода. Когда у нас есть некоторая функция SendByte(Address,Byte) которая шлет данные по шине, а потом возвращает 1 или 0 в зависимости от успешности или неуспешности операции. Метод прост, дубов, но медленный. Т.е. пока мы байт не пошлем мы не узнаем ушло ли оно, а значит будем вынуждены тупить и ждать. Да, шина i2c может быть очень быстрой. До 100кбит ЕМНИП, но даже это время, а я все же за высокоскоростное выполнение кода, без тормозных выдержек. Наш выбор — диспетчеризация и работа на прерываниях.

Суть в том, что мы подготавливаем данные которые нужно отослать. Дальше запускаем аппаратуру передачи и возвращаемся к своим делам. А зверский конечный автомат, что висит на прерывании TWI передатчика сам передает данные, отвлекая основную программу только тогда, когда нужен какой-либо экшн (например сунуть очередной байт в буфер передачи). Когда же все будет передано, то он генерит событие, которое оповещает головную программу, что мол задание выполнено.
Как? Ну это уже от конкретной реализации событий программы зависит. Может флажок выставить или байт состояния конечного автомата подправить, а может и задачу на конвейер диспетчера набросить или Event в почтовый ящик задачи скинуть. Если юзается RTOS.
(далее…)

Read More »