Nota
¡Hola! Bienvenido a la comunidad de entusiastas de SunFounder Raspberry Pi, Arduino y ESP32 en Facebook. Sumérgete en el mundo de Raspberry Pi, Arduino y ESP32 con otros entusiastas.
¿Por qué unirte?
Soporte Experto: Resuelve problemas postventa y desafíos técnicos con la ayuda de nuestra comunidad y equipo.
Aprende y Comparte: Intercambia consejos y tutoriales para mejorar tus habilidades.
Preestrenos Exclusivos: Accede anticipadamente a anuncios de nuevos productos y adelantos.
Descuentos Especiales: Disfruta de descuentos exclusivos en nuestros productos más recientes.
Promociones y Sorteos Festivos: Participa en sorteos y promociones de temporada.
👉 ¿Listo para explorar y crear con nosotros? Haz clic en [Aquí] y únete hoy mismo!
1.1.6 Módulo de Matriz de LED
Introducción
En este proyecto, aprenderás sobre el Módulo de Matriz de LED. Este módulo utiliza el controlador MAX7219 para manejar la matriz de LED de 8 x 8.
Componentes Necesarios
En este proyecto, necesitamos los siguientes componentes.
Es definitivamente conveniente comprar un kit completo, aquí tienes el enlace:
Nombre |
ELEMENTOS EN ESTE KIT |
ENLACE |
|---|---|---|
Kit Raphael |
337 |
También puedes comprarlos por separado en los enlaces a continuación.
INTRODUCCIÓN DEL COMPONENTE |
ENLACE DE COMPRA |
|---|---|
Diagrama Esquemático
Nombre T-Board |
físico |
wiringPi |
BCM |
SPIMOSI |
Pin 19 |
12 |
MOSI |
SPICE0 |
Pin 24 |
10 |
CE0 |
SPISCLK |
Pin 23 |
14 |
SCLK |
Procedimientos Experimentales
Paso 1: Construir el circuito.
Paso 2: Activa el SPI antes de comenzar el experimento, consulta Configuración de SPI para más detalles.
Paso 3: Ve a la carpeta del código.
cd ~/raphael-kit/c/1.1.6/
Paso 4: Compila el código.
make
Paso 5: Ejecuta el archivo ejecutable.
sudo ./1.1.6_LedMatrix
Después de ejecutar el código, la matriz de LED muestra en secuencia un cuadrado, un corazón y los números del 0 al 9.
Nota
Si no funciona después de ejecutarlo, o aparece un mensaje de error: "wiringPi.h: No such file or directory", por favor consulta Instalar y verificar WiringPi.
Código
#include <wiringPi.h>
#include <wiringPiSPI.h>
#include <stdio.h>
#define SPI_CHANNEL 0 // Define SPI channel (0 or 1)
#define SPI_SPEED 1000000 // SPI speed set to 1 MHz
// Function to write data to a MAX7219 register
void max7219_write(unsigned char address, unsigned char data) {
unsigned char buffer[2];
buffer[0] = address; // Register address to write to
buffer[1] = data; // Data to write into the register
wiringPiSPIDataRW(SPI_CHANNEL, buffer, 2); // Send data via SPI
}
// Function to initialize the MAX7219 display module
void max7219_init() {
max7219_write(0x09, 0x00); // Decode Mode: No decoding for digits (useful for 7-segment displays)
max7219_write(0x0A, 0x03); // Intensity: Set brightness level (0x00 to 0x0F)
max7219_write(0x0B, 0x07); // Scan Limit: Display digits 0-7 (all 8 digits)
max7219_write(0x0C, 0x01); // Shutdown Register: Normal operation (not in shutdown mode)
max7219_write(0x0F, 0x00); // Display Test: Normal operation (no test mode)
// Clear all digits on the display
for (int i = 1; i <= 8; i++) {
max7219_write(i, 0x00); // Write 0 to each digit register
}
}
// Function to display a pattern on the MAX7219
void max7219_display(unsigned char *data) {
for (int i = 1; i <= 8; i++) {
max7219_write(i, data[i - 1]); // Write each row of the pattern to the display
}
}
// Function to display a pattern for a specified duration
void display_pattern(const unsigned char pattern[8], int delay_ms) {
max7219_display((unsigned char *)pattern); // Display the pattern
delay(delay_ms); // Wait for the specified time in milliseconds
}
// Array of patterns to display
const unsigned char patterns[][8] = {
// Square pattern
{
0b11111111, // Row 1
0b10000001, // Row 2
0b10000001, // Row 3
0b10000001, // Row 4
0b10000001, // Row 5
0b10000001, // Row 6
0b10000001, // Row 7
0b11111111 // Row 8
},
// Heart pattern
{
0b01100110, // Row 1
0b11111111, // Row 2
0b11111111, // Row 3
0b11111111, // Row 4
0b01111110, // Row 5
0b00111100, // Row 6
0b00011000, // Row 7
0b00000000 // Row 8
},
// Number 0
{
0b00111100, // Row 1
0b01100110, // Row 2
0b11000011, // Row 3
0b11000011, // Row 4
0b11000011, // Row 5
0b11000011, // Row 6
0b01100110, // Row 7
0b00111100 // Row 8
},
// Number 1
{
0b00011000, // Row 1
0b00111000, // Row 2
0b01111000, // Row 3
0b00011000, // Row 4
0b00011000, // Row 5
0b00011000, // Row 6
0b01111110, // Row 7
0b01111110 // Row 8
},
// Number 2
{
0b01111110, // Row 1
0b11000011, // Row 2
0b00000011, // Row 3
0b00001110, // Row 4
0b00110000, // Row 5
0b11000000, // Row 6
0b11111111, // Row 7
0b00000000 // Row 8
},
// Number 3
{
0b01111110, // Row 1
0b11000011, // Row 2
0b00000011, // Row 3
0b00111110, // Row 4
0b00000011, // Row 5
0b11000011, // Row 6
0b01111110, // Row 7
0b00000000 // Row 8
},
// Number 4
{
0b00001110, // Row 1
0b00011110, // Row 2
0b00110110, // Row 3
0b01100110, // Row 4
0b11111111, // Row 5
0b00000110, // Row 6
0b00000110, // Row 7
0b00000000 // Row 8
},
// Number 5
{
0b11111111, // Row 1
0b11000000, // Row 2
0b11111110, // Row 3
0b00000011, // Row 4
0b00000011, // Row 5
0b11000011, // Row 6
0b01111110, // Row 7
0b00000000 // Row 8
},
// Number 6
{
0b00111110, // Row 1
0b01100000, // Row 2
0b11000000, // Row 3
0b11111110, // Row 4
0b11000011, // Row 5
0b11000011, // Row 6
0b01111110, // Row 7
0b00000000 // Row 8
},
// Number 7
{
0b11111111, // Row 1
0b11000011, // Row 2
0b00000110, // Row 3
0b00001100, // Row 4
0b00011000, // Row 5
0b00110000, // Row 6
0b00110000, // Row 7
0b00000000 // Row 8
},
// Number 8
{
0b01111110, // Row 1
0b11000011, // Row 2
0b11000011, // Row 3
0b01111110, // Row 4
0b11000011, // Row 5
0b11000011, // Row 6
0b01111110, // Row 7
0b00000000 // Row 8
},
// Number 9
{
0b01111110, // Row 1
0b11000011, // Row 2
0b11000011, // Row 3
0b01111111, // Row 4
0b00000011, // Row 5
0b00000110, // Row 6
0b01111100, // Row 7
0b00000000 // Row 8
},
};
int main() {
if (wiringPiSetup() == -1) {
printf("Failed to initialize WiringPi\n");
return 1;
}
if (wiringPiSPISetup(SPI_CHANNEL, SPI_SPEED) == -1) {
printf("Failed to initialize SPI\n");
return 1;
}
max7219_init(); // Initialize the MAX7219 module
// Display patterns in a loop
while (1) {
// Display the square pattern
display_pattern(patterns[0], 1000); // Display for 1000 milliseconds
// Display the heart pattern
display_pattern(patterns[1], 1000);
// Display numbers 0-9
for (int i = 2; i <= 11; i++) {
display_pattern(patterns[i], 1000);
}
}
return 0;
}
Análisis de Código
Archivos de Cabecera:
wiringPi.h: Proporciona funciones para el control de GPIO.wiringPiSPI.h: Proporciona funciones para la comunicación SPI.stdio.h: Biblioteca estándar de entrada/salida para funciones como printf.
Definiciones:
SPI_CHANNEL: Especifica el canal SPI (0 o 1) utilizado para la comunicación.SPI_SPEED: Establece la velocidad de comunicación SPI a 1 MHz.
#define SPI_CHANNEL 0 // Define el canal SPI (0 o 1) #define SPI_SPEED 1000000 // Velocidad SPI establecida en 1 MHz
Función
max7219_write: Envía datos a un registro específico del controlador de pantalla MAX7219.address: La dirección del registro a escribir.data: Los datos a escribir en el registro.Crea un buffer que contiene la dirección y los datos.
Usa
wiringPiSPIDataRWpara enviar el buffer por SPI.
void max7219_write(unsigned char address, unsigned char data) { unsigned char buffer[2]; buffer[0] = address; // Dirección del registro para escribir buffer[1] = data; // Datos para escribir en el registro wiringPiSPIDataRW(SPI_CHANNEL, buffer, 2); // Enviar datos vía SPI }
Función
max7219_init: Inicializa el módulo de pantalla MAX7219 con configuraciones necesarias.Configura el modo de decodificación a «sin decodificación» ya que estamos controlando los LEDs directamente.
Ajusta la intensidad (brillo) a un nivel moderado (0x03).
Establece el límite de escaneo en 7 para habilitar los 8 dígitos (filas) de la pantalla.
Sale del modo de apagado para encender la pantalla.
Desactiva el modo de prueba de pantalla.
Limpia la pantalla escribiendo 0x00 en todos los registros de dígitos.
void max7219_init() { max7219_write(0x09, 0x00); // Modo de decodificación: Sin decodificación para dígitos (útil para pantallas de 7 segmentos) max7219_write(0x0A, 0x03); // Intensidad: Establecer nivel de brillo (0x00 a 0x0F) max7219_write(0x0B, 0x07); // Límite de escaneo: Mostrar dígitos 0-7 (todos los 8 dígitos) max7219_write(0x0C, 0x01); // Registro de apagado: Operación normal (no en modo de apagado) max7219_write(0x0F, 0x00); // Prueba de pantalla: Operación normal (sin modo de prueba) // Limpiar todos los dígitos en la pantalla for (int i = 1; i <= 8; i++) { max7219_write(i, 0x00); // Escribir 0 en cada registro de dígito } }
Función
max7219_display: Actualiza la pantalla con un patrón de 8 bytes dado.data: Un arreglo que contiene el patrón a mostrar.Itera a través de cada una de las 8 filas (dígitos) y escribe los datos correspondientes.
void max7219_display(unsigned char *data) { for (int i = 1; i <= 8; i++) { max7219_write(i, data[i - 1]); // Escribir cada fila del patrón en la pantalla } }
Función
display_pattern: Muestra un patrón durante un tiempo específico.pattern: El patrón a mostrar (arreglo de 8 bytes).delay_ms: Duración para mostrar el patrón en milisegundos.Llama a
max7219_displaypara mostrar el patrón.Usa
delaypara esperar durante la duración especificada.
void display_pattern(const unsigned char pattern[8], int delay_ms) { max7219_display((unsigned char *)pattern); // Mostrar el patrón delay(delay_ms); // Esperar el tiempo especificado en milisegundos }
Patrones de Arreglos:
Contiene patrones predefinidos para el cuadrado, corazón y números del 0 al 9.
Cada patrón es un arreglo de 8 bytes, representando 8 filas de la matriz LED de 8x8.
Cada byte usa notación binaria donde cada bit representa un LED (1 para encendido, 0 para apagado).
const unsigned char patterns[][8] = { // Patrón cuadrado { 0b11111111, // Fila 1 0b10000001, // Fila 2 0b10000001, // Fila 3 0b10000001, // Fila 4 0b10000001, // Fila 5 0b10000001, // Fila 6 0b10000001, // Fila 7 0b11111111 // Fila 8 }, ... // Número 9 { ... }, };
Función main:
Inicializa
WiringPiy la interfazSPI.if (wiringPiSetup() == -1) { printf("Error al inicializar WiringPi\n"); return 1; } if (wiringPiSPISetup(SPI_CHANNEL, SPI_SPEED) == -1) { printf("Error al inicializar SPI\n"); return 1; }
Llama a
max7219_initpara configurar el módulo MAX7219.max7219_init(); // Inicializar el módulo MAX7219
Entra en un bucle infinito para mostrar los patrones continuamente. Muestra cada patrón durante 1 segundo antes de pasar al siguiente.
while (1) { // Mostrar el patrón cuadrado display_pattern(patterns[0], 1000); // Mostrar durante 1000 milisegundos // Mostrar el patrón de corazón display_pattern(patterns[1], 1000); // Mostrar números del 0 al 9 for (int i = 2; i <= 11; i++) { display_pattern(patterns[i], 1000); } }
Comprensión de los Patrones
Representación Binaria:
Cada patrón se define usando literales binarios (prefijo 0b).
Cada byte corresponde a una fila en la matriz LED de 8x8.
Cada bit dentro del byte representa una columna (LED) en esa fila.
El bit más significativo (a la izquierda) corresponde al primer LED a la izquierda.
Creación de Patrones Personalizados:
Puedes crear nuevos patrones definiendo nuevos arreglos de 8 bytes.
Cada patrón puede añadirse al arreglo de patrones.
Actualiza el bucle de visualización en main para incluir tus nuevos patrones.
Ajustes y Personalización
Cambiar el Brillo: Modifica el nivel de intensidad en
max7219_init:max7219_write(0x0A, brightness_level); // brillo entre 0x00 y 0x0F
Modificar el Tiempo de Visualización: Cambia el parámetro
delay_msen las llamadas adisplay_patternpara ajustar el tiempo de visualización de cada patrón.
Imagen del Fenómeno
