MAX7219 Arduino-ledmatrix: scrollende tekst met MD_Parola
MAX7219 Arduino-gids: sluit 8x8- en 4-in-1 8x32-ledmatrixmodules aan, scroll tekst met MD_Parola, los gespiegelde tekst op met FC16_HW, plus klok- en ESP32-code.
De MAX7219 is een goedkope driverchip die zelfstandig 64 leds aanstuurt, en het is de makkelijkste manier om een ledmatrix met Arduino te gebruiken. Je vindt hem meestal in twee vormen: een module met één 8x8-dotmatrix en een 4-in-1 8x32-dotmatrixmodule met vier matrices naast elkaar. De MAX7219 heeft maar 3 signaaldraden van de Arduino nodig (DIN, CS, CLK); hij scant de rijen honderden keren per seconde, stelt de helderheid in en onthoudt zelf de status van elke led. Zo blijft de Arduino vrij voor scrollende tekst, klokken, scoreborden of animaties, en je kunt het display zo lang maken als je wilt door modules achter elkaar te koppelen.
In deze gids leer je hoe de MAX7219 werkt, hoe je de module via SPI aansluit op een Arduino Uno, ESP32 en Raspberry Pi Pico, hoe je modules koppelt en hoe je je eerste scrollende tekst toont met de MD_Parola-bibliotheek. Daarna los je het probleem van ondersteboven of gespiegelde tekst op, waar de meeste beginners over struikelen, door het juiste hardwaretype (FC16_HW) te kiezen. Ook bepaal je de helderheid en het stroomverbruik, toon je letters met accenten en eigen tekens en bouw je een klok met een RTC-module en een animatie pixel voor pixel. De laatste delen behandelen berichten versturen vanaf je telefoon met een ESP32, MicroPython-code voor de Pico en oplossingen voor de meest gemaakte fouten.

Wat is de MAX7219 en hoe werkt hij?
Je kunt 64 leds niet op afzonderlijke Arduino-pinnen aansluiten, dus ledmatrices gebruiken multiplexing. In een 8x8-matrix zitten de leds in een raster van 8 rijen en 8 kolommen. Op elk moment activeert de MAX7219 maar één groep leds (een "digit" in de datasheet, bij een matrix een rij of een kolom), stuurt hij de andere lijnen aan om te kiezen welke van de acht leds in die groep oplichten en gaat hij dan door naar de volgende groep. Alle acht groepen worden zo'n 800 keer per seconde gescand; je oog kan die snelheid niet volgen, dus het beeld lijkt stabiel. Ondertussen bewaart de chip het patroon van elke groep in zijn eigen 8x8-bits RAM, begrenst hij de ledstroom met één weerstand en stelt hij de helderheid in 16 stappen in.
De Arduino praat met de MAX7219 via een seriële interface met 3 draden die veel op SPI lijkt. Elk commando is een pakket van 16 bits: de bovenste byte kiest het register waarnaar wordt geschreven en de onderste byte bevat de waarde. Zolang CS (LOAD in de datasheet) LOW is, schuiven er bij elke stijgende flank van CLK bits binnen vanaf DIN; zodra CS weer HIGH wordt, wordt het pakket in het register geschreven. Het is hetzelfde idee als bij het 74HC595-schuifregister, maar omdat de MAX7219 ook het scannen en de stroombegrenzing regelt, is het veel minder werk. Hoe SPI in het algemeen werkt, lees je in Wat is SPI?.
| Eigenschap | Waarde |
|---|---|
| Voedingsspanning | 4,0–5,5 V (in de praktijk 5 V) |
| Interface | Seriëel met 3 draden (DIN, CLK, CS), tot 10 MHz |
| Aangestuurde leds | 64 (een 8x8-matrix of acht 7-segmentcijfers) |
| Scansnelheid | Typisch 800 Hz (8 digits) |
| Segmentstroom | Ingesteld door de RSET-weerstand, max. 40 mA (op modules meestal 10 kΩ) |
| Helderheid | 16 stappen, duty cycle van 1/32 tot 31/32 |
| Stroom in shutdown | Ongeveer 150 µA |
| HIGH-drempel van de ingang | Minimaal 3,5 V (bij een voeding van 5 V) |
| Koppelen (daisy chain) | DOUT-uitgang naar de DIN-ingang van de volgende chip |
De MAX7219 heeft 14 adresseerbare registers, maar degene die je voor een ledmatrix nodig hebt staan in de tabel hieronder. De bibliotheken stellen ze voor je in; toch helpt het enorm om te weten wat ze doen als je gaat debuggen. Wanneer de chip bijvoorbeeld voor het eerst spanning krijgt, start hij in shutdown-modus met een donker display, dus als de initialisatiecode niet draait, lijkt de module helemaal dood. Zijn broertje, de MAX7221, heeft dezelfde registers, maar heeft een echte SPI-compatibele CS-pin en segmentdrivers met beperkte slew rate die elektromagnetische storing verminderen.
| Adres | Register | Doel |
|---|---|---|
| 0x00 | No-Op | Laat deze chip ongewijzigd terwijl een pakket naar een andere chip in de keten gaat |
| 0x01–0x08 | Digit 0–7 | Het 8-bits ledpatroon van elk van de acht rijen (of kolommen) |
| 0x09 | Decode Mode | BCD-decodering voor 7-segmentcijfers; uit (0x00) voor een matrix |
| 0x0A | Intensity | Helderheid, van 0x0 tot 0xF |
| 0x0B | Scan Limit | Aantal te scannen digits; 7 (alle acht) voor een matrix |
| 0x0C | Shutdown | 0: shutdown-modus, 1: normaal bedrijf |
| 0x0F | Display Test | 1: alle leds branden op volle helderheid |
Losse 8x8-module of 4-in-1 8x32-module?
De twee modules die je het vaakst tegenkomt gebruiken dezelfde schakeling; het verschil zit in hoe de ledmatrix op de MAX7219 is aangesloten en in de vorm van de printplaat. De losse module op een groene print heeft een MAX7219 in DIP-behuizing (24 pinnen) en een 8x8-matrix zoals de 1088AS, met ingangspinnen (VCC, GND, DIN, CS, CLK) aan de ene kant en uitgangspinnen (VCC, GND, DOUT, CS, CLK) aan de andere. Op de blauwe 4-in-1-module zitten vier SMD-MAX7219-chips onder de matrices en de vier blokken zijn in de fabriek al aan elkaar gekoppeld; de print is meestal gemarkeerd met FC-16. Voor lange scrollende tekst is de 4-in-1-module zowel goedkoper als netter.

| Eigenschap | Losse 8x8-module | 4-in-1 8x32-module (FC-16) |
|---|---|---|
| Resolutie | 8x8 = 64 leds | 32x8 = 256 leds |
| Aantal MAX7219's | 1 (DIP-behuizing) | 4 (SMD-behuizing) |
| Hardwaretype in code | Meestal GENERIC_HW | Meestal FC16_HW |
| Tekens tegelijk zichtbaar | 1 | 4–6 (afhankelijk van de letterbreedte) |
| Maximale stroom bij volle helderheid | Ongeveer 330 mA | Ongeveer 1,3 A |
| Het best voor | Pictogrammen, dobbelstenen, smileys, kleine spelletjes | Scrollende tekst, klokken, scoreborden |
MAX7219-bedrading: Arduino Uno, ESP32 en Pico
De module heeft vijf pinnen: VCC en GND voor de voeding, DIN voor data, CLK voor de klok en CS voor chip select (load). Standaard gebruiken de bibliotheken MD_Parola en MD_MAX72XX hardware-SPI, dus DIN moet naar de MOSI-pin van je board en CLK naar de SCK-pin, terwijl CS elke digitale pin kan zijn. Met de tool Pinout kun je nagaan waar de hardware-SPI-pinnen op jouw board zitten. Steek de draden altijd in de ingangszijde (IN) van de module, het uiteinde met DIN; het uiteinde met DOUT is voor de volgende module.
| Modulepin | Arduino Uno | ESP32 | Raspberry Pi Pico |
|---|---|---|---|
| VCC | 5V | 5V (VIN) | VBUS (5 V) |
| GND | GND | GND | GND |
| DIN | D11 (MOSI) | GPIO 23 (MOSI) | GP19 (SPI0 TX) |
| CS | D10 | GPIO 5 | GP17 |
| CLK | D13 (SCK) | GPIO 18 (SCK) | GP18 (SPI0 SCK) |
De ESP32 en Pico werken met 3,3V-logica, terwijl de datasheet van de MAX7219 bij een voeding van 5 V minimaal 3,5 V als HIGH-niveau vraagt. Signalen van 3,3 V zitten dus technisch net onder de grens. De meeste modules werken toch, maar bij lange draden of bepaalde chipseries kun je willekeurige puntjes en verstoorde beelden zien. De betrouwbare oplossing is een buffer zoals de 74HCT125, die 3,3 V als HIGH accepteert en 5 V uitstuurt, of een snelle niveauconverter op de lijnen DIN, CLK en CS. Signaaldraden korter dan 20 cm houden lost het probleem ook vaak op.
Modules koppelen (daisy chain)
De DOUT-pin van de MAX7219 geeft de data die op DIN binnenkwam 16,5 klokcycli later weer door. Als je de OUT-zijde van de ene module met de IN-zijde van de volgende verbindt, gaat DOUT naar de DIN van de volgende chip, terwijl CLK en CS door alle chips worden gedeeld. Zo gaan er nog steeds maar 3 signaaldraden de Arduino uit, maar kan het display 8, 16 of 32 blokken lang zijn. Bij elke update stuurt de bibliotheek pakketten door de hele keten, en wanneer CS stijgt, werken ze allemaal op hetzelfde moment bij. Op 4-in-1-modules zit deze bedrading al op de print; voor een display van 8 blokken (64x8) met twee 4-in-1-modules verbind je simpelweg de OUT-pinnen van de eerste module met de IN-pinnen van de tweede en stel je MAX_DEVICES in je code in op 8.
In de bibliotheek beginnen de bloknummers bij de module die het dichtst bij de DIN-ingang zit en lopen ze op naar links; bij MD_MAX72XX ligt de oorsprong in de rechterbovenhoek van het display. Daarom moet de DIN-ingang aan de rechterkant blijven, zodat de tekst goed leesbaar is. Naarmate de keten groeit, wordt de voeding de echte beperking: voed 5 V en GND elke 4–8 blokken terug in de keten met dikke draden en plaats bij de voedingsingang van elke module een elco van 10 µF en een keramische condensator van 100 nF. De datasheet raadt dit paar ook aan, om de rimpel door de stroompulsen van de leds glad te strijken.
De bibliotheken installeren: MD_MAX72XX en MD_Parola
De twee populairste MAX7219-bibliotheken komen van dezelfde auteur (majicDesigns) en werken samen. MD_MAX72XX doet het laagniveauwerk: hij initialiseert de modules, schrijft pixels en kolommen en beheert het lettertype. MD_Parola bouwt daarop voort met scrollende tekst, effecten, uitlijning en zones. De LedControl-bibliotheek uit oudere voorbeelden werkt ook, maar dan moet je het scrollen zelf schrijven. Als je nog nooit een bibliotheek hebt geïnstalleerd, lees dan eerst Een bibliotheek toevoegen in Arduino.
- Open in de Arduino IDE de Library Manager (Tools > Manage Libraries) en zoek naar MD_Parola.
- Installeer de MD_Parola-bibliotheek van majicDesigns. Kies bij de vraag over afhankelijkheden voor Install all, zodat MD_MAX72XX ook wordt geïnstalleerd.
- Sluit de module aan zoals in de tabel hierboven en stel bij een 4-in-1-module in je code HARDWARE_TYPE in op FC16_HW en MAX_DEVICES op 4.
- Upload de sketch. Als de tekst ondersteboven, gespiegeld of gedraaid is, geen zorgen; je lost dat op met één regel in het deel over het hardwaretype hieronder.
Eerste programma: scrollende tekst met 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}De belangrijkste regel is displayText(): die neemt in deze volgorde de tekst, de uitlijning (PA_LEFT, PA_CENTER, PA_RIGHT), de tijd tussen frames in milliseconden, de pauze nadat de tekst tot rust is gekomen en de in- en uitgangseffecten. Hoe kleiner de snelheidswaarde, hoe sneller de tekst beweegt; 25–60 ms geeft leesbaar scrollen. displayAnimate() zet elke keer dat hij wordt aangeroepen hooguit één frame vooruit en keert meteen terug. Daarom moet hij voortdurend in loop() worden aangeroepen en moet je geen delay() gebruiken in de rest van je code; anders stottert de tekst. Hoe je kunt wachten zonder het programma te blokkeren, lees je in millis() vs delay().
| Functie | Wat hij doet |
|---|---|
| begin() | Initialiseert de modules, haalt ze uit shutdown en wist het display |
| displayText(text, align, speed, pause, effectIn, effectOut) | Stelt de te tonen tekst en effecten in en start de animatie |
| displayAnimate() | Tekent het volgende frame; geeft true terug wanneer het effect klaar is |
| displayReset() | Speelt dezelfde tekst en hetzelfde effect opnieuw af vanaf het begin |
| print("...") | Toont statische tekst zonder effect |
| setIntensity(0–15) | Stelt de helderheid van alle modules in |
| setInvert(true) | Wisselt brandende en dode leds om (negatief beeld) |
| displayShutdown(true) | Zet het display in shutdown-modus; false maakt het weer wakker |
| begin(2) en setZone(0, 0, 1) | Verdeelt het display in onafhankelijke zones, elk met eigen tekst en effect |
Naast PA_SCROLL_LEFT zijn er veel in- en uitgangseffecten: PA_PRINT (tekst verschijnt in één keer), PA_SCROLL_UP en PA_SCROLL_DOWN (verticaal scrollen), PA_WIPE, PA_OPENING en PA_CLOSING (openen vanuit en sluiten naar het midden), PA_FADE (vervagen via de helderheid), PA_DISSOLVE, PA_BLINDS, PA_RANDOM en PA_GROW_UP. Om ze allemaal te zien upload je de sketch Parola_Animation_Catalog via File > Examples > MD_Parola; vergeet niet de regels HARDWARE_TYPE en MAX_DEVICES aan te passen aan jouw module.
Het hardwaretype kiezen (FC16_HW) en gespiegelde tekst oplossen
Fabrikanten sluiten de 8x8-matrix op verschillende manieren aan op de MAX7219: op sommige printen gaan de "digit"-lijnen van de chip naar de rijen, op andere naar de kolommen, en de volgorde van rijen of kolommen kan omgekeerd zijn. De bibliotheek corrigeert dit met de instelling HARDWARE_TYPE. Kies je het verkeerde type, dan is de module niet defect, maar zien de letters in elk 8x8-blok er gespiegeld, ondersteboven of 90 graden gedraaid uit. Omdat veel oudere code online PAROLA_HW of GENERIC_HW gebruikt, is dit het meest voorkomende probleem bij de blauwe 4-in-1-modules die nu worden verkocht. De tabel hieronder laat zien wat je per symptoom moet veranderen; hij is gebaseerd op de 4-in-1 FC-16-module.
| Wat je ziet | Waarschijnlijke oorzaak | Oplossing |
|---|---|---|
| Letters zijn in elk blok van links naar rechts gespiegeld | PAROLA_HW gekozen, kolomvolgorde omgekeerd | Gebruik FC16_HW |
| Letters zijn in elk blok 90 graden gedraaid | GENERIC_HW gekozen, rijen en kolommen verwisseld | Gebruik FC16_HW |
| Letters staan in elk blok ondersteboven | ICSTATION_HW gekozen, rij- en kolomvolgorde omgekeerd | Gebruik FC16_HW |
| De hele tekst staat ondersteboven en scrolt van links naar rechts | De module zit verkeerd om, DIN-ingang links | Draai de module 180 graden, zodat de DIN-ingang rechts zit |
| Slechts enkele blokken zijn goed, de rest is leeg of door elkaar | MAX_DEVICES komt niet overeen met het werkelijke aantal blokken | Stel MAX_DEVICES in op het aantal blokken |
Helderheid en stroomverbruik
De helderheid hangt van twee dingen af. Het eerste is de RSET-weerstand op de module: de chip stuurt ongeveer 100 keer de stroom die uit de ISET-pin vloeit naar de leds. Modules gebruiken meestal 10 kΩ, wat neerkomt op een piekstroom van iets boven 40 mA voor rode leds en ongeveer 40 mA voor blauwe en witte. Het tweede is het register Intensity dat je in software instelt: een waarde n van 0 tot 15 houdt de leds aan gedurende (2n+1)/32 van elk scaninterval, dus 0 is de laagste (1/32) en 15 de hoogste (31/32) helderheid. En omdat elke rij maar een achtste van de tijd brandt, haalt een enkele led zelfs bij volle helderheid gemiddeld zo'n 5 mA. De doorlaatspanningen per ledkleur vind je in de tool Led-spanningen.
Je kunt de gemiddelde stroom van een module grofweg zo schatten: I ≈ 8 mA + 5 mA × (2n+1)/32 × L. Hierbij is 8 mA het eigen verbruik van de chip, n de helderheidswaarde en L het aantal brandende leds op die module (0–64); 5 mA is een achtste van de piekstroom van 40 mA. Bij helderheid 15 met alle 64 leds aan krijg je bijvoorbeeld 8 + 5 × 0,97 × 64 ≈ 318 mA, wat overeenkomt met de 330 mA uit de datasheet. Scrollende tekst laat meestal maar 25–35 procent van de leds branden, dus het werkelijke verbruik ligt veel lager. De tabel hieronder toont typische waarden voor een 4-in-1-module.
| Situatie | Per module | 4-in-1-module (32x8) |
|---|---|---|
| Alle leds aan, helderheid 15 | ≈ 320 mA | ≈ 1,3 A |
| Alle leds aan, helderheid 7 | ≈ 160 mA | ≈ 630 mA |
| Scrollende tekst (~30% van de leds), helderheid 7 | ≈ 55 mA | ≈ 210 mA |
| Scrollende tekst (~30% van de leds), helderheid 2 | ≈ 25 mA | ≈ 90 mA |
| Shutdown-modus (displayShutdown) | ≈ 0,15 mA | ≈ 0,6 mA |
Om het display 's nachts te dimmen kun je de helderheid automatisch regelen met een LDR-lichtsensor en het display in slaapstand zetten met displayShutdown(true) als er niemand in de buurt is. Ontwerp je een bord op batterijen, voer dan de waarden hierboven in de tool Batterijduur in om uit te rekenen hoeveel uur het meegaat. Binnen is een helderheid van ongeveer 2–4 in plaats van 15 meestal genoeg; dat is prettiger voor je ogen en verlaagt de ledstroom tot grofweg een derde tot een zesde.
Letters met accenten en speciale tekens (UTF-8)
De Arduino IDE slaat je code op als UTF-8, dus een letter als "é" of "ü" is in de tekst geen één byte maar twee. MD_Parola zoekt elke byte op als tekennummer in het lettertype, waardoor letters met accenten betekenisloze symbolen worden. Het standaardlettertype van de bibliotheek bevat de volledige Latin-1-set (é, è, à, ñ, ç, ä, ö, ü, ß en meer), dus je hebt alleen een kleine functie nodig die UTF-8 omzet in de codes van het lettertype. Letters buiten Latin-1, zoals de Turkse ğ, ı en ş in het voorbeeld hieronder, moet je pixel voor pixel tekenen en toevoegen met addChar(). De sketch doet beide stappen.
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 elke array met een eigen teken is de eerste byte de breedte van de letter in kolommen en zijn de volgende bytes de kolommen van links naar rechts; bit 0 van elke byte is de bovenste rij. De puntloze ı is bijvoorbeeld één kolom, en de waarde 124 (0b01111100) laat rij 2 tot en met 6 branden; het enige verschil met een gewone i is de ontbrekende punt erboven. Bij de hoofdletters Ğ en İ is het lijf van de letter twee rijen korter gemaakt (5 rijen in plaats van 7) om ruimte te maken voor het accent. addChar() kopieert de data niet, maar slaat alleen het adres op, dus de arrays moeten globaal zijn en na begin() worden toegevoegd. De codes 0x80–0x85 zijn gekozen omdat ze nooit in gewone tekst voorkomen. Op dezelfde manier kun je elk symbool toevoegen dat je wilt, zoals een gradenteken, een pijl of een hart.
Klokvoorbeeld: een digitale klok met een RTC-module

De millis()-teller van de Arduino wordt gereset als de spanning wegvalt en door het keramische resonatortje van de Uno kan hij tot enkele minuten per dag afwijken. Gebruik voor een echte klok een RTC-klokmodule. Sluit de DS1307-module aan op de I2C-bus (SDA → A4, SCL → A5, VCC → 5V, GND → GND); de MAX7219 gebruikt de SPI-pinnen, dus de twee modules komen elkaar niet in de weg. Installeer voor de code de bibliotheek RTClib van Adafruit via de Library Manager.
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}De sketch leest één keer per seconde de tijd uit en laat de dubbele punt aan en uit knipperen. In het standaardlettertype zijn de dubbele punt (:) en de spatie even breed (2 kolommen), zodat de cijfers niet heen en weer springen. Wanneer de RTC voor het eerst draait, wordt hij ingesteld op het moment waarop de sketch is gecompileerd. Een DS1307 kan ongeveer een minuut per maand afwijken; voor een nauwkeurigere klok neem je een DS3231-module, gebruik je RTC_DS3231 in plaats van RTC_DS1307 en verander je de voorwaarde if (!rtc.isrunning()) in if (rtc.lostPower()). Dankzij zijn temperatuurgecompenseerde kristal wijkt de DS3231 maar ongeveer een minuut per jaar af. Je kunt het display ook in twee zones verdelen om aan de ene kant de tijd en aan de andere kant de temperatuur te tonen.
Animatie: pixel voor pixel tekenen met MD_MAX72XX
Om verder te gaan dan scrollende tekst, kun je de bibliotheek MD_MAX72XX rechtstreeks gebruiken. Die behandelt de hele keten als één pixeldisplay: een 4-in-1-module heeft 32 kolommen en 8 rijen. setPoint(row, column, state) zet één led aan of uit, setColumn() schrijft alle 8 bits van een kolom in één keer en clear() maakt het display leeg. De oorsprong (0, 0) is de rechterbovenhoek; kolomnummers lopen op naar links en rijnummers lopen op naar beneden. De code hieronder tekent een bal die stuitert tegen de randen van het display:
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 elk frame wordt eerst het automatisch bijwerken (UPDATE) uitgezet, de oude pixel gewist en de nieuwe getekend, waarna UPDATE weer wordt aangezet zodat de wijzigingen in één keer naar de modules gaan. Zo voorkom je dat een half getekend frame op het display verschijnt. Met dezelfde aanpak kun je dobbelstenen, smileys, een slangenspel of audioniveaubalken tekenen. Bij de voorbeelden van MD_MAX72XX zitten ook kant-en-klare animaties zoals Pac-Man, robotogen en een zandloper. Als je MD_Parola gebruikt, kun je dezelfde tekenfuncties bereiken via getGraphicObject().
Berichten via internet met een ESP32: scrollende tekst vanaf je telefoon
Met een ESP32 kun je je scrollende bord draadloos maken. De code hieronder maakt verbinding met je thuisnetwerk, scrolt eerst zijn eigen IP-adres over het display en toont daarna de tijd die hij van internet (NTP) krijgt. Open dat IP-adres in de browser van een telefoon op hetzelfde wifinetwerk en je ziet een tekstvak; het bericht dat je intypt begint in de volgende ronde te scrollen en wisselt af met de klok. De module verbindt met de VSPI-pinnen zoals in de tabel: CLK naar GPIO 18, DIN naar GPIO 23 en CS naar GPIO 5. Ben je nieuw met de ESP32, lees dan eerst Wat is de 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() stuurt het bericht uit het formulier niet direct naar het display; hij zet het in nextMessage in de wacht. Het bericht wordt pas gekopieerd wanneer de huidige animatie klaar is (wanneer displayAnimate() true teruggeeft), zodat de tekst die MD_Parola leest nooit halverwege verandert. De waarde 3 × 3600 in configTime() is de tijdzone UTC+3 die in Turkije wordt gebruikt; vervang die regel voor het Verenigd Koninkrijk door configTzTime("GMT0BST,M3.5.0/1,M10.5.0", "pool.ntp.org"), die ook zomertijd afhandelt. Voeg voor berichten met accenten de addChar()-regels en de functie utf8ToFont() van hierboven toe aan deze sketch en vervang de regel met strlcpy() door utf8ToFont(nextMessage, message, sizeof(message)). Voor internettijd en realtime webdashboards zie je ESP32 NTP-klok en ESP32-webserver en WebSocket.
MAX7219 met de Raspberry Pi Pico en MicroPython
Op de Pico met MicroPython is de handigste aanpak om het opensource-stuurprogramma max7219.py (micropython-max7219) met Thonny naar de Pico te kopiëren. Omdat het stuurprogramma de framebuf-module van MicroPython gebruikt, zijn tekenfuncties zoals text(), pixel(), line() en rect() kant-en-klaar beschikbaar en draait het in de juiste oriëntatie op 4-in-1 FC-16-modules. Voed de module via VBUS (5 V) en verbind DIN met GP19, CLK met GP18 en CS met GP17. MicroPython claimt ook de MISO-pin van SPI0 (GP16), dus gebruik die pin nergens anders voor. Het lettertype van framebuf is 8x8 pixels en alleen ASCII, dus een 4-in-1-module toont 4 letters tegelijk en letters met accenten worden niet weergegeven. Voor de installatie zie je Wat is de Raspberry Pi Pico? en MicroPython-basis.
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)Projectideeën met de MAX7219
- Scrollend berichtenbord: bouw een berichtenbord voor een winkel, klaslokaal of slaapkamerdeur en verander het bericht vanaf je telefoon met een HC-05 Bluetooth-module.
- Klok, kalender en temperatuur: toon om beurten de tijd en datum van een RTC en de temperatuur en luchtvochtigheid van een DHT11-sensor.
- Internetklok en weer: scroll de NTP-tijd en de temperatuur uit een weer-API met een ESP32.
- Scorebord: maak een display met twee zones voor een tafeltennis- of basketbalwedstrijd, bediend met een IR-afstandsbediening.
- Minispelletjes: speel Snake, Pong of een obstakelspel op het 32x8-display met een joystick; meer ideeën in Arduino-gameprojecten.
- Audioniveaumeter: teken de metingen van een geluidssensor als staafdiagram van 32 kolommen.
- 32x32-animatiepaneel: stapel vier 4-in-1-modules op elkaar en speel animaties af zoals regen, sterren en vuurwerk.
Veelgemaakte fouten en hoe je ze oplost
| Symptoom | Waarschijnlijke oorzaak | Oplossing |
|---|---|---|
| Geen enkele led brandt | Geen voeding, de draden zitten op de OUT-zijde van de module of de CS-pin komt niet overeen met de code | Steek de draden in de IN-zijde met DIN en controleer CS_PIN en de 5V-voeding |
| Alle leds branden volledig en veranderen nooit | Er komt geen data aan: DIN en CLK zijn verwisseld of de chip zit vast in testmodus | Verbind DIN met MOSI en CLK met SCK en haal de module daarna even van de voeding |
| Letters zijn gespiegeld, ondersteboven of 90 graden gedraaid | Verkeerd HARDWARE_TYPE | Probeer FC16_HW op een 4-in-1-module en GENERIC_HW op een losse module |
| De hele tekst staat ondersteboven en scrolt van links naar rechts | De module zit verkeerd om gemonteerd, DIN-ingang links | Draai de module 180 graden; de DIN-ingang moet rechts zitten |
| Slechts één blok werkt of de tekst lijkt afgekapt | Verkeerde MAX_DEVICES of een verbroken verbinding tussen modules | Stel MAX_DEVICES in op het aantal blokken en controleer de OUT → IN-draden |
| De Arduino reset of het beeld flikkert bij hogere helderheid | De USB-limiet van 500 mA wordt overschreden en de spanning zakt in | Gebruik een externe 5V-2A-adapter, verbind de massa's en verlaag de helderheid |
| Willekeurige puntjes en verstoorde tekens op een ESP32 | Het 3,3V-signaal ligt onder de HIGH-drempel van 3,5 V en de draden zijn lang | Verhoog het niveau met een 74HCT125 en maak de draden korter |
| Letters met accenten verschijnen als betekenisloze symbolen | De UTF-8-bytes gaan rechtstreeks naar het lettertype | Gebruik de aanpak met utf8ToFont() en addChar() |
| De scrollende tekst stottert en schokt | Er staat een delay() of een lange taak in loop() | Roep displayAnimate() vaak aan en handel wachttijden af met millis() |
De MAX7219 is een van de goedkoopste manieren om met maar een paar draden een opvallend display te krijgen: de chip regelt het scannen, de stroombegrenzing en de helderheid, zodat jij je kunt richten op wat je wilt tonen. Begin met pictogrammen tekenen op een losse 8x8-module en ga daarna verder met scrollende tekst, een klok en draadloze berichten met een ESP32 op een 4-in-1-module. Wil je kleurrijke, afzonderlijk aanstuurbare leds, dan zijn WS2812B NeoPixel-leds een goede keuze, en voor een project dat alleen cijfers toont een 7-segmentdisplay. In de BlueGrays-app vind je MAX7219-projecten zoals een dotmatrixklok met kalender, een weerstation, 32x8-animaties en scrollende tekst, stap voor stap met schakelschema's en code.
Veelgestelde vragen
Waarom staat de tekst op mijn MAX7219-module ondersteboven of gespiegeld?
Fabrikanten sluiten de 8x8-matrix op verschillende manieren aan op de MAX7219 en de bibliotheek corrigeert dat met de instelling HARDWARE_TYPE. De meeste blauwe 4-in-1-modules die nu worden verkocht tonen goed met FC16_HW en losse groene modules met GENERIC_HW. Is het beeld nog steeds fout, probeer dan ook PAROLA_HW en ICSTATION_HW; er verandert maar één regel code.
Hoeveel MAX7219-modules kun je aan elkaar koppelen?
De chip zelf kent geen limiet en omdat MD_MAX72XX het aantal modules in een byte opslaat, staat de software er tot 255 toe. In de praktijk bepalen de voeding en de signaalkwaliteit de grens: voed 5 V en GND elke 4–8 blokken terug in de keten, houd de draden kort en voeg bij elke module een condensator van 10 µF en een van 100 nF toe. Hoe langer de keten, hoe langer elke update duurt en hoe meer RAM hij gebruikt.
Werkt de MAX7219 met een ESP32 op 3,3 V?
De MAX7219 heeft minimaal een voeding van 4 V nodig, dus voed de module via de 5V-pin (VIN) van de ESP32. De datasheet vraagt bij een voeding van 5 V 3,5 V als HIGH-niveau; de 3,3V-signalen van de ESP32 werken op de meeste modules nog steeds, maar liggen onder die grens. Plaats voor een betrouwbare werking een niveauconverter zoals een 74HCT125 op de lijnen DIN, CLK en CS.
Hoeveel stroom trekt een MAX7219-ledmatrix?
Een losse 8x8-module met alle leds aan op volle helderheid trekt ongeveer 330 mA en een 4-in-1 8x32-module tot 1,3 A. Bij scrollende tekst brandt maar een deel van de leds en wordt de helderheid meestal tussen 2 en 7 gehouden, dus een 4-in-1-module trekt doorgaans zo'n 100–250 mA. In shutdown-modus gebruikt elke chip maar ongeveer 150 µA.
Hoe toon ik letters met accenten of speciale tekens op een MAX7219?
Het standaardlettertype van MD_Parola bevat de Latin-1-tekens zoals é, ñ, ä, ö, ü en ß, maar de Arduino IDE slaat ze op als twee UTF-8-bytes. Zet de tekst met een kleine functie om in de codes van het lettertype voordat je hem toont. Tekens buiten Latin-1 kun je zelf tekenen en toevoegen met addChar().
Kan een MAX7219 een 7-segmentdisplay aansturen?
Ja. De MAX7219 is eigenlijk ontworpen voor 7-segmentdisplays met gemeenschappelijke kathode met maximaal 8 cijfers en heeft een BCD-modus die de cijfers zelf decodeert. Je kunt makkelijk kant-en-klare MAX7219-displaymodules met 8 cijfers gebruiken met de functie setDigit() van de LedControl-bibliotheek. Displays met gemeenschappelijke anode kun je niet rechtstreeks op deze chip aansluiten.
Projecten om hierna te bouwen
Alle projecten bekijken
Dotmatrix-klok en -kalender (MAX7219, DS1307)
Een oplichtend bord voor op je bureau of aan de muur dat de tijd en de datum toont in scrollende tekst.

Dotmatrixklok, kalender en weerstation (MAX7219, DS1307)
Een scrollend tekstbord voor op je bureau of aan de muur dat om de beurt de tijd, de datum en het weer in de kamer toont.

4x 32x8-matrix ledanimatie en tekst
Stapel vier lange ledmatrixmodules op elkaar en je krijgt een vierkant scherm met meer dan duizend lichtpunten. Eerst regenen er letters van boven naar beneden, zoals in de film.

4x 32x8 ledmatrix - pakket met 6 animaties
Vier 32x8-ledpanelen boven elkaar vormen een vierkant scherm waarop zes animaties na elkaar worden afgespeeld: vallende digitale regen, een groeiende spiraal, cellen die helemaal zelf ontstaan en…

Pixelslang 8x8-matrix
Bouw het klassieke slangenspel zelf en speel het. Op een kleurrijke 8x8-lichtmatrix stuur je met een joystick een groene slang en eet je rode appels.

Echte tijd van internet met ESP32 en NTP
De ESP32 verbindt met Wi-Fi en haalt met milliseconde-precisie de echte tijd op bij NTP-servers (Network Time Protocol). configTzTime() past de Turkse tijdzone (TRT, UTC+3) automatisch toe, en in landen met zomertijd wordt de overgang naar zomertijd (DST) geregeld met een POSIX TZ-string. De tijd wordt zowel naar de Serial Monitor als naar een optioneel I2C-lcd gestuurd.

Digitale klok met ESP32 en DS1307-RTC (I2C + LCD)
In dit project tonen we de tijd en de datum op een 16x2 I2C-LCD met de DS1307 realtimeklok-module (RTC). De DS1307 is een RTC met batterijback-up die de tijd bijhoudt, ook als de ESP32 uit staat. Beide modules delen dezelfde I2C-bus (SDA/SCL), zodat je leert hoe je met slechts twee signaaldraden meerdere apparaten bestuurt. Met dit project krijg je praktische kennis van het I2C-communicatieprotocol, de werking van RTC-modules en het dynamisch tonen van gegevens op een LCD.

Digitale klok met 7-segmentdisplay met 4 cijfers
Een lichtgevende digitale klok met vier cijfers, zoals op een keukenoven. De DS1302-klokmodule houdt de tijd bij en de Arduino leest elke seconde uren en minuten uit en toont ze op het display met…
Meer artikelen
BlueGrays-app
Bouw deze schakeling stap voor stap op je telefoon
Schakelschema, code en onderdelenlijst op één scherm. Meer dan 500 Arduino-, ESP32- en Pico-projecten om te bouwen.
Scan met je telefoon
Richt je camera op de code en de appstore van je telefoon opent.
of open de store

