Serwis Edukacyjny
Nauczycieli
w I-LO w Tarnowie

Do strony głównej I LO w Tarnowie

Materiały dla uczniów liceum

  Wyjście       Spis treści       Poprzedni       Następny  

©2018 mgr Jerzy Wałaszek
I LO w Tarnowie

Autor artykułu: mgr Jerzy Wałaszek
Konsultacje: Wojciech Grodowski, mgr inż. Janusz Wałaszek

 

 

Elementy

Układy kombinacyjne

 

Co to jest układ kombinacyjny

Układ kombinacyjny (ang. combinational logic) jest siecią logiczną zbudowaną z bramek cyfrowych, która realizuje pewną funkcję logiczną. Stan wyjść tej sieci zależy tylko od stanu jej wejść:

Układy kombinacyjne projektuje się za pomocą metod, które opisaliśmy w poprzednim rozdziale – szczególnie polecana jest tutaj metoda Karnaugha. W rozdziale omówimy podstawowe układy kombinacyjne, z którymi możesz się spotkać w technice cyfrowej. Wiele z nich produkowane jest w postaci gotowych do zastosowania układów scalonych.

 

Bramka programowana

Jako pierwszy układ kombinacyjny omówimy tzw. bramkę programowaną. Jest to sieć logiczna, której funkcję wybieramy za pomocą sygnałów sterujących.

Bramka będzie posiadała dwa wejścia danych A, B, dwa wejścia programujące funkcję F1, F0 oraz jedno wyjście Y:

W zależności od stanów na wejściach F1 i F0 bramka realizuje następujące funkcje logiczne:

F1 F0 Y
0 0 A AND B
0 1 A OR B
1 0 A NAND B
1 1 A NOR B

Układamy tabelkę stanów:

F1 F0 A B Y
0 0 0 0 0
0 0 0 1 0
0 0 1 0 0
0 0 1 1 1
0 1 0 0 0
0 1 0 1 1
0 1 1 0 1
0 1 1 1 1
1 0 0 0 1
1 0 0 1 1
1 0 1 0 1
1 0 1 1 0
1 1 0 0 1
1 1 0 1 0
1 1 1 0 0
1 1 1 1 0

Układamy mapę Karnaugha:

Na podstawie mapy wyprowadzamy funkcję:

Funkcję upraszczamy:

Na podstawie funkcji tworzymy sieć logiczną:

Testujemy się za pomocą programu w języku C:

Bramka Typ Wejścia
b1 NOT F1
b2 NOT F0
b3 NOT A
b4 NOT B
b5 OR A,B
b6 AND A,B
b7 AND b5,F0
b8 OR b7,b6
b9 AND b8,b1
b10 OR b4,b3
b11 AND b4,b3
b12 AND b10,b2
b13 OR b12,b11
b14 AND b13,F1
b15 (Y) OR b9,b14

 

/*
** SYMULACJA SIECI LOGICZNEJ
** (C)2018 mgr Jerzy Wałaszek
*/

#include <stdio.h>
#include <stdlib.h>

int main()
{
    // Sygnały wejściowe sieci
    int F1,F0,A,B;
    // Sygnał wyjściowy sieci
    int Y;
    // Bramki
    int b1,b2,b3,b4,b5,b6,b7,b8,b9,b10,
        b11,b12,b13,b14,b15;

    printf("Symulacja bramki programowanej\n");
    printf("------------------------------\n");
    printf("\n\n");
    printf("F1 F0  A  B  Y\n");
    printf("--------------\n");

    // Tworzymy środowisko pracy sieci
    for(F1 = 0; F1 < 2; F1++)          // Sygnał F1 0,1
        for(F0 = 0; F0 < 2; F0++)      // Sygnał F0 0,1
            for(A = 0; A < 2; A++)     // Sygnał A 0,1
                for(B = 0; B < 2; B++) // Sygnał B 0,1
                {
                    // Wyświetlamy sygnały wejściowe
                    printf(" %d  %d  %d  %d  ",F1,F0,A,B);

                    // Wyznaczamy wartości na wyjściach bramek sieci

                    b1  = !F1;
                    b2  = !F0;
                    b3  = !A;
                    b4  = !B;
                    b5  = A|B;
                    b6  = A&B;
                    b7  = b5&F0;
                    b8  = b7|b6;
                    b9  = b8&b1;
                    b10 = b4|b3;
                    b11 = b4&b3;
                    b12 = b10&b2;
                    b13 = b12|b11;
                    b14 = b13&F1;
                    Y = b15 = b9|b14;

                    // Wyświetlamy sygnał wyjściowy

                    printf("%d\n",Y);
                }
    printf("\n--- KONIEC SYMULACJI ---\n\n");
    return 0;
}

Tego typu układy znajdują się w mikrokontrolerach. Dzięki nim mikrokontroler potrafi wykonywać różne operacje nad danymi. Jeśli cię to zainteresowało, przeczytaj opis układu SN74181.

 

 

Kodery

Kodery (ang. coders) lub transkodery (ang. transcoders) są układami kombinacyjnymi, które przekształcają jeden kod binarny w inny kod binarny.

Kod NBC

Kodów binarnych jest bardzo dużo. Podstawowym jest naturalny kod binarny, NBC (ang. Natural Binary Code). Koduje on za pomocą bitów wartości liczbowe. Realizuje się to przypisując bitom wagi będące kolejnymi potęgami liczby 2. Dlatego często oznacza się ten kod symbolem 8421 (8 = 23, 4 = 22, 2 = 21 i 1 = 20). Wygląda to następująco:

Mamy 4 bity, które ponumerujemy od prawej do lewej kolejno: b3, b2, b1, b0. Numerki bitów będziemy nazywali pozycjami. Bitom na kolejnych pozycjach przypiszemy wagi, które będą równe liczbie 2 podniesionej do potęgi o wykładniku równym numerowi pozycji:
Wagi 23=8 22=4 21=2 20=1
Bity b3 b2 b1 b0
Pozycje 3 2 1 0

Bity mogą znajdować się w dwóch stanach: 0 lub 1. Wartość kodowanej liczby obliczamy jako sumę wag pozycji pomnożonych przez wartość bitów, które znajdują się na tych pozycjach:

Na przykład, mamy bity kolejno: 0111.

Zatem kod 0111 reprezentuje w naszym systemie dziesiętnym liczbę 7.

Ponieważ kod NBC pojawia się bardzo często, warto nauczyć się na pamięć wartości kodów 4-bitowych NBC lub zapamiętać sposób obliczania wartości tych kodów:

b3 b2 b1 b0 SUMA W
23=8 22=4 21=2 20=1    
0 0 0 0 0 0
0 0 0 1 1 1
0 0 1 0 2 2
0 0 1 1 2+1 3
0 1 0 0 4 4
0 1 0 1 4+1 5
0 1 1 0 4+2 6
0 1 1 1 4+2+1 7
1 0 0 0 8 8
1 0 0 1 8+1 9
1 0 1 0 8+2 10
1 0 1 1 8+2+1 11
1 1 0 0 8+4 12
1 1 0 1 8+4+1 13
1 1 1 0 8+4+2 14
1 1 1 1 8+4+1 15

Zwróć uwagę na budowę kodu NBC w tabelce. Jest to schemat rekurencyjny, który łatwo da się zapamiętać.

Jeśli kod NBC jest jednobitowy, to otrzymujemy tylko dwa słowa kodowe:

b0 SUMA W
20=1    
0 0 0
1 1 1

Jeśli dodamy kolejny bit, to dopisujemy go ze stanem 0 do wszystkich słów kodowych poprzedniego kodu i dopisujemy go ze stanem 1 do wszystkich słów kodowych poprzedniego kodu:

b1 b0 SUMA W
21=2 20=1    
0 0 0 0
0 1 1 1
1 0 2 2
1 1 2+1 3

Dla kolejnego bitu postępujemy podobnie:

b2 b1 b0 SUMA W
22=4 21=2 20=1    
0 0 0 0 0
0 0 1 1 1
0 1 0 2 2
0 1 1 2+1 3
1 0 0 4 4
1 0 1 4+1 5
1 1 0 4+2 6
1 1 1 4+2+1 7

 

Kod NBC można rozszerzyć na dowolną liczbę bitów. Zapamiętaj jedynie, że wagi kolejnych pozycji są kolejnymi potęgami liczby 2 (wykładnik potęgi jest równy numerowi pozycji):

Wagi 24=16 23=8 22=4 21=2 20=1
Bity b4 b3 b2 b1 b0
Pozycje 4 3 2 1 0

 

Wagi 25=32 24=16 23=8 22=4 21=2 20=1
Bity b5 b4 b3 b2 b1 b0
Pozycje 5 4 3 2 1 0

 

Wagi 27=128 26=64 25=32 24=16 23=8 22=4 21=2 20=1
Bity b7 b6 b5 b4 b3 b2 b1 b0
Pozycje 7 6 5 4 3 2 1 0

Przy obliczaniu wartości sumujemy tylko wagi pozycji, dla których bit ma wartość 1.

Na przykład kod 11110111 reprezentuje liczbę:

128 64 32 16 8 4 2 1    
1 1 1 1 0 1 1 1 =128+64+32+16+4+2+1 =247

Kod BCD

Drugim popularnym kodem jest BCD (ang. Binary Coded Decimal = kod dziesiętny kodowany dwójkowo).

W kodzie BCD kodowane są cyfry dziesiętne liczby za pomocą 4-bitowych słówek NBC. Brzmi zawile, lecz sprawa jest bardzo prosta. Zakodujmy w NBC liczbę dziesiętną 628. Każda cyfra dziesiętna potrzebuje 4 bitów, które przedstawiają jej wartość:

6 = 0110
2 = 0010
9 = 1001

I ostatecznie:

629(10) = 011000101001(NBC)

W drugą stronę jest również prosto. Na przykład kod BCD 100001110101 oznacza liczbę:

1000 0111 0101

1000 = 8
0111 = 7
0101 = 5

100001110101(NBC) = 875(10)

4-bitowe kody NBC mają wartości od 0 (0000) do 15 (1111). Kod BCD używa tylko wartości od 0 (0000) do 9 (1001). Pozostałe słówka kodu NBC (1010, 1011, 1100, 1101, 1110 i 1111) nie są używane (ponieważ nie reprezentują żadnej cyfry dziesiętnej).

Kody 1 z n

Są to kody n-bitowe. W słowie kodowym tylko jeden bit może przyjąć wartość 1. Pozostałe bity mają wartość 0. Położenie bitu 1 określa wartość słowa kodowego. Na przykład dla kodu 1 z 10 mamy:

1 z 10
0 1 2 3 4 5 6 7 8 9
1 0 0 0 0 0 0 0 0 0
0 1 0 0 0 0 0 0 0 0
0 0 1 0 0 0 0 0 0 0
0 0 0 1 0 0 0 0 0 0
0 0 0 0 1 0 0 0 0 0
0 0 0 0 0 1 0 0 0 0
0 0 0 0 0 0 1 0 0 0
0 0 0 0 0 0 0 1 0 0
0 0 0 0 0 0 0 0 1 0
0 0 0 0 0 0 0 0 0 1

Kod Gray'a

Kody Gray'a stosowane są przy pomiarach położenia lub kąta obrotu. Zaletą ich jest to, iż kolejne wyrazy różnią się od siebie tylko jednym bitem. Minimalizuje to ewentualne przekłamania pomiaru. Aby pokazać ci, o co tutaj chodzi, wyobraź sobie, iż masz układ pomiarowy, który zwraca wynik w postaci kodu NBC. Kolejne położenia są kodowane 3 bitami:

000 001 010 011 100 101 110 111
0 1 2 3 4 5 6 7

Jednakże z powodu niedokładności czujnika bity kodu nie zmieniają się jednocześnie, tylko mają pewne "luzy". Położenie przechodzi z 3 (011) na 4 (100). Jeśli zmiana bitów nie będzie jednoczesna, to na wyjściu czujnika chwilowo mogą w zasadzie pojawić się wszystkie pozostałe kody, np. kod 111 (pierwszy bit zmienił się na 1, lecz dwa pozostałe wciąż mają starą wartość). Otrzymamy przekłamanie położenia. Oczywiście można temu zapobiec za pomocą odpowiedniego oprogramowania, niemniej problem pozostaje. Kod Gray'a eliminuje tę niedogodność, sprowadzając ewentualne przekłamanie do 1 bitu, czyli położenia sąsiedniego.

Kodów Gray'a jest wiele. Podam tutaj kod Gray'a odzwierciedlony binarnie, zwany również kodem refleksyjnym.

Bity w kodzie Gray'a nie posiadają wag jak w kodzie NBC. Należy skonstruować słowa kodu. Robimy to rekurencyjnie, poczynając od słówek jednobitowych i dodając kolejne bity, aż otrzymamy kod Gray'a o założonej liczbie bitów.

Kod 1-bitowy Gray'a:

b0 W
0 0
1 1

 

Aby utworzyć kod o zwiększonej o 1 liczbie bitów, do słówek kodu dopisujemy na początku nowy bit o stanie 1, po czym odwracamy kolejność słówek i dopisujemy do nich bit o stanie 1:

Kod 2-bitowy Gray'a:

b1 b0 W
0 0 0
0 1 1
1 1 2
1 0 3

Dalej postępujemy podobnie:

Kod 3-bitowy Gray'a:

b2 b1 b0 W
0 0 0 0
0 0 1 1
0 1 1 2
0 1 0 3
1 1 0 4
1 1 1 5
1 0 1 6
1 0 0 7

Kod 4-bitowy Gray'a:

b3 b2 b1 b0 W
0 0 0 0 0
0 0 0 1 1
0 0 1 1 2
0 0 1 0 3
0 1 1 0 4
0 1 1 1 5
0 1 0 1 6
0 1 0 0 7
1 1 0 0 8
1 1 0 1 9
1 1 1 1 10
1 1 1 0 11
1 0 1 0 12
1 0 1 1 13
1 0 0 1 14
1 0 0 0 15

 

Zwróć uwagę na jedną z cech kodu Gray'a: pierwszy wyraz (0,00,000,0000...) i ostatni (1,10,100,1000...) również różnią się jednym bitem. Z tego powodu kod ten jest cykliczny.

Kod wyświetlacza 7-segmentowego

Do wyświetlania cyfr w technice cyfrowej używa się powszechnie wyświetlaczy 7-segmentowych (ang. 7-segment display).

Segmenty wyświetlacza są diodami LED lub ciekłymi kryształami. Numeracja segmentów jest następująca:

 

Wyświetlacze te umożliwiają wyświetlanie cyfr 0...9 oraz kilku liter alfabetu:

Kod wyświetlacza dla cyfr jest następujący (1 oznacza zapalony segment, 0 oznacza zgaszony segment):

Segmenty Cyfra
a b c d e f g
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 1 0 7
1 1 1 1 1 1 1 8
1 1 1 1 0 1 1 9

Transkoder kodu 421 na kod 1 z 8

W ramach ćwiczeń przedstawimy teraz sposób projektowania dwóch transkoderów.

Transkoder posiada 3 wejścia D4, D2, D1 oraz 8 wyjść 0, 1, 2, 3, 4, 5, 6, 7 i 8. Na wejścia podajemy 3-bitowy kod NBC. Na wyjściach otrzymujemy 8-bitowy kod 1 z 8.

 
Wejścia Wyjścia
D4 D2 D1 0 1 2 3 4 5 6 7
0 0 0 1 0 0 0 0 0 0 0
0 0 1 0 1 0 0 0 0 0 0
0 1 0 0 0 1 0 0 0 0 0
0 1 1 0 0 0 1 0 0 0 0
1 0 0 0 0 0 0 1 0 0 0
1 0 1 0 0 0 0 0 1 0 0
1 1 0 0 0 0 0 0 0 1 0
1 1 1 0 0 0 0 0 0 0 1

Tą sieć rozwiążemy metodą algebraiczną. Wyznaczamy funkcje logiczne poszczególnych wyjść:

Budujemy sieć logiczną:

Symulacja sieci w języku C:

Bramka Typ Wejścia
b1 NOT D4
b2 NOT D2
b3 NOT D1
b4 (0) AND3 b1,b2,b3
b5 (1) AND3 b1,b2,D1
b6 (2) AND3 b1,D2,b3
b7 (3) AND3 b1,D2,D1
b8 (4) AND3 D4,b2,b3
b9 (5) AND3 D4,b2,D1
b10 (6) AND3 D4,D2,b3
b11 (7) AND3 D4,D2,D1

 

/*
** SYMULACJA SIECI LOGICZNEJ
** (C)2018 mgr Jerzy Wałaszek
*/

#include <stdio.h>
#include <stdlib.h>

int main()
{
    // Sygnały wejściowe sieci
    int D1,D2,D4;
    // Sygnały wyjściowe sieci
    int O0,O1,O2,O3,O4,O5,O6,O7;
    // Bramki
    int b1,b2,b3,b4,b5,b6,b7,b8,b9,b10,b11;

    printf("Symulacja transkodera 421 na 1 z 8\n");
    printf("----------------------------------\n");
    printf("\n\n");
    printf("D4 D2 D1  0 1 2 3 4 5 6 7\n");
    printf("-------------------------\n");

    // Tworzymy środowisko pracy sieci
    for(D4 = 0; D4 < 2; D4++)         // sygnał D4 0,1
        for(D2 = 0; D2 < 2; D2++)     // sygnał D2 0,1
            for(D1 = 0; D1 < 2; D1++) // sygnał D1 0,1
            {
                // Wyświetlamy sygnały wejściowe D4, D2 i D1
                printf(" %d  %d  %d  ",D4,D2,D1);

                // Wyznaczamy wartości na wyjściach bramek sieci

                b1 = !D4;
                b2 = !D2;
                b3 = !D1;
                O0 = b4  = b1&b2&b3;
                O1 = b5  = b1&b2&D1;
                O2 = b6  = b1&D2&b3;
                O3 = b7  = b1&D2&D1;
                O4 = b8  = D4&b2&b3;
                O5 = b9  = D4&b2&D1;
                O6 = b10 = D4&D2&b3;
                O7 = b11 = D4&D2&D1;

                // Wyświetlamy sygnały wyjściowe

                printf("%d %d %d %d %d %d %d %d\n",O0,O1,O2,O3,O4,O5,O6,O7);
            }
    printf("\n--- KONIEC SYMULACJI ---\n\n");
    return 0;
}

Transkoder BCD na kod wskaźnika 7-segmentowego

Transkoder posiada 4 wejścia danych D8, D4, D2, D1 oraz 7 wyjść a,b,c,d,e,f,g. Na wejście podajemy cyfrę dziesiętną w kodzie BCD, na wyjściu otrzymujemy kod sterujący świeceniem segmentów we wskaźniku.

Cyfra Wejścia Wyjścia
D8 D4 D2 D1 a b c d e f g
0 0 0 0 0 1 1 1 1 1 1 0
1 0 0 0 1 0 1 1 0 0 0 0
2 0 0 1 0 1 1 0 1 1 0 1
3 0 0 1 1 1 1 1 1 0 0 1
4 0 1 0 0 0 1 1 0 0 1 1
5 0 1 0 1 1 0 1 1 0 1 1
6 0 1 1 0 1 0 1 1 1 1 1
7 0 1 1 1 1 1 1 0 0 1 0
8 1 0 0 0 1 1 1 1 1 1 1
9 1 0 0 1 1 1 1 1 0 1 1
  1 0 1 0 X X X X X X X
  1 0 1 1 X X X X X X X
  1 1 0 0 X X X X X X X
  1 1 0 1 X X X X X X X
  1 1 1 0 X X X X X X X
  1 1 1 1 X X X X X X X

Zadanie rozwiążemy za pomocą map Karnaugha, wyznaczając funkcje logiczne dla każdego sygnału wyjściowego.

a:

b:

c:

d:

e:

f:

  g:

 

Tworzymy sieć logiczną:

Testujemy sieć za pomocą programu w języku C:

Bramka Typ Wejścia
b1 NOT D8
b2 NOT D4
b3 NOT D2
b4 NOT D1
b5 AND b1,b2,b4
b6 AND D4,D1
b7 (a) OR b5,D2,D8,b6
b8 AND b3,b4
b9 AND D2,D1
b10 (b) OR b8,b2,b9
b11 (c) OR b3,D1,D4
b12 OR b4,D2
b13 AND D2,b4
b14 AND D4,b3,D1
b15 AND b12,b2
b16 (d) OR b15,b13,b14,D8
b17 AND b2,b4
b18 (e) OR b13,b17
b19 (f) OR b8,D4,D8
b20 AND b2,D2
b21 AND D4,b3
b22 (g) OR b20,b13,b21,D8

 

/*
** SYMULACJA SIECI LOGICZNEJ
** (C)2018 mgr Jerzy Wałaszek
*/

#include <stdio.h>
#include <stdlib.h>

int main()
{
    // Sygnały wejściowe sieci
    int D1,D2,D4,D8;
    // Sygnały wyjściowe sieci
    int a,b,c,d,e,f,g;
    // Bramki
    int b1,b2,b3,b4,b5,b6,b7,b8,b9,b10,
        b11,b12,b13,b14,b15,b16,b17,b18,
        b19,b20,b21,b22;

    printf("Symulacja transkodera BCD na kod wskaznika 7-segmentowego\n");
    printf("---------------------------------------------------------\n");
    printf("\n\n");
    printf("D8 D4 D2 D1  a b c d e f g\n");
    printf("--------------------------\n");

    // Tworzymy środowisko pracy sieci
    for(D8 = 0; D8 < 2; D8++)             // Sygnał D8 0,1
        for(D4 = 0; D4 < 2; D4++)         // Sygnał D4 0,1
            for(D2 = 0; D2 < 2; D2++)     // Sygnał D2 0,1
                for(D1 = 0; D1 < 2; D1++) // Sygnał D1 0,1
                {
                    // Wyświetlamy sygnały wejściowe D7, D4, D2 i D1
                    printf(" %d  %d  %d  %d  ",D8,D4,D2,D1);

                    // Wyznaczamy wartości na wyjściach bramek sieci

                    b1  = !D8;
                    b2  = !D4;
                    b3  = !D2;
                    b4  = !D1;
                    b5  = b1&b2&b4;
                    b6  = D4&D1;
                    a   = b7 = b5|D2|D8|b6;
                    b8  = b3&b4;
                    b9  = D2&D1;
                    b   = b10 = b8|b2|b9;
                    c   = b11 = b3|D1|D4;
                    b12 = b4|D2;
                    b13 = D2&b4;
                    b14 = D4&b3&D1;
                    b15 = b12&b2;
                    d   = b16 = b15|b13|b14|D8;
                    b17 = b2&b4;
                    e   = b18 = b13|b17;
                    f   = b19 = b8|D4|D8;
                    b20 = b2&D2;
                    b21 = D4&b3;
                    g   = b22 = b20|b13|b21|D8;

                    // Wyświetlamy sygnały wyjściowe

                    printf("%d %d %d %d %d %d %d\n",a,b,c,d,e,f,g);
                }
    printf("\n--- KONIEC SYMULACJI ---\n\n");
    return 0;
}

Tego typu transkodery są produkowane w postaci pojedynczych układów scalonych:

 

 

Multipleksery

Multiplekser (ang. multiplexer, mux) jest układem posiadającym n wejść danych D, m wejść wybierających A oraz jedno wyjście Y:

Działanie układu jest bardzo proste:

Na wejścia wybierające A podajemy adres dwójkowy jednego z wejść D. Wtedy na wyjściu Y pojawia się stan wybranego wejścia.

Dla przykładu zaprojektujmy multiplekser dwuwejściowy:

 
S A B Y
0 0 X 0
0 1 X 1
1 X 0 0
1 X 1 1

Jeśli na wejściu wybierającym S panuje stan niski 0, to na wyjściu Y mamy stan wejścia A. Jeśli zmienimy stan wejścia wybierającego S na wysoki 1, to na wyjściu Y pojawi się stan wejścia B.

Układamy mapę Karnaugha dla wyjścia Y:

Funkcja logiczna:

Sieć logiczna:

Jako ćwiczenie sprawdź działanie tej sieci programem w języku C.

Multipleksey są produkowane w postaci gotowych układów scalonych:

Multipleksery stosuje się często do odczytu stanu wielu linii wejścia, np. z klawiatury. Pozwalają one zaoszczędzić wiele portów mikrokontrolera. Np. układ SN74150 jest multiplekserem 16 kanałowym:

Do wejść E podłączasz sygnały, które chcesz odczytywać, następnie na wejściach A...D (D zawiera najstarszy bit adresu) umieszczasz adres wejścia E i stan wejścia odczytujesz z wyjścia W, tutaj będzie zanegowany. Wejście G należy połączyć z masą, aby układ był uaktywniony. W sumie potrzebujesz tylko 5 portów do sterowania tym układem, a bez niego potrzebowałbyś 16 portów. Widzisz zysk?

 

Demultipleksery

Demultiplekser jest układem o odwrotnej funkcji do multipleksera. Posiada jedno wejście danych D, m wejść wybierających A oraz n wyjść Y:

Zasada działania jest następująca:

Na wejściach wybierających A umieszczamy dwójkową liczbę określającą jedno z wyjść Y. Wtedy na wybranym wyjściu pojawia się stan z wejścia D. Na pozostałych wyjściach Y panuje stan nieaktywny.

Zaprojektujmy 2-kanałowy demultiplekser:

 
S D Y1 Y0
0 0 0 0
0 1 0 1
1 0 0 0
1 1 1 0

Jeśli na wejściu wybierającym S panuje stan niski 0, to na wyjściu Y0 jest stan wejścia D. Jeśli S przyjmuje stan wysoki 1, to na wyjściu Y1 pojawi się stan wejścia D. Na wyjściu niewybranym panuje stan nieaktywny 0.

Tworzymy mapy Karnaugha dla obu wyjść:

Y0:

  Y1:

 

Sieć logiczna:

Sprawdź działanie tej sieci za pomocą programu w języku C.

Przemysł elektroniczny produkuje scalone demultipleksery w różnych konfiguracjach, np.:

 

 

Komparatory

Komparator jest układem, który porównuje ze sobą dwa słowa binarne. Porównanie może ograniczać się jedynie do stwierdzenia, iż oba słowa są takie same lub różne. Istnieją również komparatory, które traktują porównywane słowa jako liczby. W takim przypadku generowana jest dodatkowo informacja o  tym, która z tych liczb jest większa, a która mniejsza:

Działanie jest następujące:

Na wejściach A i B umieszczamy n-bitowe liczby dwójkowe.

Na wyjściu A < B otrzymujemy stan 1, jeśli liczba A jest mniejsza od liczby B. W przeciwnym razie na wyjściu tym jest stan 0.

Na wyjściu A = B otrzymujemy stan 1, jeśli liczba A jest równa liczbie B. W przeciwnym razie na wyjściu tym jest stan 0.

Na wyjściu A > B otrzymujemy stan 1, jeśli liczba A jest większa od liczby B. W przeciwnym razie na wyjściu tym jest stan 0.

Dla przykładu zaprojektujmy komparator 2-bitowy:

 
A1 A0 B1 B0 A<B A=B A>B
0 0 0 0 0 1 0
0 0 0 1 1 0 0
0 0 1 0 1 0 0
0 0 1 1 1 0 0
0 1 0 0 0 0 1
0 1 0 1 0 1 0
0 1 1 0 1 0 0
0 1 1 1 1 0 0
1 0 0 0 0 0 1
1 0 0 1 0 0 1
1 0 1 0 0 1 0
1 0 1 1 1 0 0
1 1 0 0 0 0 1
1 1 0 1 0 0 1
1 1 1 0 0 0 1
1 1 1 1 0 1 0

Układamy mapy Karnaugha dla poszczególnych wyjść komparatora:

A<B

A=B

A>B

Sieć logiczna komparatora:

Test sieci za pomocą programu w języku C:

Bramka Typ Wejścia
b1 NOT A1
b2 NOT A0
b3 NOT B1
b4 NOT B0
b5 OR b1,B1
b6 AND b1,B1
b7 AND b5,b2,B0
b8 (A<B) OR b7,b6
b9 AND b2,b4
b10 AND A0,B0
b11 AND b1,b3
b12 AND A1,B1
b13 OR b9,b10
b14 OR b11,b12
b15 (A=B) AND b13,b14
b16 OR b3,A1
b17 AND A1,b3
b18 AND b16,A0,b4
b19 (A>B) OR b18,b17

 

/*
** SYMULACJA SIECI LOGICZNEJ
** (C)2018 mgr Jerzy Wałaszek
*/

#include <stdio.h>
#include <stdlib.h>

int main()
{
    // Sygnały wejściowe sieci
    int A1,A0,B1,B0;
    // Sygnał wyjściowy sieci
    int ALB,AEB,AGB;
    // Bramki
    int b1,b2,b3,b4,b5,b6,b7,b8,b9,b10,
        b11,b12,b13,b14,b15,b16,b17,b18,b19;

    printf("Symulacja komparatora 2-bitowego\n");
    printf("--------------------------------\n");
    printf("\n\n");
    printf("A1 A0 B1 B0 A<B A=B A>B\n");
    printf("-----------------------\n");

    // Tworzymy środowisko pracy sieci
    for(A1 = 0; A1 < 2; A1++)             // Sygnał A1 0,1
        for(A0 = 0; A0 < 2; A0++)         // Sygnał A0 0,1
            for(B1 = 0; B1 < 2; B1++)     // Sygnał B1 0,1
                for(B0 = 0; B0 < 2; B0++) // Sygnał B0 0,1
                {
                    // Wyświetlamy sygnały wejściowe
                    printf(" %d  %d  %d  %d  ",A1,A0,B1,B0);

                    // Wyznaczamy wartości na wyjściach bramek sieci

                    b1 = !A1;
                    b2 = !A0;
                    b3 = !B1;
                    b4 = !B0;
                    b5 = b1|B1;
                    b6 = b1&B1;
                    b7 = b5&b2&B0;
                    ALB = b8 = b7|b6;
                    b9 = b2&b4;
                    b10 = A0&B0;
                    b11 = b1&b3;
                    b12 = A1&B1;
                    b13 = b9|b10;
                    b14 = b11|b12;
                    AEB = b15 = b13&b14;
                    b16 = b3|A1;
                    b17 = A1&b3;
                    b18 = b16&A0&b4;
                    AGB = b19 = b18|b17;

                    // Wyświetlamy sygnały wyjściowe

                    printf("%d   %d   %d\n",ALB,AEB,AGB);
                }
    printf("\n--- KONIEC SYMULACJI ---\n\n");
    return 0;
}

Produkowany jest układ  SN7485, który zawiera komparator 4-bitowy:

Oprócz wejść A i B komparator posiada również wejścia wyników porównania z poprzedniej kaskady. Umożliwia to tworzenie komparatorów liczb binarnych o większej niż 4 ilości bitów:

 

 

 

Sumatory

Sumator (ang. adder) jest układem arytmetycznym, który wykonuje operację dodawania dwójkowego. Tabliczka dodawania w systemie dwójkowym jest bardzo prosta:
0 + 0 = 0
0 + 1 = 1
1 + 0 = 1
1 + 1 = 10

Zasady dodawania są identyczne jak w naszym systemie dziesiętnym. Dla przykładu dodajmy dwie liczby dwójkowe 1101 i 1011. Zapisujemy je słupku i ostatnią podkreślamy:

  1 1 0 1
+ 1 0 1 1
         

Dodawanie rozpoczynamy od ostatnich cyfr obu liczb i posuwamy się w lewą stronę, dodając do siebie kolejne cyfry. Jeśli wynik jest dwucyfrowy (1 + 1 = 10), to pod kreską zapisujemy ostatnią cyfrę, a pierwszą cyfrę zapisujemy ponad kolejną cyfra pierwszej liczby. Jest to tzw. przeniesienie (ang. carry), które musi zostać dodane do wyniku sumowania cyfr następnej kolumny.

Sumujemy ostatnie dwie cyfry: 1 + 1 = 0 i 1 przeniesienia

      1  
  1 1 0 1
+ 1 0 1 1
        0

Sumujemy kolejne cyfry: 0 + 1 = 1 + przeniesienie = 0 i 1 przeniesienia

    1 1  
  1 1 0 1
+ 1 0 1 1
      0 0

Sumujemy kolejne cyfry: 1 + 0 = 1 + przeniesienie = 0 i 1 przeniesienia

  1 1 1  
  1 1 0 1
+ 1 0 1 1
    0 0 0

Sumujemy kolejne cyfry: 1 + 1 = 0 i 1 przeniesienia + przeniesienie = 1 i 1 przeniesienia

1 1 1 1  
  1 1 0 1
+ 1 0 1 1
  1 0 0 0

Cyfry obu liczb skończyły się, ale pozostało nam przeniesienie równe 1. Przepisujemy je do wyniku (możemy potraktować tę kolumnę tak, jakby obie liczby miały tu cyfry zero):

  1 1 1 1  
  0 1 1 0 1
+ 0 1 0 1 1
  1 1 0 0 0

Dostajemy wynik: 1101 + 1011 = 11000. Sprawdźmy, czy wynik jest poprawny:

1101 = 8 + 4 + 1 = 13
1011 = 8 + 2 + 1 = 11
11000 = 16 + 8 = 24

Nie może być inaczej – wynik dodawania nie zależy od systemu liczbowego, w którym wykonujemy dodawanie, lecz od wartości dodawanych liczb.

Dla przykładu zaprojektujemy sumator jednobitowy:

 
Ci A B Y Co
0 0 0 0 0
0 0 1 1 0
0 1 0 1 0
0 1 1 0 1
1 0 0 1 0
1 0 1 0 1
1 1 0 0 1
1 1 1 1 1

Ci jest przeniesieniem z poprzedniej kaskady sumującej. Pozwala to łączyć sumatory w szereg i wykonywać sumowanie dla liczb wielobitowych.

A i B to sumowane bity.

Y jest wynikiem sumowania.

Co jest wyjściem przeniesienia.

Układamy mapy Karnaugha dla Y i Co:

Y

Co

Budujemy sieć:

Testujemy sieć za pomocą programu w języku C:

Bramka Typ Wejścia
b1 NOT Ci
b2 NOT A
b3 NOT B
b4 AND b2,B
b5 AND A,b3
b6 OR b4,b5
b7 AND b6,b1
b8 AND b2,b3
b9 AND A,B
b10 OR b8,b9
b11 AND b10,Ci
b12 (Y) OR b7,b11
b13 OR B,A
b14 AND b13,Ci
b15 (Co) OR b9,b14

 

/*
** SYMULACJA SIECI LOGICZNEJ
** (C)2018 mgr Jerzy Wałaszek
*/

#include <stdio.h>
#include <stdlib.h>

int main()
{
    // Sygnały wejściowe sieci
    int A,B,Ci;
    // Sygnały wyjściowe sieci
    int Co,Y;
    // Bramki
    int b1,b2,b3,b4,b5,b6,b7,b8,b9,b10,
        b11,b12,b13,b14,b15;

    printf("Symulacja sumatora 1-bitowego\n");
    printf("-----------------------------\n");
    printf("\n\n");
    printf("Ci A B Y Co\n");
    printf("-----------------------\n");

    // Tworzymy środowisko pracy sieci
    for(Ci = 0; Ci < 2; Ci++)          // Sygnał Ci 0,1
        for(A = 0; A < 2; A++)         // Sygnał A 0,1
            for(B = 0; B < 2; B++)     // Sygnał B 0,1
            {
                // Wyświetlamy sygnały wejściowe
                printf(" %d %d %d ",Ci,A,B);

                // Wyznaczamy wartości na wyjściach bramek sieci

                b1 = !Ci;
                b2 = !A;
                b3 = !B;
                b4 = b2&B;
                b5 = A&b3;
                b6 = b4|b5;
                b7 = b6&b1;
                b8 = b2&b3;
                b9 = A&B;
                b10 = b8|b9;
                b11 = b10&Ci;
                Y = b12 = b7|b11;
                b13 = B|A;
                b14 = b13&Ci;
                Co = b15 = b9|b14;

                // Wyświetlamy sygnały wyjściowe

                printf("%d %d\n",Y,Co);
            }
    printf("\n--- KONIEC SYMULACJI ---\n\n");
    return 0;
}

W handlu można spotkać następujące sumatory scalone:

Zespół Przedmiotowy
Chemii-Fizyki-Informatyki

w I Liceum Ogólnokształcącym
im. Kazimierza Brodzińskiego
w Tarnowie
ul. Piłsudskiego 4
©2018 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.