Tutoriel de multiplexage de LED Arduino: contrôler plus de LED avec moins de broches

L'Arduino Uno est un outil puissant pour le prototypage, mais le pilotage direct de plusieurs LED mobilise rapidement ses 20 broches GPIO et atteint la limite absolue de courant total de 200 mA de son boîtier. Pour contourner ces contraintes matérielles sans changer de microcontrôleur, les ingénieurs et les amateurs utilisent le multiplexage de LED afin d'augmenter efficacement le nombre de sorties d'affichage.

Dans ce guide, vous découvrirez les principes essentiels du balayage de matrices LED, du Charlieplexing, de la fréquence de rafraîchissement et de la suppression des images fantômes, ainsi que des exemples pratiques de code Arduino sans circuit intégré de commande ou d'extension externe.

Qu'est-ce que le multiplexage de LED avec Arduino?

Limites des GPIO de l'Arduino Uno

Chaque broche GPIO d'un Arduino Uno basé sur l'ATmega328P est soumise à des limites électriques strictes.

• Maximum absolu: une broche GPIO peut fournir ou absorber jusqu'à 40 mA dans des conditions de crête non continues
• Limite recommandée: la limite de fonctionnement sûre en sortie continue est de 20 mA ou moins par broche
• Limite totale du boîtier: le courant total traversant les broches VCC et GND du microcontrôleur ne doit pas dépasser 200 mA

Le pilotage direct d'une matrice 4x4 de 16 LED à 15 mA chacune nécessiterait 240 mA, ce qui risquerait d'endommager définitivement le silicium par surchauffe.

Persistance rétinienne et multiplexage de LED

Le multiplexage de LED repose sur un phénomène physiologique appelé persistance rétinienne. L'oeil humain ne perçoit pas les variations d'intensité lumineuse qui se produisent à une fréquence supérieure à environ 50 à 100 Hz, soit une période de 10 à 20 ms.

Si une LED reste allumée pendant 1 ms, puis éteinte pendant 9 ms, et que ce cycle se répète continuellement, l'oeil intègre les impulsions lumineuses. Au lieu de percevoir un clignotement, il voit une lumière continue légèrement moins intense. En activant successivement plusieurs LED à grande vitesse, elles semblent toutes allumées simultanément et produisent un affichage stable.

Pilotage direct ou matrice LED multiplexée

Deux méthodes principales permettent de piloter directement des LED à l'aide des broches natives d'un microcontrôleur:

• Pilotage direct: chaque LED est reliée à une broche GPIO dédiée par une résistance de limitation de courant. Cette méthode est simple à programmer, mais elle nécessite une broche par source lumineuse et atteint rapidement la limite de courant total du boîtier
• Balayage multiplexé: les LED sont organisées en grille ou selon une configuration spécialisée comme le Charlieplexing. Les pixels partagent des connexions physiques et le microcontrôleur commute rapidement certaines lignes pour adresser chaque coordonnée avec beaucoup moins de broches

Comparaison des techniques de multiplexage de LED Arduino

Le tableau suivant présente les principaux compromis des techniques permettant d'augmenter le nombre de LED pilotées directement par les broches.

Balayage matriciel lignes-colonnes: 16 broches pour 64 LED

Le balayage matriciel organise les LED dans une grille composée de lignes et de colonnes qui se croisent. Dans une matrice 8x8 de 64 LED, toutes les anodes d'une même ligne et toutes les cathodes d'une même colonne sont connectées ensemble. Seulement 16 broches sont nécessaires pour adresser individuellement chaque pixel, ce qui réduit de 75 % le nombre de broches requises et simplifie la logique de balayage de la matrice LED Arduino.

Charlieplexing de LED avec Arduino

Le Charlieplexing est une méthode de multiplexage avancée qui exploite les trois états logiques des broches GPIO du microcontrôleur: HIGH, LOW et INPUT à haute impédance. En disposant les LED par paires antiparallèles, cette méthode permet à N broches de piloter N x (N - 1) LED.

Matrice LED ou Charlieplexing

• Efficacité d'utilisation des broches: le Charlieplexing utilise nettement moins de broches. Une matrice lignes-colonnes 8x8 nécessite 16 broches pour piloter 64 LED, tandis que 9 broches en Charlieplexing peuvent en piloter jusqu'à 72
• Complexité du micrologiciel: le balayage lignes-colonnes classique commute uniquement les broches entre les états binaires HIGH et LOW. Le Charlieplexing nécessite de modifier dynamiquement leur direction entre les modes sortie et entrée à haute impédance dans la boucle d'exécution principale

Choisir la méthode de multiplexage adaptée

Choisissez le balayage matriciel lignes-colonnes si vous recherchez une luminosité homogène, un routage plus simple et une disposition en grille standard. Optez pour le Charlieplexing lorsque le nombre de broches disponibles est très limité, par exemple pour un petit appareil portable, et qu'un rapport cyclique global plus faible est acceptable.

Comment réaliser une matrice LED Arduino 8x8?

Une matrice 8x8 constitue un excellent point de départ pour apprendre à commander un affichage en grille.

Matrice LED à anode commune ou à cathode commune

Une matrice LED 8x8 étant une grille de diodes qui se croisent, elle peut être considérée simultanément comme une matrice à anode commune et à cathode commune selon l'axe analysé. La désignation commerciale du fabricant fait précisément référence à la configuration de polarité des lignes:

• Lignes à anode commune et colonnes à cathode commune: toutes les LED d'une ligne partagent leur anode positive, tandis que les colonnes sont reliées aux cathodes négatives communes. Pour allumer un pixel, par exemple ligne 1 et colonne 1, placez la ligne 1 à l'état HIGH pour fournir le courant et la colonne 1 à l'état LOW pour l'absorber
• Lignes à cathode commune et colonnes à anode commune: toutes les LED d'une ligne partagent leur cathode négative, tandis que les colonnes sont reliées aux anodes positives communes. Pour allumer un pixel, placez la ligne 1 à l'état LOW et la colonne 1 à l'état HIGH

Schéma de câblage d'une matrice LED Arduino

Le schéma ci-dessous présente le câblage conceptuel d'une matrice LED Arduino 8x8 standard à lignes à anode commune et colonnes à cathode commune, directement pilotée par un Arduino.

Figure: schéma d'une matrice LED 8x8 à lignes à anode commune et colonnes à cathode commune connectée à un Arduino Uno, avec les broches des lignes reliées aux anodes et celles des colonnes aux cathodes par des résistances.

Positionnement des résistances d'une matrice LED

Les résistances de limitation de courant doivent être placées sur les colonnes plutôt que sur les lignes, ou inversement selon l'axe balayé.

• Pourquoi est-ce important? Si les résistances sont placées sur les lignes et que le balayage s'effectue ligne par ligne, la luminosité varie selon le nombre de LED allumées sur chaque ligne. Une seule LED active sera lumineuse, tandis que huit LED actives se partageront le courant et seront beaucoup moins lumineuses
• Solution: placez une résistance sur chaque ligne ou colonne pilotée indépendamment. Selon l'axe de balayage, cette configuration assure une répartition homogène du courant et évite les différences de luminosité entre les LED actives

Utilisez cette formule de base pour calculer la valeur de la résistance:

Pour une alimentation standard de 5 V, consultez le tableau ci-dessous afin d'obtenir rapidement les valeurs appropriées:

Calcul de la fréquence de rafraîchissement d'une matrice LED Arduino

Pour obtenir un affichage stable sans scintillement visible, la matrice doit être entièrement balayée au moins 60 fois par seconde, soit 60 Hz. Une fréquence de 100 à 200 Hz est préférable pour assurer un rafraîchissement fluide. Une fréquence supérieure peut être nécessaire pour éviter les bandes produites par l'obturateur déroulant des appareils photo de smartphones.

Pour une matrice de 8 lignes balayée ligne par ligne à 100 Hz:

Période totale d'une image = 1 / 100 Hz = 10 ms

Durée active par ligne = 10 ms / 8 lignes = 1,25 ms (1250 microsecondes)

L'Arduino doit changer de ligne toutes les 1,25 ms.

Code millis() pour une matrice LED Arduino 8x8

L'utilisation d'une temporisation non bloquante avec millis() ou micros() est essentielle pour que l'Arduino puisse effectuer d'autres tâches, comme la lecture de capteurs ou la communication série, tout en actualisant l'affichage.

Principes du code:

• Initialisation des lignes et des colonnes: définition de la direction des broches et de leur état initial éteint dans setup()
• Utilisation non bloquante de micros(): exécution d'un ordonnanceur léger qui déclenche les états de rafraîchissement en fonction du temps écoulé au lieu d'utiliser la fonction bloquante delay()
• Mise à jour d'une ligne à chaque cycle: placement sélectif des lignes à l'état HIGH et des colonnes actives à l'état LOW, puis passage à la ligne suivante à chaque cycle

// Variables globales et définition du motif
const int rowPins[8] = {13, 12, 11, 10, 9, 8, 7, 6};
const int colPins[8] = {5, 4, 3, 2, A5, A4, A3, A2};

byte heartPattern[8] = {
  B00000000,
  B01100110,
  B11111111,
  B11111111,
  B11111111,
  B01111110,
  B00111100,
  B00000000
};

unsigned long lastScanTime = 0;
const unsigned long scanInterval = 1250;
int currentRow = 0;

// Fonction de configuration
void setup() {
  for (int i = 0; i < 8; i++) {
    pinMode(rowPins[i], OUTPUT);
    pinMode(colPins[i], OUTPUT);
    digitalWrite(rowPins[i], LOW);
    digitalWrite(colPins[i], HIGH);
  }
}

// Boucle principale
void loop() {
  unsigned long currentMicros = micros();
  if (currentMicros - lastScanTime >= scanInterval) {
    lastScanTime = currentMicros;
    digitalWrite(rowPins[currentRow], LOW);
    for (int col = 0; col < 8; col++) {
      digitalWrite(colPins[col], HIGH);
    }
    currentRow = (currentRow + 1) % 8;
    for (int col = 0; col < 8; col++) {
      if (bitRead(heartPattern[currentRow], 7 - col) == 1) {
        digitalWrite(colPins[col], LOW);
      }
    }
    digitalWrite(rowPins[currentRow], HIGH);
  }
}

La fonction standard digitalWrite() utilisée ci-dessus est simple et particulièrement adaptée à l'apprentissage, mais elle est relativement lente. Chaque appel à digitalWrite() effectue de nombreuses vérifications de sécurité pendant l'exécution, notamment la détection de la compatibilité PWM de la broche et la consultation des tables de correspondance des registres de ports. Ces opérations peuvent nécessiter jusqu'à 4 µs de traitement.

Dans les projets avancés exigeant des performances élevées, il est courant de contourner cette fonction en manipulant directement les ports, par exemple avec PORTD |= B00000100;, qui s'exécute en un seul cycle d'horloge, soit seulement 62,5 ns sur un microcontrôleur à 16 MHz. Des interruptions de temporisateur matériel peuvent également assurer une efficacité de balayage optimale.

Consommation électrique d'une matrice LED Arduino

Lors de la conception d'un affichage multiplexé, il est nécessaire d'équilibrer le courant de crête et le courant moyen.

• Courant de crête: courant maximal consommé lorsqu'une ligne ou une colonne est entièrement activée. Si huit LED sont allumées dans une colonne, le circuit de commande doit supporter cette pointe cumulée
• Courant moyen: en raison du rapport cyclique, par exemple 1/8 d'une image dans une matrice 8x8, la consommation moyenne d'une LED est beaucoup plus faible que lorsqu'elle est alimentée en continu
• Limites de courant USB: un port USB 2.0 standard d'ordinateur limite le courant d'alimentation à 500 mA. Les grands projets de matrices LED Arduino dépassent souvent cette limite. Lorsque les matrices multiplexées sont alimentées directement par USB, assurez-vous que les courants de crête cumulés, y compris la consommation interne de l'Arduino d'environ 50 mA, restent nettement inférieurs à cette valeur afin d'éviter la réinitialisation du port

Comment mettre en oeuvre le Charlieplexing avec Arduino?

Le Charlieplexing permet de commander efficacement un grand nombre de LED avec très peu de broches, mais exige un contrôle précis de l'état de chacune d'elles.

Logique GPIO à trois états pour le Charlieplexing

Une broche standard de microcontrôleur possède trois états: HIGH (5 V), LOW (0 V) et INPUT. Lorsqu'elle est configurée en INPUT, elle passe dans un état de haute impédance (Hi-Z) et se comporte comme un circuit ouvert. Le Charlieplexing exploite cet état pour isoler certaines paires de LED. Toute broche qui ne pilote pas activement l'image en cours est configurée comme entrée afin de bloquer le passage du courant.

Formule du nombre de LED en Charlieplexing

Le nombre maximal de LED pouvant être pilotées avec N broches se calcule comme suit:

Cette progression mathématique est très efficace. Par exemple, 3 broches permettent de commander seulement 6 LED, tandis que 6 broches peuvent en piloter jusqu'à 30.

Le tableau suivant montre la rapidité avec laquelle la capacité augmente lorsque des broches sont ajoutées:

Schéma de câblage du Charlieplexing

Pour comprendre le fonctionnement du Charlieplexing, il est utile de visualiser la disposition des LED antiparallèles sur le schéma. L'illustration suivante montre trois broches commandant un noeud Charlieplexing composé de six LED:

Figure: schéma d'un circuit Charlieplexing dans lequel 3 broches Arduino commandent 6 LED disposées par paires antiparallèles, avec une résistance sur chaque branche.

Code pinMode() pour le Charlieplexing Arduino

Pour allumer une seule LED, configurez sa broche source en OUTPUT HIGH, sa broche d'absorption en OUTPUT LOW et toutes les autres broches en INPUT à haute impédance.

Principes du code:

• Désactivation des broches précédemment actives: parcours des broches et réinitialisation en INPUT afin qu'aucun chemin parasite ne reste actif
• Configuration dynamique de la source et de l'absorption: modification des directions et des états à l'aide d'une machine à états switch-case correspondant à la LED ciblée

// Définition des broches
const int pins[3] = {9, 10, 11};

// Fonction auxiliaire turnOnLED()
void turnOnLED(int ledIndex) {
  for (int i = 0; i < 3; i++) {
    pinMode(pins[i], INPUT);
    digitalWrite(pins[i], LOW);
  }
  switch(ledIndex) {
    case 1:
      pinMode(pins[0], OUTPUT); digitalWrite(pins[0], HIGH);
      pinMode(pins[1], OUTPUT); digitalWrite(pins[1], LOW);
      break;
    case 2:
      pinMode(pins[1], OUTPUT); digitalWrite(pins[1], HIGH);
      pinMode(pins[0], OUTPUT); digitalWrite(pins[0], LOW);
      break;
    case 3:
      pinMode(pins[1], OUTPUT); digitalWrite(pins[1], HIGH);
      pinMode(pins[2], OUTPUT); digitalWrite(pins[2], LOW);
      break;
  }
}

// Configuration
void setup() {}

// Boucle principale
void loop() {
  for (int i = 1; i <= 3; i++) {
    turnOnLED(i);
    delay(5);
  }
}

Limites de luminosité du Charlieplexing

Dans sa mise en oeuvre standard, le Charlieplexing ne peut allumer qu'une seule LED à la fois. Le rapport cyclique de chaque LED diminue donc fortement à mesure que leur nombre augmente. Si 30 LED sont pilotées, chacune reste active pendant au maximum 1/30 d'une période de balayage. Ce faible rapport cyclique réduit sensiblement la luminosité apparente de l'affichage.

Suppression des images fantômes en Charlieplexing

Les images fantômes apparaissent lorsqu'un courant de fuite traverse d'autres chemins de diodes et allume faiblement des LED qui devraient rester éteintes. Ce phénomène est provoqué par une commutation trop lente de l'état des broches ou par l'utilisation de LED aux caractéristiques différentes. Pour le supprimer, ajoutez un court délai d'extinction entre les changements d'état actif, par exemple en configurant toutes les broches en INPUT pendant 50 µs.

Dépannage du multiplexage de LED Arduino

1. Supprimer le scintillement en augmentant la fréquence de balayage

Si vous observez des pulsations visibles, la fréquence de balayage est trop faible. Augmentez la fréquence du temporisateur ou des interruptions afin que la fréquence de rafraîchissement d'une image complète dépasse 80 à 100 Hz. Le code de la routine de service d'interruption ISR doit rester léger et ne pas utiliser de fonctions lentes comme analogRead() ou delay().

2. Améliorer la luminosité en limitant la perte de rapport cyclique

Un affichage multiplexé fonctionne à une fraction de sa luminosité continue normale. Pour compenser, il est possible d'alimenter les LED par impulsions avec un courant supérieur à leur valeur nominale continue. Certaines LED acceptent des courants impulsionnels plus élevés lorsque le rapport cyclique est faible. Consultez leur fiche technique pour connaître les limites de courant de crête avant de réduire la résistance afin d'augmenter la luminosité.

3. Supprimer les images fantômes d'un affichage multiplexé

Si un pixel actif éclaire légèrement les colonnes voisines, la cause peut être une charge résiduelle dans les broches de commande. Avant d'activer la ligne suivante:

1. Désactivez toutes les colonnes en les plaçant dans leur état haut ou inactif.
2. Commutez les lignes.
3. Réactivez les colonnes.

Cette séquence, appelée intervalle d'extinction, empêche les courants de fuite pendant les transitions d'état.

4. Réparer une ligne ou une colonne de LED inactive

Lorsqu'une ligne ou une colonne entière ne s'allume plus, une seule LED grillée en est rarement la cause. Une erreur de câblage, un court-circuit ou une mauvaise orientation des diodes peut désactiver une ligne ou une colonne entière. Testez le système à l'aide d'un multimètre en mode diode. Si vous utilisez des composants montés en surface (SMD), inspectez la carte à la loupe afin de repérer les joints de soudure froids ou les microfissures. Une conception correcte des pastilles de soudure du PCB permet d'éviter ces problèmes d'assemblage.

5. Résoudre les courants de fuite en Charlieplexing

Le Charlieplexing est très sensible aux différences de tension directe entre les LED. Si des LED rouges de 2,0 V et des LED bleues de 3,2 V sont utilisées sur les mêmes lignes à trois états, le courant peut traverser les LED à plus faible tension lorsque les broches sont en haute impédance et provoquer d'importantes images fantômes. Utilisez toujours des LED identiques présentant des tensions directes appariées dans un réseau en Charlieplexing.

Projets pratiques de multiplexage de LED Arduino

1. Animation sur une matrice LED 8x8

Le balayage matriciel direct par GPIO permet de créer des tableaux personnalisés afin d'afficher successivement plusieurs images. Vous pouvez ainsi réaliser de simples animations en pixel art 8x8, des graphismes de jeux rétro ou des icônes d'état sans ajouter de matériel.

2. Multiplexage d'un cube LED 4x4x4

Un cube LED 3D utilise le multiplexage spatial. En reliant les anodes de 16 colonnes verticales directement à 16 broches GPIO de l'Arduino et en utilisant 4 broches supplémentaires pour parcourir les 4 plans horizontaux à cathode commune, il est possible d'adresser individuellement les 64 LED dans l'espace tridimensionnel.

3. Badge LED en Charlieplexing

Le Charlieplexing ne nécessitant aucun circuit intégré auxiliaire externe, il convient parfaitement aux broches décoratives et aux badges portables compacts et ultralégers. Il permet de piloter 20 voyants interactifs à l'aide de seulement 5 pistes fines reliées à un microcontrôleur miniature.

4. PCB personnalisé pour les projets de matrices LED

Les plaques d'essai sont pratiques pour le prototypage, mais les circuits LED multiplexés deviennent rapidement un enchevêtrement de fils de liaison susceptible de provoquer de mauvais contacts, une capacité parasite et une résistance élevée.

Figure: rendu 3D d'un PCB shield Arduino Uno personnalisé présentant un routage propre, des composants SMT et une matrice LED 8x8.

Pour les conceptions comprenant un grand nombre de LED SMD, de résistances ou de circuits intégrés de commande, JLCPCB propose également des services d'approvisionnement en composants et d'assemblage de PCB. L'assemblage SMT professionnel et le brasage par refusion réduisent le travail d'assemblage manuel tout en garantissant une qualité de fabrication homogène.

Conclusion

Le multiplexage logiciel direct permet aux petits microcontrôleurs de commander de grands affichages grâce à une temporisation précise du balayage et à des architectures de câblage partagé. Le balayage matriciel direct par GPIO et le Charlieplexing sollicitent fortement le logiciel, mais constituent des solutions économiques, minimalistes et particulièrement instructives pour contourner les limites matérielles du nombre de broches.

La conception d'un circuit personnalisé, l'exportation de fichiers Gerber standard et le recours à des services professionnels de fabrication SMT comme le service d'assemblage de PCB de JLCPCB garantissent un brasage de qualité et un fonctionnement fiable de l'affichage, pour donner à vos projets électroniques une finition adaptée à une production commerciale.

FAQ sur le multiplexage de LED Arduino