Gonzalo Martinez / Mbed 2 deprecated TPBombaAguaDisplays

4 Cables con pulsadores y pull-up con 2 Displays en paralelo

Dependencies:   mbed

main.cpp@2:e7e06ee2d6b0, 2019-06-23 (annotated)

Committer:
gonzaloMS
Date:
Sun Jun 23 03:45:31 2019 +0000
Revision:
2:e7e06ee2d6b0
Parent:
1:2f8c5940c425 
com

Who changed what in which revision?

UserRevisionLine numberNew contents of line
gonzaloMS 1:2f8c5940c425 1
gonzaloMS 1:2f8c5940c425 2 //Tenemos 2 displays en paralelo, y manejamos cada uno por separado a través de sus habilitaciones (con transistores al corte y saturación)
gonzaloMS 1:2f8c5940c425 3
gonzaloMS 0:d644ac0f96b0 4 #include "mbed.h"
gonzaloMS 0:d644ac0f96b0 5
gonzaloMS 1:2f8c5940c425 6 //Creo los Estados para las Máquinas de Estados
gonzaloMS 1:2f8c5940c425 7 enum{INICIO,GENERA1,GENERA2,GENERA3,FIN,BEGINNING,CHECK1,CHECK2,CHECK3,ENDGAME,WINGAME};
gonzaloMS 2:e7e06ee2d6b0 8 // |----------------------------------|----------------------------------------------|
gonzaloMS 2:e7e06ee2d6b0 9 // GENERACIÓN CHEQUEO
gonzaloMS 1:2f8c5940c425 10
gonzaloMS 0:d644ac0f96b0 11 DigitalIn E1r(PTC12);
gonzaloMS 1:2f8c5940c425 12 DigitalIn E2r(PTC13); // 0 1 2 3 (Entradas reales/físicas)
gonzaloMS 1:2f8c5940c425 13 DigitalIn E3r(PTC3); // E1r E2r E3r E4r
gonzaloMS 0:d644ac0f96b0 14 DigitalIn E4r(PTC4);
gonzaloMS 1:2f8c5940c425 15 DigitalIn pulsadorReset(PTE29); //Pulsador externo para hacer reset, normalmente 1
gonzaloMS 1:2f8c5940c425 16
gonzaloMS 1:2f8c5940c425 17 DigitalOut ledWin(LED2); //Configuro Led RGB en verde para cuando ganás el juego
gonzaloMS 1:2f8c5940c425 18 DigitalOut ledLost(LED1); //Configuro Led RGB en rojo para cuando perdés el juego
gonzaloMS 1:2f8c5940c425 19
gonzaloMS 1:2f8c5940c425 20 BusOut Displays(D2,D3,D4,D5,A3,A2,A1,A0,D8); //Salidas en este orden: HAB.2 (UNIDADES) - HAB.1 (DECENAS) - G - F - E - D - C - B - A respectivamente //
gonzaloMS 1:2f8c5940c425 21
gonzaloMS 0:d644ac0f96b0 22 int E1=0;
gonzaloMS 1:2f8c5940c425 23 int E2=0; //Variables donde se van a guardar los estados de las entradas reales (Ej.: E1r en E1)
gonzaloMS 0:d644ac0f96b0 24 int E3=0;
gonzaloMS 0:d644ac0f96b0 25 int E4=0;
gonzaloMS 1:2f8c5940c425 26
gonzaloMS 1:2f8c5940c425 27 //Cada número del 0 al 9 en binario dentro de un vector, para después asignarlo al BusOut (El menos significativo acá es el más significativo del BusOut)
gonzaloMS 1:2f8c5940c425 28 int numerosD[]={0b111111010,0b011000010,0b110110110,0b111100110,0b011001110,0b101101110,0b101111110,0b111000010,0b111111110,0b111001110}; //0-9 Decenas
gonzaloMS 1:2f8c5940c425 29 int numerosU[]={0b111111001,0b011000001,0b110110101,0b111100101,0b011001101,0b101101101,0b101111101,0b111000001,0b111111101,0b111001101}; //0-9 Unidades
gonzaloMS 0:d644ac0f96b0 30
gonzaloMS 1:2f8c5940c425 31 //Inicializo Tickers que ejecutan una función cada cierto tiempo en segundos
gonzaloMS 1:2f8c5940c425 32 Ticker Tempo;
gonzaloMS 0:d644ac0f96b0 33 Ticker Display;
gonzaloMS 0:d644ac0f96b0 34 Ticker parpadeoTicker;
gonzaloMS 0:d644ac0f96b0 35
gonzaloMS 1:2f8c5940c425 36 //Funciones de cada Ticker respectivamente
gonzaloMS 1:2f8c5940c425 37 void descuentaTiempo(); //Cada 1 seg le resta 1 a una variable que lleva el tiempo. Al llegar a 0, indica a través de una variable que el jugador perdió
gonzaloMS 1:2f8c5940c425 38 void visualizacionDisplays(); //Genera Unidades y Decenas en base al tiempo. Maneja el BusOut que va a las patas de los displays para mostrar el tiempo
gonzaloMS 1:2f8c5940c425 39 void parpadeoFuncion(); //Hace que parpadee el led rojo cuando perdés y que parpadeen los segmentos de los displays cuando termine el juego
gonzaloMS 1:2f8c5940c425 40
gonzaloMS 1:2f8c5940c425 41 //Funciones de las Máquinas de estados
gonzaloMS 1:2f8c5940c425 42 void generacion(); //Genera secuencia
gonzaloMS 1:2f8c5940c425 43 void chequeo(); //Chequea si el estado de las entradas concuerda con la secuencia generada
gonzaloMS 0:d644ac0f96b0 44
gonzaloMS 1:2f8c5940c425 45 //Funciones extra
gonzaloMS 1:2f8c5940c425 46 void winReaccion(); //Prende el led verde si ganás (desconectas todos los cables en el orden correcto)
gonzaloMS 1:2f8c5940c425 47 void reset(); //Si presionás el botón reset reinicia las variables necesarias, hace que las máquinas de estados vuelvan a empezar por su estado default y apaga los leds
gonzaloMS 1:2f8c5940c425 48
gonzaloMS 1:2f8c5940c425 49 //Varible que se encarga de decidir cuándo mostrar las decenas y cuándo las unidades
gonzaloMS 1:2f8c5940c425 50 int switcheo=0;
gonzaloMS 1:2f8c5940c425 51
gonzaloMS 1:2f8c5940c425 52 //Variables relacionadas con el tiempo que se muestra en los displays
gonzaloMS 1:2f8c5940c425 53 int tiempo=60; //Guarda el tiempo en segundos
gonzaloMS 1:2f8c5940c425 54 int Decenas; //Guarda solamente la unidad del tiempo
gonzaloMS 1:2f8c5940c425 55 int Unidades; //Guarda solamente la decena del tiempo
gonzaloMS 0:d644ac0f96b0 56
gonzaloMS 1:2f8c5940c425 57 //Variables en las que se guarda el estado de las máquinas de estados
gonzaloMS 1:2f8c5940c425 58 int secuencia; //Para la máquina de estados de generación de secuencia
gonzaloMS 1:2f8c5940c425 59 int check; //Para la máquina de estados de chequeo de las entradas
gonzaloMS 1:2f8c5940c425 60
gonzaloMS 1:2f8c5940c425 61 //Variables que guardan cuántas de las entradas concuerdan con la secuencia generada
gonzaloMS 1:2f8c5940c425 62 int cantIgual=0; //Para cuando se corta un cable (1 entrada en 1, las otras 3 en 0)
gonzaloMS 1:2f8c5940c425 63 int cantIgual2=0; //Para cuando se corta el segundo cable (2 entradas en 1, las otras 2 en 0)
gonzaloMS 1:2f8c5940c425 64 int cantIgual3=0; //Para cuando se corta el tercer cable (3 entradas en 1, la otra en 0)
gonzaloMS 0:d644ac0f96b0 65
gonzaloMS 1:2f8c5940c425 66 //Variables donde se guardan valores random que van a determinar cómo queda la secuencia
gonzaloMS 1:2f8c5940c425 67 int genSec1; //primer cable a cortar
gonzaloMS 1:2f8c5940c425 68 int genSec2; //segundo cable a cortar
gonzaloMS 1:2f8c5940c425 69 int genSec3; //tercer cable a cortar
gonzaloMS 0:d644ac0f96b0 70
gonzaloMS 1:2f8c5940c425 71 //Vectores que guardan cada parte de la secuencia (que empieza en 0000 y termina en 1111)
gonzaloMS 1:2f8c5940c425 72 int vecSec[]={0,0,0,0}; //Primer cable a cortar
gonzaloMS 1:2f8c5940c425 73 int vecSec2[]={0,0,0,0}; //Segundo cable a cortar
gonzaloMS 1:2f8c5940c425 74 int vecSec3[]={0,0,0,0}; //Tercer cable a cortar
gonzaloMS 1:2f8c5940c425 75 int vecSec4[]={0,0,0,0}; //Cuarto cable a cortar
gonzaloMS 1:2f8c5940c425 76
gonzaloMS 1:2f8c5940c425 77 //Vector que guarda el estado de las entradas para compararlo con los vectores que guardan la secuencia
gonzaloMS 0:d644ac0f96b0 78 int vecChq[]={0,0,0,0};
gonzaloMS 0:d644ac0f96b0 79
gonzaloMS 1:2f8c5940c425 80 //Variable que se queda en 0 si no tiene que parpadear el display y que alterna entre 1 y 0 constantemente en el caso contrario (0 muestra el tiempo y 1 apaga el display)
gonzaloMS 0:d644ac0f96b0 81 int parpadeoDisplay=0;
gonzaloMS 0:d644ac0f96b0 82
gonzaloMS 1:2f8c5940c425 83 //Variables que informan si el jugador perdió o ganó el juego
gonzaloMS 0:d644ac0f96b0 84 int fin=0;
gonzaloMS 0:d644ac0f96b0 85 int win=0;
gonzaloMS 0:d644ac0f96b0 86
gonzaloMS 1:2f8c5940c425 87 //Variables para los "for" del programa
gonzaloMS 0:d644ac0f96b0 88 int i;
gonzaloMS 0:d644ac0f96b0 89 int y;
gonzaloMS 0:d644ac0f96b0 90 int k;
gonzaloMS 0:d644ac0f96b0 91
gonzaloMS 0:d644ac0f96b0 92
gonzaloMS 0:d644ac0f96b0 93 int main() {
gonzaloMS 1:2f8c5940c425 94 //Apago los Leds
gonzaloMS 0:d644ac0f96b0 95 ledWin=1;
gonzaloMS 0:d644ac0f96b0 96 ledLost=1;
gonzaloMS 1:2f8c5940c425 97 //Configuro modo de PullUp interno para las 4 entradas (los cuatro cables) y el botón de Reset
gonzaloMS 0:d644ac0f96b0 98 E1r.mode(PullUp);
gonzaloMS 0:d644ac0f96b0 99 E2r.mode(PullUp);
gonzaloMS 0:d644ac0f96b0 100 E3r.mode(PullUp);
gonzaloMS 0:d644ac0f96b0 101 E4r.mode(PullUp);
gonzaloMS 0:d644ac0f96b0 102 pulsadorReset.mode(PullUp);
gonzaloMS 1:2f8c5940c425 103 //Asingo las funciones a los Tickers
gonzaloMS 1:2f8c5940c425 104 Tempo.attach(&descuentaTiempo,1); //La funcion descuentaTiempo se va a ejecutar cada 1 segundo
gonzaloMS 1:2f8c5940c425 105 Display.attach(&visualizacionDisplays,0.005); //La funcion visualizacionDisplays se va a ejecutar cada 5 milisegundos
gonzaloMS 1:2f8c5940c425 106 parpadeoTicker.attach(&parpadeoFuncion,0.5); //La funcion parpadeoFuncion se va a ejecutar cada 0,5 segundos
gonzaloMS 0:d644ac0f96b0 107 while(1) {
gonzaloMS 1:2f8c5940c425 108 //Llamo a las funciones
gonzaloMS 0:d644ac0f96b0 109 generacion();
gonzaloMS 0:d644ac0f96b0 110 chequeo();
gonzaloMS 1:2f8c5940c425 111 winReaccion();
gonzaloMS 0:d644ac0f96b0 112 reset();
gonzaloMS 1:2f8c5940c425 113 //Pongo los estados de las entradas en las variables
gonzaloMS 1:2f8c5940c425 114 E1=E1r;
gonzaloMS 1:2f8c5940c425 115 E2=E2r;
gonzaloMS 1:2f8c5940c425 116 E3=E3r;
gonzaloMS 1:2f8c5940c425 117 E4=E4r;
gonzaloMS 0:d644ac0f96b0 118 }
gonzaloMS 0:d644ac0f96b0 119 }
gonzaloMS 1:2f8c5940c425 120
gonzaloMS 0:d644ac0f96b0 121 void reset()
gonzaloMS 0:d644ac0f96b0 122 {
gonzaloMS 0:d644ac0f96b0 123 if(pulsadorReset==0)
gonzaloMS 0:d644ac0f96b0 124 {
gonzaloMS 1:2f8c5940c425 125 //si se presiona el pulsador resetea todas las variables, los vectores (vuelven a empezar en 0000) y las máq. de estados empiezan por su estado default
gonzaloMS 0:d644ac0f96b0 126 ledWin=1;
gonzaloMS 1:2f8c5940c425 127 ledLost=1;
gonzaloMS 1:2f8c5940c425 128 switcheo=0;
gonzaloMS 0:d644ac0f96b0 129 cantIgual=0;
gonzaloMS 0:d644ac0f96b0 130 cantIgual2=0;
gonzaloMS 0:d644ac0f96b0 131 cantIgual3=0;
gonzaloMS 0:d644ac0f96b0 132 vecSec[0]=0;
gonzaloMS 0:d644ac0f96b0 133 vecSec[1]=0;
gonzaloMS 0:d644ac0f96b0 134 vecSec[2]=0;
gonzaloMS 0:d644ac0f96b0 135 vecSec[3]=0;
gonzaloMS 0:d644ac0f96b0 136 vecSec2[0]=0;
gonzaloMS 0:d644ac0f96b0 137 vecSec2[1]=0;
gonzaloMS 0:d644ac0f96b0 138 vecSec2[2]=0;
gonzaloMS 0:d644ac0f96b0 139 vecSec2[3]=0;
gonzaloMS 0:d644ac0f96b0 140 vecSec3[0]=0;
gonzaloMS 0:d644ac0f96b0 141 vecSec3[1]=0;
gonzaloMS 0:d644ac0f96b0 142 vecSec3[2]=0;
gonzaloMS 0:d644ac0f96b0 143 vecSec3[3]=0;
gonzaloMS 0:d644ac0f96b0 144 vecSec4[0]=0;
gonzaloMS 0:d644ac0f96b0 145 vecSec4[1]=0;
gonzaloMS 0:d644ac0f96b0 146 vecSec4[2]=0;
gonzaloMS 0:d644ac0f96b0 147 vecSec4[3]=0;
gonzaloMS 0:d644ac0f96b0 148 vecChq[0]=0;
gonzaloMS 0:d644ac0f96b0 149 vecChq[1]=0;
gonzaloMS 0:d644ac0f96b0 150 vecChq[2]=0;
gonzaloMS 0:d644ac0f96b0 151 vecChq[3]=0;
gonzaloMS 0:d644ac0f96b0 152 parpadeoDisplay=0;
gonzaloMS 1:2f8c5940c425 153 tiempo=60;
gonzaloMS 0:d644ac0f96b0 154 win=0;
gonzaloMS 0:d644ac0f96b0 155 fin=0;
gonzaloMS 0:d644ac0f96b0 156 secuencia=INICIO;
gonzaloMS 1:2f8c5940c425 157 check=BEGINNING;
gonzaloMS 0:d644ac0f96b0 158 }
gonzaloMS 0:d644ac0f96b0 159 }
gonzaloMS 1:2f8c5940c425 160
gonzaloMS 1:2f8c5940c425 161 void winReaccion()
gonzaloMS 0:d644ac0f96b0 162 {
gonzaloMS 1:2f8c5940c425 163 //Si el jugador ganó, se prende el led verde y se apaga el rojo
gonzaloMS 0:d644ac0f96b0 164 if(win==1)
gonzaloMS 0:d644ac0f96b0 165 {
gonzaloMS 0:d644ac0f96b0 166 ledWin=0;
gonzaloMS 0:d644ac0f96b0 167 ledLost=1;
gonzaloMS 0:d644ac0f96b0 168 }
gonzaloMS 0:d644ac0f96b0 169 }
gonzaloMS 1:2f8c5940c425 170
gonzaloMS 0:d644ac0f96b0 171 void parpadeoFuncion()
gonzaloMS 0:d644ac0f96b0 172 {
gonzaloMS 1:2f8c5940c425 173 //Si el jugador perdió, cada 0,5 segundos que entra en la funcion cambia el estado del led rojo de 0 a 1
gonzaloMS 0:d644ac0f96b0 174 if(fin==1)
gonzaloMS 0:d644ac0f96b0 175 {
gonzaloMS 0:d644ac0f96b0 176 ledLost=!ledLost;
gonzaloMS 0:d644ac0f96b0 177 }
gonzaloMS 1:2f8c5940c425 178 //Si el jugador perdió o ganó, cada 0,5 segundos que entra en la funcion va a cambiar entre 0 y 1 la variable que indica si se tiene que mostrar el tiempo o apagar los displays
gonzaloMS 0:d644ac0f96b0 179 if(fin==1 || win==1)
gonzaloMS 0:d644ac0f96b0 180 {
gonzaloMS 0:d644ac0f96b0 181 parpadeoDisplay=!parpadeoDisplay;
gonzaloMS 0:d644ac0f96b0 182 }
gonzaloMS 0:d644ac0f96b0 183 }
gonzaloMS 1:2f8c5940c425 184
gonzaloMS 1:2f8c5940c425 185 void descuentaTiempo()
gonzaloMS 0:d644ac0f96b0 186 {
gonzaloMS 1:2f8c5940c425 187 //Si el juego no terminó, cada 1 segundo le resta 1 a la variable tiempo, que empieza en 60, hasta que llega a 0 e indica que el jugador perdió.
gonzaloMS 1:2f8c5940c425 188 //También cada 1 segundo muestra el estado de las variables importantes para el jugador para facilitar la depuración
gonzaloMS 0:d644ac0f96b0 189 if(fin==0 && win==0)
gonzaloMS 0:d644ac0f96b0 190 {
gonzaloMS 1:2f8c5940c425 191 if(tiempo>0)
gonzaloMS 0:d644ac0f96b0 192 {
gonzaloMS 1:2f8c5940c425 193 tiempo--;
gonzaloMS 0:d644ac0f96b0 194 }
gonzaloMS 0:d644ac0f96b0 195 else
gonzaloMS 0:d644ac0f96b0 196 {
gonzaloMS 0:d644ac0f96b0 197 fin=1;
gonzaloMS 0:d644ac0f96b0 198 }
gonzaloMS 0:d644ac0f96b0 199 printf("A lograr: \n");
gonzaloMS 0:d644ac0f96b0 200 printf("%d %d %d %d \n",*vecSec,*(vecSec+1),*(vecSec+2),*(vecSec+3));
gonzaloMS 0:d644ac0f96b0 201 printf("%d %d %d %d \n",*vecSec2,*(vecSec2+1),*(vecSec2+2),*(vecSec2+3));
gonzaloMS 0:d644ac0f96b0 202 printf("%d %d %d %d \n",*vecSec3,*(vecSec3+1),*(vecSec3+2),*(vecSec3+3));
gonzaloMS 0:d644ac0f96b0 203 printf("%d %d %d %d \n",*vecSec4,*(vecSec4+1),*(vecSec4+2),*(vecSec4+3));
gonzaloMS 1:2f8c5940c425 204 printf("Entradas: %d %d %d %d \n", E1,E2,E3,E4);
gonzaloMS 1:2f8c5940c425 205 printf("Tiempo (en segundos): %d \n \n",tiempo);
gonzaloMS 0:d644ac0f96b0 206 }
gonzaloMS 0:d644ac0f96b0 207 }
gonzaloMS 1:2f8c5940c425 208
gonzaloMS 1:2f8c5940c425 209 void visualizacionDisplays()
gonzaloMS 0:d644ac0f96b0 210 {
gonzaloMS 1:2f8c5940c425 211 //Consigo el numero perteneciente a las decenas del tiempo y lo guardo en la variable. Lo mismo para las unidades del tiempo
gonzaloMS 1:2f8c5940c425 212 Decenas=tiempo/10;
gonzaloMS 1:2f8c5940c425 213 Unidades=tiempo-((tiempo/10)*10);
gonzaloMS 1:2f8c5940c425 214 //Si no tiene que parpadear el display, va cambiar entre mostrar las decenas y unidades cada 5 milisegundos que entra a la funcion
gonzaloMS 1:2f8c5940c425 215 //Si tiene que parpadear, parpadeoDisplay cambia entre 0 y 1, mostrando el tiempo en un momento y apagando los displays en otro
gonzaloMS 1:2f8c5940c425 216 if(parpadeoDisplay==0)
gonzaloMS 1:2f8c5940c425 217 {
gonzaloMS 1:2f8c5940c425 218 //Si switcheo es par, muestra decenas, y si es impar, muestra unidades. La posicion 0 del vector corresponde al numero 0, y así hasta el 9
gonzaloMS 1:2f8c5940c425 219 if(switcheo%2==0)
gonzaloMS 0:d644ac0f96b0 220 {
gonzaloMS 1:2f8c5940c425 221 Displays=numerosD[Decenas];
gonzaloMS 0:d644ac0f96b0 222 }
gonzaloMS 0:d644ac0f96b0 223 else
gonzaloMS 0:d644ac0f96b0 224 {
gonzaloMS 1:2f8c5940c425 225 Displays=numerosU[Unidades];
gonzaloMS 0:d644ac0f96b0 226 }
gonzaloMS 1:2f8c5940c425 227 }
gonzaloMS 1:2f8c5940c425 228 else
gonzaloMS 1:2f8c5940c425 229 {
gonzaloMS 1:2f8c5940c425 230 Displays=0;
gonzaloMS 1:2f8c5940c425 231 }
gonzaloMS 1:2f8c5940c425 232 //Como no importa el número en sí, para que no se haga muy grande para en 200 y vuelve a 0
gonzaloMS 1:2f8c5940c425 233 if(switcheo==200)
gonzaloMS 1:2f8c5940c425 234 {
gonzaloMS 1:2f8c5940c425 235 switcheo=0;
gonzaloMS 1:2f8c5940c425 236 }
gonzaloMS 1:2f8c5940c425 237 //switcheo aumenta en 1 cada vez que se entra a la funcion
gonzaloMS 1:2f8c5940c425 238 switcheo++;
gonzaloMS 0:d644ac0f96b0 239 }
gonzaloMS 0:d644ac0f96b0 240
gonzaloMS 0:d644ac0f96b0 241 void generacion(){
gonzaloMS 0:d644ac0f96b0 242 switch(secuencia)
gonzaloMS 0:d644ac0f96b0 243 {
gonzaloMS 1:2f8c5940c425 244 default:
gonzaloMS 0:d644ac0f96b0 245 case INICIO:
gonzaloMS 1:2f8c5940c425 246 //Se reinician las variables que se encargan de generar la secuencia
gonzaloMS 1:2f8c5940c425 247 genSec1=0;
gonzaloMS 1:2f8c5940c425 248 genSec2=0;
gonzaloMS 1:2f8c5940c425 249 genSec3=0;
gonzaloMS 1:2f8c5940c425 250 //Pasa directamente al estado GENERA1
gonzaloMS 0:d644ac0f96b0 251 secuencia=GENERA1;
gonzaloMS 0:d644ac0f96b0 252 break;
gonzaloMS 0:d644ac0f96b0 253
gonzaloMS 0:d644ac0f96b0 254 case GENERA1:
gonzaloMS 1:2f8c5940c425 255 //Se le asigna un valor random entre 1 y 4 a la variable genSec1
gonzaloMS 1:2f8c5940c425 256 genSec1=rand()%4+1;
gonzaloMS 1:2f8c5940c425 257 //Dependiendo del valor, se le suma 1 a 1 de las 4 posiciones del vector
gonzaloMS 1:2f8c5940c425 258 if(genSec1==1)
gonzaloMS 0:d644ac0f96b0 259 {
gonzaloMS 0:d644ac0f96b0 260 vecSec[0]++;
gonzaloMS 0:d644ac0f96b0 261 }
gonzaloMS 1:2f8c5940c425 262 else if(genSec1==2)
gonzaloMS 0:d644ac0f96b0 263 {
gonzaloMS 0:d644ac0f96b0 264 vecSec[1]++;
gonzaloMS 0:d644ac0f96b0 265 }
gonzaloMS 1:2f8c5940c425 266 else if(genSec1==3)
gonzaloMS 0:d644ac0f96b0 267 {
gonzaloMS 0:d644ac0f96b0 268 vecSec[2]++;
gonzaloMS 0:d644ac0f96b0 269 }
gonzaloMS 1:2f8c5940c425 270 else if(genSec1==4)
gonzaloMS 0:d644ac0f96b0 271 {
gonzaloMS 0:d644ac0f96b0 272 vecSec[3]++;
gonzaloMS 0:d644ac0f96b0 273 }
gonzaloMS 1:2f8c5940c425 274 //Pasa directamente al estado GENERA2
gonzaloMS 0:d644ac0f96b0 275 secuencia=GENERA2;
gonzaloMS 0:d644ac0f96b0 276 break;
gonzaloMS 0:d644ac0f96b0 277
gonzaloMS 0:d644ac0f96b0 278 case GENERA2:
gonzaloMS 1:2f8c5940c425 279 //Se le asigna un valor random entre 1 y 4 a la variable genSec2
gonzaloMS 1:2f8c5940c425 280 genSec2=rand()%4+1;
gonzaloMS 1:2f8c5940c425 281 //Se copia el contenido del vector de la primera parte de la secuencia al del vector de la segunda parte de la secuencia
gonzaloMS 0:d644ac0f96b0 282 vecSec2[0]=vecSec[0];
gonzaloMS 0:d644ac0f96b0 283 vecSec2[1]=vecSec[1];
gonzaloMS 0:d644ac0f96b0 284 vecSec2[2]=vecSec[2];
gonzaloMS 0:d644ac0f96b0 285 vecSec2[3]=vecSec[3];
gonzaloMS 1:2f8c5940c425 286 //Dependiendo del valor, se le suma 1 a 1 de las 4 posiciones del vector, excepto que la posicion a la que busca sumar 1 ya sea 1 de la generacion anterior
gonzaloMS 1:2f8c5940c425 287 //Si la posicion ya era 1 de antes, se vuelve a hacer el proceso (que incluye volver a generar un número random)
gonzaloMS 1:2f8c5940c425 288 if(genSec2==1)
gonzaloMS 0:d644ac0f96b0 289 {
gonzaloMS 0:d644ac0f96b0 290 if(vecSec2[0]==1)
gonzaloMS 0:d644ac0f96b0 291 {
gonzaloMS 0:d644ac0f96b0 292 secuencia=GENERA2;
gonzaloMS 0:d644ac0f96b0 293 }
gonzaloMS 0:d644ac0f96b0 294 else
gonzaloMS 0:d644ac0f96b0 295 {
gonzaloMS 0:d644ac0f96b0 296 vecSec2[0]++;
gonzaloMS 0:d644ac0f96b0 297 }
gonzaloMS 0:d644ac0f96b0 298 }
gonzaloMS 1:2f8c5940c425 299 else if(genSec2==2)
gonzaloMS 0:d644ac0f96b0 300 {
gonzaloMS 0:d644ac0f96b0 301 if(vecSec2[1]==1)
gonzaloMS 0:d644ac0f96b0 302 {
gonzaloMS 0:d644ac0f96b0 303 secuencia=GENERA2;
gonzaloMS 0:d644ac0f96b0 304 }
gonzaloMS 0:d644ac0f96b0 305 else
gonzaloMS 0:d644ac0f96b0 306 {
gonzaloMS 0:d644ac0f96b0 307 vecSec2[1]++;
gonzaloMS 0:d644ac0f96b0 308 }
gonzaloMS 0:d644ac0f96b0 309 }
gonzaloMS 1:2f8c5940c425 310 else if(genSec2==3)
gonzaloMS 0:d644ac0f96b0 311 {
gonzaloMS 0:d644ac0f96b0 312 if(vecSec2[2]==1)
gonzaloMS 0:d644ac0f96b0 313 {
gonzaloMS 0:d644ac0f96b0 314 secuencia=GENERA2;
gonzaloMS 0:d644ac0f96b0 315 }
gonzaloMS 0:d644ac0f96b0 316 else
gonzaloMS 0:d644ac0f96b0 317 {
gonzaloMS 0:d644ac0f96b0 318 vecSec2[2]++;
gonzaloMS 0:d644ac0f96b0 319 }
gonzaloMS 0:d644ac0f96b0 320 }
gonzaloMS 1:2f8c5940c425 321 else if(genSec2==4)
gonzaloMS 0:d644ac0f96b0 322 {
gonzaloMS 0:d644ac0f96b0 323 if(vecSec2[3]==1)
gonzaloMS 0:d644ac0f96b0 324 {
gonzaloMS 0:d644ac0f96b0 325 secuencia=GENERA2;
gonzaloMS 0:d644ac0f96b0 326 }
gonzaloMS 0:d644ac0f96b0 327 else
gonzaloMS 0:d644ac0f96b0 328 {
gonzaloMS 0:d644ac0f96b0 329 vecSec2[3]++;
gonzaloMS 0:d644ac0f96b0 330 }
gonzaloMS 0:d644ac0f96b0 331 }
gonzaloMS 1:2f8c5940c425 332 //Se busca verificar que el vector de la segunda parte de la secuencia contenga dos posiciones en 1. En ese caso, pasa al estado GENERA3
gonzaloMS 1:2f8c5940c425 333 //Sino vuelve a hacer el proceso
gonzaloMS 0:d644ac0f96b0 334 if((vecSec2[0]+vecSec2[1]+vecSec2[2]+vecSec2[3]) == 2)
gonzaloMS 0:d644ac0f96b0 335 {
gonzaloMS 0:d644ac0f96b0 336 secuencia=GENERA3;
gonzaloMS 0:d644ac0f96b0 337 }
gonzaloMS 0:d644ac0f96b0 338 else
gonzaloMS 0:d644ac0f96b0 339 {
gonzaloMS 0:d644ac0f96b0 340 secuencia=GENERA2;
gonzaloMS 0:d644ac0f96b0 341 }
gonzaloMS 0:d644ac0f96b0 342 break;
gonzaloMS 0:d644ac0f96b0 343
gonzaloMS 0:d644ac0f96b0 344 case GENERA3:
gonzaloMS 1:2f8c5940c425 345 //Se le asigna un valor random entre 1 y 4 a la variable genSec3
gonzaloMS 1:2f8c5940c425 346 genSec3=rand()%4+1;
gonzaloMS 1:2f8c5940c425 347 //Se copia el contenido del vector de la segunda parte de la secuencia al del vector de la tercera parte de la secuencia
gonzaloMS 0:d644ac0f96b0 348 vecSec3[0]=vecSec2[0];
gonzaloMS 0:d644ac0f96b0 349 vecSec3[1]=vecSec2[1];
gonzaloMS 0:d644ac0f96b0 350 vecSec3[2]=vecSec2[2];
gonzaloMS 0:d644ac0f96b0 351 vecSec3[3]=vecSec2[3];
gonzaloMS 1:2f8c5940c425 352 //Dependiendo del valor, se le suma 1 a 1 de las 4 posiciones del vector, excepto que la posicion a la que busca sumar 1 ya sea 1 de la generacion anterior
gonzaloMS 1:2f8c5940c425 353 //Si la posicion ya era 1 de antes, se vuelve a hacer el proceso (que incluye volver a generar un número random)
gonzaloMS 1:2f8c5940c425 354 if(genSec3==1)
gonzaloMS 0:d644ac0f96b0 355 {
gonzaloMS 0:d644ac0f96b0 356 if(vecSec3[0]==1)
gonzaloMS 0:d644ac0f96b0 357 {
gonzaloMS 0:d644ac0f96b0 358 secuencia=GENERA3;
gonzaloMS 0:d644ac0f96b0 359 }
gonzaloMS 0:d644ac0f96b0 360 else
gonzaloMS 0:d644ac0f96b0 361 {
gonzaloMS 0:d644ac0f96b0 362 vecSec3[0]++;
gonzaloMS 0:d644ac0f96b0 363 }
gonzaloMS 0:d644ac0f96b0 364 }
gonzaloMS 1:2f8c5940c425 365 else if(genSec3==2)
gonzaloMS 0:d644ac0f96b0 366 {
gonzaloMS 0:d644ac0f96b0 367 if(vecSec3[1]==1)
gonzaloMS 0:d644ac0f96b0 368 {
gonzaloMS 0:d644ac0f96b0 369 secuencia=GENERA3;
gonzaloMS 0:d644ac0f96b0 370 }
gonzaloMS 0:d644ac0f96b0 371 else
gonzaloMS 0:d644ac0f96b0 372 {
gonzaloMS 0:d644ac0f96b0 373 vecSec3[1]++;
gonzaloMS 0:d644ac0f96b0 374 }
gonzaloMS 0:d644ac0f96b0 375 }
gonzaloMS 1:2f8c5940c425 376 else if(genSec3==3)
gonzaloMS 0:d644ac0f96b0 377 {
gonzaloMS 0:d644ac0f96b0 378 if(vecSec3[2]==1)
gonzaloMS 0:d644ac0f96b0 379 {
gonzaloMS 0:d644ac0f96b0 380 secuencia=GENERA3;
gonzaloMS 0:d644ac0f96b0 381 }
gonzaloMS 0:d644ac0f96b0 382 else
gonzaloMS 0:d644ac0f96b0 383 {
gonzaloMS 0:d644ac0f96b0 384 vecSec3[2]++;
gonzaloMS 0:d644ac0f96b0 385 }
gonzaloMS 0:d644ac0f96b0 386 }
gonzaloMS 1:2f8c5940c425 387 else if(genSec3==4)
gonzaloMS 0:d644ac0f96b0 388 {
gonzaloMS 0:d644ac0f96b0 389 if(vecSec3[3]==1)
gonzaloMS 0:d644ac0f96b0 390 {
gonzaloMS 0:d644ac0f96b0 391 secuencia=GENERA3;
gonzaloMS 0:d644ac0f96b0 392 }
gonzaloMS 0:d644ac0f96b0 393 else
gonzaloMS 0:d644ac0f96b0 394 {
gonzaloMS 0:d644ac0f96b0 395 vecSec3[3]++;
gonzaloMS 0:d644ac0f96b0 396 }
gonzaloMS 0:d644ac0f96b0 397 }
gonzaloMS 1:2f8c5940c425 398 //Se busca verificar que el vector de la tercera parte de la secuencia contenga tres posiciones en 1. En ese caso, pasa al estado FIN
gonzaloMS 1:2f8c5940c425 399 //Sino vuelve a hacer el proceso
gonzaloMS 0:d644ac0f96b0 400 if((vecSec3[0]+vecSec3[1]+vecSec3[2]+vecSec3[3]) == 3)
gonzaloMS 0:d644ac0f96b0 401 {
gonzaloMS 0:d644ac0f96b0 402 secuencia=FIN;
gonzaloMS 0:d644ac0f96b0 403 }
gonzaloMS 0:d644ac0f96b0 404 else
gonzaloMS 0:d644ac0f96b0 405 {
gonzaloMS 0:d644ac0f96b0 406 secuencia=GENERA3;
gonzaloMS 0:d644ac0f96b0 407 }
gonzaloMS 0:d644ac0f96b0 408 break;
gonzaloMS 0:d644ac0f96b0 409
gonzaloMS 0:d644ac0f96b0 410 case FIN:
gonzaloMS 1:2f8c5940c425 411 //Termina con todas las posiciones en 1. Se mantiene en este estado hasta que se presione el botón de reset
gonzaloMS 0:d644ac0f96b0 412 vecSec4[0]=1;
gonzaloMS 0:d644ac0f96b0 413 vecSec4[1]=1;
gonzaloMS 0:d644ac0f96b0 414 vecSec4[2]=1;
gonzaloMS 0:d644ac0f96b0 415 vecSec4[3]=1;
gonzaloMS 0:d644ac0f96b0 416 secuencia=FIN;
gonzaloMS 0:d644ac0f96b0 417 break;
gonzaloMS 0:d644ac0f96b0 418 }
gonzaloMS 1:2f8c5940c425 419 }
gonzaloMS 1:2f8c5940c425 420
gonzaloMS 1:2f8c5940c425 421 void chequeo(){
gonzaloMS 1:2f8c5940c425 422 switch(check)
gonzaloMS 1:2f8c5940c425 423 {
gonzaloMS 1:2f8c5940c425 424 default:
gonzaloMS 1:2f8c5940c425 425 case BEGINNING:
gonzaloMS 1:2f8c5940c425 426 //Si todas las entradas están conectadas (ningún cable sin cortar), se queda en este estado, sino cambia a CHECK1
gonzaloMS 1:2f8c5940c425 427 if(E1!=0 || E2!=0 || E3!=0 || E4!=0)
gonzaloMS 1:2f8c5940c425 428 {
gonzaloMS 1:2f8c5940c425 429 check=CHECK1;
gonzaloMS 1:2f8c5940c425 430 }
gonzaloMS 1:2f8c5940c425 431 else
gonzaloMS 1:2f8c5940c425 432 {
gonzaloMS 1:2f8c5940c425 433 check=BEGINNING;
gonzaloMS 1:2f8c5940c425 434 }
gonzaloMS 1:2f8c5940c425 435 break;
gonzaloMS 1:2f8c5940c425 436
gonzaloMS 1:2f8c5940c425 437 case CHECK1:
gonzaloMS 1:2f8c5940c425 438 //El estado de las entradas al "desconectar" una se guarda en los vectores
gonzaloMS 1:2f8c5940c425 439 vecChq[0]=E1;
gonzaloMS 1:2f8c5940c425 440 vecChq[1]=E2;
gonzaloMS 1:2f8c5940c425 441 vecChq[2]=E3;
gonzaloMS 1:2f8c5940c425 442 vecChq[3]=E4;
gonzaloMS 1:2f8c5940c425 443 //Se fija si el estado de las 4 entradas corresponde con la secuencia al desconectar solo una de las entradas
gonzaloMS 1:2f8c5940c425 444 for(i=0;i<4;i++)
gonzaloMS 1:2f8c5940c425 445 {
gonzaloMS 1:2f8c5940c425 446 if(vecSec[i]==vecChq[i])
gonzaloMS 1:2f8c5940c425 447 {
gonzaloMS 1:2f8c5940c425 448 cantIgual++;
gonzaloMS 1:2f8c5940c425 449 }
gonzaloMS 1:2f8c5940c425 450 }
gonzaloMS 1:2f8c5940c425 451 //Si solo se desconectó una y era la que debía ser según la secuencia, se vuelve a hacer el proceso. Si era una incorrecta, perdiste el juego
gonzaloMS 1:2f8c5940c425 452 if((vecChq[0]+vecChq[1]+vecChq[2]+vecChq[3])==1)
gonzaloMS 1:2f8c5940c425 453 {
gonzaloMS 1:2f8c5940c425 454 if(cantIgual!=4)
gonzaloMS 1:2f8c5940c425 455 {
gonzaloMS 1:2f8c5940c425 456 check=ENDGAME;
gonzaloMS 1:2f8c5940c425 457 }
gonzaloMS 1:2f8c5940c425 458 else
gonzaloMS 1:2f8c5940c425 459 {
gonzaloMS 1:2f8c5940c425 460 cantIgual=0;
gonzaloMS 1:2f8c5940c425 461 check=CHECK1;
gonzaloMS 1:2f8c5940c425 462 }
gonzaloMS 1:2f8c5940c425 463 }
gonzaloMS 1:2f8c5940c425 464 //Si la primera que se había desconectado era la correcta y se desconecta otra más, pasa al estado CHECK2
gonzaloMS 1:2f8c5940c425 465 else if(vecChq[0]+vecChq[1]+vecChq[2]+vecChq[3])==2)
gonzaloMS 1:2f8c5940c425 466 {
gonzaloMS 1:2f8c5940c425 467 check=CHECK2;
gonzaloMS 1:2f8c5940c425 468 }
gonzaloMS 1:2f8c5940c425 469 break;
gonzaloMS 1:2f8c5940c425 470
gonzaloMS 1:2f8c5940c425 471 case CHECK2:
gonzaloMS 1:2f8c5940c425 472 //El estado de las entradas al desconectar la segunda se guarda en los vectores
gonzaloMS 1:2f8c5940c425 473 vecChq[0]=E1;
gonzaloMS 1:2f8c5940c425 474 vecChq[1]=E2;
gonzaloMS 1:2f8c5940c425 475 vecChq[2]=E3;
gonzaloMS 1:2f8c5940c425 476 vecChq[3]=E4;
gonzaloMS 1:2f8c5940c425 477 //Se fija si el estado de las 4 entradas corresponde con a la secuencia al desconectar la segunda entrada
gonzaloMS 1:2f8c5940c425 478 for(y=0;y<4;y++)
gonzaloMS 1:2f8c5940c425 479 {
gonzaloMS 1:2f8c5940c425 480 if(vecSec2[y]==vecChq[y])
gonzaloMS 1:2f8c5940c425 481 {
gonzaloMS 1:2f8c5940c425 482 cantIgual2++;
gonzaloMS 1:2f8c5940c425 483 }
gonzaloMS 1:2f8c5940c425 484 }
gonzaloMS 1:2f8c5940c425 485 //Si al desconectar la segunda entrada era la que debía ser según la secuencia, se vuelve a hacer el proceso. Si era una incorrecta, perdiste el juego
gonzaloMS 1:2f8c5940c425 486 if(vecChq[0]+vecChq[1]+vecChq[2]+vecChq[3])==2)
gonzaloMS 1:2f8c5940c425 487 {
gonzaloMS 1:2f8c5940c425 488 if(cantIgual2!=4)
gonzaloMS 1:2f8c5940c425 489 {
gonzaloMS 1:2f8c5940c425 490 check=ENDGAME;
gonzaloMS 1:2f8c5940c425 491 }
gonzaloMS 1:2f8c5940c425 492 if(cantIgual==4)
gonzaloMS 1:2f8c5940c425 493 {
gonzaloMS 1:2f8c5940c425 494 check=CHECK2;
gonzaloMS 1:2f8c5940c425 495 }
gonzaloMS 1:2f8c5940c425 496 }
gonzaloMS 1:2f8c5940c425 497 //Si la segunda que se había desconectado era la correcta y se desconecta otra más, pasa al estado CHECK3
gonzaloMS 1:2f8c5940c425 498 else if(vecChq[0]+vecChq[1]+vecChq[2]+vecChq[3])==3)
gonzaloMS 1:2f8c5940c425 499 {
gonzaloMS 1:2f8c5940c425 500 check=CHECK3;
gonzaloMS 1:2f8c5940c425 501 }
gonzaloMS 1:2f8c5940c425 502 break;
gonzaloMS 1:2f8c5940c425 503
gonzaloMS 1:2f8c5940c425 504 case CHECK3:
gonzaloMS 1:2f8c5940c425 505 //El estado de las entradas al desconectar la tercera se guarda en los vectores
gonzaloMS 1:2f8c5940c425 506 vecChq[0]=E1;
gonzaloMS 1:2f8c5940c425 507 vecChq[1]=E2;
gonzaloMS 1:2f8c5940c425 508 vecChq[2]=E3;
gonzaloMS 1:2f8c5940c425 509 vecChq[3]=E4;
gonzaloMS 1:2f8c5940c425 510 //Se fija si el estado de las 4 entradas corresponde con a la secuencia al desconectar la tercera entrada
gonzaloMS 1:2f8c5940c425 511 for(k=0;k<4;k++)
gonzaloMS 1:2f8c5940c425 512 {
gonzaloMS 1:2f8c5940c425 513 if(vecSec3[k]==vecChq[k])
gonzaloMS 1:2f8c5940c425 514 {
gonzaloMS 1:2f8c5940c425 515 cantIgual3++;
gonzaloMS 1:2f8c5940c425 516 }
gonzaloMS 1:2f8c5940c425 517 }
gonzaloMS 1:2f8c5940c425 518 //Si al desconectar la tercera entrada era la que debía ser según la secuencia, se vuelve a hacer el proceso. Si era una incorrecta, perdiste el juego
gonzaloMS 1:2f8c5940c425 519 if(vecChq[0]+vecChq[1]+vecChq[2]+vecChq[3])==3)
gonzaloMS 1:2f8c5940c425 520 {
gonzaloMS 1:2f8c5940c425 521 if(cantIgual3!=4)
gonzaloMS 1:2f8c5940c425 522 {
gonzaloMS 1:2f8c5940c425 523 check=ENDGAME;
gonzaloMS 1:2f8c5940c425 524 }
gonzaloMS 1:2f8c5940c425 525 if(cantIgual3==4)
gonzaloMS 1:2f8c5940c425 526 {
gonzaloMS 1:2f8c5940c425 527 check=CHECK3;
gonzaloMS 1:2f8c5940c425 528 }
gonzaloMS 1:2f8c5940c425 529 }
gonzaloMS 1:2f8c5940c425 530 //Si la tercera que se había desconectado era la correcta y se desconecta la última, evidentemente es la correcta y ganaste el juego
gonzaloMS 1:2f8c5940c425 531 else if(vecChq[0]+vecChq[1]+vecChq[2]+vecChq[3])==4)
gonzaloMS 1:2f8c5940c425 532 {
gonzaloMS 1:2f8c5940c425 533 check=WINGAME;
gonzaloMS 1:2f8c5940c425 534 }
gonzaloMS 1:2f8c5940c425 535 break;
gonzaloMS 1:2f8c5940c425 536
gonzaloMS 1:2f8c5940c425 537 case ENDGAME:
gonzaloMS 1:2f8c5940c425 538 //Indica que se perdió el juego
gonzaloMS 1:2f8c5940c425 539 fin=1;
gonzaloMS 1:2f8c5940c425 540 check=ENDGAME;
gonzaloMS 1:2f8c5940c425 541 break;
gonzaloMS 1:2f8c5940c425 542
gonzaloMS 1:2f8c5940c425 543 case WINGAME:
gonzaloMS 1:2f8c5940c425 544 //Indica que se ganó el juego
gonzaloMS 1:2f8c5940c425 545 win=1;
gonzaloMS 1:2f8c5940c425 546 check=WINGAME;
gonzaloMS 1:2f8c5940c425 547 break;
gonzaloMS 1:2f8c5940c425 548 }
gonzaloMS 0:d644ac0f96b0 549 }