L'affichage dynamique est partout, mais piloter des milliers de LEDs à haute vitesse tout en gérant une consommation électrique optimisée représente un défi technique majeur. C'est dans ce cadre que j'ai réalisé ce projet alliant électronique numérique, programmation bas niveau et dimensionnement énergétique.

L'objectif : Comprendre le fonctionnement d'un panneau LED RGB 32x64, maîtriser le protocole HUB75 avec un microcontrôleur ESP32, et concevoir un système d'alimentation solaire autonome pour rendre l'affichage indépendant du réseau électrique.

Contrairement à un ruban LED intelligent, ce panneau ne possède aucune mémoire d'affichage : c'est l'ESP32 qui doit lui envoyer les données en boucle à très haute fréquence. Le système a été structuré autour de plusieurs éléments clés :

1. Division de la matrice : Le panneau est géré en deux demi-dalles de 16 lignes. La zone haute est alimentée par R1, G1, B1 et la zone basse par R2, G2, B2.
2. Adressage et Multiplexage : Utilisation d'un bus d'adresse de 4 bits (A, B, C, D) pour réaliser un balayage spatial avec un multiplexage de 1/16.
3. Synchronisation : Utilisation de signaux d'horloge (CLK) pour décaler les données et d'un verrou (LAT) pour figer l'affichage des 64 pixels d'une ligne.

Câblage de l'ESP32 sur plaque d'essai relié au connecteur HE10 du panneau

Voici l'implémentation logicielle complète développée sous l'IDE Arduino pour le microcontrôleur ESP32, permettant le chargement des registres de décalage et le balayage des lignes:

const int R1 = 25;
const int G1 = 26;
const int B1 = 27;

const int R2 = 32;
const int G2 = 33;
const int B2 = 14;

const int A = 4;
const int B = 16;
const int C = 17;
const int D = 18;

const int CLK = 15;
const int LAT = 19;
const int OE  = 23;

void setup() {
  pinMode(R1, OUTPUT); pinMode(G1, OUTPUT); pinMode(B1, OUTPUT);
  pinMode(R2, OUTPUT); pinMode(G2, OUTPUT); pinMode(B2, OUTPUT);
  pinMode(A, OUTPUT);  pinMode(B, OUTPUT);  pinMode(C, OUTPUT);  pinMode(D, OUTPUT);
  pinMode(CLK, OUTPUT); pinMode(LAT, OUTPUT); pinMode(OE, OUTPUT);

  digitalWrite(OE, HIGH);
  digitalWrite(CLK, LOW);
  digitalWrite(LAT, LOW);
}

void fixerAdresse(int ligne) {
  digitalWrite(A, (ligne >> 0) & 1);
  digitalWrite(B, (ligne >> 1) & 1);
  digitalWrite(C, (ligne >> 2) & 1);
  digitalWrite(D, (ligne >> 3) & 1);
}

void envoyer64Pixels(bool r, bool g, bool b) {
  digitalWrite(OE, HIGH);

  for (int i = 0; i < 64; i++) {
    digitalWrite(R1, r);
    digitalWrite(G1, g);
    digitalWrite(B1, b);

    digitalWrite(R2, LOW);
    digitalWrite(G2, LOW);
    digitalWrite(B2, LOW);

    digitalWrite(CLK, HIGH);
    delayMicroseconds(1);
    digitalWrite(CLK, LOW);
    delayMicroseconds(1);
  }

  digitalWrite(LAT, HIGH);
  delayMicroseconds(1);
  digitalWrite(LAT, LOW);
  delayMicroseconds(1);
}

void loop() {
  for (int ligne = 0; ligne < 16; ligne++) {
    if (ligne % 3 == 0) {
      envoyer64Pixels(HIGH, LOW, LOW);
    } 
    else if (ligne % 3 == 1) {
      envoyer64Pixels(LOW, HIGH, LOW);
    } 
    else {
      envoyer64Pixels(LOW, LOW, HIGH);
    }

    fixerAdresse(ligne);

    digitalWrite(OE, LOW);

    delayMicroseconds(500);

    digitalWrite(OE, HIGH);
  }
}

Une fois le programme téléversé avec succès via le pilote CP2102, la matrice s'illumine conformément à l'algorithme de balayage cyclique. L'effet de persistance rétinienne fusionne le clignotement ultra-rapide des lignes pour afficher un motif fixe et net à l'œil humain.

Validation visuelle : Affichage du motif de test multiplexé

L'alimentation du panneau a nécessité une étude approfondie. Un calcul théorique du "pire cas" (panneau entièrement blanc fixe) donnait une consommation maximale de 12,3 Ampères.

Cependant, en prenant en compte le rapport cyclique (1/16) et le taux de remplissage d'un affichage de texte standard sur deux lignes, la consommation moyenne réelle chute à environ 190 mA sous 5V.

Sur cette base d'environ 1,5 W, je théorise un système solaire autonome complet tel que :

• Génération : Un panneau solaire de 20W à 30W (calculé pour les conditions d'hiver).
• Stockage : Une batterie Lithium de 12V / 10Ah assurant 2 jours d'autonomie complète.
• Régulation & Conversion : Un régulateur PWM 5A associé à un convertisseur DC-DC Buck (Step-down) pour abaisser proprement le 12V de la batterie en 5V stables, courant exigé par les anodes communes du panneau.

Démonstration vidéo : le texte affiche "Adam est le meilleur GEII"

Au terme de ce projet pluridisciplinaire, je repars avec les acquis suivants :

🛠 Compétences Techniques (Hard Skills) :

• Microcontrôleurs & Bas Niveau : Programmation d'un ESP32 en C++ et gestion de l'IDE Arduino.
• Protocoles d'Affichage : Maîtrise du HUB75, des registres à décalage et des verrous de données.
• Électronique Numérique : Gestion du multiplexage temporel, bus d'adressage et logique inversée.
• Génie Énergétique : Dimensionnement photovoltaïque, stockage par batterie et conversion de puissance DC-DC.

🧠 Compétences Personnelles (Soft Skills) :

• Analyse de documentation technique : Interprétation de chronogrammes et de tableaux de câblage matériels.
• Esprit critique et pragmatisme : Capacité à passer d'un calcul théorique idéal à un dimensionnement réel viable.
• Résolution de problèmes (Troubleshooting) : Identification et isolation des signaux parasites (gestion des lignes flottantes sur la zone basse).