Процедура обслуживания прерываний (ISR) вне класса

Давайте рассмотрим простое использование прерываний:

volatile bool switchChanged;

void switchPressed ()
  {
  switchChanged = true;
  }  // конец переключателя нажат

void setup ()
  {
  pinMode (2, INPUT_PULLUP);
  attachInterrupt (0, switchPressed, CHANGE);
  }  // завершение настройки

void loop ()
  {
  // неважно    
  }  // конец цикла

Это отлично компилируется.

ISR внутри класса как функция (метод) класса

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

class myClass
  {
  volatile bool switchChanged;
  
  public:

  void begin ()
    {
    pinMode (2, INPUT_PULLUP);
    attachInterrupt (0, switchPressed, CHANGE);   // <--- строка 10
    }  // конец MyClass::begin
    
  void switchPressed ()
    {
    switchChanged = true;
    }  // конец MyClass::switchPressed
    
  };  // конец класса MyClass
  
myClass foo;  // создать экземпляр MyClass
  
void setup ()
  {
  foo.begin ();
  }  // завершение настройки

void loop ()
  {
  // неважно    
  }  // конец цикла

Это не компилируется:

ISR_in_class_test.ino: In member function ‘void myClass::begin()’:
ISR_in_class_test:10: error: argument of type ‘void (myClass::)()’ does not match ‘void (*)()’

Что здесь происходит?

ISR должны быть статическими функциями, не принимающими аргументов. Однако (нестатические) функции класса имеют подразумеваемый указатель this->, который указывает на конкретный экземпляр класса.

Например, если у нас есть два экземпляра:

myClass foo;  
myClass bar; 

Если мы вызываем foo.begin(), то this-> указывает на "foo", а если мы вызываем bar.begin, то this-> указывает на "bar".

Однако ISR, когда он запускается процессором, не может знать, является ли this-> "foo" или "bar" или что-то еще. Таким образом, компилятор не может скомпилировать эту строку.

ISR внутри класса как статическая функция класса

Мы можем попытаться обойти это, сделав функцию класса статической. Это означает, что функция не привязана к какому-либо конкретному экземпляру, и, таким образом, строка attachInterrupt будет скомпилирована.

class myClass
  {
  volatile bool switchChanged;   // <--- строка 3
  
  public:

  void begin ()
    {
    pinMode (2, INPUT_PULLUP);
    attachInterrupt (0, switchPressed, CHANGE);
    }  // конец MyClass::begin
    
  static void switchPressed ()
    {
    switchChanged = true;   // <--- строка 15
    }  // конец MyClass::switchPressed
    
  };  // конец класса MyClass
  
myClass foo;  // создать экземпляр MyClass
  
void setup ()
  {
  foo.begin ();
  }  // завершение настройки

void loop ()
  {
  // неважно    
  }  // конец цикла

Однако теперь у нас есть другая проблема:

ISR_in_class_test.ino: In static member function ‘static void myClass::switchPressed()’:
ISR_in_class_test:3: error: invalid use of member ‘myClass::switchChanged’ in static member function
ISR_in_class_test:15: error: from this location

Нестатическая переменная класса не может быть вызвана из функции статического класса. Почему? Потому что компилятор не знает, какая переменная вам нужна. Это foo.switchChanged или bar.switchChanged?

ISR внутри класса как статическая функция класса со статическими переменными

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

class myClass
  {
  static volatile bool switchChanged;  // объявления
  
  public:

  void begin ()
    {
    pinMode (2, INPUT_PULLUP);
    attachInterrupt (0, switchPressed, CHANGE);
    }  // конец MyClass::begin
    
  static void switchPressed ()
    {
    switchChanged = true;
    }  // конец MyClass::switchPressed
    
  };  // конец класса MyClass
  
volatile bool myClass::switchChanged;  // определить
  
myClass foo;  // создать экземпляр MyClass
  
void setup ()
  {
  foo.begin ();
  }  // завершение настройки

void loop ()
  {
  // неважно    
  }  // конец цикла

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

Процедуры склеивания

Чтобы обойти эту проблему, мы можем написать короткие процедуры "склеивания". Это функции, которые взаимодействуют между ISR и экземпляром класса.

class myClass
  {
  volatile bool switchChanged;

  static myClass * instances [2];
 
  static void switchPressedExt0 ()
    {
    if (myClass::instances [0] != NULL)
      myClass::instances [0]->switchPressed ();
    }  // конец MyClass::switchPressedExt0
  
  static void switchPressedExt1 ()
    {
    if (myClass::instances [1] != NULL)
      myClass::instances [1]->switchPressed ();
    }  // конец MyClass::switchPressedExt1


  public:

  void begin (const byte whichPin)
    {
    pinMode (whichPin, INPUT_PULLUP);
    switch (whichPin)
      {
      case 2: 
        attachInterrupt (0, switchPressedExt0, CHANGE);
        instances [0] = this;
        break;
        
      case 3: 
        attachInterrupt (1, switchPressedExt1, CHANGE);
        instances [1] = this;
        break;
        
      } // конец переключателя
    }  // конец MyClass::begin
    
  void switchPressed ()
    {
    switchChanged = true; 
    }
    
  };  // конец класса MyClass
  
myClass * myClass::instances [2] = { NULL, NULL };

// экземпляры нашего класса
myClass foo; 
myClass bar;

void setup ()
  {
  foo.begin (2);   // вывод D2
  bar.begin (3);   // вывод D3
  }  // завершение настройки

void loop ()
  {
  // неважно    
  }  // конец цикла

Это немного неудобно, однако то, что он делает, - это запоминает в массиве, какой экземпляр класса связан с каким прерыванием. Процедуры "склеивания" switchPressedExt0 и switchPressedExt1 вызывают соответствующий экземпляр функции switchPressed, используя запомненный указатель класса.

Теперь нестатическая функция switchPressed может обращаться к нестатическим переменным класса.

Этот ответ был воспроизведен с моего форума, но я не могу публиковать здесь ответы только по ссылкам.