File content as of revision 0:fd466ee999a6:

#include "mbed.h"
#include "tsi_sensor.h"

#define ELEC0 9
#define ELEC1 10

/*  Defino esas palabras que luego usaré para
lo que se pulsa en el TSI como numeros usando la funcion
"enum{}"
*/
enum {NADA,
      ROJO,
      VERDE,
      AZUL
     };

/*  Defino los nombres de los estados como
numeros enteros con la funcion "enum{}"
*/

enum {ESPERO_USUARIO,
      MUESTRO_SECUENCIA,
      COMPARO_SECUENCIA
     };

enum {ESPERO_HAB,
      MUESTRO,
      APAGO
     };

enum {ESPERAR_HAB,
      ESPERAR_USUARIO,
      COMPARO
     };

#define ERROR 15
#define CORRECTO 24

TSIAnalogSlider tsi(ELEC0, ELEC1, 40);

// Prototipos de funciones de maquinas de estados
void MAQ_SECUENCIA();
void MAQ_MUESTREO();
void MAQ_COMPARO();

void MAQ_lecturaTSI();

void LEER_TSI();    //Prototipo funcion de lectura del TSI

void LED_1SEG();


void pulsacion_TSI();



void genero_secuencia(); // Funcion que utilizo para generar la secuencia aleatoria.

//Variables que indican el estado de las maquinas (empiezo en estado de reset)
int estado_maq_sec = ESPERO_USUARIO;
int estado_maq_mues = ESPERO_HAB;
int estado_maq_comp = ESPERAR_HAB;

int estado_maq_tsi = NADA;

//Variables que habilitan maquinas de estados
int hab_mostrar = 0;
int hab_comparo = 0;

//Variables que me indican el fin de una maquina de estados
int fin_mostrar = 0;
int fin_comparo = 0;

//Variables que acumulan datos

int color[25]; //Esta variable contendrá toda la secuencia aleatoria de 24 valores (no voy a usar el valor 0).
int nivel = 0;
int tiempo_muestreo = 0;
int color_teclado = NADA;
int ingreso = NADA;

int var_pulsacion = 25;

Ticker lectura;
Ticker temporizador;

Ticker pulsacion;

// DEFINO SALIDAS

DigitalOut ledrojo(LED_RED);
DigitalOut ledverde(LED_GREEN);
DigitalOut ledazul(LED_BLUE);
AnalogIn noise(PTB0);


int main(void)
{

    lectura.attach(LEER_TSI,0.1);
    pulsacion.attach(pulsacion_TSI,0.001);

    temporizador.attach(LED_1SEG,0.01);


    ledrojo = 1;
    ledverde= 1;
    ledazul = 1;

    while (true) {

        MAQ_lecturaTSI();

        MAQ_SECUENCIA();

        MAQ_MUESTREO();

        MAQ_COMPARO();

    }
}

void LEER_TSI()
{
    float auxiliar = 0;
    auxiliar = tsi.readPercentage();

    if(auxiliar == 0) {
        color_teclado = NADA;
    }

    if((auxiliar > 0)&&(auxiliar < 0.33)) {
        color_teclado = ROJO;
    }

    if((auxiliar >= 0.33)&&(auxiliar <= 0.66)) {
        color_teclado = VERDE;
    }

    if((auxiliar > 0.66)&&(auxiliar <= 1)) {
        color_teclado = AZUL;
    }
}

void pulsacion_TSI()
{
    if(var_pulsacion > 0) {
        var_pulsacion--;
    }
}

void MAQ_lecturaTSI()
{
    if(var_pulsacion < 1) {
        var_pulsacion = 25;
        switch(estado_maq_tsi) {
            case NADA:
                ingreso = NADA;
                switch(color_teclado) {
                    case ROJO:
                        estado_maq_tsi = ROJO;
                        ingreso = ROJO;
                        break;
                    case VERDE:
                        estado_maq_tsi = VERDE;
                        ingreso = VERDE;
                        break;
                    case AZUL:
                        estado_maq_tsi = AZUL;
                        ingreso = AZUL;
                        break;
                }
                break;
            case ROJO:
                switch(color_teclado) {
                    case NADA:
                        estado_maq_tsi = NADA;
                        break;
                    case VERDE:
                        estado_maq_tsi = VERDE;
                        ingreso = VERDE;
                        break;
                    case AZUL:
                        estado_maq_tsi = AZUL;
                        ingreso = AZUL;
                        break;
                }
                break;
            case VERDE:
                switch(color_teclado) {
                    case NADA:
                        estado_maq_tsi = NADA;
                        break;
                    case ROJO:
                        estado_maq_tsi = ROJO;
                        ingreso = ROJO;
                        break;
                    case AZUL:
                        estado_maq_tsi = AZUL;
                        ingreso = AZUL;
                        break;
                }
                break;
            case AZUL:
                switch(color_teclado) {
                    case NADA:
                        estado_maq_tsi = NADA;
                        break;
                    case ROJO:
                        estado_maq_tsi = ROJO;
                        ingreso = ROJO;
                        break;
                    case VERDE:
                        estado_maq_tsi = VERDE;
                        ingreso = VERDE;
                        break;
                }
                break;
        }
    }
}

void LED_1SEG()
{
    if(tiempo_muestreo >= 0) {
        tiempo_muestreo--;
    }
}


void MAQ_SECUENCIA()
{

    switch(estado_maq_sec) {    //El switch variará entre los distintos estados de mi maquina (los numeros correspondientes se encuentran en el "enum{}" al inicio del codigo)

        case ESPERO_USUARIO:
            if(ingreso != NADA) {
                genero_secuencia();
                nivel++;
                hab_mostrar = 1;
                estado_maq_sec = MUESTRO_SECUENCIA;
                ingreso = NADA;
            }
            break;

        case MUESTRO_SECUENCIA:

            if(fin_mostrar == 1) {
                fin_mostrar = 0;
                estado_maq_sec = COMPARO_SECUENCIA;
                hab_comparo = 1;
            }

            break;

        case COMPARO_SECUENCIA:

            if(fin_comparo == 1) {
                fin_comparo = 0;
                estado_maq_sec = MUESTRO_SECUENCIA;
                hab_mostrar = 1;
                nivel++;

            }
            break;
    }
}

void MAQ_MUESTREO()
{

    static int nivel_mostrado;  // Variable que voy a tener para saber que nivel estoy mostrando en los leds ahora

    switch(estado_maq_mues) {   // Uso un switch para variar entre los estados de la maquina

        case ESPERO_HAB:

            nivel_mostrado = 1; // El primer nivel que muestro es 1, asi que reseteo esta variable cada vez que paso por este estado

            if(hab_mostrar == 1) {  // Cuando recibo la habilitacion de la otra maquina de estados:

                estado_maq_mues = MUESTRO;  // Cambio de estado y
                tiempo_muestreo = 100;  // Establezco el tiempo en 1 seg (0.01seg * 100 = 1seg)
                hab_mostrar = 0;

            }
            break;

        case MUESTRO:

            switch(color[nivel_mostrado]) { // Muestro el color correspondiente al primer nivel, y voy cambiando cada 2 segundos
                case ROJO:
                    ledrojo = 0;
                    break;

                case VERDE:
                    ledverde = 0;
                    break;

                case AZUL:
                    ledazul = 0;
                    break;
            }

            if(tiempo_muestreo == 0) {  // Si pasó 1 segundo, reseteo el tiempo y cambio de estado
                tiempo_muestreo = 100;  // Establezco el tiempo en 1 segundo otra vez
                estado_maq_mues = APAGO;    // Cambio de estado
            }
            break;

        case APAGO:

            switch(color[nivel_mostrado]) { // Ahora voy a apagar el led correspondiente al nivel que se esta mostrando.
                case ROJO:
                    ledrojo = 1;
                    break;
                case VERDE:
                    ledverde = 1;
                    break;
                case AZUL:
                    ledazul = 1;
                    break;
            }
            if(tiempo_muestreo == 0) {
                if(nivel_mostrado == nivel) {
                    nivel_mostrado = 1;
                    estado_maq_mues = ESPERO_HAB;
                    fin_mostrar = 1;
                } else {
                    estado_maq_mues = MUESTRO;
                    nivel_mostrado++;
                    tiempo_muestreo = 100;
                }
            }
            break;


    }


}

void MAQ_COMPARO()
{


    static int nivel_comparado; // Variable que voy a usar para comparar todos los niveles sucesivamente, con lo que se vaya ingresando en el TSI
    static int obtenido = NADA;

    switch(estado_maq_comp) {
        case ESPERAR_HAB:

            nivel_comparado = 1; // Establezco en este estado el primer nivel que se va a comparar (el 1)

            if(hab_comparo == 1) {  // Si recibí habilitacion desde la otra maquina, cambio de estado
                estado_maq_comp = ESPERAR_USUARIO;
                hab_comparo = 0;
            }

            break;

        case ESPERAR_USUARIO:

            if(ingreso != NADA) { // Si se ingresa algo en el TSI, lo guardo en la variable "teclado"
                obtenido = ingreso;
                ingreso = NADA;
                estado_maq_comp = COMPARO;
            }

            break;

        case COMPARO:   //Estado donde comparo el valor que se ingresó con el valor que corresponde

            if(obtenido == color[nivel_comparado]) {
                switch(color[nivel_comparado]) {
                    case ROJO:
                        printf("rojo\n");
                        break;
                    case VERDE:

                        printf("verde\n");
                        break;
                    case AZUL:
                        printf("azul\n");
                        break;


                }


                obtenido = NADA;
                if(nivel_comparado <= nivel) {
                    estado_maq_comp = ESPERAR_USUARIO;  //Vuelvo al estado de esperar que el usuario ingrese algo y
                    nivel_comparado++;  // Paso al siguiente nivel.
                }
                if(nivel_comparado > nivel) {
                    estado_maq_comp = ESPERAR_HAB;  // Reseteo la maquina
                    fin_comparo = 1;
                }

            } else {
                estado_maq_comp = ESPERAR_HAB;  // Reseteo la maquina
                fin_comparo = 1;    // Marco error
                printf("ERROR");
                printf("ERROR");
                printf("ERROR");
                printf("ERROR");
                printf("ERROR\n");

            }
            break;
    }
}

void genero_secuencia()
{
    int auxiliar;

    srand(int (noise * 10000)); // Cambio la semilla de la funcion rand usando un valor de ruido en una entrada analogica al aire

    for(int i = 1; i <=25 ; i++) {  // Creo un for para recorren las 25 posiciones de memoria del vector "color[]" (el valor 0 no lo utilizo)


        auxiliar = rand();  //Genero un valor aleatorio y lo guardo en mi variable auxiliar

        // Dependiendo de cuanto resto me de al dividir por 3, asignare ese valor aleatorio con un color
        if((auxiliar % 3) == 0) {
            color[i] = ROJO;
        }

        if((auxiliar % 3 )== 1) {
            color[i] = VERDE;
        }

        if((auxiliar % 3 )== 2) {
            color[i] = AZUL;
        }
        switch(color[i]) {
            case ROJO:
                printf("%i ROJO;",i);
                break;
            case VERDE:
                printf("%i VERDE;",i);
                break;
            case AZUL:
                printf("%i AZUL;",i);
                break;
        }
    }
    printf("\n");
}