Программы, которые никогда не ждут: millis() и состояния

delay() легко использовать, но эта функция останавливает весь скетч. Робот, который ждёт, ничего не видит. Решение — не ждать, а поглядывать на часы. Для этого есть три инструмента: таймеры на millis(), флаги и конечный автомат.

#Что на самом деле делает delay()

Во время delay(1000) Uno целую секунду не выполняет ни одной другой строки вашего скетча. Плата не может ни прочитать датчик, ни переключить мотор, ни вывести сообщение. Продолжается только фоновая работа, например счёт времени.

Для простой задачи это нормально. Скетч из проекта «Первый заезд» использует delay(STRAIGHT_MS), то есть 1200 мс, для каждой стороны квадрата. У того робота нет датчика, и больше ему делать нечего. А теперь представьте, что на нём стоит датчик расстояния. На каждой стороне робот 1,2 секунды не смотрел бы вперёд. Он врезался бы в стену, которая появилась за это время.

Кроме того, с delay() трудно делать два дела сразу. Попробуйте с помощью delay() мигать одним светодиодом каждые 500 мс, а другим — каждые 170 мс. Каждый вызов delay() задерживает оба светодиода. Пришлось бы вручную составлять общее расписание. И оно сломалось бы, как только вы добавили бы третье дело.

Некоторые функции немного ждут и сами. В скетчах наших роботов pulseIn() ждёт эхо до 25 мс. Такие короткие ожидания допустимы. Проблема — долгое ожидание в тот момент, когда робот должен смотреть.

#millis(): часы, на которые можно посмотреть

millis() возвращает число миллисекунд с момента запуска платы. Счёт идёт сам, в фоне, пока работает ваш скетч. Результат имеет тип unsigned long: это целое число от 0 до 4 294 967 295. Любое значение времени тоже храните в переменной типа unsigned long. int не подойдёт: на Uno он вмещает числа только до 32 767. В миллисекундах это меньше 33 секунд.

Вспомните, как варят рис. Вы не стоите у кастрюли все 20 минут. Вы засекаете время, когда начали. Потом время от времени смотрите на часы: прошло ли 20 минут? А в промежутках занимаетесь другими делами. Таймер на millis() работает точно так же.

#Шаблон таймера

Вот один из двух таймеров скетча TwoTimers:

unsigned long now = millis();

if (now - moduleTimer >= MODULE_MS) {
  moduleTimer = now;
  moduleOn = !moduleOn;
  digitalWrite(LED_MODULE, moduleOn);
}

• now - moduleTimer — время, прошедшее с последнего переключения светодиода.
• >= MODULE_MS спрашивает: прошло ли хотя бы 500 мс?
• Если да, скетч сохраняет новое время в moduleTimer, переключает флаг и выставляет уровень на пине.
• Если нет, он пропускает этот блок. Он не ждёт: переходит к следующему делу и спрашивает снова при следующем проходе loop().

Используйте >=, а не ==. Ровно в 500 мс скетч может быть занят чем-то другим, например ждать внутри pulseIn(). С >= таймер всё равно сработает, пусть и чуть позже. С == он может пропустить свой момент и не сработать никогда.

#Почему вычитание не боится переполнения

Через 4 294 967 295 мс, то есть примерно через 49,7 дня, millis() снова начинает счёт с 0. Это называется переполнением (overflow).

Беззнаковые числа идут по кругу, как стрелки на циферблате. На 12-часовом циферблате от 11 часов до 2 часов проходит 3 часа, хотя 2 меньше 11. Вычитание в unsigned long работает так же: оно всегда даёт прошедшее время, отсчитанное вперёд.

Пример с настоящими числами:

• moduleTimer равен 4 294 967 000: это за 296 мс до переполнения.
• now равен 204: это через 204 мс после переполнения.
• На самом деле прошло 296 + 204 = 500 мс.
• Uno вычисляет 204 - 4 294 967 000 в unsigned long и получает ровно 500. Таймер срабатывает вовремя.

А другая запись, now >= moduleTimer + MODULE_MS, здесь не работает. Сумма 4 294 967 000 + 500 переполняется и становится равной 204. Сразу после того, как таймер запустили, now всё ещё около 4 294 967 000. Это больше 204, поэтому проверка сразу оказывается истинной — и так на каждом проходе, пока millis() не переполнится.

Робот редко работает 49 дней подряд. Но правильный шаблон написать ничуть не сложнее, а некоторые устройства, например контроллер теплицы, работают месяцами.

#Два светодиода, два таймера

В TwoTimers у каждого светодиода свой таймер: переменная, в которой хранится время последнего переключения, и постоянный интервал.

loop() выполняется много тысяч раз в секунду. На большинстве проходов обе проверки отвечают «ещё нет», и ничего не происходит. Иногда одна из них срабатывает, переключает свой светодиод и запоминает время. Ни один таймер не ждёт другого.

Подключение такое же, как в проекте Blink: пин S модуля светодиода — на D2, а его пин «-» — на GND.

Обратите внимание, где «живут» переменные. moduleTimer, boardTimer, moduleOn и boardOn объявлены вверху, вне loop(). Переменная, объявленная внутри loop(), создаётся заново на каждом проходе и забывает своё значение.

#Флаги: запоминаем «да» или «нет»

moduleOn и boardOn — это флаги: переменные типа bool, которые помнят ответ «да» или «нет». moduleOn = !moduleOn переключает флаг: true превращается в false, а false — в true. Затем digitalWrite(LED_MODULE, moduleOn) выставляет на пине HIGH при true и LOW при false.

Флаги хороши для простых фактов: горит ли светодиод, запустился ли робот? Но если у робота несколько режимов, во множестве флагов легко запутаться. Ничто не мешает двум из них одновременно быть true, даже когда это бессмысленно. Для режимов используйте конечный автомат.

#Что вы увидите в симуляторе

Соберите в симуляторе настольного робота из проекта Blink: Uno и модуль светодиода, S на D2. Вставьте скетч TwoTimers выше в «Код» и нажмите «Загрузить». На столе Uno работает от USB ноутбука. Модуль светодиода мигает раз в секунду, а светодиод L — почти три раза в секунду. Так как 500 не кратно 170, светодиоды переключаются в разные моменты, и рисунок их мигания всё время смещается. Ни один светодиод никогда не ждёт другого.

#Конечный автомат: одна переменная для того, чем занят робот

У робота, объезжающего препятствия, три дела, которые сменяют друг друга: ехать вперёд, ехать назад, поворачивать. Каждое дело — это состояние. Робот всегда находится ровно в одном состоянии.

enum class State : byte { Drive, Back, Turn };
State state = State::Drive;

enum class создаёт новый тип с тремя именованными значениями. Благодаря : byte он занимает один байт оперативной памяти. Переменная state хранит текущее состояние. Почему не обычные числа? С int запись state = 2 ничего не сказала бы читателю, а state = State::Turn понятна сразу. Кроме того, enum class строгий: компилятор не примет простое число в качестве State. А имена остаются внутри State, поэтому не смешиваются с другими именами в скетче.

В loop() конструкция switch (state) переходит к ветке case текущего состояния. Каждая ветка делает две вещи: задаёт работу моторов и проверяет, не пора ли сменить состояние. break завершает ветку.

Функция enter(next) меняет состояние. Ещё она сохраняет время в stateStart, чтобы каждое состояние могло само отсчитывать своё время. Если следующее состояние — Drive, она обнуляет lastPing. Благодаря этому робот сразу измеряет расстояние заново, а не едет дальше со старым значением.

Измерение — это не состояние. У него свой таймер в начале loop(): каждые 60 мс, в любом состоянии. Поэтому робот продолжает измерять, даже когда едет назад и поворачивает.

#Диаграмма состояний в виде таблицы

На бумаге каждое состояние можно нарисовать кружком, а каждый переход — стрелкой. Таблица содержит то же самое, а набирать её проще:

Когда планируете своего робота, сначала заполните такую таблицу: по строке на каждое состояние. Затем напишите по одному case на каждую строку. Столбец «Когда меняется» становится условием if, а столбец «Следующее состояние» — вызовом enter().

Новое поведение — это новая строка. Например, состояние Stop могло бы держать робота на месте, пока что-то ближе 10 см, и возвращать его в Drive, когда путь свободен. Вы добавляете одну строку для Stop и одно новое условие в строку Drive. Всё остальное остаётся прежним.

Запустите робота, объезжающего препятствия, на арене и следите за монитором порта (Serial Monitor). Расстояния продолжают приходить примерно каждые 60 мс, даже когда робот едет назад и поворачивает. Если бы в этих состояниях стоял delay(), поток чисел прерывался бы. Полностью этот робот описан в проекте «Робот, объезжающий препятствия».