Proyectos con Arduino.

Blog de proyectos de Arduino de alumnos de la URJC

La RuleTrago

por · 14/12/2021

Proyecto del Grupo 6 (Juan de Carlos López, Raúl Llona Cabeza e Iker Suarez Amutxastegi) de la asignatura de Diseño de Sistemas Empotrados de la Universidad Rey Juan Carlos, curso 2021/22.

En este proyecto de Arduino se va a crear una máquina para jugar por turnos a diversos juegos en grupo (mediante botones y LEDs), cuyo resultado causa que se dispensen chupitos (utilizando una bomba de agua).

Reglas del juego

En cada turno, al jugador que le toque pulsa el botón situado en la parte superior izquierda, que activa la ruleta de LEDs de colores situada en la parte superior, la cual gira hasta detenerse aleatoriamente en uno de los 5 LEDs. Cada color indica que se debe hacer:

LED Verde: (1 jugador) No ocurre nada, se pasa al siguiente jugador.

LED Rojo: (1 jugador) La máquina dispensa un chupito que el jugador debe tomar.

LED Azul: (1 jugador) Se inicia una secuencia de memoria en los LEDs azules de la parte inferior de la máquina, el jugador debe memorizar la secuencia y pulsar en orden los botones a los que corresponden cada LED. Hay 2 resultados posibles:

  • Falla la secuencia: se enciende un LED Rojo, y la máquina dispensa un chupito.
  • Acierta la secuencia: se enciende un LED Verde, y el jugador no bebe.

LED Amarillo: (2 jugadores) El jugador que ha tirado de la ruleta debe pulsar uno de los tres botones; posteriormente tiene que retar a un segundo jugador, el cual tiene que adivinar que botón ha sido presionado y pulsarlo también. Hay 2 resultados posibles:

  • Falla el botón: se enciende un LED Rojo junto a un LED azul para indicar que botón era el correcto; y la máquina sirve un chupito que el jugador 2 debe beber.
  • Acierta el botón: se enciende un LED Verde; y la máquina sirve un chupito que el jugador 1 debe beber.

LED Morado: (2 jugadores) Al igual que en el caso anterior, el jugador que ha tirado de la ruleta reta a otro. Este caso es un juego de reacción, cada jugador escoge 1 botón (izquierdo o derecho) y espera a que se iluminen los LEDs azules; en cuanto esto ocurra, ambos jugadores deben tratar de pulsar su botón lo antes posible. La máquina iluminará el LED del ganador. La máquina sirve un chupito que el perdedor debe beber.

Video Explicativo

Componentes

Nombre del ComponenteUnidadesPrecio

Arduino UNO		1Provista por la URJC

Bomba de Agua		13,50€

Batería 9v		12,50€

Acoplador de Batería 9v		10,40€

Relé de 5v		13,50€

Pulsador		40,40€

Placa de Prototipado		12,50€

Diodos LED de Colores		100,10 – 0,50€
Depende del Color

Cables Puente		~403,10€

Resistencias		100,15€

Tubo de Plástico		10,30 – 0,80€

Tablas de Madera		210€

Hardware

La implementación hardware del proyecto se divide en tres partes: conexiones de LEDs, conexiones de botones y conexión de la bomba de agua.

Para el correcto funcionamiento de la bomba de agua es necesaria la utilización de un relé y una batería de 9v. El relé es el encargado de abrir y cortar la señal sobre la bomba de agua, mientras que la batería aporta la energía necesaria para ponerla en marcha.

Esquema de Conexiones

Montaje

Todo el proyecto se ha construido sobre una caja de madera montada a medida para encajar todos los elementos que necesita la máquina. En la parte frontal de la caja se encuentran dispuestos todos los botones y leds para jugar:

En la parte posterior, se encuentra el recipiente de donde se extrae la bebida a servir, en dicho recipiente se encuentra la bomba que está conectada a la batería y al relé. A su vez, en la boca de la bomba está puesto el tubo de plástico por donde fluye la bebida hasta el vaso de chupito.

En el interior de la caja se encuentran todos los componentes electrónicos y todas las conexiones. De tal forma que quedan aislados de posibles vertimientos de la bebida.

Código

//Leds Ruleta
int led1 = A0;
int led2 = A1;
int led3 = 11;
int led4 = 10;
int led5 = 5;
int leds[] = {led1, led2, led3, led4, led5};

//Leds botones
int ledB0 = 2;
int ledB1 = 3;
int ledB2 = 4;
int ledsB[] = {ledB0, ledB1, ledB2};

//Leds Acierto / Error
int ledV = 12;
int ledR = 13;

//Botones
int botonInicio = A5;
int boton0 = A4;
int boton1 = A3;
int boton2 = A2;
int boton[] = {boton0, boton1, boton2};

//Variables para guardar el estado de los botones
int botonEstadoInicio = 0;
int botonEstado0 = 0;
int botonEstado1 = 0;
int botonEstado2 = 0;
int botonEstado[] = {botonEstado0, botonEstado1, botonEstado2};

//Variables juego reto
int botonEstado0a = 0;
int botonEstado1a = 0;
int botonEstado2a = 0;

//Variables juego memoria
int turno;
int numTurnos = 5;
int orden[5];
boolean parar;

//Variables juego reaccion
int tiempoReaccion;

//Estado general
int estado = 0;
int juego = 0;

//Variables
int t;
int c;
int j;
int aux;

//Variables para controlar los tiempos de ejecución
unsigned long tiempoAnterior;
unsigned long tiempo;

//Valor aleatorio
int num;

//Relay
int relay = 9;

void setup() {
  Serial.begin(9600);
  randomSeed(analogRead(6));
  pinMode(led1, OUTPUT);
  pinMode(led2, OUTPUT);
  pinMode(led3, OUTPUT);
  pinMode(led4, OUTPUT);
  pinMode(led5, OUTPUT);
  pinMode(ledB0, OUTPUT);
  pinMode(ledB1, OUTPUT);
  pinMode(ledB2, OUTPUT);
  pinMode(ledV, OUTPUT);
  pinMode(ledR, OUTPUT);
  pinMode(botonInicio, INPUT);
  pinMode(boton0, INPUT);
  pinMode(boton1, INPUT);
  pinMode(boton2, INPUT);
  pinMode(relay, OUTPUT);
  digitalWrite(relay, HIGH);
}

void loop() {

  botonEstadoInicio = digitalRead(botonInicio);
  if (botonEstadoInicio == HIGH) {
    estado = 1;

  }
  switch (estado) {
    case 1:
      num = random(25, 50);
      t = 100;
      Serial.println(num);
      digitalWrite(leds[0], LOW);
      digitalWrite(leds[1], LOW);
      digitalWrite(leds[2], LOW);
      digitalWrite(leds[3], LOW);
      digitalWrite(leds[4], LOW);
      for (int i = 0; i < num; i++) {
        digitalWrite(leds[i % 5], HIGH);
        if ((num - i) < 8) {
          t = t + 100;
        }
        delay(t);
        if (i != (num - 1)) {
          digitalWrite(leds[i % 5], LOW);
        }
      }
      switch ((num - 1) % 5) {
        case 0:
          //no bebe
          estado = 0;
          break;
        case 1:
          //bebe
          dispensar();
          delay(500);
          estado = 0;
          break;
        case 2:
          //juego memoria
          estado = 2;
          break;
        case 3:
          //reto a alguien
          estado = 3;
          break;
        case 4:
          //juego reacción
          estado = 4;
          break;
        default:
          break;
      }
      break;
    case 3:
      //Juego reto
      esperarBotones();
      leerBotones();
      esperarBotones();
      botonEstado0a = digitalRead(boton0);
      botonEstado1a = digitalRead(boton1);
      botonEstado2a = digitalRead(boton2);
      Serial.println(botonEstado0a);
      Serial.println(botonEstado1a);
      Serial.println(botonEstado2a);

      delay(500);
      for (int i = 0; i < 3; i++) {
        if (botonEstado[i] == 1) {
          aux = i;
        }
      }
      if (botonEstado[0] == botonEstado0a && botonEstado[1] == botonEstado1a && botonEstado[2] == botonEstado2a) {
        luzVerde();
      } else {
        luzRoja();
      }
      for (int j = 0; j < 3; j++) {
        delay(400);
        digitalWrite(ledsB[aux], HIGH);
        delay (400);
        digitalWrite(ledsB[aux], LOW);

      }
      delay(1000);
      dispensar();
      estado = 0;
      break;
    case 2:
      //Juego memoria
      digitalWrite(ledsB[0], HIGH);
      digitalWrite(ledsB[1], HIGH);
      digitalWrite(ledsB[2], HIGH);
      delay(3000);
      digitalWrite(ledsB[0], LOW);
      digitalWrite(ledsB[1], LOW);
      digitalWrite(ledsB[2], LOW);
      turno = 0;
      parar = false;
      for (int i = 0; i < numTurnos; i++) {
        //Se genera la secuencia a memorizar
        orden[i] = random(0, 3);
        digitalWrite(ledsB[orden[i]], HIGH);
        delay(1000);
        digitalWrite(ledsB[orden[i]], LOW);
        delay(200);
      }
      while (turno < numTurnos && !parar) {
        Serial.println(parar);
        esperarBotones();
        leerBotones();
        j = 0;
        while (j < 3 && !parar) {
          if (botonEstado[j] == 1) {
            if (orden[turno] == j) {
              luzVerde();
            } else {
              parar = true;
            }
          }
          j++;
        }
        turno++;
      }
      delay (1000);
      if (!parar) {
        for (int j = 0; j < 5; j++) {
          delay(200);
          digitalWrite(ledV, HIGH);
          delay (200);
          digitalWrite(ledV, LOW);
        }
      } else {
        for (int j = 0; j < 5; j++) {
          delay(200);
          digitalWrite(ledR, HIGH);
          delay (200);
          digitalWrite(ledR, LOW);
        }
        dispensar();
      }
      estado = 0;
      break;
    case 4:
      //juego reacción
      parar = false;
      digitalWrite(ledsB[0], HIGH);
      digitalWrite(ledsB[2], HIGH);
      delay(5000);
      digitalWrite(ledsB[0], LOW);
      digitalWrite(ledsB[2], LOW);
      tiempoReaccion = (random(2000, 12000));
      tiempo = millis();
      tiempoAnterior = tiempo;
      while (tiempo - tiempoAnterior < tiempoReaccion && !parar) {
        tiempo = millis();
        botonEstado[0] = digitalRead(boton0);
        botonEstado[2] = digitalRead(boton2);
        for (int i = 0; i < 3; i++) {
          botonEstado[i] = digitalRead(boton[i]);
          if (botonEstado[i] == 1) {
            digitalWrite(ledsB[i], HIGH);
            parar = true;
            aux = i;
          }
        }
      }
      if (!parar) {
        for (int i = 0; i < 3; i++) {
          digitalWrite(ledsB[i], HIGH);
        }
        esperarBotones();
        leerBotones();
        for (int i = 0; i < 3; i++) {
          digitalWrite(ledsB[i], LOW);
        }
        if (botonEstado[0] == 1) {
          digitalWrite(ledsB[0], HIGH);
          for (int j = 0; j < 5; j++) {
            delay(200);
            digitalWrite(ledV, HIGH);
            delay (200);
            digitalWrite(ledV, LOW);
          }
          delay(500);
          digitalWrite(ledsB[0], LOW);
        } else {
          digitalWrite(ledsB[2], HIGH);
          for (int j = 0; j < 5; j++) {
            delay(200);
            digitalWrite(ledV, HIGH);
            delay (200);
            digitalWrite(ledV, LOW);
          }
          delay(500);
          digitalWrite(ledsB[2], LOW);
        }
      } else {
        for (int j = 0; j < 5; j++) {
          delay(200);
          digitalWrite(ledR, HIGH);
          delay (200);
          digitalWrite(ledR, LOW);
        }
        delay(500);
        digitalWrite(ledsB[aux], LOW);
      }
      estado = 0;
      dispensar();
      break;
    default:
      break;
  }
}

void esperarBotones() {
  while (digitalRead(boton0) == digitalRead(boton1) && digitalRead(boton0) == digitalRead(boton2)) {
  }
}

void leerBotones() {
  botonEstado0 = digitalRead(boton0);
  botonEstado1 = digitalRead(boton1);
  botonEstado2 = digitalRead(boton2);
  botonEstado[0] = digitalRead(boton0);
  botonEstado[1] = digitalRead(boton1);
  botonEstado[2] = digitalRead(boton2);
  Serial.println(botonEstado[0]);
  Serial.println(botonEstado[1]);
  Serial.println(botonEstado[2]);
  delay(500);
}

void luzVerde() {
  digitalWrite(ledV, HIGH);
  delay(1000);
  digitalWrite(ledV, LOW);
}

void luzRoja() {
  digitalWrite(ledR, HIGH);
  delay(1000);
  digitalWrite(ledR, LOW);
}

void dispensar() {
  digitalWrite(relay, LOW);
  delay(800);
  digitalWrite(relay, HIGH);
  delay(500);
}

Memoria del proyecto

MemoriaG06Descarga

También te podría gustar...

Deja una respuesta

Tu dirección de correo electrónico no será publicada. Los campos obligatorios están marcados con *