¡Bienvenidos al emocionante mundo de las matrices de puntos 8×8 con Arduino y el divertido juego de Pong! En este artículo, te guiaremos a través de las instrucciones paso a paso para conectar una matriz de puntos 8×8 MAX7219 a tu Arduino y programarla para jugar el clásico juego Pong. ¡Prepárate para sumergirte en el mundo de la programación y la electrónica de una manera divertida y emocionante!
La matriz de puntos que usaremos en esta guía es una matriz de 8×8, lo que significa que tiene 8 columnas y 8 filas, lo que hace un total de 64 LED.
El chip MAX7219 facilita el control de la matriz de puntos simplemente usando 3 pines digitales de la placa Arduino.
Creo que la mejor opción es comprar la matriz de puntos con el chip MAX7219 como módulo, esto simplifica el cableado. Puedes comprobar eso Matriz de puntos en Maker Advisor y encuentra el mejor precio.
Puedes controlar más de una matriz al mismo tiempo. Para hacer esto, solo necesita conectarlos ya que tienen pines en ambos lados para expandir la matriz de puntos.
Piezas requeridas
Para esta guía necesitarás:
- Matriz de puntos 1x 8×8 con MAX7219
- Arduino UNO – leer Los mejores kits de inicio de Arduino
- 1x potenciómetro de 1k ohmios
- Cables de puente
Puedes utilizar los enlaces anteriores o ir directamente MakerAdvisor.com/tools ¡Para encontrar todas las piezas para tus proyectos al mejor precio!
Cableado de pines
Sólo necesitas conectar 5 pines de la matriz de puntos a tu placa Arduino. El cableado es bastante sencillo:
Pasador de matriz de puntos | Cableado con Arduino Uno |
Dimensiones | Tierra |
VCC | 5V |
RUIDO | pin digital |
ÉL | pin digital |
CLK | pin digital |
Cómo controlar la matriz de puntos con Arduino
Para controlar la matriz de puntos más fácilmente, necesita descargar la biblioteca LedControl e instalarla en su IDE de Arduino. Para instalar la biblioteca siga estos pasos:
- Haga clic aquí para descargar la biblioteca LedControl. Debería haber una carpeta ZIP en tus descargas.
- Descomprime eso .Cremallera carpeta y deberías recibir Maestro LedControl Carpeta
- Cambie el nombre de su carpeta de
Maestro LedControlA controles LED - mueve eso controles LED Carpeta a su instalación Arduino IDE Bibliotecas Carpeta
- Finalmente, vuelva a abrir su IDE de Arduino
Usando las funciones de la biblioteca LedControl
La forma más sencilla de mostrar algo en una matriz de puntos es utilizar las funciones establecerLed(), establecerFila() o establecerColumna(). Estas funciones le permiten controlar un solo LED, una fila o una columna a la vez.
Aquí están los parámetros para cada función:
setLed(dirección, fila, columna, estado)
- DIRECCIÓN es la dirección de su matriz. Por ejemplo, si solo tiene una matriz, la dirección int será cero.
- Fila es la fila donde se encuentra el LED
- dividir es la columna donde se ubica el LED
- Condición
- Es verdadero o 1 si quieres encender el LED
- Es falso o 0 si quieres desactivarlo.
setRow(dirección, fila, valor)
setCol(dirección, columna, valor)
índice
Como se mencionó anteriormente, esta matriz consta de 8 columnas y 8 filas. Cada uno está indexado del 0 al 7. Aquí hay un número para una mejor comprensión:
Si desea mostrar algo en la matriz, sólo necesita saber si los LED de una fila o columna en particular están encendidos o apagados.
Por ejemplo, si quieres mostrar una cara feliz, debes hacer lo siguiente:
código
Aquí hay un boceto simple que muestra tres tipos de caras: una cara triste, una cara neutral y una cara feliz. Sube el siguiente código a tu tablero:
/*
Created by Rui Santos
All the resources for this project:
Home
*/
#include "LedControl.h"
#include "binary.h"
/*
DIN connects to pin 12
CLK connects to pin 11
CS connects to pin 10
*/
LedControl lc=LedControl(12,11,10,1);
// delay time between faces
unsigned long delaytime=1000;
// happy face
byte hf[8]= {B00111100,B01000010,B10100101,B10000001,B10100101,B10011001,B01000010,B00111100};
// neutral face
byte nf[8]={B00111100, B01000010,B10100101,B10000001,B10111101,B10000001,B01000010,B00111100};
// sad face
byte sf[8]= {B00111100,B01000010,B10100101,B10000001,B10011001,B10100101,B01000010,B00111100};
void setup() {
lc.shutdown(0,false);
// Set brightness to a medium value
lc.setIntensity(0,8);
// Clear the display
lc.clearDisplay(0);
}
void drawFaces(){
// Display sad face
lc.setRow(0,0,sf[0]);
lc.setRow(0,1,sf[1]);
lc.setRow(0,2,sf[2]);
lc.setRow(0,3,sf[3]);
lc.setRow(0,4,sf[4]);
lc.setRow(0,5,sf[5]);
lc.setRow(0,6,sf[6]);
lc.setRow(0,7,sf[7]);
delay(delaytime);
// Display neutral face
lc.setRow(0,0,nf[0]);
lc.setRow(0,1,nf[1]);
lc.setRow(0,2,nf[2]);
lc.setRow(0,3,nf[3]);
lc.setRow(0,4,nf[4]);
lc.setRow(0,5,nf[5]);
lc.setRow(0,6,nf[6]);
lc.setRow(0,7,nf[7]);
delay(delaytime);
// Display happy face
lc.setRow(0,0,hf[0]);
lc.setRow(0,1,hf[1]);
lc.setRow(0,2,hf[2]);
lc.setRow(0,3,hf[3]);
lc.setRow(0,4,hf[4]);
lc.setRow(0,5,hf[5]);
lc.setRow(0,6,hf[6]);
lc.setRow(0,7,hf[7]);
delay(delaytime);
}
void loop(){
drawFaces();
}
Al final obtendrás algo como esto:
juego de mesa
El juego Pong que estás a punto de probar fue creado por Alessandro Pasotti.
Para el juego Pong, todo lo que necesitas hacer es agregar un potenciómetro de 1 k ohm al diagrama del circuito anterior. Ensamble el nuevo circuito como se muestra a continuación:
código
Luego cargue el siguiente código en su placa Arduino:
/*
* Play pong on an 8x8 matrix - project from itopen.it
*/
#include "LedControl.h"
#include "Timer.h"
#define POTPIN A5 // Potentiometer
#define PADSIZE 3
#define BALL_DELAY 200
#define GAME_DELAY 10
#define BOUNCE_VERTICAL 1
#define BOUNCE_HORIZONTAL -1
#define NEW_GAME_ANIMATION_SPEED 50
#define HIT_NONE 0
#define HIT_CENTER 1
#define HIT_LEFT 2
#define HIT_RIGHT 3
//#define DEBUG 1
byte sad[] = {
B00000000,
B01000100,
B00010000,
B00010000,
B00000000,
B00111000,
B01000100,
B00000000
};
byte smile[] = {
B00000000,
B01000100,
B00010000,
B00010000,
B00010000,
B01000100,
B00111000,
B00000000
};
Timer timer;
LedControl lc = LedControl(12,11,10,1);
byte direction; // Wind rose, 0 is north
int xball;
int yball;
int yball_prev;
byte xpad;
int ball_timer;
void setSprite(byte *sprite){
for(int r = 0; r < 8; r++){
lc.setRow(0, r, sprite[r]);
}
}
void newGame() {
lc.clearDisplay(0);
// initial position
xball = random(1, 7);
yball = 1;
direction = random(3, 6); // Go south
for(int r = 0; r < 8; r++){
for(int c = 0; c < 8; c++){
lc.setLed(0, r, c, HIGH);
delay(NEW_GAME_ANIMATION_SPEED);
}
}
setSprite(smile);
delay(1500);
lc.clearDisplay(0);
}
void setPad() {
xpad = map(analogRead(POTPIN), 0, 1020, 8 - PADSIZE, 0);
}
void debug(const char* desc){
#ifdef DEBUG
Serial.print(desc);
Serial.print(" XY: ");
Serial.print(xball);
Serial.print(", ");
Serial.print(yball);
Serial.print(" XPAD: ");
Serial.print(xpad);
Serial.print(" DIR: ");
Serial.println(direction);
#endif
}
int checkBounce() {
if(!xball || !yball || xball == 7 || yball == 6){
int bounce = (yball == 0 || yball == 6) ? BOUNCE_HORIZONTAL : BOUNCE_VERTICAL;
#ifdef DEBUG
debug(bounce == BOUNCE_HORIZONTAL ? "HORIZONTAL" : "VERTICAL");
#endif
return bounce;
}
return 0;
}
int getHit() {
if(yball != 6 || xball < xpad || xball > xpad + PADSIZE){
return HIT_NONE;
}
if(xball == xpad + PADSIZE / 2){
return HIT_CENTER;
}
return xball < xpad + PADSIZE / 2 ? HIT_LEFT : HIT_RIGHT;
}
bool checkLoose() {
return yball == 6 && getHit() == HIT_NONE;
}
void moveBall() {
debug("MOVE");
int bounce = checkBounce();
if(bounce) {
switch(direction){
case 0:
direction = 4;
break;
case 1:
direction = (bounce == BOUNCE_VERTICAL) ? 7 : 3;
break;
case 2:
direction = 6;
break;
case 6:
direction = 2;
break;
case 7:
direction = (bounce == BOUNCE_VERTICAL) ? 1 : 5;
break;
case 5:
direction = (bounce == BOUNCE_VERTICAL) ? 3 : 7;
break;
case 3:
direction = (bounce == BOUNCE_VERTICAL) ? 5 : 1;
break;
case 4:
direction = 0;
break;
}
debug("->");
}
// Check hit: modify direction is left or right
switch(getHit()){
case HIT_LEFT:
if(direction == 0){
direction = 7;
} else if (direction == 1){
direction = 0;
}
break;
case HIT_RIGHT:
if(direction == 0){
direction = 1;
} else if(direction == 7){
direction = 0;
}
break;
}
// Check orthogonal directions and borders ...
if((direction == 0 && xball == 0) || (direction == 4 && xball == 7)){
direction++;
}
if(direction == 0 && xball == 7){
direction = 7;
}
if(direction == 4 && xball == 0){
direction = 3;
}
if(direction == 2 && yball == 0){
direction = 3;
}
if(direction == 2 && yball == 6){
direction = 1;
}
if(direction == 6 && yball == 0){
direction = 5;
}
if(direction == 6 && yball == 6){
direction = 7;
}
// "Corner" case
if(xball == 0 && yball == 0){
direction = 3;
}
if(xball == 0 && yball == 6){
direction = 1;
}
if(xball == 7 && yball == 6){
direction = 7;
}
if(xball == 7 && yball == 0){
direction = 5;
}
yball_prev = yball;
if(2 < direction && direction < 6) {
yball++;
} else if(direction != 6 && direction != 2) {
yball--;
}
if(0 < direction && direction < 4) {
xball++;
} else if(direction != 0 && direction != 4) {
xball--;
}
xball = max(0, min(7, xball));
yball = max(0, min(6, yball));
debug("AFTER MOVE");
}
void gameOver() {
setSprite(sad);
delay(1500);
lc.clearDisplay(0);
}
void drawGame() {
if(yball_prev != yball){
lc.setRow(0, yball_prev, 0);
}
lc.setRow(0, yball, byte(1 << (xball)));
byte padmap = byte(0xFF >> (8 - PADSIZE) << xpad) ;
#ifdef DEBUG
//Serial.println(padmap, BIN);
#endif
lc.setRow(0, 7, padmap);
}
void setup() {
// The MAX72XX is in power-saving mode on startup,
// we have to do a wakeup call
pinMode(POTPIN, INPUT);
lc.shutdown(0,false);
// Set the brightness to a medium values
lc.setIntensity(0, 8);
// and clear the display
lc.clearDisplay(0);
randomSeed(analogRead(0));
#ifdef DEBUG
Serial.begin(9600);
Serial.println("Pong");
#endif
newGame();
ball_timer = timer.every(BALL_DELAY, moveBall);
}
void loop() {
timer.update();
// Move pad
setPad();
#ifdef DEBUG
Serial.println(xpad);
#endif
// Update screen
drawGame();
if(checkLoose()) {
debug("LOOSE");
gameOver();
newGame();
}
delay(GAME_DELAY);
}
demostración
Aquí está la demostración final de cómo juego al Pong. ¡Divertirse!
Envolver
¿Has utilizado alguna vez la matriz de puntos en tus proyectos Arduino?
Déjamelo saber dejando un comentario a continuación.
Si te gusta esta publicación, es posible que te gusten las siguientes (haz clic aquí para suscribirte a mi blog). Gracias por leer,
rui
Instrucciones para matriz de puntos 8×8 MAX7219 con Arduino + juego Pong
La matriz de puntos que vamos a utilizar en esta guía es una matriz 8×8, lo que significa que tiene 8 columnas y 8 filas, lo que da un total de 64 LEDs.
El chip MAX7219 facilita el control de la matriz de puntos, solo utilizando 3 pines digitales de la placa Arduino.
Creo que la mejor opción es comprar la matriz de puntos con el chip MAX7219 como módulo, ya que simplificará el cableado. Puedes revisar la matriz de puntos en Maker Advisor y encontrar el mejor precio.
Partes requeridas
Para esta guía necesitarás:
- 1x Matriz de puntos 8×8 con MAX7219
- Arduino UNO
- 1x Potenciómetro de 1k ohm
- Cables jumper
Puedes utilizar los enlaces anteriores o ir directamente a MakerAdvisor.com para encontrar todas las piezas para tus proyectos al mejor precio.
Cableado de pines
Solo necesitas conectar 5 pines de la matriz de puntos a tu placa Arduino. El cableado es bastante sencillo:
Pin de la matriz de puntos | Cableado a Arduino Uno |
---|---|
GND | GND |
VCC | 5V |
DIN | Pine digital |
CS | Pine digital |
CLK | Pine digital |
Cómo controlar la matriz de puntos con Arduino
Para facilitar el control de la matriz de puntos, necesitas descargar e instalar en tu Arduino IDE la librería LedControl. Sigue estos pasos para instalar la librería:
- Haz clic aquí para descargar la librería LedControl. Deberías tener una carpeta .zip en tus Descargas
- Descomprime la carpeta .zip y deberías obtener la carpeta LedControl-master
- Renombra tu carpeta de LedControl-master a LedControl
- Mueve la carpeta LedControl a la carpeta libraries de tu instalación de Arduino IDE
- Finalmente, vuelve a abrir tu Arduino IDE
Usando las funciones de la librería LedControl
La forma más sencilla de mostrar algo en la matriz de puntos es utilizando las funciones setLed(), setRow() o setColumn(). Estas funciones te permiten controlar un LED individual, una fila o una columna a la vez.
Aquí están los parámetros para cada función:
setLed(addr, row, col, state)
- addr es la dirección de tu matriz, por ejemplo, si tienes una sola matriz, la int addr será cero.
- row es la fila donde se encuentra el LED
- col es la columna donde se encuentra el LED
- state es true o 1 si quieres encender el LED, o false o 0 si quieres apagarlo
setRow(addr, row, value)
setCol(addr, column, value)
Índice
Como se mencionó anteriormente, esta matriz tiene 8 columnas y 8 filas. Cada una está indexada del 0 al 7. Aquí tienes una figura para mejor comprensión:
Juego Pong
El juego Pong que estás a punto de probar fue creado por Alessandro Pasotti.
Para el juego Pong, solo necesitas agregar un potenciómetro de 1k ohm al esquema anterior. Arma el nuevo circuito como se muestra a continuación:
Conclusión
¿Alguna vez has utilizado la matriz de puntos en tus proyectos de Arduino?
Deja tus comentarios abajo y cuéntame tu experiencia.
Si te gustó este post, probablemente te gustarán los siguientes (suscríbete haciendo clic aquí). Gracias por leer, Rui.
¡Qué interesante! Nunca pensé que se pudiera jugar Pong en una matriz de puntos. Definitivamente voy a intentarlo.