"Génies en Herbe" / "Reach for the Top" Game Machine

1// Program:      GeniesEnHerbe.ino
2// Author:       Vincent Fortin
3//  Contact:      vincent.fortin@gmail.com
4// License:      GNU GPL version 3 (https://www.gnu.org/licenses/gpl-3.0.html)
5//  Purpose:      Use Arduino Mega board to build a quiz game machine
6//               for  the "Genies en Herbe" high-school game
7//               See https://en.wikipedia.org/wiki/G%C3%A9nies_en_herbe
8//
9//  Changelog:    2019-08-02 Initial version, Vincent Fortin (vincent.fortin@gmail.com)
10//
11//  Behaviour:    The quiz machine helps determine which player and which team answers  the fastest
12//               to a question by pushing a buzzer. Each player has  his own buzzer (push-button),
13//               to which a LED is associated.  The purpose of the machine is to determine which
14//               player answers  first, by lighting up the LED associated with the buzzer being
15//               pushed  first, and by making a sound. When a buzzer is pushed, the other buzzers
16//               are  deactivated. The buzzers can be re-activated by a reset button operated by
17//               the referee. When the buzzers are activated, a green light is lit.  There is a
18//               timer after which the buzzers are re-activated if  the referee does not push the
19//               reset button. The duration of  the timer is determined by a potentiometer. If
20//               the potentiometer  is set to its maximum value, then the buzzer must be
21//               re-activated  by the referee (there is no time limit).
22//
23// Known issues: 1) The buttons  take time to "warm up" (up to 35 seconds). A delay has been
24//                  added  during startup to deal with this issue.
25//               2) Software button debouncing  takes a long time (500 milliseconds)
26//               3) Buttons are polled in  the same order each time, which will favor
27//                  a player over  another if two players hit their buzzer at the same time
28//               4)  Code has only been tester for two teams and one player per team so far
29
30/*
31    This program is free software: you can redistribute it and/or modify
32    it  under the terms of the GNU General Public License as published by
33    the Free  Software Foundation, either version 3 of the License, or
34    (at your option)  any later version.
35
36    This program is distributed in the hope that it will  be useful,
37    but WITHOUT ANY WARRANTY; without even the implied warranty of
38    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
39    GNU General  Public License for more details.
40
41    You should have received a copy of the  GNU General Public License
42    along with this program.  If not, see <https://www.gnu.org/licenses/>
43*/
44
45/*****************/
46/*  CONFIGURATION */
47/*****************/
48
49/*
50 * Number of teams and number  of players per team
51 */
52
53// Configure the number of teams and number of  players per team
54// Normally there are two teams and four players per team
55const  int numTeams = 2;
56const int numPlayers = 1; // 1 player per team for the prototype
57//  **TODO** CHANGE TO FOUR PLAYERS PER TEAM FOR THE FINAL VERSION
58
59/*
60 * Speaker
61  */
62
63// Assign a pin number to the speaker and configure the sound
64const  int pinSpeaker = 6;
65const int frequencySpeaker = 440; // Hz
66const int durationSpeaker  = 500; // milliseconds
67
68/*
69 * Delay before reset
70 */
71
72// Assign  a pin number to the potentiometer used to determine the delay after a buzz before  reset
73// and define maximum delay
74const int pinDelay = 0;
75const unsigned  long delayResetMax = 5000; // maximum delay in milliseconds (scaled by potentiometer  read)
76
77/*
78 * Delay before the quiz machine starts
79 */
80
81// Startup  delay to let the buttons warm up (I don't understand why this is needed!!!)
82const  unsigned long startupDelay = 35000; // milliseconds
83
84/*
85 * Minimum time  during which a button must be pushed
86 */
87
88// Debounce delay to filter out  flickers of button states
89const unsigned long debounceDelay = 500;    // the  debounce time for buttons in milliseconds
90
91/* 
92 * Attributes associated  with each button / buzzer
93 */
94
95// Define structure for standard button
96struct  Button {
97  int pinButton;        // pin number of the pushbutton
98  int pinLED;           // pin number of the associated LED
99  int buttonState;      // last  stable state of the button (after filtering)
100  int lastButtonState;  // last  known state of the button (including flickers)
101  int lastDebounceTime; // last  time the button flickered (for debounce purposes)
102}; 
103
104/*
105 * Configuration  of each button
106 * SET THE PIN NUMBERS CORECTLY BASED ON HOW YOUR ARDUINO BOARD  IS WIRED)
107 */
108
109// Define each button by their pin numbers (for the button  and the LED) and initial state
110struct Button buzzers[numTeams][numPlayers] =  {{{2,4,LOW,LOW,0}},{{3,5,LOW,LOW,0}}};
111struct Button whiteButton = {7,8,LOW,LOW,0};
112static  int pinGreenLED; // will be set to the pinLED attribute of the white button
113
114//  Initial setup
115void setup() {
116  // Loop through each buzzer and initialize  the associated button and LED (in particular, set the pin mode)
117  int team,player;
118  for (team=0; team<numTeams; team++) {
119    for (player=0; player<numPlayers;  player++) {
120      pinMode(buzzers[team][player].pinLED, OUTPUT);
121      pinMode(buzzers[team][player].pinButton,  INPUT_PULLUP);
122      digitalWrite(buzzers[team][player].pinLED, LOW);
123    }
124  }
125  // Set the pin mode to OUTPUT for the speaker
126  pinMode(pinSpeaker,  OUTPUT);
127  // Set the pin mode to OUTPUT for the green LED
128  pinGreenLED =  whiteButton.pinLED;
129  pinMode(pinGreenLED, OUTPUT);
130  // Set the pin mode  to INPUT for the white button
131  pinMode(whiteButton.pinButton, INPUT_PULLUP);
132  // Wait for the buttons to warm up! (don't know why they need time before they  start working...)
133  delay(startupDelay); 
134  // Light up the green LED to tell  players that the quiz machine is working
135  digitalWrite(pinGreenLED, HIGH);
136}
137
138void  loop() {
139  /* 
140   * Local variables
141   */
142  // Iterators
143  int team,  player;
144  // Identification of the winning team and player
145  int teamBuzz,  playerBuzz;
146  // Variables used to determine the delay before the reset of the  buzzers
147  int valPot;     // value of the potentiometer, between 0 and 1023
148  int delayReset; // delay obtained by rescaling the value of the potentiometer
149  // Boolean indicating if a buzzer was activated
150  bool someoneBuzzed;
151  //  Timestamp used to determine how much time has passed since a buzzer was activated
152  unsigned long timestamp;
153  /* 
154   *  Start of the loop
155   */
156  //  Determine if somebody has buzzed by scanning all the buzzers
157  someoneBuzzed  = false;
158  for (team=0; team<numTeams; team++) {
159    for (player=0; player<numPlayers;  player++) {
160      if (readButtonState(buzzers[team][player]) == HIGH) {
161        //  A buzzer is activated: set the flag, keep track of which buzzer is activated and  exit inner loop
162        someoneBuzzed = true;
163        teamBuzz = team;
164        playerBuzz = player;
165        break;
166      }
167    }
168    // A buzzer  is activated: exit outer loop
169    if (someoneBuzzed) {
170      break;
171    }
172  }
173  // Do this when someone activates his buzzer
174  if (someoneBuzzed) {
175    // turn off the green LED
176    digitalWrite(pinGreenLED, LOW);
177    // turn  on the LED associated with the buzzer which was activated
178    digitalWrite(buzzers[teamBuzz][playerBuzz].pinLED,  HIGH);
179    // play a sound
180    tone(pinSpeaker, frequencySpeaker, durationSpeaker);
181    // read the value of the potentiometer to determine the duration of the delay  before the reset
182    // a value between 0 and 1023 is obtained
183    valPot  = analogRead(pinDelay);
184    // If the value read is higher than 1000, set it  to minus one.
185    // This value will be used as a flag meaning that the white  button must be pushed to reset the quiz machine.
186    if (valPot > 1000) {
187      valPot = -1; // quiz machine must be reset manually by the referee
188    }
189    // Obtain the delay by scaling the value read from the potentiometer by the  maximum delay
190    // Negative delays mean that the reset must be done manually
191    delayReset = valPot*delayResetMax/1000;
192    // Wait for the end of the delay  before doing a reset
193    timestamp = millis();
194    while ((delayReset < 0)  || millis() - timestamp < delayReset) {
195      // The delay has not ended: check  if white button is pushed by the referee
196      if (readButtonState(whiteButton)  == HIGH) {
197        // White button is pushed: reset the quiz machine before the  end of the delay
198        break;
199      }  
200    }
201    // End of the delay  or white button pushed: reset the quiz machine
202    // Turn on the green LED
203    digitalWrite(pinGreenLED, HIGH);
204    // Turn off the LED of the buzzer which  was activated
205    digitalWrite(buzzers[teamBuzz][playerBuzz].pinLED, LOW);
206  }
207  // end of the loop: go back to the beginning!
208}
209
210// Read the state  of a button (ensure that the button is pushed for a long enough time to deal with  bouncing)
211// Input:  button structure
212// Output: state of the button (LOW  or HIGH)
213int readButtonState(Button button)
214{
215  // read the state of the  switch into a local variable:
216  int reading = digitalRead(button.pinButton);
217
218  // check to see if you just pressed the button
219  // (i.e. the input went from  LOW to HIGH), and you've waited long enough
220  // since the last press to ignore  any noise:
221
222  // If the switch changed, due to noise or pressing:
223  if  (reading != button.lastButtonState) {
224    // reset the debouncing timer
225    button.lastDebounceTime  = millis();
226  }
227  
228  if ((millis() - button.lastDebounceTime) > debounceDelay)  {
229    // whatever the reading is at, it's been there for longer than the debounce
230    // delay, so take it as the actual current state:
231    button.buttonState  = reading;
232  }
233
234  // Save last reading of the button state (including flickers)
235  button.lastButtonState = reading;
236
237  // Return last stable state of the  button
238  return button.buttonState;
239}