Jak sterować wyświetlaczem 7-segmentowym w Arduino?

Wyświetlacz 7-segmentowy to jeden z najpopularniejszych komponentów elektronicznych do prezentacji cyfr 0–9. W tym poradniku krok po kroku podłączysz go do Arduino i uruchomisz działający kod, który wyświetli cyfry dokładnie tak, jak chcesz.

Czym jest wyświetlacz 7-segmentowy?

Wyświetlacz 7-segmentowy składa się z ośmiu diod LED ułożonych w kształt segmentów: siedem głównych (A–G) oraz DP (decimal point – kropka). Każdy segment sterujesz niezależnie, a odpowiednia kombinacja zapalonych segmentów tworzy cyfry 0–9.

Zamiast zaawansowanych protokołów (I2C, SPI), wyświetlacz 7-segmentowy sterujemy bezpośrednio z pinów cyfrowych Arduino – to idealny komponent do nauki podstaw elektroniki i programowania.

Rodzaje wyświetlaczy 7-segmentowych

Wspólna katoda (CC) – wspólny minus (GND), segment świeci po podaniu stanu HIGH na jego pin.

Wspólna anoda (CA) – wspólny plus (VCC), segment świeci po podaniu stanu LOW na jego pin.

Kluczowe: piny na obudowie zwykle nie są opisane – koniecznie sprawdź datasheet, aby prawidłowo zidentyfikować piny segmentów i piny wspólne (COM).

Co będziesz potrzebować?

Do zbudowania podstawowego układu przygotuj:

• płytka Arduino (np. Arduino Uno R3, Arduino Nano, ESP32),
• wyświetlacz 7-segmentowy (CC lub CA),
• płytka stykowa (breadboard),
• 7–8 rezystorów 220 Ω (po jednym na każdy segment),
• przewody połączeniowe (jumpers).

Na drodze każdego połączenia segmentu z Arduino musi znaleźć się rezystor ograniczający prąd – to absolutnie niezbędne dla ochrony diod LED.

Jak podłączyć wyświetlacz 7-segmentowy

Krok 1 – umieszczenie wyświetlacza na płytce stykowej

Umieść wyświetlacz na płytce stykowej tak, aby każdy pin wchodził w osobny rząd. Ułóż go centralnie, by połowa pinów była po lewej, a połowa po prawej stronie płytki.

Krok 2 – podłączenie pinu wspólnego (COM)

Dla CC (wspólna katoda): połącz jeden z pinów COM z szyną masy (-) na płytce, a następnie z GND w Arduino.

Dla CA (wspólna anoda): połącz jeden z pinów COM z szyną zasilania (+5 V). Drugi pin COM może pozostać niepodłączony.

Krok 3 – podłączenie segmentów

Każdy z ośmiu segmentów (A–G oraz DP) podłącz do osobnego pinu cyfrowego Arduino, koniecznie wstawiając w szereg rezystor. Poniżej przykładowe mapowanie pinów (możesz zmienić według potrzeb):

Segment	Pin Arduino
A	11
B	7
C	3
D	5
E	6
F	10
G	2
DP	opcjonalnie

Schemat połączenia (w szeregu): rezystor – segment – pin Arduino.

Programowanie wyświetlacza

Proste podejście (wspólna katoda)

Przy pojedynczej cyfrze nie potrzebujesz multipleksowania. Wystarczy włączać i wyłączać odpowiednie segmenty we właściwym momencie. Oto minimalny przykład, który wyświetla cyfrę 0:

int a = 11; // pin segmentu A
int b = 7; // pin segmentu B
int c = 3; // pin segmentu C
int d = 5; // pin segmentu D
int e = 6; // pin segmentu E
int f = 10; // pin segmentu F
int g = 2; // pin segmentu G

void setup() {
pinMode(a, OUTPUT);
pinMode(b, OUTPUT);
pinMode(c, OUTPUT);
pinMode(d, OUTPUT);
pinMode(e, OUTPUT);
pinMode(f, OUTPUT);
pinMode(g, OUTPUT);
}

void loop() {
// Wyświetlenie cyfry 0 (A, B, C, D, E, F = ON; G = OFF)
digitalWrite(a, HIGH);
digitalWrite(b, HIGH);
digitalWrite(c, HIGH);
digitalWrite(d, HIGH);
digitalWrite(e, HIGH);
digitalWrite(f, HIGH);
digitalWrite(g, LOW);
delay(1000);
}

Uwaga (CA): dla wyświetlacza ze wspólną anodą odwróć logikę stanów (tam, gdzie jest HIGH użyj LOW i odwrotnie).

Profesjonalne podejście – tablica pinów

Zamiast definiować 8 oddzielnych zmiennych, zapisz numery pinów w tablicy i steruj nimi w pętli. To upraszcza kod i ułatwia rozbudowę. Przykładowa implementacja:

// Tablica pinów dla segmentów A–G
int pins[] = {11, 7, 3, 5, 6, 10, 2};

void setup() {
for (int i = 0; i < 7; i++) {
pinMode(pins[i], OUTPUT);
}
}

void displayDigit(int digit) {
// Mapa segmentów dla cyfr 0–9 (1 = włączony, 0 = wyłączony)
int digits[10][7] = {
{1, 1, 1, 1, 1, 1, 0}, // 0
{0, 1, 1, 0, 0, 0, 0}, // 1
{1, 1, 0, 1, 1, 0, 1}, // 2
{1, 1, 1, 1, 0, 0, 1}, // 3
{0, 1, 1, 0, 0, 1, 1}, // 4
{1, 0, 1, 1, 0, 1, 1}, // 5
{1, 0, 1, 1, 1, 1, 1}, // 6
{1, 1, 1, 0, 0, 0, 0}, // 7
{1, 1, 1, 1, 1, 1, 1}, // 8
{1, 1, 1, 1, 0, 1, 1} // 9
};

for (int i = 0; i < 7; i++) {
digitalWrite(pins[i], digits[digit][i]);
}
}

void loop() {
for (int i = 0; i < 10; i++) {
displayDigit(i);
delay(1000);
}
}

Używanie bibliotek

Możesz skorzystać z biblioteki SevenSeg, aby jeszcze bardziej uprościć kod. Po instalacji biblioteki użyj poniższego przykładu:

#include <SevenSeg.h>

SevenSeg disp(11, 7, 3, 5, 6, 10, 2); // podłączenie segmentów A–G

const int numOfDigits = 1;
int digitPins[numOfDigits] = {12};

void setup() {
disp.setDigitPins(numOfDigits, digitPins);
disp.setTimer(2);
disp.startTimer();
}

void loop() {
// Wyświetlanie cyfr 0–9
for (int i = 0; i < 10; i++) {
disp.write(i);
delay(1000);
}
}

Zaawansowane techniki – rejestr przesuwny 74HC595

Gdy brakuje wolnych pinów, zastosuj rejestr przesuwny 74HC595. Dzięki niemu do sterowania wszystkimi segmentami użyjesz tylko 3 linii (zasilanie pomijamy). To rozwiązanie świetnie sprawdza się przy wielu wyświetlaczach.

Porady praktyczne

Poniższe wskazówki pomogą Ci uniknąć najczęstszych błędów:

• testowanie segmentów – przed pisaniem pełnego programu sprawdź każdy segment osobno, zasilając go przez rezystor z Arduino, aby potwierdzić, że świeci;
• dokumentacja (datasheet) – miej pod ręką kartę katalogową swojego modelu; tylko ona jednoznacznie wskazuje układ pinów i typ (CC/CA);
• rezystory są obowiązkowe – nigdy nie pomijaj rezystorów ograniczających prąd; chronią diody LED przed uszkodzeniem;
• czytelny kod – korzystaj z tablic i pętli zamiast wielu warunków; to ułatwia utrzymanie i dalszą rozbudowę projektu.