Одновременное чтение кнопки?

Я думаю, вы хотите, чтобы через случайное время загорелся светодиод «Старт», и тот, кто первым нажмет кнопку, побеждает.

В вашем скетче есть некоторые проблемы:

• Кажется, даже если кнопка нажимается слишком рано, она все равно учитывается. Вы должны проверить этот «обман». Поэтому сразу после того, как загорится светодиод «Пуск», проверьте, не нажаты ли какие-либо кнопки. Если это так, этот игрок проигрывает.
• Предполагая, что игроки честны, вы проверяете их кнопки, которые, вероятно, в первую итерацию не будут нажаты (это будет немедленная скорость реакции). Однако, чем вы ждете 5 секунд; вероятно, оба игрока нажали свои кнопки, и вы сначала проверяете кнопку первого игрока. Поможет, если вы измените задержку на 1 мс, а то и вовсе уберете.

Непроверенное предложение:

int playerXWon = 0; // Еще ни один игрок не выиграл, 1 = игрок 1 выиграл, 2 = игрок 2 выиграл, 3 = ничья

void loop() 
{ 
   // Задержка на случайное время.
   P1_Time = random(2000, 5000);
   delay(P1_Time);

   CheatCheck();

   if (playerXWon == 0)
   {
      // Начинать
      digitalWrite(P1_Pin, HIGH); 

      checkFirstPress(); 
   }
}

void CheatCheck()
{
   // Проверяем, не нажал ли игрок свою кнопку слишком рано.
   // (Кстати, не имеет значения, если игрок нажмет и отпустит кнопку до того, как загорится светодиод.
   S1_State = digitalRead(S1_Pin);
   S2_State = digitalRead(S2_Pin);

   if (S1_State == HIGH)
   {
      else if (S2_State == HIGH) 
      {
         PlayerWin(3);
      }
      else 
      {
         PlayerWin(2);
      }
   }
   else 
   {
      if (S2_State == HIGH) 
      {
         PlayerWin(1);
      }
   }
}

void checkFirstPress() 
{
   // Выигрывает тот, кто нажмет первым.
   while (playerXWon == 0) 
   {
      S1_State = digitalRead(S1_Pin);
      S2_State = digitalRead(S2_Pin);  

      if (S1_State == HIGH) 
      {
         if (S2_State == HIGH) 
         {
            PlayerWin(3);
         }
         else if (S1_State == HIGH) 
         {
            PlayerWin(1);
         }
      } 
      else if (S2_State == HIGH)
      {
         PlayerWin(2);
      }
   }
}

void playerWins(int player)
{
   switch (player) 
   {
   case 1:
      Serial.print("Player 1 wins\n");
      break;

   case 2:
      Serial.print("Player 2 wins\n");
      break;

   case 3:
      Serial.print("Both players win\n");
      break;

    default:
       assert(NULL); // Ошибка программирования
       break;
   }

   playerXWon = player;

   digitalWrite(P1_Pin, LOW);
}

Вместо использования функции digitalRead() высокого уровня доступ к регистрам порта низкого уровня. См. эту документацию.

Регистр порта состоит из одного байта, и каждый бит представляет собой один из цифровых входов Arduino.

Сделайте что-то вроде этого:

pin_status = PIND; //Входной порт D (контакты 0-7)
button_1 = bitRead(pin_status, 2); // цифровой контакт 2
button_2 = bitRead(pin_status, 3); // цифровой контакт 3

Значения считываются одновременно, поэтому возможно совпадение.

Я не был уверен, стоит ли публиковать это как ответ, поскольку в основном это еще несколько соображений по трем существующим ответам (для справки, это ответ Мишеля Кейзерса - с использованием digitalRead -, ответ Крейга - сразу прочитать переменную PIND - , Филипа Франика - использовать прерывания), но получилось довольно длинно и в один комментарий все это не уместилось.

То, что написали вы и другие респонденты, теоретически верно. Проверка кнопки игрока 1 перед игроком 2 дает преимущество игроку 1. Чего вам не хватает, так это... Сколько преимуществ?

Длительность механических действий (таких как нажатие кнопки) составляет около 50 мс*.

Поскольку я предполагаю, что ваше приложение предназначено для проверки времени реакции, время реакции человека составляет около 250 мс.

Кроме того, механические кнопки имеют "дребезги". Типичное время устранения дребезга находится в диапазоне 20-100 мс. Этого можно избежать, просто проверив первое ребро.

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

_* Я пытался найти источник для этого, но мне не удалось получить некоторые данные. Я пробовал с онлайн-секундомером и примерно одновременно нажимал две клавиши пробела (ноутбук и USB-клавиатура), получая результаты около 75 мс. Это не реальное значение, поэтому, если у кого-то есть измеренные значения или оценки, не стесняйтесь комментировать

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

В случае digitalRead вы выполняете следующую серию действий:

1. Чтение состояния контакта 1 – 3,6 мкс.
2. Чтение состояния контакта 2 – 3,6 мкс.
3. Проверить статусы и решить, кто выиграл - несколько десятков инструкций (около 1us)
4. Цикл — пара инструкций (0,5 мкс)

60 инструкций взяты из этой темы (3,6 мкс = 57,8 инструкций на частоте 16 МГц); что касается других, это грубое измерение. Давайте предположим, что функция на самом деле производит выборку вывода в самом конце функции.

Теперь, поскольку вы проверяете ничью, если обе кнопки будут нажаты во время фаз 3, 4 или 1, вы получите ничью (поскольку обе кнопки будут считаться нажатыми). Если обе кнопки будут нажаты во время фазы 2, кнопка 2 будет помечена как нажатая, а кнопка 1 — нет, что дает преимущество этому игроку. Время, когда это происходит, составляет около 3,6 мкс. Таким образом, вы даете игроку с баттоном 2 преимущество в 3,6 мкс.

В случае PIND вы считываете кнопки точно в одно и то же время. Таким образом, преимущество равно 0.

В случае прерывания, когда прерывания EXT0 и EXT1 запускаются одновременно, выполняется EXT0, так как это было раньше в ISR. Следовательно, игрок, нажимающий кнопку на EXT0, имеет преимущество в один цикл проверки прерывания. Я признаю, что не знаю, как часто входы проверяются на прерывание EXT, но я предполагаю, что проверка выполняется каждый такт (следовательно, преимущество составляет 62,5 нс).

А теперь суммируем преимущества

• цифровое чтение: 3,6 мкс
• Вывод: 0
• прерывание: 62,5 нс

Решение для меня довольно очевидное, и оно... Плевать! Даже в худшем случае вы на четыре порядка быстрее своего феномена. Вы даете одному игроку преимущество в 4 мс в игре 250 мс (0,0016% преимущества). Я почти уверен, что механические различия между двумя кнопками (возможно, одна из них немного жестче, или имеет немного больший размер, или имеет немного более низкий контакт) влияют на чтение гораздо больше, чем это.

В конце концов, с такой настройкой вы сможете получить точность, не превышающую несколько десятков миллисекунд. С другими настройками измерения (возможно, оптическими) вы можете снизить время до 1 мс. Добавление 4us преимущества одному игроку не повлияет на результат.

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

ПРИМЕЧАНИЕ. Это основано на предположении, что разработана надлежащая программа с проверкой совпадений, без задержек и т. д. Программа, как вы написали в вопросе, не в порядке с этой точки зрения (как сейчас, она останется в цикле навсегда; если вы измените Sx_State на digitalRead, это станет примерно справедливым - что-то вроде 4us преимущества для первого игрока и 3,8us преимущества для второго игрока)

Здесь я должен согласиться с frarugi87. Несколько микросекунд, затраченных digitalRead() совершенно не важны для вашего приложения. Но позвольте мне добавить, что даже если бы ваши игроки были сверхлюдьми, способными время реакции менее миллисекунды, вы не даете преимущества ни одному из них, если вы попеременно отметите кнопку 1, затем кнопку 2, затем кнопку 1 и так далее. Причина в том, что в малое время окно между кнопкой чтения 1 и кнопкой чтения 2, вы даете преимущество для игрока 2: он выиграет, если будут нажаты обе кнопки одновременно. В следующем временном окне (между проверкой кнопка 2 и кнопка 1) такое же преимущество игрок 1.

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

Вот как я бы определил победителя. Я думаю, что этот код ясно что мы попеременно проверяем кнопку 1, затем кнопку 2, затем кнопка 1...

int find_winner()
{
    for (;;) {
        if (digitalRead(S1_Pin) == HIGH)
            return 1;
        if (digitalRead(S2_Pin) == HIGH)
            return 2;
    }
}