MAX7219 Arduino LED-Matrix: Lauftext mit MD_Parola und Uhr

Der MAX7219 ist ein günstiger Treiberbaustein, der 64 LEDs ganz allein ansteuert, und damit der einfachste Weg, eine LED-Matrix am Arduino zu betreiben. Du findest ihn meist in zwei Varianten: als Modul mit einer einzelnen 8x8-Punktmatrix und als 4-in-1-Modul mit 8x32 Punkten, bei dem vier Matrizen nebeneinander sitzen. Der MAX7219 braucht vom Arduino nur 3 Signalleitungen (DIN, CS, CLK); das Durchschalten der Zeilen hunderte Male pro Sekunde, die Helligkeit und den Zustand jeder einzelnen LED übernimmt er selbst. So bleibt der Arduino frei für Lauftext, Uhren, Anzeigetafeln oder Animationen, und du kannst die Anzeige beliebig verlängern, indem du Module hintereinander steckst.

In diesem Artikel lernst du, wie der MAX7219 funktioniert, wie du das Modul per SPI an Arduino Uno, ESP32 und Raspberry Pi Pico anschließt, wie du Module verkettest und wie du mit der Bibliothek MD_Parola deinen ersten Lauftext anzeigst. Danach behebst du das Problem mit gespiegelter oder kopfstehender Schrift, an dem die meisten Einsteiger hängen bleiben, über den richtigen Hardwaretyp (FC16_HW), berechnest Helligkeit und Stromverbrauch, zeigst Umlaute und eigene Zeichen an und baust eine Uhr mit RTC-Modul sowie eine Animation Pixel für Pixel. Zum Schluss geht es um Nachrichten vom Handy per ESP32, MicroPython-Code für den Pico und die Lösungen für typische Fehler.

Was ist der MAX7219 und wie funktioniert er?

64 LEDs einzeln an Arduino-Pins anzuschließen ist nicht möglich, deshalb arbeiten LED-Matrizen im Multiplexbetrieb. In einer 8x8-Matrix sind die LEDs in einem Raster aus 8 Zeilen und 8 Spalten verschaltet. Der MAX7219 aktiviert zu jedem Zeitpunkt nur eine LED-Gruppe (im Datenblatt ein "Digit", bei der Matrix eine Zeile oder Spalte), legt über die übrigen Leitungen fest, welche der acht LEDs dieser Gruppe leuchten, und springt dann zur nächsten Gruppe. Alle acht Gruppen werden etwa 800-mal pro Sekunde durchlaufen; das Auge kann dem nicht folgen, deshalb wirkt das Bild ruhig. Dabei speichert der Chip das Muster jeder Gruppe in seinem eigenen 8x8-Bit-RAM, begrenzt den LED-Strom mit einem einzigen Widerstand und regelt die Helligkeit in 16 Stufen.

Arduino und MAX7219 kommunizieren über eine dreiadrige serielle Schnittstelle, die ähnlich wie SPI arbeitet. Jeder Befehl ist ein 16-Bit-Paket: Das obere Byte wählt das Register, in das geschrieben wird, das untere Byte enthält den Wert. Solange CS (im Datenblatt LOAD) LOW ist, werden die Bits bei jeder steigenden Flanke von CLK über DIN hineingeschoben; wird CS wieder HIGH, landet das Paket im Register. Das Prinzip kennst du vom Schieberegister 74HC595, aber weil der MAX7219 auch das Multiplexen und die Strombegrenzung übernimmt, hast du viel weniger Arbeit. Wie SPI allgemein funktioniert, erfährst du im Artikel Was ist SPI?.

Der MAX7219 hat 14 adressierbare Register; die für eine LED-Matrix wichtigen findest du in der Tabelle unten. Die Bibliotheken stellen sie für dich ein, trotzdem hilft es bei der Fehlersuche sehr, ihre Aufgabe zu kennen. Beim ersten Einschalten startet der Chip zum Beispiel im Shutdown-Modus mit dunkler Anzeige; läuft der Initialisierungscode nicht, wirkt das Modul völlig tot. Der Schwesterchip MAX7221 hat dieselben Register, besitzt aber einen echten SPI-kompatiblen CS-Pin und flankenbegrenzte Segmenttreiber, die elektromagnetische Störungen verringern.

Einzelnes 8x8-Modul oder 4-in-1-Modul mit 8x32?

Die beiden Module, die dir am häufigsten begegnen, haben dieselbe Schaltung; der Unterschied liegt darin, wie die LED-Matrix mit dem MAX7219 verdrahtet ist, und in der Form der Platine. Das Einzelmodul auf grüner Platine trägt einen MAX7219 im DIP-Gehäuse (24 Pins) und eine 8x8-Matrix wie die 1088AS; an einem Ende sitzen die Eingangspins (VCC, GND, DIN, CS, CLK), am anderen die Ausgangspins (VCC, GND, DOUT, CS, CLK). Beim blauen 4-in-1-Modul sitzen vier SMD-MAX7219 unter den Matrizen, und die vier Blöcke sind ab Werk verkettet; auf der Platine steht meist FC-16. Für einen langen Lauftext ist das 4-in-1-Modul günstiger und aufgeräumter.

MAX7219 anschließen: Arduino Uno, ESP32 und Pico

Das Modul hat fünf Pins: VCC und GND für die Versorgung, DIN für die Daten, CLK für den Takt und CS für Chip Select (Load). MD_Parola und MD_MAX72XX nutzen standardmäßig Hardware-SPI; dann muss DIN an den MOSI-Pin und CLK an den SCK-Pin deines Boards, während du für CS jeden digitalen Pin wählen kannst. Wo die Hardware-SPI-Pins auf deinem Board liegen, zeigt dir das Pinout-Tool. Stecke die Kabel immer auf die Eingangsseite (IN) des Moduls, also das Ende mit DIN; das Ende mit DOUT ist für das nächste Modul gedacht.

ESP32 und Pico arbeiten mit 3,3-V-Pins, das Datenblatt des MAX7219 verlangt bei 5 V Versorgung aber mindestens 3,5 V als HIGH-Pegel. 3,3-V-Signale liegen also technisch knapp unter der Grenze. Die meisten Module funktionieren trotzdem, doch bei langen Kabeln oder bestimmten Chip-Chargen können zufällig leuchtende Punkte und ein gestörtes Bild auftreten. Die saubere Lösung ist ein Puffer wie der 74HCT125, der 3,3 V als HIGH erkennt und 5 V ausgibt, oder ein schneller Pegelwandler in den Leitungen DIN, CLK und CS. Signalkabel unter 20 cm zu halten, löst das Problem oft ebenfalls.

Module verketten (Daisy Chain)

Der DOUT-Pin des MAX7219 gibt die an DIN eingehenden Daten 16,5 Taktzyklen später wieder aus. Verbindest du die OUT-Seite eines Moduls mit der IN-Seite des nächsten, geht DOUT an DIN des folgenden Chips, während CLK und CS bei allen Chips gemeinsam sind. So verlassen weiterhin nur 3 Signalleitungen den Arduino, die Anzeige kann aber 8, 16 oder 32 Blöcke lang sein. Bei jeder Aktualisierung schickt die Bibliothek Pakete durch die ganze Kette, und sobald CS steigt, übernehmen alle gleichzeitig. Bei 4-in-1-Modulen ist diese Verbindung schon auf der Platine vorhanden; für eine Anzeige mit 8 Blöcken (64x8) aus zwei 4-in-1-Modulen verbindest du einfach die OUT-Pins des ersten Moduls mit den IN-Pins des zweiten und setzt MAX_DEVICES im Code auf 8.

In der Bibliothek beginnt die Blocknummerierung beim Modul, das dem DIN-Eingang am nächsten ist, und steigt nach links an; für MD_MAX72XX liegt der Koordinatenursprung in der rechten oberen Ecke. Damit der Text richtig lesbar ist, muss der DIN-Eingang deshalb rechts liegen. Je länger die Kette, desto mehr wird die Stromversorgung zur eigentlichen Grenze: Speise alle 4–8 Blöcke 5 V und GND mit dicken Leitungen neu ein und setze an den Versorgungseingang jedes Moduls einen 10-µF-Elko und einen 100-nF-Keramikkondensator. Auch das Datenblatt empfiehlt dieses Paar, um die Welligkeit durch die Stromspitzen der LEDs zu glätten.

Bibliotheken installieren: MD_MAX72XX und MD_Parola

Die beiden beliebtesten MAX7219-Bibliotheken stammen vom selben Autor (majicDesigns) und arbeiten zusammen. MD_MAX72XX erledigt die Arbeit auf unterer Ebene: Es initialisiert die Module, schreibt Pixel und Spalten und verwaltet die Schriftart. MD_Parola baut darauf auf und ergänzt Lauftext, Effekte, Ausrichtung und Zonen. Die LedControl-Bibliothek aus älteren Beispielen funktioniert ebenfalls, aber den Lauftext musst du dann selbst programmieren. Falls du noch nie eine Bibliothek installiert hast, lies zuerst Arduino-Bibliothek hinzufügen.

1. Öffne in der Arduino IDE den Bibliotheksverwalter (Werkzeuge > Bibliotheken verwalten) und suche nach MD_Parola.
2. Installiere die Bibliothek MD_Parola von majicDesigns. Wenn nach Abhängigkeiten gefragt wird, wähle Install all, damit MD_MAX72XX mitinstalliert wird.
3. Schließe das Modul wie in der Tabelle oben an und setze für ein 4-in-1-Modul im Code HARDWARE_TYPE auf FC16_HW und MAX_DEVICES auf 4.
4. Lade den Sketch hoch. Steht die Schrift auf dem Kopf, ist sie gespiegelt oder gedreht, kein Grund zur Sorge: Im Abschnitt zum Hardwaretyp unten behebst du das mit einer Zeile.

Erstes Programm: Lauftext mit MD_Parola

1// MAX7219 4'lü modülde kayan yazı (MD_Parola) / Scrolling text on a 4-in-1 MAX7219 module (MD_Parola)
2#include <MD_Parola.h>
3#include <MD_MAX72xx.h>
4#include <SPI.h>
5
6#define HARDWARE_TYPE MD_MAX72XX::FC16_HW   // mavi PCB'li 4'lü modül / blue-PCB 4-in-1 module
7#define MAX_DEVICES 4                       // zincirdeki 8x8 blok sayısı / number of 8x8 blocks in the chain
8#define CS_PIN 10                           // DIN = D11 (MOSI), CLK = D13 (SCK)
9
10MD_Parola display = MD_Parola(HARDWARE_TYPE, CS_PIN, MAX_DEVICES);
11
12void setup() {
13  display.begin();
14  display.setIntensity(4);                  // parlaklık 0–15 / brightness 0–15
15  display.displayClear();
16  // metin, hizalama, hız (ms/kare), bekleme (ms), giriş efekti, çıkış efekti
17  // text, alignment, speed (ms/frame), pause (ms), entry effect, exit effect
18  display.displayText("Merhaba BlueGrays!", PA_CENTER, 50, 1000, PA_SCROLL_LEFT, PA_SCROLL_LEFT);
19}
20
21void loop() {
22  if (display.displayAnimate()) {           // efekt bittiğinde true döner / returns true when the effect ends
23    display.displayReset();                 // aynı yazıyı baştan başlat / restart the same text
24  }
25}

Die wichtigste Zeile ist displayText(): Sie bekommt nacheinander den Text, die Ausrichtung (PA_LEFT, PA_CENTER, PA_RIGHT), die Zeit zwischen zwei Frames in Millisekunden, die Pause, nachdem der Text an seinem Platz steht, sowie den Ein- und Ausblendeffekt. Je kleiner der Geschwindigkeitswert, desto schneller läuft der Text; 25–60 ms ergeben einen gut lesbaren Lauftext. displayAnimate() rückt bei jedem Aufruf höchstens einen Frame weiter und kehrt sofort zurück. Deshalb muss die Funktion in loop() ständig aufgerufen werden, und im restlichen Code solltest du kein delay() verwenden, sonst ruckelt der Text. Wie du wartest, ohne das Programm anzuhalten, erfährst du im Artikel millis() statt delay().

Neben PA_SCROLL_LEFT gibt es viele weitere Ein- und Ausblendeffekte: PA_PRINT (Text erscheint sofort), PA_SCROLL_UP und PA_SCROLL_DOWN (vertikales Scrollen), PA_WIPE (Wischen), PA_OPENING und PA_CLOSING (Öffnen und Schließen von der Mitte aus), PA_FADE (Ein- und Ausblenden über die Helligkeit), PA_DISSOLVE, PA_BLINDS, PA_RANDOM und PA_GROW_UP. Alle auf einmal siehst du mit dem Beispiel Parola_Animation_Catalog unter Datei > Beispiele > MD_Parola; passe dabei die Zeilen HARDWARE_TYPE und MAX_DEVICES an dein Modul an.

Hardwaretyp wählen (FC16_HW): gespiegelte oder kopfstehende Schrift beheben

Die Hersteller verdrahten die 8x8-Matrix unterschiedlich mit dem MAX7219: Bei manchen Platinen führen die "Digit"-Leitungen des Chips zu den Zeilen, bei anderen zu den Spalten, und die Reihenfolge der Zeilen oder Spalten kann umgekehrt sein. Die Bibliothek gleicht das über die Einstellung HARDWARE_TYPE aus. Wählst du den falschen Typ, ist das Modul nicht defekt, aber die Zeichen erscheinen in jedem 8x8-Block gespiegelt, auf dem Kopf oder um 90 Grad gedreht. Weil viele ältere Codes im Netz PAROLA_HW oder GENERIC_HW verwenden, ist das der häufigste Fehler bei den heute verkauften blauen 4-in-1-Modulen. Die Tabelle zeigt, was du je nach Symptom ändern musst; sie bezieht sich auf das 4-in-1-Modul FC-16.

Helligkeit und Stromverbrauch

Die Helligkeit hängt von zwei Dingen ab. Das erste ist der Widerstand RSET auf dem Modul: Der Chip gibt etwa das 100-Fache des Stroms, der aus dem ISET-Pin fließt, an die LEDs weiter. Auf Modulen sitzen meist 10 kΩ; das bedeutet einen Spitzenstrom von etwas über 40 mA bei roten LEDs und etwa 40 mA bei blauen und weißen. Das zweite ist das per Software gesetzte Register Intensity: Ein Wert n von 0 bis 15 lässt die LEDs während (2n+1)/32 jedes Multiplexintervalls leuchten; 0 ist die niedrigste (1/32), 15 die höchste Helligkeit (31/32). Und weil jede Zeile nur ein Achtel der Zeit leuchtet, liegt der Mittelwert einer einzelnen LED selbst bei voller Helligkeit nur bei etwa 5 mA. Die Durchlassspannungen nach LED-Farbe findest du im Tool LED-Spannungen.

Den mittleren Strom eines Moduls kannst du grob so abschätzen: I ≈ 8 mA + 5 mA × (2n+1)/32 × L. Dabei sind 8 mA der Eigenverbrauch des Chips, n der Helligkeitswert und L die Zahl der leuchtenden LEDs auf diesem Modul (0–64); 5 mA ist ein Achtel des Spitzenstroms von 40 mA. Leuchten zum Beispiel bei Helligkeit 15 alle 64 LEDs, ergibt das 8 + 5 × 0,97 × 64 ≈ 318 mA, was zu den 330 mA im Datenblatt passt. Bei Lauftext leuchten meist nur 25–35 Prozent der LEDs, der tatsächliche Verbrauch ist also deutlich niedriger. Die Tabelle zeigt typische Werte für ein 4-in-1-Modul.

Um die Anzeige nachts zu dimmen, kannst du die Helligkeit mit einem LDR-Lichtsensor automatisch anpassen und die Anzeige mit displayShutdown(true) schlafen legen, wenn niemand in der Nähe ist. Planst du ein batteriebetriebenes Schild, gib die Werte oben in das Tool Akkulaufzeit ein und berechne, wie viele Stunden es durchhält. In Innenräumen reicht meist eine Helligkeit von 2–4 statt 15; das schont die Augen und senkt den LED-Strom auf etwa ein Drittel bis ein Sechstel.

Umlaute und Sonderzeichen (ä, ö, ü, ß)

Die Arduino IDE speichert deinen Code als UTF-8; ein Buchstabe wie "ä" oder "ß" ist im Text also nicht ein Byte, sondern zwei. MD_Parola sucht jedes Byte als Zeichennummer in der Schriftart, deshalb erscheinen statt Umlauten sinnlose Zeichen. Die Standardschrift der Bibliothek enthält den kompletten Latin-1-Zeichensatz mit ä, ö, ü, Ä, Ö, Ü, ß und °, du brauchst also nur eine kleine Funktion, die UTF-8 in die Codes der Schriftart umwandelt. Zeichen außerhalb von Latin-1, im Beispiel unten die türkischen Buchstaben ğ, ı und ş, musst du Pixel für Pixel zeichnen und mit addChar() hinzufügen. Der Sketch erledigt beide Schritte.

1// MAX7219 + MD_Parola: Türkçe karakterli kayan yazı / Scrolling text with Turkish letters
2#include <MD_Parola.h>
3#include <MD_MAX72xx.h>
4#include <SPI.h>
5
6#define HARDWARE_TYPE MD_MAX72XX::FC16_HW
7#define MAX_DEVICES 4
8#define CS_PIN 10
9
10MD_Parola display = MD_Parola(HARDWARE_TYPE, CS_PIN, MAX_DEVICES);
11
12// Fontta olmayan 6 harf: ilk bayt genişlik, sonrakiler sütunlar (bit 0 = en üst satır)
13// 6 letters missing from the font: first byte is the width, then the columns (bit 0 = top row)
14const uint8_t trG[] = {5, 56, 69, 70, 85, 116};  // Ğ
15const uint8_t trg[] = {4, 25, 166, 166, 125};    // ğ
16const uint8_t trI[] = {3, 68, 125, 68};          // İ
17const uint8_t tri[] = {1, 124};                  // ı
18const uint8_t trS[] = {5, 70, 73, 201, 73, 49};  // Ş
19const uint8_t trs[] = {4, 88, 212, 84, 52};      // ş
20
21// UTF-8 metni fontun kodlarına çevirir / converts UTF-8 text to the font's codes
22void utf8ToFont(const char *src, char *dst, size_t size) {
23  size_t n = 0;
24  while (*src && n < size - 1) {
25    uint8_t c = *src++;
26    if (c < 0x80) { dst[n++] = c; continue; }            // ASCII aynen kalır / ASCII stays as is
27    if ((c & 0xE0) == 0xC0 && *src) {                    // 2 baytlık harf / 2-byte letter
28      uint16_t u = ((c & 0x1F) << 6) | (*src++ & 0x3F);
29      switch (u) {
30        case 0x11E: dst[n++] = (char)0x80; break;        // Ğ
31        case 0x11F: dst[n++] = (char)0x81; break;        // ğ
32        case 0x130: dst[n++] = (char)0x82; break;        // İ
33        case 0x131: dst[n++] = (char)0x83; break;        // ı
34        case 0x15E: dst[n++] = (char)0x84; break;        // Ş
35        case 0x15F: dst[n++] = (char)0x85; break;        // ş
36        default: dst[n++] = (u < 0x100) ? (char)u : '?'; // ç ö ü Ç Ö Ü ° fontta var / already in the font
37      }
38      continue;
39    }
40    while ((*src & 0xC0) == 0x80) src++;                 // desteklenmeyen karakteri atla / skip an unsupported character
41    dst[n++] = '?';
42  }
43  dst[n] = '\0';
44}
45
46char message[96];
47
48void setup() {
49  display.begin();
50  display.setIntensity(3);
51  display.addChar(0x80, trG);                // addChar begin()'den sonra / addChar after begin()
52  display.addChar(0x81, trg);
53  display.addChar(0x82, trI);
54  display.addChar(0x83, tri);
55  display.addChar(0x84, trS);
56  display.addChar(0x85, trs);
57  utf8ToFont("Günaydın İstanbul! Şehirde hava 22°C, çok güzel bir gün.", message, sizeof(message));
58  display.displayText(message, PA_LEFT, 40, 1000, PA_SCROLL_LEFT, PA_SCROLL_LEFT);
59}
60
61void loop() {
62  if (display.displayAnimate()) display.displayReset();
63}

In jedem Array für ein eigenes Zeichen gibt das erste Byte die Breite des Buchstabens in Spalten an, die folgenden Bytes sind die Spalten von links nach rechts; Bit 0 jedes Bytes ist die oberste Zeile. Das türkische ı (i ohne Punkt) ist zum Beispiel eine einzige Spalte, und der Wert 124 (0b01111100) schaltet die Zeilen 2 bis 6 ein; vom normalen i unterscheidet es sich nur durch den fehlenden Punkt. Bei den Großbuchstaben Ğ und İ wurde der Buchstabe um zwei Zeilen verkürzt (5 statt 7 Zeilen), um Platz für das Zeichen darüber zu schaffen. addChar() kopiert die Daten nicht, sondern merkt sich nur ihre Adresse; die Arrays müssen also global sein und nach begin() hinzugefügt werden. Die Codes 0x80–0x85 wurden gewählt, weil sie in normalem Text nie vorkommen. Genauso kannst du beliebige Symbole wie ein Herz oder einen Pfeil ergänzen.

Uhr-Beispiel: Digitaluhr mit RTC-Modul

Der millis()-Zähler des Arduino beginnt nach einem Stromausfall wieder bei null und kann wegen des Keramikresonators des Uno um bis zu einige Minuten pro Tag abweichen. Für eine echte Uhr nimmst du ein RTC-Uhrenmodul. Schließe das DS1307-Modul am I2C-Bus an (SDA → A4, SCL → A5, VCC → 5V, GND → GND); der MAX7219 nutzt die SPI-Pins, die beiden Module kommen sich also nicht in die Quere. Für den Code installierst du im Bibliotheksverwalter die Bibliothek RTClib von Adafruit.

1// MAX7219 + DS1307 RTC ile dijital saat / Digital clock with MAX7219 + DS1307 RTC
2#include <MD_Parola.h>
3#include <MD_MAX72xx.h>
4#include <SPI.h>
5#include <RTClib.h>                         // Adafruit RTClib
6
7#define HARDWARE_TYPE MD_MAX72XX::FC16_HW
8#define MAX_DEVICES 4
9#define CS_PIN 10
10
11MD_Parola display = MD_Parola(HARDWARE_TYPE, CS_PIN, MAX_DEVICES);
12RTC_DS1307 rtc;                             // SDA = A4, SCL = A5
13
14char timeText[8];                           // "12:34" + sonlandırıcı / + terminator
15uint8_t lastSecond = 99;
16
17void setup() {
18  display.begin();
19  display.setIntensity(2);
20  display.setTextAlignment(PA_CENTER);      // print() bu hizalamayı kullanır / print() uses this alignment
21  if (!rtc.begin()) {
22    display.print("RTC?");                  // modül bulunamadı / module not found
23    while (true) {}
24  }
25  if (!rtc.isrunning()) {
26    rtc.adjust(DateTime(F(__DATE__), F(__TIME__)));   // ilk kurulumda derleme saati / compile time on first run
27  }
28}
29
30void loop() {
31  DateTime now = rtc.now();
32  if (now.second() != lastSecond) {         // saniyede bir güncelle / update once a second
33    lastSecond = now.second();
34    // ':' ve boşluk aynı genişlikte, yazı kaymaz / ':' and space are equally wide, nothing shifts
35    sprintf(timeText, (lastSecond % 2) ? "%02d %02d" : "%02d:%02d", now.hour(), now.minute());
36    display.print(timeText);
37  }
38}

Der Sketch liest jede Sekunde die Uhrzeit und lässt den Doppelpunkt blinken. In der Standardschrift sind Doppelpunkt (:) und Leerzeichen gleich breit (2 Spalten), deshalb springen die Ziffern nicht hin und her. Beim ersten Start wird die RTC auf den Zeitpunkt gestellt, zu dem der Sketch kompiliert wurde. Ein DS1307 kann etwa eine Minute pro Monat abweichen; für eine genauere Uhr nimm ein DS3231-Modul und verwende im Code RTC_DS3231 statt RTC_DS1307 und ändere die Bedingung if (!rtc.isrunning()) in if (rtc.lostPower()). Dank seines temperaturkompensierten Quarzes weicht der DS3231 nur etwa eine Minute pro Jahr ab. Du kannst die Anzeige auch in zwei Zonen teilen und auf einer Seite die Uhrzeit, auf der anderen die Temperatur zeigen.

Animation: Pixel für Pixel zeichnen mit MD_MAX72XX

Wenn du über Lauftext hinausgehen willst, kannst du die Bibliothek MD_MAX72XX direkt verwenden. Sie behandelt die ganze Kette als eine einzige Pixelanzeige: Ein 4-in-1-Modul hat 32 Spalten und 8 Zeilen. setPoint(Zeile, Spalte, Zustand) schaltet eine einzelne LED ein oder aus, setColumn() schreibt alle 8 Bit einer Spalte auf einmal, und clear() löscht die Anzeige. Der Ursprung (0, 0) liegt in der rechten oberen Ecke; die Spaltennummern steigen nach links, die Zeilennummern nach unten. Der folgende Code zeichnet einen Ball, der von den Rändern der Anzeige abprallt:

1// MD_MAX72XX ile seken top animasyonu / Bouncing ball animation with MD_MAX72XX
2#include <MD_MAX72xx.h>
3#include <SPI.h>
4
5#define HARDWARE_TYPE MD_MAX72XX::FC16_HW
6#define MAX_DEVICES 4
7#define CS_PIN 10
8
9MD_MAX72XX mx = MD_MAX72XX(HARDWARE_TYPE, CS_PIN, MAX_DEVICES);
10
11int x = 0, y = 0;                           // topun konumu (sütun, satır) / ball position (column, row)
12int dx = 1, dy = 1;                         // hareket yönü / direction of travel
13
14void setup() {
15  mx.begin();
16  mx.control(MD_MAX72XX::INTENSITY, 2);
17  mx.clear();
18}
19
20void loop() {
21  const int lastCol = mx.getColumnCount() - 1;          // 4 modülde 31 / 31 with 4 modules
22  mx.control(MD_MAX72XX::UPDATE, MD_MAX72XX::OFF);      // çizim bitene kadar gönderme / hold updates while drawing
23  mx.setPoint(y, x, false);                             // eski konumu sil / erase the old position
24  x += dx;
25  y += dy;
26  if (x <= 0 || x >= lastCol) dx = -dx;                 // kenara çarpınca dön / bounce off the edge
27  if (y <= 0 || y >= 7) dy = -dy;
28  mx.setPoint(y, x, true);                              // yeni konumu yak / light the new position
29  mx.control(MD_MAX72XX::UPDATE, MD_MAX72XX::ON);       // hepsini tek seferde gönder / send everything at once
30  delay(40);
31}

In jedem Frame wird zuerst die automatische Aktualisierung (UPDATE) ausgeschaltet, das alte Pixel gelöscht und das neue gezeichnet; danach wird UPDATE wieder eingeschaltet, sodass alle Änderungen in einem Rutsch an die Module gehen. So erscheint nie ein halb gezeichneter Frame. Nach demselben Prinzip kannst du Würfel, Smileys, ein Snake-Spiel oder Pegelbalken zeichnen. In den Beispielen von MD_MAX72XX findest du außerdem fertige Animationen wie Pac-Man, Roboteraugen und eine Sanduhr. Mit MD_Parola erreichst du dieselben Zeichenfunktionen über getGraphicObject().

Nachrichten übers Internet mit dem ESP32: Lauftext vom Handy

Mit einem ESP32 machst du deine Laufschrift kabellos. Der Code unten verbindet sich mit deinem Heimnetz, lässt zuerst seine eigene IP-Adresse durchlaufen und zeigt danach die Uhrzeit aus dem Internet (NTP) an. Öffnest du diese IP-Adresse im Browser eines Handys im selben WLAN, siehst du ein Textfeld; die eingegebene Nachricht läuft ab der nächsten Runde über die Anzeige und wechselt sich mit der Uhrzeit ab. Das Modul hängt wie in der Tabelle an den VSPI-Pins: CLK an GPIO 18, DIN an GPIO 23 und CS an GPIO 5. Wenn der ESP32 neu für dich ist, lies zuerst Was ist der ESP32?.

1// ESP32: telefondan mesaj + internet saati / ESP32: message from your phone + internet time
2#include <WiFi.h>
3#include <WebServer.h>
4#include <time.h>
5#include <MD_Parola.h>
6#include <MD_MAX72xx.h>
7#include <SPI.h>
8
9#define HARDWARE_TYPE MD_MAX72XX::FC16_HW
10#define MAX_DEVICES 4
11#define CS_PIN 5                            // VSPI: CLK = GPIO 18, DIN = GPIO 23
12
13const char* ssid = "AgAdi";                 // Wi-Fi adın / your Wi-Fi name
14const char* password = "Sifre123";          // Wi-Fi şifren / your Wi-Fi password
15
16MD_Parola display = MD_Parola(HARDWARE_TYPE, CS_PIN, MAX_DEVICES);
17WebServer server(80);
18
19char message[128];
20char nextMessage[128];
21char clockText[8] = "--:--";
22bool newMessage = false;
23bool showClock = false;
24
25const char PAGE[] = R"rawliteral(<!DOCTYPE html><html><head><meta charset="utf-8">
26<meta name="viewport" content="width=device-width"><title>MAX7219</title></head><body>
27<h2>Kayan yazı / Scrolling text</h2>
28<form action="/"><input name="m" maxlength="100"> <button>Gönder / Send</button></form>
29</body></html>)rawliteral";
30
31void handleRoot() {
32  if (server.hasArg("m")) {                 // formdan gelen mesaj / message from the form
33    server.arg("m").toCharArray(nextMessage, sizeof(nextMessage));
34    newMessage = true;
35  }
36  server.send(200, "text/html; charset=utf-8", PAGE);
37}
38
39void setup() {
40  display.begin();
41  display.setIntensity(3);
42  display.print("WiFi..");
43  WiFi.begin(ssid, password);
44  while (WiFi.status() != WL_CONNECTED) delay(500);
45  configTime(3 * 3600, 0, "pool.ntp.org");  // Türkiye UTC+3 / Turkey is UTC+3
46  snprintf(message, sizeof(message), "IP: %s", WiFi.localIP().toString().c_str());
47  server.on("/", handleRoot);
48  server.begin();
49  display.displayText(message, PA_LEFT, 40, 0, PA_SCROLL_LEFT, PA_SCROLL_LEFT);
50}
51
52void loop() {
53  server.handleClient();
54  if (display.displayAnimate()) {           // önceki gösterim bitti / the previous show has ended
55    showClock = !showClock;
56    if (newMessage) {                       // yeni mesaj sırayı keser / a new message jumps the queue
57      strlcpy(message, nextMessage, sizeof(message));
58      newMessage = false;
59      showClock = false;
60    }
61    if (showClock) {
62      struct tm t;
63      if (getLocalTime(&t, 10)) strftime(clockText, sizeof(clockText), "%H:%M", &t);
64      display.displayText(clockText, PA_CENTER, 40, 3000, PA_SCROLL_DOWN, PA_SCROLL_UP);
65    } else {
66      display.displayText(message, PA_LEFT, 40, 0, PA_SCROLL_LEFT, PA_SCROLL_LEFT);
67    }
68  }
69}

handleRoot() schreibt die Nachricht aus dem Formular nicht sofort auf die Anzeige, sondern parkt sie in nextMessage. Kopiert wird sie erst, wenn die laufende Animation fertig ist (wenn displayAnimate() true liefert); so ändert sich der Text, den MD_Parola gerade liest, nie mittendrin. Der Wert 3 × 3600 in configTime() steht für die Zeitzone UTC+3 der Türkei; in Deutschland, Österreich und der Schweiz ersetzt du die Zeile durch configTzTime("CET-1CEST,M3.5.0,M10.5.0/3", "pool.ntp.org"), das auch die Sommerzeit berücksichtigt. Für Umlaute in Nachrichten übernimmst du die addChar()-Zeilen und die Funktion utf8ToFont() von oben und ersetzt die Zeile mit strlcpy() durch utf8ToFont(nextMessage, message, sizeof(message)). Mehr zu Internetzeit und Echtzeit-Weboberflächen findest du in ESP32-NTP-Uhr und ESP32-Webserver mit WebSocket.

MAX7219 mit dem Raspberry Pi Pico und MicroPython

Mit MicroPython auf dem Pico ist es am einfachsten, den Open-Source-Treiber max7219.py (micropython-max7219) mit Thonny auf den Pico zu kopieren. Da der Treiber das framebuf-Modul von MicroPython nutzt, stehen Zeichenfunktionen wie text(), pixel(), line() und rect() direkt zur Verfügung, und auf 4-in-1-Modulen vom Typ FC-16 stimmt die Ausrichtung. Versorge das Modul über VBUS (5 V) und verbinde DIN mit GP19, CLK mit GP18 und CS mit GP17. MicroPython belegt auch den MISO-Pin von SPI0 (GP16); nutze diesen Pin also nicht anderweitig. Die Schrift von framebuf ist 8x8 Pixel groß und enthält nur ASCII, daher zeigt ein 4-in-1-Modul 4 Buchstaben gleichzeitig und keine Umlaute. Zur Einrichtung siehe Was ist der Raspberry Pi Pico? und MicroPython-Grundlagen.

1# Pico + 4'lü MAX7219 modül: kayan yazı / Pico + 4-in-1 MAX7219 module: scrolling text
2from machine import Pin, SPI
3import time
4import max7219                        # max7219.py Pico'da olmalı / must be on the Pico
5
6# GP18 = SCK -> CLK, GP19 = MOSI -> DIN, GP17 -> CS; GP16 (MISO) boş kalır / GP16 (MISO) stays free
7spi = SPI(0, baudrate=5_000_000, polarity=0, phase=0, sck=Pin(18), mosi=Pin(19))
8display = max7219.Matrix8x8(spi, Pin(17, Pin.OUT), 4)
9display.brightness(3)                 # parlaklık 0–15 / brightness 0–15
10
11def scroll(text, delay_ms=35):
12    width = len(text) * 8             # her harf 8 piksel / each letter is 8 px wide
13    for x in range(32, -width, -1):   # sağdan girip solda kaybolur / enters right, leaves left
14        display.fill(0)
15        display.text(text, x, 0, 1)
16        display.show()
17        time.sleep_ms(delay_ms)
18
19while True:
20    scroll("BlueGrays + Pico")
21    display.fill(0)
22    display.text("Pico", 0, 0, 1)     # 4 harf tam sığar / exactly 4 letters fit
23    display.show()
24    time.sleep(1)
25    display.fill(0)
26    display.rect(0, 0, 32, 8, 1)      # ekran çerçevesi / display frame
27    display.show()
28    time.sleep_ms(500)

Projektideen mit dem MAX7219

• Laufschrift-Schild: Baue eine Nachrichtentafel für Laden, Klassenzimmer oder Zimmertür und ändere den Text per HC-05-Bluetooth vom Handy aus.
• Uhr, Kalender und Temperatur: Zeige abwechselnd Uhrzeit und Datum von der RTC sowie Temperatur und Luftfeuchte von einem DHT11-Sensor.
• Internetuhr und Wetter: Lass mit dem ESP32 die NTP-Zeit und die Temperatur aus einer Wetter-API durchlaufen.
• Anzeigetafel: Steuere eine Anzeige mit zwei Zonen für ein Tischtennis- oder Basketballspiel mit einer IR-Fernbedienung.
• Mini-Spiele: Spiele Snake, Pong oder ein Ausweichspiel auf der 32x8-Anzeige mit einem Joystick; weitere Ideen in Arduino-Spieleprojekte.
• Pegelanzeige: Zeichne die Werte eines Schallsensors als Balkendiagramm mit 32 Spalten.
• 32x32-Animationspanel: Stapele vier 4-in-1-Module übereinander und spiele Animationen wie Regen, Sterne und Feuerwerk ab.

Typische Fehler und ihre Lösung

Der MAX7219 ist einer der günstigsten Wege, mit wenigen Kabeln eine auffällige Anzeige zu bauen: Multiplexen, Strombegrenzung und Helligkeit erledigt der Chip, und du kümmerst dich nur darum, was angezeigt wird. Fang mit Symbolen auf einem einzelnen 8x8-Modul an und geh dann auf dem 4-in-1-Modul zu Lauftext, Uhr und kabellosen Nachrichten mit dem ESP32 über. Wenn du farbige, einzeln steuerbare LEDs möchtest, sind WS2812B-NeoPixel-LEDs eine gute Wahl, für reine Zahlenanzeigen eine 7-Segment-Anzeige. In der BlueGrays-App findest du MAX7219-Projekte wie eine Dot-Matrix-Uhr mit Kalender, eine Wetterstation, 32x8-Animationen und Lauftext Schritt für Schritt mit Schaltplan und Code.