прерывание с кнопки и ожидание, пока на последовательный порт 1 поступит сообщение

Дело в том, что внутри ISR (Interrupt Service Routine) не только измерение времени с помощью millis() не работает, delay() также не будет работать (он использует тот же механизм прерываний, что и millis() в фоновом режиме). Как и все остальное, что зависит от их собственного ISR для выполнения — например, получение последовательных данных. Аппаратный последовательный интерфейс может получать отдельные байты, не завися от прерываний, но чтобы поместить эти байты в буфер (и фактически использовать их через Serial), вам нужно разрешить выполнение других ISR.

НИКОГДА не следует писать ISR, который выполняется долго. Держите его в микросекундах, максимум в очень низком диапазоне миллисекунд. То, как долго вы сможете дойти до этого, пока не увидите негативные эффекты, зависит от других факторов. Вам действительно следует выполнять только минимальную работу в ISR, а остальное в основном коде.

Общая структура кода для этого выглядит следующим образом:

• В вашем основном коде вы не используете никаких вызовов delay(). Все хронометрированное должно быть сделано с помощью millis() (как в примере BlinkWithoutDelay, который поставляется с Arduino IDE), чтобы это не блокировало выполнение. Также никаких длинных циклов внутри loop(). Убедитесь, что ваша функция loop() может свободно и быстро итерироваться.
• В глобальной области видимости вы определяете переменную-флаг. Простая однобайтовая переменная, помеченная как volatile.
• В вашем ISR вы ничего не делаете, кроме установки этой переменной. В зависимости от ситуации вы можете захотеть установить ее в зависимости от цифрового входа через digitalRead(), что все еще быстро, так что это нормально.
• В вашем основном коде вы используете оператор if для проверки установки этой переменной-флага. В большинстве итераций loop() это не будет выполнено. Только если переменная-флаг была установлена внутри ISR, она будет выполнена. Это место, где вы пишете код, обрабатывающий событие. В конце блока вам нужно только сбросить переменную-флаг, чтобы вы были готовы к следующему прерыванию.

Это будет выглядеть примерно так:

int button_pin = 2;
volatile bool button_flag = false;

void setup(){
  pinMode(button_pin, INPUT_PULLUP);
  attachInterrupt(digitalPinToInterrupt(button_pin), button_ISR, RISING);
}

void loop(){
  if(button_flag){
    // Обработка прерывания здесь
    button_flag = false; // Сбросить переменную флага, чтобы быть готовым к следующему прерыванию
  }
}

void button_ISR(){
  button_flag = true;
}

Обратите внимание, что переменная button_flag определена как volatile, поэтому компилятор не кэширует ее значение в каком-либо регистре, а вместо этого всегда считывает ее фактическое текущее значение (не оптимизируя его).

В вашем коде вам, вероятно, следует использовать другую концепцию кодирования, называемую конечным автоматом (FSM). Это самый простой способ реализовать код с различными состояниями/стадиями, сохраняя при этом его неблокируемость. Вы можете почитать о FSM в Интернете (или, например, в моем ответе на этот вопрос).

Суть в том, что вы используете переменную, которая представляет состояние, в котором в данный момент находится ваш код. В loop() вы затем выполняете код только для текущего состояния. Изменение в другое состояние осуществляется путем установки переменной состояния. Состояние, которое требуется вашему текущему коду, вероятно, CHECK_FOR_SINGLE_RFID_TAG и ASSOCIATE_SINGE_RFID_TAG (хотя вы можете назвать их так, как хотите). Простой FSM с этим может выглядеть следующим образом:

#define CHECK_FOR_SINGLE_RFID_TAG 0
#define ASSOCIATE_SINGLE_RFID_TAG 1

// однобайтовая переменная, поэтому нам не нужно беспокоиться об атомарных чтениях/записях
uint8_t state = CHECK_FOR_SINGLE_RFID_TAG;

void loop(){
  switch(state){
    case CHECK_FOR_SINGLE_RFID_TAG:
      if(Serial1.available()){
        // здесь считываем Serial1, сверяем идентификатор RFID-метки с сохраненным
        // и выполнить код соответствующим образом
      }
      break;
    
    case ASSOCIATE_SINGLE_RFID_TAG:
      if(Serial1.available()){
        // здесь считываем Serial1 и сохраняем новый идентификатор RFID-метки в переменной
        // затем сбросьте переменную состояния, чтобы автоматически вернуться в режим проверки
        // после регистрации новой RFID-метки
        state = CHECK_FOR_SINGLE_RFID_TAG;
      }
      // Используйте идиому BlinkWithoutDelay для неблокируемого мигания светодиода
      // что-то вроде
      // если (millis() - led_timestamp > led_interval) {
      // digitalWrite(led, !digitalRead(led));
      // }
      break;
  }
}

Видите, как мы определяем возможные состояния, сохраняем текущее в переменной и действуем в соответствии с ним внутри loop()? Эта концепция действительно мощная, поэтому ее определенно стоит изучить.

Примечание: я использовал переменную типа uint8 _t (один байт), чтобы сделать это прерывание безопасным (вы можете прочитать об этом, выполнив поиск по запросу arduino interrupt atomic read или arduino interrupt safe variable) для следующей части и определений, чтобы дать каждому значению читаемое имя. Вы можете использовать enum для этого, хотя во время написания этого я наткнулся на размер enum, который, кажется, составляет 16 бит на AVR (например, Arduino Mega), если вы не используете определенный флаг компилятора, согласно этой статье в блоге. Это объяснение сейчас не так уж и важно для вас, но я также хотел объяснить, почему здесь не используются перечисления.

Теперь мы можем объединить это с нашим кодом прерывания выше. В этом случае нам больше не нужна отдельная переменная флага. Мы можем напрямую установить переменную state внутри ISR:

#define CHECK_FOR_SINGLE_RFID_TAG 0
#define ASSOCIATE_SINGLE_RFID_TAG 1

volatile uint8_t state = CHECK_FOR_SINGLE_RFID_TAG;

int button_pin = 2;

void setup(){
  pinMode(button_pin, INPUT_PULLUP);
  attachInterrupt(digitalPinToInterrupt(button_pin), button_ISR, RISING);
  Serial.begin(115200);
  Serial1.begin(115200);
}

void button_ISR(){
  state = ASSOCIATE_SINGLE_RFID_TAG;
}

void loop(){
  switch(state){
    case CHECK_FOR_SINGLE_RFID_TAG:
      if(Serial1.available()){
        // здесь считываем Serial1, сверяем идентификатор RFID-метки с сохраненным
        // и выполнить код соответствующим образом
      }
      break;
    
    case ASSOCIATE_SINGLE_RFID_TAG:
      if(Serial1.available()){
        // здесь считываем Serial1 и сохраняем новый идентификатор RFID-метки в переменной
        // затем сбросьте переменную состояния, чтобы автоматически вернуться в режим проверки
        // после регистрации новой RFID-метки
        state = CHECK_FOR_SINGLE_RFID_TAG;
      }
      // Используйте идиому BlinkWithoutDelay для неблокируемого мигания светодиода
      // что-то вроде
      // если (millis() - led_timestamp > led_interval) {
      // digitalWrite(led, !digitalRead(led));
      // }
      break;
  }
}

Вы можете видеть, что button_ISR() очень маленький, поэтому очень быстрый. И наш loop() также работает без блокировки, поэтому его следующая итерация будет очень быстрой, и затем он выполнит состояние, которое мы установили в ISR.

Примечание: при чтении из Serial убедитесь, что вы не используете функции, которые блокируют на долгое время. Например, Serial.readString() займет 1 с для выполнения (так как это тайм-аут по умолчанию), что заблокирует неблокируемый код (нехорошо).