attachInterrupt изнутри: INT0, INT1 и свой ISR

Что делает attachInterrupt

// ArduinoCore-avr 1.8.8, cores/arduino/WInterrupts.c (ATmega328P branch, abridged)
static volatile voidFuncPtr intFunc[EXTERNAL_NUM_INTERRUPTS] = { nothing, nothing };

void attachInterrupt(uint8_t interruptNum, void (*userFunc)(void), int mode) {
  if (interruptNum < EXTERNAL_NUM_INTERRUPTS) {
    intFunc[interruptNum] = userFunc;
    switch (interruptNum) {
    case 0:
      EICRA = (EICRA & ~((1 << ISC00) | (1 << ISC01))) | (mode << ISC00);
      EIMSK |= (1 << INT0);
      break;
    case 1:
      EICRA = (EICRA & ~((1 << ISC10) | (1 << ISC11))) | (mode << ISC10);
      EIMSK |= (1 << INT1);
      break;
    }
  }
}

Первым аргументом идёт номер прерывания, а не вывода: digitalPinToInterrupt(2) = 0, digitalPinToInterrupt(3) = 1, для остальных выводов — NOT_AN_INTERRUPT (pins_arduino.h, строка 79). Режим ядро не переводит, а просто сдвигает в биты ISC: константы Arduino подобраны так, что совпадают с таблицей 13-2 даташита.

Отсюда курьёз: HIGH тоже равна 1, и attachInterrupt(0, f, HIGH) на AVR включит прерывание по любому изменению. Режим LOW опасен по-своему: прерывание по уровню срабатывает всё время, пока вывод в нуле (раздел 13), а после каждого выхода из обработчика процессор успевает выполнить ровно одну команду основной программы (раздел 7.7). Пока кнопка нажата, loop() почти стоит.

Чего attachInterrupt не делает — не трогает регистр флагов EIFR. По разделу 7.7 флаг прерывания, пришедшего, пока оно запрещено, запоминается до разрешения. До первого вызова это не опасно: после сброса EICRA = 0, это прерывание по низкому уровню (раздел 13.2.1), а в этом режиме флаг INTF0 всегда сброшен (раздел 13.2.3). Опасен повторный вызов: detachInterrupt сбрасывает только бит в EIMSK, режим фронта в EICRA остаётся, и фронт на выводе 2 — дребезг кнопки, наводка — ставит флаг. Следующий attachInterrupt разрешит прерывание, и обработчик выполнится сразу, хотя нового события не было. То же бывает после своей записи режима фронта в EICRA.

Как ядро вызывает вашу функцию

// ArduinoCore-avr 1.8.8, cores/arduino/WInterrupts.c, lines 335-338 and 372-373
#define IMPLEMENT_ISR(vect, interrupt) \
  ISR(vect) { \
    intFunc[interrupt](); \
  }

IMPLEMENT_ISR(INT0_vect, EXTERNAL_INT_0)
IMPLEMENT_ISR(INT1_vect, EXTERNAL_INT_1)

Настоящий обработчик прерывания — в ядре, а ваша функция вызывается из него по указателю. Компилятор не знает, какую функцию он вызовет, и по правилам avr-gcc считает, что она может испортить все call-used регистры — r18–r27, r30 и r31 (FAQ avr-libc). Прерванная программа этого не ожидает, поэтому обработчик ядра сохраняет все двенадцать в стеке, а заодно r0, r1 и SREG — регистр состояния аппаратура не сохраняет (раздел 7.7).

Оценка по таблице команд (раздел 37) и разделу 7.7.1, без тела вашей функции:

Около 85 тактов — 5,3 мкс при 16 МГц (расчёт наш по ABI avr-gcc, точное число зависит от компилятора и видно в листинге avr-objdump -d). Свой ISR() с коротким телом сохраняет только те регистры, которые использует, и обходится без косвенного вызова. Для кнопки разница не важна, для энкодера на 10 000 импульсов в секунду — это 5 % процессорного времени только на накладные расходы (расчёт наш: 10 000 · 5,3 мкс = 53 мс в секунду). Термин о времени реакции — «Задержка прерывания».

То же самое регистрами

volatile uint16_t edges;

ISR(INT0_vect)
{
  edges++;
}

void setup() {
  Serial.begin(115200);
  DDRD &= ~_BV(DDD2);                                          // pin 2 (PD2, INT0) input
  PORTD |= _BV(PORTD2);                                        // pull-up on
  EICRA = (EICRA & ~(_BV(ISC01) | _BV(ISC00))) | _BV(ISC01);   // falling edge
  EIFR = _BV(INTF0);                                           // drop an edge latched so far
  EIMSK |= _BV(INT0);                                          // enable INT0
}

void loop() {
  noInterrupts();                // 16-bit counter: read it in one piece
  uint16_t n = edges;
  interrupts();
  Serial.println(n);
  delay(500);
}

Порядок важен: флаг сбрасывают после записи режима фронта в EICRA — с этого момента фронты уже ставят флаг — и до разрешения в EIMSK. Сбрасывают его записью единицы (раздел 13.2.3), и именно присваиванием EIFR = _BV(INTF0), а не |=: FAQ avr-libc объясняет, что запись нулей в остальные биты флагов их не меняет, а чтение-изменение-запись сбросило бы заодно и другие установленные флаги. В этом скетче нельзя вызывать attachInterrupt: тогда в программу попадёт WInterrupts.c со своим ISR(INT0_vect), и компоновщик сообщит о повторном определении вектора.

Ещё две детали из даташита. Импульс короче периода такта процессора не гарантированно вызовет прерывание по фронту (раздел 13.2.1). И прерывание срабатывает даже тогда, когда вывод настроен на выход (раздел 13) — так можно вызвать обработчик программно.

Внутри обработчика

• millis() внутри обработчика не растёт: прерывания запрещены (раздел 7.7), и обработчик Timer0 ждёт своей очереди. delay() там работает неверно — подробности в уроке 5.
• Serial.print() в обработчике не зависнет: при запрещённых прерываниях HardwareSerial::write() сама опрашивает флаг UDRE0 (строки 255–266 HardwareSerial.cpp). Но обработчик будет ждать отправки каждого байта сверх буфера — на 9600 бит/с это около 1 мс на символ.
• Переменные, общие с loop(), объявляют volatile, а многобайтовые читают при запрещённых прерываниях, как в примере. Подробно о гонках — в статье «Прерывания и параллельность».

PCINT: прерывание на любом выводе

Кроме INT0 и INT1, у каждого вывода есть прерывание по изменению. Выводы собраны в три группы со своим вектором: PCINT0–7 (порт B, вектор PCINT0_vect), PCINT8–14 (порт C, PCINT1_vect) и PCINT16–23 (порт D, PCINT2_vect). Группу разрешают битом в PCICR, выводы внутри группы — маской PCMSK0–2 (разделы 13.2.4–13.2.8). В pins_arduino.h ядра есть макросы digitalPinToPCICR() и digitalPinToPCMSK(), но функции подключения и обработчиков PCINT ядро не даёт — только регистры. Прерывание PCINT срабатывает на любое изменение любого разрешённого вывода группы, и какой вывод изменился, обработчик выясняет сам, сравнивая PINx с прошлым значением.

Задание

1. Какие биты каких регистров выставит attachInterrupt(digitalPinToInterrupt(3), onEdge, RISING)?
2. Напишите регистровую настройку прерывания по изменению на выводе 8 Uno и пустой обработчик для него.
3. Энкодер выдаёт 20 000 импульсов в секунду на выводе 2, обработчик через attachInterrupt в режиме CHANGE. Сколько процентов времени процессора уйдёт только на накладные расходы вызова по оценке из урока?

ISR(PCINT0_vect)
{
  // compare PINB with the previous value to see which pin changed
}

void setup() {
  DDRB &= ~_BV(DDB0);         // pin 8 input
  PORTB |= _BV(PORTB0);       // pull-up
  PCMSK0 |= _BV(PCINT0);      // PB0 contributes to PCINT0_vect
  PCIFR = _BV(PCIF0);         // drop an old flag
  PCICR |= _BV(PCIE0);        // enable pin change group 0
}

Что дальше

В уроке 7 разберём Serial: два кольцевых буфера по 64 байта, прерывания приёма и передачи и почему на 57 600 бит/с ядро выбирает режим с большей ошибкой. Регистры внешних прерываний EICRA, EIMSK, EIFR, PCICR и PCMSK — на странице регистров EXINT ATmega328P, а список векторов с приоритетами — в термине «Таблица векторов прерываний». Как подавить дребезг кнопки, которая висит на прерывании, рассказывает термин «Дребезг контактов».