Am ESP32 ist ein OLED-Display per I2C schnell angeschlossen und mit wenig Code einsatzbereit. Trotzdem ist eine 7-Segmentanzeige in vielen Projekten genau die richtige Wahl – vor allem dann, wenn es um Zahlen, Zählerstände oder einfache Statusanzeigen geht. Sie ist sofort ablesbar, kommt ohne Menüs aus und konzentriert sich auf das Wesentliche.
In diesem Beitrag zeige ich, wie eine 7-Segmentanzeige am ESP32 funktioniert und wie sich Zahlen sauber programmieren lassen.
Ein ähnliches Prinzip habe ich bereits am Arduino gezeigt. Im Beitrag Arduino Lektion 62: 7 Segmentanzeige wird die 7-Segmentanzeige ausführlich erklärt und programmiert. Der dort gezeigte Code lässt sich grundsätzlich auch auf den ESP32 übertragen, da sich die Logik zur Ansteuerung nicht unterscheidet. Mit diesem Artikel reiche ich den bisher fehlenden, passenden Beitrag speziell für den ESP32 nach und gehe dabei gezielt auf dessen Einsatz ein.
Aufbau einer 7-Segmentanzeige
7-Segmentanzeigen gibt es in unterschiedlichen Ausführungen. Neben der einfachen Variante mit einer einzelnen Ziffer, wie ich sie in diesem Beitrag verwende, sind auch vierstellige Anzeigen weit verbreitet. Zusätzlich existieren fertige Module auf einer Platine, die über eine I2C-Schnittstelle verfügen. Diese vereinfachen sowohl den Anschluss als auch die Programmierung, da nur wenige Leitungen benötigt werden.
Unabhängig von der Bauform gibt es 7-Segmentanzeigen in zwei elektrischen Varianten: gemeinsame Kathode und gemeinsame Anode. Dieser Unterschied ist besonders wichtig beim Aufbau der Schaltung, da er bestimmt, ob ein Segment durch HIGH oder LOW aktiviert wird.
Welche Variante vorliegt, lässt sich in der Regel über die Typnummer auf der Anzeige ermitteln. Mithilfe dieser Kennzeichnung kann das passende Datenblatt im Internet gefunden werden. In meinem Fall handelt es sich um eine 7-Segmentanzeige vom Typ 5101AS, die über eine gemeinsame Kathode verfügt – die Segmente besitzen also einen gemeinsamen Minuspol.
Schaltung der 7-Segmentanzeige am ESP32
Für dieses Beispiel verwende ich eine 7-Segmentanzeige mit gemeinsamer Kathode. Die einzelnen Segmente A bis G (sowie optional DP) sind jeweils mit einem eigenen GPIO-Pin des ESP32 verbunden.
Der gemeinsame Anschluss der Segmentanzeige ist in meinem Aufbau über einen Vorwiderstand mit GND verbunden, was für diese Anwendung eine ausreichende Helligkeit liefert.
Wird ein GPIO-Pin auf HIGH gesetzt, leuchtet das zugehörige Segment. Auf diese Weise lassen sich die einzelnen Segmente gezielt ansteuern und zu Ziffern zusammensetzen.
Für die Schaltung benötige ich:
- einen ESP32 zbsp. den Wemos D1 R32,
- ein Micro-USB Datenkabel,
- diverse Breadboardkabel, männlich-männlich, 10cm,
- zwei 220 Ohm Widerstand,
- ein 400 Pin Breadboard
Hinweis von mir: Die mit einem Sternchen (*) markierten Links sind Affiliate-Links. Wenn du über diese Links einkaufst, erhalte ich eine kleine Provision, die dazu beiträgt, diesen Blog zu unterstützen. Der Preis für dich bleibt dabei unverändert. Vielen Dank für deine Unterstützung!
Zahlen mit einer 7-Segmentanzeige am ESP32 programmieren
Im folgenden Beispiel wird gezeigt, wie sich eine 7-Segmentanzeige am ESP32 ohne zusätzliche Libraries ansteuern lässt. Die Idee dahinter ist einfach: Für jede Ziffer wird festgelegt, welche Segmente aktiv sein müssen, und diese Information wird in einer übersichtlichen Tabelle abgelegt. Der ESP32 setzt diese Vorgaben anschließend direkt auf die entsprechenden GPIO-Pins um.
Der Quellcode ist bewusst kompakt gehalten und soll vor allem das Grundprinzip der Segmentansteuerung verdeutlichen. Auf dieser Basis lassen sich später problemlos Erweiterungen wie der Dezimalpunkt, weitere Ziffern oder mehrstellige Anzeigen realisieren.
// GPIO-Pins des ESP32 für die einzelnen Segmente
// Benennung entspricht der Beschriftung auf der 7-Segmentanzeige
#define a 16
#define b 27
#define c 5
#define d 13
#define e 12
#define f 17
#define g 25
#define dp 23
// Anzahl der Segmente (a–g + Dezimalpunkt)
const int NUM_SEGMENTS = 8;
// Array mit allen Segment-Pins in fester Reihenfolge
// Reihenfolge ist wichtig, da sie später mit der DIGITS-Tabelle übereinstimmen muss
constexpr uint8_t SEGMENT_DISPLAY[NUM_SEGMENTS] = { a, b, c, d, e, f, g, dp };
// Segment-Matrix für die Ziffern 0–9
// true (1) = Segment an
// false (0) = Segment aus
constexpr bool DIGITS[10][8] = {
// a, b, c, d, e, f, g, dp
{ 1, 1, 1, 1, 1, 1, 0, 0 }, // 0
{ 0, 1, 1, 0, 0, 0, 0, 0 }, // 1
{ 1, 1, 0, 1, 1, 0, 1, 0 }, // 2
{ 1, 1, 1, 1, 0, 0, 1, 0 }, // 3
{ 0, 1, 1, 0, 0, 1, 1, 0 }, // 4
{ 1, 0, 1, 1, 0, 1, 1, 0 }, // 5
{ 1, 0, 1, 1, 1, 1, 1, 1 }, // 6 (dp aktiv)
{ 1, 1, 1, 0, 0, 0, 0, 0 }, // 7
{ 1, 1, 1, 1, 1, 1, 1, 0 }, // 8
{ 1, 1, 1, 1, 0, 1, 1, 0 }, // 9
};
void setup() {
Serial.begin(9600);
// Alle Segment-Pins als Ausgang konfigurieren
for (int pin = 0; pin < NUM_SEGMENTS; pin++) {
pinMode(SEGMENT_DISPLAY[pin], OUTPUT);
}
}
void loop() {
// Ziffern von 0 bis 9 nacheinander anzeigen
for (int digit = 0; digit <= 9; digit++) {
// Segmente entsprechend der Tabelle setzen
for (int pin = 0; pin < NUM_SEGMENTS; pin++) {
digitalWrite(
SEGMENT_DISPLAY[pin],
DIGITS[digit][pin] ? HIGH : LOW
);
}
// Anzeigezeit pro Ziffer
delay(500);
}
}
Buchstaben auf der 7-Segmentanzeige darstellen
Neben Ziffern lassen sich auf einer klassischen 7-Segmentanzeige auch einige Buchstaben darstellen. Das ist möglich, weil bestimmte Buchstaben mit den vorhandenen Segmenten ausreichend gut angenähert werden können.
Typische darstellbare Buchstaben sind unter anderem:
A, b, c, C, d, E, F, G, H, I, L, O, P und U.
Dabei handelt es sich nicht um typografisch exakte Buchstaben, sondern um stilisierte Darstellungen, die durch den einfachen Aufbau der Anzeige bedingt sind. Groß- und Kleinbuchstaben lassen sich oft nicht eindeutig unterscheiden – etwa bei c/C oder o/O.
Für komplexere Texte oder eine saubere Darstellung des gesamten Alphabets ist eine 14- oder 16-Segmentanzeige deutlich besser geeignet. Diese bietet zusätzliche Segmente und ermöglicht dadurch wesentlich genauere Buchstabenformen.
constexpr bool LETTERS[NUM_LETTERS][8] = {
// a, b, c, d, e, f, g, dp
{ 1, 1, 1, 0, 1, 1, 1, 0 }, // A
{ 0, 0, 1, 1, 1, 1, 1, 0 }, // b
{ 0, 0, 0, 1, 1, 0, 1, 0 }, // c
{ 1, 0, 0, 1, 1, 1, 0, 0 }, // C
{ 0, 1, 1, 1, 1, 0, 1, 0 }, // d
{ 1, 0, 0, 1, 1, 1, 1, 0 }, // E
{ 1, 0, 0, 0, 1, 1, 1, 0 }, // F
{ 1, 0, 1, 1, 1, 1, 1, 0 }, // G
{ 0, 1, 1, 0, 1, 1, 1, 0 }, // H
{ 0, 1, 1, 0, 0, 0, 0, 0 }, // I
{ 0, 0, 0, 1, 1, 1, 0, 0 }, // L
{ 0, 0, 1, 1, 1, 0, 1, 0 }, // o
{ 1, 1, 1, 1, 1, 1, 0, 0 }, // O
{ 1, 1, 0, 0, 1, 1, 1, 0 }, // P
{ 0, 0, 1, 1, 1, 0, 0, 0 }, // u
{ 0, 1, 1, 1, 1, 1, 0, 0 }, // U
};
Fazit
Eine 7-Segmentanzeige ist auch am ESP32 eine einfache, robuste und sehr effiziente Möglichkeit, Zahlen und grundlegende Statusinformationen darzustellen. Gerade für Zähler, Timer oder kompakte Anzeigen ist sie oft die bessere Wahl gegenüber grafischen Displays, da sie sofort ablesbar ist und ohne komplexe Bibliotheken auskommt.
In diesem Beitrag hast du gesehen, dass sich sowohl Zahlen als auch ausgewählte Buchstaben direkt über GPIOs ansteuern lassen. Mit einer klar strukturierten Segment-Matrix bleibt der Code übersichtlich, leicht erweiterbar und gut nachvollziehbar. Das Prinzip funktioniert unabhängig vom Mikrocontroller und lässt sich problemlos auf mehrstellige Anzeigen oder andere Projekte übertragen.
Gleichzeitig wird deutlich, wo die Grenzen einer 7-Segmentanzeige liegen: Für längere Texte oder eine saubere Darstellung des gesamten Alphabets ist sie nicht geeignet. In solchen Fällen sind 14- oder 16-Segmentanzeigen die bessere Wahl.
Für einfache Anzeigen ohne zusätzlichen Overhead ist die 7-Segmentanzeige am ESP32 jedoch nach wie vor ein echtes Arbeitstier – minimaler Hardware-Aufwand, volle Kontrolle über den Code und genau so viel Anzeige, wie man wirklich braucht.
FAQ – Häufige Fragen zur 7-Segmentanzeige am ESP32
Welche 7-Segmentanzeige eignet sich für den ESP32?
Grundsätzlich funktionieren sowohl Anzeigen mit gemeinsamer Kathode als auch mit gemeinsamer Anode. Wichtig ist, dass du beim Aufbau der Schaltung und im Code berücksichtigst, ob ein Segment mit HIGH oder LOW aktiviert wird. In diesem Beitrag wurde eine Anzeige mit gemeinsamer Kathode verwendet.
Benötige ich für jedes Segment einen Vorwiderstand?
Ja, jedes Segment sollte grundsätzlich über einen eigenen Vorwiderstand verfügen, um den Strom zu begrenzen und die Anzeige sowie die GPIOs des ESP32 zu schützen. In einfachen Aufbauten wird häufig ein gemeinsamer Widerstand verwendet, technisch sauberer ist jedoch ein Widerstand pro Segment.
Warum verwende ich keine Library zur Ansteuerung?
Das Ziel dieses Beitrags ist es, das Grundprinzip der Segmentansteuerung verständlich zu machen. Ohne Library siehst du genau, welches Segment wann aktiviert wird. Das erleichtert das Debugging und macht den Code unabhängig von externen Abhängigkeiten.
Kann ich mehrere Ziffern gleichzeitig anzeigen?
Ja, dafür werden mehrstellige Anzeigen meist im Multiplex-Verfahren betrieben. Dabei werden die Ziffern sehr schnell nacheinander aktiviert, sodass sie für das menschliche Auge gleichzeitig sichtbar erscheinen. Das Grundprinzip der Segmentsteuerung bleibt dabei identisch.
Warum lassen sich nur wenige Buchstaben darstellen?
Eine 7-Segmentanzeige besteht nur aus sieben festen Segmenten. Viele Buchstaben lassen sich damit nur schlecht oder gar nicht darstellen. Die im Beitrag gezeigten Buchstaben sind Näherungen, die sich in der Praxis bewährt haben.
Wann ist eine 14- oder 16-Segmentanzeige sinnvoller?
Sobald Texte, Abkürzungen oder eine saubere Darstellung von Buchstaben benötigt werden, sind 14- oder 16-Segmentanzeigen deutlich besser geeignet. Sie bieten mehr Segmente und damit wesentlich mehr Darstellungsfreiheit.
Funktioniert der gezeigte Code auch mit Arduino oder anderen Mikrocontrollern?
Ja. Die Logik zur Ansteuerung einer 7-Segmentanzeige ist unabhängig vom ESP32. Der Code lässt sich mit minimalen Anpassungen auch auf Arduino, ESP8266 oder andere Mikrocontroller übertragen.
Kann ich zusätzlich den Dezimalpunkt nutzen?
Ja, der Dezimalpunkt ist ein eigenes Segment und kann genauso wie die anderen Segmente angesteuert werden. In der Segment-Matrix ist er bereits berücksichtigt und kann jederzeit aktiviert oder deaktiviert werden.
Eignet sich eine 7-Segmentanzeige für produktive Projekte?
Absolut. Gerade für Zähler, Timer, Statusanzeigen oder einfache Messwerte ist sie sehr zuverlässig, stromsparend und langlebig – ideal für viele praxisnahe Projekte.
Letzte Aktualisierung am: 05. Februar 2026
