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.

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.

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:

Realizacja funkcji wyjściowych q_i jest bardzo prosta i nie musimy posiłkować się tabelami Karnaugha. Każde wyjście q_i 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:

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

Teraz realizujemy funkcje poszczególnych wyjść:

...

Numerujemy bramki:

Definiujemy połączenia:

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ą:

// 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,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;
}

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.

Obciążenia wnoszone przez poszczególne wejścia:

A - 5, B - 5, C - 5, D - 3.

SN7404 × 1

SN7420 × 5

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.

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