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

©2024 mgr Jerzy Wałaszek
I LO w Tarnowie

Bity w elektronice

Sterownik wskaźnika postępu z 10 diod LED

SPIS TREŚCI

Pojęcie bitu
Przesyłanie bitów
Bity w elektronice

Zapamiętywanie bitów
Sterowanie za pomocą bitów
Przetwarzanie bitów
Podrozdziały

Opis

obrazek

Wskaźniki postępu (ang. LED Light Bar Graph Displays) są zbudowane z kilkunastu diod LED, które zapalają się w ten sposób, iż tworzą słupek świetlny o różnych wysokościach. Stosuje się je powszechnie w sprzęcie audiowizualnym do wskazywania poziomu sygnałów wejściowych lub wyjściowych - człowiek lepiej reaguje na sygnały ilościowe (długość paska, wychylenie wskazówki), niż na liczby. Z tego powodu do dzisiaj wciąż używa się w lotnictwie wskaźniki analogowe zamiast czysto cyfrowych (chociaż ich obraz może być produkowany cyfrowo przez komputer pokładowy):

Sam wskaźnik można zakupić jako gotowy produkt lub zbudować samemu z pojedynczych diod LED. Diody łączy się anodami lub katodami, uzyskując w ten sposób różne schematy zasilania z wyjść układów cyfrowych:

Wspólna anoda


dla Ud = 1,8V
otrzymujemy:

Dioda świeci przy
stanie niskim na
wyjściu bramki
sterującej

 Wspólna katoda

       


dla Ud = 1,8V
otrzymujemy:

Dioda świeci przy
stanie wysokim na
wyjściu bramki
sterującej

Na początek:  podrozdziału   strony 

Określenie funkcji logicznych

Zaprojektujemy sterownik wskaźnika postępu zbudowanego z 10 czerwonych diod LED połączonych anodami - stanem aktywnym będzie stan niski. Na wejścia sterownika podamy wartość od 0 do 10 w kodzie 8421. Na wyjściu otrzymamy sygnały sterujące poszczególnymi diodami LED wskaźnika.

obrazek

Funkcje logiczne wyjść q1 ... q10 określimy na podstawie tabelki:

Wartość D C B A q1 q2 q3 q4 q5 q6 q7 q8 q9 q10
0 0 0 0 0 1 1 1 1 1 1 1 1 1 1
1 0 0 0 1 0 1 1 1 1 1 1 1 1 1
2 0 0 1 0 0 0 1 1 1 1 1 1 1 1
3 0 0 1 1 0 0 0 1 1 1 1 1 1 1
4 0 1 0 0 0 0 0 0 1 1 1 1 1 1
5 0 1 0 1 0 0 0 0 0 1 1 1 1 1
6 0 1 1 0 0 0 0 0 0 0 1 1 1 1
7 0 1 1 1 0 0 0 0 0 0 0 1 1 1
8 1 0 0 0 0 0 0 0 0 0 0 0 1 1
9 1 0 0 1 0 0 0 0 0 0 0 0 0 1
10 1 0 1 0 0 0 0 0 0 0 0 0 0 0

Układamy tablice Karnaugha i odczytujemy z nich zminimalizowane funkcje wyjść sterownika. Funkcje sprowadzamy do operacji NAND.

Obszar q1
obrazek 00 01 11 10
00 1 0 0 0
01 0 0 0 0
11 X X X X
10 0 0 X 0
Obszar q2
obrazek 00 01 11 10
00 1 1 0 0
01 0 0 0 0
11 X X X X
10 0 0 X 0
Obszar q3A
obrazek 00 01 11 10
00 1 1 0 1
01 0 0 0 0
11 X X X X
10 0 0 X 0
Obszar q3B
obrazek 00 01 11 10
00 1 1 0 1
01 0 0 0 0
11 X X X X
10 0 0 X 0
Obszar q4
obrazek 00 01 11 10
00 1 1 1 1
01 0 0 0 0
11 X X X X
10 0 0 X 0
Obszar q5A
obrazek 00 01 11 10
00 1 1 1 1
01 1 0 0 0
11 X X X X
10 0 0 X 0
Obszar q5B
obrazek 00 01 11 10
00 1 1 1 1
01 1 0 0 0
11 X X X X
10 0 0 X 0
Obszar q6A
obrazek 00 01 11 10
00 1 1 1 1
01 1 1 0 0
11 X X X X
10 0 0 X 0
Obszar q6B
obrazek 00 01 11 10
00 1 1 1 1
01 1 1 0 0
11 X X X X
10 0 0 X 0
Obszar q7A
obrazek 00 01 11 10
00 1 1 1 1
01 1 1 0 1
11 X X X X
10 0 0 X 0
Obszar q7B
obrazek 00 01 11 10
00 1 1 1 1
01 1 1 0 1
11 X X X X
10 0 0 X 0
Obszar q7C
obrazek 00 01 11 10
00 1 1 1 1
01 1 1 0 1
11 X X X X
10 0 0 X 0
Obszar q8
obrazek 00 01 11 10
00 1 1 1 1
01 1 1 1 1
11 X X X X
10 0 0 X 0
Obszar q9A
obrazek 00 01 11 10
00 1 1 1 1
01 1 1 1 1
11 X X X X
10 1 0 X 0
Obszar q9B
obrazek 00 01 11 10
00 1 1 1 1
01 1 1 1 1
11 X X X X
10 1 0 X 0
Obszar q10
obrazek 00 01 11 10
00 1 1 1 1
01 1 1 1 1
11 X X X X
10 1 1 X 0

Podsumujmy otrzymane funkcje wyjść q sterownika:


Na początek:  podrozdziału   strony 

Budowa sieci logicznej

Budowę sieci rozpoczynamy od sygnałów wejściowych oraz ich zaprzeczeń:

Teraz tworzymy funkcje wyjść:



...



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(YB4,YB3,YB2,YB1)
YB6 = NAND(YB3,YB2,YB1)
YB7 = NAND(A,B)
YB8 = NAND(YB2,YB1)
YB9 = NAND(YB4,YB3)
YB10 = NAND(B,C)
YB11 = NAND(A,B,C)
YB12 = NAND(YB4,YB3)
YB13 = NAND(YB4,B,YB2,D)
YB14 = NOT(YB5)
YB15 = NOT(YB6)
YB16 = NAND(YB7,YB2,YB1)
YB17 = NOT(YB8)
YB18 = NAND(YB9,C)
YB19 = NAND(YB10,YB1)
YB20 = NAND(YB11,YB1)
YB21 = NAND(YB12,D)
YB22 = NOT(YB16)
YB23 = NAND(YB18,YB1)
YB24 = NOT(YB19)
YB25 = NOT(YB20)
YB26 = NOT(YB23)
q1 = YB14
q2 = YB15
q3 = YB22
q4 = YB17
q5 = YB26
q6 = YB24
q7 = YB25
q8 = YB1
q9 = YB21
q10 = YB13

Do sieci będą przekazywane kolejne dane w kodzie 8421 od 0 do 10. Na wyjściach q powinniśmy otrzymać:
Wartość D C B A q1 q2 q3 q4 q5 q6 q7 q8 q9 q10
0 0 0 0 0 1 1 1 1 1 1 1 1 1 1
1 0 0 0 1 0 1 1 1 1 1 1 1 1 1
2 0 0 1 0 0 0 1 1 1 1 1 1 1 1
3 0 0 1 1 0 0 0 1 1 1 1 1 1 1
4 0 1 0 0 0 0 0 0 1 1 1 1 1 1
5 0 1 0 1 0 0 0 0 0 1 1 1 1 1
6 0 1 1 0 0 0 0 0 0 0 1 1 1 1
7 0 1 1 1 0 0 0 0 0 0 0 1 1 1
8 1 0 0 0 0 0 0 0 0 0 0 0 1 1
9 1 0 0 1 0 0 0 0 0 0 0 0 0 1
10 1 0 1 0 0 0 0 0 0 0 0 0 0 0
C++
// Symulacja sieci logicznej
// transkodera BCD na 1 z 10
// (C)2020 mgr Jerzy Wałaszek
// I LO w Tarnowie

#include <iostream>

using namespace std;

// Funkcje bramek

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

int NAND(int a, int b, int c = 1, int d = 1)
{
    return !(a && b && c && d);
}

int main( )
{
  // Stany wejściowe oraz stany wyjściowe
  int A,B,C,D,q1,q2,q3,q4,q5,q6,q7,q8,q9,q10;

  // 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,YB23,YB24,YB25,YB26;

  int i;

  cout << " D C B A | q1 q2 q3 q4 q5 q6 q7 q8 q9 q10\n"
          "---------+-------------------------------" << endl;

  // W pętli generujemy kody liczb 8421 od 0 do 10
  for(i = 0; i < 11; i++)
  {
    // Wydobywamy bity kodu 8421
    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 = NAND(YB4,YB3,YB2,YB1);
    YB6 = NAND(YB3,YB2,YB1);
    YB7 = NAND(A,B);
    YB8 = NAND(YB2,YB1);
    YB9 = NAND(YB4,YB3);
    YB10 = NAND(B,C);
    YB11 = NAND(A,B,C);
    YB12 = NAND(YB4,YB3);
    YB13 = NAND(YB4,B,YB2,D);
    YB14 = NOT(YB5);
    YB15 = NOT(YB6);
    YB16 = NAND(YB7,YB2,YB1);
    YB17 = NOT(YB8);
    YB18 = NAND(YB9,C);
    YB19 = NAND(YB10,YB1);
    YB20 = NAND(YB11,YB1);
    YB21 = NAND(YB12,D);
    YB22 = NOT(YB16);
    YB23 = NAND(YB18,YB1);
    YB24 = NOT(YB19);
    YB25 = NOT(YB20);
    YB26 = NOT(YB23);
    q1 = YB14;
    q2 = YB15;
    q3 = YB22;
    q4 = YB17;
    q5 = YB26;
    q6 = YB24;
    q7 = YB25;
    q8 = YB1;
    q9 = YB21;
    q10 = YB13;

    // Wyświetlamy wyniki

    cout << " " << D << " " << C << " " << B << " " << A << " |  "
         << q1 << "  "
         << q2 << "  "
         << q3 << "  "
         << q4 << "  "
         << q5 << "  "
         << q6 << "  "
         << q7 << "  "
         << q8 << "  "
         << q9 << "  "
         << q10 << "  " << endl;
  }
  cout << endl;

  return 0;
}
Wynik:  
 D C B A | q1 q2 q3 q4 q5 q6 q7 q8 q9 q10
---------+-------------------------------
 0 0 0 0 |  1  1  1  1  1  1  1  1  1  1
 0 0 0 1 |  0  1  1  1  1  1  1  1  1  1
 0 0 1 0 |  0  0  1  1  1  1  1  1  1  1
 0 0 1 1 |  0  0  0  1  1  1  1  1  1  1
 0 1 0 0 |  0  0  0  0  1  1  1  1  1  1
 0 1 0 1 |  0  0  0  0  0  1  1  1  1  1
 0 1 1 0 |  0  0  0  0  0  0  1  1  1  1
 0 1 1 1 |  0  0  0  0  0  0  0  1  1  1
 1 0 0 0 |  0  0  0  0  0  0  0  0  1  1
 1 0 0 1 |  0  0  0  0  0  0  0  0  0  1
 1 0 1 0 |  0  0  0  0  0  0  0  0  0  0
Wartość D C B A q1 q2 q3 q4 q5 q6 q7 q8 q9 q10
0 0 0 0 0 1 1 1 1 1 1 1 1 1 1
1 0 0 0 1 0 1 1 1 1 1 1 1 1 1
2 0 0 1 0 0 0 1 1 1 1 1 1 1 1
3 0 0 1 1 0 0 0 1 1 1 1 1 1 1
4 0 1 0 0 0 0 0 0 1 1 1 1 1 1
5 0 1 0 1 0 0 0 0 0 1 1 1 1 1
6 0 1 1 0 0 0 0 0 0 0 1 1 1 1
7 0 1 1 1 0 0 0 0 0 0 0 1 1 1
8 1 0 0 0 0 0 0 0 0 0 0 0 1 1
9 1 0 0 1 0 0 0 0 0 0 0 0 0 1
10 1 0 1 0 0 0 0 0 0 0 0 0 0 0


Na początek:  podrozdziału   strony 

Symulacja interaktywna

Uwaga:

W symulatorze wyświetlacz LED reaguje na stan niski, czyli odpowiednia dioda LED zapala się, jeśli na jej wejściu qn pojawi się stan niski 0. Sieć logiczna działa poprawnie tylko dla kodów 8421 od 0 do 10 (0000 ... 1010)

Symulator

Na początek:  podrozdziału   strony 

Spis elementów

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

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

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
©2024 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.