Bity w elektronice
Licznik rewersyjny


Bramki logiczne
Cyfrowe układy scalone TTL i CMOS
Zasilanie układów TTL i CMOS
Układy kombinatoryczne z bramek cyfrowych
Przerzutniki
  Zastosowania
Przerzutnik RS
Przerzutnik D
Przerzutnik J-K
Licznik asynchroniczny
Licznik synchroniczny
Licznik rewersyjny
Rejestr
Rejestr przesuwający

 

Licznik rewersyjny (ang. reverse counter) można zbudować jako asynchroniczny (ang. ripple reverse counter) lub synchroniczny (synchronous reverse counter). Samo zliczanie wstecz jest dosyć proste do uzyskania - wystarczy pobierać sygnał z komplementarnych wyjść Q przerzutników T w liczniku asynchronicznym. Zanegowane stany wyjść pracują właśnie jako licznik rewersyjny.

Przyjrzyjmy się poniższej tabelce:

 

Wyjścia normalne Wyjścia zanegowane
Stan QD QC QB QA QD QC QB QA Stan
0 0 0 0 0 1 1 1 1 15
1 0 0 0 1 1 1 1 0 14
2 0 0 1 0 1 1 0 1 13
3 0 0 1 1 1 1 0 0 12
4 0 1 0 0 1 0 1 1 11
5 0 1 0 1 1 0 1 0 10
6 0 1 1 0 1 0 0 1 9
7 0 1 1 1 1 0 0 0 8
8 1 0 0 0 0 1 1 1 7
9 1 0 0 1 0 1 1 0 6
10 1 0 1 0 0 1 0 1 5
11 1 0 1 1 0 1 0 0 4
12 1 1 0 0 0 0 1 1 3
13 1 1 0 1 0 0 1 0 2
14 1 1 1 0 0 0 0 1 1
15 1 1 1 1 0 0 0 0 0

Stan 0 uzyskamy wykorzystując wejście PRE (PRESET - ustwianie Q na 1) zamiast CLR (CLEAR - ustawianie Q na 0) (patrz tabelka).

Rozważania te sugerują następujący układ pracy asynchronicznego licznika rewersyjnego:

 

 

 

 

 

Synchroniczny licznik rewersyjny można oprzeć na tej samej zasadzie lub zaprojektować go od podstaw wyznaczając funkcje przełączające T dla przerzutników J-K. Zastosujemy tę drugą metodę.

Kolejne stany licznika Funkcje przełączające
Stan QD QC QB QA TD TC TB TA
0 0 0 0 0 1 1 1 1
15 1 1 1 1 0 0 0 1
14 1 1 1 0 0 0 1 1
13 1 1 0 1 0 0 0 1
12 1 1 0 0 0 1 1 1
11 1 0 1 1 0 0 0 1
10 1 0 1 0 0 0 1 1
9 1 0 0 1 0 0 0 1
8 1 0 0 0 1 1 1 1
7 0 1 1 1 0 0 0 1
6 0 1 1 0 0 0 1 1
5 0 1 0 1 0 0 0 1
4 0 1 0 0 0 1 1 1
3 0 0 1 1 0 0 0 1
2 0 0 1 0 0 0 1 1
1 0 0 0 1 0 0 0 1

Na podstawie tabelki pożądanych stanów licznika wyznaczamy sygnały przełączające TX dla poszczególnych przerzutników. Sygnał TX ma wartość zero, gdy przerzutnik X nie musi być przełączony przy przejściu do kolejnego stanu licznika i 1, gdy przerzutnik należy przełączyć w stan przeciwny.

Wartości poszczególnych funkcji przełączających można wyprowadzić po krótkiej analizie tabelki lub wykorzystując tablice Karnaugha. Ja wybrałem ten pierwszy sposób:

 

 

 

Zwróć uwagę, iż poszczególne sygnały przełączające tworzą regularny ciąg (porównaj go z ciągiem funkcji przełączających dla licznika synchronicznego zliczającego w przód).

Funkcje przełączające TX sterują wejściami J i K poszczególnych przerzutników wchodzących w skład sieci logicznej licznika. Poniżej przedstawiamy symulację takiej sieci. Wejście zegarowe C jest wejściem impulsowym. Kliknięcie go powoduje przejście licznika do następnego stanu. Stany wyjściowe licznika zmieniają się synchronicznie z opadającym zboczem sygnału zegarowego.

 

Otrzymana sieć logiczna jest równoważna sieci licznika synchronicznego z zanegowanymi wyjściami QA...QD.

 

Licznik modulo 10 zliczający w górę i w dół

Wykorzystując opisaną metodę projektowania liczników synchronicznych przez określanie funkcji przełączających TX można konstruować dowolne układy sekwencyjne, tzn. takie, które w takt kolejnych impulsów zegarowych generują dowolne kody binarne. Aby to udowodnić, zaprojektujemy licznik zliczający w dół  i w górę modulo 10 (jest to tzw. rewersyjny synchroniczny licznik BCD). Do sterowania kierunkiem zliczania będzie wymagany dodatkowy sygnał P. Umówmy się, iż dla P = 1 licznik zlicza w górę od 0 do 9, czyli jest normalnym licznikiem synchronicznym modulo 10, a dla P = 0 licznik staje się licznikiem rewersyjnym, zliczającym w dół od 9 do 0. Ułóżmy tabelkę stanów licznika wraz z sygnałami przełączającymi TX dla przerzutników:

 

P = 1
Kolejne stany licznika Funkcje przełączające
Stan QD QC QB QA TD TC TB TA
0 0 0 0 0 0 0 0 1
1 0 0 0 1 0 0 1 1
2 0 0 1 0 0 0 0 1
3 0 0 1 1 0 1 1 1
4 0 1 0 0 0 0 0 1
5 0 1 0 1 0 0 1 1
6 0 1 1 0 0 0 0 1
7 0 1 1 1 1 1 1 1
8 1 0 0 0 0 0 0 1
9 1 0 0 1 1 0 0 1
0 0 0 0 0  
P = 0
Kolejne stany licznika Funkcje przełączające
Stan QD QC QB QA TD TC TB TA
0 0 0 0 0 1 0 0 1
9 1 0 0 1 0 0 0 1
8 1 0 0 0 1 1 1 1
7 0 1 1 1 0 0 0 1
6 0 1 1 0 0 0 1 1
5 0 1 0 1 0 0 0 1
4 0 1 0 0 0 1 1 1
3 0 0 1 1 0 0 0 1
2 0 0 1 0 0 0 1 1
1 0 0 0 1 0 0 0 1
0 0 0 0 0  

 

Na podstawie tej tabelki wyznaczamy funkcje przełączające TX wykorzystując mapy Karnaugha.

 

Sygnał TA

Z tym sygnałem nie ma problemów, gdyż z prostej analizy tabelki wynika, iż:

 

Sygnał TB

Obszar TB1
00 01 11 10
000 0 0 0 1
001 1 0 0 1
011 X X X X
010 1 0 X X
110 0 0 X X
111 X X X X
101 0 1 1 0
100 0 1 1 0
Obszar TB2
00 01 11 10
000 0 0 0 1
001 1 0 0 1
011 X X X X
010 1 0 X X
110 0 0 X X
111 X X X X
101 0 1 1 0
100 0 1 1 0
Obszar TB3
00 01 11 10
000 0 0 0 1
001 1 0 0 1
011 X X X X
010 1 0 X X
110 0 0 X X
111 X X X X
101 0 1 1 0
100 0 1 1 0
Obszar TB4
00 01 11 10
000 0 0 0 1
001 1 0 0 1
011 X X X X
010 1 0 X X
110 0 0 X X
111 X X X X
101 0 1 1 0
100 0 1 1 0
         

 

Sygnał TC

Obszar TC1
00 01 11 10
000 0 0 0 0
001 1 0 0 0
011 X X X X
010 1 0 X X
110 0 0 X X
111 X X X X
101 0 0 1 0
100 0 0 1 0
Obszar TC1
00 01 11 10
000 0 0 0 0
001 1 0 0 0
011 X X X X
010 1 0 X X
110 0 0 X X
111 X X X X
101 0 0 1 0
100 0 0 1 0
Obszar TC1
00 01 11 10
000 0 0 0 0
001 1 0 0 0
011 X X X X
010 1 0 X X
110 0 0 X X
111 X X X X
101 0 0 1 0
100 0 0 1 0
         

 

Sygnał TD

Obszar TD1
00 01 11 10
000 1 0 0 0
001 0 0 0 0
011 X X X X
010 1 0 X X
110 0 1 X X
111 X X X X
101 0 0 1 0
100 0 0 0 0
Obszar TD2
00 01 11 10
000 1 0 0 0
001 0 0 0 0
011 X X X X
010 1 0 X X
110 0 1 X X
111 X X X X
101 0 0 1 0
100 0 0 0 0
Obszar TD3
00 01 11 10
000 1 0 0 0
001 0 0 0 0
011 X X X X
010 1 0 X X
110 0 1 X X
111 X X X X
101 0 0 1 0
100 0 0 0 0
Obszar TD4
00 01 11 10
000 1 0 0 0
001 0 0 0 0
011 X X X X
010 1 0 X X
110 0 1 X X
111 X X X X
101 0 0 1 0
100 0 0 0 0
         

 

Podsumujmy:

 

 

Ponieważ otrzymane funkcje logiczne są nieco skomplikowane, sprawdzimy je w prostym programie symulacyjnym w języku C++.

 

// Test funkcji przełączających dla licznika synchronicznego 
//      zliczającego wprzód i wstecz modulo dziesięć
//----------------------------------------------------------
// (C)2007 mgr Jerzy Wałaszek I-LO w Tarnowie
//----------------------------------------------------------

#include <iostream>

using namespace std;

int main()
{
  int P,QA,QB,QC,QD,TB,TC,TD,i,i0;
  
  cout << " P QD QC QB QA TD TC TB TA | P QD QC QB QA TD TC TB TA\n"
          "---------------------------+---------------------------\n";
  for(i0 = i = 0; i < 10; i++)
  {
    QD = (i&8) > 0;
    QC = (i&4) > 0;
    QB = (i&2) > 0;
    QA = (i&1);
    P = 1;
    TB = !(!(!P&&!QA&&!(!QB&&!QC&&!QD))&&!(P&&QA&&!QD));
    TC = !(!(!P&&!QA&&!(!(QC&&!QB)&&!QD))&&!(P&&QB&&QA));
    TD = !(!(!P&&!QA&&!(!(!QD&&!QC&&!QB)&&!QD))&&!(P&&QA&&!(!QD&&!(QC&&QB))));
    cout << " 1  " << QD << "  " << QC << "  " << QB << "  " << QA
         <<   "  " << TD << "  " << TC << "  " << TB << "  1 | 0  ";
    P = 0;         
    QD = (i0&8) > 0;
    QC = (i0&4) > 0;
    QB = (i0&2) > 0;
    QA = (i0&1);
    P = 0;
    TB = !(!(!P&&!QA&&!(!QB&&!QC&&!QD))&&!(P&&QA&&!QD));
    TC = !(!(!P&&!QA&&!(!(QC&&!QB)&&!QD))&&!(P&&QB&&QA));
    TD = !(!(!P&&!QA&&!(!(!QD&&!QC&&!QB)&&!QD))&&!(P&&QA&&!(!QD&&!(QC&&QB))));
    cout << QD << "  " << QC << "  " << QB << "  " << QA << "  "
         << TD << "  " << TC << "  " << TB << "  1\n";
    if(!i0) i0 = 9; else i0--;
  }
  cout << endl;
  return 0;
}
 P QD QC QB QA TD TC TB TA | P QD QC QB QA TD TC TB TA
---------------------------+--------------------------
 1  0  0  0  0  0  0  0  1 | 0  0  0  0  0  1  0  0  1
 1  0  0  0  1  0  0  1  1 | 0  1  0  0  1  0  0  0  1
 1  0  0  1  0  0  0  0  1 | 0  1  0  0  0  1  1  1  1
 1  0  0  1  1  0  1  1  1 | 0  0  1  1  1  0  0  0  1
 1  0  1  0  0  0  0  0  1 | 0  0  1  1  0  0  0  1  1
 1  0  1  0  1  0  0  1  1 | 0  0  1  0  1  0  0  0  1
 1  0  1  1  0  0  0  0  1 | 0  0  1  0  0  0  1  1  1
 1  0  1  1  1  1  1  1  1 | 0  0  0  1  1  0  0  0  1
 1  1  0  0  0  0  0  0  1 | 0  0  0  1  0  0  0  1  1
 1  1  0  0  1  1  0  0  1 | 0  0  0  0  1  0  0  0  1

 

Wynik działania programu jest w pełni zgodny z tabelką sygnałów przełączających, zatem wyprowadzone funkcje są poprawne i możemy rozpocząć budowę sieci logicznej licznika. Poniżej przedstawiamy symulację takiej sieci. Licznik posiada trzy wejścia - wybór trybu pracy P, zegarowe C działające impulsowo i asynchroniczne wejście zerowania CLR.

 

 

Liczniki synchroniczne są produkowane w postaci gotowych układów cyfrowych. Poniżej przedstawiamy najpopularniejsze synchroniczne liczniki rewersyjne dwójkowe i binarne wchodzące w skład serii SN74.

 

SN74190 - synchroniczny licznik rewersyjny BCD
SN74191 - synchroniczny licznik rewersyjny binarny

Układy scalone SN74190 i SN74191 są synchronicznymi licznikami rewersyjnymi pracującymi w kodach binarnym 8421 (SN74191) i BCD (SN74190). Liczniki posiadają wejścia programujące A,B,C i D, które można wykorzystywać do do ustalania wstępnego stanu liczników. Dane z tych wejść są asynchronicznie przepisywane do przerzutników J-K przy ustawieniu wejścia LOAD w stan 0.

Przerzutniki J-K tworzące licznik zmieniają swój stan przy przejściu sygnału zegarowego ze stanu niskiego w wysoki - zwróć uwagę na oznaczenie wejścia taktującego. Licznik zlicza impulsy zegarowe przy stanie niskim wejścia CTEN. Gdy wejście to przyjmie stan wysoki, zliczanie jest zablokowane. Kierunek zliczania określa stan wejścia D/U (ang. Down/Up). Przy stanie wysokim licznik zlicza w dół, a przy stanie niskim w górę.

Wyjścia RCO (ang. Ripple Carry Output - wyjście przeniesienia kaskadowego) oraz MAX/MIN umożliwiają podłączenie kolejnych scalonych liczników SN74190/1. Wyjście RCO generuje ujemny impuls o czasie trwania porównywalnym z ujemnym impulsem zegarowym przy powstaniu przeniesienia (zliczanie w górę) lub pożyczki (zliczanie w dół). Wyjście RCO łączy się z wejściem CTEN następnego licznika przy równoległym taktowaniu liczników sygnałem zegarowym lub z wejściem CLK następnego licznika. Wyjście MAX/MIN generuje dodatni impuls o czasie trwania równym pełnemu okresowi sygnału zegarowego przy zaistnieniu warunku przepełnienia lub niedopełnienia licznika. Wyjście to używane jest przez układy generacji równoległych przeniesień. Odpowiednie informacje na ten temat znajdziesz w materiałach producentów.

 

SN74192 - synchroniczny licznik rewersyjny BCD
SN74193 - synchroniczny licznik rewersyjny binarny

Dwa kolejne układy SN74192 i SN74193 są również synchronicznymi licznikami rewersyjnymi BCD (SN74192) i binarnymi (SN74193). Od powyżej opisanych synchronicznych liczników rewersyjnych różnią się one sygnałami wejściowymi i wyjściowymi.

Licznik posiada asynchroniczne wejście CLR (ang. clear - czyść). Podanie stanu wysokiego na to wejście powoduje wyzerowanie wszystkich przerzutników.

Zamiast pojedynczego wejścia zegarowego, licznik posiada dwa wejścia UP (ang. w górę) i DOWN (ang. w dół). Impulsy zegarowe podawane na te wejścia odpowiednio powodują zliczanie w górę lub w dół. Nieużywane wejście zegarowe powinno być w stanie wysokim.

Dwa wyjścia CO (ang. Carry Output - wyjście przeniesienia) i BO (ang. Borrow Output - wyjście pożyczki) pozwalają w prosty sposób łączyć ze sobą kolejne dekady liczników. Wyjście CO łączymy z wejściem UP kolejnego licznika a wyjście BO z wejściem DOWN. Więcej informacji na temat tych układów znajdziesz w materiałach producentów.

 



List do administratora Serwisu Edukacyjnego Nauczycieli I LO

Twój email: (jeśli chcesz otrzymać odpowiedź)
Temat:
Uwaga: ← tutaj wpisz wyraz  ilo , inaczej list zostanie zignorowany

Poniżej wpisz swoje uwagi lub pytania dotyczące tego rozdziału (max. 2048 znaków).

Liczba znaków do wykorzystania: 2048

 

W związku z dużą liczbą listów do naszego serwisu edukacyjnego nie będziemy udzielać odpowiedzi na prośby rozwiązywania zadań, pisania programów zaliczeniowych, przesyłania materiałów czy też tłumaczenia zagadnień szeroko opisywanych w podręcznikach.



   I Liceum Ogólnokształcące   
im. Kazimierza Brodzińskiego
w Tarnowie

©2017 mgr Jerzy Wałaszek

Dokument ten rozpowszechniany jest zgodnie z zasadami licencji
GNU Free Documentation License.