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

Konwerter kodu BCD na kod 1 z 10

SPIS TREŚCI
Podrozdziały

Opis

Kod 1 z 10 jest kodem binarnym, w którym poszczególne bity reprezentują cyfry dziesiętne. W słowie kodowym może być ustawiony tylko jeden bit. Pozostałe bity muszą być w stanie przeciwnym. Cyfry dziesiętne są przyporządkowane poszczególnym bitom. Poniższa tabelka opisuje kolejne słówka kodu 1 z 10.

Cyfra logika dodatnia logika ujemna
b0 b1 b2 b3 b4 b5 b6 b7 b8 b9 b0 b1 b2 b3 b4 b5 b6 b7 b8 b9
0 1 0 0 0 0 0 0 0 0 0 0 1 1 1 1 1 1 1 1 1
1 0 1 0 0 0 0 0 0 0 0 1 0 1 1 1 1 1 1 1 1
2 0 0 1 0 0 0 0 0 0 0 1 1 0 1 1 1 1 1 1 1
3 0 0 0 1 0 0 0 0 0 0 1 1 1 0 1 1 1 1 1 1
4 0 0 0 0 1 0 0 0 0 0 1 1 1 1 0 1 1 1 1 1
5 0 0 0 0 0 1 0 0 0 0 1 1 1 1 1 0 1 1 1 1
6 0 0 0 0 0 0 1 0 0 0 1 1 1 1 1 1 0 1 1 1
7 0 0 0 0 0 0 0 1 0 0 1 1 1 1 1 1 1 0 1 1
8 0 0 0 0 0 0 0 0 1 0 1 1 1 1 1 1 1 1 0 1
9 0 0 0 0 0 0 0 0 0 1 1 1 1 1 1 1 1 1 1 0

Tego typu kody nadają się do sterowania wyświetlaczy lampowych (lampy Nixie), w których kolejne bity sterują świeceniem włókienek w wyświetlaczu, uformowanymi w kształcie odpowiedniej cyfry. Takich wyświetlaczy dzisiaj się już nie stosuje, ale możesz się z nimi spotkać w starych urządzeniach. Poniższy rysunek przedstawia lampę Nixie. Zwróć uwagę na kształt elektrod wewnątrz lampy Nixie. Świecenie odbywało się na zasadzie pobudzania przez elektrodę gazu wypełniającego lampę.

Transkodery BCD na 1 z 10 mogą mieć zastosowanie w różnych układach zamków cyfrowych i rozdzielaczach sygnałów cyfrowych.

Na początek:  podrozdziału   strony 

Określenie funkcji logicznych

Zaprojektujemy teraz prosty konwerter kodu BCD na kod 1 z 10, przy czym wybierzemy logikę ujemną - cyfra reprezentowana stanem niskim odpowiadającego jej bitu. Najpierw zdefiniujemy sygnały wejściowe i wyjściowe:

obrazek

Realizacja funkcji wyjściowych qi jest bardzo prosta i nie musimy posiłkować się tabelami Karnaugha. Każde wyjście qi reaguje tylko na jedną kombinację stanów sygnałów wejściowych A, B, C i D. Skoro tak, dla każdego wyjścia zastosujemy 4-wejściową bramkę NAND. Do wejść bramki doprowadzimy odpowiednie kombinację sygnałów i ich zaprzeczeń. Kombinacja ta powinna być taka, aby dla danego kodu BCD na wejściach bramki były same jedynki logiczne - wtedy wyjście bramki NAND przyjmie stan 0. Skorzystamy z poniższej tabelki:

Cyfra A B C D A B C D Funkcja
0 0 0 0 0 1 1 1 1
1 1 0 0 0 0 1 1 1
2 0 1 0 0 1 0 1 1
3 1 1 0 0 0 0 1 1
4 0 0 1 0 1 1 0 1
5 1 0 1 0 0 1 0 1
6 0 1 1 0 1 0 0 1
7 1 1 1 0 0 0 0 1
8 0 0 0 1 1 1 1 0
9 1 0 0 1 0 1 1 0

Podsumujmy:










Na początek:  podrozdziału   strony 

Budowa sieci logicznej

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

Teraz realizujemy funkcje poszczególnych wyjść:



...


Na początek:  podrozdziału   strony 

Symulacja sieci w języku C++

Numerujemy bramki:

Definiujemy połączenia:

YB1 = NOT(D)
YB2 = NOT(C)
YB3 = NOT(B)
YB4 = NOT(A)
YB5 = NAND(YB4,YB3,YB2,YB1)
YB6 = NAND(A,YB3,YB2,YB1)
YB7 = NAND(YB4,B,YB2,YB1)
YB8 = NAND(A,B,YB2,YB1)
YB9 = NAND(YB4,YB3,C,YB1)
YB10 = NAND(A,YB3,C,YB1)
YB11 = NAND(YB4,B,C,YB1)
YB12 = NAND(A,B,C,YB1)
YB13 = NAND(YB4,YB3,YB2,D)
YB14 = NAND(A,YB3,YB2,D)
q0 = YB5
q1 = YB6
q2 = YB7
q3 = YB8
q4 = YB9
q5 = YB10
q6 = YB11
q7 = YB12
q8 = YB13
q9 = YB14

Na wejścia sieci będą podawane kolejne cyfry 0 ... 9 w kodzie BCD. Na wyjściu powinniśmy otrzymać kod 1 z 10 w logice ujemnej zgodnie z poniższą tabelką:
BCD Kod 1 z 10
D C B A q0 q1 q2 q3 q4 q5 q6 q7 q8 q9
0 0 0 0 0 1 1 1 1 1 1 1 1 1
0 0 0 1 1 0 1 1 1 1 1 1 1 1
0 0 1 0 1 1 0 1 1 1 1 1 1 1
0 0 1 1 1 1 1 0 1 1 1 1 1 1
0 1 0 0 1 1 1 1 0 1 1 1 1 1
0 1 0 1 1 1 1 1 1 0 1 1 1 1
0 1 1 0 1 1 1 1 1 1 0 1 1 1
0 1 1 1 1 1 1 1 1 1 1 0 1 1
1 0 0 0 1 1 1 1 1 1 1 1 0 1
1 0 0 1 1 1 1 1 1 1 1 1 1 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, int d)
{
    return !(a && b && c && d);
}


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

  // Stany wyjściowe bramek
  int YB1, YB2, YB3, YB4, YB5, YB6, YB7, YB8, YB9, YB10;
  int YB11,YB12,YB13,YB14;

  int i;

  cout << " D C B A | q0 q1 q2 q3 q4 q5 q6 q7 q8 q9\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 = NAND(YB4,YB3,YB2,YB1);
    YB6 = NAND(A,YB3,YB2,YB1);
    YB7 = NAND(YB4,B,YB2,YB1);
    YB8 = NAND(A,B,YB2,YB1);
    YB9 = NAND(YB4,YB3,C,YB1);
    YB10 = NAND(A,YB3,C,YB1);
    YB11 = NAND(YB4,B,C,YB1);
    YB12 = NAND(A,B,C,YB1);
    YB13 = NAND(YB4,YB3,YB2,D);
    YB14 = NAND(A,YB3,YB2,D);
    q0 = YB5;
    q1 = YB6;
    q2 = YB7;
    q3 = YB8;
    q4 = YB9;
    q5 = YB10;
    q6 = YB11;
    q7 = YB12;
    q8 = YB13;
    q9 = YB14;

    // Wyświetlamy wyniki

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

  return 0;
}
Wynik:  
 D C B A | q0 q1 q2 q3 q4 q5 q6 q7 q8 q9
---------+-------------------------------
 0 0 0 0 |  0  1  1  1  1  1  1  1  1  1
 0 0 0 1 |  1  0  1  1  1  1  1  1  1  1
 0 0 1 0 |  1  1  0  1  1  1  1  1  1  1
 0 0 1 1 |  1  1  1  0  1  1  1  1  1  1
 0 1 0 0 |  1  1  1  1  0  1  1  1  1  1
 0 1 0 1 |  1  1  1  1  1  0  1  1  1  1
 0 1 1 0 |  1  1  1  1  1  1  0  1  1  1
 0 1 1 1 |  1  1  1  1  1  1  1  0  1  1
 1 0 0 0 |  1  1  1  1  1  1  1  1  0  1
 1 0 0 1 |  1  1  1  1  1  1  1  1  1  0
D C B A q0 q1 q2 q3 q4 q5 q6 q7 q8 q9
0 0 0 0 0 1 1 1 1 1 1 1 1 1
0 0 0 1 1 0 1 1 1 1 1 1 1 1
0 0 1 0 1 1 0 1 1 1 1 1 1 1
0 0 1 1 1 1 1 0 1 1 1 1 1 1
0 1 0 0 1 1 1 1 0 1 1 1 1 1
0 1 0 1 1 1 1 1 1 0 1 1 1 1
0 1 1 0 1 1 1 1 1 1 0 1 1 1
0 1 1 1 1 1 1 1 1 1 1 0 1 1
1 0 0 0 1 1 1 1 1 1 1 1 0 1
1 0 0 1 1 1 1 1 1 1 1 1 1 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.

Symulator
Na początek:  podrozdziału   strony 

Spis elementów

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

SN7404 × 1
obrazek
SN7420 × 5
obrazek

Scalony konwerter kodu BCD na kod 1 z 10 - SN7442

Sieć logiczna konwertera wymaga zastosowania aż 6 układów scalonych TTL. To samo zadanie realizuje jeden układ scalonego konwertera BCD na kod 1 z 10 o symbolu SN7442. Schemat wyprowadzeń tego układu przedstawiamy poniżej.

obrazek

Ponieważ stanem aktywnym jest stan niski, to do wyjść konwertera podłączamy diody LED w sposób następujący:

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