Конечный автомат, ожидающий входного состояния, не получает входные состояния по неизвестной причине

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

Все остальное работает безупречно на макетной плате, и программа работает отлично, за исключением части, где программа ждет, пока состояние датчиков не покажет "BOTH_RSENSORS_LOW" на строке 304 программы. У меня запущен последовательный монитор для проверки состояния "RsensorState", которое обновляется каждый раз при запуске строки 302. В основном цикле "RsensorState" должен обновляться на строке 174, которая должна обновляться на строке 437, где он должен возвращать состояние на основе входов датчика. Последовательный монитор не показывает никаких изменений состояния при изменении входа на подключенных к нему контактах. Я также проверил другие контакты на предмет того, не закорочены ли они каким-то образом на HIGH. У меня точно такие же датчики работают нормально, возвращая состояние датчиков 1 и 2. Я просмотрел код и не знаю, чего не хватает. Каждый другой блок работает отлично и так, как и требовалось. Возможно, у меня небольшая синтаксическая ошибка, которую я просто не вижу. Я попытался изложить программу в максимально простом формате и разбить шаги логики на блоки, в которых мне было бы легко ориентироваться.

Плата: Arduino DUE

Программное обеспечение: Arduino IDE 1.8.5

Включает библиотеки Bounce2.h и LiquidCrystal.h

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

CLEAR_SENSORS Выключает реле 2, прикрепленное к физическому упору, предназначенному для выравнивания детали, чтобы готовая деталь могла быть продвинута через машину, а затем проверяет, не заблокированы ли датчики 1 и 2, что означает, что деталь была снята, чтобы упор можно было вернуть на место. Датчики 1 и 2 находятся по обе стороны от упора, чтобы упор не активировался и не ударил деталь, когда она проталкивается.

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

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

WAIT_FOR_BUTTON Ожидает нажатия кнопки и переходит к следующему шагу.

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

FINAL_CHECK проверяет, не была ли удалена деталь. Если она удалена, то возвращается к ожиданию установки детали на место и отпускания всех кнопок.

LOWER_RAILS проверяет, удерживаются ли кнопки, и если да, опускает выравнивающие и удерживающие перила, прикрепленные к Relay3

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

SAFETY_WINDOW — это небольшой временной интервал, в течение которого машина ждет, пока не включится реле, а затем по истечении этого временного интервала включает реле1

RELAY_ON отключает главное реле1 и удерживающее реле3, если кнопки отпущены, и отключает их после истечения времени срабатывания реле. Затем он переходит в начало, где ждет, пока деталь будет удалена.

Когда я обхожу шаг CHECK_RAIL_SENSORS, все работает безупречно. Я в недоумении, почему эта конкретная часть не работает. Насколько я могу судить, это связано с тем, что RsensorState не обновляется так, как ожидалось, как другие датчики. sensorState обновляется и функционирует точно так, как ожидалось, поэтому я не уверен, почему RsensorState не обновляется. Может, я делаю синтаксическую ошибку, о которой не знаю? Я прошел через это сто раз, и, возможно, я просто ее не вижу. Все компоненты были протестированы и функционируют так, как ожидалось. Вот код:

// Этот скетч считывает входные данные с двух кнопок и датчика для включения двух реле
// RelayPin2 задействован до конца цикла первого реле
// Требуется, чтобы обе кнопки были нажаты с определенным интервалом друг от друга и удерживались
// Затем контакт реле включается на определенный период времени.
// RelayPin3 включается и проверяется датчиками 3 и 4
// RelayPin2 выключается после того, как первый релейный контакт завершит свой цикл
// Когда датчик очищен, RelayPin2 снова включается
// Затем обе кнопки необходимо снова отпустить, чтобы начался новый цикл.
// Конечный автомат используется только для того, чтобы было более понятно, что происходит.
// Используется с Arduino DUE в Arduino 1.8.5 IDE
// Оригинальный эскиз найден на https://arduino.stackexchange.com/questions/45584/state-machine-logic-problem-with-added-states-monitoring-safety-switches/
// Использует библиотеку Bounce2: https://github.com/thomasfredericks/Bounce2
//
// При нажатии кнопки вход становится ВЫСОКИМ.
//
// Обычно для состояния используется только один 'enum', который управляет кодом.
// В этом эскизе также есть «перечисление» для кнопок, которое называется состоянием ввода.
// определяем различные состояния для этого эскиза.
// «Перечисление» похоже на ряд #define с увеличивающимися числами.

// включить код библиотеки:
#include <Bounce2.h>
#include <LiquidCrystal.h>

// инициализируем библиотеку с номерами интерфейсных контактов
LiquidCrystal lcd(7, 8, 9, 10, 11, 12);

// Логические состояния основного конечного автомата
enum
{
  CLEAR_SENSORS,
  CHECK_SENSORS,
  WAIT_FOR_BOTH_LOW,
  WAIT_FOR_BUTTON,
  ONE_PUSHED_WAIT_FOR_OTHER_BUTTON,
  FINAL_CHECK,
  LOWER_RAILS,
  CHECK_RAIL_SENSORS,
  SAFETY_WINDOW,
  RELAY_ON,
} state;       // 'enum' — это его собственный тип.

// определяем различные состояния ввода.
enum
{
  BOTH_BUTTONS_LOW,      // ни одна кнопка не нажата .
  BOTH_BUTTONS_HIGH,     // обе кнопки нажаты.
  ONE_BUTTON_HIGH,       // вероятно, нажата одна из кнопок.
};

// Определить различные состояния датчика

enum
{
  BOTH_SENSORS_HIGH, // Оба датчика не заблокированы
  BOTH_SENSORS_LOW, // Оба датчика заблокированы
  SENSOR1_HIGH_SENSOR2_LOW,  // Датчик 1 не заблокирован, но датчик 2 заблокирован
  SENSOR2_HIGH_SENSOR1_LOW,   // Датчик 2 не заблокирован, но датчик 1 заблокирован
};

// Определить различные состояния датчика рельса

enum
{
  BOTH_RSENSORS_HIGH, // Оба датчика не заблокированы
  BOTH_RSENSORS_LOW,  // Оба датчика рельса заблокированы
  SENSOR3_HIGH_SENSOR4_LOW,  // Датчик 3 не заблокирован Датчик 4 заблокирован
  SENSOR4_HIGH_SENSOR3_LOW,  // Датчик 4 не заблокирован Датчик 3 заблокирован
};

const int ButtonPin1 = 2;
const int ButtonPin2 = 3;
const int Sensor1Pin = 6;
const int Sensor2Pin = 24;
const int Sensor3Pin = 30;
const int Sensor4Pin = 31;
const int RelayPin = 5;
const int RelayPin2 = 13;
const int RelayPin3 = 34;
const int IndicatorPin = 4;
const int IndicatorPin2 = 25;
const int IndicatorPin3 = 26;
const int IndicatorPin4 = 27;
const int IndicatorPin5 = 35;

// «previousMillis» предназначен исключительно для части конечного автомата.
// Используется для разных программных таймеров в разных состояниях.
// Это нормально, потому что внутри конечного автомата состояния отделены друг от друга.
// Функции за пределами конечного автомата потребуют отдельного таймера.
unsigned long previousMillis;

const unsigned long RelayOnTime = 1750;    // Длительность времени для реле
const unsigned long TimeFrameForSecondButton = 300; // Длительность времени, в течение которого можно выполнить два нажатия
const unsigned long PushSafetyWindow = 300; // Задержка безопасности после push, чтобы убедиться, что деталь на месте

// Счетчики количества неудачных срабатываний реле и успешных циклов.
// Вероятно, они также могут быть обычными целыми числами.
unsigned long failed = 0;
unsigned long success = 0;

// Создание объектов Bounce
Bounce debouncer1 = Bounce();
Bounce debouncer2 = Bounce();
Bounce debouncer3 = Bounce();
Bounce debouncer4 = Bounce();
Bounce debouncer5 = Bounce();
Bounce debouncer6 = Bounce();

void setup()
{
  lcd.begin(16, 2);
  lcd.print("On");
  Serial.begin(9600);
  Serial.println("Unit Online");

// Настраиваем первую кнопку
  pinMode(ButtonPin1, INPUT);
  debouncer1.attach(ButtonPin1);
  debouncer1.interval(15); //Время дребезга

// Настраиваем вторую кнопку
  pinMode(ButtonPin2, INPUT);
  debouncer2.attach(ButtonPin2);
  debouncer2.interval(15); //Время дребезга

// Настройка датчика 1
  pinMode (Sensor1Pin, INPUT);
  debouncer3.attach(Sensor1Pin);
  debouncer3.interval(5); //Время дребезга

// Настройка датчика 2
  pinMode (Sensor2Pin, INPUT);
  debouncer4.attach(Sensor2Pin);
  debouncer4.interval(5); //Время дребезга

  // Настройка Sensor3
  pinMode (Sensor3Pin, INPUT);
  debouncer5.attach(Sensor3Pin);
  debouncer5.interval(5); //Время дребезга

// Настройка датчика4
  pinMode (Sensor4Pin, INPUT);
  debouncer6.attach(Sensor4Pin);
  debouncer6.interval(5); //Время дребезга

  pinMode(RelayPin, OUTPUT);      // ВЫХОД на реле
  pinMode(RelayPin2, OUTPUT);     // ВЫХОД на второе реле
  pinMode(RelayPin3, OUTPUT);     // ВЫХОД на третье реле
  pinMode(IndicatorPin, OUTPUT);  // ВЫХОД на светодиод индикатора
  pinMode(IndicatorPin2, OUTPUT); // ВЫХОД на второй светодиод индикатора
  pinMode(IndicatorPin3, OUTPUT); // ВЫХОД на третий светодиод индикатора
  pinMode(IndicatorPin4, OUTPUT); // ВЫХОД на четвертый светодиод индикатора
  pinMode(IndicatorPin5, OUTPUT); // ВЫХОД на пятый светодиод индикатора

  Serial.println("Going to CLEAR_SENSORS state");

// Установить начальное состояние машины
  state = CLEAR_SENSORS;
}


void loop()
{

  unsigned long currentMillis = millis();

// Обновить экземпляры Bounce
  debouncer1.update();
  debouncer2.update();
  debouncer3.update();
  debouncer4.update();

  int inputState = getInputState();
  int sensorState = getSensorState();
  int RsensorState = getRSensorState();

// Обрабатываем данные в конечном автомате.
// Выходная часть также находится в конечном автомате.
  switch(state)
  {
    case CLEAR_SENSORS:
       // Выключите реле2 и подождите, пока все не очистится
        lcd.setCursor(0,0);
        lcd.print("Clear Machine");
        digitalWrite(RelayPin2, LOW);     // Выключить реле 2
        digitalWrite(IndicatorPin2, LOW); // Выключить IndicatorPin 2
        digitalWrite(IndicatorPin4, HIGH); // Включить IndicatorPin 4
      if(sensorState == BOTH_SENSORS_HIGH)
      {
        // Приготовьтесь перейти к следующему состоянию
        Serial.println("Machine Clear Going to CHECK_SENSORS state");
        state = CHECK_SENSORS;
      }
      break;
    case CHECK_SENSORS:
      // Включите реле 2 и убедитесь, что датчик включен, прежде чем продолжить
        lcd.setCursor(0,0);
        lcd.print("Load Barricade");
        digitalWrite(RelayPin2, HIGH);  // Включить реле 2
        digitalWrite(IndicatorPin2, HIGH); // Включить IndicatorPin 2
        digitalWrite(IndicatorPin3, HIGH); // Включить IndicatorPin 3
        digitalWrite(IndicatorPin4, LOW); // Выключить IndicatorPin 4
      if(sensorState == SENSOR2_HIGH_SENSOR1_LOW)
      {
        // Приготовьтесь перейти к следующему состоянию
        Serial.println("Machine Clear Going to WAIT_FOR_BOTH_LOW state");
        state = WAIT_FOR_BOTH_LOW;
      }
      break;
    case WAIT_FOR_BOTH_LOW:
      // Для продолжения необходимо отпустить обе кнопки.
        lcd.setCursor(0,0);
        lcd.print("Wait For Release");
        digitalWrite(IndicatorPin3, LOW); // Выключить IndicatorPin 3
      if(inputState == BOTH_BUTTONS_LOW)
      {
        // Приготовьтесь перейти к следующему состоянию.
        Serial.println("Going to WAIT_FOR_BUTTON state");
        state = WAIT_FOR_BUTTON;
      }
      break;
    case WAIT_FOR_BUTTON:
// Это состояние, когда все бездействует и ни одна кнопка не нажата.
// Обычно обе кнопки отпущены.
// Ожидание нажатия первой кнопки.
// Обе кнопки можно нажать одновременно!
        lcd.setCursor(0,0);
        lcd.print("Engage Buttons   ");
      if(inputState == ONE_BUTTON_HIGH || inputState == BOTH_BUTTONS_HIGH)
      {
// Нажата хотя бы одна кнопка.
// Приготовьтесь перейти к следующему состоянию.
// Запускаем таймер, так как есть тайм-аут.
        Serial.println("Going to ONE_PUSHED_WAIT_FOR_OTHER_BUTTON state");
        previousMillis = currentMillis;
        state = ONE_PUSHED_WAIT_FOR_OTHER_BUTTON;
       }
      break;
    case ONE_PUSHED_WAIT_FOR_OTHER_BUTTON:
        lcd.setCursor(0,0);
        lcd.print("Wait for Other");
      if(inputState == BOTH_BUTTONS_LOW)
      {
// Кнопка была отпущена. Это не то, что нам нужно.
// Возвращаемся в состояние ожидания выключения обоих.
        Serial.println("Going to WAIT_FOR_BOTH_LOW state");
        state = WAIT_FOR_BOTH_LOW;
      }
      else if(currentMillis - previousMillis >= TimeFrameForSecondButton)
      {
// Время ожидания истекло.
// Вторая кнопка не была нажата после первой кнопки
// в течение тайм-аута. Это очень плохо.
        Serial.println("Too Long Going to WAIT_FOR_BOTH_LOW state");
        state = WAIT_FOR_BOTH_LOW;
      }
      else if(inputState == BOTH_BUTTONS_HIGH)
      {
// Тайм-аут не закончился и все еще продолжается.
// И теперь обе кнопки нажаты.
// Мы можем продолжить.
// Запускаем таймер для состояния SAFETY_WINDOW.
        Serial.println("Going to FINAL_CHECK state");
        previousMillis = currentMillis;  
        state = FINAL_CHECK;
      }
      break;
    case FINAL_CHECK:
      if(sensorState != SENSOR2_HIGH_SENSOR1_LOW)
      // Проверьте, не убрана ли баррикада
      {
        // Приготовьтесь перейти к следующему состоянию
        Serial.println("Machine Clear Going to CHECK_SENSORS state");
        state = CHECK_SENSORS;
      }
      else if(sensorState == SENSOR2_HIGH_SENSOR1_LOW)
      {
        Serial.println("Going to LOWER_RAILS state");
        state = LOWER_RAILS;
      }
      break;    
    case LOWER_RAILS:
        lcd.setCursor(0,0);
        lcd.print("Lowering Rails  ");
      if(inputState != BOTH_BUTTONS_HIGH)
      // Проверьте, удерживаются ли кнопки безопасности, и если нет, подождите еще одну попытку
      {
        Serial.println("Going to WAIT_FOR_BOTH_LOW state from LOWER_RAILS");
        state = WAIT_FOR_BOTH_LOW;
      }
      else
      // Если кнопки 1 и 2 все еще удерживаются, продолжайте включать реле 3 и проверку датчика
      {
        digitalWrite(RelayPin3, HIGH);  // Включить RelayPin3
        digitalWrite(IndicatorPin5, HIGH); // Включить IndicatorPin5
        Serial.println("Going to CHECK_RAIL_SENSORS state");
        state = CHECK_RAIL_SENSORS;
      }
      break;
    case CHECK_RAIL_SENSORS:
       lcd.setCursor(0,0);
       lcd.print("Checking Rails  ");
       Serial.println(RsensorState);       
       // Подождите, пока датчики не заблокируются, чтобы перейти в следующее состояние
      if(RsensorState == BOTH_RSENSORS_LOW)
      {
        Serial.println("Going to SAFETY_WINDOW state");
        state = SAFETY_WINDOW;
      }
      break;
    case SAFETY_WINDOW:
        lcd.setCursor(0,0);
        lcd.print("Wait a second");
      if(inputState != BOTH_BUTTONS_HIGH)
      {
// Во время окна безопасности была отпущена кнопка.
// Возврат в режим ожидания.
        Serial.println("Going to WAIT_FOR_BOTH_LOW state");
        digitalWrite(RelayPin, LOW);  // Выключить RelayPin
        digitalWrite(IndicatorPin, LOW); // Выключить IndicatorPin
        digitalWrite(RelayPin3, LOW);  // Выключить RelayPin3
        digitalWrite(IndicatorPin5, LOW); // Выключить IndicatorPin5
        state = WAIT_FOR_BOTH_LOW;        
      }
      else if(currentMillis - previousMillis >= PushSafetyWindow)
      {
// Кнопки все еще нажаты.
// Временное окно достигло конца.
// Приготовьтесь перейти к следующему состоянию.
        Serial.println("Going to RELAY_ON state");
        previousMillis = currentMillis;
        digitalWrite(RelayPin, HIGH);  // Включить RelayPin
        digitalWrite(IndicatorPin, HIGH); // Включить IndicatorPin
        state = RELAY_ON;
      }
      break;
    case RELAY_ON:
        lcd.setCursor(0,0);
        lcd.print("Relay Engaged   ");
      if(inputState != BOTH_BUTTONS_HIGH)
      {
// Одна из кнопок была отпущена.
// Остановите реле и вернитесь в режим ожидания.
// Хотя реле и сработало, оно не сработало.
        failed++;
        Serial.print("Failed=");
        Serial.println(failed);
        Serial.println("Going to WAIT_FOR_BOTH_LOW state");
        digitalWrite( RelayPin, LOW);  // Выключить RelayPin
        digitalWrite(IndicatorPin, LOW); // Выключить IndicatorPin
        digitalWrite(RelayPin3, LOW);  // Выключить RelayPin3
        digitalWrite(IndicatorPin5, LOW); // Выключить IndicatorPin5
        state = WAIT_FOR_BOTH_LOW;
      }
      else if(currentMillis - previousMillis >= RelayOnTime)
      {
        // Всё было хорошо.
        // Кнопки все еще нажаты.
        // Он был завершен и успешен.
        // Пришло время отключить реле и вернуться в режим ожидания.
        success++;
        Serial.print("Success=");
        Serial.println(success);
        Serial.println("Going to CLEAR_SENSORS state");
        lcd.setCursor(0,1);
        lcd.print("Cycles ");
        lcd.print(success);
        digitalWrite(RelayPin, LOW);  // Выключить RelayPin
        digitalWrite(IndicatorPin, LOW); // Выключить IndicatorPin
        digitalWrite(RelayPin3, LOW);  // Выключить RelayPin3
        digitalWrite(IndicatorPin5, LOW); // Выключить IndicatorPin5
        state = CLEAR_SENSORS;
      }
      break;
    default:
        Serial.println("Error, unknown state");
      break;
    }
}


// Эта функция возвращает состояние ввода.
// StateChangeDetection отсутствует, поскольку используется конечный автомат.
  int getInputState()
{
  int returnInputState;

// Считываем состояние дребезга и создаем входное состояние в соответствии со значениями 'enum'.
  int value1 = debouncer1.read();
  int value2 = debouncer2.read();

    if(value1 == LOW && value2 == LOW)
    {
      returnInputState = BOTH_BUTTONS_LOW;
    }
    else if(value1 == HIGH && value2 == HIGH)
    {
      returnInputState = BOTH_BUTTONS_HIGH;
    }
    else
    {
    // Не оба включены, не оба выключены, значит, это что-то другое.
    returnInputState = ONE_BUTTON_HIGH;
    }

  return(returnInputState);
}

 // Эта функция возвращает состояние датчиков 1 и 2
  int getSensorState()
{
  int returnSensorState;

// Считываем состояния датчиков и создаем входное состояние
  int value3 = debouncer3.read();
  int value4 = debouncer4.read();

    if(value3 == HIGH && value4 == HIGH)
    {
      returnSensorState = BOTH_SENSORS_HIGH;
    }
    else if(value3 == HIGH && value4 == LOW)
    {
      returnSensorState = SENSOR1_HIGH_SENSOR2_LOW;
    }
    else if(value4 == HIGH && value3 == LOW)
    {
      returnSensorState = SENSOR2_HIGH_SENSOR1_LOW;
    }
    else
    {
      returnSensorState = BOTH_SENSORS_LOW;
    }
  return(returnSensorState);
}

 // Эта функция возвращает состояние датчиков 3 и 4
  int getRSensorState()
{
  int returnRSensorState;

// Считываем состояния датчиков и создаем входное состояние
  int value5 = debouncer5.read();
  int value6 = debouncer6.read();

  if(value5 == LOW && value6 == LOW)
    {
      returnRSensorState = BOTH_RSENSORS_LOW;
    }
    else if(value5 == HIGH && value6 == LOW)
    {
      returnRSensorState = SENSOR3_HIGH_SENSOR4_LOW;
    }
    else if(value6 == HIGH && value5 == LOW)
    {
      returnRSensorState = SENSOR4_HIGH_SENSOR3_LOW;
    }
    else
    {
      returnRSensorState = BOTH_RSENSORS_HIGH;
    }
  return(returnRSensorState);
}

Больше всего меня беспокоит вот это состояние:

case CHECK_RAIL_SENSORS:
   lcd.setCursor(0,0);
   lcd.print("Checking Rails  ");
   Serial.println(RsensorState);       
   // Подождите, пока датчики не заблокируются, чтобы перейти в следующее состояние
  if(RsensorState == BOTH_RSENSORS_LOW)
  {
    Serial.println("Going to SAFETY_WINDOW state");
    state = SAFETY_WINDOW;
  }
  break;

Это может быть связано с тем, как приобретается состояние датчика. Я использую Bounce2 для устранения дребезга входов.

 // Эта функция возвращает состояние датчиков 3 и 4
  int getRSensorState()
{

  int returnRSensorState;

// Считываем состояния датчиков и создаем входное состояние
  int value5 = debouncer5.read();
  int value6 = debouncer6.read();

  if(value5 == LOW && value6 == LOW)
    {
      returnRSensorState = BOTH_RSENSORS_LOW;
    }
    else if(value5 == HIGH && value6 == LOW)
    {
      returnRSensorState = SENSOR3_HIGH_SENSOR4_LOW;
    }
    else if(value6 == HIGH && value5 == LOW)
    {
      returnRSensorState = SENSOR4_HIGH_SENSOR3_LOW;
    }
    else
    {
      returnRSensorState = BOTH_RSENSORS_HIGH;
    }
  return(returnRSensorState);
}

Любой вклад будет высоко оценен! Пожалуйста, дайте мне знать, если нужны дополнительные разъяснения.

Редактировать 07/12/18

ЕСЛИ вы используете этот код, не забудьте обновить этот раздел, чтобы он заработал! Полный, исправленный код слишком большой для публикации:

// Обновите экземпляры Bounce
  debouncer1.update();
  debouncer2.update();
  debouncer3.update();
  debouncer4.update();
  debouncer5.update();
  debouncer6.update();