Прерывания Arduino: attachInterrupt, правила ISR и антидребезг

Прерывание Arduino заставляет процессор бросить текущую работу в тот момент, когда на пине происходит ожидаемое изменение (или срабатывает событие таймера), и выполнить твою специальную функцию. Проще говоря, вместо того чтобы постоянно спрашивать внутри loop() «кнопка нажата?», ты говоришь Arduino: «сообщи, когда её нажмут». Для этого есть функция attachInterrupt(); на Arduino Uno прерывания поддерживают пины D2 и D3, а на ESP32 и Raspberry Pi Pico прерывание может вызвать почти любой GPIO.

Прерывания незаменимы, когда нужно без пропусков считать очень быстрые импульсы (энкодеры, датчики скорости, датчики расхода воды), поймать короткое событие посреди долгой задачи или разбудить плату из сна. В этом руководстве пошагово разберём, как прерывание работает в железе, какие пины доступны на каждой плате, чем отличаются режимы RISING, FALLING и CHANGE, по каким правилам писать обработчик прерывания (ISR), как устранить дребезг кнопки, а также примеры с кнопкой, энкодером и счётчиком оборотов. В конце ты узнаешь про IRAM_ATTR на ESP32 и про irq в MicroPython на Pico.

Что такое прерывание и как оно работает?

Представь дверной звонок: без него пришлось бы каждую минуту подходить к двери и проверять, не стоит ли кто-нибудь за ней. Это называется опрос (polling), и чтение пина через digitalRead() внутри loop() — именно опрос. Звонок — это прерывание: он звенит, пока ты занят другим делом, ты отвлекаешься, открываешь дверь и возвращаешься к своему занятию. Микроконтроллер работает так же. Когда на пине происходит выбранное изменение, железо устанавливает флаг прерывания; процессор завершает текущую инструкцию, сохраняет регистры, через вектор прерываний переходит к твоему ISR (Interrupt Service Routine, обработчик прерывания), а после его завершения продолжает выполнять loop() ровно с того места, где выполнение было прервано. На Uno такое переключение занимает всего несколько микросекунд.

Какие пины поддерживают прерывания? Arduino, ESP32 и Pico

В коде не передавай номер пина напрямую: преобразуй его в номер прерывания через digitalPinToInterrupt(пин), потому что номер прерывания меняется от платы к плате: на Uno D2 — это прерывание 0, а D3 — прерывание 1, тогда как на Leonardo прерывание 0 — это D3, а прерывание 1 — D2. Если на Uno нужно больше двух прерываний, почти на всех пинах работают прерывания по изменению состояния пина (PCINT); правда, они сообщают только, что «что-то изменилось», а все пины одного порта делят один ISR. Библиотеки PinChangeInterrupt и EnableInterrupt упрощают работу с ними. Полную карту пинов своей платы ищи в утилите распиновки, а функции пинов Uno — в статье Распиновка Arduino Uno.

Как пользоваться attachInterrupt и режимы прерываний

Синтаксис: attachInterrupt(digitalPinToInterrupt(пин), ISR, режим). Второй параметр — имя функции, которая выполняется при срабатывании прерывания; она не принимает параметров и ничего не возвращает (void). Третий параметр задаёт, какое событие вызывает прерывание. Чтобы отключить прерывание, используй detachInterrupt(digitalPinToInterrupt(пин)), чтобы ненадолго приостановить все прерывания — noInterrupts(), а чтобы снова их включить — interrupts().

Выбирай режим под свою схему. Если кнопка подключена с INPUT_PULLUP, на пине обычно HIGH, а при нажатии уровень падает до LOW, поэтому нажатие ловит FALLING. Режим LOW требует осторожности: пока на пине LOW, ISR выполняется снова и снова, и loop() почти не продвигается. Поэтому его обычно используют только для пробуждения платы из сна; чтобы разбудить Uno из самого глубокого режима сна (power-down), даташит рекомендует прерывание по уровню LOW или прерывание по изменению состояния пина. На ESP32 константы LOW и HIGH работают как режимы прерывания не так, как можно ожидать: LOW вообще не включает прерывание, а HIGH ведёт себя как нарастающий фронт. Для прерываний по уровню там пишут ONLOW и ONHIGH.

Первый пример: считаем нажатия кнопки с помощью прерывания

1. Подключи одну ножку кнопки к D2, а другую — к GND. Внешний резистор не нужен: используем встроенную подтяжку.
2. Загрузи код ниже в плату и открой монитор порта на скорости 9600 бод.
3. Нажми кнопку несколько раз и смотри, как растёт счётчик. Несмотря на delay(500) внутри loop(), ни одно нажатие не теряется.
4. Не удивляйся, если число иногда прыгает сразу на 2 или 3: это дребезг контактов, и скоро мы его устраним.

1const byte BUTTON_PIN = 2;                // kesme pini D2 (INT0) / interrupt pin D2 (INT0)
2volatile unsigned int pressCount = 0;     // ISR ile paylaşılan sayaç / counter shared with the ISR
3
4void onPress() {                          // ISR: kısa ve hızlı / ISR: short and fast
5  pressCount++;
6}
7
8void setup() {
9  Serial.begin(9600);
10  pinMode(BUTTON_PIN, INPUT_PULLUP);      // dahili pull-up, buton GND'ye / internal pull-up, button to GND
11  attachInterrupt(digitalPinToInterrupt(BUTTON_PIN), onPress, FALLING);
12}
13
14void loop() {
15  noInterrupts();                         // 2 baytlık değeri güvenle kopyala / copy the 2-byte value safely
16  unsigned int count = pressCount;
17  interrupts();
18
19  Serial.print(F("Basis / Presses: "));
20  Serial.println(count);
21  delay(500);                             // loop yavaş olsa da basış kaçmaz / presses are not missed even if loop is slow
22}

В этом коде три важных момента. Во-первых, onPress() лишь прибавляет к счётчику единицу и сразу завершается: задача ISR — отметить событие, а не выполнять работу. Во-вторых, счётчик объявлен как volatile, поэтому компилятор не держит его в регистре и не читает устаревшее значение, а каждый раз берёт свежее значение из памяти. В-третьих, loop() на мгновение отключает прерывания, пока читает счётчик. На Uno unsigned int занимает 2 байта, и 8-битный процессор читает его в два шага. Когда счётчик переходит с 255 на 256, то есть с 0x00FF на 0x0100, loop() сначала читает младший байт (0xFF); если именно в этот момент срабатывает прерывание и увеличивает счётчик, затем читается уже новый старший байт (0x01), и в итоге получается 0x01FF, то есть 511. Такая ошибка проявляется очень редко, поэтому её ещё и трудно отловить. На платах AVR такую же защиту даёт макрос ATOMIC_BLOCK(ATOMIC_RESTORESTATE) из util/atomic.h; у однобайтовых переменных вроде bool и byte этой проблемы нет.

Правила ISR: коротко, volatile, никакого delay

• Делай ISR коротким и быстрым: пока он выполняется, остальные прерывания ждут. На Uno счётчик millis() и последовательный порт тоже работают на прерываниях, поэтому длинный ISR сбивает тайминг и может привести к потере входящих данных по последовательному порту. Идеальный ISR укладывается в несколько микросекунд.
• Не используй delay(): delay() отсчитывает время по счётчикам, которые обновляет прерывание Timer0; внутри ISR прерывания отключены, поэтому delay() не работает. millis() прочитать можно, но во время ISR значение не растёт, а micros() через 1–2 мс начинает возвращать неверные значения. Если очень короткая пауза действительно нужна, работает delayMicroseconds().
• Не используй Serial.print(): отправка данных по последовательному порту тоже зависит от прерываний; она удлиняет ISR и блокируется, если буфер заполнится. Оставь вывод для loop().
• Делай общие переменные volatile: каждая переменная, которая используется и в ISR, и в loop(), должна быть объявлена как volatile.
• Читай многобайтовые переменные атомарно: в loop() копируй переменные int, long, float и unsigned long между noInterrupts() и interrupts().
• Без параметров и возвращаемого значения: ISR должен быть void и не принимать параметров; данные передаются через глобальные переменные.
• Не помещай тяжёлую работу в ISR: вывод на I2C-дисплей, запись на SD-карту или вызов библиотек, которым самим нужны прерывания (например, Wire), внутри ISR приводят к зависанию.

Чтение кнопки через прерывание и антидребезг

При нажатии механической кнопки металлические контакты замыкаются не сразу: примерно от 0,1 до 10 миллисекунд они несколько раз размыкаются и замыкаются. loop() может работать слишком медленно, чтобы это заметить, но прерывание ловит каждый фронт, поэтому одно нажатие может дать 3–5 прерываний. Более того, дребезг бывает не только при нажатии, но и при отпускании, поэтому код, который использует только FALLING с блокировкой по времени, может посчитать нажатие дважды, если долго удерживать кнопку, а потом отпустить. Код ниже использует режим CHANGE и засчитывает нажатие, только когда на пине LOW и линия перед этим была спокойной не менее 50 мс. Так отсеивается дребезг и при нажатии, и при отпускании.

1const byte BUTTON_PIN = 2;                // kesme pini / interrupt pin
2const byte LED_PIN = 13;                  // dahili LED / onboard LED
3const unsigned long QUIET_MS = 50;        // gereken sessizlik süresi / required quiet time
4
5volatile bool ledState = false;           // ISR ile paylaşılır / shared with the ISR
6
7void onButtonChange() {                   // iki kenarda da çalışır / runs on both edges
8  static unsigned long lastEdgeMs = 0;
9  unsigned long now = millis();           // ISR'de okunur ama artmaz / readable in an ISR but does not advance
10  bool pressed = (digitalRead(BUTTON_PIN) == LOW);
11
12  if (pressed && now - lastEdgeMs > QUIET_MS) {   // hat sessizdi: gerçek basış / line was quiet: real press
13    ledState = !ledState;
14  }
15  lastEdgeMs = now;                       // her kenar süreyi yeniden başlatır / every edge restarts the timer
16}
17
18void setup() {
19  pinMode(LED_PIN, OUTPUT);
20  pinMode(BUTTON_PIN, INPUT_PULLUP);
21  attachInterrupt(digitalPinToInterrupt(BUTTON_PIN), onButtonChange, CHANGE);
22}
23
24void loop() {
25  digitalWrite(LED_PIN, ledState ? HIGH : LOW);   // bool tek bayt, okuması atomik / bool is one byte, atomic read
26  // burada uzun işler olsa da basış kaçmaz / long tasks here will not make you miss a press
27}

Кроме программного способа, дребезг можно подавить и аппаратно: если поставить конденсатор 100 nF параллельно кнопке и подтягивающий резистор 10 kΩ на пин, постоянная времени составит τ = R × C = 10 kΩ × 100 nF = 1 мс, и короткие всплески дребезга сгладятся; триггер Шмитта на входах Uno тоже очищает фронт. Другие значения можно рассчитать в утилите постоянной времени RC. Честно говоря, для кнопок, которые нажимают рукой, прерывание часто вообще не нужно: если loop() быстрый, хватит опроса. Про подтяжку pull-up, pull-down и антидребезг на millis() читай в статье Как подключить кнопку к Arduino. Прерывания оставь для быстрых и коротких сигналов.

Чтение поворотного энкодера через прерывание

При вращении поворотного энкодера (например, KY-040) на двух пинах, CLK и DT, появляются прямоугольные импульсы, сдвинутые друг относительно друга. При быстром вращении импульсы становятся короче миллисекунды, и опрос легко пропускает шаги. Самый простой способ — подключить CLK к пину прерывания и в момент спада CLK проверить уровень DT: если на DT HIGH, вращение идёт в одну сторону, если LOW — в другую. Эта версия считает один шаг на щелчок; если направление получается обратным, поменяй местами строки ++ и --. Дешёвые энкодеры тоже дребезжат, поэтому конденсатор 10–100 nF между CLK и GND и между DT и GND заметно улучшает результат. Версию, где оба пина подключены к прерываниям, а таблица состояний не даёт пропустить ни одного шага, смотри в руководстве по поворотному энкодеру (KY-040).

1const byte PIN_CLK = 2;                   // kesme pini / interrupt pin
2const byte PIN_DT = 4;                    // normal dijital giriş / regular digital input
3
4volatile long position = 0;               // 4 baytlık konum / 4-byte position
5
6void onClkFall() {
7  if (digitalRead(PIN_DT) == HIGH) {      // yön DT seviyesinden / direction from the DT level
8    position++;
9  } else {
10    position--;
11  }
12}
13
14void setup() {
15  Serial.begin(115200);
16  pinMode(PIN_CLK, INPUT_PULLUP);
17  pinMode(PIN_DT, INPUT_PULLUP);
18  attachInterrupt(digitalPinToInterrupt(PIN_CLK), onClkFall, FALLING);
19}
20
21void loop() {
22  static long lastPos = 0;
23
24  noInterrupts();                         // atomik kopya / atomic copy
25  long pos = position;
26  interrupts();
27
28  if (pos != lastPos) {
29    Serial.println(pos);
30    lastPos = pos;
31  }
32}

Подсчёт оборотов: измеряем скорость мотора в об/мин

Измерение скорости вращения мотора или колеса — классическое применение прерываний. В качестве датчика берут либо щелевой оптический датчик скорости на LM393 с 20-щелевым диском энкодера, либо датчик Холла, например A3144, и магнит, приклеенный к валу. Каждая щель или каждый проход магнита даёт один импульс. По числу импульсов за одну секунду скорость считается так: об/мин = импульсы в секунду × 60 / импульсы на оборот. Например, если 20-щелевой диск даёт 100 импульсов в секунду, мотор вращается со скоростью 100 × 60 / 20 = 300 об/мин.

1const byte SENSOR_PIN = 3;                // kesme pini D3 (INT1) / interrupt pin D3 (INT1)
2const byte PULSES_PER_REV = 20;           // diskteki yarık sayısı / slots on the encoder disc
3
4volatile unsigned long pulseCount = 0;
5
6void onPulse() {
7  pulseCount++;
8}
9
10void setup() {
11  Serial.begin(9600);
12  pinMode(SENSOR_PIN, INPUT_PULLUP);
13  attachInterrupt(digitalPinToInterrupt(SENSOR_PIN), onPulse, FALLING);
14}
15
16void loop() {
17  static unsigned long lastMs = 0;
18
19  if (millis() - lastMs >= 1000) {        // her saniye hesapla / compute once per second
20    lastMs += 1000;
21
22    noInterrupts();                       // kopyala ve sıfırla / copy and reset
23    unsigned long pulses = pulseCount;
24    pulseCount = 0;
25    interrupts();
26
27    float rpm = pulses * 60.0 / PULSES_PER_REV;
28    Serial.print(F("RPM: "));
29    Serial.println(rpm, 1);
30  }
31}

Здесь loop() каждую секунду копирует и обнуляет счётчик; оба действия выполняются внутри одного блока noInterrupts(), чтобы ни один импульс не потерялся, если прерывание придёт между ними. С 20-щелевым диском разрешение составляет 3 об/мин. Для более точных результатов на низких скоростях вместо подсчёта импульсов измеряй в ISR время между двумя импульсами с помощью micros() и используй формулу об/мин = 60 000 000 / (период_µs × импульсы на оборот). Тот же метод подходит для датчика расхода воды YF-S201, для измерения скорости датчиком Холла и для оборотов колеса DC-мотора с редуктором.

Коротко о прерываниях по таймеру

Прерывания приходят не только от пинов. Таймеры внутри микроконтроллера тоже могут генерировать прерывания через равные промежутки, и тогда функция выполняется ровно каждую 1 мс или каждые 500 мс, чем бы ни был занят loop(). У Uno три таймера, и некоторые из них уже заняты собственными функциями Arduino:

На Uno проще всего воспользоваться библиотекой TimerOne: Timer1.initialize(500000) задаёт период в микросекундах, а Timer1.attachInterrupt(функция) подключает ISR, который выполняется каждые 500 мс. Поскольку библиотека использует Timer1, она конфликтует с библиотекой Servo и с analogWrite() на пинах 9 и 10. На ESP32 с ядром Arduino 3.x прерывание по таймеру настраивается через timerBegin(1000000), timerAttachInterrupt() и timerAlarm(); функции timerAlarmWrite() и timerAlarmEnable() из 2.x удалены, поэтому старые примеры не компилируются и выдают ошибку «was not declared in this scope» (не объявлено в этой области видимости). На Pico в MicroPython Timer(period=500, mode=Timer.PERIODIC, callback=функция) настраивает периодическое прерывание одной строкой. О том, как таймеры связаны с ШИМ, читай в статье Что такое PWM?

Прерывания на ESP32: IRAM_ATTR и portMUX

На ESP32 не нужно искать особый пин: прерывание может вызвать любой GPIO. Только у GPIO 34–39 нет встроенной подтяжки, поэтому кнопке на этих пинах нужен внешний подтягивающий резистор 10 kΩ; кроме того, в списке ошибок (errata) Espressif отмечено, что GPIO 36 и 39 могут давать ложные прерывания, пока работает АЦП. Главное отличие ESP32 — атрибут IRAM_ATTR перед ISR. Он размещает функцию не во флеш-памяти, а в быстром внутреннем ОЗУ (IRAM). Во время записи во флеш (Preferences, SPIFFS, OTA) кэш отключается; в зависимости от конфигурации прерывание, которое в этот момент обращается к коду во флеш-памяти, может перезагрузить плату с ошибкой «Guru Meditation Error: Core 1 panic'ed (Cache disabled but cached memory region accessed)» (кэш отключён, а код обращается к кэшируемой области памяти). ESP8266 ещё строже: ISR без IRAM_ATTR останавливает плату с сообщением «ISR not in IRAM!» сразу при вызове attachInterrupt.

1const int BUTTON_PIN = 27;                // her GPIO kesme verebilir / any GPIO can interrupt
2const int LED_PIN = 2;                    // çoğu DevKit'te dahili LED / onboard LED on most DevKits
3const uint32_t QUIET_MS = 50;             // gereken sessizlik süresi / required quiet time
4
5volatile uint32_t pressCount = 0;
6portMUX_TYPE mux = portMUX_INITIALIZER_UNLOCKED;   // paylaşılan veri kilidi / lock for shared data
7
8void IRAM_ATTR onButtonChange() {         // ISR IRAM'de çalışır / ISR runs from IRAM
9  static uint32_t lastEdgeMs = 0;
10  uint32_t now = millis();
11  bool pressed = (digitalRead(BUTTON_PIN) == LOW);
12
13  if (pressed && now - lastEdgeMs > QUIET_MS) {
14    portENTER_CRITICAL_ISR(&mux);
15    pressCount++;
16    portEXIT_CRITICAL_ISR(&mux);
17  }
18  lastEdgeMs = now;
19}
20
21void setup() {
22  Serial.begin(115200);
23  pinMode(LED_PIN, OUTPUT);
24  pinMode(BUTTON_PIN, INPUT_PULLUP);
25  attachInterrupt(digitalPinToInterrupt(BUTTON_PIN), onButtonChange, CHANGE);
26}
27
28void loop() {
29  static uint32_t lastCount = 0;
30
31  portENTER_CRITICAL(&mux);               // loop tarafında kilit / lock on the loop side
32  uint32_t count = pressCount;
33  portEXIT_CRITICAL(&mux);
34
35  if (count != lastCount) {
36    lastCount = count;
37    digitalWrite(LED_PIN, (count % 2) ? HIGH : LOW);   // her basışta LED değişir / LED toggles on every press
38    Serial.printf("Basis / Press: %lu\n", (unsigned long)count);
39  }
40}

Поскольку на ESP32 работает FreeRTOS и у неё два ядра, общие переменные защищают не через noInterrupts(), как на Uno, а блокировкой portMUX_TYPE: внутри ISR используй portENTER_CRITICAL_ISR(), а в loop() — portENTER_CRITICAL(). Чтение 32-битной переменной на ESP32 и так выполняется за один шаг, но блокировка обязательна, например, когда нужно прочитать и обнулить значение или обновить сразу несколько переменных. Если нужно подключить одну функцию к нескольким пинам, attachInterruptArg() позволяет передать в ISR параметр, например номер пина. Основы ESP32 описаны в статье Что такое ESP32?, а задачи и ядра — в статье FreeRTOS и два ядра ESP32.

Прерывания на Raspberry Pi Pico: irq в MicroPython

На Raspberry Pi Pico прерывание может вызвать любой пин от GP0 до GP28. В MicroPython оно настраивается методом irq() объекта пина: в trigger передаётся Pin.IRQ_FALLING, Pin.IRQ_RISING или их комбинация, а handler — это функция, которая выполняется при срабатывании прерывания; в качестве параметра она получает пин, вызвавший прерывание. В Python нет volatile: переменные, которые меняются в ISR, достаточно объявить как global. Для измерения времени используй time.ticks_ms() и устойчивую к переполнению time.ticks_diff(). Код ниже переносит на Pico логику «тишины на линии» из примера для Arduino:

1from machine import Pin
2import time
3
4led = Pin("LED", Pin.OUT)                 # dahili LED (Pico ve Pico W) / onboard LED (Pico and Pico W)
5button = Pin(14, Pin.IN, Pin.PULL_UP)     # buton GP14 ile GND arasında / button between GP14 and GND
6
7QUIET_MS = 50                             # gereken sessizlik süresi / required quiet time
8presses = 0
9last_edge = time.ticks_ms()
10
11def on_change(pin):                       # handler tetikleyen pini alır / handler receives the pin
12    global presses, last_edge
13    now = time.ticks_ms()
14    if pin.value() == 0 and time.ticks_diff(now, last_edge) > QUIET_MS:
15        presses += 1
16        led.toggle()
17    last_edge = now
18
19button.irq(trigger=Pin.IRQ_FALLING | Pin.IRQ_RISING, handler=on_change)
20
21while True:
22    print("Basis / Presses:", presses)    # ana döngü uyurken bile basışlar sayılır / presses are counted while the loop sleeps
23    time.sleep(1)

На Pico irq по умолчанию работает как мягкое (soft) прерывание: MicroPython ставит функцию в очередь и выполняет её как можно скорее, поэтому print или создание списка внутри неё не вызывают проблем, но задержка немного растёт. Если передать hard=True, задержка падает до микросекунд; зато внутри ISR нельзя выделять память, так что новый список, строка и даже вычисление с float могут вызвать ошибку «MemoryError». Если Pico программируется из Arduino IDE (ядро Earle Philhower), attachInterrupt() одинаково работает на любом GPIO. Про установку читай в статье Что такое Raspberry Pi Pico?, а про основные команды — в статье Основы MicroPython.

Идеи проектов с прерываниями

• Измеритель реакции: с помощью micros() в ISR измеряй с точностью лучше миллисекунды, сколько времени проходит от загорания светодиода до нажатия кнопки.
• Велоспидометр: закрепи магнит на колесе, а датчик Холла — на раме; по времени одного оборота рассчитай скорость и пройденное расстояние.
• Счётчик воды: считай импульсы датчика расхода YF-S201 и показывай израсходованные литры.
• Робот-машинка, которая едет прямо: измерь скорость обоих моторов энкодерами колёс и выровняй её.
• Управление меню: листай экранное меню и меняй настройки поворотным энкодером.
• Сигнализация на батарейках: пусть выход PIR-датчика будит плату, пока она спит; для ESP32 смотри статью про глубокий сон.

Частые ошибки и их решения

Прерывания — мощный инструмент, который позволяет ловить каждое событие, даже когда loop() занят другой работой; нужно лишь помнить три правила: ISR должен быть коротким, общие переменные — volatile, а читать их в loop() нужно атомарно. В приложении BlueGrays есть счётчики нажатий кнопки, тест времени реакции, проекты с кнопкой на ESP32 и проект «Антидребезг кнопки на Pico: IRQ против программного опроса», и у каждого есть пошаговая схема подключения и код.