Arduino LED-Treiber-Tutorial: Steuern Sie mehr LEDs mit 74HC595 und MAX7219

Arduino-GPIO-Pins gehen bei größeren LED-Projekten schnell zur Neige. Durch den Einsatz spezieller LED-Treiber und Erweiterungs-ICs können Sie die Pin-Nutzung drastisch reduzieren, prozessorintensive Multiplexing-Schleifen vermeiden und die Display-Verdrahtung vereinfachen.

In dieser Anleitung lernen Sie die Betriebsarchitektur, die Verdrahtungskonfigurationen, Kaskadierungstechniken und Optimierungsstrategien für das Schieberegister 74HC595 und den LED-Treiber MAX7219 kennen.

Warum Arduino-Projekte LED-Treiber-ICs benötigen

Arduino-GPIO- und Strombegrenzungen

Ein Arduino Uno auf ATmega328P-Basis hat physikalische Grenzen, die eine direkte Ansteuerung vieler LEDs im großen Stil unmöglich machen:

• Maximaler Strom pro Pin: Ein einzelner digitaler I/O-Pin kann sicher maximal 20 mA dauerhaft liefern oder aufnehmen (absolute Spitzenbelastung liegt bei 40 mA).
• Gesamtgrenze des Bauteils: Der gesamte Strom, der durch die Haupt-VCC- und GND-Pins des Mikrocontrollers fließt, darf 200 mA nicht überschreiten.
• Physischer Pins-Mangel: Der Arduino Uno bietet nur 14 digitale I/O-Pins und 6 analoge Eingangspins.

Wenn Sie versuchen, sechzehn Standard-LEDs mit 15 mA gleichzeitig anzusteuern, benötigen Sie 240 mA vom Mikrocontroller-Baustein – das verletzt den sicheren Betriebsbereich und riskiert die sofortige thermische Zerstörung des Siliziums.

LED-Multiplexing vs. LED-Treiber-ICs

Bei der Ansteuerung von Standard-Arrays (wie 8x8-Matrizen oder 7-Segment-Anzeigen) stehen Sie vor der Wahl zwischen direktem softwaregesteuertem Multiplexing und dedizierten Hardware-Treiber-ICs:

• Direktes GPIO-Multiplexing: Erfordert, dass die Arduino-CPU eine hochfrequente Schleife ausführt, um Zeilen und Spalten kontinuierlich zu scannen. Wenn die Hauptschleife durch einen Sensorwert, eine serielle Kommunikation oder einen delay()-Aufruf blockiert wird, friert das Display sofort ein oder flackert.
• Schieberegister (74HC595): Erweitern digitale Ausgangspins über eine einfache 3-Draht-Serielle-Schnittstelle. Obwohl sie das Problem der physischen Pin-Begrenzung kostengünstig lösen, muss der Mikrocontroller dennoch die schnelle Scan-Schleife in Software ausführen, um Matrizen zu multiplexen.
• Dedizierte Display-Treiber (MAX7219): Lagern das Multiplexing vollständig von der CPU aus. Sie enthalten eingebautes statisches RAM zum Halten der Displaydaten und Hardware-Oszillatoren, um die Zeilen-/Spaltendurchläufe automatisch zu verwalten, wodurch die Arduino-CPU vollständig entlastet wird.

74HC595 vs. MAX7219: Welchen LED-Treiber sollten Sie wählen?

• Wählen Sie den 74HC595, wenn Sie eine allgemeine digitale Ausgangserweiterung benötigen (z. B. zur Steuerung einer Reihe von Relais, benutzerdefinierter Balkendiagramme oder einzelner Statusanzeigen) zu sehr geringen Bauteilkosten.
• Wählen Sie den MAX7219, wenn Ihr Projekt speziell 8x8-LED-Gitter, Laufschriftbanner oder mehrstellige 7-Segment-Anzeigen umfasst, da er Strombegrenzung, Scannen und Dimmen auf einem einzigen Silizium-Chip übernimmt.

Vergleich der Arduino-LED-Treiber-ICs

Die folgenden Tabellen zeigen die wesentlichen Unterschiede zwischen Standard-Ausgangserweiterungen und dedizierten Display-Controllern.

So verwenden Sie den 74HC595 mit Arduino für LEDs und LED-Matrizen

Das Schieberegister 74HC595 ist ein äußerst kostengünstiger Chip zur Erweiterung Ihrer Ausgangspins.

74HC595 Pinbelegung erklärt

Der 74HC595 enthält ein 8-Bit-Schieberegister und ein 8-Bit-D-Typ-Speicherregister. Zu den wichtigsten Pins gehören:

• DS (Pin 14): Serieller Dateneingang.
• SH_CP (Pin 11): Schieberegister-Takt. Aktiv bei steigender Flanke.
• ST_CP (Pin 12): Speicherregister-Takt (Latch). Aktualisiert die parallelen Ausgangspins.
• OE (Pin 13): Ausgangsfreigabe. Aktiv LOW.
• MR (Pin 10): Master-Reset. Aktiv LOW.
• Q0 - Q7 (Pins 15, 1-7): Parallele Ausgänge.
• Q7' (Pin 9): Serieller Ausgang (für Daisy-Chaining).

Abbildung: Pinbelegungsdiagramm eines 74HC595 8-Bit-Schieberegister-ICs im DIP-16-Gehäuse.

74HC595 Arduino 8x8 LED-Matrix-Schaltplan

Um eine Doppel-Schieberegister-Konfiguration für eine 8x8-LED-Matrix anzuschließen, verbinden Sie die Takt- und Latch-Pins beider Register parallel mit dem Arduino und kaskadieren Sie ihre seriellen Datenleitungen.

Abbildung: Detaillierter Verdrahtungsplan, der einen Arduino Uno zeigt, der zwei kaskadierte 74HC595-Schieberegister steuert. Das erste Register steuert die Zeilenanoden; das zweite Register steuert die Spaltenkathoden mit Vorwiderständen und teilt sich die Latch- und Taktsignale.

Arduino 74HC595 LED-Matrix-Code mit shiftOut()

Dieser Code demonstriert, wie man ein 3D-gepuffertes Bild (z. B. ein Herz-Muster) auf einer 8x8-LED-Matrix unter Verwendung einer Doppelregister-Kaskade scannt. Durch sequentielles Verschieben von zwei Bytes werden die Spalten und Zeilen in jeder Scanzeile aktualisiert.

Code-Highlights:

• Kaskadierte Schiebeoperation: Hält den Latch LOW, während zwei 8-Bit-Werte hintereinander verschoben werden. Das erste Byte läuft in Register 2 (Spalten) über, während das zweite Byte Register 1 (Zeilen) füllt.
• Spalten- und Zeilen-Polaritätszuordnung: Invertiert die Spaltenwerte (~pattern), um die Kathoden auf LOW zu treiben, und setzt einzelne Zeilenpins über eine bitweise Verschiebung auf HIGH.
• Stabile Aktualisierungsverschachtelung: Verwendet eine Schleife mit geringer Verzögerung, um jede Scanzeile sequentiell zu durchlaufen und so ein stabiles, flimmerfreies Bild zu liefern.
• C/C++

const int latchPin = 10;
const int clockPin = 9;
const int dataPin = 11;

// 8x8 heart pattern representation (1 = active LED, 0 = off LED)
byte heartPattern[8] = {
  B00000000,
  B01100110,
  B11111111,
  B11111111,
  B11111111,
  B01111110,
  B00111100,
  B00000000
};


C/C++

// Setup
void setup() {
  pinMode(latchPin, OUTPUT);
  pinMode(clockPin, OUTPUT);
  pinMode(dataPin, OUTPUT);
}

C/C++

// Main Loop
void loop() {
  // Scan through all 8 rows sequentially
  for (int row = 0; row < 8; row++) {
    // Columns (active LOW): Invert the pattern so that 1s are driven LOW (sinking current)
    byte colData = ~heartPattern[row];
    
    // Rows (active HIGH): Turn on only the current row (e.g. Row 0 -> B00000001, Row 1 -> B00000010)
    byte rowData = (1 << row);
    
    // Ground the latch pin and hold it LOW as long as we are transmitting data
    digitalWrite(latchPin, LOW);
    
    // 1. Shift out column data first (this byte overflows into Register 2, controlling Columns)
    shiftOut(dataPin, clockPin, MSBFIRST, colData);
    
    // 2. Shift out row data second (this byte stays in Register 1, controlling Rows)
    shiftOut(dataPin, clockPin, MSBFIRST, rowData);
    
    // Return the latch pin HIGH to output the updated states simultaneously
    digitalWrite(latchPin, HIGH);
    
    // Delay interval per scan line (1.25 ms per row achieves ~100 Hz frame refresh rate)
    delayMicroseconds(1250);
  }
}

Während softwarebasiertes shiftOut() einfach und bequem ist, basiert es auf manuellem Software-Umschalten der Takt- und Datenpins, was einen Ausführungs-Overhead verursacht. Für hochfrequente Displays mit hohen Anforderungen können Sie auf den Hardware-SPI-Bus (Serial Peripheral Interface) des Arduino umsteigen. Hardware-SPI nutzt die dedizierte interne Schieberegister-Schaltung des ATmega328P, gibt CPU-Taktzyklen frei und ermöglicht Datenübertragungsraten von bis zu 8 MHz.

Kaskadierung mehrerer 74HC595-Schieberegister

Um mehr als 8 Ausgänge zu steuern, können Sie mehrere Schieberegister ohne zusätzliche Pins am Arduino ketten. Verbinden Sie den seriellen Ausgang Q7' (Pin 9) des ersten Registers mit dem seriellen Dateneingang DS (Pin 14) des zweiten Registers. Verbinden Sie die Takt- (SH_CP) und Latch-Pins (ST_CP) beider Chips parallel mit denselben Arduino-Steuerleitungen.

Aufgrund der FIFO (First-In, First-Out) -Natur des seriellen Schiebens führt das Senden von 16 Datenbits dazu, dass die ersten 8 verschobenen Bits aus dem ersten Chip überlaufen und sich im zweiten Chip niederlassen. Daher muss bei Verwendung der MSBFIRST-Übertragung das Datenbyte, das für das zweite Schieberegister in der Kette bestimmt ist, zuerst verschoben werden.

74HC595 PWM-Helligkeitssteuerung über den OE-Pin

Um eine globale Helligkeitssteuerung zu implementieren, verbinden Sie den OE-Pin (Output Enable) des 74HC595 mit einem der PWM-fähigen Pins des Arduino (wie D3 oder D9), anstatt ihn fest mit Masse zu verbinden. Durch Schreiben eines analogen Werts mit analogWrite(OEPin, brightnessValue) (wobei 0 für volle Helligkeit und 255 für Aus steht) können Sie die Ausgangsfreigabezeit der Register modulieren.

So verwenden Sie ein MAX7219 LED-Matrix-Modul mit Arduino

Während das Verdrahten von blanken integrierten Schaltkreisen (ICs) auf Steckbrettern für das grundlegende Lernen nützlich ist, verwenden praktische Bastler und Produktentwickler fast ausschließlich die weit verbreiteten MAX7219 8x8 LED-Matrix-Module. Diese kostengünstigen, fertigen Breakout-Boards sind mit einem oberflächenmontierten MAX7219-IC, Entkopplungskondensatoren und dem Matrix-Sockel bestückt, die bereits auf einer kompakten Platine verlötet sind, was die Hardware-Integration zum Kinderspiel macht.

MAX7219 8x8 LED-Matrix Funktionsprinzip

Ein MAX7219 8x8 LED-Matrix-Modul übernimmt die Multiplexing-Aktualisierung vollständig "on-board". Das Modul enthält ein internes 8x8 Dual-Port statisches RAM.

Wenn Ihr Arduino Pixeldaten über seinen schnellen SPI-Bus an das Board sendet, werden diese Zustände direkt in diesen Onboard-Speicher geschrieben. Der Treiber scannt dann automatisch und kontinuierlich das Gitter mit einer festen internen Rate von 800 Hz.

Da das Modul die Hardware intern aktualisiert, wird Ihr Arduino vollständig von der CPU-intensiven Persistenz-des-Seh-Effekts (PoV)-Schleife befreit, wodurch Bildschirmflimmern verhindert wird, wenn Ihre Hauptschleife langsamere Aufgaben ausführt.

MAX7219 8x8 LED-Matrix Pinbelegung & Verbindung

Standard-MAX7219 8x8 LED-Matrix-Module führen typischerweise alle erforderlichen SPI-Leitungen auf einfache, benutzerfreundliche 5-Pin-Stiftleisten an gegenüberliegenden Enden der Platine heraus (allgemein als "Eingangs"- und "Ausgangsseite" bezeichnet).

Abbildung: MAX7219 8x8 LED-Matrix-Modul mit der standardmäßigen 5-Pin-Eingangsstiftleiste (links) für die Arduino-Kommunikation und der 5-Pin-Ausgangsstiftleiste (rechts) für die Kaskadierung.

• VCC: Stromversorgung (typischerweise +5V DC).
• GND: System-Massebezug.
• DIN (Data In): Serieller Dateneingang, verbunden mit der MOSI-Leitung des Mikrocontrollers.
• CS (Chip Select / LOAD): Pin, der auf LOW gezogen wird, um die Übertragung zu starten, und auf HIGH, um die eingehenden Bytes zu übernehmen.
• CLK (Serial Clock): Synchronisiert die Byte-Übertragung bis zu 10 MHz.
• DOUT (Data Out): Befindet sich auf der Ausgangsstiftleiste. Wird verwendet, um mehrere Module miteinander zu ketten.

Platzierung des integrierten R_iset-Widerstands

Bei einem rohen Silizium-Chip muss der Spitzenstrom des LED-Segments mit einem berechneten externen Widerstand (R_iset) eingestellt werden, der an den ISET-Pin angeschlossen wird.

Bei Standard-MAX7219 8x8 LED-Matrix-Modulen ist dieser Stromeinstellwiderstand bereits auf der Platine integriert (normalerweise ein oberflächenmontierter 10k-Ohm-Widerstand). Dieser voreingestellte Widerstand konfiguriert den Spitzenstrom des Segments sicher auf 40 mA für Standard-Rot-LEDs, wodurch die Notwendigkeit entfällt, diskrete Widerstände selbst zu berechnen, aufzubauen oder zu löten.

Abbildung: Schematische Darstellung der Verdrahtungsverbindungen zwischen einem Arduino Uno und einem MAX7219 8x8 LED-Matrix-Modul.

MAX7219 Steuerregister

Auf niedriger Ebene erfolgt die Kommunikation mit dem Modul durch Senden eines 16-Bit-Pakets, das aus einem 8-Bit-Adressregister gefolgt von einem 8-Bit-Datenbyte besteht:

Befehlbyte = [Adresse (D15-D8)] + [Datenbyte (D7-D0)]

Die primären Steuerregister, die intern auf der Platine abgebildet sind, sind:

Dedizierte Arduino-Bibliotheken vs. Low-Level-Steuerung

Während das Senden von rohen Registercodes mit der Hardware-SPI.h-Bibliothek sehr lehrreich ist, um die Register im Detail zu verstehen, ist das Schreiben komplexer Grafiken oder Laufschrift von Grund auf mühsam.

Für reale Projekte nutzen Entwickler dedizierte, hochoptimierte Open-Source-Bibliotheken, die die Steuerung von MAX7219 LED-Matrix-Modulen unglaublich einfach machen:

1. LedControl: Eine leichte, anfängerfreundliche Bibliothek, mit der Sie einzelne Module oder kleine Ketten ansprechen, einzelne LEDs mit Koordinaten umschalten (setLed()) oder Zeichen anzeigen können.
2. MD_MAX72XX und MD_Parola: Der Goldstandard für kommerzielle und Hobby-Projekte. Sie behandelt Hardware-Konfigurationsvarianten (wie FC-16-Modul-Layouts), mehrstellige Laufschrift-Textpuffer, Schriftarten, Ein-/Ausgangs-Textanimationseffekte und mehrzeilige Zonenlayouts mit minimalem Codierungsaufwand.

Beispiel: Konzeptionelle Low-Level-SPI-Steuerung

Der folgende Code demonstriert, wie eine dedizierte Bibliothek unter der Haube mit den internen Registern des MAX7219 unter Verwendung des nativen Hardware-SPI-Busses des Arduino interagiert.

C/C++

// Pin Definitions
// Includes and Definitions
#include <SPI.h>
const int csPin = 10;

// MAX7219 Register Addresses
const byte REG_NOOP         = 0x00;
const byte REG_DIGIT0       = 0x01;
const byte REG_DECODE_MODE  = 0x09;
const byte REG_INTENSITY    = 0x0A;
const byte REG_SCAN_LIMIT   = 0x0B;
const byte REG_SHUTDOWN     = 0x0C;
const byte REG_DISPLAY_TEST = 0x0F;


// Display Pattern Buffer
byte heartPattern[8] = {
  B00000000,
  B01100110,
  B11111111,
  B11111111,
  B11111111,
  B01111110,
  B00111100,
  B00000000
};

C/C++

// Helper Function to Write to Register
void writeRegister(byte address, byte data) {
  digitalWrite(csPin, LOW);
  SPI.transfer(address);
  SPI.transfer(data);
  digitalWrite(csPin, HIGH);
}

C/C++

// Setup Function
void setup() {
  pinMode(csPin, OUTPUT);
  digitalWrite(csPin, HIGH);
  SPI.begin();
  SPI.beginTransaction(SPISettings(8000000, MSBFIRST, SPI_MODE0));
  writeRegister(REG_DISPLAY_TEST, 0x00);
  writeRegister(REG_DECODE_MODE, 0x00);
  writeRegister(REG_INTENSITY, 0x03);
  writeRegister(REG_SCAN_LIMIT, 0x07);
  writeRegister(REG_SHUTDOWN, 0x01);
  for (int i = 1; i <= 8; i++) {
    writeRegister(i, 0x00);
  }
}

C/C++

// Main Loop
void loop() {
  for (int col = 0; col < 8; col++) {
    writeRegister(REG_DIGIT0 + col, heartPattern[col]);
  }
  delay(1000);
}

Kaskadierung von MAX7219 8x8 LED-Matrix-Modulen

Das Kaskadieren mehrerer MAX7219 8x8 LED-Matrix-Module, um ein breites Banner-Display zu bauen, ist bemerkenswert einfach.

Sie montieren die Module einfach nebeneinander. Verbinden Sie die gemeinsamen Leitungen - VCC, GND, CLK und CS - parallel über alle Boards (normalerweise einfach mit Standard-Female-Female-Dupont-Jumperkabeln).

Für den seriellen Datenpfad führen Sie den DOUT (Data Out)-Pin auf der rechten Ausgangsstiftleiste des ersten Moduls direkt in den DIN (Data In)-Pin auf der linken Eingangsstiftleiste des benachbarten Moduls.

Wenn Sie übergeordnete Bibliotheken wie MD_Parola verwenden, deklarieren Sie einfach die Gesamtzahl der angeschlossenen Module in Ihren Setup-Konfigurationen (z. B. #define MAX_DEVICES 4). Die Bibliothek koordiniert automatisch das Verschieben der seriellen Textpuffer durch die geketteten Boards und erzeugt nahtlose, synchronisierte Multi-Modul-Textscrolling.

Stromanforderungen für Arduino-LED-Matrix-Displays

Während ein einzelnes Modul sicher über den integrierten 5V-Regler Ihres Arduino betrieben werden kann, werden größere kaskadierte Arrays schnell das USB-Strombudget sprengen:

• USB 2.0 Versorgungsgrenze: Standard-Computer-USB-Anschlüsse begrenzen den Versorgungsstrom auf 500 mA.
• Stromaufnahme bei Kaskadierung: Ein 8x32 (4-Modul)-Display, das mit voller Helligkeit läuft, kann bei hoher Pixeldichte leicht 600 mA bis 1 A ziehen.
• Die Lösung: Schließen Sie ein externes, geregeltes 5V-Netzteil mit einer Nennleistung von mindestens 2 A direkt an die VCC- und GND-Schienen Ihrer LED-Module an. Entscheidend ist, dass Sie die GND-Leitung des externen Netzteils immer mit dem GND-Pin des Arduino verbinden, um eine gemeinsame Massebezugsebene herzustellen.

Fehlerbehebung bei Arduino-LED-Treibern

#1 74HC595 Ausgänge werden nicht aktualisiert

Wenn Ihre LEDs ihren Zustand nicht ändern, überprüfen Sie die Latch-Leitung (ST_CP). Wenn diese Leitung unterbrochen oder mit GND kurzgeschlossen ist, empfängt das Schieberegister die Daten, lädt die Werte aber nie auf die physischen Ausgangspins.

#2 Falsche LED-Reihenfolge nach der Kaskadierung

Wenn Ihre LEDs in umgekehrter Reihenfolge aufleuchten oder Daten in das falsche Register verschoben werden, liegt ein FIFO-Zuordnungsfehler vor. Denken Sie daran, dass das zuerst verschobene Datenbyte in den zweiten Chip der Kette geschoben wird. Versuchen Sie, die Reihenfolge Ihrer shiftOut()-Aufrufe in Ihrem Code zu tauschen.

#3 MAX7219 Matrix zeigt keinen Text an

Wenn eine kaskadierte Matrix vollständig leer bleibt, ist die häufigste Ursache eine fehlende Aufwecksequenz. Der MAX7219 startet standardmäßig im energiesparenden Herunterfahr-Zustand.

Ihr Setup-Code muss explizit 0x01 in das Shutdown-Register (0x0C) schreiben und das Scan-Limit-Register (0x0B) auf 0x07 konfigurieren, um alle 8 Zeilen zu aktivieren.

#4 LED-Matrix ist dunkel oder ungleichmäßig

Wenn die LEDs dunkel erscheinen oder entlang einer Kaskadenkette nachlassen, überprüfen Sie Ihre Stromverteilung. Der Bahnwiderstand dünner Jumperkabel verursacht einen Spannungsabfall.

Führen Sie immer dickere Kabel direkt von Ihrem 5V-Netzteil zum Stromeingangspin jedes Moduls, anstatt die dünnen VCC-Kabel von Board zu Board zu kaskadieren.

#5 LED-Display flackert

Flimmern wird fast immer durch eine fehlende Masseverbindung verursacht. Wenn Ihre Module von einem externen Netzteil gespeist werden und Sie vergessen haben, ein Kabel zwischen dem Minuspol des Netzteils und dem GND-Pin des Arduino zu verlegen, schwanken die Hochgeschwindigkeits-SPI-Signale wild relativ zur schwebenden Referenz.

#6 Probleme mit dem Startzustand

Beim Einschalten können die Schieberegister-Ausgänge schweben oder zufällig initialisieren, was zu einem kurzen, unerwünschten Aufleuchten aller angeschlossenen LEDs führt.

Um dies zu verhindern, setzen Sie einen 10k-Ohm-Pullup-Widerstand vom OE-Pin zu VCC. Dies zwingt die Ausgänge beim Start in einen hochohmigen (deaktivierten) Zustand. Sobald die Arduino-Bootsequenz abgeschlossen ist, kann Ihr Setup-Code den OE-Pin auf LOW setzen, um saubere Ausgangszustände zu aktivieren.

Arduino-LED-Treiber-Projekte

8x32 MAX7219 Laufschrift-Display

Durch Kaskadierung von vier Standard-8x8-Modulen und Verwendung der MD_Parola-Bibliothek können Sie ein großes Laufschrift-Banner-Display mit fließenden Ein- und Ausgangs-Textanimationen bauen.

Abbildung: Vier 8x8 LED-Matrix-Module, die per Daisy-Chain für ein Textdisplay-Projekt mit Arduino verbunden sind

Großes LED-Balkendiagramm mit 74HC595

Durch die Kettung von drei 74HC595-Schieberegistern können Sie einen hochauflösenden 24-Segment-Audio-Pegelindikator oder eine Batterieanzeige mit außergewöhnlicher Helligkeit und ohne zusätzlichen Pin-Aufwand ansteuern.

Arduino 7-Segment-Anzeige Multiplexing

Für Projekte, die numerische Anzeigen erfordern, ist ein Arduino 7-Segment-Anzeige-Multiplexing-Aufbau eine klassische Implementierung. Eine typische mehrstellige 7-Segment-Anzeige basiert auf einer Standardanordnung von sieben einzelnen LED-Segmenten, die mit a, b, c, d, e, f und g bezeichnet werden, zusammen mit einem optionalen achten Dezimalpunkt-Segment (dp).

In einem 4-stelligen Paket führt dies zu insgesamt 12 physischen Schnittstellenpins: 8 Pins, die parallel geschaltet sind, um die Segmente aller Ziffern abzubilden, und 4 gemeinsame Kathoden- oder Anodenpins, um auszuwählen, welche Ziffer aktiv ist.

Viele Arduino 7-Segment-Multiplexing-Projekte verwenden 74HC595-Schieberegister oder MAX7219-Treiber, um die GPIO-Nutzung zu reduzieren und das Aktualisierungstiming zu vereinfachen. Dieser Aufbau ist sehr vielseitig, unabhängig davon, ob Sie Common-Anode- oder Common-Cathode-Konfigurationen verwenden.

Anstatt 32 Pins zu verwenden, um vier Ziffern direkt anzusteuern, durchläuft das Multiplexing sequentiell die vier gemeinsamen Pins, während die entsprechenden Segmentdaten verschoben werden. Bei schnellem Scannen verschmelzen die einzelnen Ziffern zu einer kontinuierlichen mehrstelligen Anzeige ohne sichtbares Flimmern.

Vom Steckbrett-Prototyp zur kundenspezifischen LED-Anzeige-PlatineKostenloses Angebot erhalten

• Wenn Sie vom Steckbrett-Prototyp zu einer kundenspezifischen LED-Anzeige-Platine wechseln, planen Sie die Strompfade, Steckerplatzierungen, Entkopplungskondensatoren und Footprints der Treiber-ICs frühzeitig.
• Die PCB-Fertigungs- und Bestückungsdienste von JLCPCB können helfen, Arduino-LED-Treiber-Prototypen in kompakte, produktionsreife Platinen zu verwandeln.

Fazit

Arduino-LED-Treiber ermöglichen es kleinen Mikrocontrollern, überraschend große Displays mit sorgfältigem Scan-Timing und gemeinsamen Verdrahtungsarchitekturen zu steuern. Matrix-Scannen, 74HC595-Schieberegister, Charlieplexing und MAX7219-Treiber lösen jeweils unterschiedliche Skalierungsprobleme, abhängig von GPIO-Grenzen, Helligkeitsanforderungen, CPU-Auslastung und Schaltungskomplexität.

Häufig gestellte Fragen (FAQs) zu Arduino-LED-Treibern

F: Wie viele LEDs kann ein 74HC595 steuern?

Ein einzelnes 74HC595-Schieberegister hat 8 parallele Ausgänge und kann somit bis zu 8 einzelne LEDs direkt steuern. Sie können jedoch mehrere Register in Reihe kaskadieren, um die Ausgänge unbegrenzt zu erweitern.

F: Wie viele MAX7219-Module können kaskadiert werden?

Sie können sauber bis zu 8 MAX7219-Module in Reihe über einen standardmäßigen Hardware-SPI-Bus kaskadieren, bevor Signalausbreitungsverzögerungen auf den Datenleitungen Latenzprobleme verursachen.

F: Benötigt der MAX7219 Multiplexing-Code?

Nein. Der MAX7219 verfügt über eine eingebaute Hardware-Multiplexing-Schaltung, die die angeschlossenen Matrixspalten intern kontinuierlich aktualisiert, sodass kein Multiplexing-Code auf Ihrem Arduino erforderlich ist.

F: Warum ist mein 74HC595-Ausgang beim Start zufällig?

Beim Einschalten booten interne Schieberegister in einen zufälligen Zustand. Sie können dies beheben, indem Sie einen 10k-Ohm-Pullup-Widerstand am Output Enable (OE)-Pin platzieren, um die Ausgänge deaktiviert zu halten, bis Ihr Arduino-Setup-Code abgeschlossen ist.

F: Kann der 74HC595 leistungsstarke LEDs ansteuern?

Nein. Ein paralleler Pin des 74HC595 ist für einen maximalen Ausgangsstrom von nur 35 mA ausgelegt. Um leistungsstarke LEDs anzusteuern, schließen Sie die Schieberegister-Ausgänge an eine Transistor-Treiberplatine oder ein Darlington-Array an.

F: Was ist besser: 74HC595 oder MAX7219?

Der 74HC595 ist besser für die allgemeine digitale Ausgangserweiterung mit kleinem Budget geeignet. Der MAX7219 ist für komplexe Common-Cathode-7-Segment-Anzeigen oder 8x8-LED-Gitter deutlich überlegen.

F: Warum flackert meine LED-Matrix?

Flimmern wird normalerweise durch den Betrieb eines externen Netzteils ohne Verbindung seiner Masseleitung zum GND-Pin des Arduino verursacht oder durch die Verwendung einer softwaregesteuerten SPI-Schleife, die durch langsame Operationen in Ihrem Code blockiert wird.

F: Benötigen MAX7219-Module externe Widerstände?

Nein. Standard-MAX7219 8x8 LED-Matrix-Module werden mit einem integrierten, bereits auf der Platine verlöteten Stromeinstellwiderstand geliefert, wodurch die Notwendigkeit externer Vorwiderstände in Ihren Spalten vollständig entfällt.