Paso 5: subir
//Este bosquejo implementa un "Peligro" estilo concursante respuesta de desempate.
//
Cada concursante tiene un interruptor pulsador.
Después de la instalación, se invoca la función waitingForQuestion. Esto utiliza un
bucle local, en lugar de en el bucle de Arduino, a esperar a que el moderador
para empezar. Mientras espera, se iluminan las luces del reproductor en modo chase.
Cuando el moderador presiona el interruptor de botón del S6, el QUESTION_READING
Estado comienza. No hay tiempo límite aquí. En esta fase el jugador
LED se encenderá en modo chase. Durante este tiempo, si es un botón del reproductor
presionado, se aplica una penalización de 0,25 segundos para la siguiente fase. Cuando
el moderador presiona el botón del interruptor S5 y suelta, el
READY_FOR_ANSWER_LIGHT se enciende, jugador LED se apaga y
el juego se procederá al estado WAITING_FOR_RING_IN.
En WAITING_FOR_RING_IN, la READY_FOR_ANSWER_LIGHT es
iluminados. Hay cinco segundo tiempo de espera que, a su vencimiento,
hace el juego a resetAll para borrar las variables, el waitingForQuestion
se invoca la función y el estado cambia a QUESTION_READING. Cuando
un jugador presiona un botón, si el jugador no está bloqueado de un antes de
respuesta incorrecta y cualquier tiempo de retardo se impusieron en la fase QUESTION_READING,
se ilumina el del jugador y READY_FOR_ANSWER_LIGHT se apaga.
El juego procede al estado WAITING_FOR_ANSWER.
En WAITING_FOR_ANSWER, después de un tiempo de espera segundos cinco o
un jugador da una respuesta incorrecta, el juego procede a
WAITING_FOR_RING_IN, si hay jugadores no zumbó en. Si un
jugador da una respuesta correcta o todos los jugadores han tratado de responder,
resetAll borra las variables, se invoca la función waitingForQuestion
y el estado cambia a QUESTION_READING.
//
Nota: Este programa está configurado para manejar hasta cuatro jugadores. Si hay menos
los jugadores, que manejará, aunque cuando los jugadores han sonado en y
respondió incorrectamente, el programa va fuera de tiempo, en lugar de inmediatamente
Reconociendo que no hay ningún jugadores restantes. Para los tres tradicionales
los puristas del jugador o los que no puede esperar los cinco segundos extras, MAX_PLAYERS
se puede cambiar a tres y el programa recompilied y subido. Será entonces
solo reconocen los jugadores uno a través de tres.
2012.12.18 inicial de lanzamiento.
/*
* Definiciones de entorno
*/
#define MAX_PLAYERS 4
#define TIMEOUT_PERIOD 5000
#define DELAY_TIME 250
#define NO_ANSWER 0
#define CORRECT_ANSWER 1
#define WRONG_ANSWER -1
/*
* Definiciones hardware
*/
#define TOP_LED 13
#define TOP_SWITCH 9
El CORRECT_ANSWER_BUTTON es interruptor S6
#define CORRECT_ANSWER_BUTTON 3
El WRONG_ANSWER_BUTTON es interruptor S5
#define WRONG_ANSWER_BUTTON 4
#define READY_FOR_ANSWER_LIGHT 5
/*
* Definiciones limpieza
*/
int buzzedInPlayer = -1;
int buzzedInPlayerCount = 0;
tiempo de espera largo sin signo = 0;
int blockedPlayers = 0;
Asesor int;
char ESC_CHAR = 27;
#define PUT_CURSOR_MIDSCREEN\
Serial.Print (ESC_CHAR); \
Serial.Print ("[2J"); \
demora (2); \
Serial.Print (ESC_CHAR); \
Serial.Print("[10;1H");
/*
* Definiciones de Presione los botones
*/
#define NOT_PUSHED alta
#define empujado bajo
#define bloqueado -1
/*
* Definiciones de estado LED
*/
#define LED_ON alta
#define LED_OFF baja
/*
* Juego de Estados
*/
#define QUESTION_READING 1
#define WAITING_FOR_RING_IN 2
#define WAITING_FOR_ANSWER 3
fase de int = QUESTION_READING;
#define DEBOUNCE_TIME 10
struct player_t {}
int luz;
int buttonPin;
int tecla;
unsigned timePenalty;
} ;// Fin struct playerStruct_t
struct player_t player [MAX_PLAYERS];
Restablecer el tiempo del jugador.
void resetPlayerTime()
{
int i;
para (i = 0; i < MAX_PLAYERS; i ++)
{
jugador [i] .timePenalty = 0;
};
} / / Fin resetAll
Restablecer el estado inicial.
void resetAll()
{
int i;
Asesor = NO_ANSWER;
fase = QUESTION_READING;
para (i = 0; i < MAX_PLAYERS; i ++)
{
digitalWrite (jugador [i] .light, LED_OFF);
.button jugador [i] = NOT_PUSHED;
resetPlayerTime();
};
buzzedInPlayer = -1;
buzzedInPlayerCount = 0;
} / / Fin resetAll
int readModerator()
{
Lanzamiento de botón es el detonante de un botón después de haber sido empujado.
Debounce es utilizado para detectar la versión de botón.
Si (digitalRead(CORRECT_ANSWER_BUTTON) == PUSHED) {}
for(;;) {
Delay(DEBOUNCE_TIME);
Si (digitalRead(CORRECT_ANSWER_BUTTON) == NOT_PUSHED) {}
rotura;
}
}
volver CORRECT_ANSWER;
} else if (digitalRead(WRONG_ANSWER_BUTTON) == PUSHED) {}
for(;;) {
Delay(DEBOUNCE_TIME);
Si (digitalRead(WRONG_ANSWER_BUTTON) == NOT_PUSHED) {}
rotura;
}
}
volver WRONG_ANSWER;
} else {}
volver NO_ANSWER;
}
}
void readPlayers()
{
Estados de los botones de reproducción se guardan en la matriz del jugador.
int i;
para (i = 0; i < MAX_PLAYERS; i ++)
{
Si (.button jugador [i]! = bloqueados) {}
Si (digitalRead(player[i].buttonPin) == PUSHED) {}
.button jugador [i] = empujado;
} else {}
.button jugador [i] = NOT_PUSHED;
}
}
}
}
void waitingForQuestion()
{
int i;
digitalWrite (READY_FOR_ANSWER_LIGHT, LED_OFF);
Serial.println ("\tModerator, pulse S6 y empezar a leer);
Serial.println ("\tModerator, S5 Pulse cuando haya terminado la pregunta");
mientras (! () readModerator() == CORRECT_ANSWER)) {}
para (i = 0; i < MAX_PLAYERS; i ++) {}
digitalWrite (jugador [i] .light, LED_ON);
Delay(250);
digitalWrite (jugador [i] .light, LED_OFF);
}
}
PUT_CURSOR_MIDSCREEN
Serial.println ("\tPlayers, espere pregunta terminar");
}
void setup()
{
int i;
para (i = 0; i < MAX_PLAYERS; i ++) {}
Asignar los LEDs, cátodos conectados a tierra
.light jugador [i] = TOP_LED - i;
pinMode (jugador [i] .light, salida);
Asignar los interruptores de botón; Conecte la entrada a la tierra cuando está cerrado.
jugador [i] .buttonPin = TOP_SWITCH - i;
pinMode (jugador [i] .buttonPin, entrada);
digitalWrite (.buttonPin jugador [i], HIGH); Activar subida
}
pinMode (READY_FOR_ANSWER_LIGHT, salida);
pinMode (WRONG_ANSWER_BUTTON, entrada);
digitalWrite (WRONG_ANSWER_BUTTON, alto); Activar subida
pinMode (CORRECT_ANSWER_BUTTON, entrada);
digitalWrite (CORRECT_ANSWER_BUTTON, alto); Activar subida
resetAll();
Serial.Begin(9600); Biblioteca Serial a 9600 bps
PUT_CURSOR_MIDSCREEN
waitingForQuestion();
}
void loop()
{
int i;
interruptor (fase) {}
caso QUESTION_READING: {}
Moderador ha presionado el botón reset
o el cuestionado ha sido answeredd
o todos los jugadores han respondido incorrectamente.
No hay tiempo para esta fase.
Cualquier ins Buzz sufrirá retraso segundo 0.25 cuando entró en estado próximo.
readPlayers();
Solicitar pena de Prensas del botón impaciente
para (i = 0; i < MAX_PLAYERS; i ++) {}
Si ((.button jugador [i] == PUSHED) & &
(.timePenalty de jugador [i] == 0)) {
jugador [i] .timePenalty = DELAY_TIME;
Serial.Print ("\tPlayer");
Serial.Print(i+1);
Serial.println ("consigue una pena");
}
}
Asesor = readModerator();
Si (moderador == WRONG_ANSWER) {}
fase = WAITING_FOR_RING_IN;
tiempo de espera = millis() + TIMEOUT_PERIOD;
digitalWrite (READY_FOR_ANSWER_LIGHT, LED_ON);
para (i = 0; i < MAX_PLAYERS; i ++) {}
jugador [i] .timePenalty += millis();
}
PUT_CURSOR_MIDSCREEN
Serial.println ("\tWaiting para el anillo en");
Serial.println();
blockedPlayers = 0;
}
rotura;
} / / End case QUESTION_READING
caso WAITING_FOR_RING_IN: {}
Moderador ha presionado el botón cualquiera en estado QUESTION_READING.
Cinco segundos para esta fase.
Si (blockedPlayers > = MAX_PLAYERS) {}
PUT_CURSOR_MIDSCREEN
Serial.println ("\tAll jugadores han sonado en");
Serial.println ("\tModerator, por favor lea la siguiente pregunta");
fase = QUESTION_READING;
resetAll();
waitingForQuestion();
rotura;
} else {}
buzzedInPlayer = -1;
Si (tiempo de espera > = {millis())}
readPlayers();
para (i = 0; i < MAX_PLAYERS; i ++) {}
Si ((reproductor [i] .timePenalty < = millis()) & &
.button jugador [i] == PUSHED) {}
buzzedInPlayer = i;
buzzedInPlayerCount += 1;
digitalWrite (jugador [buzzedInPlayer] .light, LED_ON);
digitalWrite (READY_FOR_ANSWER_LIGHT, LED_OFF);
fase = WAITING_FOR_ANSWER;
tiempo de espera = millis() + TIMEOUT_PERIOD;
.button jugador [i] = bloqueado;
blockedPlayers += 1;
PUT_CURSOR_MIDSCREEN
Serial.Print ("número de \tPlayer");
Serial.println(i+1);
}
}
} else {}
Serial.println ("\tTimed a la espera de una RING_IN");
Serial.println ("\tModerator, por favor lea la siguiente pregunta");
fase = QUESTION_READING;
resetAll();
waitingForQuestion();
rotura;
}
rotura;
} / / Fin otra
} / / End case WAITING_FOR_RING_IN
caso WAITING_FOR_ANSWER: {}
Un jugador ha presionado el botón mientras está en estado WAITING_FOR_RING_IN.
Cinco segundos para esta fase.
Si (tiempo de espera < millis()) {}
Si (buzzedInPlayerCount < = MAX_PLAYERS) {}
PUT_CURSOR_MIDSCREEN
Serial.println("\tWAITING_FOR_RING_IN");
tiempo de espera = millis() + TIMEOUT_PERIOD;
digitalWrite (jugador [buzzedInPlayer] .light, LED_OFF);
digitalWrite (READY_FOR_ANSWER_LIGHT, LED_ON);
fase = WAITING_FOR_RING_IN;
PUT_CURSOR_MIDSCREEN
Serial.Print ("número de \tPlayer");
Serial.Print(buzzedInPlayer+1);
Serial.println ("agotado el tiempo esperando una respuesta");
}
}
Asesor = readModerator();
Si (moderador == CORRECT_ANSWER) {}
digitalWrite (jugador [buzzedInPlayer] .light, LED_OFF);
PUT_CURSOR_MIDSCREEN
Serial.Print ("número de \tPlayer");
Serial.Print(buzzedInPlayer+1);
Serial.println (", eso es correcto");
Serial.println ("\tModerator, por favor lea la siguiente pregunta");
fase = QUESTION_READING;
resetAll();
waitingForQuestion();
} else
Si (moderador == WRONG_ANSWER) {}
fase = WAITING_FOR_RING_IN;
tiempo de espera = millis() + TIMEOUT_PERIOD;
digitalWrite (jugador [buzzedInPlayer] .light, LED_OFF);
digitalWrite (READY_FOR_ANSWER_LIGHT, LED_ON);
Serial.println ("\tOooo, lo sentimos, que es incorrecto");
Serial.println ("\tWaiting para el anillo en");
resetPlayerTime();
}
rotura;
} / / End case WAITING_FOR_ANSWER
por defecto: {}
Serial.Print ("por defecto: fase =");
Serial.println(Phase);
}
} / / Fin interruptor (fase)
}
