Note
Bonjour et bienvenue dans la Communauté Facebook des passionnés de Raspberry Pi, Arduino et ESP32 de SunFounder ! Plongez plus profondément dans l’univers des Raspberry Pi, Arduino et ESP32 avec d’autres passionnés.
Pourquoi rejoindre ?
Support d’experts : Résolvez les problèmes après-vente et les défis techniques avec l’aide de notre communauté et de notre équipe.
Apprendre et partager : Échangez des astuces et des tutoriels pour améliorer vos compétences.
Aperçus exclusifs : Accédez en avant-première aux annonces de nouveaux produits et aux aperçus.
Réductions spéciales : Profitez de réductions exclusives sur nos produits les plus récents.
Promotions festives et cadeaux : Participez à des cadeaux et des promotions de vacances.
👉 Prêt à explorer et à créer avec nous ? Cliquez [Ici] et rejoignez-nous aujourd’hui !
1.1.6 Module Matrice à LED
Introduction
Dans ce projet, vous allez découvrir le module de matrice à LED. Ce module utilise le driver MAX7219 pour piloter la matrice de LED 8 x 8.
Composants nécessaires
Dans ce projet, nous avons besoin des composants suivants.
Il est certainement pratique d’acheter un kit complet, voici le lien :
Name |
ITEMS IN THIS KIT |
LINK |
|---|---|---|
Raphael Kit |
337 |
Vous pouvez également les acheter séparément via les liens ci-dessous.
INTRODUCTION DES COMPOSANTS |
LIEN D’ACHAT |
|---|---|
Schéma de câblage
Nom T-Board |
Physique |
wiringPi |
BCM |
SPIMOSI |
Pin 19 |
12 |
MOSI |
SPICE0 |
pin 24 |
10 |
CE0 |
SPISCLK |
Pin 23 |
14 |
SCLK |
Procédures expérimentales
Étape 1 : Construisez le circuit.
Étape 2: Activez le SPI avant de commencer l’expérience, référez-vous à Configuration SPI pour les détails.
Étape 3: Accédez au dossier du code.
cd ~/raphael-kit/c/1.1.6/
Étape 4: Compilez le code.
make
Étape 5: Exécutez le fichier exécutable.
sudo ./1.1.6_LedMatrix
Après l’exécution du code, la matrice de LED affiche les chiffres de 0 à 9 et les lettres de A à Z en séquence.
Note
Si cela ne fonctionne pas après l’exécution, ou s’il y a une erreur : "wiringPi.h: No such file or directory", veuillez vous référer à Installer et vérifier WiringPi.
Code
#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;
}
Explication du code
Fichiers d’en-tête :
wiringPi.h: Fournit des fonctions pour le contrôle GPIO.wiringPiSPI.h: Fournit des fonctions pour la communication SPI.stdio.h: Bibliothèque d’entrée/sortie standard pour des fonctions comme printf.
Définitions :
SPI_CHANNEL: Spécifie le canal SPI (0 ou 1) utilisé pour la communication.SPI_SPEED: Définit la vitesse de communication SPI à 1 MHz.
#define SPI_CHANNEL 0 // Définit le canal SPI (0 ou 1) #define SPI_SPEED 1000000 // Vitesse SPI définie à 1 MHz
Fonction
max7219_write: Envoie des données à un registre spécifique du pilote d’affichage MAX7219.address: L’adresse du registre à écrire.data: Les données à écrire dans le registre.Crée un buffer contenant l’adresse et les données.
Utilise
wiringPiSPIDataRWpour envoyer le buffer via SPI.
void max7219_write(unsigned char address, unsigned char data) { unsigned char buffer[2]; buffer[0] = address; // Adresse du registre à écrire buffer[1] = data; // Données à écrire dans le registre wiringPiSPIDataRW(SPI_CHANNEL, buffer, 2); // Envoie les données via SPI }
Fonction
max7219_init: Initialise le module d’affichage MAX7219 avec les réglages nécessaires.Définit le mode de décodage sur « sans décodage » car nous contrôlons directement les LED.
Définit l’intensité (luminosité) à un niveau modéré (0x03).
Définit la limite de balayage à 7 pour activer les 8 chiffres (lignes) de l’affichage.
Désactive le mode veille pour allumer l’affichage.
Désactive le mode de test de l’affichage.
Efface l’affichage en écrivant 0x00 dans tous les registres de chiffres.
void max7219_init() { max7219_write(0x09, 0x00); // Mode de décodage : Pas de décodage pour les chiffres (utile pour les affichages à 7 segments) max7219_write(0x0A, 0x03); // Intensité : Définit le niveau de luminosité (0x00 à 0x0F) max7219_write(0x0B, 0x07); // Limite de balayage : Affiche les chiffres 0-7 (tous les 8 chiffres) max7219_write(0x0C, 0x01); // Registre d'arrêt : Fonctionnement normal (pas en mode veille) max7219_write(0x0F, 0x00); // Test d'affichage : Fonctionnement normal (pas en mode de test) // Efface tous les chiffres de l'affichage for (int i = 1; i <= 8; i++) { max7219_write(i, 0x00); // Écrit 0 dans chaque registre de chiffre } }
Fonction
max7219_display: Met à jour l’affichage avec un modèle de 8 octets donné.data: Un tableau contenant le modèle à afficher.Itère à travers chacune des 8 lignes (chiffres) et écrit les données correspondantes.
void max7219_display(unsigned char *data) { for (int i = 1; i <= 8; i++) { max7219_write(i, data[i - 1]); // Écrit chaque ligne du modèle sur l'affichage } }
Fonction
display_pattern: Affiche un modèle pendant une durée spécifiée.pattern: Le modèle à afficher (tableau de 8 octets).delay_ms: Durée d’affichage du modèle en millisecondes.Appelle
max7219_displaypour afficher le modèle.Utilise
delaypour attendre la durée spécifiée.
void display_pattern(const unsigned char pattern[8], int delay_ms) { max7219_display((unsigned char *)pattern); // Affiche le modèle delay(delay_ms); // Attendre la durée spécifiée en millisecondes }
Modèles de tableaux :
Contient des modèles prédéfinis pour le carré, le cœur et les chiffres 0-9.
Chaque modèle est un tableau de 8 octets, représentant 8 lignes de la matrice LED 8x8.
Chaque octet utilise la notation binaire où chaque bit représente une LED (1 pour allumé, 0 pour éteint).
const unsigned char patterns[][8] = { // Modèle de carré { 0b11111111, // Ligne 1 0b10000001, // Ligne 2 0b10000001, // Ligne 3 0b10000001, // Ligne 4 0b10000001, // Ligne 5 0b10000001, // Ligne 6 0b10000001, // Ligne 7 0b11111111 // Ligne 8 }, ... // Chiffre 9 { ... }, };
Fonction principale :
Initialise l’interface
WiringPietSPI.if (wiringPiSetup() == -1) { printf("Échec de l'initialisation de WiringPi\n"); return 1; } if (wiringPiSPISetup(SPI_CHANNEL, SPI_SPEED) == -1) { printf("Échec de l'initialisation de SPI\n"); return 1; }
Appelle
max7219_initpour configurer le module MAX7219.max7219_init(); // Initialise le module MAX7219
Entre dans une boucle infinie pour afficher les modèles en continu. Affiche chaque modèle pendant 1 seconde avant de passer au suivant.
while (1) { // Affiche le modèle de carré display_pattern(patterns[0], 1000); // Affiche pendant 1000 millisecondes // Affiche le modèle de cœur display_pattern(patterns[1], 1000); // Affiche les chiffres 0-9 for (int i = 2; i <= 11; i++) { display_pattern(patterns[i], 1000); } }
Comprendre les Modèles
Représentation Binaire :
Chaque modèle est défini en utilisant des littéraux binaires (préfixe 0b).
Chaque octet correspond à une ligne de la matrice LED 8x8.
Chaque bit dans l’octet représente une colonne (LED) dans cette ligne.
Le bit le plus significatif (à gauche) correspond à la première LED à gauche.
Création de Modèles Personnalisés :
Vous pouvez créer de nouveaux modèles en définissant de nouveaux tableaux de 8 octets.
Chaque modèle peut être ajouté au tableau des modèles.
Mettez à jour la boucle d’affichage dans la fonction principale pour inclure vos nouveaux modèles.
Ajustements et Personnalisation
Changer la Luminosité : Modifiez le niveau d’intensité dans
max7219_init:max7219_write(0x0A, brightness_level); // brightness_level entre 0x00 et 0x0F
Modifier le Temps d’Affichage : Changez le paramètre
delay_msdans les appels àdisplay_patternpour ajuster la durée d’affichage de chaque modèle.
Image du phénomène
