Juego de basketball con cronometro y marcador de aciertos con arduino

Publicado el: 1 de mayo de 2020
Principiante
Acerca de este proyecto
Tablero de basketball con cronómetro de tiempo y marcador de aciertos. Por cada canasta acertada, se incrementa el marcador en uno.
arduino juegos displays 7 segmentos
Publicidad
DETALLES

Este juego hace tiempo que queria desarrollarlo cuando fui a unos de esos sitios de diversiones y se enconraban estas máquinas de arcade que permiten lanzar por un tiempo determinado pelotas de basketball hacia la canasta y van mostrando en sus displays la cantidad de puntos obtenidos. Dichas máquinas cuentan también con un indicador de el puntaje más alto obtenido, efectos de sonido, movimiento, etc.

Máquina de basketball arcade

Por tal razón decidí realizarlo para divertirme en familia y compartir la realización con el resto de makers.


LISTA DE MATERIALES:

  • (1)Arduino, uno, micro, nano o mega.
  • (2) CI 74LS47 - Decodificadores BCD - 7 segmentos
  • (4) Displays de 7 segmentos de ánodo común.
  • (4) Transistores NPN.
  • (4) Resistores de 1k ohm.
  • (14) Resistores de 100 ohms.
  • (1) Sensor emisor-receptor de infrarojos.
  • (1) Tablero de basketball pequeño.
  • (1) Pelota.
  • Cables de conexión
  • Fuente regulada de 5V.

El tablero puede ser adquirido comercialmente, son económicos los infantiles que ya vienen con la pelota. De igual manera se puede armar con acríico, madera, icopor u otro material.

SENSOR EMISOR-RECEPTOR INFRAROJO.

Emisor-receptor infrarojo

Posee 3 pines: Vcc, Gnd y salida digital que cambia de estado cuando el led receptor recibe la luz emitida por el emisor.


UBICACIÓN DEL SENSOR INFRAROJOS EN EL TABLERO.

Debe ser colocado en la parte inferior de la canasta de tal manera que cuando la pelota atraviese el aro, este la detecte. El sensor trae incorporado un potenciometro que permite calibrar la distancia de sensado.

Ubicación sensor


FUNCIONAMIENTO

Cuando la pelota atraviesa el aro, esta es detectada por el emisor-receptor infrarojo, ya que la pelota actúa como objeto de rebote para la luz infraroja emitida por el led emisor, el led receptor detecta la luz y cambia de estado lógico su salida (pin del medio). Esto es detectado en el código para incrementar el contador o marcador de aciertos.


DIAGRAMA ESQUEMÁTICO

Diagrama ¿esquemático


En la parte izquierda se muestra el módulo del cronómetro y en la derecha el módulo del marcador. Ambos son equivalentes, están consituidos por un CI 74LS47 que es el decodificador BCD-7 segmentos, (2) displays de 7 segmentos cuyas salidas se unen entre si.

Las 4 entradas del 74LS47 del cronómetro son controladas por los pines 1,2,3 y 4 del arduino mientras que las entradas del 74LS47 del módulo marcador o contador se controlan por los pines 7,8,9, y 10 del arduino. Los pines 5,6 y 11 y 12 controlan y activan las bases de los transistores conectados a cada display. Los emisores de cada transistor activan de manera consecutica cada display, es decir, cada display va a estar encendido por una cantidad de tiempo pequeña mientras que los tres restantes permanecen apagados, pero gracias a la persistencia de imágenes en la retina se da la sensación que todos los displays están encendidos sl tiempo.


Mejoras al proyecto.

Se pueden realizar las siguientes mejoras o agregar las siguientes funciones:

  • Agregar otro display al marcador para contar hasta 999, o colocar otro display en el módulo del cronómetro para ampliar el tiempo de cronómetro.
  • Realizar un display de mayor tamaño para mejorar la visualización de los valores.
  • Agregar un efecto de sonido para cuando el temporizador llegó a cero.
  • Agregar un efecto de sonido por cada acierto que se obtenga.
  • Agregar un interruptor que permita resetear los valores del marcador y del cronómetro.

VIDEO DE FUNCIONAMIENTO

CODIFICACIÓN
Código basketball arduino-

//Programa del juego de basquetball con cronómetro y marcador de canasta

//Variables para el cronómetro
const int Acr = 1;
const int Bcr = 2;
const int Ccr = 3;
const int Dcr = 4;

const  int displayUnidadesCronometro = 5;
const  int displayDecenasCronometro = 6;

//  Variables para el marcador
const int Am = 7;
const int Bm = 8;
const int Cm = 9;
const int Dm = 10;

const  int displayUnidadesMarcador = 11;
const  int displayDecenasMarcador = 12;

//*****************************************

const int sensor = 13;

long tiempoAnterior = 0;
long intervalo = 1000;

int estadoSensor;
bool estadoBotonAnteriorSensor;

bool activo = true;

const int tiempo = 8;
const int tiempoAntirebote = 10;

int tiempoCronometro;
int marcador;

int unidadesCronometro = 0;
int decenasCronometro = 0;
int unidadesMarcador = 0;
int decenasMarcador = 0;

boolean estadoAnterior = LOW;    // Estado anterior del botòn
boolean estadoActual = LOW; // Estado actual del botòn


void escribirBcdCronometro(byte num) {
  digitalWrite(Acr, (num & 1) == 1);
  digitalWrite(Bcr, (num & 2) == 2);
  digitalWrite(Ccr, (num & 4) == 4);
  digitalWrite(Dcr, (num & 8) == 8);
}

void escribirBcdMarcador(byte num) {
  digitalWrite(Am, (num & 1) == 1);
  digitalWrite(Bm, (num & 2) == 2);
  digitalWrite(Cm, (num & 4) == 4);
  digitalWrite(Dm, (num & 8) == 8);
}

void setup() {

  pinMode(Acr, OUTPUT);
  pinMode(Bcr, OUTPUT);
  pinMode(Ccr, OUTPUT);
  pinMode(Dcr, OUTPUT);

  pinMode(displayUnidadesCronometro, OUTPUT);
  pinMode(displayDecenasCronometro, OUTPUT);

  pinMode(Am, OUTPUT);
  pinMode(Bm, OUTPUT);
  pinMode(Cm, OUTPUT);
  pinMode(Dm, OUTPUT);

  pinMode(displayUnidadesMarcador, OUTPUT);
  pinMode(displayDecenasMarcador, OUTPUT);

  pinMode(sensor, INPUT);
  //pinMode(reset,INPUT_PULLUP);

  digitalWrite(displayUnidadesCronometro, HIGH);
  digitalWrite(displayDecenasCronometro, HIGH);
  digitalWrite(displayUnidadesMarcador, HIGH);
  digitalWrite(displayDecenasMarcador, HIGH);
  
  estadoBotonAnteriorSensor = 1;
  tiempoCronometro = 59;
  marcador = 0;
}

//*******RUTINA ANTIREBOTE *********************************************************
boolean antiRebote  (int pin ) {
  int  contador = 0;
  boolean estado;            // guarda el estado del boton
  boolean estadoAnterior;    // guarda el ultimo estado del boton

  do {
    estado = digitalRead (pin);
    if (estado != estadoAnterior ) { // comparamos el estado actual
      contador = 0;
      estadoAnterior = estado;
    }
    else {
      contador = contador + 1;       // aumentamos el contador en 1
    }
    delay (1);
  }
  while (contador < tiempoAntirebote);
  return estado;
}

//************************************************************************

//  TEMPORIZADOR O CRONÓMETRO
void timer() {

  long tiempoActual = millis();  //Leo el tiempo actual

  if(activo){
    if (tiempoActual - tiempoAnterior > intervalo)  {
    tiempoCronometro = tiempoCronometro - 1;
    tiempoAnterior = tiempoActual;
  }
    
 }

}

void habilitarUnidadesCronometro() {
  escribirBcdCronometro(unidadesCronometro);
  digitalWrite(displayUnidadesCronometro, HIGH);
  digitalWrite(displayDecenasCronometro, LOW);
  delay(tiempo);
}

void habilitarDecenasCronometro() {
  escribirBcdCronometro(decenasCronometro);
  digitalWrite(displayUnidadesCronometro, LOW);
  digitalWrite(displayDecenasCronometro, HIGH);
  delay(tiempo);
}

void habilitarUnidadesMarcador() {
  escribirBcdMarcador(unidadesMarcador);
  digitalWrite(displayUnidadesMarcador, HIGH);
  digitalWrite(displayDecenasMarcador, LOW);
  delay(tiempo);
}

void habilitarDecenasMarcador() {
  escribirBcdMarcador(decenasMarcador);
  digitalWrite(displayUnidadesMarcador, LOW);
  digitalWrite(displayDecenasMarcador, HIGH);
  delay(tiempo);
}

void loop() {

  timer();

  estadoSensor = digitalRead(sensor);


  //*********************************************************************************************
  if(activo){
        
    if (estadoSensor  != estadoBotonAnteriorSensor)  {
      //si hay cambio con respeto al estado
      if (antiRebote (sensor))    {
        //checamos  si esta presionado y si lo esta
        marcador++;
      }
    }

    estadoBotonAnteriorSensor = estadoSensor;      // guardamos el estado del boton
  }
  //*******************************************************************************************
  //  Si se acabó el tiempo, no permita que siga contando el marcador
  
  if (tiempoCronometro == 0)  {
    activo = false;    
  }

  if (marcador > 99) {
    marcador = 0;
  }


  decenasCronometro = tiempoCronometro / 10; //Extraigo el dìgito de las unidades

  unidadesCronometro =  tiempoCronometro - ( decenasCronometro * 10); //Extraigo el dìgito de las decenas

  //*************************************************************************************************
  decenasMarcador = marcador / 10; //Extraigo el dìgito de las unidades

  unidadesMarcador =  marcador - (decenasMarcador * 10); //Extraigo el dìgito de las decenas

  habilitarUnidadesCronometro();
  habilitarDecenasCronometro();
  habilitarUnidadesMarcador();
  habilitarDecenasMarcador();

}


Autor: sistemasymicros
31 proyectos 6 seguidores 0 siguiendo

Ingeniero en electrónica. Maker, apasionado por la programación. Sigueme en sistemasymicros.

COMENTARIOS
Para publicar un comentario debes