Таймеры, прерывания и volatile

Как считает таймер

Счётчик TCNTn увеличивается на единицу на каждом такте таймера. Такт таймера — это системная частота, поделённая предделителем N. Для Timer0 его выбирают биты CS02…CS00 регистра TCCR0B (раздел 15.9.2):

В режиме CTC (Clear Timer on Compare Match, WGM02:0 = 2) счётчик сравнивается с регистром OCR0A и при совпадении сбрасывается в ноль (раздел 15.7.2). Одновременно поднимается флаг OCF0A, и если прерывание разрешено — вызывается обработчик. Период прерываний:

Формула периода выведена нами из формулы частоты выхода в разделе 15.7.2, где переключение вывода на каждом совпадении даёт f = f_clk / (2 · N · (1 + OCR0A)).

Прерывание: что нужно разрешить

Чтобы прерывание сработало, нужны два разрешения (раздел 7.7): свой бит источника — для совпадения Timer0 это OCIE0A в регистре TIMSK0 — и общий бит I в регистре SREG, который ставит функция sei(). При входе в обработчик аппаратура сбрасывает бит I, поэтому обработчики не прерывают друг друга, а команда RETI в конце обработчика ставит его снова. Реакция на прерывание — не меньше четырёх тактов, возврат — ещё четыре (раздел 7.7.1).

Обработчик в avr-libc объявляется макросом ISR с именем вектора из заголовка кристалла. Имена векторов ATmega328P повторяют таблицу 12-6 даташита с суффиксом _vect: TIMER0_COMPA_vect, TIMER1_COMPA_vect, USART_RX_vect, ADC_vect.

Пример: системный тик 1 мс на Timer0

Посчитаем: при 16 МГц и делителе 64 такт таймера — 250 кГц, значит, на миллисекунду приходится 250 тактов, и OCR0A = 250 − 1 = 249. Значение укладывается в 8 бит.

#define F_CPU 16000000UL
#include <avr/interrupt.h>
#include <avr/io.h>
#include <stdint.h>
#include <util/atomic.h>

static volatile uint32_t ms_ticks;  /* changed in the ISR: must be volatile */

ISR(TIMER0_COMPA_vect)
{
    ms_ticks++;                     /* called every 1 ms */
}

static uint32_t millis_now(void)
{
    uint32_t t;
    ATOMIC_BLOCK(ATOMIC_RESTORESTATE) {
        t = ms_ticks;               /* 4 bytes read with interrupts off */
    }
    return t;
}

int main(void)
{
    DDRB |= _BV(DDB5);              /* LED on PB5 */

    TCCR0A = _BV(WGM01);            /* CTC mode, TOP = OCR0A */
    OCR0A = 249;                    /* 16 MHz / 64 / 250 = 1 kHz */
    TIMSK0 = _BV(OCIE0A);           /* compare match A interrupt */
    TCCR0B = _BV(CS01) | _BV(CS00); /* clk/64, the timer starts */
    sei();                          /* global interrupt enable */

    uint32_t last = 0;
    for (;;) {
        uint32_t now = millis_now();
        if (now - last >= 500) {    /* every 500 ms */
            last += 500;
            PINB = _BV(PINB5);      /* toggle the LED */
        }
        /* free time for other work */
    }
}

Две детали этого кода важнее самого таймера.

volatile. Переменная ms_ticks меняется в обработчике, о котором компилятор при разборе цикла main ничего не знает. Без volatile оптимизатор вправе прочитать её один раз и больше не обращаться к памяти — этот случай разобран в FAQ avr-libc. Подробнее — термин volatile.

Атомарность. Процессор AVR 8-битный, и 32-битную переменную он читает четырьмя командами. Если прерывание случится между ними, получится смесь старого и нового значения. Макрос ATOMIC_BLOCK(ATOMIC_RESTORESTATE) из util/atomic.h запрещает прерывания на время чтения и затем возвращает бит I в прежнее состояние. Вычитание now - last в беззнаковых числах правильно работает и при переполнении счётчика. Об этих проблемах — статья «Прерывания и конкурентный доступ».

Пример: Timer1 и период в секунду

На 8-битном таймере длинный период не получить: даже при делителе 1024 и OCR0A = 255 это 1024 · 256 / 16 МГц ≈ 16,4 мс. У Timer1 счётчик 16-битный. Его режим CTC с вершиной OCR1A — режим 4, бит WGM12 в регистре TCCR1B (разделы 16.9.2 и 16.11.2); делитель выбирают биты CS12…CS10 с теми же значениями, что у Timer0.

При делителе 256 такт таймера — 62,5 кГц, и секунда — это 62 500 тактов, OCR1A = 62 499:

#include <avr/interrupt.h>
#include <avr/io.h>

ISR(TIMER1_COMPA_vect)
{
    PINB = _BV(PINB5);              /* toggle the LED once a second */
}

int main(void)
{
    DDRB |= _BV(DDB5);

    TCCR1A = 0;                     /* no output compare pins, WGM11:10 = 0 */
    OCR1A = 62499;                  /* 16 MHz / 256 / 62500 = 1 Hz */
    TIMSK1 = _BV(OCIE1A);
    TCCR1B = _BV(WGM12) | _BV(CS12);/* mode 4 (CTC), clk/256 */
    sei();

    for (;;) {
    }
}

Запись 16-битного OCR1A компилятор разбивает на две 8-битные в правильном порядке — сначала старший байт во временный регистр, потом младший (раздел 16.3). Но если 16-битный регистр таймера пишут и в основной программе, и в обработчике, запись тоже надо защищать от прерываний.

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

Правила для обработчиков

• Обработчик должен быть коротким: пока он выполняется, остальные прерывания ждут.
• Никаких _delay_ms и долгих циклов внутри обработчика.
• Всё, что обработчик меняет, а main читает, — volatile; всё, что длиннее байта, — читать в ATOMIC_BLOCK.
• Не разрешайте прерывание без обработчика: по умолчанию avr-libc отправляет такие прерывания на адрес 0, и программа начнётся заново с адреса 0 — без аппаратного сброса, с прежними значениями регистров ввода-вывода.

Задание

1. Нужно прерывание каждые 0,5 с на Timer1 при 16 МГц. Подберите делитель из ряда 1, 8, 64, 256, 1024 и значение OCR1A.
2. Почему в первом примере ms_ticks нельзя читать в main просто как uint32_t now = ms_ticks;, даже если переменная объявлена volatile?

Что дальше

В уроке 6 таймеры начнут сами управлять выводами и выдавать ШИМ. Все режимы таймеров, таблицы WGM и захват — в статье «Таймеры AVR»; регистры с битами — на страницах Timer0 и Timer1 атласа. Коротко о понятиях урока — термины «Прерывание», «Предделитель», «Режим CTC» и «Таблица векторов прерываний».