Een 7-segmentdisplay gebruiken: cijfers tonen met Arduino, gemeenschappelijke anode vs kathode
Hoe werkt een 7-segmentdisplay? Segmentletters (a–g, dp), gemeenschappelijke kathode vs anode, pinout en weerstanden, code om van 0–9 te tellen, 4-cijferige displays en multiplexing, de TM1637-module, ESP32 en Pico.
Een 7-segmentdisplay is een eenvoudige indicator van zeven staafvormige leds die als het cijfer "8" zijn gerangschikt, plus een klein puntje. Digitale klokken, magnetrontimers, scoreborden en benzinepompen gebruiken het. Het is goedkoop, erg helder en zelfs van een afstand goed leesbaar. In Arduino-projecten is het een van de klassieke uitgangen voor tellers, dobbelstenen, stopwatches en klokken.

Hoe werkt een 7-segmentdisplay?
De segmenten hebben letternamen: te beginnen met a bovenaan en met de klok mee volgen b (rechtsboven), c (rechtsonder), d (onder), e (linksonder) en f (linksboven); de middelste balk is g en de punt is dp. Elk segment is eigenlijk een aparte led en afhankelijk van welke segmenten branden, ontstaan er verschillende cijfers. Voor "1" lichten bijvoorbeeld alleen b en c op, terwijl bij "8" alle zeven branden.
| Cijfer | Brandende segmenten |
|---|---|
| 0 | a, b, c, d, e, f |
| 1 | b, c |
| 2 | a, b, d, e, g |
| 3 | a, b, c, d, g |
| 4 | b, c, f, g |
| 5 | a, c, d, f, g |
| 6 | a, c, d, e, f, g |
| 7 | a, b, c |
| 8 | a, b, c, d, e, f, g |
| 9 | a, b, c, d, f, g |
Gemeenschappelijke kathode of gemeenschappelijke anode?
Net als bij een RGB-led zit één kant van elk segment aan een gemeenschappelijke pin. Bij een display met gemeenschappelijke kathode gaat de gemeenschappelijke pin naar GND en brandt een segment als je het HIGH geeft. Bij een display met gemeenschappelijke anode gaat de gemeenschappelijke pin naar 5V en brandt een segment als je het LOW geeft. Ze zien er van buiten hetzelfde uit; om te achterhalen welke je hebt, sluit je de gemeenschappelijke pin aan op GND en raak je een segmentpin aan met 5V via een weerstand van 220 Ω. Als het segment brandt, is het een gemeenschappelijke kathode; zo niet, draai dan de aansluiting om en probeer het opnieuw.
| Eigenschap | Gemeenschappelijke kathode (CC) | Gemeenschappelijke anode (CA) |
|---|---|---|
| Gemeenschappelijke pin (3 en 8) | GND | 5V |
| Een segment laten branden | HIGH | LOW |
| In code | digitalWrite(pin, on) | digitalWrite(pin, !on) |
Pinout en Arduino-bedrading
Bij gangbare 10-pins displays met één cijfer zijn de pinnen tegen de klok in genummerd, beginnend linksonder, terwijl de voorkant van het display naar je toe wijst. De twee middelste pinnen (3 en 8) vormen de gemeenschappelijke aansluiting en zijn intern met elkaar verbonden. De onderstaande tabel toont zowel de displaypinnen als de Arduino-pinnen die de code in dit bericht gebruikt:
| Displaypin | Segment | Arduino-pin |
|---|---|---|
| 7 | a | D2 |
| 6 | b | D3 |
| 4 | c | D4 |
| 2 | d | D5 |
| 1 | e | D6 |
| 9 | f | D7 |
| 10 | g | D8 |
| 5 | dp | D9 |
| 3 en 8 | Gemeenschappelijk | GND (gemeenschappelijke kathode) of 5V (gemeenschappelijke anode) |
Tellen van 0 tot 9 met Arduino
Als je in een array als bits opslaat welke segmenten elk cijfer laat branden, blijft de code kort. In het onderstaande voorbeeld is het meest linkse bit van elke byte segment a en het meest rechtse bit segment g. De functie showDigit() leest deze bits één voor één en schrijft ze naar de pinnen; gebruik je een display met gemeenschappelijke anode, zet dan COMMON_ANODE op true.
1const int SEG_PINS[7] = {2, 3, 4, 5, 6, 7, 8}; // a, b, c, d, e, f, g
2const bool COMMON_ANODE = false; // ortak anotsa true / true for common anode
3
4// her rakam için a–g segmentleri (1 = yanar) / a–g segments per digit (1 = on)
5const byte DIGITS[10] = {
6 0b1111110, // 0
7 0b0110000, // 1
8 0b1101101, // 2
9 0b1111001, // 3
10 0b0110011, // 4
11 0b1011011, // 5
12 0b1011111, // 6
13 0b1110000, // 7
14 0b1111111, // 8
15 0b1111011 // 9
16};
17
18void showDigit(int n) {
19 for (int i = 0; i < 7; i++) {
20 bool on = DIGITS[n] & (1 << (6 - i)); // a en soldaki bit / a is the leftmost bit
21 digitalWrite(SEG_PINS[i], COMMON_ANODE ? !on : on);
22 }
23}
24
25void setup() {
26 for (int i = 0; i < 7; i++) pinMode(SEG_PINS[i], OUTPUT);
27}
28
29void loop() {
30 for (int n = 0; n <= 9; n++) {
31 showDigit(n);
32 delay(1000);
33 }
34}4-cijferige displays en multiplexing

Een display met vier cijfers heeft geen 32 aparte segmentpinnen; het heeft slechts 12 pinnen: 8 segmentlijnen (a–g en dp) die door elk cijfer gedeeld worden en 4 pinnen die kiezen welk cijfer oplicht. Omdat de segmentlijnen gedeeld worden, kun je niet op hetzelfde moment verschillende getallen op verschillende cijfers tonen. De oplossing is multiplexing: je laat een paar milliseconden alleen het 1e cijfer branden, dan het 2e, het 3e en het 4e. Wanneer deze cyclus vaker dan 50 keer per seconde wordt herhaald, ziet het oog alle vier de cijfers tegelijk branden. In plaats van deze scan zelf te schrijven, is het veel makkelijker om de bibliotheek SevSeg te gebruiken:
1#include "SevSeg.h"
2
3SevSeg sevseg;
4
5void setup() {
6 byte digitPins[] = {2, 3, 4, 5}; // hane seçme pinleri / digit select pins
7 byte segmentPins[] = {6, 7, 8, 9, 10, 11, 12, 13}; // a, b, c, d, e, f, g, dp
8 sevseg.begin(COMMON_CATHODE, 4, digitPins, segmentPins, true); // dirençler segmentlerde / resistors on segments
9 sevseg.setBrightness(90);
10}
11
12void loop() {
13 sevseg.setNumber(millis() / 1000); // geçen saniye / elapsed seconds
14 sevseg.refreshDisplay(); // sürekli çağrılmalı / must be called continuously
15}De TM1637-module: 4 cijfers met slechts 2 draden

Als 12 draden en constant scannen als veel werk klinken, is de TM1637-module iets voor jou. De driverchip doet de multiplexing zelf; de Arduino geeft alleen via de pinnen CLK en DIO door welk getal getoond moet worden. De meeste uitvoeringen hebben ook een dubbele punt (:) in het midden om klokken te maken. Installeer de bibliotheek TM1637 van Avishay Orpaz via de Library Manager; de onderstaande code toont minuten en seconden met de dubbele punt:
1#include <TM1637Display.h>
2
3TM1637Display display(2, 3); // CLK, DIO
4
5void setup() {
6 display.setBrightness(5); // 0–7
7}
8
9void loop() {
10 int minutes = (millis() / 60000) % 60;
11 int seconds = (millis() / 1000) % 60;
12 // ortadaki iki noktayla dakika:saniye / minutes:seconds with the colon
13 display.showNumberDecEx(minutes * 100 + seconds, 0b01000000, true);
14 delay(200);
15}7-segmentdisplays met de ESP32 en Raspberry Pi Pico
Je kunt een display met één cijfer direct aansluiten op een ESP32 of Pico; omdat de pinnen 3,3 V leveren, branden de segmenten iets zwakker, dus gebruik kleinere weerstanden, zoals 100–150 Ω. De TM1637-module werkt ook op 3,3 V en wordt op de ESP32 met dezelfde Arduino-bibliotheek gebruikt. Op de Pico met MicroPython kopieer je gewoon het bestand tm1637.py (de bibliotheek van mcauser) naar de Pico:
1import tm1637
2from machine import Pin
3import time
4
5tm = tm1637.TM1637(clk=Pin(16), dio=Pin(17)) # tm1637.py Pico'da olmalı / tm1637.py must be on the Pico
6tm.brightness(4) # 0–7
7
8count = 0
9while True:
10 tm.number(count) # -999 … 9999
11 count += 1
12 time.sleep(1)7-segment, LCD of OLED?
| Eigenschap | 7-segment | 16x2 LCD | OLED |
|---|---|---|---|
| Wat het kan tonen | Cijfers en een paar letters | Letters, cijfers, eigen tekens | Tekst, afbeeldingen, pictogrammen |
| Leesbaarheid | Erg helder, van veraf leesbaar | Goed met de achtergrondverlichting | Hoog contrast, maar klein |
| Benodigde pinnen | 8 of meer (2 met een TM1637) | 2 (I2C) | 2 (I2C) |
| Het best voor | Klokken, tellers, scoreborden | Menu's, meettekst | Afbeeldingen, pictogrammen, kleine gadgets |
Als je alleen cijfers hoeft te tonen en leesbaarheid van een afstand telt, is het 7-segmentdisplay ongeslagen. Heb je tekst, eenheden en menu's nodig, kijk dan eens naar Een I2C-lcd-display gebruiken.
Projectideeën met een 7-segmentdisplay
- Elektronische dobbelsteen: toon een willekeurig getal van 1 tot 6 wanneer je op een knop drukt.
- Knopteller: maak een teller die met één knop omhooggaat en met een andere wordt gereset.
- Digitale klok: een klok met een TM1637 en een RTC-module die de tijd ook bij een stroomuitval bijhoudt.
- Aftellen: een instelbare timer voor bordspellen of experimenten.
- Temperatuurdisplay: toon de temperatuur gemeten met een DHT11 in grote cijfers.
- Reactietest: toon in milliseconden hoe snel je op de knop drukt nadat een led oplicht.
Veelgemaakte fouten en hoe je ze oplost
- Er brandt helemaal geen segment: de gemeenschappelijke pin zit op de verkeerde plek; misschien heb je een display met gemeenschappelijke anode op GND aangesloten.
- Cijfers zien er door elkaar uit: de koppeling tussen segmenten en Arduino-pinnen klopt niet; controleer dit door elk segment één voor één te laten branden.
- Sommige cijfers zijn dof: er zit één weerstand op de gemeenschappelijke pin; gebruik voor elk segment een aparte weerstand.
- Bij een 4-cijferig display brandt of flikkert maar één cijfer: er staat een delay() in loop() of het scannen gebeurt niet vaak genoeg.
- De segmenten die aan moeten staan zijn uit en de rest is aan: gemeenschappelijke anode en kathode zijn door elkaar gehaald; wijzig COMMON_ANODE.
- Pinnen tekort: beperk het aantal pinnen met een TM1637-module, een MAX7219-driver of een 74HC595-schuifregister.
Weten dat elk segment eigenlijk een led is, is de sleutel tot het begrijpen van 7-segmentdisplays; voor de basis kijk je eens naar Wat is een led? In de BlueGrays-app vind je projecten voor tellen van 0–9, knopteller, dobbelsteen, 4-cijferige digitale klok en bomanimatie, stap voor stap met schakelschema's en code.
Veelgestelde vragen
Welke weerstand moet ik gebruiken bij een 7-segmentdisplay?
Bij 5 V is 220–330 Ω per segment geschikt; 220 Ω geeft een helderder licht en 330 Ω gebruikt minder stroom. Op boards met 3,3 V, zoals de ESP32 en Pico, kun je 100–150 Ω gebruiken. Plaats de weerstanden afzonderlijk op elke segmentlijn, niet op de gemeenschappelijke pin.
Hoe weet ik of mijn 7-segmentdisplay een gemeenschappelijke anode of kathode heeft?
Sluit de gemeenschappelijke pin (3 of 8) aan op GND en raak een segmentpin aan met 5V via een weerstand van 220 Ω; als het segment brandt, is het een gemeenschappelijke kathode. Zo niet, sluit dan de gemeenschappelijke pin aan op 5V en de segmentpin via de weerstand op GND; brandt het nu wel, dan is het een gemeenschappelijke anode. Het typenummer bevat meestal ook CC of CA.
Hoeveel pinnen heeft een 7-segmentdisplay?
Displays met één cijfer hebben 10 pinnen: 7 segmenten, 1 punt en 2 gemeenschappelijke pinnen. Displays met vier cijfers hebben 12 pinnen: 8 gedeelde segmentlijnen en 4 pinnen om het cijfer te kiezen. Modules zoals de TM1637 worden met slechts 4 pinnen aangesloten (CLK, DIO, VCC, GND).
Waarom brandt er maar één cijfer op mijn 4-cijferige display?
Displays met vier cijfers werken met multiplexing, dus de cijfers moeten steeds achter elkaar worden gescand. Als je delay() in loop() gebruikt, stopt het scannen en blijft alleen het laatste cijfer branden. Gebruik een bibliotheek zoals SevSeg, roep refreshDisplay() voortdurend aan en doe je timing met millis().
Kan een 7-segmentdisplay letters tonen?
Sommige letters wel: A, b, C, d, E, F, H, L, P, U en o kunnen herkenbaar worden getoond. Letters zoals K, M, W en X kunnen met zeven segmenten niet goed worden getekend. Als je tekst moet tonen, past een lcd- of OLED-display beter.
Hoe kan ik een 7-segmentdisplay met minder pinnen aansturen?
De makkelijkste manier is een module met een driverchip: de TM1637 stuurt vier cijfers aan via 2 draden en de MAX7219 stuurt acht cijfers aan via 3. Wil je zelf een schakeling bouwen, dan kun je met een 74HC595-schuifregister 8 segmenten besturen met slechts 3 Arduino-pinnen.
Projecten om hierna te bouwen
Alle projecten bekijken
Cijfers 0-9 tonen op een 7-segmentdisplay
Schrijf zelf die bekende cijfers die je in liften en digitale klokken ziet. Op een display van zeven kleine lichtbalkjes toont de Arduino elke seconde een cijfer van 0 tot 9 en begint daarna opnieuw.

Getallen van 0-99 tonen op een 7-segmentdisplay
Een display met twee cijfers, opgebouwd uit kleine streepjes zoals op een rekenmachine, telt van 0 tot 99.

Teller met 7-segmentdisplay en knoppen
Een eenvoudige teller met drie knoppen: met de ene knop gaat het cijfer op het display er één omhoog, met de andere één omlaag en de derde zet het terug op nul.

Dobbelsteenproject
Nooit meer een zoekgeraakte dobbelsteen bij bordspellen: elke keer dat je op de knop drukt, verschijnt er een willekeurig getal van 1 tot 6 op het 7-segmentdisplay.

0-9999 tonen op een 7-segmentdisplay met 4 cijfers
Op een getaldisplay met vier cijfers razen getallen van 0 tot 9999 voorbij en beginnen dan weer bij nul.

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…

Bomanimatie met 7-segmentdisplay met 4 cijfers
De tikkende bom uit de films, gewoon op je bureau en volkomen ongevaarlijk: het display met 4 cijfers telt af vanaf 1:05, de buzzer piept elke seconde en de rode LED knippert.

ESP32 TM1637 4-cijferig 7-segmentdisplay
We sturen met een ESP32 een 4-cijferige 7-segmentdisplaymodule met TM1637-driver aan. Met slechts 2 GPIO-pins (CLK en DIO) laten we een teller van 0 tot 9999 lopen, stellen we de helderheid in en tonen we de dubbele punt (:) in klokformaat. Dankzij de TM1637Display-bibliotheek is het aansturen van getallen, hexwaarden, segmenten en strings heel eenvoudig.
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

