volatile и прерывания: почему переменная молчит

Поливалка в оранжерее считала обороты крыльчатки водосчётчика: геркон щёлкал на пине 2, attachInterrupt ловил каждый фронт, счётчик увеличивался — я видел это по вспышке светодиода из обработчика. А loop() раз в минуту печатал в монитор одно и то же: oboroty=0. За вечер я переписал скетч четырьмя способами: переносил переменную выше, менял тип, объявлял глобальной, дёргал её в setup() — а виновато было слово, которое я дважды пропустил, переписывая пример из туториала: volatile.

Механика подвоха такая. Arduino IDE компилирует скетчи с оптимизацией -Os — оптимизацией по размеру, и у неё есть полное право держать часто читаемую переменную не в памяти, а в регистре процессора. Компилятор не знает про прерывания: ваш обработчик для него — функция, которую никто не вызывает, значит, по его данным никто не ходит, значит, перечитывать память в loop() незачем. Прерывание меняет переменную за спиной компилятора — регистр честно держит старую копию, и loop() месяцами смотрит на ноль.

В этом уроке два этажа одной беды. Первый — volatile: слово, которое запрещает компилятору кешировать. Второй — атомарность, которую volatile не даёт: на Uno int занимает два байта, и обработчик может вклиниться посреди чтения. Разберём таблицу «без volatile — с volatile — с критической секцией», соберём счётчик в симуляторе и добьём граблю «работало до подключения библиотеки». Базу про прерывания здесь не повторяю — она в уроке про attachInterrupt.

Язык C++ разрешает компилятору всё, что не меняет видимого поведения программы. Для обычного кода это благодеяние: переменная, которую loop() читает десятки раз за проход, ложится в регистр, и каждая проверка стоит ноль обращений к памяти. Проблема всплывает ровно в момент, когда значение меняет не ваш код, а железо через обработчик: у регистра нет механизма узнать о визите ISR.

volatile перед типом — приказ, а не рекомендация: читать из памяти при каждом обращении и не перемещать значение. Он не делает переменную атомарной, не защищает от гонок и не ускоряет код — он делает ровно одно: лишает оптимизатор права на кеш. Именно поэтому его пропускают: в мигалке с кнопкой без него правда работает — до первой правки кода, после которой компилятор раскладывает регистры по-новому.

Тот же шаблон держит счёт тиков энкодера: в уроке про энкодер на прерываниях я считал щелчки с этим же словом в первой строке. Разница лишь в направлении счёта и дребезге, а контракт между ISR и loop() один и тот же.

Классическая демонстрация на настоящей плате — цикл ожидания: while (flag == 0) с флагом из обработчика. Без volatile компилятор выносит чтение за пределы цикла: условие сравнивает регистровую копию один раз, и скетч зависает навсегда, хотя обработчик щёлкает на глазах. С volatile цикл честно перечитывает память и отпускает. Именно поэтому ожидание события я всегда вписываю в неблокирующий loop() через проверку флага, а не в мёртвый while: первый ещё и кнопку читает, второй — тупик из одного действия.

ATmega328P — восьмибитное ядро. int занимает два байта, и чтение — две машинные команды: сначала один байт, потом второй, в каком порядке неважно, важно, что их два. Между этими командами обработчику ничего не стоит вклиниться — прерывание срабатывает между любыми командами основного кода.

Честный пример, на котором я это увидел: счётчик дорос до 255 и получает плюс один. В памяти было 0x00FF, становится 0x0100. Loop успел прочитать старший байт до ISR, младший — после, и собрал 0x01FF: пятьсот одиннадцать оборотов из двухсот пятидесяти шести. В другой раз наоборот — 0x0000, счётчик откатился в ноль. Значение выходит не «чуть неточным», а чужим: два байта из разных эпох, склеенные в одно число.

Лечение — критическая секция: noInterrupts() перед чтением, interrupts() сразу после. На время пары команд прерывания выключены: пара микросекунд для ISR кнопки — задержка, которую никто никогда не заметит. Правило размера: секция — несколько команд, ни одного вызова Serial, ни одного delay. Сама печать — вне секции, по уже снятой копии. Сборка числа из байтов через сдвиги и маски разобрана в уроке про битовые операции.

В симуляторе пары noInterrupts()/interrupts() не видно и не почувствовать: движок не вытесняет loop посреди команды, и рваных чтений там не бывает. Привычку ставьте с первого скетча — настоящая плата вытеснит ваш код в любой момент, и не когда удобно вам.

Про размер данных всё решается байтом. byte, bool и char на AVR — один байт, одна машинная команда, атомарность достаётся даром: флагу flag = 1 хватает volatile byte и никакой критической секции. А вот long — четыре байта, float — тоже: без снимка под выключенными прерываниями никуда. Контракт один для всех входов прерывания, не только для INT0: PCINT ловит любой пин платы — в уроке про PCINT счётчики собираются точно так же.

Отдельный случай — millis() внутри обработчика: unsigned long, четыре байта, и сам вызов тянет за собой чтение счётчика таймера. Если в ISR позарез нужно время, снимайте его в loop(): обработчик только ставит флаг «событие было», а основной код сам смотрит на часы и решает, когда это было. Так заодно экономится время прерывания — четыре байта под выключенными прерываниями прямо в ISR, это то ещё развлечение.

И про архитектуру: из обработчика — флаг и счёт, всё остальное в loop(). Датчики, которые будят основной цикл, живут по тому же контракту — как в уроке про прерывание от датчика по I2C: ISR минимален, решения принимает loop() после того, как заметил флаг. Это же правило спасает millis-планировщик из урока про таймеры: длинный обработчик сдвигал бы все задачи.