Serwis Edukacyjny
w I-LO w Tarnowie
obrazek

Materiały dla uczniów liceum

  Wyjście       Spis treści       Wstecz       Dalej  

Autor artykułu: mgr Jerzy Wałaszek

©2020 mgr Jerzy Wałaszek
I LO w Tarnowie

Bity w elektronice

Wyświetlacz 7-segmentowy

SPIS TREŚCI
Podrozdziały

Opis

Wyświetlacze cyfrowe LED (ang. Light Emitting Diode - dioda emitująca światło, LED display, digital LED display, BCD to seven segment decoder/driver) są powszechnie stosowane w różnym sprzęcie elektronicznym - radia, telewizory, zasilacze, urządzenia pomiarowe, termometry cyfrowe, zegary itp. Zbudowane są z diod LED, które pod wpływem przyłożonego napięcia (około 2...2,4V) świecą różnymi kolorami, najczęściej na czerwono, chociaż obecnie inne kolory również stają się popularne.

Świecenie diody LED nie ma nic wspólnego z procesami termicznymi, jak np. w żarówce. Pod wpływem przepływu elektronów przez specjalnie dobrany półprzewodnik następuje wzbudzanie jego atomów i generacja fotonów o ściśle określonych długościach fal, które wydostają się na zewnątrz dając efekt świecenia diody. Procesy te są bardzo szybkie - diodę LED można załączać i wyłączać miliony razy na sekundę (własność tę wykorzystują np. nadajniki światłowodowe). Ponieważ w trakcie świecenia dioda nie rozgrzewa się do wysokich temperatur, jej bezawaryjny czas pracy jest bardzo długi - około 50...100 tysięcy godzin. Więcej na temat diod LED znajdziesz tutaj.

Budowa cyfrowego wyświetlacza LED

Typowy, cyfrowy wyświetlacz LED zbudowany jest z 7 segmentów, za pomocą których można wyświetlać wszystkie cyfry oraz kilkanaście liter i innych znaków (do liter stosuje się wyświetlacze alfanumeryczne, które posiadając dodatkowe segmenty pozwalają wyświetlać wszystkie litery alfabetu).

obrazek

Każdy segment jest podświetlany przez oddzielną diodę LED. Aby zaoszczędzić na liczbie wyprowadzeń wyświetlacza, wewnętrznie diody są ze sobą połączone katodami (wyświetlacz o wspólnej katodzie - ang. common cathode) lub anodami (wyświetlacz o wspólnej anodzie - ang. common anode).

obrazek Wspólna katoda
obrazek
    Wspólna anoda
obrazek
   

Poniższa symulacja wyświetlacza LED pozwala ci przetestować różne konfiguracje segmentów. Segmenty zaświecasz i gasisz kliknięciem myszki.

Symulator

Wyświetlacz o wspólnej katodzie zaświeca segmenty, jeśli na ich wejścia sterujące podamy poziom wysoki. Z kolei wyświetlacz o wspólnej anodzie reaguje na poziom niski na wejściach sterujących. Należy na ten fakt zwrócić uwagę przy konstruowaniu urządzenia cyfrowego. Praktycznie wszystkie wyświetlacze LED są produkowane w obu wariantach połączeń.

Na początek:  podrozdziału   strony 

Określenie funkcji logicznych

W tym projekcie zbudujemy sterownik wyświetlacza LED ze wspólną katodą. Na początek określmy sygnały wejściowe i wyjściowe

obrazek

Sterownik posiada cztery wejścia D, C, B, A, na które podajemy cyfrę dziesiętną w kodzie BCD. W odpowiedzi na wyjściach a, b, c, d, e, f i g pojawiają się sygnały sterujące odpowiednimi segmentami wyświetlacza LED. Poniższa tabelka definiuje sygnały wyjściowe w funkcji sygnałów wejściowych.

wejście wyjście cyfra
D C B A a b c d e f g
0 0 0 0 1 1 1 1 1 1 0 obrazek
0 0 0 1 0 1 1 0 0 0 0 obrazek
0 0 1 0 1 1 0 1 1 0 1 obrazek
0 0 1 1 1 1 1 1 0 0 1 obrazek
0 1 0 0 0 1 1 0 0 1 1 obrazek
0 1 0 1 1 0 1 1 0 1 1 obrazek
0 1 1 0 1 0 1 1 1 1 1 obrazek
0 1 1 1 1 1 1 0 0 1 0 obrazek
1 0 0 0 1 1 1 1 1 1 1 obrazek
1 0 0 1 1 1 1 1 0 1 1 obrazek

Na podstawie tabelki tworzymy tablice Karnaugha dla poszczególnych sygnałów wyjściowych i dokonujemy minimalizacji funkcji logicznych, sprowadzając je do funkcji NAND:

Obszar a1
obrazek 00 01 11 10
00 1 0 1 1
01 0 1 1 1
11 X X X X
10 1 1 X X
Obszar a2
obrazek 00 01 11 10
00 1 0 1 1
01 0 1 1 1
11 X X X X
10 1 1 X X
Obszar a3
obrazek 00 01 11 10
00 1 0 1 1
01 0 1 1 1
11 X X X X
10 1 1 X X
Obszar a4
obrazek 00 01 11 10
00 1 0 1 1
01 0 1 1 1
11 X X X X
10 1 1 X X
 
Obszar b1
obrazek 00 01 11 10
00 1 1 1 1
01 1 0 1 0
11 X X X X
10 1 1 X X
Obszar b2
obrazek 00 01 11 10
00 1 1 1 1
01 1 0 1 0
11 X X X X
10 1 1 X X
Obszar b3
obrazek 00 01 11 10
00 1 1 1 1
01 1 0 1 0
11 X X X X
10 1 1 X X
   
Obszar c1
obrazek 00 01 11 10
00 1 1 1 0
01 1 1 1 1
11 X X X X
10 1 1 X X
Obszar c2
obrazek 00 01 11 10
00 1 1 1 0
01 1 1 1 1
11 X X X X
10 1 1 X X
Obszar c3
obrazek 00 01 11 10
00 1 1 1 0
01 1 1 1 1
11 X X X X
10 1 1 X X
   
Obszar d1
obrazek 00 01 11 10
00 1 0 1 1
01 0 1 0 1
11 X X X X
10 1 1 X X
Obszar d2
obrazek 00 01 11 10
00 1 0 1 1
01 0 1 0 1
11 X X X X
10 1 1 X X
Obszar d3
obrazek 00 01 11 10
00 1 0 1 1
01 0 1 0 1
11 X X X X
10 1 1 X X
Obszar d4
obrazek 00 01 11 10
00 1 0 1 1
01 0 1 0 1
11 X X X X
10 1 1 X X
Obszar d5
obrazek 00 01 11 10
00 1 0 1 1
01 0 1 0 1
11 X X X X
10 1 1 X X
Obszar e1
obrazek 00 01 11 10
00 1 0 0 1
01 0 0 0 1
11 X X X X
10 1 0 X X
Obszar e2
obrazek 00 01 11 10
00 1 0 0 1
01 0 0 0 1
11 X X X X
10 1 0 X X
     
Obszar f1
obrazek 00 01 11 10
00 1 0 0 0
01 1 1 1 1
11 X X X X
10 1 1 X X
Obszar f2
obrazek 00 01 11 10
00 1 0 0 0
01 1 1 1 1
11 X X X X
10 1 1 X X
Obszar f3
obrazek 00 01 11 10
00 1 0 0 0
01 1 1 1 1
11 X X X X
10 1 1 X X
   
Obszar g1
obrazek 00 01 11 10
00 0 0 1 1
01 1 1 0 1
11 X X X X
10 1 1 X X
Obszar g2
obrazek 00 01 11 10
00 0 0 1 1
01 1 1 0 1
11 X X X X
10 1 1 X X
Obszar g3
obrazek 00 01 11 10
00 0 0 1 1
01 1 1 0 1
11 X X X X
10 1 1 X X
Obszar g4
obrazek 00 01 11 10
00 0 0 1 1
01 1 1 0 1
11 X X X X
10 1 1 X X
 

Podsumujmy otrzymane funkcje logiczne dla poszczególnych wyjść sterownika:

Na początek:  podrozdziału   strony 

Budowa sieci logicznej

Rozpoczynamy od sygnałów wejściowych i ich negacji:

Teraz realizujemy kolejne funkcje wyjściowe:







Tutaj korzystamy z funkcji, która została już użyta w sygnale d.




Wykorzystujemy funkcje z sygnału a i d.

Na początek:  podrozdziału   strony 

Symulacja sieci w języku C++

Numerujemy bramki:

Definiujemy sieć połączeń:

YB1 = NOT(D)
YB2 = NOT(C)
YB3 = NOT(B)
YB4 = NOT(A)
YB5 = NAND(A,C)
YB6 = NAND(YB2,YB4)
YB7 = NAND(YB3,YB4)
YB8 = NAND(A,B)
YB9 = NAND(YB4,B,YB2)
YB10 = NAND(YB3,C)
YB11 = NAND(B,YB2)
YB12 = NAND(A,YB3,C)
YB13 = NAND(YB4,YB3)
YB14 = NAND(YB3,YB1,YB5,YB6)
YB15 = NAND(C,YB7,YB8)
YB16 = NAND(YB4,YB10)
YB17 = NAND(YB10,YB4)
YB18 = NAND(YB2,YB1,YB13)
YB19 = NAND(YB5,B)
YB20 = NAND(YB1,YB16,YB11,YB12)
YB21 = NOT(YB17)
YB22 = NAND(YB10,YB19,YB1)
a = YB14
b = YB15
c = YB9
d = YB20
e = YB21
f = YB18
g = YB22

Na wejścia sieci będą podawane kody BCD kolejnych cyfr od 0 do 9. Na wyjściu otrzymamy stany sygnałów sterujących wyświetlaczem LED a ... g:
wejście wyjście cyfra
D C B A a b c D e f g
0 0 0 0 1 1 1 1 1 1 0 obrazek
0 0 0 1 0 1 1 0 0 0 0 obrazek
0 0 1 0 1 1 0 1 1 0 1 obrazek
0 0 1 1 1 1 1 1 0 0 1 obrazek
0 1 0 0 0 1 1 0 0 1 1 obrazek
0 1 0 1 1 0 1 1 0 1 1 obrazek
0 1 1 0 1 0 1 1 1 1 1 obrazek
0 1 1 1 1 1 1 0 0 1 0 obrazek
1 0 0 0 1 1 1 1 1 1 1 obrazek
1 0 0 1 1 1 1 1 0 1 1 obrazek
C++
// Symulacja sieci logicznej
// sterownika wyświetlacza LED
// (C)2020 mgr Jerzy Wałaszek
// I LO w Tarnowie

#include <iostream>

using namespace std;

// Funkcje bramek

int NOT(int a)
{
    return !a;
}

int NAND2(int a, int b)
{
    return !(a && b);
}

int NAND3(int a, int b, int c)
{
    return !(a && b && c);
}

int NAND4(int a, int b, int c, int d)
{
    return !(a && b && c && d);
}

int main( )
{
  // Stany wejściowe oraz stany wyjściowe
  int A,B,C,D,a,b,c,d,e,f,g;

  // Stany wyjściowe bramek
  int YB1, YB2, YB3, YB4, YB5, YB6, YB7, YB8, YB9, YB10;
  int YB11,YB12,YB13,YB14,YB15,YB16,YB17,YB18,YB19,YB20;
  int YB21,YB22;

  int i;


  cout << " D C B A | a b c d e f g\n"
          "---------+---------------" << endl;

  // W pętli generujemy kody cyfr BCD od 0 do 9
  for(i = 0; i < 10; i++)
  {
    // Wydobywamy bity kodu BCD
    D = (i & 8) > 0;
    C = (i & 4) > 0;
    B = (i & 2) > 0;
    A = (i & 1);

    // Symulacja sieci

    YB1  = NOT(D);
    YB2  = NOT(C);
    YB3  = NOT(B);
    YB4  = NOT(A);
    YB5  = NAND2(A,C);
    YB6  = NAND2(YB2,YB4);
    YB7  = NAND2(YB3,YB4);
    YB8  = NAND2(A,B);
    YB9  = NAND3(YB4,B,YB2);
    YB10 = NAND2(YB3,C);
    YB11 = NAND2(B,YB2);
    YB12 = NAND3(A,YB3,C);
    YB13 = NAND2(YB4,YB3);
    YB14 = NAND4(YB3,YB1,YB5,YB6);
    YB15 = NAND3(C,YB7,YB8);
    YB16 = NAND2(YB4,YB10);
    YB17 = NAND2(YB10,YB4);
    YB18 = NAND3(YB2,YB1,YB13);
    YB19 = NAND2(YB5,B);
    YB20 = NAND4(YB1,YB16,YB11,YB12);
    YB21 = NOT(YB17);
    YB22 = NAND3(YB10,YB19,YB1);
    a = YB14;
    b = YB15;
    c = YB9;
    d = YB20;
    e = YB21;
    f = YB18;
    g = YB22;

    // Wyświetlamy wyniki

    cout << " " << D << " " << C << " " << B << " " << A
         << " | "
         << a << " "
         << b << " "
         << c << " "
         << d << " "
         << e << " "
         << f << " "
         << g << endl;
  }
  cout << endl;

  return 0;
}
Wynik:  
 D C B A | a b c d e f g
---------+---------------
 0 0 0 0 | 1 1 1 1 1 1 0
 0 0 0 1 | 0 1 1 0 0 0 0
 0 0 1 0 | 1 1 0 1 1 0 1
 0 0 1 1 | 1 1 1 1 0 0 1
 0 1 0 0 | 0 1 1 0 0 1 1
 0 1 0 1 | 1 0 1 1 0 1 1
 0 1 1 0 | 1 0 1 1 1 1 1
 0 1 1 1 | 1 1 1 0 0 1 0
 1 0 0 0 | 1 1 1 1 1 1 1
 1 0 0 1 | 1 1 1 1 0 1 1
D C B A a b c d e f g
0 0 0 0 1 1 1 1 1 1 0
0 0 0 1 0 1 1 0 0 0 0
0 0 1 0 1 1 0 1 1 0 1
0 0 1 1 1 1 1 1 0 0 1
0 1 0 0 0 1 1 0 0 1 1
0 1 0 1 1 0 1 1 0 1 1
0 1 1 0 1 0 1 1 1 1 1
0 1 1 1 1 1 1 0 0 1 0
1 0 0 0 1 1 1 1 1 1 1
1 0 0 1 1 1 1 1 0 1 1

Na początek:  podrozdziału   strony 

Symulacja interaktywna

Symulator
Na początek:  podrozdziału   strony 

Spis elementów

Obciążenia wnoszone przez poszczególne wejścia: A - 4, B - 5, C - 5,  D - 1,

SN7400 x 3
obrazek
SN7404 x 1
obrazek
SN7410 x 2
obrazek
SN7420 x 1
obrazek

Scalony sterownik wyświetlacza LED - SN7448

Sieć logiczna sterownika wyświetlacza cyfrowego LED wymaga zastosowania aż 7 układów scalonych TTL. Ponieważ wyświetlacze LED są powszechnie stosowane w różnym sprzęcie cyfrowym, przemysł elektroniczny produkuje scalone sterowniki, które zawierają taką sieć wewnątrz pojedynczego układu, udostępniając dodatkowe funkcje. Takim właśnie scalonym sterownikiem jest na przykład układ scalony TTL SN7448 (również SN7446, SN7447 i SN7449 - sterują wyświetlaczami o wspólnej anodzie).

 

SN7448
obrazek

Układ SN7448 pozwala bezpośrednio sterować 7 segmentowym wyświetlaczem LED o wspólnej katodzie, czyli realizuje podobne funkcje do naszego sterownika. Typowa aplikacja dla tego układu jest następująca:

obrazek

Sygnały sterujące LT, BI/RBO i RBI (LT - LED Test,  BI - Blanking Input - wejście wygaszające,  RBO - Ripple-Blanking Output - wyjście sztafetowego wygaszania, RBI - Ripple-Blanking Input - wejście sztafetowego wygaszania) umożliwiają testowanie wyświetlacza oraz wygaszanie początkowych zer w układach sterujących większą liczbą wyświetlaczy cyfr. Więcej informacji na temat tego układu znajdziesz w katalogach producenta. Poniższa tabelka przedstawia zależności pomiędzy sygnałami wejściowymi i wyjściowymi dla układu SN7448. Zwróć uwagę na uboższe o jeden segment wyświetlanie cyfr 6, 7 i 9.

Wejścia BI/RBO Wyjścia LED Uwagi
LT RBI D C B A a b c d e f g
1 1 0 0 0 0 1 1 1 1 1 1 1 0 obrazek Cyfry
1 X 0 0 0 1 1 0 1 1 0 0 0 0 obrazek
1 X 0 0 1 0 1 1 1 0 1 1 0 1 obrazek
1 X 0 0 1 1 1 1 1 1 1 0 0 1 obrazek
1 X 0 1 0 0 1 0 1 1 0 0 1 1 obrazek
1 X 0 1 0 1 1 1 0 1 1 0 1 1 obrazek
1 X 0 1 1 0 1 0 0 1 1 1 1 1 obrazek
1 X 0 1 1 1 1 1 1 1 0 0 0 0 obrazek
1 X 1 0 0 0 1 1 1 1 1 1 1 1 obrazek
1 X 1 0 0 1 1 1 1 1 0 0 1 1 obrazek
1 X 1 0 1 0 1 0 0 0 1 1 0 1 obrazek Znaki
specjalne
1 X 1 0 1 1 1 0 0 1 1 0 0 1 obrazek
1 X 1 1 0 0 1 0 1 0 0 0 1 1 obrazek
1 X 1 1 0 1 1 1 0 0 1 0 1 1 obrazek
1 X 1 1 1 0 1 0 0 0 1 1 1 1 obrazek
1 X 1 1 1 1 1 0 0 0 0 0 0 0 obrazek
X X X X X X 0 0 0 0 0 0 0 0 obrazek Wygaszenie
1 0 0 0 0 0 0 0 0 0 0 0 0 0 obrazek Wygaszenie zera
0 X X X X X 1 1 1 1 1 1 1 1 obrazek Test diod LED
Na początek:  podrozdziału   strony 

Zespół Przedmiotowy
Chemii-Fizyki-Informatyki

w I Liceum Ogólnokształcącym
im. Kazimierza Brodzińskiego
w Tarnowie
ul. Piłsudskiego 4
©2020 mgr Jerzy Wałaszek

Materiały tylko do użytku dydaktycznego. Ich kopiowanie i powielanie jest dozwolone
pod warunkiem podania źródła oraz niepobierania za to pieniędzy.

Pytania proszę przesyłać na adres email: i-lo@eduinf.waw.pl

Serwis wykorzystuje pliki cookies. Jeśli nie chcesz ich otrzymywać, zablokuj je w swojej przeglądarce.
Informacje dodatkowe.