Maquina de pinball
Introducción
La creación de una máquina de pinball es una tarea que requiere mucha creatividad y habilidad técnica. En este proyecto, inicialmente teníamos como idea la realización de un toldo o una papelera de reciclaje, pero después de una reflexión cuidadosa sobre la originalidad y la complejidad, decidimos embarcarnos en la creación de una máquina de juego única y emocionante.
Nuestra máquina de pinball cuenta con una pantalla en la que se muestra la puntuación en tiempo real, sensores que detectan la bola utilizada y diodos leds que se encienden cuando la bola se introduce en un agujero específico. Estos elementos trabajan juntos para crear una experiencia de juego interactiva y emocionante.
En los siguientes apartados, detallaremos las diferentes partes de nuestro proyecto. Discutiremos el software utilizado para el control de la máquina, el hardware utilizado para su construcción, los problemas que enfrentamos durante el proceso de construcción y las soluciones que encontramos para superarlos. También mencionaremos posibles mejoras que se podrían implementar en el futuro para hacer nuestra máquina de pinball aún más impresionante.
En general, estamos muy emocionados de presentar nuestro proyecto observando todas las características únicas y emocionantes de nuestra máquina de pinball.
Software (Código)
// Incluímos la libreria externa para poder utilizarla
#include <LiquidCrystal.h>
// Definimos las constantes
#define COLS 16 // Columnas del LCD
#define ROWS 2 // Filas del LCD
//indicamos los pins de la interfaz
LiquidCrystal lcd(12, 11, 5, 4, 3, 2);
int puntuacion = 0;
int puntuacion_final = 0;
const int azul_1 = 7;
const int rojo_1 = 8;
const int verde_1 = 9;
const int amarillo_1 = 10;
//valor del sensor 1
int now_1 = 0;
int previo_1 = 0;
int comp_1 = 0;
//valor del sensor 1
int now_2 = 0;
int previo_2 = 0;
int comp_2 = 0;
//valor del sensor 2
int now_3 = 0;
int previo_3 = 0;
int comp_3 = 0;
//valor del sensor 3
int now_4 = 0;
int previo_4 = 0;
int comp_4 = 0;
//valor del sensor 4
int now_0 = 0;
int previo_0 = 0;
int comp_0 = 0;
//boton
const int buttonPin = 13;
int buttonState = 0;
void setup() {
pinMode(verde_1, OUTPUT);
pinMode(azul_1, OUTPUT);
pinMode(amarillo_1, OUTPUT);
pinMode(rojo_1, OUTPUT);
pinMode (buttonPin, INPUT);
// Configuración monitor serie
Serial.begin(9600);
// Configuramos las filas y las columnas del LCD en este caso 16 columnas y 2 filas
lcd.begin(COLS, ROWS);
// Limpiamos la pantalla
lcd.clear();
// Situamos el cursor en la columna 0 fila 0
lcd.setCursor(0,0);
// Escribimos Puntuacion
lcd.print("Puntuacion:");
// Situamos el cursor en la columna 0 fila 1
lcd.setCursor(0,1);
// Escribimos la puntuacion que al principio será 0
lcd.print(puntuacion);
//Inicializamos las variables
now_0 = analogRead(A0);
now_1 = analogRead(A1);
now_2 = analogRead(A2);
now_3 = analogRead(A3);
now_4 = analogRead(A4);
}
void loop() {
//leemos los valores de los sensores
//si detectamos cambios en los valores
//sumamos la puntuacion y la mostramos en el lcd
previo_0 = now_0;
now_0 = analogRead(A0);
//La variable comp_X sirve para saber si se ha detectado un objeto en el sensor
comp_0 = abs(now_0-previo_0);
previo_1 = now_1;
now_1 = analogRead(A1);
comp_1 = abs(now_1-previo_1);
previo_2 = now_2;
now_2 = analogRead(A2);
comp_2 = abs(now_2-previo_2);
previo_3 = now_3;
now_3 = analogRead(A3);
comp_3 = abs(now_3-previo_3);
previo_4 = now_4;
now_4 = analogRead(A4);
comp_4 = abs(now_4-previo_4);
if (comp_1 >= 40){
puntuacion = puntuacion + 50;
Serial.println("A1");
Serial.println(analogRead(A1));
digitalWrite(azul_1, HIGH);
digitalWrite(amarillo_1, HIGH);
delay(1000);
}
if (comp_2 >= 40){
puntuacion = puntuacion + 75;
Serial.println("A2");
Serial.println(analogRead(A2));
digitalWrite(azul_1, HIGH);
digitalWrite(rojo_1, HIGH);
digitalWrite(amarillo_1, HIGH);
delay(1000);
}
if (comp_3 >= 40){
puntuacion = puntuacion + 25;
Serial.println("A3");
Serial.println(analogRead(A3));
digitalWrite(azul_1, HIGH);
delay(1000);
}
if (comp_4 >= 40 ){
puntuacion = puntuacion + 100;
Serial.println("A4");
Serial.println(analogRead(A4));
digitalWrite(azul_1, HIGH);
digitalWrite(rojo_1, HIGH);
digitalWrite(amarillo_1, HIGH);
digitalWrite(verde_1, HIGH);
delay(1000);
}
lcd.clear();
lcd.setCursor(0,0);
// Escribimos Puntuacion
lcd.print("Puntuacion:");
// Situamos el cursor en la columna 0 fila 1
lcd.setCursor(0,1);
// Escribimos la puntuacion actual
lcd.print(puntuacion);
digitalWrite(azul_1, LOW);
digitalWrite(rojo_1, LOW);
digitalWrite(verde_1, LOW);
digitalWrite(amarillo_1, LOW);
//si detecta la bola el sensor que indica fin de partida
if (comp_0 >= 80){
puntuacion_final = puntuacion;
lcd.clear();
lcd.setCursor(0,0);
// Escribimos Juego terminado indicando el fin de este
lcd.print("Juego terminado");
// Situamos el cursor en la columna 0 fila 1
lcd.setCursor(0,1);
// Escribimos la puntuacion final de la partida
lcd.print("puntuacion: ");
lcd.print(puntuacion_final);
//bucle donde queda atrapado hasta que se pulse el boton
while (digitalRead(buttonPin) == 0){
}
//al pulsar el boton restablece la pantalla y la puntuacion
puntuacion = 0;
lcd.clear();
lcd.setCursor(0,0);
// Escribimos Puntuacion de nuevo
lcd.print("Puntuacion");
// Situamos el cursor en la columna 0 fila 1
lcd.setCursor(0,1);
// Escribimos la puntuacion que vuelve a ser 0
lcd.print(puntuacion);
}
}
Material para su construcción
| Material | Precio (€) |
| 1 x Arduino UNO | Incluido en el material de la URJC |
| 1 x Protoboard | Incluido en el material de la URJC |
| 1 x LCD | Incluido en el material de la URJC |
| 1 x led azul | Incluido en el material de la URJC |
| 1 x led verde | Incluido en el material de la URJC |
| 1 x led amarillo | Incluido en el material de la URJC |
| 1 x led rojo | Incluido en el material de la URJC |
| 1 x potenciómetro | Incluido en el material de la URJC |
| 5 x res 10k | Incluido en el material de la URJC |
| 5 x res 220 | Incluido en el material de la URJC |
| 3 x res 330 | Incluido en el material de la URJC |
| 10 x Varilla de madera | 1,00 |
| 1 x Bolsa de gomas elásticas | 2,24 |
| Silicona Liquida | 2,40 |
| 80 x Cables extra | 6,00 |
| 5 x Sensor de proximidad | 6,10 |
Problemas y soluciones
Parte física
Nos encontramos con diferentes dificultades de las cuales son:
- Longitud de los cables.
- Impedir que la bola salga volando con el lanzador: En este aspecto, lo que hicimos fue colocar un cartón encima de la rampa por la que pasa la bola al empezar la partida para que haga de techo y la bola no se salga del tablero de juego.
- Creación de las palancas para impulsar la bola.
- A la hora de construir la máquina físicamente con los cartones, nos encontramos varios problemas cuando la bola se deslizaba por el tablero. En ciertos lugares se quedaba atascada, así que tuvimos que añadirle celo, o algunos cartones más que hacen de obstáculos pero que facilitan el recorrido de esta.
- Los sensores nos dificultaron la construcción de nuestro proyecto, porque muchas veces no detectaba correctamente la bola cuando caía por los agujeros, con sus consiguientes problemas. Para solucionar eso, decidimos colocarlos más cerca de los agujeros, para que los pueda detectar más fácilmente al caer la bola.
Parte código
Dentro del código, al igual que en la parte física, dividimos el proyecto en varias partes importantes, de las cuales a mencionar, la pantalla y los sensores.
- Pantalla: nos encontramos con un pequeño problema que era cómo hacer los print de aquello que queríamos mostrar usando texto tipo String y una variable, el cual simplemente poniendo un print a continuación de este sin cambiar la posición del cursor de la pantalla era posible. Además con el uso del Clear() podemos modificar la pantalla fácilmente cada vez que cambie el valor de la puntuación.
- Sensores: Aquí es donde más problemas han surgido ya que los valores variaban continuamente según la luz ambiente. Fuimos probando los valores que aparecían una vez instalados los sensores en sus respectivas posiciones comprobamos los valores que estos daban y comprobamos que aunque sus valores de raíz eran diferentes, vimos que había una diferencia del valor de 40 aproximadamente, por lo que en lugar de comparar el valor en sí, lo que hicimos fue calcular el valor previo y el actual, y si daba un salto mayor de 40 es que la bola está pasando. Esto luego nos supuso un problema, este se trataba de que esta detección se daba 2 veces, ya que si comprobamos el valor previo y el actual, cuando este vuelve al valor normal vuelve a detectarse ya que el salto es grande de nuevo. Por ejemplo con los valores: 100 150 100, se encuentran 2 saltos, del 100 al 150 y del 150 al 100. Para solucionar esto lo que hicimos fue que este sumara la mitad de puntos que deseábamos de manera que aunque se detecte 2 veces sume los puntos que buscamos.
Casos de uso
A continuación se presentan los casos de uso de la máquina de pinball:
Visualizar los puntos: El jugador puede visualizar su puntuación actual en la pantalla de la máquina de pinball en tiempo real durante el transcurso del juego. Para ello, la máquina mostrará la puntuación acumulada después de cada lanzamiento de bola.
Jugar una partida: El usuario puede jugar una partida de pinball utilizando la bola proporcionada por la máquina y el lanzador.
Reiniciar la partida: En caso de que el jugador quiera reiniciar la partida, puede hacerlo presionando el botón de reinicio en el arduino. La puntuación actual se borrará y el juego comenzará desde cero.
Empezar partida: Una vez iniciada la partida, el jugador puede comenzar a lanzar la bola para obtener la mayor cantidad de puntos posible.
En general, estos casos de uso cubren las funciones básicas de la máquina de pinball y permiten al jugador interactuar con la máquina de manera efectiva.
Posibles mejoras
A continuación se presentan algunas posibles mejoras para la máquina de pinball:
- Mejora del paso de la bola: Se podría mejorar el diseño del sistema de retorno de bola, utilizando materiales más suaves que permitan que la bola ruede sin problemas hacia el lanzador.
- Rediseño del lanzador: Se podría sustituir la varilla de madera por un lanzador de plástico que sea más fácil de usar. Además, se podría incorporar un sistema automático que devuelva la bola al lanzador después de cada partida.
- Añadir más luces decorativas: Se podrían agregar más luces LED en la máquina para crear efectos visuales más impresionantes y atractivos.
- Incorporación de nuevos modos de juego: Se podría añadir un modo contrarreloj en el que los jugadores compitan para obtener la mejor puntuación en un tiempo determinado.
- Registro de la puntuación más alta: Se podría incorporar un sistema que registre la puntuación más alta y muestre una lista de los mejores jugadores que hayan jugado en la máquina de pinball.
- Mejoras en la pista: Se podría añadir más obstáculos en la pista o mejorar la calidad de la misma para hacerla más divertida y desafiante. Esto aumentaría la emoción y la dificultad del juego.
- Mejoras en los acabados: En lugar de usar materiales de cartón para la estructura de la máquina, se podrían usar materiales más duraderos y de alta calidad, como la madera o el metal, para mejorar la resistencia y la durabilidad de la máquina.
Para terminar, hay muchas mejoras que se pueden hacer en una máquina de pinball para mejorar la experiencia del jugador y hacerla más emocionante y desafiante. Desde mejoras en el lanzador y en el sistema de retorno de bola hasta la incorporación de nuevos modos de juego y la mejora de los acabados, hay muchas posibilidades para crear una experiencia de juego única y memorable.
