Este es un gran reto de programación con Arduino.
Analiza el programa adjunto y configura una placa con cuatro leds. Ubícalos físicamente en un círculo.
Posteriormente, al lado de cada led, pon un pulsador y conectalo con la placa.

Conecta los ocho componentes correctamente, de manera que a cada led le corresponda un pulsador en el mismo orden (1,2,3,4)

Responde a las siguientes preguntas:

¿ Para qué sirve el vector global llamado secuencia_secreta?
¿ Cuántos elementos tiene?
¿ Qué contiene cada elemento del vector?
¿ Qué función carga el contenido inicial ?

¿ Para qué sirve la función denominada muestra_uno(num_led, duracion) ?
¿ Cuántos parámetros tiene ?
¿ Para qué sirve cada uno ?

¿ Para qué sirve la función muestra_todos_hasta(posicion) ?
¿ Para qué sirve el parámetro posicion ?

¿ Qué hace la  función denominada espera_y_comprueba_uno(num_led) ?
¿ Para qué sirve el parámetro num_led ?
¿ En qué condiciones devuelve el valor 1 ?
¿ En qué condiciones devuelve el valor 0 ?
¿ Quién recibe ese valor devuelto ?

¿ Qué hace la  función llamada comprueba_todos_hasta(posicion) ?
¿ Para qué sirve el parámetro num_led ?
¿ En qué condiciones devuelve el valor 1 ?
¿ En qué condiciones devuelve el valor 0 ?
¿ Quién recibe ese valor devuelto ?



Finalmente, crea tu mismo el contenido del bucle loop.

En dicho bucle aparecerá una variable llamada posicion_actual, que comenzará con valor cero.
Posteriormente, se ejecutará una llamada a muestra_todos_hasta(posicion_actual).
Tras ella, una llamada a comprueba_todos_hasta(posicion_actual).
Cada vez que esta función devuelva un valor 1, se incrementará la variable posicion_actual.
Si devuelve cero, el juego habrá finalizado y el jugador habrá perdido.

Además, si posición_actual llega hasta el final de secuencia_secreta, el juego habrá finalizado y el jugador habrá ganado.

Usa las funciones fallo y acierto para indicar cuándo se gana y cuándo se pierde el juego

//////////////////////////////////////////////////////
////// DECLARACIONES Y DEFINICIONES GENÉRICAS ////////
//////////////////////////////////////////////////////

#define NOTE_A3  220
#define NOTE_AS3 233
#define NOTE_B3  247
#define NOTE_C4  262
int tonos[] = {NOTE_A3, NOTE_AS3, NOTE_B3, NOTE_C4 };

// Constantes de pines
#define PIN_DEL_P1 6        // Entrada digital del p1
#define PIN_DEL_P2 7        // Entrada digital del p2
#define PIN_DEL_P3 8        // Entrada digital del p3
#define PIN_DEL_P4 10       // Entrada digital del p4
int pulsadores[] = {PIN_DEL_P1, PIN_DEL_P2, PIN_DEL_P3, PIN_DEL_P4};

#define PIN_DEL_PIEZO 9     // Salida PWM del piezo

#define PIN_DEL_L1  2       // Salida digital del l1
#define PIN_DEL_L2 3        // Salida digital del l2
#define PIN_DEL_L3 4        // Salida digital del l3
#define PIN_DEL_L4 5        // Salida digital del l4
int leds[] = {PIN_DEL_L1, PIN_DEL_L2, PIN_DEL_L3, PIN_DEL_L4};



// Declaración de variables y objetos globales
int valor_dig_del_p1 = 0 ;  //[num 0-1]
int valor_dig_del_p2 = 0 ;  //[num 0-1]
int valor_dig_del_p3 = 0 ;  //[num 0-1]
int valor_dig_del_p4 = 0 ;  //[num 0-1]


#define MAX_RECORDAR 15
char  secuencia_secreta[MAX_RECORDAR];

void carga_secuencia_secreta() {
  for (int i = 0; i < MAX_RECORDAR; i++) {
    secuencia_secreta[i] = random(0, 3);
  }

}

void  muestra_uno(int num_led, int duracion) {

  digitalWrite(leds[num_led], HIGH);
  analogWrite(PIN_DEL_PIEZO, tonos[num_led]);
  delay(duracion / 2);
  digitalWrite(leds[num_led], LOW);
  delay(duracion / 2);

}

void muestra_todos_hasta(int posicion) {
  for (int i = 0; i < posicion; i++) {
    muestra_uno(posicion, 500);
    delay(600);
  }

}

int espera_y_comprueba_uno(int num_led) {

  do { // Lectura de los sensores.
    valor_dig_del_p1 = digitalRead( PIN_DEL_P1 );        // valor_dig_del_p1 es un 0 o un 1
    valor_dig_del_p2 = digitalRead( PIN_DEL_P2 );        // valor_dig_del_p2 es un 0 o un 1
    valor_dig_del_p3 = digitalRead( PIN_DEL_P3 );        // valor_dig_del_p3 es un 0 o un 1
    valor_dig_del_p4 = digitalRead( PIN_DEL_P4 );        // valor_dig_del_p4 es un 0 o un 1
  } while (valor_dig_del_p1 && valor_dig_del_p2 && valor_dig_del_p3 && valor_dig_del_p4 == LOW);

  if (valor_dig_del_p1 == HIGH && num_led == 0) {
    return (1);
  }
  if (valor_dig_del_p2 == HIGH && num_led == 1) {
    return (1);
  }
  if (valor_dig_del_p3 == HIGH && num_led == 2) {
    return (1);
  }
  if (valor_dig_del_p4 == HIGH && num_led == 3) {
    return (1);
  }

  return (0);

}


int  comprueba_todos_hasta(int posicion) {
  for (int i = 0; i < posicion; i++) {
    if (espera_y_comprueba_uno(secuencia_secreta[posicion]) == 0) {
      return (0);
    }
    return (1);
  }
}

void fallo() {
  digitalWrite(0, HIGH);
  digitalWrite(1, HIGH);
  delay(10000);
}

void acierto() {
  digitalWrite(2, HIGH);
  digitalWrite(3, HIGH);
  delay(10000);
}


//////////////////////////////////////////////////////
//////////  DEFINICIÓN DE LA INICIALIZACIÓN //////////
//////////////////////////////////////////////////////

void setup( ) {
  // pinMode de los pines digitales de salida.
  randomSeed(analogRead(A0));
  pinMode( PIN_DEL_L1 , OUTPUT );
  pinMode( PIN_DEL_L2 , OUTPUT );
  pinMode( PIN_DEL_L3 , OUTPUT );
  pinMode( PIN_DEL_L4 , OUTPUT );

  carga_secuencia_secreta();
  muestra_todos_hasta(4);

} // fin de la definición de la función de INICIALIZACIÓN setup( )


//////////////////////////////////////////////////////
////////////// DEFINICIÓN DEL PROGRAMA ///////////////
//////////////////////////////////////////////////////

void loop( ) {


  

} // fin de definición de la función de PROGRAMA loop( )