SIMON

Dependencies:   mbed tsi_sensor

Files at this revision

API Documentation at this revision

Comitter:
gonzaloMS
Date:
Sat Jun 22 00:02:57 2019 +0000
Parent:
0:31131c8fdcfb
Commit message:
Comentado

Changed in this revision

main.cpp Show annotated file Show diff for this revision Revisions of this file
--- a/main.cpp	Wed Jun 19 12:44:51 2019 +0000
+++ b/main.cpp	Sat Jun 22 00:02:57 2019 +0000
@@ -1,53 +1,52 @@
 #include "mbed.h"
 
-enum{MUESTRA,MUESTRA2,NO_MUESTRA,NO_MUESTRA2,NO_INGRESA,INGRESA,ESPERA,FAIL};
+//Creo los estados
+enum{MUESTRA,MUESTRA2,NO_MUESTRA,NO_MUESTRA2,NO_INGRESA,INGRESA,ESPERA,FIN,LEE,APAGA,AGUARDA};
+//   |--------------------------------------|-----------------------------|-----------------|
+//          GENERACIÓN DE SECUENCIA                 CONFIRMACIÓN              PULSADORES
 
-const int MaxElem=5;
+//Defino la cantidad máxima de elementos
+const int MaxElem=24;
 
+//Defino como salidas el led RGB en los tres colores, Red, Green y Blue
 DigitalOut ledR(LED1);
 DigitalOut ledG(LED2);
 DigitalOut ledB(LED3);
 
-DigitalIn E1r(D2);
-DigitalIn E2r(D3);
-DigitalIn E3r(D4);
+//Defino como entradas los 3 pulsadores (para Red, Green y Blue) y el pulsador para el reseteo
+DigitalIn E1r(D2);  //Pulsador para el color Rojo  (R)
+DigitalIn E2r(D3);  //Pulsador para el color Verde (G)
+DigitalIn E3r(D4);  //Pulsador para el color Azul  (B)
 DigitalIn reseteo(D5);
 
+//Variables donde guardo los valores de las entradas de los 3 colores
+int E1; // <-- E1r
+int E2; // <-- E2r
+int E3; // <-- E3r
+
+//Creo los tickers
 Ticker pantalla;
-Ticker leer;
+Ticker mostrarLeds;
 Ticker Interludio;
 
-int HG=1;
-int E1;
-int E2;
-int E3;
+//Las funciones de cada ticker respectivamente
+void visualizaTexto();      //Muestra en el Hercules los datos cada vez que se entra a la función
+void visualizaSecuencia();  //Hace que, cada cierto tiempo, se prenda el led correspondiente a la parte de la secuencia en la que está  
+void tiempoLedsOn();        //Define básicamente cuánto tiempo quedan prendidos los leds antes de apagarse otra vez para esperar el próx.color o botón presionado
+
+//Función encargada del reseteo de todas las variables y volver al estado inicial de cada máquina de estados
+void reset();
 
-int i=0;
-int i2=0;
-int i3=0;
-int i4=0;
-int iMuestra=0;
+//Funciones que son las máquinas de estados
+void detectorPulsado();     //Detecta qué botón de los 3 de colores tocaste quitando el rebote
+void generadorSecuencia();  //Genera la secuencia
+void confirmacion();        //Confirma si lo ingresado con los pulsadores corresponde con la secuencia
 
-int a=0;
-int b=0;
-int c=0;
-
+//Variables que indican los estados de las máquinas de estados
+int estadosPulsadores;
 int estadosSecuencia;
 int estadosConfirm;
 
-int CT=0;
-int EP;
-int LED;
-
-int print=0;
-
-int contar=0;
-
-int j;
-int x;
-int w;
-int p;
-int l=0;
 
 int vecR[MaxElem];
 int vecG[MaxElem];
@@ -56,59 +55,71 @@
 int vecE2[MaxElem];
 int vecE3[MaxElem];
 
-void generadorSecuencia();
-void detectorPulsado();
-void confirmacion();
-void leerFuncion();
-void cutled();
-void pantalleate();
+//Variable que determina si se tiene que generar una nueva secuencia o no (Habilita Generación)
+int HG;
+//Variable que indica la Cantidad Total de posiciones de la secuencia
+int CT=0;
+//Variable que indica en cuál de las posiciones de la secuencia está en el momento (Estado Parcial)
+int EP;
+//Variable que guarda un número random del cuál depende cuál color se va a guardar en esa posición de la secuencia
+int LED;
+
+//Variables que cuentan diferentes cosas
+int iSecuencia=0;   //Posición de la secuencia para generar la secuencia
+int iIngresado=0;   //Cantidad de veces que algo fue ingresado mediante los pulsadores
+int iCorrecto=0;    //Cantidad de veces que lo ingresado fue correcto / coincide con la secuencia
+int iChequeo=0;     //Posición para chequear si lo ingresado fue correcto / coincide con la secuencia
+int iMuestra=0;     //Posición para mostrar la secuencia en los leds 
+
+//Variables que sirven para eliminar el rebote de los pulsadores y detectar solo el flanco ascendente
+int mantieneRojo=0;
+int mantieneVerde=0;
+int mantieneAzul=0;
+
+//Variable que indica si se tienen que mostrar los printf o no en el Hercules
+int print=0;
+//Variable que, según su valor, indica si los leds tienen que estar apagados o mantener su estado
+int decideLedOff=0;
+
+//Variables que se usan para pasar por las posiciones de los vectores cuando estos se tienen que reiniciar o se quiere mostrar la secuencia en el Hercules
+int j;
+int w;
+int p;
+
+//Variable que indica si se tienen que prender los leds con respecto a las posiciones de la secuencia
+int doSec=0;
 
 int main(void) {
+    //Configuro en modo Pull-Up las 4 entradas con pulsadores 
+    E1r.mode(PullUp);
+    E2r.mode(PullUp);
+    E3r.mode(PullUp);
     reseteo.mode(PullUp);
+    //Apago los leds
     ledR=1;
     ledG=1;
     ledB=1;
-    leer.attach(&leerFuncion,0.4);
-    Interludio.attach(&cutled,0.2);
-    pantalla.attach(&pantalleate,1);
-    while (true) {
-        if(reseteo==0)
-        {
-            for(j=0;j<MaxElem;j++){
-                vecR[j]=0;
-                vecG[j]=0;
-                vecB[j]=0;
-                vecE1[j]=0;
-                vecE2[j]=0;
-                vecE3[j]=0;
-            }
-            CT=0;
-            HG=0;
-            EP=0;
-            l=0;
-            contar=0;
-            print=0;
-            LED=0;
-            a=0;
-            b=0;
-            c=0;
-            i=0;
-            i2=0;
-            i3=0;
-            i4=0;
-            estadosSecuencia=NO_MUESTRA;
-            estadosConfirm=NO_INGRESA;
-            
-            
-        }
+    //Asigno las funciones a los tickers
+    pantalla.attach(&visualizaTexto,1);             //Se ejecuta visualizaTexto cada 1 segundo
+    mostrarLeds.attach(&visualizaSecuencia,0.6);    //Se ejecuta visualizaSecuencia cada 0,6 segundos 
+    Interludio.attach(&tiempoLedsOn,0.2);           //Se ejecuta tiempoLedsOn cada 0,2 segundos
+    while(true) {
+        //Llamo a la función reset todo el tiempo
+        reset();
+        //Si la cantidad total de elementos de una secuencia todavía no pasó el máximo permitido, se ejecutan las funciones y muestran los printf
+        //Sino, se para todo y se indica al jugador que debe apretar el botón reset para empezar de nuevo
         if(CT<=MaxElem)
         {
+            detectorPulsado();
+            confirmacion();
+            generadorSecuencia();
             if(print==1)
             {
                 printf("Cant. Total Secuencia:%d \n",CT);
-                printf("Cant. Total de veces Ingresado:%d \n",i2);
-                printf("Cant. Total de veces que fue correcto lo ingresado:%d \n",i3);
+                printf("Cant. Total de veces Ingresado:%d \n",iIngresado);
+                printf("Cant. Total de veces que fue correcto lo ingresado:%d \n",iCorrecto);
                 printf("Secuencia a lograr: \n");
+                printf("R G B \n");
                 for(p=0;p<=(CT-1);p++)
                 {
                     if(CT==MaxElem+1)
@@ -120,43 +131,174 @@
                 printf("\n \n");
                 print=0;   
             }
-            if(l==1)
-            {
-            detectorPulsado();
-            generadorSecuencia();
-            confirmacion();
-            l=0;
-            }
         }
         else
         {
-            if(l==1)
+            if(print==1)
             {
                 printf("Por favor, empiece otra vez \n");
-                l=0;  
+                print=0;  
             }
         }
     }
 }
 
-void pantalleate()
+void reset()
 {
+    //Resetea todas las variables, los vectores y vuelve a los estados iniciales de las máquinas de estados
+    if(reseteo==0)
+    {
+        for(j=0;j<MaxElem;j++)
+        {
+            vecR[j]=0;
+            vecG[j]=0;
+            vecB[j]=0;
+            vecE1[j]=0;
+            vecE2[j]=0;
+            vecE3[j]=0;
+        }
+        CT=0;
+        HG=0;
+        EP=0;
+        doSec=0;
+        decideLedOff=0;
+        print=0;
+        LED=0;
+        mantieneRojo=0;
+        mantieneVerde=0;
+        mantieneAzul=0;
+        iSecuencia=0;
+        iIngresado=0;
+        iCorrecto=0;
+        iChequeo=0;
+        estadosSecuencia=NO_MUESTRA;
+        estadosConfirm=NO_INGRESA;        
+    }
+}
+
+void visualizaTexto()
+{
+    //Cada 1 segundo, esto se pone en 1 para mostrar los printf. Al instante se vuelve 0 y deja de mostrar los printf, esperando que se vuelva a llamar a la función
     print=1;   
 }
 
-void cutled()
+void visualizaSecuencia()
+{
+    //Cada 0,6 segundos, la variable se hace 1. Cuando llegue la parte de mostrar la secuencia, la variable se va a hacer 0 y va a esperar a que se llame a la función otra vez
+    doSec=1;     
+}
+
+void tiempoLedsOn()
 {   
-    if(contar%2==0)
+    //Cada 0,2 segundos, se le suma 1 a la variable y, cada vez que es par, apaga los leds sin importar sus estados anteriores
+    if(decideLedOff%2==0)
     {
         ledR=1;
         ledG=1;
         ledB=1;
     }
-    contar++;
+    decideLedOff++;
 }
-void leerFuncion()
+
+void detectorPulsado()
 {
-    l=1;     
+    switch(estadosPulsadores)
+    {
+        default:
+        case LEE:
+        //Espera a que se toque el pulsador de rojo
+        //Si es así guarda eso en los vectores, pone la variable E1 en 1, suma 1 a iIngresado y prende el led rojo, que va a ser apagado por la función tiempoLedsOn
+        //También se pone en 1 la variable mantieneRojo que es un indicador del estado anterior
+        //Cambia el estado a APAGA
+        if(E1r==0 && mantieneRojo==0)
+        {
+            E1=1;
+            mantieneRojo=1;
+            vecE1[iIngresado]=1;
+            vecE2[iIngresado]=0;
+            vecE3[iIngresado]=0;
+            ledR=0;
+            iIngresado++;
+            estadosPulsadores=APAGA;
+        }
+        //Espera a que se toque el pulsador de Verde
+        //Si es así guarda eso en los vectores, pone la variable E2 en 1, suma 1 a iIngresado y prende el led verde, que va a ser apagado por la función tiempoLedsOn
+        //También se pone en 1 la variable mantieneVerde que es un indicador del estado anterior
+        //Cambia el estado a APAGA
+        if(E2r==0 && mantieneVerde==0)
+        {
+            E2=1;
+            mantieneVerde=1;
+            vecE1[iIngresado]=0;
+            vecE2[iIngresado]=1;
+            vecE3[iIngresado]=0;
+            ledG=0;
+            iIngresado++;
+            estadosPulsadores=APAGA;
+        }
+        //Espera a que se toque el pulsador de Azul
+        //Si es así guarda eso en los vectores, pone la variable E3 en 1, suma 1 a iIngresado y prende el led verde, que va a ser apagado por la función tiempoLedsOn
+        //También se pone en 1 la variable mantieneAzul que es un indicador del estado anterior
+        //Cambia el estado a APAGA
+        if(E3r==0 && mantieneAzul==0)
+        {
+            E3=1;
+            mantieneAzul=1;
+            vecE1[iIngresado]=0;
+            vecE2[iIngresado]=0;
+            vecE3[iIngresado]=1;
+            ledB=0;
+            iIngresado++;
+            estadosPulsadores=APAGA;
+        }
+        break;
+        
+        case APAGA:
+        //Si el pulsador de uno de los colores se mantiene pulsado y ya pasó por el estado anterior, E1 se vuelve 0 (E1 va a estar en 1 por muy poco tiempo)
+        //Se pasa al estado AGUARDA
+        if(E1r==0 && mantieneRojo==1)
+        {
+            E1=0;
+            estadosPulsadores=AGUARDA;
+        }
+        //Si el pulsador de uno de los colores se mantiene pulsado y ya pasó por el estado anterior, E2 se vuelve 0 (E2 va a estar en 1 por muy poco tiempo)
+        //Se pasa al estado AGUARDA
+        if(E2r==0 && mantieneVerde==1)
+        {
+            E2=0;
+            estadosPulsadores=AGUARDA;
+        }
+        //Si el pulsador de uno de los colores se mantiene pulsado y ya pasó por el estado anterior, E3 se vuelve 0 (E3 va a estar en 1 por muy poco tiempo)
+        //Se pasa al estado AGUARDA
+        if(E3r==0 && mantieneAzul==1)
+        {
+            E3=0;
+            estadosPulsadores=AGUARDA;
+        }
+        break;
+        
+        case AGUARDA:
+        //Si ya se tocó el pulsador una vez y ahora se suelta, el E se mantiene como estaba, se indica con la otra variable que terminó el proceso y vuelve al estado LEE
+        if(E1r==1 && mantieneRojo==1)
+        {
+            E1=0;
+            mantieneRojo=0;
+            estadosPulsadores=LEE;
+        }
+        if(E2r==1 && mantieneVerde==1)
+        {
+            E2=0;
+            mantieneVerde=0;
+            estadosPulsadores=LEE;
+        }
+        if(E3r==1 && mantieneAzul==1)
+        {
+            E3=0;
+            mantieneAzul=0;
+            estadosPulsadores=LEE;
+        }
+        break;   
+    }
 }
 
 void confirmacion(){
@@ -164,52 +306,67 @@
     {
         default:
         case NO_INGRESA:
+        //Se reinicia el contenido de los vectores de entrada, así cuando completás una secuencia tenés que escribir toda la que sigue desde cero
+        //El contenido de los vectores de secuencia, que guardan los colores y su posición en la secuencia, no se reinicia porque es parte del juego que la secuencia
+        //siguiente siempre es igual que la anterior solo que con un color random más agregado al final
         for(w=0;w<MaxElem;w++)
         {
             vecE1[w]=0;
             vecE2[w]=0;
             vecE3[w]=0;
         }
-        i2=0;
-        i4=0;
-        i3=0;
+        //Se reinician los indicadores cuando completás una secuencia
+        iIngresado=0;
+        iChequeo=0;
+        iCorrecto=0;
+        //Se habilita la generación de una nueva secuencia
         HG=1;
+        //Se pasa directamente al siguiente estado
         estadosConfirm=ESPERA;
         break;
         
         case INGRESA:
-        i4++;
+        //Se le suma 1 a iChequeo para que la proxima vez que se ingrese algo lo verifique con la siguiente posición de la secuencia
+        iChequeo++;
+        //Pasa directamente a ESPERA
         estadosConfirm=ESPERA;
         break;
         
         case ESPERA:
+        //Automáticamente se deshabilita la generación
         HG=0;
+        //Si no se ingresa nada mediante los pulsadores, queda en ESPERA
         if(E1==0 && E2==0 && E3==0)
         {
             estadosConfirm=ESPERA;
         }
+        //Si se ingresa algo, se fija si esa posición concuerda con la misma posición de la secuencia
+        //De ser correcto, va a INGRESA
+        //De ser incorrecto, el jugador perdió cambia el estado a FIN
         else
         {
-            if(i3!=CT)
+            if(iCorrecto!=CT)
             {
-                if((vecR[i4]==vecE1[i4]) && (vecG[i4]==vecE2[i4]) && (vecB[i4]==vecE3[i4]))
+                if((vecR[iChequeo]==vecE1[iChequeo]) && (vecG[iChequeo]==vecE2[iChequeo]) && (vecB[iChequeo]==vecE3[iChequeo]))
                 {
-                    i3++; 
+                    iCorrecto++; 
                     estadosConfirm=INGRESA;
                 }
                 else
                 {
-                    estadosConfirm=FAIL;   
+                    estadosConfirm=FIN;   
                 }
             }
         }
-        if(i3==CT)
+        //Si se ingresó toda la secuencia correctamente, vuelve al estado inicial NO_INGRESA donde se va a habilitar una nueva generación y reiniciar variables
+        if(iCorrecto==CT)
         {
             estadosConfirm=NO_INGRESA;
         }
         break;
         
-        case FAIL:
+        case FIN:
+        //En caso de perder, se hace que CT sea mayor a la máxima cantidad de elementos posibles, condición en la que se termina el juego y espera el reseteo
         CT=MaxElem+1;
         break;
     }
@@ -219,136 +376,93 @@
     {
         default:
         case NO_MUESTRA:
-            LED=0;
-            if(HG==0)
-            {
-                estadosSecuencia=NO_MUESTRA;
-            }
-            else
-            {
-                estadosSecuencia=NO_MUESTRA2;
-            }
-            break;
+        //La variable LED empieza en 0, que no hace nada
+        LED=0;
+        //Si se habilitó la generación de una secuencia, pasa al siguiente estado, NO_MUESTRA2
+        //Sino, se queda en este estado
+        if(HG==0)
+        {
+            estadosSecuencia=NO_MUESTRA;
+        }
+        else
+        {
+            estadosSecuencia=NO_MUESTRA2;
+        }
+        break;
         
         case NO_MUESTRA2:
+        //De ser habilitada la generación de una nueva secuencia, se le suma 1 a la cantidad total de elementos/posiciones que va a tener la secuencia
+        //CT empieza en 0, cuando se habilita la generación, CT pasa a ser 1, entonces dentro de la secuencia solo va a haber un color random
+        //Cuando se toque bien ese color, vuelve a generar una secuencia, solo que ahora va a hacer CT++ otra vez y la secuencia va a constar de 2 colores random
         CT++;
+        //Pasa a MUESTRA directamente
         estadosSecuencia=MUESTRA;
         break;
         
         case MUESTRA:
-            if(EP!=CT)
+        //Si el estado parcial en que se encuentra no es último de la secuencia, hace que LED sea un número random entre 1 y 3
+        //Basado en eso decide que color corresponde a ese estado parcial/posición de la secuencia
+        //Eso lo guarda en los vectores de secuencia, que tienen qué color corresponde a qué posición
+        //EP empieza en 0 y solo se reinicia en el reset, de manera que siempre se va a añadir un color random al final de la secuencia anterior para hacer la nueva
+        if(EP!=CT)
+        {
+            LED=rand()%3+1;
+            if(LED==1)
+            {
+                vecR[iSecuencia]=1;
+                vecG[iSecuencia]=0;
+                vecB[iSecuencia]=0;
+            }
+            else if(LED==2)
+            {
+                vecR[iSecuencia]=0;
+                vecG[iSecuencia]=1;
+                vecB[iSecuencia]=0;
+            }
+            else if(LED==3)
             {
-                LED=rand()%3+1;
-                if(LED==1)
-                {
-                    vecR[i]=1;
-                    vecG[i]=0;
-                    vecB[i]=0;
-                }
-                else if(LED==2)
-                {
-                    vecR[i]=0;
-                    vecG[i]=1;
-                    vecB[i]=0;
-                }
-                else if(LED==3)
-                {
-                    vecR[i]=0;
-                    vecG[i]=0;
-                    vecB[i]=1;
-                }
-                if(i<CT)
-                {
-                    i++;
-                }
-                EP++;
+                vecR[iSecuencia]=0;
+                vecG[iSecuencia]=0;
+                vecB[iSecuencia]=1;
+            }
+            if(iSecuencia<CT)
+            {
+                iSecuencia++;
             }
-            else
-            {
-                estadosSecuencia=MUESTRA2;
-            }
-            break;
+            EP++;
+        }
+        //Al hacerlo una vez, EP pasa a ser igual que CT, por lo que cambia al estado MUESTRA2 y espera a que el proceso se vuelva a hacer para que CT valga más que EP
+        //(En el estado anterior con CT++)
+        else
+        {
+            estadosSecuencia=MUESTRA2;
+        }
+        break;
             
-            case MUESTRA2:
+        case MUESTRA2:
+        //Cada 1 segundo que doSec se hace 1 y pasa a ser 0 instantáneamente, los leds se prenden con respecto a la secuencia generada (guardada en los vectores)
+        //Se apagan con la funcion tiempoLedsOn
+        //El estado de los leds es igual a lo que contiene la posición del vector -negado- porque los leds se prenden con 0, no con 1
+        //Los vectores guardan con 1 los leds que se tienen que prender
+        //Cuando se muestra toda la secuencia en los leds, se reinicia iMuestra y vuelve al estado inicial NO_MUESTRA
+        if(doSec==1)
+        {
+            //La secuencia se guarda desde la posición 0 de los vectores. La primera secuencia se hace con CT=1. Por eso el CT-1
             if(iMuestra<=CT-1)
             {
                 ledR=!vecR[iMuestra];
                 ledG=!vecG[iMuestra];
                 ledB=!vecB[iMuestra];
                 iMuestra++;
-                estadosSecuencia=MUESTRA2;
             }
             else
             {
                 iMuestra=0;
                 estadosSecuencia=NO_MUESTRA;
             }
-            break;
+            doSec=0;
+        }
+        break;
     }
 }
 
-void detectorPulsado()
-{
-    if(E1r==1 && a==0)
-    {
-        E1=1;
-        a=1;
-        vecE1[i2]=1;
-        vecE2[i2]=0;
-        vecE3[i2]=0;
-        ledR=0;
-        i2++;
-    }
-    else if(E1r==1 && a==1)
-    {
-        ledR=1;
-        E1=0;
-    }
-    else if(E1r==0 && a==1)
-    {
-        E1=0;
-        a=0;
-    }
-    
-    if(E2r==1 && b==0)
-    {
-        E2=1;
-        b=1;
-        vecE1[i2]=0;
-        vecE2[i2]=1;
-        vecE3[i2]=0;
-        ledG=0;
-        i2++;
-    }
-    else if(E2r==1 && b==1)
-    {
-        ledG=1;
-        E2=0;
-    }
-    else if(E2r==0 && b==1)
-    {
-        E2=0;
-        b=0;
-    }
-
-    if(E3r==1 && c==0)
-    {
-        E3=1;
-        c=1;
-        vecE1[i2]=0;
-        vecE2[i2]=0;
-        vecE3[i2]=1;
-        ledB=0;
-        i2++;
-    }
-    else if(E3r==1 && c==1)
-    {
-        ledB=1;
-        E3=0;
-    }
-    else if(E3r==0 && c==1)
-    {
-        E3=0;
-        c=0;
-    }
-}
\ No newline at end of file