Étape 5: Télécharger
//Cette esquisse implémente un tie-break de réponse « Jeopardy » style candidat à l’investiture.
//
Chaque participant dispose d’un commutateur de bouton poussoir.
Après l’installation, la fonction waitingForQuestion est appelée. Cet exemple utilise un
boucle locale, plutôt que la boucle de l’Arduino, à attendre que le modérateur
pour commencer. En attendant, les lumières de joueur sont allumées en mode chase.
Quand l’animateur appuie sur l’interrupteur bouton S6, la QUESTION_READING
État commence. Il n’y a aucune limite de temps ici. Dans cette phase le joueur
LED s’allume en mode chase. Pendant ce temps, si une joueur touche est
pressé, une pénalité de 0,25 secondes est appliquée pour la phase suivante. Quand
l’animatrice appuie sur le bouton interrupteur S5 et le libère, le
READY_FOR_ANSWER_LIGHT est activée, le lecteur LED s’éteint et
le jeu va procéder à l’État WAITING_FOR_RING_IN.
Dans WAITING_FOR_RING_IN, la READY_FOR_ANSWER_LIGHT est
enluminés. Il y a un délai d’attente du deuxième cinq qui, à son expiration,
provoque le jeu à resetAll pour effacer des variables, la waitingForQuestion
fonction est appelée et le passage à QUESTION_READING. Quand
un joueur appuie sur un bouton, si le joueur n’est pas bloqué par un avant
mauvaise réponse et aucun délai imposé dans la phase QUESTION_READING,
s’allume de ce joueur et READY_FOR_ANSWER_LIGHT est désactivé.
Le jeu passe à l’État WAITING_FOR_ANSWER.
En WAITING_FOR_ANSWER, après un délai de cinq deuxième ou
un joueur qui donne une mauvaise réponse, le jeu passe à
WAITING_FOR_RING_IN, si il y a des joueurs non encore bourdonnaient dans. Si un
joueur donne une réponse correcte ou tous les joueurs ont tenté de répondre,
resetAll efface variables, la fonction waitingForQuestion est appelée
et l’État devient QUESTION_READING.
//
Remarque : Ce programme est mis en place pour gérer jusqu'à quatre joueurs. S’il y en a moins
les joueurs, il se chargera d’eux, bien que quand les joueurs ont sonné et
ont mal répondu, le programme n’expire, au lieu d’immédiatement
reconnaissant qu’il n’y a pas de joueurs restants. Pour les trois traditionnels
les puristes de joueur ou ceux qui ne peuvent pas attendre les cinq secondes supplémentaires, MAX_PLAYERS
peut être remplacé par trois et le programme recompilied et téléchargées. Il sera ensuite
reconnaîtra que les joueurs un à trois.
2012.12.18 version initiale.
/*
* Définitions de l’environnement
*/
#define MAX_PLAYERS 4
#define TIMEOUT_PERIOD 5000
#define DELAY_TIME 250
#define NO_ANSWER 0
#define CORRECT_ANSWER 1
#define WRONG_ANSWER -1
/*
* Définitions hardware
*/
#define TOP_LED 13
#define TOP_SWITCH 9
Le CORRECT_ANSWER_BUTTON est commutateur S6
#define CORRECT_ANSWER_BUTTON 3
Le WRONG_ANSWER_BUTTON est passer S5
#define WRONG_ANSWER_BUTTON 4
#define READY_FOR_ANSWER_LIGHT 5
/*
* Définitions de ménage
*/
int buzzedInPlayer = -1 ;
int buzzedInPlayerCount = 0 ;
unsigned long timeout = 0 ;
int blockedPlayers = 0 ;
Modérateur int ;
char ESC_CHAR = 27 ;
#define PUT_CURSOR_MIDSCREEN\
Serial.Print (ESC_CHAR); \
Serial.Print ("[2J"); \
retard (2); \
Serial.Print (ESC_CHAR); \
Serial.Print("[10;1H") ;
/*
* Définitions de presse bouton
*/
#define NOT_PUSHED haute
#define poussé bas
#define bloqué -1
/*
* Définitions d’état LED
*/
#define LED_ON haute
#define LED_OFF faible
/*
* Jeu États
*/
#define QUESTION_READING 1
#define WAITING_FOR_RING_IN 2
#define WAITING_FOR_ANSWER 3
phase d’int = QUESTION_READING ;
#define DEBOUNCE_TIME 10
struct player_t {}
int lumière ;
int buttonPin ;
bouton int ;
timePenalty non signé ;
} End;// struct playerStruct_t
struct player_t joueur [MAX_PLAYERS] ;
Réinitialiser le temps de joueur.
Sub resetPlayerTime()
{
int i ;
pour (i = 0; i < MAX_PLAYERS; i ++)
{
lecteur [i] .timePenalty = 0 ;
};
} / / Fin resetAll
Rétablir l’état initial.
Sub resetAll()
{
int i ;
Modérateur = NO_ANSWER ;
phase = QUESTION_READING ;
pour (i = 0; i < MAX_PLAYERS; i ++)
{
digitalWrite (joueur [i] .light, LED_OFF) ;
touche lecteur [i] = NOT_PUSHED ;
resetPlayerTime() ;
};
buzzedInPlayer = -1 ;
buzzedInPlayerCount = 0 ;
} / / Fin resetAll
int readModerator()
{
Bouton est le déclencheur d’un bouton après avoir été poussé.
Debounce est utilisé pour détecter la version de bouton.
Si (digitalRead(CORRECT_ANSWER_BUTTON) == PUSHED) {}
for(;;) {
Delay(DEBOUNCE_TIME) ;
Si (digitalRead(CORRECT_ANSWER_BUTTON) == NOT_PUSHED) {}
rupture ;
}
}
Return CORRECT_ANSWER ;
} ElseIf (digitalRead(WRONG_ANSWER_BUTTON) == PUSHED) {}
for(;;) {
Delay(DEBOUNCE_TIME) ;
Si (digitalRead(WRONG_ANSWER_BUTTON) == NOT_PUSHED) {}
rupture ;
}
}
Return WRONG_ANSWER ;
} else {}
Return NO_ANSWER ;
}
}
Sub readPlayers()
{
États de tous les boutons du lecteur sont enregistrés dans le tableau du joueur.
int i ;
pour (i = 0; i < MAX_PLAYERS; i ++)
{
Si (touche joueur [i]! = bloqué) {}
Si (digitalRead(player[i].buttonPin) == PUSHED) {}
touche lecteur [i] = PUSHED ;
} else {}
touche lecteur [i] = NOT_PUSHED ;
}
}
}
}
Sub waitingForQuestion()
{
int i ;
digitalWrite (READY_FOR_ANSWER_LIGHT, LED_OFF) ;
Serial.println (« \tModerator, appuyez sur S6 et commencer la lecture") ;
Serial.println (« \tModerator, S5 Appuyez sur lorsque vous avez terminé la Question") ;
tandis que (! () readModerator() == CORRECT_ANSWER)) {}
pour (i = 0; i < MAX_PLAYERS; i ++) {}
digitalWrite (joueur [i] .light, LED_ON) ;
Delay(250) ;
digitalWrite (joueur [i] .light, LED_OFF) ;
}
}
PUT_CURSOR_MIDSCREEN
Serial.println (« \tPlayers, attendez la question à la fin") ;
}
void setup()
{
int i ;
pour (i = 0; i < MAX_PLAYERS; i ++) {}
Assigner les LEDs, cathodes raccordés à la terre
.light joueur [i] = TOP_LED - i ;
pinMode (joueur [i] .light, sortie) ;
Assigner les commutateurs de bouton poussoir ; Raccorder l’entrée à la terre au moment où il est fermé.
lecteur [i] .buttonPin = TOP_SWITCH - i ;
pinMode (joueur [i] .buttonPin, entrée) ;
digitalWrite (joueur [i] .buttonPin, HIGH) ; Activez pullup
}
pinMode (READY_FOR_ANSWER_LIGHT, sortie) ;
pinMode (entrée, WRONG_ANSWER_BUTTON) ;
digitalWrite (WRONG_ANSWER_BUTTON, élevé) ; Activez pullup
pinMode (entrée, CORRECT_ANSWER_BUTTON) ;
digitalWrite (CORRECT_ANSWER_BUTTON, élevé) ; Activez pullup
resetAll() ;
Serial.Begin(9600) ; mettre en place une bibliothèque série à 9600 bps
PUT_CURSOR_MIDSCREEN
waitingForQuestion() ;
}
void loop()
{
int i ;
interrupteur (phase) {}
case QUESTION_READING: {}
Modérateur a appuyé sur le bouton de réinitialisation
ou l’en question a été answeredd
ou tous les joueurs ont répondu correctement.
Aucun calendrier pour cette phase.
Aucun Buzz-ins souffriront 0,25 seconde de délai lors de l’état suivant est entré.
readPlayers() ;
Appliquer la sanction pour les presseurs bouton désireux
pour (i = 0; i < MAX_PLAYERS; i ++) {}
Si ((touche joueur [i] == PUSHED) & &
(.timePenalty de joueur [i] == 0)) {
lecteur [i] .timePenalty = DELAY_TIME ;
Serial.Print ("\tPlayer") ;
Serial.Print(i+1) ;
Serial.println ("obtient une pénalité") ;
}
}
Modérateur = readModerator() ;
Si (modérateur == WRONG_ANSWER) {}
phase = WAITING_FOR_RING_IN ;
Timeout = millis() + TIMEOUT_PERIOD ;
digitalWrite (READY_FOR_ANSWER_LIGHT, LED_ON) ;
pour (i = 0; i < MAX_PLAYERS; i ++) {}
lecteur [i] .timePenalty += millis() ;
}
PUT_CURSOR_MIDSCREEN
Serial.println ("\tWaiting pour anneau dans") ;
Serial.println() ;
blockedPlayers = 0 ;
}
rupture ;
} / / Fin de cas QUESTION_READING
case WAITING_FOR_RING_IN: {}
Modérateur a appuyé sur le bouton tout en état QUESTION_READING.
Cinq secondes pour cette phase.
Si (blockedPlayers > = MAX_PLAYERS) {}
PUT_CURSOR_MIDSCREEN
Serial.println ("\tAll joueurs ont sonné dans") ;
Serial.println (« \tModerator, veuillez lire la Question suivante") ;
phase = QUESTION_READING ;
resetAll() ;
waitingForQuestion() ;
rupture ;
} else {}
buzzedInPlayer = -1 ;
Si (timeout > = {millis())}
readPlayers() ;
pour (i = 0; i < MAX_PLAYERS; i ++) {}
Si ((joueur [i] .timePenalty < = millis()) & &
touche lecteur [i] == PUSHED) {}
buzzedInPlayer = i ;
buzzedInPlayerCount += 1 ;
digitalWrite (.light joueur [buzzedInPlayer], LED_ON) ;
digitalWrite (READY_FOR_ANSWER_LIGHT, LED_OFF) ;
phase = WAITING_FOR_ANSWER ;
Timeout = millis() + TIMEOUT_PERIOD ;
touche lecteur [i] = bloqué ;
blockedPlayers += 1 ;
PUT_CURSOR_MIDSCREEN
Serial.Print ("nombre de \tPlayer") ;
Serial.println(i+1) ;
}
}
} else {}
Serial.println (« \tTimed out waiting for un RING_IN") ;
Serial.println (« \tModerator, veuillez lire la Question suivante") ;
phase = QUESTION_READING ;
resetAll() ;
waitingForQuestion() ;
rupture ;
}
rupture ;
} / / Fin d’autre
} / / Fin de cas WAITING_FOR_RING_IN
case WAITING_FOR_ANSWER: {}
Un joueur a appuyé sur le bouton en état WAITING_FOR_RING_IN.
Cinq secondes pour cette phase.
Si (timeout < millis()) {}
Si (buzzedInPlayerCount < = MAX_PLAYERS) {}
PUT_CURSOR_MIDSCREEN
Serial.println("\tWAITING_FOR_RING_IN") ;
Timeout = millis() + TIMEOUT_PERIOD ;
digitalWrite (.light joueur [buzzedInPlayer], LED_OFF) ;
digitalWrite (READY_FOR_ANSWER_LIGHT, LED_ON) ;
phase = WAITING_FOR_RING_IN ;
PUT_CURSOR_MIDSCREEN
Serial.Print ("nombre de \tPlayer") ;
Serial.Print(buzzedInPlayer+1) ;
Serial.println ("timed out en attente d’une réponse") ;
}
}
Modérateur = readModerator() ;
Si (modérateur == CORRECT_ANSWER) {}
digitalWrite (.light joueur [buzzedInPlayer], LED_OFF) ;
PUT_CURSOR_MIDSCREEN
Serial.Print ("nombre de \tPlayer") ;
Serial.Print(buzzedInPlayer+1) ;
Serial.println (", c’est exact") ;
Serial.println (« \tModerator, veuillez lire la Question suivante") ;
phase = QUESTION_READING ;
resetAll() ;
waitingForQuestion() ;
} else
Si (modérateur == WRONG_ANSWER) {}
phase = WAITING_FOR_RING_IN ;
Timeout = millis() + TIMEOUT_PERIOD ;
digitalWrite (.light joueur [buzzedInPlayer], LED_OFF) ;
digitalWrite (READY_FOR_ANSWER_LIGHT, LED_ON) ;
Serial.println (« \tOooo, Désolé, c’est mal ») ;
Serial.println ("\tWaiting pour anneau dans") ;
resetPlayerTime() ;
}
rupture ;
} / / Fin de cas WAITING_FOR_ANSWER
par défaut: {}
Serial.Print ("par défaut : phase =") ;
Serial.println(phase) ;
}
} / / Fin interrupteur (phase)
}
