Многозадачность и прерывания на Arduino

Сегодня я буду основываться на методе, описанном в публикации Многозадачность на Arduino и исследую несколько типов прерываний Arduino, а также покажу, каким же образом их использовать, чтобы помочь Arduino управлять еще большим числом задач. Я расскажу, как использовать прерывания таймера, чтобы все работало как часы и рассмотрю внешние прерывания, дающие нам уведомления о внешних событиях.

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

Прерывание — это сигнал, который сообщает процессору, что нужно немедленно остановить то, что он в настоящий момент делает, и произвести некоторые операции, имеющие высокий приоритет. Эта обработка с высоким приоритетом называется обработчиком прерываний (interrupt handler).

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

Прерывания могут быть созданы несколькими источниками:

• Одним из таймеров Arduino, формируя прерывания по таймеру;
• Изменением состояния одного из входов внешних прерываний;
• Изменение состояния одного из группы пинов.

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

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

Прерывания по таймеру Arduino

В прошлой публикации про многозадачность я рассматривал, как использовать функцию millis () для управления временем. Но для того, чтобы это работало, нам нужно вызывать millis () каждый раз в цикле, чтобы увидеть, не настало ли время сделать что-то. Это, своего рода, расточительство — вызывать millis () чаще, чем один раз в миллисекунду, только чтобы узнать, что время не изменилось. Было бы неплохо, если бы мы проверяли это только один раз в миллисекунду.

Таймер и прерывания по таймеру позволяют нам сделать именно это. Мы можем установить таймер, чтобы он прерывал нас один раз в миллисекунду. Таймер будет, на самом деле, сообщать нам, что пора проверить часы!

Arduino имеет три таймера: Timer0, Timer1 и Timer2. Timer0 уже настроен для генерации миллисекундных прерываний, обновляя счетчик миллисекунд, передаваемый в millis ().  Это именно то, что нам нужно!

Таймеры — это простые счетчики, которые считают с некоторой частотой, получаемой из системных 16Мгц. Мы можем сконфигурировать делитель частоты для получения требуемой частоты и различных режимов счета. Мы также можем настроить их для генерации прерываний при достижении таймером некоторых заданных значений.

Timer0 являющийся 8-битным, считает от 0 до 255 и генерирует прерывание, при переполнении (превышении значения в 255). Он использует тактовый делитель на 64 по умолчанию, чтобы дать нам частоту прерываний 976.5625 Гц (достаточно близко к 1 кГц для наших целей). Мы не будем изменять частоту в Timer0, потому что это точно нарушит работу millis ()!

Регистры сравнения

В регистрах сравнения хранятся данные, которые постоянно сравниваются с состоянием таймера/счетчика. Установим регистр сравнения (OCR0A) для генерации другого прерывания где-то в середине этого счета. Приведенный ниже код будет генерировать прерывание TIMER0_COMPA всякий раз, когда значение счетчика проходит 0xAF.

// Timer0 уже используется millis() - мы создаем прерывание где-то
// в середине и вызываем ниже функцию "Compare A"
OCR0A = 0xAF;
TIMSK0 |= _BV(OCIE0A);

Затем определим обработчик прерывания для вектора прерывания по таймеру, называемому TIMER0_COMPA_vect. В этом обработчике прерывания будет делаться все то, что мы ранее делали в loop ().

// Прерывание вызывается один раз в миллисекунду
SIGNAL(TIMER0_COMPA_vect)
{
 unsigned long currentMillis = millis();
 sweeper1.Update(currentMillis);

 //if(digitalRead(2) == HIGH)
 {
  sweeper2.Update(currentMillis);
  led1.Update(currentMillis);
 }
 led2.Update(currentMillis);
 led3.Update(currentMillis);
}

Что оставляет нас с абсолютно пустым loop ()

void loop()
{
}

Здесь мы теперь можем делать все что угодно. Можно даже вернуться к использованию delay ()! Это не затронет наши мигающие светодиоды и вращающиеся сервы. Они будут по-прежнему независимо вызываться один раз в миллисекунду.

Напишем новый код, независимо управляющий миганием светодиодов и вращением сервоприводов, но уже используя таймер.

#include <Servo.h>

class Flasher
{
 // Переменные-члены класса
 // Устанавливаются при запуске
 int ledPin; // Номер пина со светодиодом
 long OnTime; // длительность ВКЛ в мс
 long OffTime; // длительность ВЫКЛ в мс

 // Текущее состояние
 int ledState; // устанавливает состояние светодиода
 unsigned long previousMillis; // время последнего обновления светодиода

 // Конструктор - создает Flasher
 // и инициализирует переменные-члены
 // и состояние
 public:
 Flasher(int pin, long on, long off)
 {
  ledPin = pin;
  pinMode(ledPin, OUTPUT); 

  OnTime = on;
  OffTime = off;

  ledState = LOW;
  previousMillis = 0;
 }

 void Update(unsigned long currentMillis)
 {
  if((ledState == HIGH) && (currentMillis - previousMillis >= OnTime))
  {
   ledState = LOW; // ВЫКЛ
   previousMillis = currentMillis; // Запомнить время
   digitalWrite(ledPin, ledState); // Обновить состояние светодиода
  }
  else if ((ledState == LOW) && (currentMillis - previousMillis >= OffTime))
  {
   ledState = HIGH; // ВКЛ
   previousMillis = currentMillis; // Запомнить время
   digitalWrite(ledPin, ledState); // Обновить состояние светодиода
  }
 }
};

class Sweeper
{
 Servo servo; // объект servo
 int pos; // текущее положение сервы
 int increment; // увеличивать перемещение на каждом интервале
 int updateInterval; // время между обновлениями
 unsigned long lastUpdate; // последнее обновление положения

 public:
 Sweeper(int interval)
 {
  updateInterval = interval;
  increment = 1;
 }

 void Attach(int pin)
 {
  servo.attach(pin);
 }

 void Detach()
 {
  servo.detach();
 }

 void Update(unsigned long currentMillis)
 {
  if((currentMillis - lastUpdate) > updateInterval) // пришло время обновляться
  {
   lastUpdate = millis();
   pos += increment;
   servo.write(pos);
   if ((pos >= 180) || (pos <= 0)) // конец вращения
   {
    // обратное направление
    increment = -increment;
   }
  }
 }
};

Flasher led1(11, 123, 400);
Flasher led2(12, 350, 350);
Flasher led3(13, 200, 222);

Sweeper sweeper1(25);
Sweeper sweeper2(35);

void setup()
{
 sweeper1.Attach(9);
 sweeper2.Attach(10);

 // Timer0 уже используется millis() - прерываемся где-то
 // посередине и вызываем ниже функцию "Compare A"
 OCR0A = 0xAF;
 TIMSK0 |= _BV(OCIE0A);
} 

// Прерывание вызывается один раз в миллисекунду,
// ищет любые новые данные, и сохраняет их
SIGNAL(TIMER0_COMPA_vect)
{
 unsigned long currentMillis = millis();
 sweeper1.Update(currentMillis);

 if(digitalRead(2) == HIGH)
 {
  sweeper2.Update(currentMillis);
  led1.Update(currentMillis);
 }

 led2.Update(currentMillis);
 led3.Update(currentMillis);
}
void loop()
{
}

Внешние прерывания

В отличие от прерываний по таймеру, внешние прерывания вызываются внешними событиями. Например, когда нажата кнопка, или же получен импульс от датчика вращения. Однако, также как и с прерываниями по таймеру, нам не нужно постоянно опрашивать выводы GPIO на изменения.

На используемой мной Arduino Mega 2560 имеется 6 пинов, обрабатывающих внешние прерывания (на Arduino UNO таких входов только 2). В этом примере я подключу кнопку к одному из них и использую ее для сброса сервоприводов.

Во-первых, давайте добавим функцию reset () в наш класс Sweeper.  Функция reset () устанавливает положение в ноль и немедленно перемещает туда серву.

void reset()
{
 pos = 0;
 servo.write(pos);
 increment = abs(increment);
}

Затем, добавим вызов функции attachInterrupt (), соединяющую внешнее прерывание с обработчиком. На Arduino Mega 2560, также как и на Arduino UNO, Inerrupt 0 ассоциировано с цифровым пином 2. Мы говорим, что ждем «спада» фронта сигнала на этом выводе. При нажатии кнопки сигнал «спадает» от высокого до низкого уровня и вызывается обработчик прерывания Reset.

pinMode(2, INPUT_PULLUP);
attachInterrupt(0, Reset, FALLING);

И здесь есть обработчик прерывания. Он просто вызывает функции, сбрасывающие сервы.

void Reset()
{
 sweeper1.reset();
 sweeper2.reset();
}

Теперь, при нажатии на кнопку, серва останавливает вращение и немедленно возвращается в нулевую позицию.

Схема у нас та же, что и в прошлый раз.

Полный скетч с таймерами и внешними прерываниями:

#include <Servo.h>

class Flasher
{
 // Переменные-члены класса
 // Устанавливаются при запуске
 int ledPin; // Номер пина со светодиодом
 long OnTime; // длительность ВКЛ в мс
 long OffTime; // длительность ВЫКЛ в мс

 // Текущее состояние
 int ledState; // устанавливает состояние светодиода
 unsigned long previousMillis; // время последнего обновления светодиода

 // Конструктор - создает Flasher
 // и инициализирует переменные-члены
 // и состояние
 public:
 Flasher(int pin, long on, long off)
 {
  ledPin = pin;
  pinMode(ledPin, OUTPUT);

  OnTime = on;
  OffTime = off;

  ledState = LOW;
  previousMillis = 0;
 }

 void Update(unsigned long currentMillis)
 {
  if((ledState == HIGH) && (currentMillis - previousMillis >= OnTime))
  {
   ledState = LOW; // ВЫКЛ
   previousMillis = currentMillis; // Запомнить время
   digitalWrite(ledPin, ledState); // Обновить состояние светодиода
  }
  else if ((ledState == LOW) && (currentMillis - previousMillis >= OffTime))
  {
   ledState = HIGH; // ВКЛ
   previousMillis = currentMillis; // Запомнить время
   digitalWrite(ledPin, ledState); // Обновить состояние светодиода
  }
 }
};

class Sweeper
{
 Servo servo; // объект servo
 int pos; // текущее положение сервы
 int increment; // увеличивать перемещение на каждом интервале
 int updateInterval; // время между обновлениями
 unsigned long lastUpdate; // последнее обновление положения

 public:
 Sweeper(int interval)
 {
  updateInterval = interval;
  increment = 1;
 }

 void Attach(int pin)
 {
  servo.attach(pin);
 }

 void Detach()
 {
  servo.detach();
 }

 void reset()
 {
  pos = 0;
  servo.write(pos);
  increment = abs(increment);
 }

 void Update(unsigned long currentMillis)
 {
  if((currentMillis - lastUpdate) > updateInterval) //пришло время обновляться
  {
   lastUpdate = millis();
   pos += increment;
   servo.write(pos);
   if ((pos >= 180) || (pos <= 0)) // конец вращения
   {
    // обратное направление
    increment = -increment;
   }
  }
 }
};

Flasher led1(11, 123, 400);
Flasher led2(12, 350, 350);
Flasher led3(13, 200, 222);

Sweeper sweeper1(25);
Sweeper sweeper2(35);

void setup()
{
 sweeper1.Attach(9);
 sweeper2.Attach(10);

 // Timer0 уже используется millis() - прерываемся где-то
 // посередине и вызываем ниже функцию "Compare A"
 OCR0A = 0xAF;
 TIMSK0 |= _BV(OCIE0A);

 pinMode(2, INPUT_PULLUP);
 attachInterrupt(0, Reset, FALLING);
}

void Reset()
{
 sweeper1.reset();
 sweeper2.reset();
}

// Прерывание вызывается один раз в миллисекунду,
// ищет любые новые данные, и сохраняет их
SIGNAL(TIMER0_COMPA_vect)
{
 unsigned long currentMillis = millis();
 sweeper1.Update(currentMillis);

 // if(digitalRead(2) == HIGH)
 {
  sweeper2.Update(currentMillis);
  led1.Update(currentMillis);
 }

 led2.Update(currentMillis);
 led3.Update(currentMillis);
}
void loop()
{
}

И результат

Библиотеки для работы с прерываниями

В сети можно найти несколько библиотек для работы с таймерами. Многие просто постоянно опрашивают millis () так же, как мы делали это в прошлый раз. Но есть некоторые, которые позволяют настроить таймеры для генерации прерываний.

Отличные библиотеки TimerOne и TimerThree от Paul Stoffregan дают множество низкоуровневых возможностей для конфигурирования прерываний по таймеру. Библиотека TimerThree не работает на Arduino UNO.  Ее можно использовать с Leonardo, Mega 2560 и некоторыми платами Teensy.

Arduino UNO имеет только два входа внешних прерываний. Но что делать если требуется более двух входов? К счастью Arduino UNO поддерживает прерывания «pin-change» (по изменению входа) для всех пинов.

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

Библиотека PinChangeInt реализует удобный интерфейс для прерываний по изменению входа.

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

Для того, чтобы все работало гладко, лучше использовать не более 10 различных прерываний.

Если все имеет высокий приоритет, значит высокого приоритета нет ни у чего

Обработчики прерываний должны использоваться для обработки только приоритетных, чувствительных ко времени событий. Помните, что прерывания отключены, пока вы находитесь в обработчике прерывания. Если вы попытаетесь сделать слишком много на уровне прерывания, вы получите худший ответ на другие прерывания.

Одно прерывание в каждый момент времени

Когда программа находится в функции обработки прерывания, то другие прерывания отключены. Это имеет два важных следствия:

• Работа, выполняемая в функции обработки прерывания должна быть короткой, чтобы не пропустить не одного прерывания.
• Код, выполняемый в функции обработки прерывания не должен вызывать ничего такого, что требовало бы, чтобы прерывания были активны (например, delay () , или что-нибудь, использующее шину I²C). Это приведет к зависанию программы.

Отложите длительную обработку в loop ()

Если вам необходимо произвести обширную обработку в ответ на прерывание, используйте обработчик прерывания для того, чтобы сделать то, что необходимо, а затем установите переменную состояния volatile, показывающую, что дальнейшая обработка не требуется. При вызове функции Update () из loop () проверьте переменную состояния, на предмет того, не требуется ли какая-либо последующая обработка.

Проверка перед переконфигурированием таймера

Таймеры являются ограниченным ресурсом. На Arduino UNO их всего 3, и они используются для многих вещей. Если вы запутались с конфигурацией таймера, некоторые вещи могут перестать работать. Например, на Arduino UNO:

• Timer0 - используется millis (), micros (), delay () и ШИМ на пинах 5 и 6
• Timer1 - используется для Servo, библиотеки WaveHC и ШИМ на пинах 9 и 10
• Timer2 - используется Tone и ШИМ на пинах 11 и 13

Безопасное совместное использование данных

Поскольку прерывание приостановит все, что процессор делает, мы должны побеспокоиться об обмене данными между обработчиками прерываний и кодом в loop ().

Иногда компилятор попытается оптимизировать свой код для увеличения производительности. Иногда, в результате этой оптимизации, копии часто используемых переменных будут сохраняться в регистре для быстрого доступа к ним. Проблема в том, что если одна из этих переменных совместно используется обработчиком прерывания и кодом в loop (), то, в конечном итоге, в ней может обнаружиться несвежая копия вместо реального значения. Маркировка переменной как voltatile сообщает компилятору, что не нужно производить эти потенциально опасные оптимизации.

Даже пометка переменной как volatile будет не достаточным в случае, если переменная больше, чем целое (например, строка, массив, структура и т.п.). Большим переменным иребуется несколько циклов инструкций для обновления, и если прерывание происходит в середине этого обновления, данные могут быть повреждены. Если у вас есть большие переменные или структуры, которые совместно используются с обработчиком прерываний, вы должны отключить прерывания при обновлении их из loop (). Замечу, что прерывания отключены в обработчике прерывания уже по умолчанию.

[add_ratings]