Appunti di Elettronica dei Sistemi Digitali

Transcript

Appunti di Elettronica Digitale
Capitolo 4 - Circuiti sequenziali (parte III)
Esercizio..................................................................................................... 1
Circuiti a celle iterative.................................................................................... 8
Introduzione ............................................................................................... 8
Registri .......................................................................................................... 21
Introduzione ai registri ............................................................................. 21
Osservazione sul clock ........................................................................ 22
Registro a scorrimento (shift register)....................................................... 23
Segnali di controllo .................................................................................. 26
Applicazione: accumulatore ..................................................................... 31
Contatori ........................................................................................................ 33
Introduzione ............................................................................................. 33
Contatore modulo 8 .................................................................................. 33
Contatori up, down e up-down ............................................................ 37
Contatori a decade.............................................................................. 40
Ripple-Carry Out (RCO) .......................................................................... 41
Contatori ad anello (Ring Counter)........................................................... 42
Contatore ad anello intrecciato (Twisted Ring Counter)..................... 45
ESERCIZIO
Consideriamo un circuito sequenziale sincrono, ad 1 ingresso ed 1 uscita, che si comporti nel
modo seguente: ricevendo la sequenza binaria in ingresso, esso deve analizzarla 5 bit per volta e
deve dare uscita =1, dopo ogni gruppo di 5bit, se in tale gruppo ci sono solo 2 bit pari ad 1.
Vogliamo sintetizzare questo circuito sequenziale.
La prima cosa da fare è tracciare il diagramma degli stati del circuito. Indichiamo con A lo stato
di partenza, cioè lo stato in cui la macchina deve trovarsi all’inizio di ogni gruppo di 5 bit. Il
diagramma degli stati risulta essere il seguente:
A
1
0
B
0
1
D
1
0
C
E
0
G
1
0
0
F
I
L
1
1
P
O
0/0
1
1
H
0
N
1
0
M
1/1
0/1
1/0
1,0/0
Appunti di “Elettronica dei Sistemi Digitali” - Capitolo 4
La struttura ad albero appena disegnata prevede, in pratica, che la macchina sia divisa in 4 rami
verticali, ognuno dei quali corrisponde ad un preciso numero di 1 rilevati nella sequenza di ingresso:
gli stati del primo ramo (B,D,G,N) corrispondono ad assenza di 1; gli stati del secondo ramo
(C,E,H,O) corrispondono ad un solo 1 nella sequenza; gli stati del terzo ramo (F,I,P) corrispondono
ad due 1 nella sequenza; infine, gli stati del quarto ramo (L,M) corrispondono a tre 1 nella sequenza.
Dal diagramma appena tracciato possiamo immediatamente risalire alla tabella degli stati e delle
uscite:
s .p . \ x
0
1
0
1
A
B
B
D
C
E
0
0
0
0
C
D
E
G
F
H
0
0
0
0
E
H
I
0
0
F
G
I
N
L
O
0
0
0
0
H
I
O
P
P
M
0
0
0
0
L
M
M
A
M
A
0
0
0
0
N
A
A
0
0
O
P
A
A
A
A
0
1
1
0
Abbiamo dunque ottenuto una macchina (completamente specificata) di 14 stati, per rappresentare
i quali avremmo bisogno di 4 variabili di stato (che consentono la codifica binaria di 16 stati), ossia
di 4 flip-flop. Andiamo allora a vedere se la macchina considerata è minima e, in caso non lo sia,
procediamo alla minimizzazione.
Anziché applicare immediatamente il metodo rigoroso, basato sull’uso della tabella triangolare, ci
accorgiamo subito della presenza di due stati indistinguibili: si tratta degli stati M ed N, che hanno la
stessa uscita e la cui equivalenza implica l’equivalenza di A con se stesso. Possiamo dunque già
ridurre la tabella degli stati, accorpando M ed N in un unico stato, che indichiamo con Q:
Autore: Sandro Petrizzelli
s .p . \ x
0
1
0
1
A
B
C
B
D
E
C
E
F
0
0
0
0
0
0
D
G
H
0
0
E
F
G
H
I
Q
I
L
O
0
0
0
0
0
0
H
O
P
0
0
I
L
Q
P
Q
A
Q
Q
A
0
0
0
0
0
0
O
P
A
A
A
A
0
1
1
0
2
Circuiti sequenziali
Non è più possibile trarre altre conclusioni in modo immediato, per cui utilizziamo la tabella
triangolare. La tabella risulta essere fatta nel modo seguente:
B
C
D
E
F
G
H
I
L
Q
O
P
B, D
C, E
B, E
C, F
B, G
C, H
B, H
C, I
B, I
C, L
B, Q
C, O
B, O
C, P
B, P
C, Q
B, Q
C, Q
A, B
A, C
X
X
A
\\
D, E
E, F
D, G
E, H
D, H
E, I
D, I
E, L
D, Q
E, O
D, O
E, P
D, P
E, Q
D, Q
E, Q
A, D
A, E
X
X
B
\\
\\
\\
\\
\\
\\
\\
\\
\\ \\
\\
\\
\\
\\
\\
\\
\\
\\
\\ \\
\\
\\
\\
\\
\\
\\
\\
\\ \\
\\
\\
\\
\\
\\
\\
\\ \\
\\
\\
\\
\\
\\
\\ \\
\\
\\
\\
\\
\\ \\
\\
\\
\\
\\ \\
\\
\\
\\ \\
E, G
F, H
E, H
F, I
E, I
F, L
E, Q
F, O
E, O
F, P
E, P
F, Q
E, Q
F, Q
A, E
A, F
X
X
C
G, H
H, I
G, I
H, L
G, Q
H, O
G, O
H, P
G, P
H, Q
G, Q
H, Q
A, G
A, H
X
X
D
H, I
I, L
H, Q
I, O
H, O
I, P
H, P
I, Q
H, Q
I, Q
A, H
A, I
X
X
E
I, Q
L, O
I, O
L, P
I, P
L, Q
I, Q
L, Q
A, I
A, L
X
X
F
N, O
O, P
N, P
O, Q
N, Q
O, Q
A, Q
A, O
X
X
G
O, P
P, Q
O, Q
P, Q
\\
P, Q
A, O A, P
A, Q
A, P A, Q
X
X
X
X
X
X
H
I
L
\\ \\
\\ \\
X
X
Q
\\
X
O
Si osserva che gli ultimi due stati sono distinguibili da tutti gli altri per il semplice fatto di avere
uscite diverse da tutti gli altri. Di conseguenza, possiamo immediatamente aggiungere delle X in
quelle caselle in cui compaiono O oppure P o entrambi:
B
C
D
E
F
G
H
I
L
Q
O
P
B, D
C, E
B, E
C, F
B, G
C, H
B, H
C, I
B, I
C, L
X
X
X
B, Q
C, Q
A, B
A, C
X
X
A
\\
D, E
E, F
D, G
E, H
D, H
E, I
D, I
E, L
X
X
X
D, Q
E, Q
A, D
A, E
X
X
B
\\
\\
\\
\\
\\ \\ \\
\\
\\ \\
\\
\\
\\
\\
\\ \\ \\
\\
\\ \\
\\
\\
\\
\\ \\ \\
\\
\\ \\
\\
\\
\\ \\ \\
\\
\\ \\
\\
\\ \\ \\
\\
\\ \\
X
X
X
I, Q
L, Q
A, I
A, L
X
X
F
\\ \\ \\
X \\ \\
X X \\
\\
\\
\\
\\ \\
\\ \\
\\ \\
X
X
X
\\
\\ \\
X
X
X A, Q \ \ \ \
X
X
G
X
X
H
X
X
I
E, G
F, H
E, H
F, I
E, I
F, L
X
X
X
E, Q
F, Q
A, E
A, F
X
X
C
G, H
H, I
G, I
H, L
X
X
X
G, Q
H, Q
A, G
A, H
X
X
D
H, I
I, L
X
X
X
H, Q
I, Q
A, H
A, I
X
X
E
3
X
X
L
X
X
Q
\\
X
O
Il risultato ottenuto, con questo passaggio, è il fatto che anche gli stati G,H ed I sono sicuramente
distinguibili, per cui possiamo nuovamente andare a riempire con delle X le caselle in cui compaiono
tali stati:
B
C
D
E
F
G
H
I
L
Q
O
P
B, D
C, E
B, E
C, F
X
X
X
X
X
X
B, Q
C, Q
A, B
A, C
X
X
A
\\
D, E
E, F
X
X
X
X
X
X
D, Q
E, Q
A, D
A, E
X
X
B
\\
\\ \\ \\ \\ \\ \\
\\
\\ \\
\\
\\ \\ \\ \\ \\ \\
\\
\\ \\
\\
X
X
X
X
X
\\
\\
X
X
X
X
\\
\\
\\
X
X
X
\\
\\
\\
\\
X
X
\\
\\
\\
\\
\\
X
\\
\\
\\
\\
\\
\\
\\
\\
\\
\\
\\
\\
\\
\\
\\
\\
\\
\\
X
X
X
X
X
X
\\
\\ \\
X
X
X
X
X
X A, Q \ \ \ \
X
X
D
X
X
E
X
X
F
X
X
G
X
X
H
X
X
I
X
X
X
X
X
X
E, Q
F, Q
A, E
A, F
X
X
C
X
X
L
X
X
Q
\\
\\
\\
\\
\\
\\
\\
X
O
Con questo secondo passaggio, abbiamo ottenuto che anche gli stati D,E ed F sono distinguibili da
tutti gli altri. Ripetendo ancora il procedimento, diventano distinguibili dagli altri anche gli stati B e
C, da cui consegue che anche L e Q sono distinguibili dagli altri e, infine, che anche L e Q sono
distinguibili. La conclusione è dunque che la macchina considerata è già minima.
Dobbiamo dunque sintetizzare una macchina con 13 stati, per i quali saranno perciò necessarie 4
variabili di stato (y1y2y3y4) ossia 4 flip-flop.
Il passo successivo è quello di effettuare l’assegnamento: chiaramente, avendo 4 variabili di stato,
ossia 16 configurazioni binarie, ne assegneremo solo 13, lasciandone invece 3 non assegnate.
Proviamo con un assegnamento casuale, quale ad esempio può essere il seguente:
y1 y 2 y 3 y 4 \ x
A = 0000
B = 0001
C = 0010
D = 0011
E = 0100
F = 0101
G = 0110
H = 0111
I = 1000
L = 1001
Q = 1010
O = 1011
P = 1100
0
0001
0011
0100
0110
0111
1000
1010
1011
1100
1010
0000
0000
0000
1
0010
0100
0101
0111
1000
1001
1011
1100
1010
1010
0000
0000
0000
4
0
0
0
0
0
0
0
0
0
0
0
0
0
1
1
0
0
0
0
0
0
0
0
0
0
0
1
0
Scegliamo adesso il tipo di FLIP-FLOP da utilizzare per realizzare il circuito: prendiamo ad
esempio flip-flop di tipo D, per cui le funzioni da sintetizzare sono Y1=D1, Y2=D2, Y3=D3 e Y4=D4,
cui ovviamente va aggiunta l’uscita. Si tratta, inoltre, di funzioni di 5 variabili (y1,y2,y3,y4,x), che
potremo minimizzare usando mappe di Karnaugh a 5 variabili, ossia, per ogni funzione, coppie di
mappe di Karnaugh a 4 variabili. Ricordiamo, inoltre, fin da ora che tali mappe di Karnaugh
conterranno delle condizioni don’t care nelle celle corrispondenti alle seguenti configurazioni di
stato non assegnate:
y1,y2,y3,y4=1101,1110,1111
Procediamo allora con la minimizzazione:
• la mappa di Karnaugh della funzione D1 si ottiene considerando la prima colonna dello stato
presente e la prima colonna degli stati successivi:
y1 y 2 \ y 3 y 4
00
00
01
11
10
0
1
3
2
01
11
10
4
1
7
1
6
1
X
1
1
x=0
15
X
14
X
12
8
5
13
9
11
y1 y 2 \ y 3 y 4
00
01
11
10
10
00
01
11
10
0
1
3
2
4
1
1
7
1
6
1
X
1
1
x =1
15
X
14
X
12
8
5
13
9
11
10
Y1 = D1 = y1 y' 2 y'3 + xy '1 y 2 + y 2 y 3 + y 2 y 4 = y1 y' 2 y'3 + y 2 (xy'1 + y 3 + y 4 )
In questa espressione, non si notano particolari proprietà, in quanto la funzione Y1 risulta
dipendere da tutte le variabili in questione;
• la mappa di Karnaugh della funzione D2 si ottiene considerando la seconda colonna dello stato
presente e la seconda colonna degli stati successivi:
y1 y 2 \ y 3 y 4
00
01
11
10
00
01
0
1
1
5
4
12
8
13
X
1
x=0
9
11
3
1
10
2
1
7
6
15
X
11
14
X
10
y1 y 2 \ y 3 y 4
00
01
11
10
00
0
01
1
1
4
12
8
5
13
X
9
11
3
1
7
1
15
X
10
2
1
6
14
11
X
10
x =1
Y2 = D 2 = x ' y1 y' 2 y'3 y' 4 + x ' y'1 y 2 y'3 y' 4 + y'1 y' 2 y 3 + xy '1 y' 2 y' 4 + xy'1 y 3 y 4
• la mappa di Karnaugh della funzione D3 si ottiene considerando la terza colonna dello stato
presente e la terza colonna degli stati successivi:
5
y1 y 2 \ y 3 y 4
00
00
0
4
01
11
10
01
1
1
1
5
X
8
9
1
x=0
12
13
11
3
1
7
1
10
2
X
15
6
1
14
X
11
y1 y 2 \ y 3 y 4
00
00
0
1
01
01
11
10
4
5
10
1
X
8
9
1
1
x =1
12
13
11
3
1
7
15
X
11
10
2
6
1
14
X
10
Y3 = D 3 = .....
• infine, la mappa di Karnaugh della funzione D4 si ottiene considerando la quarta colonna dello
stato presente e la quarta colonna degli stati successivi:
y1 y 2 \ y 3 y 4
00
01
11
10
00
0
1
4
1
12
01
1
1
5
13
8
X
9
11
10
3
2
7
1
6
15
X
14
11
X
10
y1 y 2 \ y 3 y 4
00
01
11
10
x=0
00
01
0
1
4
5
1
12
13
X
8
9
11
3
1
7
15
X
11
10
2
1
6
1
14
X
10
x =1
Y4 = D 4 = ....
E’ abbastanza evidente che tutte e 4 le funzioni da sintetizzare risultano piuttosto complicate.
Allora, proviamo a individuare l’assegnamento ottimale. A questo scopo, seguiamo il metodo di
Hartmanis per la ricerca delle partizioni stabili. Aiutandoci ancora una volta con la tabella
triangolare degli stati, l’applicazione del metodo porta ai seguenti risultati:
B
C
D
E
F
G
H
I
L
Q
O
P
π(1)
π(1)
π(1)
π(1)
π(1)
π(1)
π(1)
π(1)
π(1)
π(1)
π(1)
π(1)
A
\\
πA
π(1)
π(1)
πB
π(1)
π(1)
π(1)
π(1)
π(1)
π(1)
π(1)
B
\\
\\
π(1)
π(1)
π(1)
π(1)
π(1)
π(1)
π(1)
π(1)
π(1)
π(1)
C
\\
\\
\\
πC
πD
π(1)
π(1)
π(1)
π(1)
π(1)
π(1)
π(1)
D
\\
\\
\\
\\
πE
π(1)
π(1)
π(1)
π(1)
π(1)
π(1)
π(1)
E
\\
\\
\\
\\
\\
\\
\\
\\
\\
\\
\\
\\
\\
\\
\\
\\
\\
\\
\\
\\
\\
\\
\\
\\
\\
\\
\\
\\
π(1) \ \
\\
\\
\\
π(1) π F
\\
\\
π(1) π G
πI
π(1) π H π L π M
\\
π(1) π(1) π(1) π(1) π(1)
π(1) π(1) π(1) π(1) π(1)
π(1) π(1) π(1) π(1) π(1)
F
G
H
I
L
dove abbiamo fatto le seguenti posizioni:
6
\\
\\
\\
\\
\\
\\
\\
\\
\\
\\
\\
\\
\\
\\
\\
\\
\\
\\
\\
\\
\\
πN
Q O
π A = {(A), (B, C), (D, E, F), (G, H, I, L), (Q, O, P)}
π B = {(C), (B, F), (A, D, G, H, I, Q, O, P), (E, L)}
π C = {(A), (B), (C), (D, E), (F), (G, H, I), (L), (Q, O, P)}
π D = {(A), (B), (C), (D, F), (Q, O, P), (G, I), (H, L)}
π E = {(A), (B), (C), (D), (E, F), (G ), (H, I, L), (Q, O, P)}
π F = {(A), (B), (C), (D), (E), (F), (G, H), (I), (L), (Q, O, P)}
π G = {(A), (B), (C), (D), (E), (F), (G, I), (H), (L), (Q, O, P)}
π H = {(A), (B), (C), (D), (E), (F), (G, L), (H), (I), (Q, O), (P)}
π I = {(A), (B), (C), (D), (E), (F), (H, I), (G ), (L), (Q, O, P)}
π L = {(A), (B), (C), (D), (E), (F), (H, L), (G ), (I), (Q, O, P)}
π M = {(A), (B), (C), (D), (E), (F), (L, I), (G ), (H), (Q, P), (O)}
π N = {(A), (B), (C), (D), (E), (F), (L), (I), (G ), (H), (O, P), (Q)}
Possiamo considerare la partizione πB, composta da 4 sottogruppi, per associare 2 variabili di
stato:
y1 y 2
00
sottogruppo (A, D, G, H, I, Q, O, P)
01
C
11
B, F
10
E, L
Esiste anche una partizione output consistent, che è la seguente:
λ O = {(A, B, C, D, E, F, G, H, I, L, Q), (O), (P)}
Tuttavia, l’intersezione di questa partizione con la πB non dà la partizione banale π(0), il che
impedisce di poter individuare, in modo univoco, ciascuno stato mediante una configurazione
binaria.
Allora, .....?....
7
Circuiti a celle iterative
INTRODUZIONE
Nei seguenti paragrafi vogliamo mostrare come sia possibile sintetizzare una generica macchina a
stati finiti mediante un circuito combinatorio anziché un circuito sequenziale, così come invece
abbiamo fatto nei paragrafi precedenti. Possiamo inquadrare bene il problema, partendo da un
esempio concreto.
Consideriamo una FSM già considerata in precedenza: si tratta di una FSM con 2 ingressi (x1 ed
x2), il cui compito è quello di confrontare, a 4 bit alla volta, le sequenze binarie che giungono a tali
due ingressi: dopo ogni coppia di quartine di bit, la macchina deve dare 1 in uscita se le due quartine
sono uguali, mentre deve dare 0 in caso contrario.
Ripetiamo la descrizione del funzionamento della macchina così come l’abbiamo data in
precedenza. Supponiamo perciò che i bit abbiano un periodo di ripetizione pari a T/4, il che significa
che ogni quartina di bit “dura” un tempo pari a T: allora, il compito della macchina è di fissare il
valore dell’uscita dopo ogni quartina, per cui le eventuali commutazioni dovranno avvenire a
distanza T una dall’altra. Supponiamo ad esempio che le 2 sequenze in ingresso siano le seguenti:
0 0 1 0 0 1 1 1 0 1 0 1 0 0 1 1 1 1 0 1
1 0 1 0 0 1 1 1 0 0 0 0 1 1 1 1 1 1 0 1
La macchina confronta queste due sequenze (composte da 20 bit, per un totale di 5 periodi T) una
quartina per volta, partendo da una condizioni iniziale in cui l’uscita è z=0:
• le prime quartine sono, rispettivamente, 0010 e 1010: esse differiscono per un bit, per cui la
macchina mantiene l’uscita a 0 dopo un primo periodo di tempo pari a T;
• le seconde quartine sono invece uguali (0011), per cui la macchina, dopo un tempo pari a 2T
dall’avvio, pone l’uscita ad 1;
• le successive quartine sono diverse, per cui, dopo un tempo 3T, l’uscita va nuovamente a 0;
• l’uscita rimane ancora a zero in quanto anche le successive quartine sono diverse: quindi,
all’istante 4T, l’uscita è ancora a 0;
• le ultime quartine sono nuovamente uguali, per cui, dopo un tempo 5T, l’uscita commuta a 1.
L’andamento temporale dell’uscita è dunque il seguente:
z(t)
T
2T
3T
4T
5T
t
Il primo problema che ci poniamo è quello di sintetizzare questa macchina mediante un circuito
sequenziale. A questo scopo, può convenire tracciare il grafo orientato che descrive il funzionamento
della macchina. Per tracciare questo grafo, ci basta fare una considerazione di fondo: la macchina
deve sostanzialmente seguire due percorsi diversi nel grafo, dove un percorso è relativo all’arrivo di
8
coppie di bit uguali, mentre l’altro è relativo all’arrivo di coppie di bit distinti. In altre parole, se la
macchina riceve in ingresso coppie di bit uguali, dobbiamo portarla verso una condizione in cui,
all’arrivo della quarta coppia di bit uguali, essa possa dare uscita 1 e riportarsi nello stato iniziale; al
contrario, non appena giunge una coppia di bit diversi, allora dobbiamo fare in modo che, comunque
siano fatte le coppie di bit successive, la macchina dia uscita 0 e si riporti nuovamente nello stato di
partenza.
Si può verificare facilmente che il grafo che viene fuori da queste considerazioni è il seguente:
A
00
11
01
10
B
C
00
11
01
10
F
00
11
G
00
11
D
10
01
01
1
10
E
00
01
10
11
1
1
Il ramo di sinistra è quello che corrisponde a coppie di bit via via uguali; il ramo di destra è quello
in cui invece la macchina perviene non appena arriva una coppia di bit diversi.
Per sintetizzare questo grafo, determiniamo la corrispondente tabella degli stati e delle uscite, che
si comporrà evidentemente di 7 stati:
s.p. \ x 1 x 1
A
B
C
D
E
F
G
00 01 11
B C B
F D F
D D D
E E E
A A A
G E G
A A A
10 00 01 11 10
C 0 0 0 0
D 0 0 0 0
D 0 0 0 0
E 0 0 0 0
A 0 0 0 0
E 0 0 0 0
A 1 0 1 0
Volendo sintetizzare questa macchina, dobbiamo per prima cosa verificare che essa sia minima,
usando la tabella delle implicazioni (ricordiamo che la FSM considerata è completamente
specificata, per cui facciamo riferimento alla proprietà di equivalenza tra stati):
9
B
C
D
E
F
G
\\ \\ \\ \\ \\
\\ \\ \\ \\
\\ \\ \\
\\ \\
\\
A
B
C
D
E
F
Per prima cosa, individuiamo eventuali coppie di stati che possano essere distinti per la diversa
uscita ad essi associata: è evidente che si tratta dell’intera riga corrispondente allo stato G, che è
l’unico ad avere uscita diversa dagli altri:
B
\\ \\ \\
C
\\ \\
D
\\
E
F
G X X X X
A B C D
\\
\\
\\
\\
X
E
\\
\\
\\
\\
\\
X
F
Adesso andiamo a riempire le rimanenti caselle mediante le coppie di stati 1-successori
(ricordiamo infatti, che due stati sono tra loro equivalenti se lo sono anche i loro x-successori e
quindi anche i loro 1-successori):
B
C
D
E
F
G
B, F
C, D
B, D
C, D
B, E
C, E
A, B
A, C
B, G
C, E
X
A
\\
\\
\\
\\
\\
F, D
\\
\\
\\
\\
E, D
\\
\\
\\
\\
\\
E, F
D, E
A, F
A, D
F, G
D, E
X
B
A , D A, E
D, G
A, G
E, G
\\
D, E
A, E
X
X
X
X
C
D
E
F
Adesso dobbiamo verificare se le caselle contrassegnate con la X comportano a loro volta altre
distinguibilità: dato allora che lo stato G è sicuramente distinguibile da tutti gli altri, possiamo
direttamente riempire con una X le caselle in cui compare proprio lo stato G:
10
B, F
C, D
B, D
C
C, D
B, E
D
C, E
A, B
E
A, C
F
X
G X
A
B
\\
\\
\\
\\ \\
F, D
\\
\\
\\ \\
E, F
E, D \ \ \ \ \ \
D, E
A, F
A, D A, E \ \ \ \
A, D
X
X
X
X \\
X
X
X
X X
B
C
D
E F
Come si osserva, il risultato dell’ultimo passaggio è stato il riempimento della riga corrispondente
allo stato F, che quindi risulta distinguibile da tutti gli altri. Possiamo allora ripetere lo stesso
passaggio, riempiendo con una X tutte le caselle in cui compare lo stato F:
B
X
B, D
C
C, D
B, E
D
C, E
A, B
E
A, C
F
X
G X
A
\\
\\
\\
\\ \\
X
\\
\\
\\ \\
X
E, D
\\
\\ \\
X
A, D A, E \ \ \ \
X
X
B
X
X
C
X
X
D
X
X
E
\\
X
F
Abbiamo così riempito la colonna corrispondente allo stato B, che quindi è distinguibile da tutti
gli altri. Andando allora a riempire tutte le caselle in cui compare lo stato B, osserviamo che si
riempie di X la colonna corrispondente allo stato A, che quindi è a sua volta distinguibile da tutti gli
altri:
B
C
D
E
F
X \\ \\
\\
X X
\\
\\
X X E, D \ \
X X A, D A, E
X X
X
X
G X
A
X
B
X
C
X
D
\\
\\
\\
\\
X
\\
\\
\\
\\
\\
X
E
X
F
A questo punto, è evidente che anche le 3 caselle rimanenti contengono coppie di stati
distinguibili, per cui possiamo senz’altro concludere che la macchina considerata sia minima.
Accertato questo, possiamo passare alla sintetizzazione vera e propria della macchina, che
comincia con la fase dell’assegnamento. Andiamo allora alla ricerca dell’assegnamento ottimale,
ricercando eventuali partizioni stabili con l’aiuto del metodo di Hartmanis.
11
Riprendiamo dunque la tabella triangolare di prima, che adesso ci servirà per studiare gli stati
successori di tutte le possibili coppie di stati che possiamo formare a partire dall’insieme di stato
della macchina considerata:
B
C
D
E
F
G
\\ \\ \\ \\ \\
\\ \\ \\ \\
\\ \\ \\
\\ \\
\\
A
B
C
D
E
F
Senza scendere nei dettagli dei singoli alberi che si tirano fuori, limitiamoci a riportare i risultati
finali:
• in primo luogo, la maggior parte delle coppie porta alla partizione banale
π(1) = {(A, B, C, D, E, F, G )}; si tratta in particolare delle coppie indicate nella tabella seguente:
B
C
D
E
F
G
π(1)
π(1)
\\
\\
\\
π(1) π(1)
π(1)
\\
\\
\\
π(1)
π(1) π(1)
π(1)
A
B
C
π(1)
D
\\
\\
\\
\\
π(1)
E
\\
\\
\\
\\
\\
π(1)
F
• le rimanenti coppie, invece, danno luogo alle seguenti partizioni stabili:
(A, D), (A, F), (B, E), (B, G ), (C, E), (C, G ) 
→ π A = {(A, D, F), (B, C, E, G )}
(B, C) 
→ π B = {(A), (B, C), (D, F), (E, G )}
(D, F) 
→ π C = {(A), (B), (C), (D, F), (E, G )}
(E, G ) 
→ π D = {(A), (B), (C), (D), (F), (E, G )}
Possiamo dunque completare la tabella delle partizioni nel modo seguente:
B
C
D
E
F
G
π(1) \ \
\\
\\
\\
\\
π(1) π B
\\
\\
\\
\\
π A π(1) π(1) \ \
\\
\\
π(1) π A π A π(1) \ \
\\
π A π(1) π(1) π C π(1) \ \
π(1) π A π A π(1) π D π(1)
A
B
C
D
E
F
12
Si osserva una interessante particolarità delle 4 partizioni stabili ottenute:
πD < πC < πB < πA
Questa relazione dice, in pratica, che, via via che passiamo in rassegna le varie coppie, giungiamo
a partizioni stabili via via più piccole.
Dobbiamo adesso decidere come usare queste 4 partizioni stabili ai fini dell’assegnamento delle
variabili di stato.
Una prima possibilità consiste nell’utilizzare la partizione πA per assegnare 1 variabile di stato, ad
esempio y1:
y1
0
1
sottogruppo (A, D, F) (B, C, E, G )
Con questa scelta, siamo certi che Y1 dipenderà solo da y1 e dall’ingresso.
Successivamente, possiamo usare le rimanenti 2 variabili di stato (ricordiamo che la macchina in
esame ha 7 stati, per codificare i quali servono 3 variabili di stato) per individuare i singoli stati
all’interno dei due sottogruppi:
y 2 y 3 00 01 10 00 01 10 11 \ \
stato A D F B C E G \ \
Così facendo, otteniamo il seguente assegnamento complessivo:
y1 y 2 y 3
stato
000 001 010 100 101 110 111 \ \
A
D
F
B
C
E
G \\
Resta evidentemente una configurazione binaria non assegnata.
Con questo assegnamento, abbiamo ottenuto solo l’indipendenza di Y1 da y2 e y3. Possiamo in
realtà fare qualcosa in più, in quanto ci si accorge facilmente che la partizione πB è una partizione
input-consistent1: osservando che i sottogruppi contenuti in πB sono 4, possiamo partire assegnando
due variabili di stato (y1 ed y2) per individuare tali sottogruppi, dopo di che, osservando che tali
sottogruppi non contengono più di 2 stati, possiamo usare la terza variabile di stato per distinguere i
singoli stati all’interno di ciascun sottogruppo:
y1 y 2
00
sottogruppo A
01
B, C
11
D, F
10
E, G
y3
0 0 1 0 1 0 1 \\
stato A B C D F E G \ \
1
Ricordiamo la definizione di partizione input-consistent: una partizione stabile è detta input-consistent se, preso un qualsiasi
stato appartenente ad essa, i suoi stati 1-successori appartengono ancora alla partizione e sono contenuti in uno stesso
sottogruppo.
13
Così facendo, otteniamo il seguente assegnamento complessivo:
y1 y 2 y 3
stato
000 010 011 110 100 111 101 \ \
A
B
C
D
E
F
G \\
Con questo assegnamento, abbiamo ottenuto un duplice risultato: in primo luogo, Y1 ed Y2 non
dipendono da y3, visto che sono state assegnate a partire da una partizione stabile; in secondo luogo,
Y1 ed Y2 non dipendono nemmeno dall’ingresso x, visto che la suddetta partizione stabile è anche
input-consistent.
Questo risultato è sicuramente preferibile rispetto a quello ottenuto prima, per cui procediamo su
questa strada.
La tabella degli stati e delle uscite diventa la seguente:
y1 y 2 y 3 \ x 1 x 2
A = 000
B = 010
C = 011
D = 110
E = 100
F = 111
G = 101
00
010
111
110
100
000
101
000
01
011
110
110
100
000
100
000
11
010
111
110
100
000
101
000
10 00 01 11 10
011 0 0 0 0
110 0 0 0 0
110 0 0 0 0
100 0 0 0 0
000 0 0 0 0
100 0 0 0 0
000 1 0 1 0
Per il circuito di memoria, scegliamo di usare ancora una volta flip-flop di tipo D: dovremo allora
sintetizzare, oltre all’uscita Z, tre funzioni (Y1=D1, Y2=D2, Y3=D3). Tutte le funzioni sono di 5
variabili, per cui, per ciascuna di esse, dovremo considerare coppie di mappe di Karnaugh a 16
caselle. Osserviamo inoltre che, in tali mappe, compariranno sicuramente delle condizioni don’t care,
dovute al fatto che la configurazione binaria y1y2y3=001 non è stata assegnata.
Vediamo nei dettagli cosa si ottiene:
• la mappa di Karnaugh della funzione D1 si ottiene considerando la prima colonna dello stato
presente e la prima colonna degli stati successivi:
y 2 y 3 \ x1x 2
00
01
11
10
00
01
11
10
0
1
3
2
X
15
1
11
1
X
14
1
10
1
X 5X
12
1 13 1
8
1 91
y1 = 0
4
7
6
y 2 y3 \ x1x 2
00
01
11
10
00
01
11
10
0
1
3
2
4
5
7
6
1 13 1
8
1 91
y1 = 1
12
1
11
1
15
14
10
1
1
Y1 = D1 = y 2
Come previsto, la funzione Y1 non dipende da y3 né dall’ingresso; è capitato anche che non
dipenda da y1, ma è puramente un caso;
• la mappa di Karnaugh della funzione D2 si ottiene considerando la seconda colonna dello stato
presente e la seconda colonna degli stati successivi:
14
y 2 y 3 \ x1x 2
00
01
11
10
00 01
0
1 11
4
X 5X
12
1 13 1
8
1 91
y1 = 0
11
3
1
7
X
15
1
11
1
10
2
1
6
X
14
1
10
1
y 2 y3 \ x1x 2
00
01
11
10
00 01 11 10
0
1
3
2
4
5
7
6
12
13
15
14
8
9
11
10
y1 = 1
Y2 = D 2 = y'1
Anche la funzione Y2, come previsto, non dipende da y3 e dall’ingresso; anche qui, il fatto che
Y2 non dipenda da y2 ma solo da y1 è un caso;
• la mappa di Karnaugh della funzione D3 si ottiene considerando la terza colonna dello stato
presente e la terza colonna degli stati successivi:
y 2 y 3 \ x1x 2
00
01
11
10
00
0
X
4
12
01
1
1
5
X
13
9
1
y1 = 0
8
11
3
7
X
15
11
1
10
2
1
6
X
14
10
y 2 y3 \ x1x 2
00
01
11
10
00
01 11 10
0
1
3
2
4
5
7
6
13
15
12
1
8
9
1
11
14
10
y1 = 1
Y3 = D3 = y'1 (y2 y'3 x'1 x'2 +y2 y'3 x1x 2 + y'2 x'1 x 2 + y' 2 x1x'2 ) + y1 (y2 y3 x'1 x' 2 +y2 y3 x1x 2 )
Ancora in accordo alle previsioni, la funzione Y3 dipende da tutte e tre le variabili di stato e
dall’ingresso, con una espressione anche abbastanza complicata; possiamo anche provare a
semplificare questa espressione (che ci servirà in seguito):
Y3 = D 3 = y'1 (y 2 y' 3 [x '1 x ' 2 + x 1 x 2 ] + y' 2 [x '1 x 2 + x 1 x ' 2 ]) + y1 y 2 y 3 (x '1 x ' 2 + x 1 x 2 ) =
= y'1 (y 2 y'3 (x 1 ⊕ x 2 )'+ y' 2 (x 1 ⊕ x 2 )) + y1 y 2 y 3 (x 1 ⊕ x 2 )' =
= y 2 [y'1 y'3 + y1 y 3 ](x 1 ⊕ x 2 )'+ y'1 y' 2 (x 1 ⊕ x 2 ) = y 2 (y1 ⊕ y 3 )' (x 1 ⊕ x 2 )'+ y'1 y' 2 (x 1 ⊕ x 2 )
• la mappa di Karnaugh della funzione Z si ottiene infine considerando la tabella delle uscite:
y 2 y 3 \ x1x 2
00
01
11
10
00
01
11
10
0
1
3
2
4
X
5
X
7
X
6
X
12
13
15
14
8
9
11
10
y 2 y3 \ x1x 2
00
01
11
10
y1 = 0
00 01 11 10
0
1
1
5
7
12
13
15
14
8
9
11
10
4
3
2
1
6
y1 = 1
Z = y1 (y' 2 y 3 x '1 x ' 2 + y' 2 y 3 x 1 x 2 ) = y1 y' 2 y 3 (x 1 ⊕ x 2 )'
15
Abbiamo dunque ottenuto le espressioni booleane delle 4 funzioni, per cui resta solo da tradurre
tali espressioni nei corrispondenti circuiti logici. Essendo però questi ultimi abbastanza complessi, ci
limitiamo a tracciare lo schema a blocchi del circuito sequenziale nel suo complesso:
Fin qui, dunque, non abbiamo incontrato niente di nuovo rispetto a quanto fatto in precedenza.
Infatti, abbiamo ancora una volta modellato il nostro circuito sequenziale scomponendolo in una
parte combinatoria (composta in questo caso da 4 blocchi, uno per ogni funzione) e in una parte di
memoria (composta in questo caso da 3 flip-flop di tipo D):
Ci chiediamo, adesso, se sia possibile utilizzare un circuito puramente combinatorio che svolga le
stesse funzioni del circuito sequenziale appena determinato. La risposta è si, a patto però di fare una
assunzione fondamentale di partenza: dato che un circuito combinatorio non possiede, per
definizione, una memoria, non possiamo certo pensare di inviare le due sequenze x1 ed x2 mandando
un bit alla volta; al contrario, dato che il nostro scopo è quello di confrontare tali sequenze a gruppi
di 4 bit (cioè a semibyte), come minimo dobbiamo pensare di inviare in ingresso al circuito
combinatorio contemporaneamente 4 bit di x1 e 4 bit di x2. Dovremo cioè realizzare uno schema del
tipo seguente:
16
xA1
xA2
xA3
xA4
C.C.
xB1
xB2
xB3
xB4
z
Mandando le due sequenze di ingresso a 4 bit per volta, il circuito dovrà dare uscita z=1 se i due
semibyte sono uguali e uscita z=0 in caso contrario. La funzione z sarà allora una normale funzione
di 8 variabili, il che significa che, per assegnarla, dovremo considerare tutte le 28=256 possibili
configurazioni di ingresso. Descrivere una funzione mediante una tabella della verità con 256 righe è
ovviamente impensabile, così come anche ricorrere ai mintermini (cioè esprimere la funzione con la
prima forma canonica) oppure mediante mappe di Karnaugh. Dobbiamo allora trovare un metodo
alternativo.
Questo metodo è quello cosiddetto delle celle iterative: il punto di partenza di questo metodo
consiste nel sintetizzare la macchina considerata mediante un circuito sequenziale, esattamente come
abbiamo fatto prima; il passo successivo è quello di usare questo circuito sequenziale per giungere
direttamente al circuito combinatorio che svolge le stesse funzioni. Dobbiamo allora capire come si
possa passare dal circuito sequenziale a quello combinatorio.
Il passo da un circuito sequenziale (il cui funzionamento si svolge, in pratica, attraverso una serie
di transizioni di stato) al corrispondente circuito combinatorio si effettua in questo modo:
• in primo luogo, dal circuito sequenziale si elimina completamente la parte di memoria,
lasciando solo la parte combinatoria (e svincolandosi ovviamente dal clock);
• in secondo luogo, si ripete la parte combinatoria un numero di volte opportuno e si dispongono
i vari blocchi combinatori (che si chiamano celle) in cascata gli uni agli altri; nel nostro caso,
lo schema da realizzare è il seguente:
xA1
xB1
y1
y2
y3
C.C.
xA2
Y1
y1
Y2
y2
Y3
y3
xB2
C.C.
xA3
Y1
y1
Y2
y2
Y3
y3
xB3
C.C.
xA4
Y1
y1
Y2
y2
Y3
y3
xB4
C.C.
Z
Mandando in ingresso a ciascuna cella una coppia di bit (presi uno dalla prima sequenza e uno
dall’altra), è facile rendersi conto che il circuito svolge la funzione desiderata:
• supponiamo di partire da una condizione iniziale corrispondente allo stato A, per cui le
variabili y1,y2,y3 in ingresso alla prima cella valgono tutte 0;
• quando arriva la prima coppia (xA1,xB1) di bit, la prima cella, per come è stata realizzata,
produce in uscita la configurazione binaria corrispondente ad un opportuno stato: sarà
evidentemente la configurazione 010 (=B) se i due bit sono uguali, mentre sarà 011(=C) se i
due bit sono diversi;
17
• così facendo, è come se la seconda cella parta da uno stato iniziale che è B o C a seconda della
configurazione in ingresso; in funzione della seconda coppia (xA2,xB2) di bit, la seconda cella
darà anch’essa in uscita una configurazione binaria opportuna e così via fino all’ultima cella, il
cui compito è quello di fornire l’uscita2 corrispondente a tutta la catena.
In pratica, il risultato ottenuto è quello di aver trasformato la
successione
temporale
degli
stati
che
avevamo
nel
circuito
sequenziale in una successione spaziale di stati, che si ha appunto
nel corrispondente circuito combinatorio.
In definitiva, quindi, per sintetizzare il circuito combinatorio non dobbiamo far altro che
sintetizzare il corrispondente circuito sequenziale e, da questo, secondo il metodo poco fa descritto,
passare al circuito combinatorio finale.
Possiamo anche scendere in maggiori dettagli, in quanto ci possiamo porre una domanda: abbiamo
appena accertato che le 4 celle di cui si compone il nostro circuito combinatorio hanno lo stesso
schema logico, in quanto sono tutte uguali alla parte combinatoria del circuito sequenziale
sintetizzato all’inizio; ci chiediamo, allora, se in effetti le 4 celle devono proprio avere lo stesso
schema logico (peraltro abbastanza complicato) della parte combinatoria del circuito sequenziale di
partenza, oppure possono essere semplificate. Vedremo che la risposta a questa domanda è
affermativa, ossia è possibile fare una semplificazione degli schemi logici delle celle.
Una prima osservazione da fare, peraltro già accennata prima, è la seguente:
• in primo luogo, la 4° cella è l’unica che deve necessariamente possedere il circuito che produce
l’uscita Z in funzione di y1,y2 ed y3, mentre le altre celle possono anche essere sprovviste di
questo circuito, visto che daranno comunque tutte uscita sempre 0 (in base all’ipotesi per cui
l’uscita deve commutare solo dopo che sono state confrontate le quartine di bit in ingresso e
non i singoli bit); di conseguenza, possiamo subito dire che le prime celle non dovranno
contenere il circuito di uscita;
• d’altra parte, la 4 ° cella, proprio perché il suo compito è solo quello di produrre un valore
opportuno dell’uscita Z, non è necessario che contenga il circuito combinatorio che genera le
funzioni Y1,Y2 ed Y3 in funzione di y1,y2 ed y3.
Quindi, l’ultima cella è costituita solo dal circuito di uscita, mentre le prime 3 celle (uguali tra
loro) non possiedono il circuito di uscita, ma solo il circuito che genera le funzioni Y1,Y2 ed Y3 in
funzione di y1,y2 ed y3.
Non è finita, in quanto possiamo ancora dire molto di più. Infatti, quando abbiamo introdotto il
circuito a celle iterative, abbiamo detto che il suo corretto funzionamento presuppone che la prima
cella parta necessariamente dallo stato iniziale che, nel circuito sequenziale, avevamo indicato con
A; dato che questo stato è stato codificato con la terna binaria 000, possiamo direttamente impostare
i valori delle variabili y1,y2 ed y3 in ingresso alla prima cella:
2
Quest’ultimo aspetto mostra una differenza sostanziale dell’ultima cella rispetto alle precedenti: mentre le prime 3 celle devono
contenere solo la parte combinatoria relativa alle funzioni Y1,Y2 e Y3, l’ultima cella deve contenere solo la parte combinatoria
relativa all’uscita.
18
xA1
xB1
ya1=0
ya2=0
ya3=0
Cella
(a)
xA2
Ya1
yb1
Ya2
yb2
Ya3
yb3
xB2
Cella
(b)
xA3
Yb1
yc1
Yb2
yc2
Yb3
yc3
xB3
Cella
(c)
xA4
Yc1
yd1
Yc2
yd2
Yc3
yd3
xB4
Cella
(d)
Z
D’altra parte, noi conosciamo le espressioni booleane di Y1,Y2 ed Y3 in funzione di y1,y2 ed y3:
Y1 = y 2
Y2 = y'1
Y3 = y 2 (y1 ⊕ y 3 )' (x 1 ⊕ x 2 )'+ y'1 y' 2 (x 1 ⊕ x 2 )
Possiamo allora stabilire quanto valgono le variabili di stato Ya1,Ya2 ed Ya3 in uscita della cella
(a):
Ya1 = y a 2 = 0
Ya 2 = y' a1 = 1
Ya 3 = y a 2 (y a1 ⊕ y a 3 )' (x A1 ⊕ x B1 )'+ y' a1 y' a 2 (x A1 ⊕ x B1 ) = y' a1 (x A1 ⊕ x B1 ) = (x A1 ⊕ x B1 )
A questo punto, dato che Ya1 = y b1 , Ya 2 = y b 2 e Ya 3 = y b 3 , sappiamo quanto valgono le variabili di
stato in ingresso alla cella (b):
y b1 = 0
y b2 = 1
y b3 = (x A1 ⊕ x B1 )
Da queste, riapplicando le stesse formule possiamo stabilire quanto valgono le variabili di stato
Yb1,Yb2 ed Yb3 in uscita della cella (b), ossia anche le variabili yc1,yc2 ed yc3 in ingresso alla cella (c):
y c1 = Yb1 = y b2 = 1
y c2 = Yb2 = y' b1 = 1
y c3 = Yb3 = y b2 (y b1 ⊕ y b3 )' (x A2 ⊕ x B2 )'+y' b1 y' b2 (x A2 ⊕ x B2 ) = y b2 (y b1 ⊕ y b3 )' (x A2 ⊕ x B2 )' = y' b3 (x A2 ⊕ x B2 )'
= (x A1 ⊕ x B1 )(x A2 ⊕ x B2 )'
Ancora una volta, abbiamo trovato che le prime due variabili di stato (sia in ingresso sia in uscita)
hanno un valore prestabilito, mentre l’ultima variabile dipende dai bit che fanno parte delle sequenze
di ingresso da confrontare.
Adesso possiamo ancora ripetere il procedimento, al fine di calcolare le variabili di stato Yc1,Yc2
ed Yc3 in uscita della cella (c), ossia anche le variabili yd1,yd2 ed yd3 in ingresso alla cella (d):
19
yd1 = Yc1 = yc2 = 1
yd 2 = Yc 2 = y'c1 = 0
yd3 = Yc3 = yc 2 (yc1 ⊕ yc3 )' (x A3 ⊕ x B3 )'+ y'c1 y'c2 (x A3 ⊕ x B3 ) = y c2 (y c1 ⊕ y c3 )' (x A3 ⊕ x B3 )' = (1 ⊕ y c3 )' (x A3 ⊕ x B3 )' =
= yc3 (x A3 ⊕ x B3 )' = (x A1 ⊕ x B1 )(x A2 ⊕ x B2 )' (x A3 ⊕ x B3 )'
Infine, note le variabili in ingresso alla cella (d), possiamo calcolare l’espressione dell’uscita Z:
ricordando infatti che Z = y1 y' 2 y 3 (x 1 ⊕ x 2 )' , abbiamo che
Z = y d1 y'd 2 y d 3 (x A 4 ⊕ x B 4 )' = y d 3 (x A 4 ⊕ x B 4 )' = {(x A1 ⊕ x B1 )(x A 2 ⊕ x B 2 )' (x A 3 ⊕ x B3 )'}(x A 4 ⊕ x B 4 )' =
= (x A1 ⊕ x B1 )(x A 2 ⊕ x B 2 )' (x A 3 ⊕ x B3 )' (x A 4 ⊕ x B 4 )'
Questa è dunque l’espressione booleana che ci consente di fare la sintesi conclusiva del circuito:
Questo schema mostra bene il concetto di celle iterative (si consideri che l’EXOR iniziale può
essere a sua volta realizzato con un EXNOR, a patto di porre in cascata un invertitore).
Facciamo adesso alcune interessanti osservazioni:
• in primo luogo, è evidente che, a questo punto, diventa immediato perfezionare la macchina,
richiedendo, per esempio, che il confronto delle sequenze di ingresso avvenga non per quartine
di bit, ma ad esempio per cinquine di bit: in questo caso, infatti, sfruttando proprio il concetto
di celle iterative, è evidente che basta aggiungere un nuovo blocco EXNOR che vada in AND
con l’ultimo:
• in secondo luogo, possiamo chiederci se il circuito combinatorio sia più veloce del circuito
sequenziale dal quale siamo partiti; in generale, il circuito combinatorio è più veloce: infatti,
mentre nel circuito sequenziale bisogna aspettare 4 colpi di clock per vedere un valore
significativo dell’uscita, nel caso del circuito combinatorio l’unico ritardo con cui si manifesta
20
l’uscita è dovuto solo alla propagazione del segnale lungo le varie porte e tale ritardo è in
generale inferiore al tempo corrispondente a 4 colpi di clock. D’altra parte, c’è anche da
osservare una cosa: nel caso del circuito sequenziale, le due sequenze di ingresso xA ed xB
arrivano in modo seriale (cioè un bit per volta), in quanto il circuito presenta 1 solo pin di
ingresso per xA ed un solo pin di ingresso per xB; al contrario, dato che il circuito combinatorio
cui siamo pervenuti presenta 4 pin di ingresso per xA e 4 pin di ingresso per xB, allora i due
ingressi arrivano in modalità parallelo (4 bit per ciascuno alla volta): sotto questa condizione,
il circuito combinatorio risulta effettivamente più veloce di quello sequenziale; al contrario, se
anche l’ingresso al circuito combinatorio dovesse arrivare in modo seriale (per esempio in
modo sincrono ad un clock esterno3), allora i due circuiti (sequenziale e combinatorio)
risultano del tutto equivalenti in termini di velocità di risposta.
Concludiamo l’argomento osservando che, nel caso dei circuiti a celle iterative, si usa una
denominazione diversa, rispetto ai circuiti sequenziali, per le variabili di stato y (stato presente) ed Y
(stato successivo): le prime prendono il nome di riporti di ingresso, mentre le altre prendono il
nome di riporti di uscita.
Registri
INTRODUZIONE AI REGISTRI
Abbiamo visto che un circuito sequenziale sincrono consiste in un gruppo di flip-flop e di
porte logiche connessi in modo da formare un percorso di retroazione. I flip-flop sono essenziali in
quanto, in loro assenza, il circuito si riduce ad una pura rete combinatoria. Al contrario, in presenza
di almeno un flip-flop, ma in assenza di porte logiche, il circuito continua ad essere di tipo
sequenziale.
Certi circuiti MSI (Medium Scale of Integration) che includono flip-flop sono classificati in base
alle operazioni che compiono più che al loro nome vero e proprio. Circuiti di questo tipo, che
analizzeremo in questi paragrafi, sono i registri e i contatori.
Un registro può essere semplicemente visto come un insieme di celle di memoria, ognuna
utilizzabile per memorizzare una informazione binaria, cioè 1 bit. Il registro è
costituito da un gruppo di flip-flop, ognuno dei quali rappresenta
una cella del registro, ossia viene utilizzato per la memorizzazione
di 1 bit. Un registro da N bit è dunque costituito da N flip-flop. In aggiunta ai flip-flop, un
registro può avere anche porte logiche che svolgono determinate funzioni, alcune delle quali
particolarmente importanti: sinteticamente, possiamo affermare che i flip-flop memorizzano i bit,
mentre le porte logiche cui sono connessi servono a stabilire quando e come delle nuove
informazioni binarie devono essere memorizzate.
Esistono vari tipi di registri realizzati mediante circuiti MSI. Il registro più semplice è quello
costituito da soli flip-flop, senza alcuna porta logica. La figura seguente ne mostra un esempio:
3
Dire che un ingresso è sincrono con un clock significa dire che i bit che compongono l’ingresso non arrivano in istanti qualsiasi,
ma in corrispondenza di istanti ben precisi, legati agli impulsi di clock: ad esempio, i bit possono giungere in corrispondenza dei
fronti di salita degli impulsi di clock.
21
Il registro è realizzato mediante 4 flip-flop di tipo D: i terminali D dei flip-flop rappresentano gli
ingressi del circuito, mentre i terminali Q rappresentato le uscite.
Tutti i flip-flop sono connessi ad uno stesso clock4, il quale, come noto, li abilita (cioè consente
eventuali transizioni di stato e di uscita) solo quando è ad 1: ciò significa che l’applicazione
dell’ingresso e una eventuale variazione dell’uscita si possono avere solo quando il clock si trova ad
1.
Quindi, il clock si comporta come un segnale che controlla il caricamento di nuove informazioni
binarie nel registro: quando il clock va ad 1, l’informazione in ingresso viene caricata nel registro;
quando il clock rimane a 0, il contenuto del registro rimane invariato.
Osservazione sul clock
E’ importante osservare una cosa circa il clock: quando abbiamo introdotto i
flip-flop, abbiamo detto che, a differenza dei latch, essi commutano o durante
i fronti di salita del clock o durante quelli di discesa (al contrario dei latch,
che invece possono commutare in un istante qualsiasi in cui il clock sia al
livello alto). Se non ci sono particolari indicazioni in proposito, i flip-flop
commutano durante i fronti di salita del clock (positive edge triggered):
questo è indicato, sul simbolo circuitale del flip-flop, mediante un triangolino
in corrispondenza del morsetto del clock:
FLIP-FLOP
X
D
Q
Z
clock
Se, invece, il flip-flop commuta in corrispondenza dei fronti di discesa del
clock (negative edge triggered), allora si usa un triangolino con
all’interno un cerchietto:
4
Ogni flip-flop ha evidentemente un pin destinato all’applicazione dell’impulso di clock: tale pin prende il nome di clock-pulse
input e si indica brevemente con CP oppure con ck.
22
FLIP-FLOP
D
X
Q
Z
clock
E’ abbastanza evidente che, partendo da un flip-flop progettato per commutare
sugli impulsi di salita del clock, si può facilmente passare ad un flip-flop che
commuti sugli impulsi di discesa semplicemente applicando un clock negato:
FLIP-FLOP
X
D
Q
Z
clock
Nel seguito, salvo diversa indicazione, tralasceremo di specificare se il
generico flip-flop commuta con il clock in salita o in discesa, ma negli schemi
circuitali reali è necessario conoscere come vadano le cose.
REGISTRO A SCORRIMENTO (SHIFT REGISTER)
La figura seguente mostra un registro a scorrimento realizzato mediante flip-flop di tipo D
posti in cascata:
Si tratta di un registro particolare, dove la particolarità deriva dall’aver adottato un ingresso
seriale ed una uscita seriale: ciò significa che un eventuale ingresso può essere applicato 1 bit alla
volta e, in modo analogo, che l’uscita può eventualmente essere letta 1 bit alla volta. In generale, ci
sono 4 possibilità:
23
Sia l’ingresso sia l’uscita possono essere di tipo SERIALE (1 bit alla volta, in modo sincrono con
il clock) oppure di tipo PARALLELO (un certo numero di bit alla volta, sempre sincronicamente
con il clock)5. Generalmente, sono disponibili, sullo stesso registro, più possibilità. Ad esempio, con
riferimento al registro disegnato prima, basta aggiungere dei pin che rendano disponibili i morsetti Q
dei vari flip-flop per ottenere l’ uscita parallela, da aggiungere a quella seriale (indicata con Z):
Con questo schema, possiamo inserire le informazioni 1 bit alla volta (serial in), ma possiamo
leggere il contenuto del registro sia 1 bit alla volta (serial out) sia per intero (parallel out).
Ricordiamo, inoltre, che il trasferimento di una nuova informazione in un registro prende il nome
di “caricamento” (loading) del registro stesso: in base a quanto appena detto, il loading può essere
parallelo oppure seriale.
Vediamo adesso per quale motivo questo tipo di registro prende il nome di registro a
scorrimento.
Cominciamo col ricordare la tabella di pilotaggio dei flip-flop di tipo D (il cui funzionamento può
essere anche semplicemente rappresentato dalla relazione booleana Q+=D)
Q Q+
0 0
0 1
1 0
1 1
D
0
1
SET
0 RESET
1
Supponiamo di partire da una condizione iniziale in cui tutti i flip-flop sono azzerati, per cui le
uscite Z1, Z2, Z3 e Z4(=Z) sono tutte a 0. Il flip-flop contiene dunque l’informazione 0000.
Supponiamo inoltre di applicare, in un certo istante, un 1 in ingresso (per cui, fisicamente, si tratterà
5
In generale, un sistema digitale opera in modo seriale quando le informazione sono trasferite
e manipolate 1 bit alla volta.
24
di portare il pin X alla tensione di alimentazione, ad esempio 5 V). Sappiamo che il flip-flop 1, cui è
applicato questo ingresso, non risente dell’influenza di questo ingresso finche l’impulso di clock non
va ad 1. Nel momento in cui l’impulso di clock giunge ad 1, il primo flip-flop, avendo inizialmente
Q1=0 e risentendo di D1=1, passa a Q1=1. Questo Q1=1 è adesso un nuovo ingresso per il flip-flop 2,
che si trova nella stessa condizione iniziale del flip-flop 1: di conseguenza, al secondo colpo di
clock, anche il flip-flop 2 passa a Q=1 e così via per gli altri due flip-flop (il FF 3 passa a Q3=1 al
terzo colpo di clock, mentre il FF 4, cioè l’uscita, passa a Q4=1 al quarto colpo di clock). In pratica, è
successo che l’1 iniziale applicato in ingresso si è “spostato” dal primo al quarto flip-flop,
“scorrendo” quindi per tutto il registro. Da qui la denominazione di registro a scorrimento (shift
register).
Ovviamente, mentre abbiamo accertato che il FF 4 passa a Q4=1 dopo 4 colpi di clock, dobbiamo
preoccuparci anche di quello che succede agli altri flip-flop durante questi 4 colpi di clock.
Supponiamo, per esempio, che l’1 applicato in ingresso venga mantenuto per tutti e 4 i colpi di
clock:
• il FF 1, che dopo il primo colpo di clock è passato a Q1=1, al secondo colpo di clock, ha 1 in
ingresso ed 1 in uscita, per cui, in base alla tabella di pilotaggio, lascia invariata ad 1 la sua
uscita;
• di conseguenza, il FF 2, che al secondo colpo di clock è passato a Q2=1, ha ancora un 1
ingresso al terzo colpo di clock , per cui anch’esso rimane ad 1 e così via gli altri due.
Possiamo perciò sintetizzare il tutto con la seguente tabella:
clock
X = D1
Q1 = D 2
Q2 = D3
Q3 = D 4
Q4 = Z
iniziale
1
0
0
0
0
1
1
1
0
0
0
2
1
1
1
0
0
3
1
1
1
1
0
4
1
1
1
1
1
Adesso vediamo cosa succede se, dopo aver posto X=1 per il primo colpo di clock, riportiamo X a
0 a partire dal secondo colpo di clock in poi. In questo caso, è facile vedere che le transizioni
diventano le seguenti:
clock
iniziale 1 2 3 4
X = D1
1
1 0 0 0
Q1 = D 2
0
1 0 0 0
Q 2 = D3
0
0 1 0 0
Q3 = D 4
0
0 0 1 0
Q4 = Z
0
0 0 0 1
Il primo flip-flop, che al primo colpo di clock commuta ad 1, al secondo colpo di clock si trova
con uno 0 in ingresso e un 1 in uscita, per cui, sempre in base alla tabella di pilotaggio, si porta a 0 e
ivi rimane, nei successivi istanti di clock, dato che il suo ingresso rimane permanentemente a 0.
Analogamente, il secondo flip-flop commuta ad 1 al secondo colpo di clock, in quanto si trova
con uscita a 0 e con ingresso ad 1, ma poi commuta nuovamente a 0 al terzo colpo di clock in quanto,
trovandosi con uscita a 1, riceve ingresso a 0.
Analogo discorso per gli altri due flip-flop.
25
In questo modo, è ancora più evidente lo scorrimento: l’1 applicato in ingresso si “propaga”
attraverso il registro, presentandosi in uscita con un ritardo di 4 colpi di clock. In questo senso,
quindi, si capisce come un registro a scorrimento si comporti essenzialmente come un ritardatore
dell’ingresso: la sequenza binaria applicata in ingresso si ripresenta in
uscita con un ritardo pari a N colpi di clock, dove N è il numero di
flip-flop da cui il registro è costituito. Se, ad esempio, la sequenza di
ingresso è lunga M bit, allora avremo bisogno di N+M colpi di clock, a partire da quello in cui la
sequenza viene applicata, per rivederla, identica, in uscita.
Evidentemente, questo è il funzionamento di un registro a scorrimento con SERIAL IN e SERIAL
OUT. D’altra parte, avendo detto che basta disporre dei pin collegati alle uscite Q dei flip-flop per
leggere l’uscita in parallelo, possiamo anche usare il registro in modo SERIAL IN e PARALELOUT: così facendo, non facciamo altro che convertire la sequenza in ingresso da seriale a parallela.
Per esempio, con un registro a scorrimento ad N celle, possiamo convertire una parola seriale di 2N
bit in due parole parallele da N bit ciascuna: inviando in ingresso (in modo seriale) la sequenza, dopo
i primi N colpi di clock potremo leggere (contemporaneamente) i primi N bit, e dopo i successivi N
colpi di clock potremo leggere (sempre contemporaneamente) i rimanenti N bit.
Possiamo anche fare l’operazione inversa, ossia la conversione da sequenza parallela e sequenza
seriale: infatti, disponendo di un registro a scorrimento che dispone di PARALEL IN e di SERIAL
OUT, possiamo inviare la sequenza di ingresso N bit alla volta e possiamo leggerla in modo seriale
all’uscita, 1 bit alla volta. Consideriamo, per esempio, una sequenza lunga 2N bit: al primo colpo di
clock, inviamo i primi N bit, contemporaneamente, nel registro; i successivi N colpi di clock servono
a leggere tali N bit, facendoli scorrere nel registro; un successivo colpo di clock serve a memorizzare
gli altri N bit, dopo di che servono altri N colpi di clock per leggere tali bit. Alla fine, servono 2N+2
colpi di clock per leggere l’intera parola in modo seriale.
Riepilogando, quindi, un registro a scorrimento può fondamentalmente comportarsi in 3 modi
differenti:
IN
OUT
1 seriale
seriale
2 seriale parallelo
3 parallelo seriale
Scarsa importanza ha invece un registro a scorrimento con ingresso e uscita entrambi paralleli.
SEGNALI DI CONTROLLO
Questi sono dunque i principi di funzionamento di un registro a scorrimento. In realtà, perché sia
possibile ottenere funzionamenti di questo tipo, è necessario predisporre alcuni particolari segnali di
controllo (da aggiungere, ovviamente, al segnale di clock, detto in questi casi shift pulse, ossia
impulso di scorrimento, per i motivi descritti prima).
Un primo tipo di segnale di controllo è il CLEAR, che serve ad azzerare il contenuto dei flip-flop
(quindi del registro) all’istante iniziale, in modo che possa iniziare la memorizzazione. Tutti i flipflop dispongono di un pin per l’applicazione del segnale di CLEAR: quando il clear va a 0, il flipflop viene azzerato in modo asincrono; dopo di che, il clear va messo ad 1 durante le normali
operazioni sincrone del flip-flop.
In molti circuiti integrati contenenti flip-flop di tipo D, esiste un apposito pin che serve a mandare
il segnale di clear a tutti i flip-flop (così come esiste l’apposito pin per l’applicazione di un clock
comune a tutti i flip-flop); ad esempio, nella figura seguente è riportato lo schema interno di un
integrato contenente 8 flip-flop di tipo D, con segnali di clear e di clock comuni a tutti i flip-flop:
26
Un integrato come questo può essere appunto utilizzato, disponendo gli opportuni collegamenti
tra i pin, per realizzare un registro a scorrimento a 8 celle: basta collegare la Q di ciascun flip-flop
con la D del successivo, eccezion fatta per il primo flip-flop (il cui morsetto D rappresenta l’ingresso
al registro) e per l’ultimo flip-flop (il cui morsetto Q rappresenta l’uscita del registro).
Tanto per comprendere il funzionamento del segnale di CLEAR, consideriamo uno shift register
costituito da 4 flip-flop di tipo D in cascata, come indicato nella figura seguente:
La condizione iniziale dei flip-flop non può essere deterministica, ma necessariamente causale. Di
conseguenza, quando dobbiamo cominciare a memorizzare informazioni, dobbiamo per prima cosa
inizializzare o resettare tutti i flip-flop, il che si ottiene appunto con il segnale di CLEAR: questo
segnale, nelle normali condizioni di funzionamento, è sempre ad 1, mentre va posto a 0, per un
intervallo di tempo anche molto breve, nel momento in cui si intende resettare i flip-flop, ossia
azzerare il loro contenuto. Non essendo un segnale sincrono, il CLEAR non ha bisogno di un clock
pari ad 1 per avere effetto: ciò significa che, non appena il CLEAR viene posto a 0, immediatamente
i flip-flop si azzerano, dopo di che il CLEAR può essere riportato ad 1 e lasciato a questo valore.
Serviamoci di una simulazione P-Spice per osservare il comportamento del registro, supponendo
di inviare in ingresso un 1 seguito da tanti 0. La figura seguente mostra l’andamento temporale delle
diverse variabili coinvolte:
27
Il segnale più in alto è l’onda quadra del clock. Sotto di esso c’è il segnale di CLEAR, che
presenta una transizione iniziale 1→0, molto veloce, necessaria all’azzeramento dei flip-flop. Non
appena il CLEAR viene posto a 0, si nota che le 4 uscite vanno immediatamente a 0, dopo di che il
CLEAR viene riportato ad 1 per le normali condizioni di funzionamento.
Dopo un intervallo di tempo pari a poco meno di 2 periodo di clock, viene applicato un ingresso,
che consta di un 1 seguito da un certo numero di zeri. In corrispondenza del primo fronte di salita del
clock che giunge dopo l’applicazione dell’ 1 in ingresso, il primo flip-flop si trova con un 1 in
ingresso ed uno 0 in uscita, per cui commuta, portando ad 1 la propria uscita. Gli altri flip-flop,
invece, rimangono a 0, in quanto, in corrispondenza dello stesso fronte di salita del clock, hanno sia
l’ingresso sia l’uscita a 0. Al successivo impulso di clock, il secondo flip-flop si trova con uscita=0 e
ingresso=1, per cui commuta ad 1; contemporaneamente, il primo flip-flop si trova con uscita=1 e
ingresso=0, per cui commuta a 0. Gli altri due flip-flop rimangono invece invariati. Come si osserva
dagli andamenti temporali, l’1 in ingresso si è spostato dal primo al secondo flip-flop. Al successivo
colpo di clock, il meccanismo si ripete: il primo flip-flop rimane fermo, il secondo commuta a 0, il
terzo commuta ad 1 ed il quarto rimane fermo. All’ulteriore colpo di clock, è il quarto flip-flop che
commuta, presentando così 1 all’uscita del registro, mentre gli altri sono a 0. In definitiva, l’1
applicato in ingresso si ritrova in uscita dopo 4 colpi di clock dall’istante in cui è stato applicato,
come ci aspettavamo.
Un altro segnale di controllo importante è quello che consente di scegliere la direzione dello
scorrimento dei bit nel registro: da sinistra verso destra (SHIFT RIGHT), come nel caso precedente,
oppure da destra verso sinistra (SHIFT LEFT). Consideriamo ad esempio un registro a scorrimento
formato da un certo numero di flip-flop di tipo D e consideriamo, in particolare 3 flip-flop
consecutivi: per realizzare lo scorrimento verso destra (shift right), lo schema da adottare è quello
visto prima; per realizzare, invece, lo scorrimento verso sinistra, basta fare in modo che l’uscita di
ciascun flip-flop faccia da ingresso al precedente, come indicato nella figura seguente (relativamente
ai 3 flip-flop intermedi di cui si diceva poco fa):
Se volessimo predisporre sia lo scorrimento verso destra sia quello verso sinistra (shift left), in
base al valore di un apposito segnale di controllo, ci basterebbe adottare uno schema del tipo
seguente:
28
Vediamo come funziona questo schema:
• supponiamo che il segnale indicato con shift direction valga 1: questo significa che le porte
AND numero 2 e 4, nelle quali questo segnale arriva complementato, danno uscita 0, mentre le
porte 1 e 3 danno in uscita il valore dell’altro ingresso che ricevono: tale ingresso è l’uscita del
flip-flop precedente, per cui il funzionamento è esattamente quello dello scorrimento verso
destra;
• al contrario, se il segnale shift direction vale 0: le porte 1 e 3 danno uscita 0, mentre le porte
2 e 4 danno uscita pari all’altro ingresso che ricevono; questo ingresso è l’uscita del flip-flop
verso destra, per cui lo scorrimento avviene in questo caso verso sinistra.
Come si vede, quindi, impostando ad 1 o a 0 il segnale shift direction, si ottiene, rispettivamente,
lo scorrimento verso destra o verso sinistra.
E’ bene comunque osservare una cosa circa la direzione di scorrimento di un registro a
scorrimento. Consideriamo infatti lo stesso registro a scorrimento considerato all’inizio:
Abbiamo mostrato che, applicando l’ingresso al morsetto X, lo ritroviamo, identico, all’uscita
dopo 4 colpi di clock: abbiamo perciò uno scorrimento verso destra.
In realtà, si può anche ottenere, dallo stesso circuito, uno scorrimento verso sinistra: basta
applicare l’ingresso al morsetto Z e leggere l’uscita al morsetto X.......(?)...
Quindi, con uno stesso registro, si può ottenere indifferentemente o lo scorrimento verso destra o
quello verso sinistra. Se, invece, si vogliono predisporre entrambi i tipi di scorrimento, scegliendo
poi quello desiderato, allora bisogna usare il segnale shift direction descritto prima.
Ci sono inoltre dei segnali di controllo che sono comuni a tutti i tipi di registri e non solo a quelli
di scorrimento. Vediamone alcuni.
29
Molti sistemi digitali hanno un clock principale (master-clock) applicato a tutti i registri e, in
generale, a tutti i flip-flop del sistema: questo clock principale pilota, dunque, l’intero sistema.
Aggiunto ad esso, ci può essere poi un separato segnale di controllo, che
stabilisce quali particolari impulsi del clock principale devono
avere effetto su un particolare registro. In sistemi di questo tipo, quindi, il
clock principale va in AND con il segnale di controllo e solo l’uscita dell’ AND viene applicata al
morsetto di clock del registro considerato. Ad esempio, con riferimento ancora al registro a
scorrimento a 4 bit considerato nei paragrafi precedenti, la situazione è la seguente:
Quando il segnale di controllo è a 0, l’uscita dell’ AND è a sua volta 0, per cui l’informazione
memorizzata nel registro rimane invariata, per qualunque ingresso X applicato. Se, invece, il segnale
di controllo è ad 1, allora il clock principale “attraversa” la porta AND e risulta applicato al registro,
il cui contenuto, quindi, cambia, ad ogni colpo di clock.
Il segnale di controllo utilizzato prende il nome di shift control input.
Una tipica applicazione di questo segnale avviene quando si vuole che solo un certo numero di
impulsi di clock abbiamo effetto su un dato registro: ad esempio, avendo un registro a scorrimento a
4 bit, per utilizzarlo come un ritardatore di 1 bit (quindi con serial in, cui viene applicata la sequenza
1000, e serial out, da cui si vuole ottenere 1 dopo 4 colpi di clock), basta fare in modo che solo 4
impulsi di clock consecutivi abbiano effetto sul registro. Allora, lo shift control input servirà appunto
a scegliere i 4 impulsi di clock consecutivi desiderati: applicando, in ingresso al registro, la sequenza
1000 (1 bit per ogni colpo di clock), dopo i 4 colpi di clock selezionati l’uscita del registro sarà 1.
C’è però da fare una osservazione: inserendo una porta AND nel percorso che il clock principale
segue per arrivare ai singoli registri, si introduce un ritardo di propagazione del segnale tra il
generatore del clock principale e il pin ck dei registri. Allora, per sincronizzare perfettamente il
sistema comprendente tutti i registri (e in generale tutti i flip-flop), bisogna necessariamente fare in
modo che tutti gli impulsi di clock arrivino, nello stesso istante, agli ingressi di clock dei singoli
componenti, in modo che questi ultimi possano cambiare tutti contemporaneamente il loro stato. Da
questo punto di vista, la presenza di porte logiche sui percorsi seguiti dagli impulsi di clock può
essere di ostacolo: per questo, molto spesso si evita di inserire tali porte, ossia si evita di usare
segnali di controllo sul clock, mentre si preferisce usare altri segnali di controllo, che invece
agiscono direttamente sugli ingressi, stabilendo quando essi vanno applicati ai rispettivi flip-flop e
quando no: questi segnali sono detti di load control input.
Un segnale di load control input esegue una funzione analoga a quella dello shift control input,
ma non più sul clock, bensì sugli ingressi: nonostante la presenza continua degli
impulsi di clock, è il segnale di load input che controlla le
operazioni del registro. Questo avviene con uno schema del tipo seguente:
30
Anche in presenza di un ingresso e di un clock ad 1, l’effetto dell’ingresso è nullo finche il load
input vale 0, per cui il registro conserva invariate le proprie informazione. Quando, invece, il load
input è ad 1, allora l’ingresso è abilitato e quindi, ad ogni colpo di clock, si ha una variazione del
contenuto del registro.
APPLICAZIONE: ACCUMULATORE
Nei calcolatori digitali, le operazioni vengono tipicamente effettuate in parallelo, in quanto questo
è il modo più veloce di operare. Le operazioni seriali sono invece più lente, ma necessitano di
hardware più semplice.
Il nostro scopo è quello di realizzare un addizionatore seriale completo. In particolare, abbiamo
già visto in precedenza come è possibile realizzare questo circuito usando una macchina sequenziale.
Lo schema logico che, a suo tempo, abbiamo ottenuto, è il seguente:
La parte di memoria è rappresentata da un solo flip-flop di tipo D, mentre la parte combinatoria
(necessaria a produrre l’uscita nonché il carry per la somma successiva) è quella indicata. Questa
parte combinatoria non è altro che un full-adder, per cui la macchina è scomponibile,
essenzialmente, in un full-adder e in un flip-flop di tipo D necessario a tener memorizzato il carry
della somma precedente.
Da questo schema si giunge al cosiddetto accumulatore semplicemente aggiungendo dei registri a
scorrimento necessari a contenere sia i due operandi da sommare sia la loro somma:
31
I due numeri binari che si vogliono sommare vengono inizialmente memorizzati in due registri a
scorrimento, del tipo descritto nei paragrafi precedenti. Tali due numeri vengono quindi prelevati dai
due registri in modo seriale, ossia 1 bit alla volta; ad ogni colpo di clock, i due bit prelevati vengono
quindi sommati da un singolo addizionatore completo (full-adder); il compito di questo full-adder è
duplice: da un lato, esso trasferisce il risultato binario della somma ad un terzo registro di
scorrimento, nel quale verrà memorizzato il risultato finale dell’operazione; dall’altro, esso manda il
bit del carry (riporto) ad un flip-flop di tipo D, che ha il compito di conservarlo e di ripresentarlo in
ingresso allo stesso full-adder per la somma dei 2 bit successivi. Inizialmente, è ovvio che il carry in
è posto a zero.
I tre registri di scorrimento ed il flip-flop hanno tutti lo stesso clock, mentre il full-adder, essendo
un circuito combinatorio, non lavora in modo sincrono, cioè non è pilotato da alcun clock.
E’ interessante osservare una cosa: man mano che il circuito esegue la somma richiesta, i bit che
compongono i due operandi vengono shiftati verso destra nei rispettivi registri; allora, per la
memorizzazione del risultato finale, si può pensare di utilizzare direttamente uno dei registri che
contengono gli operandi: al primo colpo di clock, la prima coppia di bit non significativi viene
estratta dai due registri a scorrimento e sommata, per cui il risultato della somma, anziché essere
trasferito nella cella più a sinistra del terzo registro a scorrimento, può essere inviata nella cella più a
sinistra di uno qualsiasi dei due registri di partenza. Se poi, al risultato ottenuto, andrà sommato un
ulteriore addendo, questo andrà evidentemente sistemato nell’altro registro e così il processo può
ripetersi per infinite somme. In questo modo, scegliendo per esempio di memorizzare il risultato nel
registro n° 1, si ottiene un incremento progressivo del contenuto di questo registro.
A questo punto, possiamo fare un confronto tra l’addizionatore seriale appena descritto e
l’addizionatore parallelo descritto in precedenza. Si notano le seguenti differenze:
• l’addizionatore parallelo deve usare registri con PARALLEL IN, mentre l’addizionatore seriale
usa registri a scorrimento;
• il numero di circuiti full-adder necessari a realizzare l’addizionatore parallelo è pari al numero
di bit di cui si compongono gli operandi, mentre l’addizionatore seriale necessita di un unico
full-adder;
• l’addizionatore parallelo, escludendo i registri necessari alla memorizzazione, è un circuito
puramente combinatorio, mentre l’addizionatore seriale è un circuito sequenziale.
32
Infine, osserviamo che il circuito sequenziale dell’addizionatore seriale consiste
fondamentalmente del full-adder e del flip-flop che memorizza il carry (in particolare l’output carry):
questo è tipico dei circuiti che realizzano operazioni seriali, visto che il risultato della somma di due
bit può dipendere non solo dai bit stessi, ma anche dalla somma dei bit precedenti.
Contatori
INTRODUZIONE
Si definisce contatore un circuito logico sequenziale che conta gli
impulsi di clock. Per effettuare questo conteggio, un contatore è chiaramente fatto in modo
che ad ogni nuovo impulso di clock la sua uscita assuma una configurazione diversa: molto
semplicemente, l’uscita è un numero binario che rappresenta il numero d’ordine dell’ultimo impulso
di clock.
E’ chiaro che un contatore non può contare infiniti colpi di clock, ma avrà un numero massimo di
impulsi di clock conteggiabili: questo numero è il cosiddetto modulo del contatore ed è usato
appunto per distinguere un contatore da un altro. Nei cosiddetti contatori binari, il modulo è
sempre una potenza di 2, ma ci sono anche contatori non binari, come per esempio i contatori a
decade, dove il modulo è un multiplo di 10.
Un esempio di contatore binario è il contatore modulo 16, che può cioè contare un massimo di
16 impulsi di clock (che saranno numerati da 0 a 15). Quando il contatore ha contato un numero di
impulsi di clock pari al suo modulo, il conteggio riparte da 0.
Per un contatore modulo N, sono necessarie N diverse configurazioni, ottenibili con un numero k
di flip-flop tale che 2k=N: ad esempio, un contatore modulo 16 sarà costituito da 4 flip-flop, in
quanto 24=16.
Mettendo in cascata più contatori, si può ottenere un contatore di modulo maggiore: per esempio,
si può osservare che, ponendo in cascata un contatore modulo 5 e un contatore modulo 12, si ottiene
un unico contatore modulo 60, particolarmente utile negli orologi digitali.
CONTATORE MODULO 8
Consideriamo un contatore modulo 8: esso dovrà prevedere 8 stati diversi, per cui necessiterà di 3
flip-flop (23=8). Possiamo pensare di sintetizzare il contatore mediante una macchina di Moore, cui
assoceremo un diagramma degli stati fatto nel modo seguente:
A
B
H
C
G
D
F
E
33
Dovremmo scegliere l’assegnamento ottimale, per sintetizzare questa macchina, ma la scelta è
immediata: infatti, se associamo l’uscita direttamente allo stato, abbiamo che
stato / uscita A / 0 B / 1 C / 2 D / 3 E / 4 F / 5 G / 6 H / 7
codice
000 001 010 011 100 101 110 111
Possiamo dunque contare 8 impulsi di clock, che saranno numerati da 0 a 7: quando il contatore
ne ha contati 7, al successivo torna nello stato iniziale e riprende il conteggio da 0.
La tabella degli stati è immediata:
s.p. s.s.
A B
B C
C D
D E
Z
000
001
010
011
E
F
G
H
100
101
110
111
F
G
H
A
y1 y 2 y 3 Y1Y2 Y3
A = 000
001
B = 001
010
C = 010
011
D = 011
100
E = 100
101
F = 101
110
G = 110
111
H = 111
000
Z
000
001
010
011
100
101
110
111
Per codificare tali stati, abbiamo bisogno di 3 variabili di stato (y1,y2,y3 per lo stato presente e
Y1,Y2,Y3 per lo stato successivo). Andiamo allora a sintetizzare, con i metodi tradizionali, le
funzioni Y1,Y2,Y3 .
I contatori vengono tipicamente realizzati usando flip-flop di tipo T, dei quali ricordiamo la
tabella di pilotaggio:
Q Q+ T
0 0 0
0 1 1
SET
1 1 0
1 0 1 RESET
In base a questa tabella, la funzione T ha un 1 (cioè un mintermine) solo quando l’uscita
commuta. Di conseguenza, per determinare le mappe di Karnaugh delle funzioni T1=Y1, T2=Y2 e
T3=Y3 , dobbiamo semplicemente verificare per quali combinazioni di y1,y2,y3 si ottiene una
commutazione:
• funzione T1 → la funzione ha un 1 quando y1 è diversa da Y1 e si osserva che questo accade in
corrispondenza degli stati D ed H: infatti, da D=011 si passa ad E=100, mentre da H=111 si
passa ad A=000:
34
y1 y 2 y 3
000
001
010
011
100
101
110
111
Y1Y2 Y3 Z
001
000
010
001
011
010
100
011
101
100
110
101
111
110
000
111

→
y1 y 2 \ y 3
00
01
11
10
0
1
0
1
2
1
7
1
3
6
4

→
Y1 = T1 = y 2 y 3
5
corrispondenza di 4 stati:
y1 y 2 y 3
000
001
010
011
100
101
110
111
Y1Y2 Y3 Z
001
000
010
001
011
010
100
011
101
100
110
101
111
110
000
111

→
y1 y 2 \ y 3
00
01
11
10
0
0
2
6
4
1
1
3
1
7
1
5
1
1

→
Y2 = T2 = y 3
• funzione T3 → la funzione ha un 1 quando y3 è diversa da Y3 e si osserva che questo accade per
tutte le transizioni di stato: di conseguenza, otterremmo una mappa di Karnaugh con tutte le
caselle riempite, il che significa che
Y3 = T3 = 1
ossia che il terzo flip-flop commuta ad ogni impulso di clock, come è ovvio che sia, visto che
esso rappresenta la cifra meno significativa del conteggio, la quale varia ad ogni impulso di
clock.
Possiamo dunque sintetizzare il circuito sequenziale che si comporta da contatore modulo 8. In
particolare, anziché usare direttamente flip-flop di tipo T, possiamo usare flip-flop di tipo J-K, nei
quali però gli ingressi J e K siano cortocircuitati (questa è infatti proprio la definizione di flip-flop di
tipo T):
35
In questo schema, la cifra meno significativa del conteggio è n1, mentre quella più significativa è
n3: abbiamo cioè indicato con n1 la funzione T3 e con n3 la funzione T1.
Vediamo se il conteggio funziona effettivamente, usando una simulazione con P-Spice:
La figura mostra gli andamenti temporali delle variabili che ci interessano:
• il segnale più in alto è l’onda quadra corrispondente al clock comune ai 3 flip-flop;
• il successivo segnale è il segnale di CLEAR, che serve a resettare il contatore prima che inizi il
conteggio: tale segnale è normalmente ad 1 e va portato a 0 nel momento in cui si vuol
resettare. Non essendo un segnale sincrono, il CLEAR agisce immediatamente sui flip-flop,
portando le rispettive uscite a 0, come si nota dai corrispondenti andamenti temporali;
• per la simulazione, sono stati usati flip-flop che commutano sui fronti negativi del clock:
∗ durante il primo impulso di clock, durante il quale il contatore è stato resettato, sia n1
sia n2 sia n3 sono a 0;
∗ appena finisce l’impulso, n1 commuta ad 1, mentre n2 ed n3 rimangono a 0: questo
significa, essendo n1 la cifra meno significativa, che il contatore ha contato l’
impulso di clock avente numero d’ordine 1 (cioè ha contato 2 colpi di clock);
∗ all’arrivo del successivo impulso di clock, n1 torna a 0, n3 rimane a 0, mentre n2 va
ad 1: la configurazione binaria è dunque 010 e corrisponde al conteggio del colpo di
clock di numero d’ordine 2;
∗ si procede in questo modo fino a quando risulta n1=n2=n3=1: questa configurazione
si ha quando il contatore ha contato l’impulso di clock di numero d’ordine 7, cioè l’8°
colpo di clock da quando è iniziato il conteggio;
∗ all’ulteriore colpo di clock, risulta nuovamente n1=n2=n3=0, a conferma del fatto che
il conteggio è ripreso.
36
Il caso appena analizzato è quello in cui il CLEAR del contatore viene fatto durante un impulso di
clock; nella figura seguente è invece mostrato quello che accade se il CLEAR avviene mentre il
clock è a 0:
E’ evidente che anche in questo caso il conteggio funziona perfettamente: durante il primo
impulso di clock, tutte le uscite sono a 0; durante il secondo impulso di clock, solo n1 è ad 1 e così
via, fino all’ottavo colpo di clock, durante il quale tutte le uscite sono ad 1. Al colpo di clock
successivo, le uscite si azzerano ed il conteggio riprende.
Contatori up, down e up-down
E’ possibile realizzare contatori che contino, anziché in avanti come nel caso precedente,
all’indietro: se il conteggio avviene in avanti, come nel caso appena considerato, si parla di
contatori UP (up counter) mentre, se il conteggio avviene all’indietro, si parla di contatori
DOWN (down counter).
Un contatore DOWN ha evidentemente un diagramma degli stati identico ad un contatore UP, ma
con gli archi orientati nel verso opposto:
A
B
H
C
G
D
F
E
La corrispondente tabella degli stati e delle uscite è allora la seguente:
y1 y 2 y 3 Y1 Y2 Y3
A = 000
111
B = 001
000
C = 010
001
D = 011
010
E = 100
011
F = 101
100
G = 110
101
H = 111
110
37
Z
000
001
010
011
100
101
110
111
Procediamo allora alla sintetizzazione di questo contatore, procedendo in modo del tutto analogo
a quanto fatto prima (usando ancora flip-flop di tipo J-K con i morsetti J e K cortocircuitati):
corrispondenza degli stati A ed E:
y1 y 2 y 3
000
001
010
011
100
101
110
111
Y1 Y2 Y3
Z
111
000
000
001
001
010
010
011
011
100
100
101
101
110
110
111

→
y1 y 2 \ y 3
00
01
11
10
0 1
1 1
0
2
3
6
7
1
5
4

→
Y1 = T1 = y' 2 y 3
corrispondenza di 4 stati:
y1 y 2 y 3
000
001
010
011
100
101
110
111
Y1 Y2 Y3
111
000
001
010
011
100
101
110
Z
000
001
010
011
100
101
110
111

→
y1 y 2 \ y 3
00
01
11
10
0 1
1 1
2
1 3
6
1 7
4
1 5
0

→
Y2 = T2 = y'3
• funzione T3 → la funzione ha un 1 quando y3 è diversa da Y3 e si osserva che, ancora una volta,
questo accade per tutte le transizioni di stato: di conseguenza, abbiamo ancora che
Y3 = T3 = 1
Possiamo dunque disegnare il circuito logico:
38
La cifra meno significativa è n3, che commuta ad ogni impulso di clock, mentre la cifra più
significativa è la n1.
Facciamo osservare che lo schema appena tracciato può essere semplificato considerando che sia
il FF 3 sia il FF 2 possono già darci in uscita direttamente l’uscita negata, senza perciò dover
ricorrere alle due porte NOT:
La maggior parte dei contatori sono progettati in modo da poter contare sia in avanti sia
all’indietro e si parla in questo caso di up-down counter: essi prevedono infatti un apposito
ingresso di controllo, che stabilisce la direzione di conteggio.
E’ abbastanza facile comprendere quale possa essere lo schema di un up-down counter, se
confrontiamo lo schema del contatore down appena tracciato con lo schema del corrispondente
contatore up:
Facendo il confronto, si osserva che non cambia niente per il FF 3, mentre ci sono due sole
differenze per i flip-flop 2 ed 1:
39
• l’ingresso del FF 2 è y3 per il contatore up, mentre è y’3 per il contatore down;
• in modo analogo, l’ingresso al FF 2 è l’AND di y3 con y2 nel caso del contatore up oppure con
y’2 nel caso del contatore down.
Allora, per realizzare un contatore up-down, dobbiamo semplicemente predisporre un segnale di
controllo che selezioni le possibilità appena elencate. E’ facile accorgersi che lo schema da utilizzare
è il seguente:
Il segnale denominato controllo effettua la selezione tra conteggio in avanti e conteggio
all’indietro:
• quando esso vale 0, l’ingresso al FF 2 è y3, mentre l’ingresso al FF 1 è y2y3: questo si ha per il
contatore up;
• quando “controllo” vale 1, invece, l’ingresso al FF 2 è y’3, mentre l’ingresso al FF 1 è y’2y3:
questo si ha per il contatore down.
Contatori a decade
Non è detto, come anticipato in precedenza, che il modulo di un contatore sia una potenza di 2. E’
infatti possibile realizzare, ad esempio, un contatore modulo 10 (appartenente perciò alla
categoria dei contatori a decade): dato che il contatore dovrà avere almeno 10 stati, dovremo
comunque ricorrere a dei flip-flop e, nella fattispecie, ce ne serviranno 4. Con 4 flip-flop, il contatore
potrebbe contare fino a 16 impulsi di clock (numerandoli da 0 a 15): allora, dato che noi vogliamo
che esso conti solo 10 impulsi di clock, dovremo prevedere un circuito che, al 10° impulsi, azzeri il
contenuto del contatore e gli faccia così riprendere il conteggio.
Ricordiamo, infine, che i contatori a decade sono precaricabili: ciò significa che possiamo fare in
modo che il conteggio non avvenga da 0, ma da un valore da noi stabilito. Esistono appositi circuiti
per precaricare un contatore a decade: essi fanno in modo che il conteggio parta e riprenda sempre
dal valore iniziale da noi fissato e non da 0.
40
RIPPLE-CARRY OUT (RCO)
Abbiamo dunque visto che un contatore modulo 8 è una macchina a stati finiti molto semplice.
Allo schema ottenuto poco fa si possono apportare alcuni miglioramenti.
Ad esempio, molti contatori dispongono di una ulteriore uscita, detta Ripple-Carry Out
(brevemente RCO): questa uscita vale sempre 0, tranne quando il contatore è arrivato a contare un
numero di impulsi di clock pari al suo modulo, nel qual caso va ad 1. Per esempio, nel caso del
contatore modulo 8 prima descritto, l’uscita RCO vale 0 tranne quando il contatore è arrivato a
contare 7 impulsi, ossia quando y1=y2=y3=1. E’ immediato accorgersi di quale sia l’espressione
booleana di questa funzione RCO:
y1 y 2 y 3
000
001
010
011
100
101
110
111
RCO
0
0
0
0
0
0
0
1

→
RCO = y1 y 2 y 3
Se il contatore avesse avuto k variabili di stato (per cui sarebbe stato un contatore modulo N=2k),
la RCO sarebbe stata il prodotto logico di tali k variabili di stato, ossia delle uscite dei k flip-flop
costituenti il contatore. Nel nostro caso (k=3), lo schema logico del contatore diventa dunque il
seguente:
In questo schema, abbiamo tenuto conto del fatto che era già disponibile il prodotto di y1=n1 e
y2=n2, per cui abbiamo semplicemente mandato tale prodotto in AND con y3=n3.
E’ importante osservare che la RCO assume valore 1, quando è stato contato il 7 impulso di clock,
solo quando scatta il FF numero 1: infatti, nel conteggio precedente, n2 ed n3 sono già andate ad 1,
per cui resta solo da aspettare che anche n1 vada ad 1.
Riutilizzando la stessa simulazione P-Spice fatta e spiegata prima, otteniamo quanto segue:
41
Come si nota, l’uscita RCO vale 1 solo quando viene contato l’8° impulso di clock (cioè quello di
numero d’ordine 7, visto che il conteggio comincia da 0).
L’uscita RCO ha anche un’altra importante applicazione: infatti, osservando la sua tabella della
verità, si nota che essa commuta ogni 8 impulsi di clock; allora, se ogni impulso di clock ha durata
T, con l’uscita RCO otteniamo un segnale che vale 1, per un periodo 2T, ogni 8 colpi del clock
principale:
clock
T
t
2T 3T 4T 5T 6T 7T 8T 9T
RCO
t
Si ottiene, in pratica, un clock particolare, i cui impulsi hanno durata 2T e occorrono ogni 8
impulsi del clock originale.
CONTATORI AD ANELLO (RING COUNTER)
Un particolare tipo di contatore è quello rappresentato nello schema logico seguente:
Si tratta evidentemente di N flip-flop di tipo D, connessi in cascata, e con l’ultimo la cui uscita
viene riportata in ingresso al primo. Si tratta perciò di un normale registro a scorrimento, nel quale
però l’uscita è riportata in ingresso.
Supponiamo di partire da una condizione iniziale in cui tutti i flip-flop sono azzerati, il che si
ottiene, come sappiamo, applicando un segnale di CLEAR fatto nel modo seguente:
clear
t
42
Il clear, cioè, è normalmente ad 1, ma presenta inizialmente una transizione a 0, che serve appunto
a resettare il registro: il clear non è un segnale sincrono, che cioè agisce solo quando arriva l’impulso
di clock, ma è un segnale asincrono, che quindi comporta l’azzeramento dei flip-flop nell’istante in
cui va a 0.
Dopo aver resettato, supponiamo di portare ad 1 l’ingresso D del primo flip-flop: questo si ottiene
applicando, al flip-flop 1, un segnale di PRESET, che vale normalmente 1, ma viene portato a 0 per
il tempo necessario affinché il primo flip-flop carichi appunto un 1:
preset
t
Che succede a questo punto? Vediamo.
Ricordiamo ancora una volta la tabella di pilotaggio di un flip-flop di tipo D:
Q Q+
0 0
0 1
1 0
1 1
D
0
1
SET
0 RESET
1
La catena dei flip-flop funziona, almeno per i primi colpi di clock, come un normale registro a
scorrimento: supponiamo che il caricamento di 1 nel primo flip-flop (grazie al segnale di PRESET),
sia avvenuto prima del primo impulso di clock; quando arriva tale impulso, il flip-flop si trova con 1
in uscita e 0 in ingresso (in quanto questo 0 è l’uscita dell’ultimo flip-flop, che è ancora azzerato),
per cui commuta a 0; in corrispondenza dello stesso colpo di clock, però, il secondo flip-flop si trova
con 1 in ingresso (in quanto il primo flip-flop non ha ancora commutato) e 0 in uscita, per cui
commuta ad 1. Quindi, dopo il primo colpo di clock, la situazione è quella per cui l’1 si è spostato
dal primo al secondo flip-flop: quest’ultimo ha uscita 1, mentre gli altri hanno uscita 0. Al secondo
colpo di clock, quindi, è il terzo flip-flop che ha 0 in uscita ed 1 ingresso, per cui esso va ad 1,
mentre il secondo flip-flop torna a 0, in quanto ha 1 in uscita e 0 in ingresso. Il procedimento
continua, fin quando, all’N-1° colpo di clock, l’1 viene caricato dall’ultimo flip-flop. Quindi, all’ N1° colpo di clock, tutti i flip-flop sono a 0 e solo l’ultimo è ad 1. Al successivo colpo di clock, il
meccanismo riparte, in quanto è nuovamente il primo flip-flop a trovarsi un 1 in ingresso.
In questo modo, il contatore conta dunque N colpi di clock, tanti quanti sono i flip-flop. Di
conseguenza, in un ring counter (contatore ad anello), il modulo coincide con il numero N di flipflop di tipo D posti in cascata.
Facciamo un esempio concreto, supponendo di avere un ring counter di modulo 4, cioè costituito
da 4 flip-flop di tipo D:
43
Abbiamo evidentemente considerato un segnale di clock ed un segnale di clear comuni a tutti i
flip-flop, mentre il segnale di preset è stato considerato solo per il flip-flop 1: in realtà, quello che
bisogna fare è mantenere il PRESET dei flip-flop 2,3 e 4 sempre ad 1, mentre il PRESET del primo
flip-flop va portato a 0 solo per il breve tempo necessario a caricare l’1 iniziale (per il resto del
tempo, anche questo flip-flop ha PRESET ad 1).
L’andamento temporale dei segnali coinvolti in questo circuito è il seguente:
Il segnale più in alto è il clock. Sotto di esso c’è il segnale di CLEAR, che presenta una
transizione iniziale 1→0 necessaria all’azzeramento dei flip-flop. Dopo di che c’è il segnale di
PRESET per il primo flip-flop (il segnale di PRESET per gli altri flip-flop abbiamo detto essere
costantemente sul valore 1): anche questo segnale presenta una transizione iniziale 1→0 (successiva
a quella del CLEAR), necessaria a caricare il primo 1 nel primo flip-flop. Come si nota, al primo
colpo di clock successivo al PRESET del primo flip-flop, l’1 comincia a spostarsi e accade che ogni
4 colpi di clock esso si trova nel primo flip-flop. Il conteggio, dunque, avviene osservando che
ciascuna uscita va ad 1 ogni 4 periodi di clock (e rimane ad 1 per 1 solo periodo di clock).
E’ importante osservare che, prima dell’azzeramento del contatore mediante il CLEAR, la
simulazione fornisce ambiguità sui bit contenuti nei 4 flip-flop, in conseguenza del fatto che la
situazione prima dell’azzeramento è casuale.
44
Contatore ad anello intrecciato (Twisted Ring Counter)
Questo contatore è identico a quello visto nel paragrafo precedente, con la differenza che il
segnale riportato all’ingresso D del primo flip-flop non è l’uscita Q dell’ultimo flip-flop, ma l’uscita
negata:
Vediamo allora come si comporta questo contatore, nella solita duplice ipotesi di applicare,
inizialmente, prima un segnale di CLEAR che resetti tutti i flip-flop e poi un segnale di PRESET che
memorizzi un 1 nel primo registro.
Al primo fronte di salita del clock dopo l’applicazione del PRESET, il flip-flop 1 si trova con
l’uscita ad 1, ma anche con l’ingresso ad 1, in quanto questo corrisponde all’uscita negata
dell’ultimo flip-flop, che è azzerato. Di conseguenza, il primo flip-flop, al primo colpo di clock
rimane con uscita ad 1. Allo stesso colpo di clock, il secondo flip-flop si trova con uscita 0 e
ingresso 1, per cui va anch’esso ad 1. Al secondo colpo di clock, i primi due flip-flop conservano l’1
in uscita, mentre il terzo flip-flop, che si trova con uscita 0 e ingresso ad 1, va anch’esso ad 1. Il
meccanismo di ripete fino all’N-1° colpo di clock, al quale anche l’ultimo flip-flop va ad 1. Al
successivo colpo di clock, il primo flip-flop viene dunque a trovarsi con uno 0 in ingresso e un 1 in
uscita, per cui commuta a 0. Al colpo di clock ancora successivo, il primo flip-flop rimane ad 1 (in
quanto ha 0 in uscita e 0 in ingresso), mentre il secondo flip-flop, avendo 1 in uscita e 0 ingresso, va
anch’esso a 0 e il meccanismo si ripete nuovamente.
L’andamento temporale delle variabili coinvolte è indicato nella figura seguente:
A differenza del contatore ad anello considerato nel paragrafo precedente, l’effetto che si nota è
che i flip-flop generano una uscita che, per un tempo via via crescente (fino ad un massimo di 4
periodi di clock che si ha a regime), è a 0 (mentre per il tempo rimanente è ad 1). Il conteggio
avviene dunque in base al fatto che, a regime, le uscite dei 4 flip-flop si mantengono a 0 per un
tempo pari a 4 periodi di clock.
Autore: SANDRO PETRIZZELLI
e-mail: [email protected]
sito personale: http://users.iol.it/sandry
succursale: http://digilander.iol.it/sandry1
45

Appunti di Elettronica dei Sistemi Digitali

Transcript

Documenti analoghi

Esercizio Circuitmaker 2005-2006 Si progetti un comparatore

Esercizio Circuitmaker

Generatore di clock, contatore, display

Esercitazione di laboratorio n. 3

Flip-flop e loro applicazioni

Chapter 7 – Registers and Register Transfers

CORSO BASE CORSO BASE DI ELETTRONICA ELETTRONICA

Elettronica delle Telecomunicazioni II

INVERTER RISONANTI

INTRODUZIONE AI CONTATORI Introduzione I