Esercitazioni di Sistemi Elettronici Digitali

Selezione e risoluzione esercizi a cura del Prof. Maurizio Zamboni

Traduzione e impaginazione con lausilio di Marco Druetta, Andrea Maria Milazzo, Salvatore Ganci, Matteo Frittelli, Gabriele Brancaleoni, Antonio Fattore
A Documento realizzato in L TEX

21 gennaio 2010

Indice
1 Algebra Booleana - Circuiti Combinatori di base 1.1 Copertura mappe di Karnough . . . . . . . . 1.2 Copertura mappe di Karnough . . . . . . . . 1.3 Copertura con Sum of Product (SoP) . . . . . 1.4 Copertura con Sum of Product . . . . . . . . 1.5 Sintesi con porte NAND . . . . . . . . . . . 1.6 Sintesi con porte NOR . . . . . . . . . . . . Sintesi dei Circuiti Combinatori di Base 2.1 Sintesi con porte NAND . . . . . . 2.2 Multiplexer 2-to-1 . . . . . . . . . . 2.3 Multiplexer 4-to-1 . . . . . . . . . . 2.4 Multiplexer in cascata . . . . . . . . 2.5 Espansione di Shannon . . . . . . . 2.6 Espansione di Shannon . . . . . . . 2.7 Sintesi con Decoder . . . . . . . . . 2.8 Sintesi multiuscite con Decoder . . 2.9 Sintesi con LUT a due ingressi . . . 2.10 Sintesi con LUT a tre ingressi . . . 2.11 Sintesi con Blocchi MPX-based . . 7 7 8 9 10 12 13 15 15 16 18 19 21 23 24 24 26 27 28 31 31 32 35 36 37 39 39 41

. . . . . .

. . . . . .

. . . . . .

. . . . . .

. . . . . .

. . . . . .

. . . . . .

. . . . . .

. . . . . .

. . . . . .

. . . . . .

. . . . . . . . . . .

. . . . . . . . . . .

. . . . . . . . . . .

. . . . . . . . . . .

. . . . . . . . . . .

. . . . . . . . . . .

. . . . . . . . . . .

. . . . . . . . . . .

. . . . . . . . . . .

. . . . . . . . . . .

. . . . . . . . . . .

. . . . . . . . . . .

. . . . . . . . . . .

. . . . . . . . . . .

. . . . . . . . . . .

. . . . . . . . . . .

Fondamenti di VHDL 3.1 VHDL - Descrizione di funzioni booleane 3.2 VHDL - Sintesi con porte NAND . . . . . 3.3 VHDL - Sintesi con PoS . . . . . . . . . 3.4 VHDL - Encoder 8-to-3 . . . . . . . . . . 3.5 VHDL - Decoder BCD 7 segmenti . . . .

. . . . .

. . . . .

. . . . .

. . . . .

. . . . .

. . . . .

. . . . .

. . . . .

. . . . .

. . . . .

. . . . .

. . . . .

. . . . .

FPGA 4.1 PLA di tipo NOR-NOR - SoP . . . . . . . . . . . . . . . . . . . 4.2 PLA di tipo NOR-NOR - PoS . . . . . . . . . . . . . . . . . . . 1

4.3 4.4 5

PLA nMOS-LIKE . . . . . . . . . . . . . . . . . . . . . . . . . . PLA con LUT . . . . . . . . . . . . . . . . . . . . . . . . . . . .

42 43 46 46 47 47 48 48 48 49 50 51 53 54 55 56 57 60 60 62 63 66 67 68 70 71 72 74 74 75 75 78 80 81 82 83 84 85 86 87

Blocchi Aritmetici 5.1 Decimali Senza segno . . . . . . . . . . . . . . . . . . . . . . 5.2 Complemento a 1 . . . . . . . . . . . . . . . . . . . . . . . . 5.3 Complemento a 2 . . . . . . . . . . . . . . . . . . . . . . . . 5.4 Complemento a 1 e complemento a 2 . . . . . . . . . . . . . . 5.5 XOR . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 5.6 Operatore XOR . . . . . . . . . . . . . . . . . . . . . . . . . 5.7 Sottrazioni UNSIGNED . . . . . . . . . . . . . . . . . . . . 5.8 Sottrazioni SIGNED . . . . . . . . . . . . . . . . . . . . . . 5.9 Convertitore in Complemento a 2 . . . . . . . . . . . . . . . . 5.10 Overow . . . . . . . . . . . . . . . . . . . . . . . . . . . . 5.11 Carry-out . . . . . . . . . . . . . . . . . . . . . . . . . . . . 5.12 Addizioni e sottrazioni con segno . . . . . . . . . . . . . . . . 5.13 Somme/Sottrazioni binarie con segno . . . . . . . . . . . . . 5.14 Somma e sottrazione in modulo e segno . . . . . . . . . . . . 5.15 Somma di 3 numeri di 4 bit . . . . . . . . . . . . . . . . . . . 5.16 Incrementatore e Decrementatore per 2 . . . . . . . . . . . . . 5.17 Complemento a 9 di un digit BCD . . . . . . . . . . . . . . . 5.18 Addizione BCD e VHDL . . . . . . . . . . . . . . . . . . . . 5.19 Sottrazione BCD . . . . . . . . . . . . . . . . . . . . . . . . 5.20 Interpretazione graca di un numero BCD a 3 digit con segno 5.21 Half-adder ternario . . . . . . . . . . . . . . . . . . . . . . . 5.22 Full-adder ternario . . . . . . . . . . . . . . . . . . . . . . . 5.23 Sottrattore decimale . . . . . . . . . . . . . . . . . . . . . . . 5.24 Sommatore binario 2-bit . . . . . . . . . . . . . . . . . . . . 5.25 Sommatore 4-bit . . . . . . . . . . . . . . . . . . . . . . . . 5.26 Somme algebriche in Complemento a 2 . . . . . . . . . . . . 5.27 Sommatore con una costante . . . . . . . . . . . . . . . . . . 5.28 Conta numero di 1 presenti in ingresso . . . . . . . . . . . . . 5.29 Comparatore > = < . . . . . . . . . . . . . . . . . . . . . . 5.30 Comparatore di uguaglianza di due numeri senza segno su 4 bit 5.31 Comparatore su 4-bit . . . . . . . . . . . . . . . . . . . . . . 5.32 Comparatore su 4-bit modulare . . . . . . . . . . . . . . . . . 5.33 Comparatore su 4-bit realizzato con un sottrattore a 4 bit . . . 5.34 Comparatore di uguaglianza e maggioranza su 4-bit modulare 5.35 Sommatore Ripple-Carry . . . . . . . . . . . . . . . . . . . . 5.36 Carry-Lookahead Gerarchico . . . . . . . . . . . . . . . . . . 5.37 Codice VHDL ignoto . . . . . . . . . . . . . . . . . . . . . . 2

. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .

. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .

5.38 Percorso critico di un moltiplicatore . . . . . . . . . . . . . . . . 5.39 VHDL di un moltiplicatore . . . . . . . . . . . . . . . . . . . . . 6 Circuiti sequenziali 6.1 Flip-op SR sincrono con ip-op di tipo D . . 6.2 Latch SR Set- Dominant . . . . . . . . . . . . 6.3 Flip op MS a set dominante . . . . . . . . . . 6.4 Flip op MS a Set dominante - verica . . . . . 6.5 Flip op di tipi diversi . . . . . . . . . . . . . 6.6 Latch SR . . . . . . . . . . . . . . . . . . . . 6.7 Latch Nand-Nand . . . . . . . . . . . . . . . . 6.8 Latch SR gated . . . . . . . . . . . . . . . . . 6.9 Divisore di frequenza . . . . . . . . . . . . . . 6.10 JK con ip op T . . . . . . . . . . . . . . . . 6.11 JK negative-edge-triggered . . . . . . . . . . . 6.12 Confronto tra circuiti con ip op . . . . . . . 6.13 Flip op D negative edge triggered . . . . . . 6.14 Flip-op di tipo D . . . . . . . . . . . . . . . . 6.15 Confronto tra diversi tipi di ip-op D e latch . 6.16 Flip-op SR . . . . . . . . . . . . . . . . . . . 6.17 Flip Flop LH . . . . . . . . . . . . . . . . . . 6.18 Latch D gated . . . . . . . . . . . . . . . . . . 6.19 Bidirectional shift . . . . . . . . . . . . . . . . 6.20 Up/Down counter . . . . . . . . . . . . . . . . 6.21 Derivazione tabella e diagramma degli stati . . 6.22 Derivazione tabella e diagramma degli stati (2) 6.23 Derivazione tabella e diagramma degli stati (3) 6.24 Diagramma a stati . . . . . . . . . . . . . . . . 6.25 Generazione sequenza di verica . . . . . . . . 6.26 Progetto FSM e simulazione . . . . . . . . . . 6.27 Tabella e diagramma degli stati . . . . . . . . . 6.28 Progetto FSM . . . . . . . . . . . . . . . . . . 6.29 Progetto FSM (2) . . . . . . . . . . . . . . . . 6.30 Simulazione Progetto FSM (2) . . . . . . . . . 6.31 Progetto FSM (3) . . . . . . . . . . . . . . . . 6.32 Ottimizzazione di FSM . . . . . . . . . . . . . 6.33 Start, Stop e Run . . . . . . . . . . . . . . . . 6.34 Complementatore a 2 seriale . . . . . . . . . . 6.35 NRZI . . . . . . . . . . . . . . . . . . . . . . 6.36 Conversione NRZI - standard . . . . . . . . . . 6.37 Contatore da 11 a 233 . . . . . . . . . . . . . . 3

88 90 94 94 96 96 98 100 100 101 102 102 103 104 105 106 107 108 109 110 112 113 115 118 120 121 123 124 125 126 128 129 131 132 135 137 140 143 144 146

. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .

. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .

. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .

. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .

. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .

. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .

. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .

. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .

. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .

. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .

6.38 6.39 6.40 6.41 6.42 6.43 6.44 6.45 6.46 6.47 6.48 6.49 6.50 6.51 6.52 6.53 6.54 6.55 6.56 6.57 6.58 6.59 7

Generatore di sequenze per USB . . . . . . . . . . . . Generatore di sequenza . . . . . . . . . . . . . . . . . Generatore di sequenza - Zero Insertion . . . . . . . . Rilevatore del primo uno in una sequenza . . . . . . . Lucchetto Elettronico . . . . . . . . . . . . . . . . . . Controllore di Handshake . . . . . . . . . . . . . . . . Progetto FSM con tecnica One-Hot . . . . . . . . . . . Contatore ad anello a 3 bit . . . . . . . . . . . . . . . FSM equivalenti . . . . . . . . . . . . . . . . . . . . . FSM distributore automatico . . . . . . . . . . . . . . FSM distributore automatico (2) . . . . . . . . . . . . Distributore di bibite . . . . . . . . . . . . . . . . . . Sintesi di un JK . . . . . . . . . . . . . . . . . . . . . Contatore a 4 bit con T ip op . . . . . . . . . . . . . Up/Down counter con ip op T . . . . . . . . . . . . Up/Down counter con ip op D . . . . . . . . . . . Contatore . . . . . . . . . . . . . . . . . . . . . . . . Ring Oscillator . . . . . . . . . . . . . . . . . . . . . Progetto di un circuito generatore di impulsi . . . . . . Calcolo delay massimo e frequenza massima . . . . . Massima frequenza di funzionamento - contatore . . . Massima frequenza di funzionamento - Bus con registri

. . . . . . . . . . . . . . . . . . . . . .

. . . . . . . . . . . . . . . . . . . . . .

. . . . . . . . . . . . . . . . . . . . . .

. . . . . . . . . . . . . . . . . . . . . .

. . . . . . . . . . . . . . . . . . . . . .

. . . . . . . . . . . . . . . . . . . . . .

147 149 150 153 154 157 159 161 163 164 167 168 169 169 170 171 171 172 174 174 177 178 180 180 181 182 183 186 188 191 192 193 194 195 198 199 201 202 203 204

VHDL per circuiti sequenziali 7.1 VHDL - Flip op T . . . . . . . . . . . . . . . . . . . . . . . . 7.2 VHDL - Flip op JK . . . . . . . . . . . . . . . . . . . . . . . 7.3 Derivazione circuitale da VHDL . . . . . . . . . . . . . . . . . 7.4 VHDL - Riconoscitore di sequenza . . . . . . . . . . . . . . . . 7.5 VHDL - Riconoscimento di 2 ingressi uguali per 4 colpi di clock 7.6 VHDL - Parit` su 3 bit consecutivi . . . . . . . . . . . . . . . . a 7.7 VHDL - Shift bidirezionale . . . . . . . . . . . . . . . . . . . 7.8 VHDL - Up/Down counter a 24 bit . . . . . . . . . . . . . . . . 7.9 VHDL - Up/Down counter a 24 bit parametrico . . . . . . . . . 7.10 VHDL - Contatore up a 12 bit . . . . . . . . . . . . . . . . . . 7.11 VHDL - Descrizione gerarchica . . . . . . . . . . . . . . . . . 7.12 VHDL - Johnson counter . . . . . . . . . . . . . . . . . . . . . 7.13 VHDL - Ring Counter . . . . . . . . . . . . . . . . . . . . . . 7.14 VHDL - Descrizione comportamentale . . . . . . . . . . . . . . 7.15 Simulazione e sintesi CAD . . . . . . . . . . . . . . . . . . . . 7.16 Simulazione e sintesi CAD (2) . . . . . . . . . . . . . . . . . . 7.17 Simulazione e sintesi CAD (3) . . . . . . . . . . . . . . . . . . 4

. . . . . . . . . . . . . . . . .

7.18 VHDL - Contatore BCD a 4 digit . . . . . . . . . . . . . . . . . . 205 8 Progettazione di sistemi digitali 8.1 Divisore per sottrazioni ripetute . . . . . 8.2 Logaritmo in base 2 . . . . . . . . . . . . 8.3 Scambio a 3 registri - progetto . . . . . . 8.4 Scambio a 3 registri - ASM chart . . . . . 8.5 Scambio a 3 registri - ASM chart (2) . . . 8.6 Ordinamento - Sorting . . . . . . . . . . 8.7 Shift register . . . . . . . . . . . . . . . . 8.8 Counter . . . . . . . . . . . . . . . . . . 8.9 Moltiplicatore somma/shift . . . . . . . . 8.10 Divisore - Codice VHDL . . . . . . . . . 8.11 ASM chart equivalente . . . . . . . . . . 8.12 ASM chart equivalente - Codice VHDL . 8.13 Trasformazioni di ASM chart . . . . . . 8.14 Pseudo-codice per il sorting . . . . . . . 8.15 Ordinamento con buffer 3-state . . . . . . 8.16 Ordinamento - Uso moduli memoria lpm . 8.17 Media . . . . . . . . . . . . . . . . . . . 8.18 Media (2) . . . . . . . . . . . . . . . . . 8.19 Media (2) - Codice VHDL . . . . . . . . 8.20 Pseudo-codice per un sorter . . . . . . . . 8.21 VHDL di un sorter . . . . . . . . . . . . 8.22 Processore . . . . . . . . . . . . . . . . . 8.23 Processore (2) . . . . . . . . . . . . . . . 8.24 Semaforo . . . . . . . . . . . . . . . . . 8.25 Anti-rimbalzo . . . . . . . . . . . . . . . Memorie 9.1 Linee indirizzo e linee input-output . 9.2 Decoder . . . . . . . . . . . . . . . 9.3 Decoder (2) . . . . . . . . . . . . . 9.4 DRAM - Locazioni . . . . . . . . . 9.5 DRAM - Pin di indirizzo . . . . . . 9.6 DRAM - Refresh . . . . . . . . . . 9.7 Struttura memoria . . . . . . . . . . 9.8 Struttura memoria (2) . . . . . . . . 208 208 213 218 220 221 225 234 235 239 246 250 250 253 253 261 262 269 274 276 284 286 292 294 298 302 305 305 306 307 308 309 309 310 311

. . . . . . . . . . . . . . . . . . . . . . . . .

. . . . . . . . . . . . . . . . . . . . . . . . .

. . . . . . . . . . . . . . . . . . . . . . . . .

. . . . . . . . . . . . . . . . . . . . . . . . .

. . . . . . . . . . . . . . . . . . . . . . . . .

. . . . . . . . . . . . . . . . . . . . . . . . .

. . . . . . . . . . . . . . . . . . . . . . . . .

. . . . . . . . . . . . . . . . . . . . . . . . .

. . . . . . . . . . . . . . . . . . . . . . . . .

. . . . . . . . . . . . . . . . . . . . . . . . .

. . . . . . . . . . . . . . . . . . . . . . . . .

. . . . . . . . . . . . . . . . . . . . . . . . .

. . . . . . . . . . . . . . . . . . . . . . . . .

. . . . . . . .

. . . . . . . .

. . . . . . . .

. . . . . . . .

. . . . . . . .

. . . . . . . .

. . . . . . . .

. . . . . . . .

. . . . . . . .

. . . . . . . .

. . . . . . . .

. . . . . . . .

. . . . . . . .

. . . . . . . .

. . . . . . . .

. . . . . . . .

10 Temi desame 313 10.1 Prova desame del 30-04-2009 . . . . . . . . . . . . . . . . . . . 313 10.2 Prova desame del 03-07-2009 . . . . . . . . . . . . . . . . . . . 327 10.3 Prova desame del 07-09-2009 . . . . . . . . . . . . . . . . . . . 342

Capitolo 1 Algebra Booleana - Circuiti Combinatori di base

1.1 Copertura mappe di Karnough
Progettare un circuito digitale che abbia tre ingressi, x1 , x2 e x3 e che produca come uscita il valore 1 se due o pi` variabili dingresso assumono il valore 1; in u caso contrario luscita deve essere a 0. Soluzione La tabella di verit` della funzione f che rappresenta luscita del circuito proa posto e riportata nella tabella seguente insieme alla mappa di Karnough: ` x1 0 0 0 0 1 1 1 1 x2 0 0 1 1 0 0 1 1 x3 0 1 0 1 0 1 0 1 f 0 0 0 1 0 1 1 1

x3

x1 , x2 00 01 11 0 0 0 1 1 0 1 1

10 0 1

La funzione booleana f risultante e ` f = x1 x2 + x1 x3 + x2 x3

1.2 Copertura mappe di Karnough

Determinare la funzione logica f di un circuito che abbia tre ingressi, x1 , x2 e x3 e che produca come uscita il valore 1 se esattamente una o due variabili in ingresso assumono il valore 1; in caso contrario luscita deve essere a 0. Si calcoli la funzione sia nella forma Prodotto di Somme (Product of Sums - PoS) sia nella forma Somma di Prodotti (Sum of Products - SoP). Soluzione La tabella di verit` della funzione proposta e riportata nella tabella seguente a ` insieme alla mappa di Karnough: x1 0 0 0 0 1 1 1 1 x2 0 0 1 1 0 0 1 1 x3 0 1 0 1 0 1 0 1 f 0 1 1 1 1 1 1 0

x3

x1 , x2 00 01 11 0 0 1 1 1 1 1 0

10 1 1

La funzione nella forma Prodotto di Somme (PoS) deve coprire gli zeri della mappa di Karnough e vale 8

PoS: f = (x1 + x2 + x3 )(x1 + x2 + x3 ) invece la forma Somma di Prodotti (SoP) copre gli uni nella tabella e vale SoP: f = x1 x3 + x2 x3 + x1 x2

1.3 Copertura con Sum of Product (SoP)

Dalla gura seguente (g. 1.1) che rappresenta il comportamento nel tempo del circuito combinatorio da analizzare, sintetizzare la funzione f (x1 , x2 , x3 ) nella forma SoP.

x1 x2 x3 f

1 0 1 0 1 0 1 0
Time

Figura 1.1:

Soluzione Dalla forma donda proposta che rappresenta il comportamento del circuito, supposto combinatorio, si deriva in modo esaustivo la seguente tabella di verit` : a

x1 0 0 0 0 1 1 1 1

x2 0 0 1 1 0 0 1 1

x3 0 1 0 1 0 1 0 1

f 1 0 0 1 0 1 1 0

La mappa di Karnaugh relativa e riportata nella seguente tabella: ` x1 , x2 00 01 11 0 1 0 1 1 0 1 0 10 0 1

x3

La copertura della mappa nella forma SoP e: f = x1 x2 x3 + x1 x2 x3 + x1 x2 x3 + x1 x2 x3 Tale funziona pu` essere coperta anche mediante gli operatori booleani EXo OR dando origine alla seguente forma sintetizzata: f = x1 + x2 + x3

1.4 Copertura con Sum of Product

Si consideri il diagramma temporale riportato in gura 1.2 e si sintetizzi la funzione f (x1 , x2 , x3 ) nella forma pi` semplice di Somme di Prodotti SoP. u Soluzione Dalla forma donda riportata in gura 1.2 si deriva la tabella di verit` : a

10

x1 x2 x3 f

1 0 1 0 1 0 1 0
Time

Figura 1.2: x1 0 0 0 0 1 1 1 1 nonch la mappa di Karnaugh e x1 , x2 00 01 11 0 0 1 0 1 1 1 1 x2 0 0 1 1 0 0 1 1 x3 0 1 0 1 0 1 0 1 f 0 1 1 1 1 0 0 1

x3

10 1 0

La funzione f vale dunque f = x1 x3 + x1 x2 + x2 x3 + x1 x2 x3

11

1.5 Sintesi con porte NAND

Data la funzione f (x1 , x2 , x3 ) = m(1, 3, 4, 6, 7), disegnare il circuito pi` eleu mentare che la implementi utilizzando solo porte NAND. Soluzione La tabella di verit` e riportata nella tabella seguente: a` x1 0 0 0 0 1 1 1 1 mentre la mappa di Karnaugh e ` x1 , x2 00 01 11 0 0 0 1 1 1 1 1 x2 0 0 1 1 0 0 1 1 x3 0 1 0 1 0 1 0 1 f 0 1 0 1 1 0 1 1

x3

10 1 0

x1

x2 x3
Figura 1.3:

12

La funzione booleana f risultante e ` f = x1 x3 + x1 x2 + x1 x3

x1

x2 x3
Figura 1.4:

La sintesi della funzione logica f nella forma SoP e riportata in gura 1.3: ` Se si utilizza la tecnica di sintesi con solo porte NAND si deve ricordare che lOR del primo livello e realizzabile con una NAND, come pure le funzioni AND di secondo livello (vedi teoria). In questo caso la realizzazione e quella riportata ` in gura 1.4

1.6 Sintesi con porte NOR

Ripetere lesercizio precedente utilizzando solo porte NOR. Soluzione In questo caso per derivare automaticamente il circuito facendo uso solo di porte NOR occorre esprimere la funzione booleana nella forma Product od Sums: f = (x1 + x3 )(x1 + x2 + x3 ) 13

La soluzione tradizionale prevede un AND di termini OR di secondo livello, come riportato in gura 1.5:

x1 x2 x3
Figura 1.5:

x1 x2 x3
Figura 1.6: Utilizzando la sintesi con solo porte NOR si deve considerare che lAND di primo livello e realizzabile con un NOR come pure le porte OR di secondo livello ` (vedi teoria); la soluzione e riportata in gura 1.6: `

14

Capitolo 2 Sintesi dei Circuiti Combinatori di Base

2.1 Sintesi con porte NAND
Mappare unicamente con blocchi logici di tipo NAND il circuito riportato nella gura 2.1 usando il metodo delle trasformazioni supponendo di avere a disposizione solo inverter e NAND a 2, 3 e 4 ingressi.

A B C D E F
Figura 2.1:

Soluzione Il metodo delle trasformazioni richiede, nel caso proposto, di trasformare dapprima le porte logiche di tipo OR in porte NAND con gli ingressi negati (logica-

15

mente equivalenti) mentre le porte AND si trasformano in NAND seguiti da un inverter. Se ne deduce che il circuito pu` essere trasformato come in gura 2.2. o
A

C D

Figura 2.2: Successivamente si eliminano le serie di due inverter non inglobabili nelle porte NAND, ottenendo il circuito di gura 2.3:

2.2 Multiplexer 2-to-1

Data la funzione f = w1 w3 + w2 w3 + w1 w2 derivare un circuito per f che utilizzi un multiplexer a due vie (MPX 2-to-1). Soluzione La prima cosa da fare e derivare la tabella di verit` della funzione: ` a

16

A B

C f D

F
Figura 2.3: w1 0 0 0 0 1 1 1 1 w2 0 0 1 1 0 0 1 1 w3 0 1 0 1 0 1 0 1 f 1 0 1 1 0 0 1 0

Dalla tabella di verit` si determina la mappa di Karnaugh della funzione che a si cercher` di coprire mediante luso di multiplexer. a w1 , w2 00 01 11 0 1 1 1 1 0 1 0

w3

10 0 0

La scelta della copertura mediante multiplexer richiede di denire una variabile (se si usano MPX 2-to-1) di controllo o selezione del multiplexer e denire le funzioni logiche relative agli ingressi del multiplexer stesso. 17

Dallanalisi della tabella di verit` conviene scegliere w1 come linea si selezioa ne perch` si nota come per le prime 4 linee con w1 a 0 luscita sia esprimibile e come m = w2 + w3 mentre per le ultime 4 linee con w1 a 1 luscita e denita dalla ` funzione n = w2 w3 . Ne consegue che il circuito nale, riportato in gura, 2.4 sar` composto dal a MPX a due vie e dalle porte logiche che realizzano le due sotto-funzioni m e n.

w2

f w3
1

w1
Figura 2.4:

2.3 Multiplexer 4-to-1

Implementare la funzione F(A, B,C, D) = m(1, 3, 4, 11, 12, 13, 14, 15) con un MPX 4-to-1 e porte logiche elementari. Collegare A e B alle linee di selezione del MPX. Soluzione Come al solito la prima cosa da fare e predisporre la tabella di verit` della ` a funzione F:

18

A 0 0 0 0 0 0 0 0 1 1 1 1 1 1 1 1

B C 0 0 0 0 0 1 0 1 1 0 1 0 1 1 1 1 0 0 0 0 0 1 0 1 1 0 1 0 1 1 1 1

D 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1

F 0 1 0 1 1 0 0 1 0 0 0 1 1 1 1 1

F1 = D

F2 = CD

F3 = CD

F4 = 1

Il testo del problema richiede di usare A e B come variabili di selezione del multiplexer a 4 vie (MPX 4-to-1), per cui occorre denire le funzioni logiche aggiuntive Fi da realizzare sui 4 ingressi del MPX nelle varie combinazioni delle variabili di selezione. Le variabili da considerare sono ovviamente C e D per cui deniamo nei 4 casi la funzione Fi , funzione delle variabili C e D. Queste funzioni devono essere implementate con porte logiche esterne. Il circuito risultante e in ` gura 2.5.

2.4 Multiplexer in cascata

Costruire un multiplexer a 15 vie che selezioni uno tra i quindici dati di ingresso Di utilizzando due multiplexer 8-to-1 collegati opportunamente ai bit di selezione A0 ..A3 Interconnettere i due MPX in modo da minimizzare la logica richiesta per la selezione dei dati da 0000 a 1110. Soluzione La tabella di verit` prevede che lindirizzo A3 discrimini quando far passare i a dati D0 ... D7 (A3 = 0) dai dati D8 ... D14 (A3 = 1).

19

C D 00 01 F 10 11 V DD
S1 S2

A
Figura 2.5: A3 0 . . . 0 1 . . . 1

D0 . . . D7 D8 . . . D14

Se A3 = 0 passa in uscita * mentre se A3 = 1 passa #; occorre quindi usare due multiplexer a 8 vie (MPX 8-to-1). La soluzione migliore consiste nel collegare al primo MPX (MPX1) i primi 8 dati (D0 ..D7 ), mentre i restanti 7 dati (D8 ..D14 ) sono collegati al secondo MPX (MPX2) che ha ancora un ingresso di dato libero che sar` collegato alluscita di a MPX1. La selezione di MPX1 e afdata ai bit meno signicativi dellindirizzo di sele` zione A0 ..A2 , mentre la selezione di MPX2 deve considerare, oltre agli stessi tre bit di indirizzo, anche A3 per discriminare tra gli ingressi Di e luscita di MPX1. Il circuito risultante e riportato in gura 2.6. `

20

D0

0 D8 0

MPX1 D7 A2 A1 A0 7 S2 S1 S0 D14 6 7 S2 S1 S0 MPX2 f

A2 _ A3 A1 _ A3 A0 _ A3

Figura 2.6:

2.5 Espansione di Shannon

Data la funzione f (w1 , w2 , w3 ) = m(0, 2, 3, 6), utilizzare il teorema dellespansione di Shannon per derivare un circuito con un multiplexer a due vie ed altre porte logiche. Soluzione La funzione f da sintetizzare vale f (w1 , w2 , w3 ) = w1 w2 w3 + w1 w2 w3 + w1 w2 w3 + w1 w2 w3 Utilizzando il teorema di espansione di Shannon si deve dapprima identicare la variabile di riferimento e denire successivamente i due cofattori relativi. Ipotizziamo di selezionare w1 come variabile di riferimento. In questo caso, dato che in tutti e 4 i minterm della funzione sono presenti tutte le variabili booleane, la scelta non e particolarmente critica; in caso differente, occorre valutare ` 21

la complessit` dei cofattori per ogni variabile di riferimento per la scelta della a soluzione a costo minimo. Con la scelta di w1 , la funzione f diventa: f = fw1 (1, w2 , w3 )w1 + fw1 (0, w2 , w3 )w1 con fw1 (1, w2 , w3 ) = w2 w3 e con fw1 (0, w2 , w3 ) = w2 w3 + w2 w3 + w2 w3 = w3 + w2 w3 = (w2 + w3 ) Il risultato dellespansione e quindi: ` f = w1 (w2 w3 ) + w1 (w2 + w3 ) Luso del teorema di Shannon permette di sintetizzare la funzione con un multiplexer, dove la variabile di riferimento e usata come selezione. ` Il circuito risultante e in gura 2.7. `

w 2

w 3

1 w 1
Figura 2.7:

22

2.6 Espansione di Shannon

Ripetere lesercizio precedente per realizzare la funzione f (w1 , w2 , w3 ) = m(0, 4, 6, 7). Soluzione La funzione f da sintetizzare e ` f = w1 w2 w3 + w1 w2 w3 + w1 w2 w3 + w1 w2 w3 Per la scelta della variabile di riferimento, calcoliamo tutti i cofattori relativi ad ogni variabile per poter scegliere la soluzione a costo minimo: w1 w2 w3 f (1, w2 , w3 ) = w2 w2 + w2 w3 + w2 w3 f (0, w2 , w3 ) = w2 w3 f (w1 , 1, w3 ) = w1 w3 + w1 w3 = w1 f (w1 , 0, w3 ) = w1 w3 + w1 w3 = w3 f (w1 , w2 , 1) = w1 w2 f (w1 , w2 , 0) = w1 w2 + w1 w2 + w1 w2 = w2 + w1 w2 = w2 + w1

La soluzione a costo minore si ottiene usando w2 come variabile di riferimento e di selezione del MPX. Il circuito e in gura 2.8 `

w3

w1

w2
Figura 2.8:

23

2.7 Sintesi con Decoder

Mostrare come la funzione f (w1 , w2 , w3 ) = m(0, 2, 3, 4, 5, 7) possa essere implementata utilizzando un decoder binario 3-to-8 e porte logiche OR. Soluzione La soluzione con decoder richiede che le variabili wi siano usate come variabili di ingresso del decoder, che nel nostro caso sar` sempre abilitato (E = 1). a La copertura della funzione booleana si ottiene semplicemente mettendo in OR le uscite del decoder in tutte le combinazioni degli ingressi per cui la funzione deve valere 1. Il circuito nale e riportato in gura 2.9. `

w1 w2 w3

A2 A1 A0

0 1 2 3 f 4 5 6

EN

Figura 2.9:

2.8 Sintesi multiuscite con Decoder

Un circuito combinatorio e denito dalle tre seguenti funzioni Booleane: ` F1 = X + Z + XY Z F2 = X + Z + XY Z F3 = XY Z + X + Z

24

Progettare un circuito che realizzi le tre funzioni utilizzando un decoder e porte logiche. Soluzione La tabella di verit` per le tre funzioni proposte e a ` X 0 0 0 0 1 1 1 1 Y Z 0 0 0 1 1 0 1 1 0 0 0 1 1 0 1 1 F1 1 0 1 0 0 0 0 1 F2 1 0 1 1 0 0 0 0 F3 1 0 1 0 0 1 0 0

La soluzione con decoder richiede che i tre ingressi X ,Y, Z siano usati come ingressi di selezione del decoder, mentre le uscite Fi si ottengono mettendo in OR le uscite del decoder che si riferiscono a termini che sono a 1 nelle differenti funzioni (gura 2.10).

0 1 X A2 2 3 Y A1 4 5 Z A0 6 7 F3 F2 F1

Figura 2.10:

25

2.9 Sintesi con LUT a due ingressi

Data la funzione f = w1 w2 + w2 w3 + w1 w2 w3 , trovare un circuito che implementi f utilizzando il numero minimo di circuti Look-Up-Table LUT a 2 ingressi. Denire la tavola di verit` implementata allinterno di ogni LUT. a Soluzione Le LUT sono dei circuiti logici in grado di esprimere qualunque funzione logica degli ingressi, lavorando come delle tabelle che realizzano la tavola di verit` a programmata al loro interno. Dato che la funzione f e composta da tre variabili, occorre denire funzioni ` di due variabili da implementare lele LUT e comporle opportunamente. Per questo e utile utilizzare il teorema di espansione di Shannon per denire le funzioni ` intermedie utili per la sintesi. Data la funzione, scegliamo w2 come varabile di riferimento, dato che compare in ogni minterm. Ne consegue allora:
1 0 f = fw2 (w1 , 1, w3 )w2 + fw2 (w1 , 0, w3 )w2

I due cofattori sono

1 fw2 = w1 w3 = g 0 f w2 = w 1 + w 3 = g

Dato che entrambi i cofattori sono esprimibili tramite la funzione g e possibile ` esprimere f ne modo seguente f = g w2 + g w2 Per realizzare il circuito proposto si ha bisogno quindi di due LUT, la prima delle quali (LUT1) realizza la funzione g, mentre la seconda (LUT2) realizza la funzione f . LUT L1 : LUT L2 : g = f (w1 , w2 ) f = (g, w2 )

Le tavole di verit` delle due LUT sono a

26

w1 0 L1 : 0 1 1

w3 0 1 0 1

g 0 0 0 1

g w2 0 0 L2 : 0 1 1 0 1 1

f 1 0 0 1

Il circuito nale e riportato in gura 2.11. `

w1 L1 w3 g

L2

w2
Figura 2.11:

2.10 Sintesi con LUT a tre ingressi

Data la funzione f (w1 , w2 , w3 , w4 ) = m(0, 1, 3, 6, 8, 9, 14, 15), derivarne unimplementazione utilizzando il minimo numero possibile di LUT a tre ingressi. Soluzione Dalla tavola di verit` della funzione si ricava la funzione f : a f = w2 w3 + w1 w2 w4 + w2 w3 w4 + w1 w2 w3 Con lespansione di Shannon conviene fattorizzare w2 come variabile di riferimento dato che compare in tutti i minterm della funzione. Esprimiamo quindi f nel modo seguente
0 1 f = w2 fw2 + w2 fw2

27

I due cofattori sono

1 fw2 = w3 w4 + w1 w3 = w3 (w1 + w4 ) = g 0 fw2 = w3 + w1 w4 = w3 (w1 + w4 ) = g

Dato che anche in questo caso i due cofattori sono uno il complemento dellaltro, la funzione f si pu` esprimere cos`: o f = w2 g + w2 g Per sintetizzare la funzione sono sufcienti due LUT, la prima delle quali serve per realizzare la funzione g, mentre la seconda realizza la funziona f . La seconda LUT e sottoutilizzata dato che lesercizio richiede di utilizzare LUT a tre ingressi ` mentre solo due di essi sono utilizzati per g e w2 . In realt` si tratta di casi reali a dove nei circuiti programmabili tutte le LUT sono solitamente di uguali capacit` a e dimensione. In gura 2.12 e riportato lo schema. `

w1 w3 w4 LUT g w2 LUT f

Figura 2.12:

2.11 Sintesi con Blocchi MPX-based

Alcuni produttori di circuiti logici programmabili producono FPGA che hanno il blocco logico multiplexer-based illustrato in gura 2.13 come blocco base per i circuiti combinatori. Mostrare come la funzione f = w2 w3 + w1 w3 + w2 w3 possa essere implementata utilizzando un solo blocco logico del tipo illustrato. 28

i1 i2 i3 i4 i5 i6 i7 i8 f

Figura 2.13: Soluzione Scegliamo w3 come variabile di controllo dellespansione di Shannon della funzione f e utilizziamola per pilotare il MPX pi` vicino alluscita: u
1 0 f = fw3 w3 + fw3 w3

w2

w1

Figura 2.14: con i due fattori

1 fw3 = w1 + w2 0 fw3 = w2

29

I due cofattori sono realizzati con i multiplexer restanti, realizzando le funzioni riportate nelle gure 2.14 e 2.15.
w2

Figura 2.15: Il circuito nale risulta quindi come riportato in gura 2.16.

w3 0 w2 0 1 w2 1 w1 0 1
Figura 2.16:

0 1 0 1

30

Capitolo 3 Fondamenti di VHDL

3.1 VHDL - Descrizione di funzioni booleane
Scrivere il codice VHDL che implementi la funzione booleana f identicata dalla mappa di Karnaugh seguente: x1 x2 00 01 11 10 1 1 1 1 1 1 1 1 x1 x2 00 01 11 10 Con x5 = 1 : x3 x4 00 01 11 10 1 1 1 1 1 1 1 1

Con x5 = 0 : x3 x4

00 01 11 10

Soluzione

La funzione f pu` essere realizzata mediante il circuito mostrato in gura 3.1, o e che e stato ricavato usando il metodo della scomposizione. ` 31

x1 x2 x5 x3

k x4
Figura 3.1: Il codice VHDL prodotto non fa altro che replicare le porte logiche costituenti la funzione f , usando le funzioni dappoggio g e k. Il codice e riportato di seguito: ` LIBRARY ieee; USE ieee.std_logic_1164.all; ENTITY f_g_h IS PORT ( x1, x2, x3, x4 f END f_g_h;

: IN STD_LOGIC; : OUT STD_LOGIC);

ARCHITECTURE LogicFunc OF f_g_h IS SIGNAL g, k : STD_LOGIC; BEGIN g <= x1 OR x2 OR x3; k <= (NOT x3 AND x4) OR (x3 AND NOT x4); f <= (k AND g) OR (NOT k AND NOT g); END LogicFunc;

3.2 VHDL - Sintesi con porte NAND

Scrivere il codice VHDL che implementi il circuito riportato in gura 3.2 e realizzato con porte logiche AND e OR, utilizzando solamente porte logiche di tipo NAND. 32

x1 x2 x3 x4 x5 x6 x7
Figura 3.2:

Soluzione

x1 x2 x3 x4 x5 x6 x7
Figura 3.3:

Prima di procedere con la scrittura del codice VHDL, e necessario trasformare ` il circuito con sole porte NAND, utilizzando il metodo della trasformazione delle porta gi` analizzato nel capitolo precedente. Tale metodo consiste nel trasformare a le porte OR in NAND con gli ingressi invertiti e aggiungere alluscita delle AND coppie di inverter. Nellesercizio proposto, per` , le due porte AND intermedie non o sono trasformate mediante laggiunta delle coppie di porte NOT in uscita dato che lOR successivo viene gi` trasformato con una inversione in ingresso che quindi a andr` a fare parte della NAND nale. a Il circuito intermedio e riportato in gura 3.3. ` Procedendo alla trasformazione del circuito si ottiene il circuito nale riportato in 33

x1 x2 x3 x4 x5 x6 x7

f h

l
Figura 3.4:

gura 3.4 che viene descritto dal codice VHDL seguente:

LIBRARY ieee; USE ieee.std_logic_1164.all; ENTITY Logica_NAND IS PORT ( x1, x2, x3, x4, x5, x6, x7 : IN STD_LOGIC; f : OUT STD_LOGIC); END Logica_NAND; ARCHITECTURE LogicFunc OF Logica_NAND IS SIGNAL g, h, l, f_bar : STD_LOGIC; BEGIN g <= (x1 NAND x1) NAND (x2 NAND X3); h <= x4 NAND ((x5 NAND x5) NAND (X6 NAND x6)); l <= x7 NAND x7; f_bar <= g NAND (h NAND l); f <= f_bar NAND f_bar; END LogicFunc;

34

3.3 VHDL - Sintesi con PoS

Scrivere il codice VHDL che implementi la funzione seguente mediante la tecnica di copertura basata sul Prodotto di Somme (PoS): f (x1 , x2 , x3 , x4 ) = m(0, 1, 2, 4, 5, 7, 8, 9, 11, 12, 14, 15). Soluzione La tabella di verit` del circuito e: a ` x1 0 0 0 0 0 0 0 0 1 1 1 1 1 1 1 1 x2 0 0 0 0 1 1 1 1 0 0 0 0 1 1 1 1 x3 0 0 1 1 0 0 1 1 0 0 1 1 0 0 1 1 x4 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 f 1 1 1 0 1 1 0 1 1 1 0 1 1 0 1 1

La sintesi mediante Prodotto di Somme richiede la copertura degli zeri della tabella di verit` e porta alla seguente funzione booleana : a f = (x1 + x2 + x3 + x4 )(x1 + x2 + x3 + x4 )(x1 + x2 + x3 + x4 )(x1 + x2 + x3 + x4 ) Il codice VHDL che descrive la funzione logica f non deve fare altro che ripetere, in modo testuale, gli operatori booleani deniti, ricordando luso delle parentesi per mantenere la gerarchia desiderata delle operazioni quando non espressamente denita dal linguaggio:

35

LIBRARY ieee; USE ieee.std_logic_1164.all; ENTITY Sintesi_PoS IS; PORT ( x1, x2, x3, x4 : IN STD_LOGIC; f : OUT STD_LOGIC); END Sintesi_PoS; ARCHITECTURE LogicFunc OF Sintesi_PoS BEGIN f <= (x1 OR x2 OR NOT x3 OR NOT x4) (x1 OR NOT x2 OR NOT x3 OR x4) (NOT x1 OR x2 OR not x3 OR x4) (NOT x1 OR NOT x2 OR x3 OR NOT END LogicFunc; IS AND AND AND x4);

3.4 VHDL - Encoder 8-to-3

Scrivere il codice VHDL che descriva un Encoder 8-to-3 usando le istruzioni di Assegnamento Condizionato. Soluzione La funzione Encoder codica in modo binario pesato la posizione dellunico ingresso che in ogni istante e pari a 1. Si ipotizza quindi che in ogni istante ci sia ` sempre uno e un solo ingresso attivo a uno nel vettore w che sar` utilizzato come a ingresso. Il codice richiede quindi che a fronte di un vettore di 8 bit in ingresso (del tipo STD LOGIC) ci sia un vettore in uscita y denito come un array di 3 bit dello stesso tipo (STD LOGIC). Il codice VHDL risultante e: ` LIBRARY ieee; USE ieee.std_logic_1164.all; ENTITY Encoder_8_to_3 IS; PORT ( w : IN STD_LOGIC_VECTOR ( 7 DOWNTO 0 ); y : OUT STD_LOGIC_VECTOR ( 1 DOWNTO 0 )); END Encoder_8_to_3; ARCHITECTURE Behavior OF Encoder_8_to_3 IS 36

BEGIN y <= "000" WHEN "001" WHEN "010" WHEN "011" WHEN "100" WHEN "101" WHEN "110" WHEN "111"; END Behavior;

w w w w w w w

= = = = = = =

"00000001" "00000010" "00000100" "00001000" "00010000" "00100000" "01000000"

ELSE ELSE ELSE ELSE ELSE ELSE ELSE

3.5 VHDL - Decoder BCD 7 segmenti

Scrivere il codice VHDL che descriva un convertitore BCD-7 segmenti basato sulla codica dei segmenti riportata nella gura 3.5.

a f e d
Figura 3.5:

b c

Soluzione Il codice VHDL deve accendere per ogni numero BCD in ingresso sul vettore bcd di tipo STD LOGIC VECTOR i segmenti relativi al numero impostato. Tali segmenti sono la porta di uscita del blocco e sono rappresentati dal vettore a 7 bit LEDS. Si usano le istruzioni di assegnamento condizionato per esprimere le relazioni booleane nel seguente codice VHDL: LIBRARY ieee; USE ieee.std_logic_1164.all; 37

ENTITY BCD_to_7_Segmenti IS PORT ( bcd : IN STD_LOGIC_VECTOR ( 3 DOWNTO 0 ); LEDS : OUT STD_LOGIC_VECTOR ( 1 TO 7 )); END BCD_to_7_Segmenti; ARCHITECTURE Behavior BEGIN WITH bcd SELECT -- abcdefg leds <= "1111110" "0110000" "1101101" "1111001" "0110011" "1011011" "1011111" "1110000" "1111111" "1111011" "0000000" END Behavior; OF BCD_to_7_Segmenti IS

WHEN WHEN WHEN WHEN WHEN WHEN WHEN WHEN WHEN WHEN WHEN

"0000", "0001", "0010", "0011", "0100", "0101", "0110", "0111", "1000", "1001", OTHERS, -- negli altri casi il display -- rimane spento

38

Capitolo 4 FPGA
4.1 PLA di tipo NOR-NOR - SoP
Disegnare lo schema di una PLA programmabile in logica NOR-NOR, con lo stessa struttura riportata in gura 4.1, per implementare la funzione f1 (x1 , x2 , x3 ) = m(0, 3, 5, 6).
VDD x 1 x2 x3 VDD

P1 P2 P3 P4

f1

f2

Figura 4.1:

39

Soluzione Lo schema riportato in gura 4.1 si riferisce ad una PLA realizzata con tecnologia NOR-NOR con inversione nale, in grado di realizzare le usuali coperture logiche sotto forma di somma di prodotti (AND-OR). Il piano di uscita OR della PLA esegue a tutti gli effetti lOR dei termini provenienti dal piano di ingresso (AND) che per` , in logica NOR, esegue lOR logico, con inversione, degli ingreso si collegati ad ogni linea. Per sintetizzare quindi ogni minterm, si deve ricorrere alla forma negata del minterm ed esprimerlo quindi come una somma di termini.

x1

x2

x3

P1 P2 P3 P4

f
Figura 4.2: In accordo al testo del problema, luscita f della PLA vale f = x1 x2 x3 + x1 x2 x3 + x1 x2 x3 + x1 x2 x3 che pu` essere espressa nella forma seguente: o f = P1 + P2 + P3 + P4 40

ogni termine Pi per poter essere sintetizzato in modo congruente con un minterm della funzione booleana, deve essere espresso mediante una somma di termini in forma negata (per realizzare la funzione NOR denita). Ne consegue quindi che i termini Pi saranno esprimibili nel seguente modo: P1 = x1 + x2 + x3 P3 = x1 + x2 + x3 P2 = x1 + x2 + x3 P4 = x1 + x2 + x3

Si ricava in conclusione lo schema riportato in gura 4.2 dove si pu` notare o come nel piano AND ci sia una connessione logica per ogni ingresso del singolo minterm relativo al valore complementato di quello che compare nella espressione logica.

4.2 PLA di tipo NOR-NOR - PoS

Mostrare come la funzione f dellesercizio precedente possa essere realizzata con una PLA senza inverter a valle delle porte logiche NOR di uscita. Soluzione In questo caso si tratta di una vera e propria sintesi mediante una struttura a due livelli, dove la logica NOR-NOR realizza la classica somma di prodotti gi` a studiata in precedenza. La PLA implementa quindi la classica struttura AND-OR che prevede per ogni minterm di uscita del piano AND collegamenti con gli ingressi che compaiono nel minterm stesso (nellesercizio precedente comparivano i termini nella versione complementata). Se si vuole una giusticazione logica a quanto detto, basta ricordare, facendo ricorso alla terminologia riportata in gura 4.3, che f = S1 + S2 + S3 + S4 ovvero f = S1 S2 S3 S4 Dunque, la funzione originaria f f = x1 x2 x3 + x1 x2 x3 + x1 x2 x3 + x1 x2 x3 41

x1

x2

x3

S1 S2 S3 S4

f
Figura 4.3: e esprimibile nella forma ` f = (x1 + x2 + x3 ) (x1 + x2 + x3 ) (x1 + x2 + x3 ) (x1 + x2 + x3 ) S1 S2 S3 S4 Il circuito risultante e riportato in gura 4.3 `

4.3 PLA nMOS-LIKE

Ripetere lesercizio precedente con una PLA in logica NOR-NOR realizzata con tecnologia MOS (nMOS-like) come nella gura 4.4 che segue. Soluzione Il circuito presentato in gura 4.4 mostra un esempio di PLA realizzato con tecnologia nMOS-like in logica NOR-NOR sfruttando la caratteristica delle con42

x1

x2

x3 S1 S2 S3 S4 f
Figura 4.4:

nessioni wired-or per realizzare i piani AND e OR della struttura. Se ad esempio si analizza il funzionamento della linea che genera S2 , si nota che la linea stessa andr` a zero non appena X1 o X2 o X3 sono a uno, mandando in conduzione il a corrispondente transistore nMOS. Di conseguenza ogni linea orizzontale realizza la funzione NOR degli ingressi collegati ad essa. Analogamente la linea verticale che produce luscita f realizza la funzione NOR dei termini Si collegati ad essa. Se ne deduce che per ottenere la stessa funzione logica dellesercizio precedente e sufciente sostituire la X di ogni connessione prevista in gura 4.3 con un tran` sistore nMOS collegato a massa e pilotato sul gate dal corrispondente ingresso. Il circuito cos` risultante e riportato in gura 4.5. `

4.4 PLA con LUT

Data la funzione f (x1 , x2 , x3 ) = m(2, 3, 4, 6, 7), mostrare come possa essere realizzata utilizzando due LUT a due ingressi. Soluzione Il circuito che realizza la funzione f richiesta potrebbe essere benissimo realizzato con le PLA tradizionali denite negli esercizi precedenti. In questo caso

43

x1

x2

x3 S1 S2 S3 S4 f
Figura 4.5:

per` si richiede di utilizzare dei blocchi intermedi in grado di realizzare funzioni o logiche programmabili: le Look Up Table o LUT. Lorganizzazione interna delle LUT e simile a quella di una memoria in cui ` si programma il valore delluscita per ogni combinazione degli ingressi (locazioni). Occorre quindi semplicemente denire il contenuto di ogni LUT che realizzer` la funzione f richiesta. a La funzione f e ` f = x1 x2 x3 + x1 x2 x3 + x1 x2 x3 + x1 x2 x3 + x1 x2 x3 che e rappresentabile dalla mappa di Karnaugh ` x1 x2 00 01 11 10 0 0 1 1 1 1 0 1 1 0

x3

Coprendo gli implicanti si ottiene: f = x2 + x1 x3 44

La funzione f non pu` essere realizzata con una sola LUT a due ingressi o (ne basterebbe una a tre ingressi, per altro normalmente disponibile nelle FPGA). Allora si usa una LUT per il calcolo di x1 x3 e una seconda per sommare tale valore a x2 . Il circuito risultante e riportato in gura 4.6. `

x1 LUT x3

_ x1 x 3 LUT x2
Figura 4.6:

_ x2 + x1 x3

45

Capitolo 5 Blocchi Aritmetici

5.1 Decimali Senza segno
Determinare il valore decimale dei seguenti numeri senza segno: a) (0111011110)2 b) (1011100111)2 c) (3751)8 e) (A25F)1 6 f) (F0F0)1 6

Soluzione a) 478 b) 743 c) 2025 e) 41567 f) 61680

46

5.2 Complemento a 1
Determinare il valore decimale dei seguenti numeri binari in complemento a 1: a) 0111011110 b) 1011100111 c) 1111111110

Soluzione a) 478 b) 280 c) 1

5.3 Complemento a 2
Determinare il valore decimale dei seguenti numeri binari in complemento a 2: a) 0111011110 b) 1011100111 c) 1111111110

Soluzione a) 478 b) 281 c) 2

47

5.4 Complemento a 1 e complemento a 2

Ottenere il complemento a 1 e a 2 dei seguenti numeri senza segno (UNSIGNED): 10011100, 10011101, 10101000, 00000000, 10000000

Soluzione Unsigned 10011100 10011101 10101000 00000000 10000000 Complemento a 1 01100011 01100010 01010111 11111111 01111111 Complemento a 2 01100100 01100011 01011000 00000000 10000000

5.5 XOR
Dimostrare che loperatore XOR e associativo, e quindi: ` xi (yi zi ) = (xi yi zi ) Soluzione x (y z) = x (yz + yz) = x(yz + yz) + x(yz + yz) = xyz + xyz + xyz + xyz x (y z) = x (xy + xy) z = (xy + xy)z + (xy + xy)z = xyz + xyz + xyz + xyz

5.6 Operatore XOR

Usando le manipolazioni algebriche vericare che x (x y) = y . Soluzione Loperatore XOR e associativo, quindi: `

48

x (x y) = (x x) y = 0y =y

5.7 Sottrazioni UNSIGNED

Eseguire le sottrazioni indicate con i seguenti numeri binari UNSIGNED utilizzando il complemento a 2. 1. 11010 - 10001 2. 11110 - 1110 3. 1111110 - 11111110 4. 101001 - 101

Soluzione La risoluzione delle sottrazioni proposte (tutti e due i termini sono considerati interi positivi senza segno - UNSIGNED) richede semplicemente di denire il complemento a due del sottraendo e di sommarlo al minuendo (si ipotizza in questo esercizio che non ci sia possibilit` di overow, ovvero che il minuendo sia a sempre maggiore del sottraendo). 1. Complemento a 2 di 10001 = 01111 11010 + 01111 = 01001 2. Complemento a 2 di (0)1110 = 10010 Si noti che in questo caso in cui il sottraendo e espresso su un numero infe` riore di bit del minuendo, dapprima si estende il numero con tanti 0 quanti sono i bit mancanti per avere lo stesso numero di bit del minuendo e poi dopo si effettua il complemento a due. 11110 + 10010 = 10000 49

3. Complemento a 2 di 1111110 = 0000010 1111110 + 0000010 = 0000000 4. Complemento a 2 di (000)101 = 111011 101001 + 111011 = 100100

5.8 Sottrazioni SIGNED

Ripetere il problema precedente, assumendo che i numeri riportati siano deniti in complemento a 2 con segno (SIGNED). Usare lestensione di segno per uguagliare la lunghezza degli operandi; indicare dove avviene un overow durante la conversione degli addendi e durante le somme.

Soluzione a) 11010 + 01111 = 01001 11110 + 00010 = 10000 1111110 + 0000010 = 0000000 101001 + 000011 = 101100

b)

c)

d)

In nessuno dei casi proposti si verica una condizione di overow dato che si sottraggono due numeri con uguale segno.

50

5.9 Convertitore in Complemento a 2

Progettare, utilizzando solo porte AND, OR e NOT, due versioni di un circuito combinatorio nellipotesi che gli ingressi siano su 4-bit e loutput sia il complemento a due dellingresso e che valgano i seguenti vincoli: a) il circuito e sintetizzato a 2 livelli, pi` eventuali inverter, se necessari per le ` u variabili di ingresso; b) il circuito e costituito da quattro identiche celle a 2-ingressi e 2-uscite, una ` per ogni bit di peso della parola. Le celle sono connesse in cascata con una struttura simile al passaggio del carry nei circuiti sommatori. Il valore applicato al carry-bit in ingresso alla cella meno signicativa e 0. ` c) Calcolare il costo del circuito in termini di gate per i due casi proposti e determinare la soluzione pi` economica in base a tale parametro. u

Soluzione a) La tabella di verit` del complementatore a due e a ` A 0 0 0 0 0 0 0 0 1 1 1 1 1 1 1 1 B C D E 0 0 0 0 0 0 1 1 0 1 0 1 0 1 1 1 1 0 0 1 1 0 1 1 1 1 0 1 1 1 1 1 0 0 0 1 0 0 1 0 0 1 0 0 0 1 1 0 1 0 0 0 1 0 1 0 1 1 0 0 1 1 1 0 F G H 0 0 0 1 1 1 1 1 0 1 0 1 1 0 0 0 1 1 0 1 0 0 0 1 0 0 0 1 1 1 1 1 0 1 0 1 1 0 0 0 1 1 0 1 0 0 0 1

che genera le seguenti equazioni booleane: 51

H=D G =CD F = BC + BD + BC D E = AB + AB C D + AC + AD b) In questo caso la cella da replicare nel circuito deve tenere conto dellalgoritmo iterativo di generazione del complemento a due, ovvero, partendo dal bit meno signicativo si lasciano inalterati tutti i bit no al primo uno che rimane invariato, dopodich` si procede a complementare tutti i bit pi` e u signicativi. La tabella di verit` della cella e a ` Bit Cin 0 0 0 1 1 0 1 1 S Cout 0 0 1 1 1 1 0 1

da cui si deniscono le funzioni booleane S = Bit Cin Cout = Bit +Cin Lo schema risultante del circuito e riportato In gura 5.1 . `

A B C D 0 Bit Cin Cout S Bit Cin H Cout S G Bit Cin Cout S F

Bit Cin

Cout S E

Figura 5.1:

c) Si ipotizzi che il costo normalizzato di un inverter sia 1, il costo di un gate elementare AND o OR sia pari al numero dei suoi ingressi e di conseguenza il costo di una porta XOR sia pari a 8 (costo di due AND a due ingressi 52

pi` un OR a due ingressi pi` il costo di due inverter per complementare le u u due variabili di ingresso), a meno che gli ingressi siano gi` complementati a altrove (come nel caso a). Il costo complessivo per il caso a e pari a 4 + 0 + 6 + 10 + 14 = 34. ` Il costo complessivo per il caso b e pari a 4 x (2 + 6 + 2) = 40. ` Il caso a e migliore rispetto al caso a in termini di gates usati, anche se si` curamente il caso b e modulare e quindi estensibile a qualunque numero di ` bit in modo automatico mentre il caso a richiede sintesi ripetute al variare del numero di bit. In compenso il caso b risulta essere pi` lento in quanto si u deve attendere la propagazione del dato D attraverso tutta la catena di celle, mentre il caso a presenta un ritardo dato comunque da quello di un inverter pi` quello di due porte logiche. u

A3

A2

A1 A0

C4

S3

S2

S1

S0

Figura 5.2:

5.10 Overow
Dimostrare la validit` dellespressione Overow = cn cn1 per la somma dei a numeri di tipo SIGNED su n bit. 53

Soluzione Creiamo la tavola di verit` a

xn1 0 0 0 0 1 1 1 1

yn1 0 0 1 1 0 0 1 1

cn1 0 1 0 1 0 1 0 1

cn 0 0 0 1 0 1 1 1

sn1 (bit di segno) Overow 0 0 1 1 1 0 0 0 1 0 0 0 0 1 1 0

Da notare che loverow non avviene quando si sommano due numeri con segno opposto. Dalla tavola di verit` si ricava lespressione delloverow: a Over f low = cn cn1 + cn cn1 = cn cn1

5.11 Carry-out
Dati due numeri SIGNED su n bit, sia ck1 il segnale di carry-out dal bit in posizione k 1 verso il bit pi` signicativo, dimostrare la validit` dellespressione u a ck1 = xk yk sk dove xk e yk sono gli ingressi pi` signicativi , e sk e il bit di somma corrisponu ` dente. Soluzione Dallespressione canonica che denisce il bit di somma sk a partire dai due ingressi xk e yk e il carry in ingresso ck1 sk = xk yk ck1 54

segue che: xk yk sk = (xk yk ) (xk yk ck1 ) = (xk yk ) (xk yk ) ck1 = 0 ck1 = ck1

5.12 Addizioni e sottrazioni con segno

Eseguire le seguenti operazioni su numeri SIGNED in complemento a 2 e indicare quando si verica un overow. Controllare i risultati convertendo in decimale il risultato. 1. 00110110 + 01000101 2. 01110101 + 11011110 3. 11011111 + 10111000 4. 00110110 - 00101011 5. 01110101 - 11010110 6. 11010011 - 11101100

Soluzione 00110110 + 1. 01000101 = 01111011 01110101 + 2. 11011110 = 01010011 11011111 + 3. 10111000 = 10010111 54 + 69 = 123 117 + -34 = 83 -33 + -72 = -105

55

4. Complemento a 2 di 00101011 = 11010101 00110110 + 11010101 = 00001011 54 43 11 =

5. Complemento a 2 di 11010110 = 00101010 01110101 + 00101010 = 10011111 117 -42 = Overow!!! 159 = -97

Loverow si verica perch lEXOR dei bit di carry Cn e Cn1 nella some ma effettuata vale 1 (Cn = 0,Cn1 = 1). Questa e la condizione da veri` care per rilevare la presenza di overow nel caso di unoperazione di somma/sottrazione. La teoria dice che dati due numeri con segno su n bit, si pu` vericare overow in due casi: sommando due numeri con lo stesso seo gno o sottraendo due numeri con segno diverso. In entrambi i casi si tratta di effettuare la somma di due numeri che presentano lo stesso MSB (bit di segno) con il bit di risultato differente dal segno dei due addendi. Questo si pu` vericare in due casi: o C` un riporto oltre il bit di segno (Cn = 1) senza che dal bit precee dente ci sia un riporto (Cn1 = 0) sul segno (condizione di somma di due numeri negativi o di sottrazione di un numero positivo da uno negativo) Non c` riporto oltre il bit di segno (Cn = 0), ma il carry del bit pree cedente e a 1 (Cn1 = 1) provocando quindi un risultato con segno ` opposto al segno dei due operandi da sommare. 6. Complemento a 2 di 11101100 = 00010100 11010011 + 00010100 = 11100111 -45 -20 -25 =

5.13 Somme/Sottrazioni binarie con segno

I numeri binari che seguono sono di tipo SIGNED in complemento a 2. Si effettuino le operazioni richieste, indicando eventuali condizioni di overow. a) 100111 + 111001 b) 001011 + 100110 56

c) 110001 010010 d) 101110 110111

Soluzione 100111 111001 100000 001011 100110 110001 110001 101110 011111 101110 001001 110111 25 7 32 11 26 15 15 18 Overow 33 18 9 9

a)

b)

c)

d)

5.14 Somma e sottrazione in modulo e segno

Progettare un sommatore/sottrattore in modulo e segno a 5 bit. Dividere il circuito nelle seguenti parti 1. generatore del segno e controllo logico delloperazione di addizione/sottrazione, 2. sommatore/sottrattore di numeri UNSIGNED utilizzando il complemento a 2 per il minuendo della sottrazione, 3. correzione logica selettiva del risultato del complemento a 2.

Soluzione I due numeri su cui operare sono Ai e Bi , con bit di segno rispettivamente A4 e B4 ; il segnale di controllo che determina se effettuare una somma o una sottrazione e S/A: `

57

S/A

A4 , A3 , A2 , A1 , A0

B4 , B3 , B2 , B1 , B0

La prima cosa da denire e quando effettuare una somma o una sottrazione: ` Si effettua una somma (A + B) se: S/A = 0 e A4 + B4 = 0 (A e B hanno stesso segno) S/A = 1 e A4 + B4 = 1 (A e B hanno segno opposto) Ne consegue che si deve effettuare la somma se S/A + A4 + B4 = 0 Si effettua una sottrazione (A B) se: S/A = 1 e A4 + B4 = 1 (A e B hanno opposto segno) S/A = 0 e A4 + B4 = 0 (A e B hanno lo stesso segno) Ne consegue che si deve sottrarre se S/A + A4 + B4 = 1 Deniamo quindi la variabile di appoggio Sub che vale 1 in caso di sottrazione da eseguire: Sub = S/A + A4 + B4

Il circuito a blocchi complessivo e mostrato in gura 5.3 ` La logica di correzione, che gestisce labilitazione di un complementatore a due pilotato, e quella di denizione del segno del risultato sono deniti dallanalisi del tipo di operazione effettuata, dal segno degli operandi e dal carry in uscita Cout del sommatore:

Sub C out 0 0 0 0 0 1 0 1 1 0 1 0 1 1 0 1

A4 0 1 0 1 0 1 0 1

AB4 V 0 0 1 0 0 1 1 1 1 0 0 0 0 0 1 0 58

Corr 0 0 0 0 1 1 0 0

Overow Overow

B 3 ...... B S/A A4 B4 Sub A3...... A

C_out

Sommatore 4 bit C_in

C3 Corr

C2

C1

C0

A4

Logica di correzione e sign

Complemento a 2

Sign S4 S3 S2 S1 S0

AB 4
Figura 5.3:

AB 0

La correzione (il bit Corr abilita il complementatore per complementare il risultato del sommatore a 4 bit) si deve effettuare solo se si tratta di una sottrazione (Sub = 1) senza carry e dunque non si oltrepassa la linea dello 0 (vedi gura 5.4) ( C out = 0 ). In tal caso A+(2n B) non genera carry, quindi si ha A < B e quindi al risultato occorre applicare la correzione. Ad esempio se si effettua la sottrazione +2 -7 si avr` per il modulo 0010 + a 1001 = 1011 che deve essere complementato (corretto) per fornire il valore 0101 (5) che e il valore corretto del modulo del risultato. ` Le funzioni logiche che determinano il bit di correzione Corr, il segno del risultato AB4 e il bit di overow V sono:

59

0000 1111 1 . . . 7 8 1001 1000 +7 0111 . 0 +1 +2 . . Caso in cui non viene oltrepassata la linea dello 0 0001

Figura 5.4: Corr = Sub C out Sign = A4 + Corr V = Sub C out

5.15 Somma di 3 numeri di 4 bit

Progettare un circuito che permetta di sommare 3 numeri UNSIGNED di 4 bit. Utilizzare sommatori a 4 bit e ogni altra porta logica necessaria. Soluzione Per realizzare il circuito occorre considerare che un sommatore e in grado di ` effettuare una somma solo di due addendi. La soluzione consiste quindi nel prendere i primi due addendi (A e B) e sommarli; poi si prendono i bit del risultato e si somma il terzo addendo C. In questo modo si ottengono i 4 bit meno signicativi del risultato (y3 .....y0). I due bit pi` signicativi del risultato si ottengono prenu dendo i carry generati dai due sommatori e sommandoli mediante un Half Adder, come riportato in gura 6.73 che mostra il circuito nale.

5.16 Incrementatore e Decrementatore per 2

Realizzare un circuito che sia in grado di incrementare o decrementare di 2 una parola di 8 bit e poi ottimizzarlo con la tecnica della Contrazione. 60

A
c

C
c

HA
s

y5

y4

y3 y2 y1 y0
Figura 5.5:

Soluzione Per realizzare il circuito che incrementa (Sub = 0) e decrementa (Sub = 1) di due una parola su 8 bit, occorre avere a disposizione un sommatore a 8 bit con la possibilit` di sommare il numero +2 o -2. a Se si usa la codica in complemento a 2, e sufciente codicare i due numeri ` +2 e -2 e riportarli su uno degli ingressi del sommatore mediante un multiplexer controllato dalla variabile Sub. Sullaltro ingresso si invia il numero xi e si effettua la somma. Se si vuole ottimizzare il progetto ed utilizzare la tecnica della Contrazione, si pu` osservare come la codica dei due numeri sia o +2 0 -2 1 0 0 0 0 0 Add 1 1 1 1 1 Sub 1 1 x1 0 0 x0

Si noti come in entrambi i casi, nella somma con la costante, x0 resti invariato, dato che si deve sempre sommare ad esso il valore 0; ad x1 invece deve 61

sempre essere sommato 1 e quindi il valore di uscita sar` il suo complemento e a in caso valga 1, si propaga un Carry al bit successivo. Tutti i bit pi` signicativi u (x2 , x3 , x4 , x5 , x6 , x7 ) devono essere sommati o con tutti 0 o con tutti 1 a seconda del tipo di operazione ed in pi` si deve provvedere alla somma delleventuale riporto u proveniente da x1 . Per questo e sufciente inserire una catena di FA con riporto ` che dipende dal segnale di controllo Sub. Il circuito ottimizzato con la tecnica della Contrazione che esegue quanto richiesto e riportato in gura 5.6. `

x7 Sub FA S7

x6

x5

x4

x3

x2

x1

x0

FA S6

FA S5

FA S4

FA S3

FA S2

C_in

S1

S0

Figura 5.6:

5.17 Complemento a 9 di un digit BCD

Progettare un circuito che generi il complemento a nove di un digit BCD (il complemento a 9 di d e 9 d). ` Soluzione Sia Y = y3 y2 y1 y0 il complemento a 9 del digit BCD X = x3 x2 x1 x0 . Y e denito ` dalla seguente tavola di verit` : a

62

x3 0 0 0 0 0 0 0 0 1 1

x2 0 0 0 0 1 1 1 1 0 0

x1 0 0 1 1 0 0 1 1 0 0

x0 0 1 0 1 0 1 0 1 0 1

y3 1 1 0 0 0 0 0 0 0 0

y2 0 0 1 1 1 1 0 0 0 0

y1 0 0 1 1 0 0 1 1 0 0

y0 1 0 1 0 1 0 1 0 1 0

La sintesi delle 4 uscite della tavola di verit` e : a` y0 y1 y2 y3 = x0 = x1 = x2 x1 + x2 x1 = x3 x2 x1

5.18 Addizione BCD e VHDL

Derivare uno schema per effettuare addizioni in BCD e descriverne il funzionamento in VHDL. Usare la tecnica della contrazione per ottimizzare il circuito nale. Soluzione Si supponga che i due numeri da sommare siano x e y deniti in BCD su 4 bit. Il testo del problema richiede di effettuare la somma dei due digit con eventuale riporto sul digit pi` signicativo. u x3 ...x0 0-9 + y3 ...y0 0-9

La somma avviene in modo usuale se sommando i due addendi il risultato e inferiore a 10 e quindi e esprimibile naturalmente sul digit meno signicativo ` ` del risultato; in caso contrario, se x + y > 9, il riporto deve essere fatto sul digit successivo e occorre normalizzare il risultato ovvero va effettuata una correzione. 63

x 4 Carry_out

y 4 C_in

Sommatore 4 bit z 30 4

Adjust (add 6) if z>9 6 Adjust 1 0 0

Sommatore 4 bit 4 C_out S

Figura 5.7: La correzione avviene in 2 casi: 1. 9 < x + y 15 Non si genera internamente il riporto C out verso il digit pi` signicatiu vo. Si deve generare articialmente un riporto e riportare il digit meno signicativo nellintervallo 0-9 sommando 6. 2. x + y > 15 u Si genera C out verso il digit pi` signicativo. Si deve quindi generare il riporto grazie a C out ma il digit meno signicativo del risultato e corretto. ` Esempio: 7 + 5 = 1. 12 0111 + 0101 = 01100 + 00110 1.0010 C out=1 64

= 12 + 6

8 + 2. 9 = 17

1000 + 1001 = 1.0111 C out=1

Lo schema del circuito che realizza quanto denito dallalgoritmo di somma dei numeri in BCD e riportato in gura 5.7 ` La realizzazione con la tecnica della contrazione della parte di correzione richiede lanalisi dei bit di somma parziali Zi e del Carry out dello stesso sommatore. Lequazione che genera il segnale di uscita Ad just del circuito e: ` Ad just = Carryout + Z3 (Z2 + Z1 ) e si riferisce alle due condizioni indicate precedentemente. Il circuito nale che esegue la correzione a partire dalle uscite del sommatore a 4 bit che genera Zi e ` riportato in gura 5.8.

Carry_out

z3 z1 z2 z3

z3 z2 Adjust

z1

z0

Sommatore 2 bit

C_out

S3
Figura 5.8:

S2

S1

S0

Il codice VHDL del circuito richiesto (senza le ottimizzazioni ottenute con la tecnica della Contrazione) e : `

65

LIBRERY ieee; USE ieee.std_logic_1164.all; USE iee.std_logic_unsigned.all; ENTITY BCD IS PORT ( X, Y S END BCD;

: IN STD_LOGIC_VECTOR ( 3 DOWNTO 0 ); : OUT STD_LOGIC_VECTOR ( 4 DOWNTO 0 ));

ARCHITECURE Behavior OF BCD IS SIGNAL Z : STD_LOGIC_VECTOR ( 4 DOWNTO 0); SIGNAL Adjust : STD_LOGIC; BEGIN Z <= ( 0 & X ) + Y; Adjust <= 1 WHEN Z > 9 ELSE 0; s <= Z WHEN ( Adjust = 0 ) ELSE Z + 6; END Behavior;

5.19 Sottrazione BCD

Derivare uno schema a blocchi per implementare la sottrazione di due operandi in formato BCD. Suggerimento: La sottrazione e facilmente realizzabile se gli operandi sono rap` presentati in complemento a 10 (radice del complemento). In tale rappresentazione il segno e 0 per i numeri positivi, e 9 per quelli negativi. ` Soluzione La sottrazione in BCD pu` essere attuata usando la rappresentazione in como plemento a 10 utilizzando un approccio analogo a quello utilizzato per la sottrazione in complemento a 2. Si noti come i complementi a 10 e a 2 siano i complementi alle radici nel sistema di numerazione, dove le radici sono rispettivamente 10 e 2. Siano dati due numeri X e Y (in notazione BCD) in complemento a 10, tali che il segno del digit pi` signicativo sia 0 per i numeri positivi e 9 per i negativi. La u ` sottrazione S = X Y si effettua trovando il complemento a 10 di Y e sommandolo a X, ignorando qualsiasi riporto (carry) del digit di segno. Per esempio, dati X = 068 e Y = 043, allora il complemento a 10 di Y e 957 e ` S = 068 + 957 = 1025. Ignorando il riporto (carry out) del digit di segno si ottiene il risultato corretto S = 025. 66

Come altro esempio si considerino X = 032 e Y = 043; allora S = 032 + 957 = 989, che rappresenta 1110 in complemento a 10. Il complemento a 10 di Y pu` essere effettuato aggiungendo 1 al complemento a o 9 di Y; lo schema a blocchi del circuito che permette quindi di effettuare addizioni e sottrazioni in BCD pu` essere visto in gura 5.9, dove il segnale Add/Sub viene o utilizzato per discriminare somme e sottrazioni. Il blocco che realizza il complemento a 9 e stato derivato in un esercizio prece` dente.

complementatore a9

MUX

Add/Sub

Sommatore BCD

S
Figura 5.9:

5.20 Interpretazione graca di un numero BCD a 3 digit con segno

Mostrare sul cerchio dei numeri uninterpretazione graca di un numero decimale in BCS a 3 digit, il pi` signicativo dei quali e il bit di segno (0 per i numeri u ` positivi, 9 per i numeri negativi.) Vericare la validit` della risposta con qualche a 67

esempio.

Soluzione La rappresentazione graca sul cerchio dei numeri prevede di considerare tutti i numeri del tipo 0XX se positivi e 9XX se negativi. Tali numeri sono riportati sul cerchio dei numeri come in gura 5.10.
000 001

998 999 997 996

002

003 004

096 904 903 902 901 900 099 098 097

Figura 5.10:

Per vericare la rappresentazione supponiamo, ad esempio, di effettuare laddizione 3 + (+5) = 2. Questo vuol dire rappresentare 3 in complemento a 10 ovvero 997 = 3 e identicato il punto sul cerchio sommare 5 vuol dire muoversi in senso orario di 5 posizioni. Il risultato e quindi 002(= +2). ` Come altro esempio, la sottrazione 4 (+8) = 4, implica partire da 004(= +4) e contare in senso antiorario (sottrarre) per 8 numeri, il risultato e 996(= 4). `

5.21 Half-adder ternario

In un sistema di numerazione ternario vi sono tre possibili valori: 0, 1 e 2. Nella tabella sottostante si denisce la tabella di verit` relativa alla somma di due numeri a mediante un half-adder ternario. Progettare il circuito che implementi tale halfadder, usando una codica binaria dei segnali, tale che due bits vengono usato per 68

ogni dato ternario. I dati ida sommare sono A = a1 a0 e B = b1 b0 mentre la somma ternaria e Sum = s1 s0 ; ` Poich la somma di due numeri produce al massimo un singolo carry, luscita e Carry e un segnale binario. Si usi la notazione che segue: 00 = (0)3 , 01 = (1)3 e ` 10 = (2)3. Minimizzare il costo del circuito. A B Carry Sum 0 0 0 0 0 1 0 1 0 2 0 2 1 0 0 1 1 1 0 2 1 2 1 0 2 0 0 2 2 1 1 0 2 2 1 1

Soluzione Lhalf-adder, con una codica binaria, pu` essere denito come segue: o A a1 a0 00 00 00 01 01 01 10 10 10 B b1 b0 00 01 10 00 01 10 00 01 10 Carry cout 0 0 0 0 0 1 0 1 1 Sum s1 s0 00 01 10 01 10 00 10 00 01

Le rimanenti 7 condizioni non previste, con a1 = a0 = 1, e/o b1 = b0 01, possono essere trattate come condizioni di dont care. Le funzioni logiche che minimizzano la copertura del circuito sono:

69

cout = a0 b1 + a1 b1 + a1 b0 s 1 = a0 b0 + a1 a0 b1 + a1 b1 b0 s 0 = a1 b1 + a1 a0 b0 + a0 b1 b0

5.22 Full-adder ternario

Progettare un full-adder ternario, usando lapproccio descritto nel problema precedente. Soluzione Il full-adder ternario, pu` essere denito dalla seguente tabella di verit` : o a Ci n A 0 0 0 0 0 0 0 1 0 1 0 1 0 2 0 2 0 2 1 0 1 0 1 0 1 1 1 1 1 1 1 2 1 2 1 2 B 0 1 2 0 1 2 0 1 2 0 1 2 0 1 2 0 1 2 Cout 0 0 0 0 0 1 0 1 1 0 0 1 0 1 1 1 1 1 Sum 0 1 2 1 2 0 2 0 1 1 2 0 2 0 1 0 1 2

Utilizzando la codica binaria su due bit per gli ingressi A e B e per luscita S gi` utilizzata nellesercizio precedente, la tabella pu` essere denita come segue: a o

70

cin ci n 0 0 0 0 0 0 0 0 0 1 1 1 1 1 1 1 1 1

A a1 a0 00 00 00 01 01 01 10 10 10 00 00 00 01 01 01 10 10 10

B b1 b0 00 01 10 00 01 10 00 01 10 00 01 10 00 01 10 00 01 10

Carry Sum cout s1 s0 0 00 0 01 0 10 0 01 0 10 1 00 0 10 1 00 1 01 0 01 0 10 1 00 0 10 1 00 1 01 1 00 1 01 1 10

Le rimanenti 14 combinazioni degli ingressi dove a1 = a0 = 1 e/o b1 = b0 = 1 sono condizioni dont care. La migliore copertura delle mappe per ottenere un costo minimo e: ` cout = a0 b1 + a1 b0 + a1 cin + b1 cin + a0 b0 cin s1 = a0 b0 cin + a1 a0 b1 cin + a1 b1 b0 cin + a1 b1 cin + a1 a0 b0 cin + a0 b1 b0 cin s0 = a1 b1 cin + a1 a0 b0 cin + a0 b1 b0 cin + a1 b0 cin + a0 b1 cin + a1 a0 b1 b0 cin

5.23 Sottrattore decimale

Considerando le sottrazioni 26 27 = 99 e 18 34 = 84 spiegare in che modo queste risposte (99 e 84) possano essere interpretate come corretti risultati con segno di queste sottrazioni. Soluzione Le sottrazioni 26 27 = 99 e 18 34 = 84 hanno un signicato se i numeri su due digit da 00 a 99 sono interpretati come segue: da 00 a 49 sono numeri positivi 71

(da 0 a 49), mentre i numeri da 50 a 99 sono numeri negativi, (da 50 a 1). Questo schema e illustrato sul cerchio dei numeri in gura 5.11 e su questo si ` possono vericare i calcoli effettuati nelle due sottrazioni.
99
1

98
97 3 2

00
0

01
+1

02
+2

03

+3

48 49 50

+49

+48

52 51

48 50 49

Figura 5.11:

5.24 Sommatore binario 2-bit

Progettare un circuito combinatorio che implementi un sommatore binario a 2-bit, partendo dai due addendi A1 A0 , B1 B0 , e generando i bit di somma S1 S0 .Il sommatore ha in ingresso un bit di carry-in C0 e in uscita oltre ai bit di somma viene generato il carry out C2 . Progettare lintero circuito sintetizzando ognuna delle tre uscite mediante un circuito a due livelli, pi` eventuali inverter per le variabili di u input. Iniziare il progetto con le equazioni che seguono, per ogni bit del sommatore: Si = Ai BiCi + Ai BiCi + Ai BiCi + Ai BiCi Ci+1 = Ai Bi + AiCi + BiCi

Soluzione 72

La sintesi a due livelli delle tre uscite da ricavare richiede la scelta di rappresentare le funzioni nella forma somma di prodotti (SOP). Derivazione di S0 : S0 = A0 B0C0 + A0 B0C0 + A0 B0C0 + A0 B0C0 Derivazione di S1 : S1 = A1 B1C1 + A1 B1C1 + A1 B1C1 + A1 B1C1 dove C1 e il carry-out dei bit meno signicativi del sommatore: ` C1 = C0 A0 + A0 B0 +C0 B0 Ne consegue quindi per S1 : S1 = A0 A1 B1C0 +A0 B0 A1 B1 +C0 B0 A1 B1 +C0 A0 A1 B1 +A0 B0 A1 B1 +C0 B0 A1 B1 + C0 A0 A1 B1 + A0 B0 A1 B1 +C0 B0 A1 B1 +C0 A0 A1 B1 + A0 B0 A1 B1 +C0 B0 A1 B1 A questo punto si pu` ricavare il valore del carry-out del sommatore C2 : o C2 = C1 A1 + A1 B1 +C1 B1 C2 = C0 A0 A1 + A0 B0 A1 +C0 B0 A1 +C0 A0 B1 + A0 B0 B1 +C0 B0 B1 + A1 B1

C1 T3 B0 A0 T1 T4 T2 S0

C0

Figura 5.12:

73

5.25 Sommatore 4-bit

Il circuito logico del primo stadio di un sommatore a 4-bit, del tipo 74283, e ` implementato come in gura 5.12; vericare che il circuito realizza un full-adder. Soluzione Deriviamo dapprima la funzione del bit di somma S0 : S0 = C0 T4 = C0 T1 T 2 = C0 A0 B0 (A0 + B0 ) = C0 (A0 + B0 )(A0 + B0 ) = C0 A0 B0 + A0 B0 ovvero S0 = A0 B0 C0 Il bit di carry-out C1 e invece ` C1 = T1 + T2 = T1C0 + T2 = A0 B0 C0 + A0 + B0 = (A0 + B0 )C0 + A0 B0 = (A0 B0 + C0 )(A0 + B0 ) ovvero C1 = A0 B0 + A0C0 + B0C0 Se ne deduce quindi che le funzioni logiche realizzate sono proprio quelle canoniche di un full-adder.

5.26 Somme algebriche in Complemento a 2

Eseguire le operazioni aritmetiche (+36) + (24) e (35) (24) utilizzando per i numeri negativi una rappresentazione in complemento a 2.

Soluzione

74

+36 24

= 0100100 = 1101000

36 +(24) = 12

0100100 + 1101000 1 0001100 = 0001100 1011101 0011000 1110101

35

= 1011101

35 (24) = 11

+ =

5.27 Sommatore con una costante

Progettare un circuito che sommi 0011 ad un dato in ingresso su 4-bit, e dia in uscita il risultato su 4 bit pi` il bit di Carry. u Soluzione In gura 5.2 e riportato lo schema del circuito che pu` essere ricavato partendo ` o dal circuito base del sommatore con un HalfAdder (per il bit meno signicativo) e 3 FullAdder procedendo poi con la tecnica di riduzione per contrazione (Design by Contraction) come denito a lezione.

5.28 Conta numero di 1 presenti in ingresso

Supponendo di voler contare quanti bit a 1 sono presenti in un numero UNSIGNED a 3 bit, progettare un circuito che realizzi ci` . In seguito ripetere lesercio zio con un numero UNSIGNED a 6 bit e inne con un numero UNSIGNED a 8 bit. Soluzione La conta si effettua usando dei Full Adder che contano in binario il numero di 1 presenti in ingresso: 1. Numero UNSIGNED su 3 bit: In questo caso il circuito e semplice perch` si devono contare solo tre ingres` e si e per questo basta un Full Adder in cui si collegano entrambi gli ingressi di dato e il carry in ingresso. Il circuito e riportato in gura 5.13. ` 75

x1 S x2 x3
Figura 5.13: 2. Numero UNSIGNED su 6 bit: In questo caso sono necessari due stadi di somma, come riportato in gura 5.14. Nel primo si sommano tre ingressi per volta, mentre il secondo stadio somma le uscite del primo stadio di peso omologo. Si usa un HA nel secondo livello invece di un FA per ottimizzare il circuito dovendo sommare solo 2 bit di peso meno signicativo.

y1 y0

FA
C

x1 c FA s

x2

x3 c

x4 FA s

x5

x6

c 22 y
2

FA s 21 y
1

HA s 20 y
0

Figura 5.14: 3. Numero UNSIGNED su 8 bit:

76

La somma di 8 bit richiede tre stadi di somma. In gura 5.15 si nota come nel primo stadio ci sono 2 FA e un HA per la somma degli 8 ingressi. Il secondo stadio permette di generare il bit meno signicativo del risultato (y0 ) e prepara il bit di peso 21 che viene generato dal HA del terzo stadio di peso inferiore. LHalf adder di peso superiore invece genera i due bit pi` u signicativi del risultato (y3 e y2 ).

x1 x2

x3 x4

x5

x6 x 7

x8

HA s

FA s

FA s

FA s

FA s

HA s

HA s

2 y
3

2 y
2

2 y
1

2 y
0

Figura 5.15:

77

5.29 Comparatore > = <

Realizzare un circuito che compari due numeri SIGNED a 4 bit e generi i ag Z = (Zero), N = (Negative) e V = (Over f low) da cui denire le relazioni x = y, x < y, x y, x > y e x y. Soluzione I due numeri da confrontare su 4 bit nella forma SIGNED in complemento a due sono xi e yi , dove il bit pi`u signicativo rappresenta il segno: sign x3 y3 x2 y2 x1 y1 x0 y0

Per poter denire i ag di confronto e le relazioni di maggioranza, minoranza, etc., si effettua la differenza dei due numeri x y, ricorrendo al concetto di somma con il complemento a due del sottraendo (y). Il circuito quindi usa 4 FA in cui lingresso y viene complementato e il bit di Carryin del primo stadio (C0 ) e sso a ` 1. I bit di Z, N e V vengono calcolati con il solito metodo e sono riportati in gura 5.16. Deniamo le funzioni che calcolano le diseguaglianze richieste: x<y x e y hanno lo stesso segno non si genera mai overow (V = 0) se (x y) e negativo N = 1 e la condizione e vera ` ` x negativo, y positivo V = 0, N = 1 (Risultato corretto e condizione vera) V = 1, N = 0 (Risultato non corretto ma condizione vera) x positivo, y negativo la condizione non e mai vera ` x=y Si verica sempre quando Z = 1 (condizione vera) x>y

78

x3

y3

x2

y2

x1

y1

x0

y0

C4

FA
S3

C3

FA
S2

C2

FA
S1

C1

FA
S0

C0 1

Figura 5.16: se x e y hanno lo stesso segno non si verica mai overow V = 0 Se (xy) e positivo e maggiore di zero N = 0, Z = 0 e la condizione ` e vericata ` se x e y hanno segno opposto x positivo, y negativo V = 0, N = 0 (Risultato corretto e condizione vera) V = 1, N = 1 (Risultato non corretto ma condizione vera) x negativo e y positivo Condizione mai vera Con le considerazioni precedenti si determinano le funzioni booleane che realizzano le diseguaglianze richieste: x < yV +N =1 x=yZ=1 x y V + N +Z = 1 79

 x > y = x y V + N +Z = 1 xy=x < y V +N =1

5.30 Comparatore di uguaglianza di due numeri senza segno su 4 bit

Progettare un circuito che lavora come comparatore di uguaglianza di due numeri senza segno su 4 bit. Soluzione Una possibile soluzione e riportata in gura 5.17 . La realizzazione e molto ` ` semplice in quanto i due numeri sono uguali solo quando sono uguali bit a bit. Per questo e sufciente una catena di XOR con tanto di NOR in uscita per vericare ` che ci sia luguaglianza su tutti i bit da confrontare.
x y
7

y1

x0 y0

Uguaglianza

Figura 5.17:

80

5.31 Comparatore su 4-bit

Progettare un circuito combinatorio che confronti due numeri UNSIGNED di 4 bit, e dia come risultato il bit X, che pu` assumere il valore X = 1 se A < B e o X = 0 se A B. Soluzione

A3

B3

A2

B2

A1

B1

A0

B0

Figura 5.18: Procedendo dal bit pi` signicativo al bit meno signicativo si ha che A e miu ` nore di B se per tutti i bit maggiori di i i due numeri sono uguali mentre per i bit di indice i risulta Ai < Bi . Ovvero: A < B se Ai < Bi (Ai Bi = 1) e per tutti i bit j tali che j > i risulta A j = B j (A j B j + A j B j = 1).

81

Sulla base di quanto sopra, X = A3 B3 + (A3 B3 + A3 B3 )A2 B2 + (A3 B3 + A3 B3 )(A2 B2 + A2 B2 )A1 B1 + (A3 B3 + A3 B3 )(A2 B2 + A2 B2 )(A1 B1 + A1 A1 )A0 B0 . Lo schema del circuito e riportato in gura 5.18. `

5.32 Comparatore su 4-bit modulare

Ripetere lesercizio precedente, usando come circuito base un blocco con tre ingressi e unuscita in grado di discriminare la condizione di maggiore su un singolo bit. I quattro circuiti (uno per ognuno dei 4 bit) sono connessi in cascata tramite un segnale Cin /Cout che propaga la condizione di minoranza (A < B) da parte dei bit meno signicativi. Soluzione

A B C in C out

A B C in

C out

XC

A3 B3 C3

A2 B2 C2

A1 B1 C1

A0 B0 0

Figura 5.19:

82

Ogni blocco base ha due ingressi di un bit A e B e un segnale Cin che propaga linformazione se per i bit meno signicativi delle due parole da confrontare e ` vera la condizione A B (Cin = 0) o A < B (Cin = 1). Luscita Cout varr` 1 se tutti a gli stadi meno signicativi, compreso quello in analisi, portano al risultato A < B. In gura 5.19 e riportato lo schema del singolo blocco logico nonch la catena ` e di blocchi che costituiscono tutto il circuito richiesto.

5.33 Comparatore su 4-bit realizzato con un sottrattore a 4 bit

Ripetere lesercizio precedente, utilizzando un sottrattore a 4 bit e la tecnica della contrazione; luscita X che denisce il risultato della comparazione e il riporto ` della sottrazione e vale X = 1 se A < B e X = 0 se A B. Soluzione In un sottrattore A B, rispetto ad un normale sommatore la somma e rimpiaz` zata dalla differenza e il carry dal riporto (borrow). Il riporto della sottrazione ad ogni bit vale 1 solo se per i bit meno signicativi, partendo proprio da quello che genera il borrow, vale la condizione A < B. Per produrre luscita X e quindi necessario considerare solo il borrow che indi` ca proprio tale condizione: dal bit LSB no a questo vale la relazione A < B. Per tale motivo si pu` ridurre, per contrazione, tutta la logica che non partecio pa alla generazione del borrow ma serve solo per denire i bit del risultato della sottrazione. Lequazione per il calcolo del riporto Br nella posizione i + 1 e : ` Bri+1 = Ai Bi + Ai Bri + Bi Bri per i = 0.....3.

Il riporto di ingresso al LSB del sottrattore e 0, ovvero Br0 = 0; di conseguen` za, usando la tecnica della contrazione, risulta Br1 = A0 B0 . Per tutti gli altri bit di peso superiore, il blocco logico implementato deve realizzare lequazione appena descritta. Si consideri ora il borrow del bit pi` signicativo: se il riporto Br4 = 1, allora u A < B. Ne consegue quindi che luscita del circuito deve essere X = Br4 In gura 5.20 e riportato lo schema del circuito da cui si ricava la presenza di tre `

83

blocchi identici per la gestione del Brin /Brout nei bit pi` signicativi nonch land u e e linverter per la gestione del primo riporto, usando la tecnica della contrazione.

B3 Bi X Br i+1

A3 A

B2 B Br

A2

B1 B

A1 Ai Br i

A0

B0

Ai
Br i

Br i

i+1

Br i+1

Figura 5.20:

5.34 Comparatore di uguaglianza e maggioranza su 4-bit modulare

Progettare un circuito combinatorio che compari due numeri su 4-bit UNSIGNED. In uscita si devono distinguere i casi in cui A = B oppure A > B. Si utilizzi, per la realizzazione di quanto richiesto, un circuito modulare sulla falsariga di quanto denito negli esercizi precedenti. Soluzione In questo problema il circuito deve avere due uscite relative alle due decisioni che devono essere prese: se sia vero che A > B, oppure se sia vero che A = B. Per generare un circuito modulare, da replicare ad ogni bit, sono necessarie due catene di carry: Gi (Greater = maggiore) e Ei (Equal = uguale). I carry passano attraverso il circuito dal bit meno signicativo verso il pi` signicativo. Lo schema logico e u ` riportato in gura 5.21 dove il bit meno signicativo si trova a destra e le catene di carry corrono da destra verso sinistra, iniziando con G0 = 0 e E0 = 1. Ogni cella ha come ingressi Ai , Bi , Gi e Ei mentre Gi+1 e Ei+1 sono le uscite del blocco che si collegheranno al blocco successivo. Usando le mappe di karnaugh per la sintesi, le equazioni delle celle sono : Ei+1 = Ai Bi Ei + Ai Bi Ei Gi+1 = Ai Bi Ei + (Ai + Bi )Ei

84

Usando la tecnica della sintesi multilivello, il costo del circuito pu` essere rio dotto sfruttando i termini condivisi: Ei+1 = (Ai Bi + Ai Bi )Ei Gi+1 = (Ai Bi + (Ai Bi )Gi
B3 B E i+1 G i+1 A3 Ai B2 B E i+1 G i+1 A2 Ai B B E i+1 G i+1 A1 Ai B0 B E i+1 G i+1 A0 Ai

E4 G4

Ei

Ei

Ei

Ei

E0 =1

Gi

Gi

Gi

Gi

G0=0

Figura 5.21:

5.35 Sommatore Ripple-Carry

Il circuito in gura 5.22 pu` essere usato come blocco base in un sommatore o carry-ripple. Discutere i pro e i contro di tale implementazione.
Ci

Pi Xi

Si

Vdd

Gi Yi Ci+1

Figura 5.22:

Soluzione Il circuito genera il valore complementato del carry out e richiede il valore negato del carry in ingresso allo stadio. Per questo e necessario inserire al carry in ` 85

in ingresso, una porta NOT per invertire il carry in proveniente dallesterno. Tale gate non e necessario negli altri stadi della catena (quando i > 0) dato che la catena ` di propagazione e tutta basata su segnali di carry in logica negata. Laspetto po` sitivo di questa implementazione riguarda il ridotto numero di transistori NMOS per produrre ci+1 a partire dal ci , condizione critica per la velocit` del sommatore. a Lo svantaggio e la propagazione di ci = 1 attraverso lNMOS pi` in alto che crea ` u quindi una catena di NMOS in serie lungo gli stadi.

5.36 Carry-Lookahead Gerarchico

Si realizzi un sommatore Carry-lookahed gerarchico a 4 bit, nellipotesi di avere a disposizione dei blocchi elementari di somma a 2 bit con generazione dei bit G e P.

Soluzione

X3 Y3 X2 Y2

X1 Y1 X0 Y0

ADD_2bit

ADD_2bit

C0

G1 P1

S3 S2

G0 P0

S1 S0

C4

C2

Figura 5.23:

La soluzione per la versione a 4-bit del sommatore gerarchico e rappresentata ` in gura 5.23. 86

Il blocco di somma a 2 bit (ADD 2bit) oltre a generare i due bit di uscita di somma, genera i bit di Generate (Gi ) e Propagate (Pi ) secondo le equazioni descritte di seguito. I due blocchi sottostanti realizzano le funzioni booleane di creazione dei carry. Complessivamente il circuito ha le espressioni: pi = xi + yi gi = xi yi P0 = p1 p0 G0 = g 1 + p 1 g 0 P1 = p3 p2 G1 = g 3 + p 3 g 2 c2 = G0 + P0 c0 c4 = G1 + P1 G0 + P1 P0 c0

5.37 Codice VHDL ignoto

Si consideri il codice VHDL sottostante; si trovi la relazione fra i segnali Input e Out put e si identichi la funzione del circuito descritto dal codice. Commentare se il codice VHDL rappresenta un buon stile di utilizzo del linguaggio per le funzionalit` che esso rappresenta. a LIBRARY ieee; USE ieee.std_logic_1164.all; ENTITY Circuito IS PORT(Input :I N STD_LOGIC_VECTOR(3 DOWNTO 0); Output : OUT STD_LOGIC_VECTOR(3 DOWNTO 0)); END Circuito; ARCHITECTURE behav BEGIN WITH Input SELECT Output<="0001" "0010" "0011" "0010" "0100" "0110" "0011" OF Circuito IS

WHEN WHEN WHEN WHEN WHEN WHEN WHEN

"0101", "0110", "0111", "1001", "1010", "1011", "1101", 87

"0110" WHEN "1110", "1001" WHEN "1111", "0000" WHEN OTHERS; END behav;

Soluzione Il codice rappresenta un moltiplicatore a due bit. Esso moltiplica i due bit meno signicativi dell Input con i due bit bit pi` signicativi dello stesso dato, u producendo lOut put su quattro bit. Lo stile del codice e mediocre, perch` non ` e descrive prontamente le funzionalit` di un moltiplicatore. a

5.38 Percorso critico di un moltiplicatore

Determinare il percorso critico (critical path) del moltiplicatore parallelo descritto in gura 5.24. Determinare il ritardo lungo il percorso critico in termini di numero di porte.

m3

m2

m1

m0 q0

PP1 0

q2 q3

PP2 0 p
7

Figura 5.24:

88

Soluzione Il circuito moltiplicatore illustrato in gura 5.24 e composto da tre righe, la ` prima delle quali contiene blocchi del tipo riportato in gura 5.25, mentre le restanti due righe sono costituite da blocchi logici come quelli riportati in gura 5.26.
m k+1 mk

q0 q1

c out

FA

c in

Figura 5.25:

Bit of PPi

mk

qj

c out

FA

c in

Figura 5.26: Il percorso pi` lungo (vedi gura 5.27) che causa il ritardo critico, va dagli u input m0 e m1 alloutput p7 attraversando orizzontalmente tutta la prima linea 89

m3

m2

m1

m0 q0

PP1 0

q1 q2 q3

PP2 0 p
7

Figura 5.27: di blocchi per poi scendere verticalmente no allultima linea e dopo spostarsi ulteriormente verso sinistra no alla ne dei blocchi dove c` appunto luscita p7 , e come indicato dalla linea tratteggiata nella gura 5.27.

5.39 VHDL di un moltiplicatore

Scrivere il codice VHDL che descrive il moltiplicatore dellesercizio precedente partendo dal circuito che realizza la prima riga (gura 5.25), il circuito di base delle altre due righe (gura 5.26 ) e il circuito completo. Soluzione Codice VHDL del circuito di base che realizza il blocco base della prima riga del moltiplicatore e riportato in gura 5.25: LIBRARY ieee; USE ieee.std_logic_1164.all; ENTITY row0 IS; PORT ( q0, q1, cin, mk, mkp1 : IN 90

STD_LOGIC;

s, cout END row0;

: OUT STD_LOGIC );

ARCHITECTURE LogicFunc OF row0 IS SIGNAL a0, a1 : STD_LOGIC; BEGIN a0 <= q0 AND mkp1; a1 <= q1 AND mk; s <= cin XOR a0 XOR a1; cout <= ( cin AND a0 ) OR ( cin AND a1 ) OR ( a0 AND a1 ); END LogicFunc;

Codice VHDL del circuito che realizza il blocco base della seconda e terza riga del moltiplicatore e riportato in gura 5.26: LIBRARY ieee; USE ieee.std_logic_1164.all; ENTITY row1 IS; PORT ( qj, cin, mk, BitPPi : IN STD_LOGIC; s, cout : OUT STD_LOGIC ); END row1; ARCHITECTURE LogicFunc OF row1 IS SIGNAL a0 : STD_LOGIC; BEGIN a0 <= qj ANK mk; s <= cin XOR a0 XOR BitPPi; cout <= ( cin AND a0 ) OR ( cin AND BitPPi ) OR ( a0 AND BitPPi ); END LogicFunc;

Codice VHDL del moltiplicatore completo:

91

LIBRARY ieee; USE ieee.std_logic_1164.all; ENTITY mult4x4 IS PORT ( cin : IN STD_LOGIC; M, Q : IN STD_LOGIC_VECTOR (3 DOWNTO 0); P : OUT STD_LOGIC_VECTOR (7 DOWNTO 0)); END mult4X4; ARCHITECTURE Structure OF mult4x4 IS COMPONENT row0 PORT ( q0, q1, cin, mk, mkp1 : IN STD_LOGIC; s, cout : OUT STD_LOGIC ); END COMPONENT; COMPONENT row1 PORT ( qj, cin, mk, BitPPi : IN STD_LOGIC; s, cout : OUT STD_LOGIC ); END COMPONENT; SIGNAL PP1 : STD_LOGIC_VECTOR (5 DOWNTO 2); SIGNAL PP2 : STD_LOGIC_VECTOR (6 DOWNTO 3); SIGNAL Crow0, Crow1, Crow2 : STD_LOGIC_VECTOR (1 TO 3); BEGIN P(0) <= Q(0) AND M(0); row0_1: row0 PORT MAP (Q(0),Q(1),cin,M(0),M(1),P(1),Crow0(1)); row0_2: row0 PORT MAP (Q(0),Q(1),Crow0(1),M(1),M(2),PP1(2),Crow2(2)); row0_3: row0 PORT MAP (Q(0),Q(1),Crow0(2),M(2),M(3),PP1(3),Crow0(3)); row0_4: row0 PORT MAP (Q(0),Q(1),Crow0(3),M(3),cin,PP1(4), PP1(5) ); row1_2: row1 PORT MAP (Q(2),cin, M(0),PP1(2),P(2),Crow1(1)); row1_3: row1 PORT MAP (Q(2),Crow1(1),M(1),PP1(3),PP2(3),Crow1(2)); row1_4: row1 PORT MAP (Q(2),Crow1(2),M(2),PP1(4),PP2(4),Crow1(3)); 92

row1_5: row1 PORT MAP (Q(2),Crow1(3),M(3),PP1(5),PP2(5),PP2(6)); row2_3: row1 PORT MAP (Q(3),cin, M(0),PP2(3),P(3),Crow2(1)); row2_4: row1 PORT MAP (Q(3),Crow2(1),M(1),PP2(4),P(4),Crow2(2)); row2_5: row1 PORT MAP (Q(3),Crow2(2),M(2),PP2(5),P(5),Crow2(3)); row2_6: row1 PORT MAP (Q(3),Crow2(3),M(3),PP2(6),P(6),P(7)); END Structure;

93

Capitolo 6 Circuiti sequenziali

6.1 Flip-op SR sincrono con ip-op di tipo D
Un ip-op sincrono SR e un ip-op che ha gli ingressi SET e RESET come ` un SR, ma e sensibile al fronte di clock. Mostrare come un ip-op SR sincrono ` possa essere costruito a partire da un ip-op di tipo D. Soluzione La tabella di verit` del circuito SR e a ` S R Q 0 0 Q 0 1 0 1 0 1 1 1 0

stato proibito (RESET DOMINANT FF)

SR=10

A Q=1 SR=01,11

B Q=0

SR=10,00

SR=01,00,11

Figura 6.1: 94

Rispetto ad SR normale, lo stato proibito di fatto non esiste, ma si assegna lo stesso una codica delluscita. Nellesempio si suppone che si tratti di un SR Reset Dominant ovvero che nella condizione di stato proibito domini il reset. Il diagramma a stati del circuito e riportato in gura 6.1. ` Per non avere rete duscita, ovvero per far s` che luscita coincida con la va riabile di stato, si effettua la seguente assegnazione degli stati, dove y rappresenta lo stato presente e Y rappresenta lo stato futuro: Assegnamento stati e rete di uscita A = 1 B = 0 Q = y La tabella di verit` dello stato futuro e: a ` y S R Y 0 0 0 0 0 0 1 0 0 1 0 1 0 1 1 0 1 0 0 1 1 0 1 0 1 1 0 1 1 1 1 0 Lequazione che determina lo stato futuro Y vale Y = S R + y S R = R (S + y S) = R (S + y)

S R CK

y Q

Figura 6.2:

Il circuito nale che realizza quanto richiesto e descritto in gura 6.2. ` 95

6.2 Latch SR Set- Dominant

R R Q

Clk

Q S S

Figura 6.3: Il latch SR di tipo gated in gura 6.3 ha un comportamento non prevedibile se gli ingressi S e R sono entrambi uguali a 1 quando il segnale Clk commuta a 0. Un modo per risolvere questo problema consiste nel creare un latch SR gated di tipo set dominant in cui la condizione S=R=1 porta luscita del latch a essere comunque uguale a 1. Progettare un tal tipo di latch (SR gated set-dominant ) e disegnarne il circuito. Soluzione Il circuito richiesto e in gura 6.4. `
R Q

Figura 6.4:

6.3 Flip op MS a set dominante

Un ip-op a set dominante Master-Slave, ha come ingressi Set e Reset. Esso differisce da un comune SR-FF master-slave dal fatto che, quando sia S che R sono uguali a 1, luscita del ip-op e 1. ` 96

a) Determinare la tabella degli stati del ip-op a set dominante. b) Ricavare il diagramma degli stati per tale ip-op. c) Progettare il ip-op a set dominante usando un SR-FF, porte logiche e inverter.

Soluzione

La tabella degli stati del ip op da sintetizzare e riportata nella tabella se` guente:

S R Q 0 0 Q 0 1 0 1 0 1 1 1 1

Memoria Reset Set Set

Il diagramma degli stati e riportato in gura 6.5, dove luscita coincide con il ` valore dello stato (0 o 1).
00,01 10,11 00,10,11

0
01

Figura 6.5:

Per denire il circuito si identica dapprima la tabella delle transizioni, dove le uscite A e B rappresentano gli ingressi di Set e Reset di un FF-SR tradizionale.

97

Stato Presente Q 0 0 0 0 1 1 1 1

Ingressi Stato Futuro S R Q(t+1) 0 0 0 0 1 0 1 0 1 1 1 1 0 0 1 0 1 0 1 0 1 1 1 1

Uscite A B 0 x 0 x 1 0 1 0 x 0 0 1 x 0 x 0

Le equazioni di stato futuro sono: A=S B = SR Il circuito risultante e riportato in gura 6.6. `
A

CLOCK S R B

Figura 6.6:

6.4 Flip op MS a Set dominante - verica

Vericare manualmente la validit` della soluzione del problema precedente relaa tivo al ip op a Set dominante . Considerare tutte le transizioni di S e R con il clock uguale a 0. Soluzione

La verica manuale semplicemente prende in considerazione il circuito di gura 6.6 e la tabella degli stati prevista e ne compara i risultati con quella ottenuta vericando a mano: 98

Stato Presente Q 0 0 0 0 1 1 1 1

Ingressi Stato S R Q(t+1) 0 0 0 0 1 0 1 0 1 1 1 1 0 0 1 0 1 0 1 0 1 1 1 1

Futuro previsto Stato A B A 0 x 0 0 x 0 1 0 1 1 0 1 x 0 0 0 1 0 x 0 1 x 0 1

Futuro vericato B Q(t+1) 0 0 1 0 0 1 0 1 0 1 1 0 0 1 0 1

Clock D

Figura 6.7:

D Clock

Qa Qa Qb Qb Qc Qc

Clk

Figura 6.8:

99

6.5 Flip op di tipi diversi

Considerare il diagramma temporale mostrato in gura 6.7. Assumendo che gli ingressi D e Clock vengano inviati al circuito riportato in gura 6.8, disegnare le forme donda dei segnali Qa , Qb e Qc . Soluzione Le forme donda richieste sono riportate in gura 6.9.

Clock D Qa Qb Qc

Figura 6.9:

6.6 Latch SR
Il circuito in g. 6.10 pu` essere modicato per implementare un latch SR? o Motivare la risposta. Soluzione Il circuito in gura 6.10 pu` diventare un latch SR connettendo S allingresso o Data e SorR allingresso Load. Cos` il valore di S viene caricato nel latch quando S o R viene asserito (settato a 1). Bisogna assicurarsi che il segnale Data rimanga stabile mentre il segnale Load viene settato a 1 altrimenti il circuito non funziona come richiesto.

100

Load

Data TG1

Output

TG2

Figura 6.10:

6.7 Latch Nand-Nand

La gura 6.11 mostra un latch realizzato con porte NOR. Disegnare un latch simile usando porte NAND. Ricavare la sua tabella di verit` e il diagramma temporale a che illustri il suo funzionamento.

Qa

Qb

Figura 6.11:

Soluzione Il circuito e riportato in gura 6.12. ` La tabella di verit` del circuito e a ` S R 1 1 1 0 0 1 0 0 Qa 0/1 0 1 1 Qb 1/0 (memoria) 1 0 1

101

Figura 6.12:

6.8 Latch SR gated

Disegnare un circuito che implementi un latch SR gated usando solo porte NAND. Soluzione Il circuito richiesto e in gura 6.13. `
S Q Clock Q R

Figura 6.13:

6.9 Divisore di frequenza

Dato un segnale di clock a 100 MHz, ricavare un circuito usando ip-op di tipo D per generare segnali di clock a 50 MHz e 25 MHz. Disegnare il diagramma temporale per tutti i segnali di clock, assumendo ritardi ragionevoli. Soluzione

102

Il circuito e riportato in gura 6.14. `

100 MHz

50 MHz

25 MHz

12.5 MHz

Figura 6.14: Il diagramma temporale richiesto e in gura 6.15 `

100 MHz

50 MHz

25 MHz

12.5 MHz

0 ns

10 ns

20 ns

30 ns

40 ns

50 ns

60 ns

70 ns

Figura 6.15:

6.10 JK con ip op T
Realizzare un ip-op JK utilizzando un ip-op T e altre porte logiche. Soluzione 103

Il circuito richiesto e in gura 6.16. `

J T K Q Clock Q Q Q

Figura 6.16:

6.11 JK negative-edge-triggered
Si consideri il circuito in gura 6.17. Le due porte NAND hanno un tempo di propagazione maggiore (circa il quadruplo) delle altre porte del circuito. Come si comporta questo circuito rispetto a quelli discussi precedentemente in questo capitolo?

A E

D C

Figura 6.17:

104

Soluzione Questo circuito si comporta come un ip-op JK negative-edge-triggered (in cui J = A, K = B, Clock = C, Q = D e Q = E). Si pu` trovare nel circuiti integrati o standard tipo 74LS107A (con laggiunta dellingresso Clear che qui non viene mostrato).

6.12 Confronto tra circuiti con ip op

Si consideri il circuito riportato in gura 6.18. Lo si confronti con il circuito in gura 6.19. Pu` essere usato per lo stesso scopo? In caso contrario, qual e la o ` differenza chiave tra i due?

J Clock K

S Clk R

S Clk

Figura 6.18:

J D K Q Q

Clock

Figura 6.19:

105

Soluzione Il circuito in gura 6.18 e un ip-op JK master-slave ed e affetto dal problema ` ` chiamato spesso ones catching: si consideri la situazione in cui luscita Q e al ` livello basso e i segnali Clock, J e K sono a 0; ora se Clock rimane stabile a 0 mentre J commuta da 0 a 1 per poi tornare a 0, il master va a 1 e questo valore verr` erroneamente trasferito allo slave quando Clock va al livello alto. Il circuito a in gura 6.19 si comporta invece in modo corretto.

6.13 Flip op D negative edge triggered

Progettare un circuito con porte NOR, simile a quello in gura 6.20, che implementi un ip-op D negative-edge-triggered.

Q Clock Q

Figura 6.20:

Soluzione Applicando pi` volte le leggi di DeMorgan` possibile trasformare il ip op u e D positive-edge-triggered in gura 6.20 in un ip op sempre di tipo D sensibile al fronte di discesa (Negative-edge-triggered) come riportato in gura 6.21.

106

Q Clock Q

Figura 6.21:

6.14 Flip-op di tipo D

Uno schema alternativo per un ip-op D positive-edge-triggered e mostrato in ` gura 6.22. Vericare manualmente che presenti effettivamente il comportamento previsto.

Q C Q

Figura 6.22:

Soluzione Una possibile simulazione del circuito e riportata in gura 6.23, dove si ipo` tizza che ogni porta logica presenti un ritardo arbitrario. Dalla simulazione si comprende come il circuto si comporti proprio come un ip-op di tipo D con C che agisce come segnale di clock e D come segnale di dato. 107

C D Q Q

Figura 6.23:

6.15 Confronto tra diversi tipi di ip-op D e latch

C D D C
D Q Q Latch Q1 Q1

D C

Q2 D Q
Q2

MS Triggered D

D C

Q3 D Q
Q3

Q Triggered D

Figura 6.24: Nella parte destra della gura 6.24 sono rappresentate le forme donda relative ai due segnali C e D applicati ai tre tipi di ip-op/latch deniti a sinistra. Disegnare e forme donda duscita Qi per il latch ed ognuno dei ip-op assumendo che la propagazione del ritardo negli elementi con memoria sia trascurabile e che inizialmente le uscite siano a 0. 108

Soluzione Le forme donda richieste sono riportate in gura 6.25.

C D

Q1 Q2

Q3

Figura 6.25:

6.16 Flip-op SR
Nella gura 6.26 sono rappresentate le forme donda di tre segnali C, S e R che sono applicati agli ingressi di tre tipi differenti di ip-op di tipo SR. Per ognuno dei ip-op disegnare le forme donda duscita Qi assumendo che la propagazione del ritardo negli elementi con memoria sia trascurabile e che inizialmente le uscite siano a 0.

Soluzione Le forme donda richieste sono riportate in gura 6.27.

109

C S R S
S Q

Q1

Q1 R
R Q

SR
S

Q2
S Q

C R

Q2

S C

MasterSlave Triggered SR Q3
S Q

Q3
C

MasterSlave Triggered SR

Figura 6.26:

6.17 Flip Flop LH

Progettare un nuovo tipo di ip op Positive-Edge-Triggered chiamato LH. Il nuovo oggetto ha un clock C, un ingresso di dato D e un ingresso di load L. Se, su un fronte positivo di C, L e uguale a 0, allora il valore correntemente memorizzato ` nel ip op sar` mantenuto (stato di memoria); se invece L = 1 il valore di D verr` a a memorizzato. Progettare il ip-op usando solo dei ip op SR (ingressi attivi bassi), porte NAND e inverter. Soluzione

110

S R

Q1

Q2

Q3

Unknown

Figura 6.27: Per realizzare il ip op di tipo Positive Edge Triggered, si pu` usare la tecnica o gi` sperimentata per realizzare un ip op D mediante due SR collegati mediante a due fasi del clock realizzando un ip op Master Slave.
D L R R Q S S Q

Figura 6.28: La tabella di verit` del circuito e riportata nella tabella seguente: a ` C L D 0/1 x x 0 x 1 0 1 1 Q(t+1) S Memoria x Memoria 0 0 0 1 1 R x 0 1 0

111

Il circuito che realizza il op op LH richiesto e denito in gura 6.28. Il ` funzionamento e simile a quello di un circuito Master Slave con il segnale di ` clock applicato in modo complementato ai due stadi del circuito.

6.18 Latch D gated

Nella gura 6.29 viene mostrato un latch D di tipo gated. Assumendo che i tempi di propagazione sia delle porte NAND sia dellinverter siano pari ad 1ns, completare il diagramma temporale (avente risoluzione di 1 ns) in gura 6.30.
D Q Clock Q A

Figura 6.29:

Clock

1 0

1 0

1 0

1 0

Figura 6.30:

Soluzione 112

Clock

1 0

1 0

1 0

1 0

Figura 6.31: Il diagramma temporale richiesto e riportato in gura 6.31. `

CK r0 r1 r2 r3 Q Q Q Q

d0 d1 d2 d3 PL S

Figura 6.32:

6.19 Bidirectional shift

Uno shift register bidirezionale pu` far scorrere i bit in entrambe le direzioni (S = o 0 shift a destra) (S = 1 shift a sinistra) e ha un segnale di parallel-load PL per caricare una congurazione di ingresso r (PL = 1). Progettare un circuito per

113

realizzare uno shift register di questo tipo su 4 bit. Si ipotizzi che gli ingressi seriali siano forzati a 0. Soluzione Si vuole realizzare un circuito che memorizzi 4 bit (d0 , ..., d3) e che permetta di shiftare i dati a destra (verso il bit meno signicativo) o a sinistra. Lo schema a blocchi del circuito e riportato in gura 6.32; lipotesi di avere gli ingressi seriali ` forzati a 0 elimina tali ingressi. Le equazioni dei 4 ingressi di dei FF sono do = PL r0 + PL (S q1 + S 0) d1 = PL r1 + PL (S q2 + S q0 ) d2 = PL r2 + PL (S q3 + S q1 ) d3 = PL r3 + PL (S 0 + S q2 )

d0

q0

0 1 r1 S

0 1

d1

q1

PL

d2

q2

d3

q3

Figura 6.33: La realizzazione delle funzioni denite per di richiede delle catene di multiplexer. In gura 6.33 e evidenziato il circuito che genera d1 . Quello che genera d2 e ` ` 114

identico mentre quelli allestremit` (d0 e d3 ) non hanno il multiplexer controllato a da S ma solo una porta logica.

6.20 Up/Down counter

Progettare un up/down counter a 3 bit utilizzando ip-op di tipo D. Inserire un ingresso di controllo chiamato U /D. Se U /D = 1 il contatore viene incrementato ad ogni colpo di clock (conta up ), se U /D = 0 il contatore decrementa ad ogni colpo di clock (conta down ). Soluzione Per realizzare il circuito richiesto, occorre dapprima ricavare la tabella di verit` a relativa alle transizioni delle uscite Qi a seconda dal verso in cui si effettua la conta. Nella tabella seguente e riportata tale tabella relativa al valore da fornire ` agli ingressi Di dei ip op di stato del contatore: Q2 0 0 0 0 0 0 0 0 1 1 1 1 1 1 1 1 Q1 0 0 0 0 1 1 1 1 0 0 0 0 1 1 1 1 Q0 U /D D2 0 0 1 0 1 0 1 0 0 1 1 0 0 0 0 0 1 0 1 0 0 1 1 1 0 0 0 0 1 1 1 0 1 1 1 1 1 0 0 0 1 1 1 0 1 1 1 0 D1 1 0 0 1 0 1 1 0 1 0 0 1 0 1 1 0 D0 1 1 0 0 1 1 0 0 1 1 0 0 1 1 0 0

Le mappe di Karnaugh relative ai tre ingressi dei ip op di stato D2 , D1 , D0 sono riportate di seguito 115

D2 : 00 1 Q2 , Q1 01 11 10 1 1 1 1 1 1 1

00 01 Q0 ,U /D 11 10

D1 : 00 00 1 01 Q0 ,U /D 11 1 10 D0 : 00 00 1 01 1 Q0 ,U /D 11 10 Q2 , Q1 01 11 10 1 1 1 1 1 1 Q2 , Q1 01 11 10 1 1 1 1 1 1

La copertura delle mappe di Karnaugh permette di denire le funzioni boolenane da sintetizzare per la realizzazione del circuito. Si ricava dapprima la funzione booleana per la variabile D2 : D2 = Q2 Q1 Q0 + Q2 Q0 U /D + Q2 Q1 Q0 + + Q2 Q0 U /D + Q2 Q1 Q0 U /D + Q2 Q1 Q0 U /D D2 = Q2 (Q1 Q0 + Q1 U /D + Q1 Q0 + Q0 U /D) + + Q2 (Q1 Q0 U /D + Q1 Q0 U /D) = 116

= Q2 (Q1 + Q0 + Q0 + U /D) + Q2 (Q1 Q0 U /D + Q1 Q0 U /D) Se si utilizza la variabile dappoggio a a = Q1 Q0 U /D + Q1 Q0 U /D e a = (Q1 + Q0 + U /D) (Q1 + Q0 + U /D) = = Q1 Q0 + Q1 U /D + Q0 Q1 + Q0 U /D + Q1 U /D + Q0 U /D Si effettuano le seguenti semplicazioni: Q1 Q0 + Q0 Q1 = Q1 + Q0 Q0 U /D + Q0 U /D = Q0 + U /D Q1 U /D + Q1 U /D = Q1 + U /D (ma e sovrabbondante) ` Risulta quindi a = Q1 + Q0 + Q0 + U /D e quindi: D2 = Q2 ( Q1 + Q0 + Q0 + U /D ) + + Q2 (Q1 + Q0 + Q1 + U /D) ovvero D2 = Q2 + (Q1 + Q0 + Q1 + U /D) = = Q2 + (Q1 Q0 U /D + Q1 Q0 U /D) Il circuito che realizza D2 e riportato in gura 6.34: ` D1 e denito nel modo seguente: ` D1 = Q2 ( Q1 + Q0 + U /D ) + Q2 ( Q1 + Q0 + U /D ) = = Q1 + Q0 + U /D = = Q1 + (Q0 + U /D) 117

U/D Q1 0 Q0 Q1 1 Q0
Figura 6.34: Inne si denisce la funzione booleana per D0 D0 = Q0

Q2 D2

6.21 Derivazione tabella e diagramma degli stati

Un circuito sequenziale con due ip-op D, rispettivamente con uscite A e B, ha due ingressi, X e Y e unuscita Z ed e caratterizzato dalle seguenti equazioni: ` DA = XA + XY , DB = XB + X A, Z = XB a) Disegnare lo schema del circuito b) Derivare la tabella degli stati c) Derivare il diagramma degli stati

Soluzione Lo schema del circuito e riportato in gura 6.35, mentre il diagramma a stati ` ricavato dalle equazioni costitutive e invece rappresentato in gura 6.36 insieme ` alla tabella degli stati. Nella tabella seguente e invece riportato il diagramma ` degli stati della macchina. Dallanalisi del circuito e delle equazioni costitutive si evince che si tratta di una macchina a stati di tipo Mealy, dato che luscita Z dipende non solo dallo stato ma anche dallingresso X . 118

X A Y

D Q
CLOCK

Q
X B Z

D Q
CLOCK

Figura 6.35: Stato Presente A B 0 0 0 0 0 0 0 0 0 1 0 1 0 1 0 1 1 0 1 0 1 0 1 0 1 1 1 1 1 1 1 1 Ingressi Stato X Y A 0 0 0 0 1 0 1 0 0 1 1 1 0 0 0 0 1 0 1 0 0 1 1 1 0 0 1 0 1 1 1 0 0 1 1 1 0 0 1 0 1 1 1 0 0 1 1 1 Futuro Uscite B Z 0 0 0 0 0 0 0 0 1 0 1 0 0 1 0 1 0 0 0 0 1 0 1 0 1 0 1 0 1 1 1 1

119

Descrizione archi: XY/Z

0X/0 , X0/0 10/1 S0 11/0 10/0 11/1 10/1 S2 0X/0 0X/0 , 11/1 11/0 S3 S1 0X/0

Allocazione Stati
S0 00 S1 01 S2 10 S3 11

Figura 6.36:

6.22 Derivazione tabella e diagramma degli stati (2)

Un circuito sequenziale ha 3 ip-op D le cui uscite sono i segnali A, B e C mentre i rispettivi ingressi di dato sono DA , DB e DC . Lunico ingresso esterno, a parte il segnale di clock, e X e Il circuito e descritto dalle seguenti equazioni di ingresso: ` ` DA = (BC + BC)X + (BC + BC)X DB = A DC = B a) Si derivi la tabella degli stati per il circuito. b) Disegnare due diagrammi a stati parziali, uno relativo a tutte le transizioni nel caso in cui X=0 e laltro per X=1 (in pratica occorre denire il diagramma degli stati nellipotesi che lingresso sia sso ad uno dei due valori indicati; come si genera il diagramma degli stati complessivo? ).

120

Soluzione La tabella degli stati che realizza le equazioni proposte e: ` Stato Presente A B C 0 0 0 0 0 0 0 0 1 0 0 1 0 1 0 0 1 0 0 1 1 0 1 1 1 0 0 1 0 0 1 0 1 1 0 1 1 1 0 1 1 0 1 1 1 1 1 1 Ingressi Stato Futuro X A B C 0 1 0 0 1 0 0 0 0 0 0 0 1 1 0 0 0 0 0 1 1 1 0 1 0 1 0 1 1 0 0 1 0 1 1 0 1 0 1 0 0 0 1 0 1 1 1 0 0 0 1 1 1 1 1 1 0 1 1 1 1 0 1 1

I due diagrammi degli stati sono riportati in gura 6.37. Si noti come il diagramma degli stati completo si ottenga semplicemente combinando i due diagrammi parziali.

6.23 Derivazione tabella e diagramma degli stati (3)

Un circuito sequenziale e composto da un ip-op di tipo D con uscita S (che ` rappresenta anche lunica uscita del circuito) e ha due ingressi X e Y. Il circuito implementa la seguente rete di stato futuro: D = X Y S con D, ingresso del D-FF. Ricavare la tabella degli stati e il diagramma degli stati del circuito sequenziale.

121

X=0

000

100

110

011

001

010

111 101

X=1
001 100 010 101

011

111

000 110

Figura 6.37: Soluzione La tabella degli stati che realizza la funzione proposta e: `

Stato Presente Q 0 0 0 0 1 1 1 1

Ingressi Stato Futuro Uscita X Y D S=Q 0 0 0 0 0 1 1 0 1 0 1 0 1 1 0 0 0 0 1 1 0 1 0 1 1 0 0 1 1 1 1 1

Il diagramma degli stati e proposto in gura 6.38. ` 122

Descrizione archi: XY/S

00/0 , 11/0 01/1 , 10/1 00/1 , 11/1

01/0 , 10/0

Figura 6.38:

6.24 Diagramma a stati

Determinare il diagramma a stati di un circuito sequenziale specicato dalla tabella degli stati seguente: Stato Presente A B 0 0 0 0 0 0 0 0 0 1 0 1 0 1 0 1 1 0 1 0 1 0 1 0 1 1 1 1 1 1 1 1 Ingressi Stato X Y A 0 0 0 0 1 0 1 0 1 1 1 1 0 0 0 0 1 1 1 0 1 1 1 0 0 0 1 0 1 1 1 0 1 1 1 1 0 0 0 0 1 0 1 0 0 1 1 0 123 Futuro Uscita B Z 0 0 1 0 0 1 1 1 1 1 0 1 0 0 0 0 1 1 1 0 1 1 0 0 0 0 0 1 0 0 1 1

Soluzione

Descrizione archi: XY/Z

00/0

01/0

00/1

11/0

10/1 0x/0 , 01/1 11/1

01/1 , 10/0

11/1 2

11/0 x0/1 , 01/0

Figura 6.39: Il diagramma degli stati richiesto e riportato in gura 6.39. `

6.25 Generazione sequenza di verica

Generare una sequenza per vericare il circuito descritto dalla tabella degli stati dellesercizio precedente; per ridurre la lunghezza della sequenza di simulazione, assumiamo che il simulatore possa manipolare gli ingressi XY in modo da poter seguire tutti gli archi del diagramma a stati. La sequenza deve permettere di visitare tutti gli archi del diagramma a partire dallo stato AB = 00; a tal ne si supponga che sia disponibile un segnale esterno di Reset per poter inizializzare la macchina dallo stato 00. Soluzione Nella gura 6.40 e riportato il diagramma degli stati con il segnale di Reset per ` forzare la macchina nello stato 00. Nella gura e riportata la sequenza di archi da `

124

1
00/0

2 8
00/1 01/0

Reset

11/0

14
x0/0,01/1 11/1 10/1

4
01/1,10/0

11
3

12
11/1

15 13
2

9 5
11/0

x0/1,01/0

10

SEQUENZA: Reset, 00, 01, 00, 01, 11, x0, x0, 01,10, 01, 01, 11, 11, 11, 10

Figura 6.40: provare per vericare la macchina; ad ogni numero (1..15) sono associati i valori da fornire agli ingressi XY per forzare la transizione lungo larco voluto.

6.26 Progetto FSM e simulazione

Progettare il circuito specicato nei due esercizi precedenti e usare la sequenza dellesercizio precedente per eseguire una simulazione del circuito. Soluzione Dallanalisi della tabella degli stati si pu` ricavare il circuito denito in gura o 6.41. La sequenza di test per il circuito (ingressi e uscite) e invece riportata in ` gura 6.42.

125

X A B A B X Y A X Y A B A B Y A B X Y A B X A B Y A B X Y

A D Q Clock Q A

B D Q Clock Q B

A B X A B Y

Figura 6.41:
Clock Reset X Y A B

Figura 6.42:

6.27 Tabella e diagramma degli stati

Un circuito sequenziale ha due ip-op SR, un ingresso X e unuscita Y. Lo schema del circuito e mostrato in gura 6.43. Ricavare la Tabella degli Stati e ` il Diagramma degli stati del circuito.

126

B S B

R X CLK

Figura 6.43: Soluzione Le equazioni di stato futuro per i quattro ingressi ai ip-op (due di tipo Set e due di tipo Reset) sono: SA = B SB = X A RA = B; RB = X A Da tali equazioni si ricava la Tabella degli Stati seguente:

Stato Presente A B 0 0 0 0 0 1 0 1 1 0 1 0 1 1 1 1

Ingresso X 0 1 0 1 0 1 0 1

Stato Futuro Uscita A B Y 0 1 0 0 0 1 1 1 1 1 0 0 0 0 1 0 1 0 1 0 0 1 1 1

Il diagramma degli stati relativo al circuito e riportato in gura 6.44. `

127

Descrizione archi: X/Y 0/0 1/1 0 1/0 0/1 1/0 2 0/0 3 1/1 0/1

Figura 6.44:

6.28 Progetto FSM

Progettare un circuito sequenziale con due ip-op di tipo D le cui uscita siano A, e B, ed un ingresso X . Quando X=0, lo stato del circuito rimane immutato mentre quando X=1, il circuito compie la transizione da AB= 00 a 10 a 11 a 01, ritornando a 00, per poi ripartire con lo stesso algoritmo. Soluzione La tabella degli stati relativa al funzionamento del circuito e riportata nel ` seguito.

Stato Presente A B 0 0 0 0 0 1 0 1 1 0 1 0 1 1 1 1

Ingresso X 0 1 0 1 0 1 0 1

Stato Futuro A B 0 0 1 0 0 1 0 0 1 0 1 1 1 1 0 1

128

Se si deniscono Da e Db le variabili di stato futuro associate alle variabili di stato A e B si pu` denire la mappa di Karnaugh per le due uscite, riportata in o gura 6.45.
Da XB A
00 01 0 1 11 10

Db XB A
0 1 00 01 11 10

1 1 1

1 1

Figura 6.45: Coprendo le due mappe si ottengono le equazioni della rete di stato futuro richieste: Da = AX + BX Db = AX + BX Lo schema circuitale non e riportato ma e ricavabile facilmente. ` `
Descrizione archi: X1 X2 / Z 00/0 , 11/0 01/0 , 10/1

A
00/0 , 01/0 Reset

B
10/1 , 11/1 01/1 , 10/0

C
00/1 , 11/1 10/0 , 11/0

Figura 6.46:

6.29 Progetto FSM (2)

Per il diagramma degli stati riportato in gura 6.46: 129

a) Ricavare la tabella degli stati per il circuito. b) Eseguire lassegnazione degli stati per il circuito usando 2 bit di codica, e ricavare la tabella degli stati codicati. c) Ricavare un circuito ottimizzato usando D-FF, porte NAND e inverter.

Soluzione

Si esegue dapprima lallocazione degli stati secondo la seguente tabella: Stato A B C D Q1 ,Q2 00 01 10 11

La tabella degli stati che realizza il diagramma degli stati richiesto e riportata ` nella tabella sottostante, dove Q1 e Q2 rappresentano le variabili di stato. Stato Presente Q1 Q2 0 0 0 0 0 0 0 0 0 1 0 1 0 1 0 1 1 0 1 0 1 0 1 0 1 1 1 1 1 1 1 1 Ingressi X1 X2 0 0 0 1 1 0 1 1 0 0 0 1 1 0 1 1 0 0 0 1 1 0 1 1 0 0 0 1 1 0 1 1 Stato Futuro Uscita Q1 (t + 1) Q2 (t + 1) z 0 0 0 0 1 0 0 1 1 0 0 0 0 0 0 0 0 0 1 1 1 1 1 1 0 0 1 0 0 0 1 0 1 1 0 0 1 0 1 0 1 1 0 1 0 1 0 1

130

X1

X2
D Q

Q1 CLK
Q

D Q

Q2 CLK
Q

Figura 6.47: Il circuito richiesto, ottimizzato nelluso di sole porte NAND, inverter e ipop, e riportato nelle gure 6.47, per quanto riguarda la rete di stato presente e i ` ip op di stato, e 6.48 per quanto riguarda la rete di uscita.

6.30 Simulazione Progetto FSM (2)

Effettuare una simulazione logica di verica del progetto dellesercizio precedente. La sequenza di ingresso usata nella simulazione deve includere tutte le transizioni in gura 6.46. La simulazione deve includere lingresso X e le variabili di stato A, B, e di uscita Z.

Soluzione 131

Q1 Q2 X1 Q1 Q2 X2 Q2 X1 X2 Q1 X1 X2

Figura 6.48: La simulazione logica si presenta come in gura 6.49.

Clock Reset X Y A B

Figura 6.49:

6.31 Progetto FSM (3)

Per il diagramma a stati riportato in gura 6.50: a) Ricavare la tabella degli stati per il circuito. b) Eseguire lassegnazione degli stati per il circuito usando 3 bit di codica per i 6 stati; Si utilizzi uno dei bit di codica come bit di uscita per ottimizzare la logica, e ricavare la tabella degli stati codicata. c) Progettare il circuito ottimizzato usando D-FF, porte NAND e inverter. 132

Ingresso X, Uscita Z A 0 Reset 0 C 0 1 D 1 0 F 1 1 1 0 1 1 0 B 0

1 0 E 1 0

Figura 6.50: Soluzione

La tabella degli stati relativa al diagramma degli stati proposto e ` Stato Presente Q(t) Stato Futuro Qn+1 (t) Uscita X=0 X=1 Z A B D 0 B D C 0 C A F 0 D F C 1 E C E 1 F E F 1 La codica degli stati e riportata nella seguente tabella. Si e scelto di utilizzare la ` ` variabile Q3 come variabile di uscita (Z = Q3 ).

133

Stato Codica: Q1 ,Q2 ,Q3 A 010 B 100 C 110 D 001 E 011 F 101 H 000 G 111

Q1 X

Q1 X

D Q
CLOCK

Q1

X Q2

Q1 X Q2 X Q3 Q1 Q2 X CLOCK Q3

D Q Q

Q2

Q3 Q2

Q1 Q3 X

Q2 X1

Q3

D Q
Q1 CLOCK

Q3

X Q2

Figura 6.51:

134

Ai due stati non presenti nel diagramma degli stati (denominati H e G) sono stati assegnati i codici 000 e 111. La copertura di tali stati pu` essere fatta in molti o modi, considerando lo stato futuro relativo come una sequenza di dont care, da coprire nel modo pi` opportuno. In generale per` e sempre opportuno denire u o ` come stato futuro di uno stato non raggiungibile teoricamente nel diagramma, uno stato di reset (nellesempio lo stato A) in modo da garantirsi che in presenza di disturbi o di condizioni impreviste la macchina a stati possa sempre e comunque ritornare in uno stato permesso. Una possibile implementazione del circuito e riportata in gura 6.51. `
X Y3 X Y Y3

D Q
CLOCK

Y1

Y1

X Y3 Y2 X Y2 Y3 CLOCK X

D Q Q

Y2

Y2

D Q
CLOCK

Y3

Figura 6.52:

6.32 Ottimizzazione di FSM

Si vuole riprogettare il circuito dato in gura 6.52 al ne di ridurne il costo in termini di gate. Il circuito realizza una macchina a stati niti con tre variabili di stato (Y1 , Y2 e Y3 ), ununico ingresso X e luscita Z. a) Trovare la tabella degli stati per il circuito e sostituire gli stati codicati con lettere (A, B, C,...). Gli stati 100 e 111 non erano utilizzati nel disegno originale e quindi sono da considerarsi come stati dont care. 135

b) Ricercare la presenza di stati equivalenti e fonderli in una nuova assegnazione degli stati ottimizzata. c) Assegnare i nuovi stati in modo tale che luscita coincida con una delle variabili di stato. d) Determinare il costo del nuovo circuito e confrontarlo con quello del circuito originale, assumendo che il costo di un D-FF sia pari a 14 e che il costo delle porte elementari sia pari al numero di ingressi della porta.

Soluzione Come prima cosa da fare, in questo esercizio di reverseengineering, occorre ricavare la tabella degli stati a partire dal circuito proposto. Lindicazione del fatto che esistano solo sei stati raggiungibili permette di assegnare ad ognuno di essi una label da A a F e a estrapolare, dal circuito, la tabella delle transizioni degli stati. La codica scelta e dunque ` Stato Codica: Y1 ,Y2 ,Z A 000 B 001 C 010 D 011 E 101 F 110 Su tale base e possibile ricavare, dallanalisi delle equazioni di stato futuro, la ` tabella di transizione degli stati: Stato Presente Qn (t) Stato Futuro Qn+1 (t) Uscita X=0 X=1 Z A C E 0 B E D 1 C C E 0 D F A 1 E B D 1 F C E 0 La verica dellequivalenza degli stati porta a identicare diversi percorsi equivalenti; ad esempio gli stati A, C, F prevedono le stesse transizioni e la stessa 136

uscita: per semplicit` possono essere accorpati nellunico stato M. Analogamente a gli stati B e E sono equivalenti e possono essere accorpati con il nome dello stato N. Per completezza rinominiamo lo stato D in O. A questo punto il sistema avr` tre stati M, N e O cui possiamo associare una a codica su due bit. Uno dei due bit e la variabile duscita Z che sar` quindi 1 negli ` a stati N e O. Di conseguenza una possibile codica degli stati e ` Stato Codica (Y, Z) M 00 N 01 O 11 dove Y e una variabile di stato insieme a Z. La nuova tabella di transizione degli ` stati YZ vale Stato Presente (Yn Zn ) M N O Stato Futuro (Yn+1 Zn+1 ) X=0 M N M Uscita X=1 Z N 0 O 1 M 1

Dalla tabella si posso ricavare le equazioni di stato futuro relative agli ingressi dei due ip op DY e DZ : DY = Y ZX DZ = ZX +Y Z Per il calcolo del costo complessivo del caso in esame, si pu` semplicemente o contare il numero di ingressi alle porte del caso originario (1 porta a un ingresso, 7 porte a due ingressi e 2 a tre ingressi per un costo totale pari a 1 x 1 + 7 x 2 + 2 x 3 = 21) pi` 3 ip op con un costo pari a 14 x 3 = 42. Il costo complessivo del u circuito originario e quindi 21 + 42 = 63. ` Nel caso ottimizzato si ha un costo pari a 2 ip op (2 x 14 = 28) pi` il costo di u 3 porte a due ingressi e 1 a tre ingressi (2 x 3 + 3 x 1 = 9) per un costo complessivo pari a 9 + 28 = 37.

6.33 Start, Stop e Run

Un circuito digitale di controllo ha 3 ingressi: Start, Stop e Clock oltre a un segnale di uscita Run. I segnali Start e Stop hanno una durata indeterminata che 137

potrebbe coprire diversi colpi di clock. Quando il segnale Start va a 1, il circuito deve generare Run = 1. Il segnale Run deve rimanere alto nch` il segnale di Stop e non va a 1, dopo di che deve tornare a 0. Tutti i cambiamenti del segnale di Run devono essere sincronizzati con il fronte di salita del segnale di Clock. 1. Progettare il circuito di controllo 2. Scrivere il codice VHDL del circuito progettato

Soluzione Le due condizione da vericare per il funzionamento corretto sono: Start quando va a 1 Run va a 1 sincrono con il clock Stop quando va a 1 Run va a 0 sincrono con il clock Il diagramma degli stati che realizza il funzionamento richiesto e riportato in ` gura 6.53.
START = 1

RUN 0

RUN 1

STOP = 1

Figura 6.53: Dalla tabella degli stati, ipotizzando di associare allo stato Run la variabile di stato futuro RunFut, con la scelta di assegnare lo stato 0 al caso in cui Run = 0, si ricava la seguente tabella delle transizioni:

138

Run Start 0 0 0 1 1 0 0 1 1 1

Stop RunFut 0 0 1 0 0 1 1 0 1 0 1 0 0 1 1 0

Stop 0 Start 1

RunFut

Run

CK
Figura 6.54: Dalla tabella si passa alla mappa di Karnaugh per la generazione della variabile di stato futuro RunFut

RunFut

0 1

Start, Stop 00 01 11 10 1 1 1

La funzione booleana che copre la variabile RunFut e ` RunFut = Start Stop + Stop Run

139

Il circuito nale che realizza quanto richiesto e riportato in gura 6.54. ` Il codice VHDL e ` LIBRARY ieee; USE ieee.std_logic_1164.all; ENTITY Start_stop_run IS PORT ( Clock, Start, Stop : IN STD_LOGIC; Run : BUFFER STD_LOGIC ); END Start_stop_run; ARCHITECTURE Behavior OF Start_stop_run IS BEGIN PROCESS (Clock) BEGIN IF ClockEVENT AND Clock = 1 THEN IF Stop = 1 THEN Run <= 0; ELSE Run <= Start OR Run; END IF; END IF; END PROCESS;

6.34 Complementatore a 2 seriale

Progettare un complementatore a 2 seriale che accetti sullingresso X un numero INTEGER binario di lunghezza arbitraria partendo dal bit meno signicativo. Quando arriva un bit sullingresso X , il corrispondente bit in uscita deve apparire sulluscita Z nello stesso colpo di clock (si usi una macchina di Mealy). Per indicare che una sequenza e terminata e che il circuito deve essere inizializzato per ` ricevere unaltra sequenza, lingresso Y rimane a 1 per un ciclo di clock, altrimenti resta a 0. Determinare il diagramma degli stati del complementatore a 2 seriale Denire la tavola degli stati per il complementatore a 2 seriale

140

Soluzione
x

LSB

x y

fine

ck

Figura 6.55:

CK x y

z 1 uscita 2 3 4 Reset e uscita z non definita

Figura 6.56: Lo schema logico e a blocchi del circuito che si vuole realizzare e riportato ` in gura 6.55. Il usso di bit in ingresso viene inviato allingresso X del circuito (dapprima lLSB , ovviamente, dato che lalgoritmo di complementazione a due parte dal bit meno signicativo). Il segnale Y denisce la ne della sequenza che viene inviata secondo il diagramma temporale denito in gura 6.56. Dato che i bit di uscita devono essere disponibili nello stesso colpo di clock del loro arrivo in ingresso, si deve operare con una macchina di Mealy, il cui diagramma degli stati e rappresentato in gura 6.57 dove sugli archi sono riportate ` le condizione sugli ingressi XY e il valore delluscita Z. I due stati sono identicati dalla variabile Q. Dallanalisi del diagramma degli stati si ricava la tabella delle transizioni:

141

XY/Z
1/ Run Q=1

Reset Q=0

10/1 1/ 00/0 10/0 00/1

Figura 6.57: X 0 0 1 1 0 0 1 1 Y 0 1 0 1 0 1 0 1 Qn1 0 0 0 0 1 1 1 1 Z 0 1 1 0 Qn 0 0 1 0 1 0 1 0

La sintesi della tabella origina le seguenti funzioni booleane: Qn = X Y Q + X Y Q + X Y Q = = XY + XYQ = = Y (X + X Q) = = Y (X + Q) Z = (X + Y + Q)(X + Y + Q) = = Y +X + Q

142

6.35 NRZI
In molti sistemi di comunicazione, il segnale trasmesso sulla linea utilizza un formato non-return-to-zero (NZR). LUSB utilizza una versione specica che si rif` al non-return-to-zero inverted (NZRI). Progettare un circuito che converta a ogni sequenza di zeri e uni in una sequenza di formato NRZI. Il comportamento di tale protocollo e denito nel modo seguente: ` Se il bit del messaggio e a 0, allora il bit inviato nel formato NRZI imme` diatamente ha una transizione (cambia da 0 a 1 e viceversa); Se il bit del messaggio e a 1, allora il bit nel formato NRZI rimane ssato a ` 0 o 1 a seconda del valore del bit precedente trasmesso in formato NRZI. Questa trasformazione e illustrata dallesempio seguente in cui si suppone che ` il valore iniziale del messaggio NRZI sia 1: Messaggio: Messaggio NZRI: 10001110011010 10100001000110

1. Ricavare il diagramma degli stati del circuito utilizzando una macchina a stati di Mealy 2. Ricavare la tabella degli stati del circuito 3. Progettare il circuito utilizzando un ip-op D e altre porte logiche.

Soluzione La macchina a stati che si deve realizzare deve praticamente commutare luscita in presenza di uno zero e lasciarla inlterata in presenza di un uno in ingresso:

Commutazione

Mantiene il valore vecchio 143

Realizzare la FSM con una macchina di Mealy implica che sugli archi si denisca il valore delluscita che si deve inviare. In gura 6.58 e riportato il dia` gramma degli stati per la macchina, nellipotesi che lingresso seriale dei dati sia X e luscita codicata in formato NRZI sia Z. Ci sono due stati identicati con i simboli OU T (0) e OU T (1).
Reset X=0 / Z=1

OUT (0)

OUT (1)

X=0 / Z=0

X=1 / Z=0

X=1 / Z=1

Figura 6.58: La tabella degli stati e riportata nella tabella seguente, dove la variabile OU T ` rappresenta la variabile di stato: OU Tn 0 0 1 1 X 0 1 0 1 Z OU Tn+1 1 1 0 0 0 0 1 1

Dalla sintesi della tabella degli stati si ricava la rete di stato futuro e di uscita che origina il circuito denito in gura 6.59.

6.36 Conversione NRZI - standard

Ripetere lesercizio precedente, progettando un circuito sequenziale che trasformi un messaggio NRZI in un messaggio normale. La specica per tale circuito e la ` seguente:

144

X D CK Z

Reset
Figura 6.59: a) Se avviene una transizione da 0 a 1 o da 1 a 0 tra bit successivi nel messaggio NRZI, allora il bit del messaggio da decodicare e uno 0. ` b) Se non avviene nessuna transizione tra i bit adiacenti nel messaggio NRZI, allora il bit del messaggio da decodicare e un 1. `

Soluzione Il diagramma degli stati del circuito proposto e riportato in gura 6.60. `
X=1/Z=1 X=1/Z=0 X=0/Z=1

0
X=0/Z=0

Figura 6.60: Dal diagramma degli stati si pu` derivare la tabella di allocazione e di transio zione degli stati:

145

Stato Presente A 0 0 1 1

Ingresso X 0 1 0 1

Stato Futuro A 1 0 1 0

Uscita Z 0 1 1 0

Il circuito che realizza quanto richiesto e riportato in gura 6.61. `

X
D Q

CLK

Z
Q

Figura 6.61:

6.37 Contatore da 11 a 233

Utilizzando due contatori a 4 bit, come quello riportato in gura 6.62, realizzare un contatore che conti da 11 a 233 (decimale). Aggiungere la logica necessaria afnch` quando il segnale INIT = 1 il contatore si inizializzi al valore 11 in modo e sincrono con il clock CK.

LD CE D0 D1 D2 D3

Q0 Q1 Q2 Q
3

CO

Figura 6.62:

146

Soluzione Il contatore proposto in gura 6.62 ha due segnali di controllo per il caricamento sincrono (LD) e labilitazione alla conta (CE). Occorre contare no al numero 233 che si rappresenta su 8 bit nel modo seguente: 233 = 11101001. Il circuito da progettare deve quindi contare da 11 = 00001011 no a 233. Arrivato a ne conta si deve tornare al valore 11 che sar` quindi caricato tramite un a impulso sul segnale LD. Si deve inne prevedere un segnale esterno INIT di inizializzazione del contatore. Il circuito progettato e riportato in gura 6.63. `

CK INIT

LD CE D0 D1 D2 D3

Q1 Q2 Q3 CO

Q1 Q2 Q3

LD CE D0 D1 D2 D3

Q Q Q

0 1 2

Q Q Q Q

4 5 6 7

Q3 CO

Figura 6.63:

6.38 Generatore di sequenze per USB

Una linea di comunicazione Universal Serial Bus (USB) richiede un circuito che generi la sequenza 00000001. Progettare un circuito sequenziale sincrono che inizi a generare la sequenza quando lingresso E = 1. Una volta iniziata la generazione della sequenza, questa deve essere portata a termine. Se E rimane alto anche dopo la ne della sequenza essa deve essere ripetuta. Altrimenti, se E = 0, luscita deve rimanere ssa a 1.

147

 Denire il diagramma degli stati del circuito utilizzando una macchina a stati di Moore Determinare la tabella degli stati Progettare il circuito utilizzando un ip-op D e altre porte logiche. Includere il Reset per congurare il circuito nellappropriato stato iniziale nel quale viene controllato lingresso E per determinare se si debba generare la sequenza 00000001.

Soluzione

Il circuito deve produrre una sequenza completa di sette 0 prima di un 1 non appena il segnale di controllo E va al valore 1.
E=0 0/0 1/0 2/0 3/0 4/0 5/0 6/0 7/1

E=1

Figura 6.64: Il diagramma degli stati del circuito e riportato in gura 6.64 dove la condi` zione E=1 e quella che fa attivare la sequenza di uscita. ` Una possibile associazione degli stati con tanto di tabella delle transizioni e ` riportata nella tabella seguente: Stato Presente D2 D1 D0 000 001 010 011 100 101 110 111 Stato Futuro E=0 001 010 011 100 101 110 111 111 148 Uscita Z 0 0 0 0 0 0 0 1

E=1 001 010 011 100 101 110 111 000

E Z D0 CLOCK Q S D Q

D0

D1 D0 D1 CLOCK S Q D Q

D0 D2 D Q D1 D2 D0 D1 D2 RESET CLOCK S Q D2

Figura 6.65: Nellallocazione degli stati proposta, la condizione di stato idle (stato 7), coincidente con la verica della condizione E=1, e associata allo stato 111; in tal caso ` la condizione di reset del circuito coincide con il set dei tre ip op che sono utilizzati per la realizzazione del circuito che e riportato in gura 6.65. Si poteva ` ovviamente scegliere una qualsiasi altra allocazione degli stati; ad esempio se allo stato 7 fosse stato associato il codice 000 i tre ip op del circuito dovevano essere resettati dal segnale di RESET esterno invece che essere settati a 1.

6.39 Generatore di sequenza

Ripetere lesercizio precedente per la sequenza 01111110 che e usata in un diffe` rente protocollo di comunicazione di rete.

149

Soluzione In questo caso il diagramma degli stati e riportato in gura 6.66 e si presenta ` fondamentalmente identico a quello dellesercizio precedente. Anche in questo caso lo stato 7 e lo stato di idle da cui partire in caso di RESET esterno (non ` considerato in questa soluzione).
E=0
0/0 1/1 2/1 3/1 4/1 5/1 6/1 7/1

E=1

Figura 6.66: La tabella dellallocazione degli stati e delle transizioni e riportata nella se` guente tabella: Stato Presente D2 D1 D0 000 001 010 011 100 101 110 111 Stato Futuro E=0 001 010 011 100 101 110 111 111 Uscita Z 1 1 1 1 1 1 1 0

E=1 001 010 011 100 101 110 111 000

Il circuito risultante e riportato in gura 6.67. Si noti come la rete di stato ` futuro coincida, ovviamente, con quella dellesercizio precedente, dato che levoluzione tra i vari stati e la medesima. Differisce solo la rete di uscita. La rete che ` provoca la partenza del circuito dallo stato 7 a causa di un RESET esterno non e ` riportata ma e la stessa del circuito dellesercizio precedente. `

6.40 Generatore di sequenza - Zero Insertion

La sequenza 01111110 nel problema precedente e usata come ag in un proto` collo di comunicazione seriale per rappresentare linizio di un messaggio e deve 150

E Z D0 Clock D Q Q

D0

D1 D0 D1 Clock D Q Q Z

D0 D2 D Q D1 D2 D0 D1 D2 Clock Q D2

Figura 6.67: ovviamente essere una sequenza che non compare in nessuna altra parte della comunicazione. Come conseguenza, al massimo possono comparire non pi` di cinu que 1 in sequenza in qualunque altra sezione nel messaggio. Poich` questo non e pu` essere garantito in generale, si usa la tecnica dello Zero Insertion: ogni volta o che ci sono pi` di 5 uni di seguito da inviare, si inserisce in modo arbitrario uno 0 u nella sequenza dei bit inviati. Il messaggio da inviare entra quindi in modo seriale nellingresso X di un circuito sequenziale chiamato Zero-Insertion. Il circuito ha due uscite, Z e S. Quando un quinto uno appare in sequenza su X, uno 0 viene inserito nel usso di uscita Z, mentre laltra uscita S va a 1, indicando che non deve essere applicato nessun ingresso per un ciclo di clock (situazione di stallo). Questo e necessario perch` linserimento di zeri nella sequenza di ingresso causa ` e in uscita sequenze pi` lunghe rispetto alla sequenza di ingresso e dunque occorre u fermare per un colpo di clock la trasmissione dei bit ad ogni stallo. La tecnica della Zero-Insertion e illustrata dal seguente esempio: ` Sequenza di X: 01111100111111100001011110101 Sequenza di Z: 0111110001111101100001011110101 Sequenza di S: 0000001000000010000000000000000 151

a) Ricavare il diagramma a stati del circuito. b) Ricavare la tabella degli stati per il circuito e fare lassegnazione degli stati. c) Progettare il circuito usando D-FF e porte logiche.

Soluzione

Il diagramma a stati del circuito e riportato in gura 6.68 `

X=0/Z=0,S=0

X=1/Z=1,S=0

0
X=x/Z=0,S=1

X=0/Z=0,S=0

1
X=1/Z=1,S=0

X=0/Z=0,S=0

5
X=0/Z=0,S=0

X=1/Z=1,S=0

X=0/Z=0,S=0 X=1/Z=1,S=0

4
X=1/Z=1,S=0

Figura 6.68: Supponendo di associare ad ogni stato il codice binario relativo al numero dello stato, si ricava la seguente tabella delle transizioni. I due stati non assegnati sono il 6 (110) e il 7 (111).

152

Stato A 0 0 0 0 0 0 0 0 1 1 1 1 1 1

Presente B C 0 0 0 0 0 1 0 1 1 0 1 0 1 1 1 1 0 0 0 0 0 1 0 1 1 0 1 1

Ingresso Stato X A B 0 0 0 1 0 0 0 0 0 1 0 1 0 0 0 1 0 1 0 0 0 1 1 0 0 0 0 1 1 0 0 0 0 1 0 0 -

Futuro Uscite C Z S 0 0 0 1 1 0 0 0 0 0 0 0 0 0 0 1 1 0 0 0 0 0 1 0 0 0 0 1 1 0 0 0 1 0 0 1 -

Il circuito che realizza la macchina a stati denita in precedenza e in gura ` 6.69.

6.41 Rilevatore del primo uno in una sequenza

Progettare un rilevatore seriale di sequenza che fornisca unuscita attiva al riconoscimento del primo uno ricevuto. Sullingresso X del rilevatore seriale viene inviato un numero in binario di lunghezza arbitraria a partire dal bit pi` signicau tivo. Quando giunge un bit sullingresso X , deve apparire il corrispondente bit di sulluscita Z nello stesso ciclo di clock, rendendo quindi necessario luso di una macchina di Mealy. Finch` allingresso X giungono degli 0, luscita Z = 0. Quane do allingresso X arriva il primo 1, Z = 1. Per tutti i valori seguenti che arrivano su X , Z = 0. Per indicare che la sequenza e terminata e che il circuito pu` iniziare ` o a ricevere una nuova sequenza, lingresso Y assume il valore alto per un ciclo di clock, altrimenti Y = 0. Determinare il diagramma degli stati per il rivelatore seriale Denire la tabella degli stati Progettare il circuito utilizzando dei ip op di tipo D. Soluzione Non disponibile. 153

X D2 D1 X D0 D2 CLOCK D Q Q D0 X Z

X D0 D1 D2 X D1
D2

D Q CLOCK Q

D1

X D2 CLOCK D Q Q

D2

Figura 6.69:

6.42 Lucchetto Elettronico

Un lucchetto elettronico di una valigia ha 10 bottoni etichettati con i numeri 0,1,2,3,4,5,6,7,8,9. Ogni pulsante genera un 1 su Xi , i=0...9 rispettivamente, mentre tutti gli altri X j ,(con j diverso da i) sono uguali a 0. Questi dieci pulsanti producono un fronte positivo sul clock C che attiva i ip-op presenti nel circuito. La circuiteria che produce i segnali Xi , ed il clock C e gi` stata progettata e ` a quindi si suppone disponibile. Il lucchetto si apre in risposta alla sequenza corretta di 4 valori Xi , impostati dallutente. La logica per connettere i 4 segnali selezionati alle variabili interne XA , XB , XC e XD e gi` stata progettata e disponibile. Il ` a lucchetto viene bloccato e il circuito va in uno stato di reset non appena il pulsante LOCK, che fornisce il segnale L, diventa attivo, resettando in modo asincrono il circuito. Il lucchetto si sblocca in risposta alla sequenza corretta dei 4 valori XA , XB , XC , XD , indipendentemente da tutti gli ingressi precedenti applicati dal momento del reset. Il circuito ha una uscita U (di Moore) , che va a 1 quando viene riconosciuta 154

la sequenza corretta e si sblocca il lucchetto, mentre vale 0 quando il lucchetto e ` bloccato. Progettare il circuito sequenziale con gli ingressi XA ,XB ,XC ,XD , il reset L e il clock C utilizzando solo D-FF, porte NAND e inverter e usando la tecnica one-hot per la codica degli stati. Soluzione

Lanalisi degli stati del circuito evidenzia la necessit` di codicare 5 stati, uno a per il reset e e 4 per il riconoscimento progressivo della sequenza. Denendo A, B, C, D, E questi stati, la tabella di transizione degli stati risulta essere: Stato Presente ABCDE 10000 10000 01000 01000 00100 00100 00010 00010 00001 Ingressi XB XC x x x x 0 x 1 x x 0 x 1 x x x x x x Stato Futuro Uscita ABCDE U 10000 0 01000 0 10000 0 00100 0 10000 0 00010 0 10000 0 00001 0 00001 1

XA 0 1 x x x x x x x

XD x x x x x x 0 1 x

Tale allocazione permette di utilizzare luscita dello stato E come variabile duscita U , come richiesto dal problema. Le equazioni della rete combinatoria di stato futuro sono: DA = AX A + BX B +CX C + DD DB = AXA DC = BXB DD = CXC DE = E + DXD U =E Il segnale L e applicato negli ingressi set/reset sui ip-op per implementa` re il meccanismo di bloccaggio (Lock) facendo evolvere lo stato della macchina nella condizione ABCDE = 10000, corrispondente alla condizione sequenza non 155

riconosciuta - Lucchetto chiuso). Per tale motivo il segnale L viene inviato al Set del ip op che genera A e al Reset di tutti gli altri ip op. Il circuito nale e ` riportato in gura 6.70.
X_D D X_C C X_B B S L

D Q CLOCK Q

X_A A A

D Q
X_A

CLOCK
R B

D Q
X_B

CLOCK
R

C X_C

D Q CLOCK
R

D X_D E

D Q CLOCK Q
R

E = U

Figura 6.70:

156

6.43 Controllore di Handshake

Una coppia di segnali, Request (R) e Acknowledge (A) e usata per coordinare le ` transazioni tra una CPU e il suo sistema di I/O. Linterazione di questi segnali e ` molto spesso riferita come handshake. Questi segnali sono sincroni con il clock e, per ogni transazione, devono presentare i fronti nello stesso ordine denito in gura 6.71.
CLK R A E

Figura 6.71: Si progetti un circuito, controllore di handshake, che verichi che lordine delle azioni associate ai due segnali segua le regole del protocollo denito con lhandshake. Il controllore ha gli ingressi R e A, un reset asincrono RESET, e unuscita, Error (E). Se le transazioni nell handshake avvengono nellordine corretto, E=0. Se le transazioni avvengono fuori ordine, allora E diventa 1 e rimane attivo nch` il reset asincrono RESET=1non resetta il canale di comunicazione. e a) Ricavare il diagramma a stati del circuito di controllo. b) Ricavare la tabella di transizione degli stati per il circuito..

Soluzione

Il diagrammi degli stati richiesto e in gura 6.72 ` La tabella di verit` del circuto e rappresentata nella seguente tabella. Gli stati a ` 5, 6 e 7 non sono assegnati e quindi le righe relative sono dei dont care.

157

xx/1

x1/1 0x/1 00/0 10/0 11/0 11/0 010

100 1x/1 x0/1 01/0 01/0

000 Reset

001

011

00/0

Figura 6.72: Stato Presente B C D 0 0 0 0 0 0 0 0 0 0 0 0 0 0 1 0 0 1 0 0 1 0 0 1 0 1 0 0 1 0 0 1 0 0 1 0 0 1 1 0 1 1 0 1 1 0 1 1 1 0 0 1 0 0 1 0 0 1 0 0 Ingressi Stato R A B 0 0 0 0 1 1 1 0 0 1 1 1 0 0 1 0 1 1 1 0 0 1 1 0 0 0 1 0 1 0 1 0 1 1 1 0 0 0 0 0 1 0 1 0 1 1 1 1 0 0 1 0 1 1 1 0 1 1 1 1 Futuro Uscita C D E 0 0 0 0 0 1 0 1 0 0 0 1 0 0 1 0 0 1 0 1 0 1 0 0 0 0 1 1 1 0 0 0 1 1 0 0 0 0 0 1 1 0 0 0 1 0 0 1 0 0 1 0 0 1 0 0 1 0 0 1

158

6.44 Progetto FSM con tecnica One-Hot

Un circuito sequenziale realizzato con la tecnica degli stati codicati in binario puro ha due ip-op A e B, un ingresso X e unuscita Y. Il diagramma a stati e ` mostrato in gura 6.73. Riprogettare il circuito usando la codica one-hot per gli stati.
1 0 00/1 01/0 0

11/0 0 0

10/0

Figura 6.73:

Soluzione

La codica one-hot prevede che ogni stato sia rappresentato da una codice con tutti zeri tranne uno, relativo allo stato in questione. Dato che nel diagramma degli stati sono presenti 4 stati, sar` necessario utilizzare una codica su 4 bit con a conseguente impiego di 4 ip-op Y4, Y3, Y2, Y1. Si ricava quindi dapprima la tabella degli stati e delle transizioni partendo dalla realizzazione con due ip op A e B. Nella tabella sono riportate le transizioni in entrambe le codiche:

159

A 0 0 0 0 1 1 1 1

Stato B Y4 Y3 0 0 0 0 0 0 1 0 0 1 0 0 0 0 1 0 0 1 1 1 0 1 1 0

Presente Y2 0 0 1 1 0 0 0 0

Ingresso Y1 X A 1 0 0 1 1 0 0 0 0 0 1 1 0 0 1 0 1 1 0 0 1 0 1 0

B 1 0 1 0 1 0 1 0

Stato Y4 0 0 0 0 1 0 1 0

Futuro Y3 Y2 0 1 0 0 0 1 1 0 0 0 1 0 0 0 0 0

Uscita Y1 Z 0 1 1 1 0 0 0 0 0 0 0 0 0 0 1 0

X Y1 X Y4 CLOCK X Y1 X Y2 CLOCK D Q Q Y2 Q D Q Y1

X Y2 X Y3 CLOCK X Y3 X Y4 CLOCK D Q Q Y4 D Q Q Y3

Figura 6.74: Utilizzando la tecnica one-hot si ricavano le equazioni della rete di stato futuro (Di e lingresso di stato futuro del ip op con uscita Yi ) per limplementazione ` richiesta: 160

D1 = Y 1 = X Y 1 + X Y 4 D2 = Y 2 = X Y 1 + X Y 2 D3 = Y 3 = X Y 2 + X Y 3 D4 = Y 4 = X Y 3 + X Y 4 Il circuito nale e riportato in gura 6.74. `

6.45 Contatore ad anello a 3 bit

La tabella degli stati di un contatore ad anello a 3 bit (twisted ring counter) e la ` seguente: Stato A 0 1 1 1 0 0 Presente B C 0 0 0 0 1 0 1 1 1 1 0 1 Stato A B 1 0 1 1 1 1 0 1 0 0 0 0 Futuro C 0 0 1 1 1 0

Questo circuito non ha ingressi e le sue uscite sono le uscite non complementate dei ip-op. Poich non ha ingressi, il circuito semplicemente commuta da e stato a stato ad ogni colpo di clock evolvendo secondo la tabella degli stati. Un reset asincrono esterno permette di inizializzare il circuito allo stato 000. a) Progettare il circuito usando D-FF e assumendo per gli stati non specicati nella tabella una condizione di dont care. b) Aggiungere la logica necessaria al circuito per inizializzare il circuito nello stato 000 in corrispondenza del reset esterno.

Soluzione

Sulla base di quanto denito nel testo, occorre dapprima completare la tabella degli stati inserendo gli stati non raggiungibili teoricamente dal circuito. I due

161

stati non indicati sono gli stati 010 e 101, per i quali si ipotizza quindi di avere dei dont care come stati futuri. La tabella completa e ` Stato A 0 0 0 0 1 1 1 1 Presente C 0 1 0 1 0 1 0 1 Stato A B 1 0 0 0 x x 0 0 1 1 x x 1 1 0 1 Futuro C 0 0 x 1 0 x 1 1

B 0 0 1 1 0 0 1 1

a) Per realizzare il circuito occorrono tre ip op i cui ingressi chiameremo DA , DB e DC . Su questa base, coprendo le tre mappe di Karnough relative alle tre uscite dei ip op A, B e C si ottengono le seguenti equazioni per la rete di stato futuro: DA = C DB = A DC = B La rete di uscita non esiste in quanto le uscite coincidono con le uscite non complementate A, B e C dei ip op. b) Per forzare lo stato 000 e sufciente che i ip op abbiano il Clear (attivo ` basso) collegato al segnale di Reset esterno. Si ottiene dunque ClearA = Reset ClearB = Reset ClearC = Reset

162

6.46 FSM equivalenti

Trovare la tabella degli stati di una macchina a stati che sia equivalente al diagramma degli stati riportato in gura 6.75, riducendo la complessit` delle condizioni a di transizione il pi` possibile. Cercare di rendere luscita il pi` possibile di Moore u u (denita solo dallo stato invece che dagli archi) e discutere vantaggi e svantaggi della trasformazione. Effettuare poi unassegnazione degli stati opportuna e progettare il corrispondente circuito sequenziale utilizzando ip-op di tipo D, porte AND, porte OR, e inverter.
Descrizione archi: XY/Z 00/0,01/0 Reset 10/0,11/0 A 00/1,10/0 00/1,11/1 10/0,11/1 B 01/1,11/0 C 00/0,01/1 D 01/1,10/1

Figura 6.75:

Soluzione Lanalisi del diagramma degli stati di gura 6.26 mette in luce il fatto che alcuni archi possono essere compattati, riducendo il numero di variabili da considerare (nellesempio da due ad una). Ad esempio la transizione A B avviene tutte le volte che X=1, analogamente la transizione B C avviene solo se Y = 1. Ragionando allo stesso modo per le altre transizioni si pu` ottenere la tabella o degli stati riportata immediatamente nel seguito:

163

Stato A

Stato Codicato 00

Condizione Stato Futuro Stato futuro Codicato X X A B A C D A D C 00 01

Uscita 0

01 Y Y 00 10

10 X X 11 00

11 XY +X Y XY+XY 11 10

X Reset X A Z=0 Y B Z=X X Y C Z=Y XY+XY X D Z=1

XY+XY

Figura 6.76: Lultima colonna della tabella rappresenta luscita che ha il valore 0 nello stato A, vale 1 nello stato D, mentre nello stato B e C e legata al valore degli ingressi. ` Ne consegue che la macchina non e veramente trasformata in una macchina di ` Moore, ma si e solo ridotto in qualche modo la dipendenza di Z dagli ingressi. ` Il diagramma degli stati compattato e modicato come sopra e riportato in ` gura 6.76. Il circuito che realizza quanto indicato e invece riportato in gura ` 6.77.

6.47 FSM distributore automatico

Si vuole ricavare il diagramma degli stati di una FSM di un distributore automatico. Tale distributore vende caramelle al prezzo di 25 cent. cadauna. La macchina accetta pezzi da 5 cent (N=1) , pezzi da 10 cent (D= 1) e pezzi da 25 cent (Q=1). Quando la somma delle monete inserite e pari a 25 cent o maggiore, la macchina ` 164

Y1 X Y1 Y2 Y2 Y Y1 X Y2 X Y1 Y2 X Y1 Y X Y1 Y2 Y Y1

D Q
Clock

Q R

Y1

RESET

D Q
Clock

Y2

Q R

Y2

X Y2 Y2 Y1 Y1 Y Z

Figura 6.77: eroga una caramella imponendo DJ uguale a 1 e riportando tutto allo stato iniziale. Per tutti gli altri stati DJ=0. Se viene inserito un importo inferiore a 25 centesimi e viene premuto il pulsante CR (Coin Return), allora le monete depositate nel distributore devono essere rilasciate nellapposito slot di uscita della macchina portando RC=1 e resettando la macchina, ritornando alle condizioni iniziali. In tutti gli altri stati RC=0. Realizzare il diagramma degli stati con una macchina di Moore.

165

Soluzione
N x D x Q

Init Coin Return RC=1 N x D N CR x D x N x Q CR x D x N x Q N N x D x Q 5 cent ND N x D x Q

CR x D x N x Q 10 cent

NDQ

CR x D x N x Q CR x D x N x Q

N N x (D+Q)

15 cent

CR x D x N x Q CR x D x N x Q

N N x D

20 cent

CR x D x N x Q Dispense DJ=1

N+D+Q

Figura 6.78: Il diagramma degli stati della FSM e riportato in gura 6.78, dove il valore ` di default delle uscite e 0 a meno che non sia espressamente riportato nello stato ` (come RC=1 nello stato Coin Return e DJ=1 nello stato Dispense). 166

6.48 FSM distributore automatico (2)

Progettare un circuito sequenziale per il diagramma degli stati della macchina a stati del problema precedente. Usare la tecnica di codica one -hot per lassegnazione degli stati. La sintesi deve utilizzare solo ip op D, porte AND, porte OR ed inverter. Soluzione Stato Init Codica 1000000 Condizione N D Q NDQ Stato Futuro 5 cent 10 cent Dispense Init Init 10 cent 15 cent Dispence Coin Return 5 cent 15 cent 20 cent Dispence Coin Return 10 cent 20 cent Dispense Coin Return 15 cent Dispense Coin Return 20 cent Init Codica Uscite 0010000 0001000 0000001 1000000 RC 1000000 0001000 1000000 0000001 0100000 0010000 0000100 0000010 0000001 0100000 0001000 0000010 0000001 0100000 0000100 0000100 0000010 0001000 DJ 1000000

Coin Return 5cent 1 N D Q CR CRNDQ 0001000 N D Q CR CRNDQ 0000100 N D+Q CR CRNDQ 0000010 N+D+Q CR CRNDQ 0000001 1 0100000 0010000

10cent

15cent

20cent

Dispense

La tabella degli stati e delle transizioni soprariportata identica gli stati e la loro codica come richiesta, nonch le condizioni relative alle transizioni tra i vari e stati.

167

Nella colonna delle uscite viene riportata solo luscita che in ogni stato e attiva ` a 1. Le uscite a 0 non vengono riportate. La FSM ha 7 stati, per cui la codica one-hot necessita di 7 ip-op. Ogni uscita del ip op di stato ha assegnato come nome lo stato stesso. Su tale base e ` possibile identicare la rete di stato futuro e la rete di uscita: Rete di stato futuro - ingressi dei ip op D di stato: Init(i + 1) = Init N D Q +CoinReturn + Dispense CoinReturn(i + 1) = 5cent CR + 10cent CR + 15cent CR + 20cent CR 5cent(i + 1) = Init N + 5cent CR N D Q 10cent(i + 1) = Init D + 5cent N + 10cent CR N D Q 15cent(i + 1) = 5cent D + 10cent N + 15cent CR N D Q 20cent(i + 1) = 10cent D + 15cent N + 20cent CR N D Q Dispense(i + 1) = Q + 15cent D + 20cent D + 20cent N Rete di uscita: RC = CoinReturn DJ = Dispense

6.49 Distributore di bibite

Si ricavi il diagrammi della macchina a stati per un distributore di bevande. Tale distributore vende tutte le bevande a 1.50 a bottiglia. La macchina accetta solo banconote da 1 (D=1) e monete da 25 centesimi (Q=1). Quando la somma dei soldi e maggiore di 1.50, per esempio due banconote da 1, la macchina d` il ` a resto (due monete da 25 centesimi). Quando sono inseriti 1.5 allora un LED della macchina si illumina per indicare che la bevanda pu` essere selezionata. Le scelte o dei pulsanti sono C (Cola), L (Lemon Soda), O (Orange Soda), e R (Root Beer). Quando un pulsante e premuto, la bevanda selezionata e fornita dal distributore ` ` che viene riportato allo stato iniziale. Unaltra caratteristica del distributore e un ` LED che avverte lutente che non sono disponibili due monete (cio` due gettoni e da 25 cent) per il resto qualora venga inserita una banconota da 1. Soluzione Il diagramma degli stati richiesti e riportato in gura 6.79, dove le uscite (di ` Moore) sono riportate vicino agli stati solo quando attive (a 1). 168

No_Change No Ch

DR D LT2Q

DR

DR

DR

DR

DR

CLOR

Init
Reset

25c

50c

75c

100c

125c

150c
LED

200c
Return_2_Quartes

DR

C L O Disp_Orange R Disp_Cola Disp_Lemon Disp_Root_Beer

Figura 6.79:

6.50 Sintesi di un JK
Sintetizzare un circuito che implementi il codice scritto per lesercizio precedente usando degli strumenti CAD. Simulare tale circuito e disegnare un diagramma temporale che ne verichi il funzionamento desiderato. Soluzione Non disponibile.

6.51 Contatore a 4 bit con T ip op

Disegnare un circuito che implementi un contatore a 4 bit sincrono con caricamento parallelo utilizzando dei ip-op T. Soluzione il circuito richiesto e in gura 6.80. ` 169

Enable

0 1

Q0

D0 Q

0 1

Q1

D1 Q

0 1

Q2

D2 Q

0 1

Q3

D3 Q Output carry

Load

Clock

Figura 6.80:

6.52 Up/Down counter con ip op T

Progettare un up/down counter a 3 bit utilizzando ip-op di tipo T. Inserire un ingresso di controllo chiamato U p/Down per controllare il verso del conteggio: se U p/Down = 1 il contatore viene incrementato ad ogni colpo di clock (conta up ), se U /D = 0 il contatore decrementa ad ogni colpo di clock (conta down ). Soluzione 170

Il circuito richiesto e riportato in gura 6.81. `

Up/Down

Q Q0
0 1

Q Q1 Q
0 1

Q Q2 Q

Clock

Figura 6.81:

6.53 Up/Down counter con ip op D

Ripetere il problema precedente usando ip-op D. Soluzione Il circuito richiesto e riportato in gura 6.82. `
Up/Down

Q Q0
0 1

Q Q1 Q
0 1

Q Q2 Q

Clock

Figura 6.82:

6.54 Contatore
Il circuito in gura 6.83 sembra essere un contatore. In che sequenza conta?

171

Clock

Figura 6.83: Soluzione La sequenza di conteggio e 000, 001, 010, 111. `

6.55 Ring Oscillator

Un ring-oscillator e un circuito con un certo numero dispari n di inverter connessi ` in una struttura ad anello chiuso, come mostrato in gura 6.84. Luscita di ogni inverter e un segnale periodico con un certo periodo. `

Figura 6.84: (a) Tutti gli inverter sono identici e hanno lo stesso ritardo t p. Scrivere unequazione che esprima il periodo delluscita f in funzione di t p e n. (b) Progettare un circuito in grado di effettuare la misura sperimentale del ritardo t p usando i segnali Interval e Reset, i cui diagrammi temporali sono mostrati in gura 6.85. Lintervallo di tempo in cui Interval = 1 e pari a 100ns. Il circuito ` dovrebbe usare porte logiche e sotto-circuiti come ip-op, contatori, registri, etc.

172

RESET

INTERVAL

100 ns

Figura 6.85: Soluzione (a) Il periodo dellonda quadra prodotta dal ring oscillator vale Tcycle = 2 n t p

Reset Interval

Reset E Counter

Count
Figura 6.86: (b) Per misurare il ritardo di un inverter basta contare quanti impulsi (valore memorizzato in Count) di f ci sono in 100 ns (periodo di validit` di Interval). Cos` a ` sufciente si ricava Tcycle ; basta poi dividere tale tempo per 2 n e si ottiene t p. E quindi utilizzare un contatore come in gura 6.86. Il contatore conta il numero di impulsi in un periodo di 100 ns. Quindi si ricava il ritardo di un inverter t p nel modo seguente: tp = 100ns 2 Count n

173

6.56 Progetto di un circuito generatore di impulsi

Un circuito logico ha due ingressi, Clock e Start, e due uscite, f e g. Il suo comportamento e descritto dal diagramma temporale riportato in gura 6.87. Quando ` un impulso e inviato allingresso Start, viene prodotto un impulso sia sulluscita ` f sia su quella g, secondo il diagramma temporale mostrato in gura.

Clock

1 0

Start

1 0

1 0

1 0

Figura 6.87: Progettare il circuito logico usando solo un contatore sincrono a 3 bit positiveedge-triggered e porte logiche base (trascurando i tempi di propagazione). Soluzione Il circuito richiesto e riportato in gura 6.88. `

6.57 Calcolo delay massimo e frequenza massima

Per ogni ip-op nel contatore riportato in gura 6.89, assumere che il tempo di set-up tsu sia di 3 ns, il tempo di hold th sia pari a 1 ns e il tempo di propagazione clock-to-output tCKQ di 1 ns. Assumere che ogni porta AND, XOR e multiplexer 2-to-1 abbia un ritardo di propagazione tgate di 1 ns. Qual e la massima frequenza ` di clock alla quale il circuito pu` funzionare correttamente? o Soluzione 174

Start Clock

Reset 3 bit counter

Figura 6.88: I tempi relativi ai componenti presenti nel circuito sono riportati nella tabella seguente: tsu = 3ns th = 1ns tCKQ = 1ns tgate = 1ns Ricordiamo che il calcolo del percorso critico (critical path) richiede di calcolare tutti i percorsi che partono da ogni ip op e arrivano allingresso di tutti ip op con lo stesso segnale di temporizzazione (leggermente diverso e il caso ` in cui ci siano diversi regimi di temporizzazione ma per questi si rimanda a testi specici). Nel caso proposto occorre riconoscere quale sia il percorso pi` lungo per la u denizione della massima frequenza operativa. Analizzando a fondo il circuito in gura 6.89, si scopre che il massimo ritardo combinatorio si ottiene uscendo dal ip op che genera Qo 0, passando attraverso la successione delle prime tre porte AND in cascata e inserendosi, tramite la porta EX-OR e il multiplexer, allingresso del ip op che genera Q3 . A questo ritardo occorre sommare il ritardo clock-to-output del ip op posto allinizio del path (il tutto scatta quando sul fronte del segnale di clock luscita Q0 commuta) e ad esso bisogna aggiungere il tempo di set-up del ip op posto in fondo al path,

175

Enable D0

0 D 1 Q Q Q0

0 D D1 1 Q Q Q
1

0 D D2 1 Q Q Q
2

0 D D3 1 Q Output Carry Q Q3

Load Clock

Figura 6.89:

176

dato che si deve garantire tale tempo prima di poter sentire il prossimo fronte di sincronizzazione del clock senza avere problemi di metastabilit` . a Se ne deduce quindi che il percorso critico e: ` tCKQ0 AND + AND + AND + X OR + MPX + tsuQ3 1 + ck Q 5 5 x tgate + 3 tsu = 9ns

La massima frequenza di funzionamento e ` fMAX = 1 = 111, 1 MHz 9ns

6.58 Massima frequenza di funzionamento - contatore

Determinare la massima frequenza di funzionamento per il circuito dellesercizio precedente riportatoin gura 6.89 usando i parametri temporali seguenti: per ogni ip-op assumere che il tempo di set-up tsu sia di 0.6ns, il tempo di hold th sia pari a 1 ns e il tempo di propagazione clock-to-output tCKQ di 1 ns. Assumere che ogni porta AND, OR e XOR abbia un ritardo di propagazione tgate di 1.2ns mentre il ritardo di ogni inverter sia pari 1.1ns e non si abbia in libreria nessuna porta di tipo mutiplexer. Soluzione Non esistendo il componente multiplexer in libreria, occorre come prima cosa realizzarlo. Se si realizza come in gura 6.90, allora

w0

s
w1
Figura 6.90:

177

tmux

= tNOT + tAND + tOR = 1.1+1.2+1.2 = 3.5 ns

Per il circuito in gura 6.89 Tmin = tCKQ + 3(tAND) + tXOR + tMUX + tsu = 1.0+3*(1.2)+1.2+3.5+0.6 = 9.9 ns

Quindi FMAX = 1/9.9 = 101.01MHz

6.59 Massima frequenza di funzionamento - Bus con registri

Ripetere il problema precedente per il circuito in gura 6.91 nellipotesi che k = 4, usando i parametri temporali seguenti: per i ip-op assumere che il tempo di set-up tsu sia di 0.6ns, il tempo di hold th sia pari a 1 ns e il tempo di propagazione clock-to-output tCKQ di 1 ns. Assumere inoltre che ogni porta AND abbia tAND = 1.4ns, ogni porta OR abbia tOR = 1.5ns mentre il ritardo di ogni inverter sia pari 1.1ns
Bus

R1 in
R1

R2 in
R2

Rk in
Rk

Clock

Data
S0 S j1
Multiplexers

Figura 6.91:

Soluzione 178

Dato che in gura 6.91 ci sono 4 registri allora servono dei multiplexer 5-a-1. Se questi sono implementati con un circuito AND-OR simile a quello in gura 6.92, allora ogni porta AND ha 4 ingressi e la porta OR ne ha 5. Quindi

s0
w0

s1
w1 f w2

w3
Figura 6.92:

tMUX

= tNOT + tAND + tOR = 1.1+1.4+1.5 = 4.0 ns

Poi Tmin = tregister + tMUX = tCKQ + tsu + tMUX = 1.0+0.6+4.0 = 5.6 ns

In conclusione FMAX = 1/5.6 = 178.57MHz

179

Capitolo 7 VHDL per circuiti sequenziali

7.1 VHDL - Flip op T
Scrivere il codice VHDL che descrive un ip-op T con un ingresso di reset (clear) asincrono. Usare una descrizione comportamentale del circuito. Soluzione Il codice richiesto e riportato nel seguito. ` LIBRARY ieee ; USE ieee.std_logic_1164.all ; ENTITY T_ff IS PORT ( T, Resetn, Clock : IN STD_LOGIC ; Q : OUT STD_LOGIC ) ; END T_ff ; ARCHITECTURE Behavior OF T_ff IS SIGNAL Qint : STD_LOGIC ; BEGIN PROCESS ( Resetn, Clock ) BEGIN IF Resetn = 0 THEN Qint <= 0 ; ELSIF ClockEVENT AND Clock = 1 THEN IF T = 1 THEN 180

Qint <= NOT Qint ; ELSE Qint <= Qint ; END IF ; END IF ; END PROCESS ; Q <= Qint ; END Behavior ;

7.2 VHDL - Flip op JK

Scrivere il codice VHDL che descrive un ip-op JK. Usare una descrizione comportamentale del circuito. Soluzione Il codice richiesto e riportato nel seguito. ` LIBRARY ieee ; USE ieee.std_logic_1164.all ; ENTITY jk_ff IS PORT ( J, K, Resetn, Clock : IN STD_LOGIC ; Q : OUT STD_LOGIC ) ; END jk_ff ; ARCHITECTURE Behavior OF jk_ff IS SIGNAL Qint : STD_LOGIC ; BEGIN PROCESS ( Resetn, Clock ) BEGIN IF Resetn = 0 THEN Qint <= 0 ; ELSIF ClockEVENT AND Clock = 1 THEN Qint <= ( J AND NOT Qint ) OR ( NOT K AND Qint ) ; END IF ; 181

END PROCESS ; Q <= Qint ; END Behavior ;

7.3 Derivazione circuitale da VHDL

(a) Disegnare il circuito descritto dal seguente codice VHDL. LIBRARY ieee; USE ieee.std_logic_1164.all; ENTITY problem IS PORT ( x1, x2, s f END problem;

: IN STD_LOGIC; : OUT STD_LOGIC);

ARCHITECTURE Behavior OF problem IS BEGIN PROCESS ( x1, x2, s ) BEGIN IF s=0 THEN y1 <= x1; y2 <= x2; ELSIF s=1 THEN y1 <= x2; END IF; END PROCESS; END Behavior; (b) Come si pu` modicare questo codice per implementare un crossbar-switch? o Soluzione (a) Il circuito descritto e riportato in gura 7.1 `

182

S x1
0 1

y1

x2

y2

Clk

Figura 7.1: (b) Per implementare un crossbar-switch basta aggiungere la seguente riga di codice alla clausola ELSIF: y2 <= x1;

7.4 VHDL - Riconoscitore di sequenza

Derivare il diagramma degli stati per una FSM di Mealy che abbia un ingresso w e una uscita z. Il circuito deve generare z = 1 quando i 4 valori precedenti di w erano 1001 oppure 1111; in caso contrario la variabile duscita z = 0. Epermesso sovrapporre i campioni in ingresso. Un esempio del comportamento desiderato e: `

w: 0 1 z: 0 0

0 1 0 0

1 1 1 0 0 1

0 0 0 0

1 1 1 0

0 0 1 0 0 1

1 1 0 0

1 1 1 1

Scrivere il codice VHDL che modellizzi la macchina a stati descritta precedentemente Soluzione 183

Il diagramma a stati del riconoscitore e riportato in gura 7.2. ` w/z

1/1 1/1 0/0 A Reset 1/0 B 1... 1/0 C 11... 1/0 D 111... 0/0 0/0 0/0 E 10... 0/0 F 100...

0/0
Figura 7.2: Il codice VHDL relativo al problema proposto e: ` LIBRARY ieee; USE iee.std_logic_1164.all; ENTITY Seq_ric IS PORT ( Clock : Resetn : w : z : END Seq_ric;

IN IN IN OUT

STD_LOGIC; STD_LOGIC; STD_LOGIC; STD_LOGIC );

ARCHITECTURE Behavior OF Seq_ric IS TYPE State_type IS ( A, B, C, D, E, F ); SIGNAL y : State_type; BEGIN 184

PROCESS ( Resetn, Clock ) BEGIN IF Resetn = 0 THEN y <= A; ELSEIF ClockEVENT AND Clock = 1 THEN CASE y IS WHEN A => IF w = 0 THEN y <= A; ELSE y <= B; END IF; WHEN B => IF w = 0 THEN y <= E; ELSE y <= C; END IF; WHEN C => IF w = 0 THEN y <= E; ELSE y <= D; END IF; WHEN D => IF w = 0 THEN y <= E; ELSE y <= D; END IF; WHEN E => IF w = 0 THEN y <= F; ELSE y <= B; END IF; WHEN F => IF w = 0 THEN y <= A; ELSE y <= B; END IF; END CASE; END IF; END PROCESS; PROCESS ( y, w ) BEGIN IF ( y = D AND w = 1 ) OR ( y = F AND w = 1 ) THEN z <= 1; ELSE z <= 0; END PROCESS; END Behavior; 185

7.5 VHDL - Riconoscimento di 2 ingressi uguali per 4 colpi di clock

Un circuito sequenziale ha 2 ingressi, w1 e w2 , e unuscita z. La sua funzione e ` di comparare le sequenze in ingresso sui due ingressi. Se w1 = w2 per 4 cicli di clock consecutivi il circuito deve forzare z = 1, altrimenti z = 0. Un esempio di funzionamento e riportato di seguito: ` w1 : 0110111000110 w2 : 1110101000111 z: 0000100001110

Progettare un circuito che realizzi il riconoscitore utilizzando una macchina a stati di Mealy Scrivere il codice VHDL per la macchina a stati descritta precedentemente

Soluzione Si suggerisce di utilizzare una variabile logica dappoggio K che effettui lEXOR dei due ingressi W1 e W2 : 1 se = 0 se =

K = w1 + w2

w1 w2
Figura 7.3:

Il circuito che realizza la funzione K e riportato in gura 7.3. ` 186

Il diagramma a stati della macchina a stati e riportato in gura 7.4. ` K/Z

1/0 0/0 A 0= 1/0

1/0 0/0 B 1= C 2= 0/0 D 3= 0/1 OK 4 Bit uguali

1/0
Figura 7.4:

Il codice VHDL che descrive la macchina e: ` LIBRARY ieee; USE ieee.std_logic_1164.all; ENTITY Same_inputs IS PORT ( Clock : IN Resetn : IN w1, w2 : IN z : OUT END Same_inputs;

STD_LOGIC; STD_LOGIC; STD_LOGIC; STD_LOGIC );

ARCHITECTURE Behavior OF Same_inputs IS TYPE State_type IS ( A, B, C, D ); SIGNAL y : State_type; SIGNAL K : STD_LOGIC; BEGIN k <= w1 XOR w2; PROCESS ( Resetn, Clock ) 187

BEGIN IF Resetn = 0 THEN y <= A; ELSE ( ClockEVENT AND Clock = 1 ) THEN CASE y IS WHEN A => IF k = 0 THEN y <= B; ELSE y <= A; END IF; WHEN B => IF k = 0 THEN y <= C; ELSE y <= A; END IF; WHEN C => IF k = 0 THEN y <= D; ELSE y <= A; END IF; WHEN D => IF k = 0 THEN y<= D; ELSE y <= A; END IF; END CASE; END IF; END PROCESS; z <= 1 WHEN y = D AND k = 0 ELSE 0; END Behavior;

7.6 VHDL - Parit` su 3 bit consecutivi a

Derivare la tabella degli stati per una macchina a stati di Moore che agisca come un generatore di parit` per sequenze di 3 bit. Ogni 3 bit sullingresso w in 3 cicli a di clock successivi, la FSM genera il bit di parit` p = 1 se e solo se il numero di a uni nella sequenza di 3 bit e dispari. ` Scrivere poi il codice VHDL che descrive tale macchina a stati. Soluzione Il diagramma a stati della macchina da realizzare e in gura 7.5. `

188

1 0 0 1 0 F Fine p=1 1 C 1 dispari 0 1 0 1 1 0 E 2 dispari

A Fine p=0

B 1 pari

D 2 pari

Figura 7.5: Il diagramma delle transizioni e riportato nella tabella seguente: ` Stato Prossimo stato Uscita iniziale w = 0 w = 1 p A B C 0 B D E 0 C E D 0 D A F 0 E F A 0 F B C 1 Il codice VHDL che descrive il comportamento della macchina FSM e: ` LIBRARY ieee; USE ieee.std_logic_1164.all; ENTITY Parity_3 IS PORT ( Clock : IN

STD_LOGIC; 189

Resetn w p END Parity_3;

: IN STD_LOGIC; : IN STD_LOGIC; : OUT STD_LOGIC );

ARCHITECTURE Behavior OF Parity_3 IS TYPE State_type IS ( A, B, C, E, F, ); SIGNAL y : State_type; BEGIN PROCESS ( Resetn, Clock ); BEGIN IF Resetn = 0 THEN y <= A ELSE ( ClockEVENT AND Clock = 1 ) THEN CASE y IS WHEN A => IF w = 0 THEN y <= B; ELSE y <= C; END IF; WHEN B => IF w = 0 THEN y <= D; ELSE y <= E; END IF; WHEN C => IF w = 0 THEN y <= E; ELSE y <= D; END IF; WHEN D => IF w = 0 THEN y<= A; ELSE y <= F; END IF; WHEN E => IF w = 0 THEN y<= F; ELSE y <= A; END IF; WHEN F => IF w = 0 THEN y<= B; ELSE y <= C; END IF; END CASE; END IF; 190

END PROCESS; p <= 1 WHEN y = F ELSE 0; END Behavior;

7.7 VHDL - Shift bidirezionale

Scrivere il codice VHDL che descrive uno shift register bidirezionale a n bit. Soluzione Il codice richiesto e riportato nel seguito. ` LIBRARY ieee ; USE ieee.std_logic_1164.all ; ENTITY bid_sh IS GENERIC ( N : INTEGER := 4 ) ; PORT ( R : IN STD_LOGIC_VECTOR (0 TO N-1) ; S : IN STD_LOGIC_VECTOR (1 DOWNTO 0) ; L, Clock : IN STD_LOGIC ; Q : BUFFER STD_LOGIC_VECTOR (0 TO N-1) ) ; END bid_sh ; ARCHITECTURE Behavior OF bid_sh IS BEGIN PROCESS BEGIN WAIT UNTIL ClockEVENT AND Clock = 1 ; IF L = 1 THEN Q <= R ; ELSE CASE S IS WHEN 0 => Q <= 0 & Q(0 TO N-2) ; -- shift a destra WHEN OTHERS => Q <= Q(1 TO N-1) & 0 ; -- shift a sinistra END CASE ; END IF ; END PROCESS ;

191

END Behavior ;

7.8 VHDL - Up/Down counter a 24 bit

Scrivere il codice VHDL comportamentale che descrive un contatore up/down a 24 bit con parallelel load e reset asincrono. Soluzione Il codice VHDL richiesto e: ` LIBRARY ieee ; USE ieee.std_logic_1164.all ; USE ieee.STD_LOGIC unsigned.all ; ENTITY cntr_24 IS PORT ( R : IN STD_LOGIC_VECTOR(23 DOWNTO 0) ; Clock, Resetn, L, U : IN STD_LOGIC ; Q : BUFFER STD_LOGIC_VECTOR(23 DOWNTO 0) ) ; END cntr_24 ; ARCHITECTURE Behavior OF cntr_24 IS BEGIN PROCESS ( Clock, Resetn ) BEGIN IF Resetn = 0 THEN Q <= (OTHERS => 0) ; ELSIF ClockEVENT AND Clock = 1 THEN IF L = 1 THEN Q <= R ; ELSIF U = 1 THEN Q <= Q+1 ; ELSE Q <= Q-1 ; END IF ; END IF ; END PROCESS ; 192

END Behavior ;

7.9 VHDL - Up/Down counter a 24 bit parametrico

Modicare il codice VHDL seguente aggiungendo un parametro che setti il numero di ip op nel contatore. LIBRARY ieee; USE ieee.std_logic_1164.all; USE ieee.std_logic_unsigned.all; ENTITY upcount IS PORT ( Clock, Resetn, E : IN STD_LOGIC; Q : OUT STD_LOGIC_VECTOR(3 DOWNTO 0)); END upcount; ARCHITECTURE Behavior OF upcount IS SIGNAL Count: STD_LOGIC_VECTOR(3 DOWNTO 0); BEGIN PROCESS ( Clock, Resetn ) BEGIN IF Resetn=0 THEN Count <= "0000"; ELSIF (ClockEVENT AND Clock=1) THEN IF E=1 THEN Count <= Count+1; ELSE Count <= Count; END IF; END IF; END PROCESS; Q <= Count; END Behavior;

Soluzione Il codice VHDL richiesto e riportato nel seguito. Il parametro aggiunto e N, ` ` denito come GENERIC e di tipo INTEGER. 193

LIBRARY ieee ; USE ieee.std_logic_1164.all ; USE ieee.std_logic_unsigned.all ; ENTITY upcount_mod IS GENERIC ( N : INTEGER := 4 ) ; PORT ( Clock, Resetn, E : IN STD_LOGIC ; Q : OUT STD_LOGIC_VECTOR ( N-1 DOWNTO 0) ) ; END upcount_mod ; ARCHITECTURE Behavior OF upcount_mod IS SIGNAL Count : STD_LOGIC_VECTOR ( N-1 DOWNTO 0 ) ; BEGIN PROCESS ( Clock, Resetn ) BEGIN IF Resetn = 0 THEN Count <= (OTHERS ELSIF ClockEVENT AND Clock = IF E = 1 THEN Count <= Count ELSE Count <= Count END IF ; END IF ; END PROCESS ; Q <= Count ; END Behavior ;

=> 0) ; 1 THEN + 1 ; ;

7.10 VHDL - Contatore up a 12 bit

Scrivere il codice VHDL comportamentale che descrive un contatore up a modulo 12 con reset sincrono. Soluzione Il codice richiesto e riportato nel seguito. ` LIBRARY ieee ; 194

USE ieee.std_logic_1164.all ; ENTITY cntr_mod_12 IS PORT ( R : IN INTEGER RANGE 0 TO 11 ; Clock, Resetn, L : IN STD_LOGIC ; Q : BUFFER INTEGER RANGE 0 TO 11 ) ; END cntr_mod_12 ; ARCHITECTURE Behavior OF cntr_mod_12 IS BEGIN PROCESS ( Clock, Resetn ) BEGIN IF Resetn = 0 THEN Q <= 0 ; ELSIF ClockEVENT AND IF L = 1 THEN Q <= R ; ELSE IF Q = 11 Q <= ELSE Q <= END IF ; END IF ; END IF ; END PROCESS ; END Behavior ;

Clock = 1 THEN

THEN 0 ; Q + 1 ;

7.11 VHDL - Descrizione gerarchica

Scrivere il codice VHDL gerarchico (strutturale) che descrive il circuito in gura 7.7 usando come sotto-circuito il contatore disegnato in gura 7.6.

195

Enable D0

0 D 1 Q Q Q
0

0 D D1 1 Q Q Q1

0 D D2 1 Q Q Q2

0 D D3 1 Q Output Carry Q Q3

Load Clock

Figura 7.6: Soluzione Il codice VHDL richiesto e riportato nel seguito. ` LIBRARY ieee ; USE ieee.std_logic_1164.all ;

196

1 0 0 0 0

Enable D0 D1 D2 D3 Q Q Q Q
0

} }

BCD

Load Clock Clock

Clear 0 0 0 0

Enable D0 D1 D2 D3 Q Q Q Q
0

BCD

Load Clock

Figura 7.7: ENTITY bcd_counter IS PORT ( Clock, Clear : IN STD_LOGIC ; BCD0, BCD1 : BUFFER STD_LOGIC_VECTOR(3 DOWNTO 0) ) ; END bcd_counter ; ARCHITECTURE Structure OF bcd_counter IS COMPONENT count_4bit PORT ( D : IN STD_LOGIC_VECTOR(3 DOWNTO 0) ; Clock, Enable, Load : IN STD_LOGIC ; Q : BUFFER STD_LOGIC_VECTOR(3 DOWNTO 0) ) ; END COMPONENT ;

197

SIGNAL Load0, Load1 : STD_LOGIC ; SIGNAL Enab0, Enab1 : STD_LOGIC ; SIGNAL Zero : STD_LOGIC_VECTOR(3 DOWNTO 0) ; BEGIN Zero <= "0000 ; Enab0 <= 1 ; Enab1 <= BCD0(0) AND BCD0(3) ; Load0 <= Enab1 OR Clear ; Load1 <= (BCD1(0) AND BCD1(3)) OR Clear ; cnt0: count_4bit PORT MAP ( Clock => Clock, Load => Load0, Enable => Enab0, D => Zero, Q => BCD0 ) ; cnt1: count_4bit PORT MAP ( Clock => Clock, Load => Load1, Enable => Enab1, D => Zero, Q => BCD1 ) ; END Structure ;

7.12 VHDL - Johnson counter

Scrivere il codice VHDL che descrive un contatore Johnson a 8 bit. Sintetizzare il codice con gli strumenti CAD e fare una simulazione temporale che mostri la sequenza di conteggio. Soluzione Il codice VHDL del contatore Johnson (vedi appunti di teoria) e riportato nel ` seguito: LIBRARY ieee ; USE ieee.std_logic_1164.all ; ENTITY johnson_cntr IS PORT ( Clock, Resetn : IN STD_LOGIC ; Q : BUFFER STD_LOGIC_VECTOR(0 TO 7) ) ; END johnson_cntr ; ARCHITECTURE Behavior OF johnson_cntr IS

198

BEGIN PROCESS ( Clock, Resetn ) BEGIN IF Resetn = 0 THEN Q <= "00000000 ; ELSIF ClockEVENT AND Clock = 1 THEN Q <= (NOT Q(7)) & Q(0 TO 6) ; END IF ; END PROCESS ; END Behavior ;

7.13 VHDL - Ring Counter

Scrivere il codice VHDL comportamentale che descriva un ring-counter. Si usi uno stile di descrizione simile a quello proposto nel seguito (left-to-right shift register a n bit). Il codice deve essere parametrico, col parametro N che indica il numero di ip-op nel contatore. LIBRARY ieee; USE ieee.std_logic_1164.all; ENTITY shiftn IS GENERIC (N:INTEGER:=8); PORT ( R : IN STD_LOGIC_VECTOR(N-1 DOWNTO 0); Clock : IN STD_LOGIC; L, w : IN STD_LOGIC; Q : BUFFER STD_LOGIC_VECTOR(N-1 DOWNTO 0)); END shiftn; ARCHITECTURE Behavior OF shiftn IS BEGIN PROCESS BEGIN WAIT UNTIL ClockEVENT ADN Clock=1; IF L=1 THEN Q <= R; 199

ELSE Genbits: FOR i IN 0 TO N-2 LOOP Q(i) <= Q(i+1); END LOOP; Q(N-1) <= w; END IF; END PROCESS; END Behavior;

Soluzione Il codice proposto, parametrico sul numero di ip op (N) e descritto con lo stile indicato nel testo dellesercizio, e riportato ora: ` LIBRARY ieee ; USE ieee.std_logic_1164.all ; ENTITY ring_counter IS GENERIC ( N : INTEGER := 8 ) ; PORT ( Clock, Start : IN STD_LOGIC ; Q : BUFFER STD_LOGIC_VECTOR(0 TO N-1) ) ; END ring_counter ; ARCHITECTURE Behavior OF ring_counter IS BEGIN PROCESS ( Clock, Start ) BEGIN IF Start = 1 THEN Q <= (OTHERS => 0) ; Q(0) <= 1 ; ELSIF ClockEVENT AND Clock = 1 THEN GenBits: FOR i IN 1 TO N-1 LOOP Q(i) <= Q(i-1) ; END LOOP ; Q(0) <= Q(N-1) ; END IF ; END PROCESS ;

200

END Behavior ;

7.14 VHDL - Descrizione comportamentale

Scrivere il codice VHDL comportamentale che descrive le funzionalit` del circuia to riportato in gura 7.8.

Clock

Sum[3..0]

Data[3..0] Q[3..0]

dataa[3..0] datab[3..0]

A A+B B reset clock

result[3..0]

REG data[3..0] q[3..0]

Reset

Figura 7.8:

Soluzione Il codice richiesto e: ` LIBRARY ieee ; USE ieee.std_logic_1164.all ; USE ieee.STD_LOGIC unsigned.all ; ENTITY add_Q_Data IS PORT ( Clock, Reset : IN STD_LOGIC ; Data : IN STD_LOGIC_VECTOR(3 DOWNTO 0) ; 201

Q : BUFFER STD_LOGIC_VECTOR(3 DOWNTO 0) ) ; END add_Q_Data; ARCHITECTURE Behavior OF add_Q_Data IS BEGIN PROCESS ( Clock, Reset ) BEGIN IF Reset = 1 THEN Q <= 0000; ELSIF ClockEVENT AND Clock = 1 THEN Q <= Q + Data ; END IF ; END PROCESS ; END Behavior ;

7.15 Simulazione e sintesi CAD

Di seguito viene proposto il codice VHDL che descrive un sistema digitale che scambia il contenuto di due registri, R1 e R2, usando R3 come registro temporaneo. Usare gli strumenti CAD per creare uno schema del sistema, sintetizzarlo e farne una simulazione temporale. LIBRARY ieee; USE ieee.std_logic_1164.all; USE work.components.all; ENTITY swap IS PORT ( Data Resetn, w Clock, Extern RinExt BusWires END swap;

: : : : :

IN IN IN IN INOUT

STD_LOGIC_VECTOR(7 DOWNTO 0); STD_LOGIC; STD_LOGIC; STD_LOGIC_VECTOR(1 TO 3); STD_LOGIC_VECTOR(7 DOWNTO 0));

ARCHITECTURE Behavior OF swap IS SIGNAL Rin, Rout, Q: STD_LOGIC_VECTOR(1 TO 3); SIGNAL R1, R2, R3: STD_LOGIC_VECTOR(7 DOWNTO 0); BEGIN control: shiftr GENERIC MAP (K => 3) 202

PORT MAP (Resetn, Clock, w, Q); Rin(1) <= RinExt(1) OR Q(3); Rin(2) <= RinExt(2) OR Q(2); Rin(3) <= RinExt(3) OR Q(1); Rout(1) <= Q(2);Rout(2) <= Q(1); Rout(3) <= Q(3); tri_ext: trin PORT MAP (DATA, Extern, BusWires); reg1: regn PORT MAP (BusWires, Rin(1), Clock, R1); reg2: regn PORT MAP (BusWires, Rin(2), Clock, R2); reg3: regn PORT MAP (BusWires, Rin(3), Clock, R3); tri1: trin PORT MAP (R1, Rout(1), BusWires); tri2: trin PORT MAP (R2, Rout(2), BusWires); tri3: trin PORT MAP (R3, Rout(3), BusWires); END Behavior;

Soluzione Non disponibile.

7.16 Simulazione e sintesi CAD (2)

Ripetere il problema precedente usando il circuito di controllo mostrato in gura 7.9.
R2 ,R3 in out R1 ,R2 in out R3 ,R1 in out

Clock
Q Q Q

Reset

Figura 7.9:

203

Soluzione Non disponibile.

7.17 Simulazione e sintesi CAD (3)

Modicare il seguente codice VHDL in modo da usare il circuito di controllo del problema precedente. Sintetizzare il codice ottenuto per implementarlo in un chip e farne una simulazione temporale. LIBRARY ieee; USE ieee.std_logic_1164.all; USE work.components.all; ENTITY swapmux IS PORT ( Data Resetn, w Clock RinExt BusWires END swapmux;

: : : : :

IN STD_LOGIC_VECTOR(7 DOWNTO 0); IN STD_LOGIC; IN STD_LOGIC; IN STD_LOGIC_VECTOR(1 TO 3); BUFFER STD_LOGIC_VECTOR(7 DOWNTO 0));

ARCHITECTURE Behavior OF swapmux IS SIGNAL Rin, Q: STD_LOGIC_VECTOR(1 TO 3); SIGNAL S: STD_LOGIC_VECTOR(1 DOWNTO 0); SIGNAL R1, R2, R3: STD_LOGIC_VECTOR(7 DOWNTO 0); BEGIN control: shiftr GENERIC MAP (K => 3) PORT MAP (Resetn, Clock, w, Q); Rin(1) <= RinExt(1) OR Q(3); Rin(2) <= RinExt(2) OR Q(2); Rin(3) <= RinExt(3) OR Q(1); Rout(1) <= Q(2);Rout(2) <= Q(1); Rout(3) <= Q(3); reg1: regn PORT MAP (BusWires, Rin(1), Clock, R1); reg2: regn PORT MAP (BusWires, Rin(2), Clock, R2); reg3: regn PORT MAP (BusWires, Rin(3), Clock, R3); encoder: WITH S SELECT S <= "00" WHEN "000" 204

"10" WHEN "100" "01" WHEN "010" "11" WHEN OTHERS; muxes: --eight 4-to-1 multiplexers WITH S SELECT BusWires <= Data WHEN "00" R1 WHEN "01" R2 WHEN "10" R3 WHEN OTHERS; END Behavior;

Soluzione Non disponibile.

7.18 VHDL - Contatore BCD a 4 digit

Scrivere il codice VHDL comportamentale che descrive un contatore BCD a 4 digit. Soluzione Il code VHDL richiesto del contatore BCD a un digit e: ` LIBRARY ieee ; USE ieee.std_logic_1164.all ; USE ieee.STD_LOGIC unsigned.all ; ENTITY digit IS PORT ( Clock, Clear, E : IN STD_LOGIC ; BCD_digit : BUFFER STD_LOGIC_VECTOR(3 DOWNTO 0) ; nine : OUT STD_LOGIC ) ; END digit ; ARCHITECTURE Spec OF digit IS BEGIN

205

PROCESS (Clock) BEGIN IF ClockEVENT AND Clock = 1 THEN IF Clear = 1 THEN BCD_digit <= "0000 ; ELSIF E = 1 THEN IF BCD digit = 1001 THEN BCD_digit <= "0000 ; ELSE BCD_digit <= BCD_digit + 1 ; END IF ; END IF ; END IF ; END PROCESS ; PROCESS (BCD_digit) BEGIN IF BCD_digit = 1001 THEN nine <= 1 ; ELSE nine <= 0 ; END IF ; END PROCESS ; END Spec ;

mentre il codice del contatore a 4 digit e ` LIBRARY ieee ; USE ieee.std_logic_1164.all ; USE ieee.STD_LOGIC unsigned.all ; ENTITY 4_BCD_count IS PORT ( Clock, Clear, E : IN STD_LOGIC ; BCD3, BCD2, BCD1, BCD0 : BUFFER STD_LOGIC_VECTOR(3 DOWNTO 0)) ; END 4_BCD_count; ARCHITECTURE Behavior OF 4_BCD_count IS SIGNAL Carry : STD_LOGIC_VECTOR(4 DOWNTO 1) ;

206

COMPONENT digit PORT ( Clock, Clear, E : IN STD_LOGIC ; BCD_digit : OUT STD_LOGIC_VECTOR(3 DOWNTO 0) ; nine : OUT STD_LOGIC ) ; END COMPONENT ; BEGIN stage0: digit PORT MAP(Clock, Clear, E, BCD0, Carry(1)) ; stage1: digit PORT MAP(Clock, Clear, (Carry(1) AND E), BCD1, Carry(2)) ; stage2: digit PORT MAP(Clock, Clear, (Carry(2) AND Carry(1) AND E), BCD2, Carry(3)) ; stage3: digit PORT MAP(Clock, Clear, (Carry(3) AND Carry(2) AND Carry(1) AND E), BCD3, Carry(4)) ; END Behavior ;

207

Capitolo 8 Progettazione di sistemi digitali

8.1 Divisore per sottrazioni ripetute
Uno dei sistemi per implementare un divisione di numeri interi e di eseguire ` sottrazioni ripetute come indicato nello pseudocodice seguente: Q = 0; R = A; while (( R - B ) > 0 ) do R = R - B; Q = Q + 1; end while;

1. Denire un ASM chart che interpreti lalgoritmo denito dallo pseudocodice 2. Derivare il datapath in grado di realizzare la parte di esecuzione dellalgoritmo di divisione 3. Denire lASM chart per il controllo del circuito 4. Scrivere il codice VHDL che rappresenta il circuito del divisore 5. Discutere i pro e i contro del circuito confrontandolo con quello canonico (visto a lezione)

Soluzione

208

1. La ASM chart dellalgoritmo di divisione e riportata in gura 8.1. Si noti ` come siano deniti tre stati computazionali (S1, S2 e S3).

Reset

S1 Load A Load B Q 0

0 s 1

S3 0 s 1 S2 Done

R Q

RB Q+1

1 RB>=0?
Figura 8.1:

2. Il datapath che esegue la parte operativa dellalgoritmo e riportato in gura ` 8.2.

209

R sel

LoadB

0
E

RegB

n ER LoadA
E

RegR R n
C out

0 LQ +
C in L E

1 EQ

Counter

C out Clock

n RB Q

Figura 8.2: 3. In gura 8.3 e riportata la ASM chart del controllo del circuito che dovr` ` a essere sintetizzato con le usuali tecniche di progetto della macchina a stati. 4. Il codice VHDL che descrive tutto il circuito che esegue la divisione e ` riportato di seguito: LIBRARY ieee; USE ieee.std_logic_1164.all; USE ieee.std_logic_unsigned.all; USE work.components.all; ENTITY Divider IS GENERIC ( N : INTEGER := 8; P2N : INTEGER := 256 ); PORT ( Clock, Resetn, s : IN STD_LOGIC; LoadA, LoadB : IN STD_LOGIC; DataA, DataB : IN STD_LOGIC_VECTOR(N-1 DOWNTO 0); Q : OUT INTEGER RANGE 0 TO P2N-1; R : BUFFER STD_LOGIC_VECTOR (N-1 DOWNTO 0); 210

Reset

S1
LQ, EQ, Rsel=0

0 s 1

S3 0 s 1 S2
Rsel=1

Done

EQ ER

1
C OUT

Figura 8.3: Done : OUT STD_ LOGIC ); END Divider; ARCHITECTURE Behavior OF Divider IS TYPE State_type IS ( S1, S2, S3 ); SIGNAL y : State_type; SIGNAL Rsel, ER, ERint, LQ, EQ : STD_LOGIC; SIGNAL Rmux, RminusB, B: STD_LOGIC_VECTOR(N-1 DOWNTO 0); SIGNAL RminusBwCarry : STD_LOGIC_VECTOR(N DOWNTO 0); SIGNAL Zero : INTEGER RANGE 0 TO P2N-1; SIGNAL Cout : STD_LOGIC; BEGIN FSM_transitions: PROCESS ( Resetn, Clock )

211

BEGIN IF Resetn = 0 THEN y <= S1; ELSEIF ( ClockEVENT AND Clock = 1 ) THEN CASE y IS WHEN S1 => IF s = 0 THEN y <= S1; ELSE y <= S2; END IF; WHEN S2 => IF Cout = 1 THEN y <= S2; ELSE y <= S3; END IF; WHEN S3 => IF s = 1 THEN y <= S3; ELSE y <= S1; END IF; END CASE; END IF; END PROCESS; FSM_output: PROCESS ( y, Cout ) BEGIN EQ <= 0; LQ <= 0; ER <= 0; Rsel <= 0; Done <= 0; CASE y IS WHEN S1 => LQ <= 1; EQ <= 1; WHEN S2 => Rsel <= 1; IF Cout = 1 THEN EQ <= 1; ER <= 1; ELSE EQ <= 0; ER <= 0 END IF; WHEN S3 => Done <= 1; END CASE; ENS PROCESS; -- Data Path Definition Rmux <= DataA WHEN Rsel = 0 ELSE RminusB; ERint <= ER OR LoadA; RegR: regne GENERIC MAP ( N => N ) PORT MAP ( Rmus, Resetn, ERint, Clock, R ); 212

RegB: regne GENERIC MAP ( N => N ) PORT MAP ( DataB, Resetn, LoadB, Clock, B ); Zero <= 0; CntQ: prob10_1 GENERIC MAP ( modulus => P2N ) PORT MAP ( Resetn, Clock, EQ, LQ, Zero, Q ); RminusBwCarry <= ("0" & R) + ("0" & (NOT B)) + 1; RminusB <= RminusBwCarry ( N-1 DOWNTO 0 ); Cout <= RminusBwCarry ( N ); END Behavior;

5. Pro e contro: Questa versione dellalgoritmo di divisione e meno efciente ` nel worst case se confrontata allaltra implementazione mostrata a lezione. Infatti lalgoritmo presentato a lezione e in grado di eseguire una divisione ` in n cicli per n bit in ingresso, mentre il metodo delle sottrazioni ripetute impiega 2n cicli nel caso peggiore che si verica quando si divide per 1. Daltra parte, se i due numeri A e B sono piccoli, il metodo delle sottrazioni ripetute e unapproccio non particolarmente penalizzante rispetto ` allalgoritmo completo.

8.2 Logaritmo in base 2

Progettare un circuito che calcoli il logaritmo in base 2 (L) di un operando (K) memorizzato in un registro a n bit. Mostrare tutti i passi del progetto e illustrare ogni assunzione fatta. In particolare: 1. Denire lo pseudocodice dellalgoritmo da implementare 2. Denire la ASM chart dellalgoritmo 3. Derivare il datapath corrispondente allunit` di esecuzione che relizza lala goritmo 4. Denire lASM chart del controllo del circuito 5. Scrivere il codice VHDL che descrive il circuito che calcola il logaritmo

Soluzione

213

1. Lo pseudocodice che realizza lalgoritmo e denito nel seguito. L sia il ` logaritmo da calcolare rispetto al numero K. si assuma che K 1 L = 0; while ( K > 1 ) do K = K / 2; L = L + 1; end while; L ora e il pi` grande valore tale che 2L < K ` u
Reset

S1 Load K L 0

0 s 1

S3 0 s 1 S2 Shiftright K Done = 1

1 L L+1 K > 1?

Figura 8.4: 2. La ASM chart dello pseudocodice e riportata in gura 8.4. Dallanalisi della ` ASM chart si nota come sia necessario uno shift-register per dividere K per due e un contatore per L. 214

3. Il Datapath che esegue la parte operativa dellalgoritmo e riportato in gura ` 8.5. Come si pu` notare ci sono principalmente tre blocchi: uno shift regio ster, un contatore ed un rilevatore di maggioranza per denire se il numero K e maggiore di uno. `
LK Data
n L L

LL

0
log n
2

EK

Shiftright

EL

Counter

K
n

Clock

K > 1?

Kgt1

Figura 8.5: 4. La ASM chart del controllo del circuito e riportata in gura 8.6. ` 5. Il codice VHDL del circuito e: ` LIBRARY ieee; USE ieee.std_logic_1164.all; USE ieee.std_logic_unsigned.all; USE work.components.all; ENTITY Log_2 IS PORT ( Clock, Resetn, LK, s : IN STD_LOGIC; Data : IN STD_LOGIC_VECTOR ( 7 DOWNTO 0 ); L : BUFFER INTERGER RANGE 0 TO 7; 215

Reset

S1

LL

S3 0 s 1 S2 Done = 1

EK

EL

Kgt1

Figura 8.6: Done : OUT STD_LOGIC ); END Log_2; ARCHITECTURE Behavior OF Log_2 IS TYPE State_type IS ( S1, S2, S3 ); SIGNAL y : State_type; SIGNAL K : STD_LOGIC_VECTOR ( 7 DOWNTO 0 ); SIGNAL Kgt1, EK, LL, EL, low : STD_LOGIC; SIGNAL Zero : INTEGER RANGE 0 TO 7; BEGIN FSM_transitions: PROCESS ( Resetn, Clock ) BEGIN IF Resetn = 0 THEN 216

y <= S1; ELSEIF ( ClockEVENT AND Clock = 1 ) THEN CASE y IS WHEN S1 => IF s = 0 THEN y <= S1; ELSE y <= S2; END IF; WHEN S2 => IF Kgt1 = 1 THEN y <= S2; ELSE y <= S3; END IF; WHEN S3 => IF s = 1 THEN y <= S3; ELSE y <= S1; END IF; END CASE; END IF; END PROCESS; FSM_outputs: PROCESS ( y, Kgt1 ) BEGIN EL <= 0; LL <= 0; EK <= 0; Done <= 0; CASE y IS WHEN S1 => LL <= 1; WHEN S2 => EK <= 1; IF Kgt1 = 1 THEN EL <= 1; ELSE EL <= 0; END IF; WHEN S3 => Done <= 1; END CASE; END PROCESS; low <= 0; ShiftK: shiftrne GENERIC MAP ( N => 8 ) PORT MAP ( Data, LK, EK, low, Clock, K ); Zero <= 0; CntL: upcount GENERIC MAP ( modulus => 8 ) PORT MAP ( Resetn, Clock, EL, LL, Zero, L ); Kgt1 <= 1 WHEN K > 1 ELSE 0; 217

END Behavior;

Reset

SA

0 SB

G=0? 1 IN

AR

>0 SC 1 BR CR IN IN *2 SC 2 BR CR

IN? =0 IN 0

<0 SC 3 BR CR IN AR *2

Figura 8.7:

8.3 Scambio a 3 registri - progetto

Progettare un circuito digitale con 3 registri a 16 bit AR, BR e CR, contenenti numeri SIGNED caricabili tramite lingresso dati IN a 16 bit per eseguire le seguenti operazioni assumendo una rappresentazione in complemento a 2 e ignorando loverow: 1. Trasferire 2 numeri di tipo SIGNED a 16 bit su AR e BR in cicli di clock successivi dopo che il segnale G va a 1. 218

2. Se il numero in AR e maggiore di zero, moltiplicare il contenuto di BR per ` 2 e trasferire il risultato in CR. 3. Se il numero in AR e minore di zero, moltiplicare il contenuto di AR per 2 ` e trasferire il risultato in CR. 4. Se il numero in AR e zero, resettare il registro CR a 0. ` Scrivere il codice VHDL che implementa tale circuito. Soluzione
CK

IN 15:0 15:0 LA L I5 AR 0 14:0 14:0 SEL 1 s 15:0 NEG Zero LC RSTC CR 0 0 0 LB L BR

Figura 8.8: La ASM chart dellalgoritmo e riportata in gura 8.7. Si tratta di un algoritmo ` a 5 stati che gestisce il caricamento dei dati (SB ) e le operazioni richieste (stati SCi ). Lo stato SA rappresenta lo stato di idle. Il datapath che realizza lalgoritmo proposto e riportato in gura 8.8. ` La ASM chart del circuito di controllo che controlla e gestisce il datapath nei vari passi algoritmici e in gura 8.9. ` 219

Reset SA LA, LB, SEL, LC, RSTC 0 Ottimizzazioni SEL = NEG RSTC = Zero

G=O? SB

LA

1 (<0) S C1 LB LC SEL 1 1 1

Zero, NEG S C 2(=0) 10 LB RSTC 1 1

00 (>0) S C3 LB LC 1 1

Figura 8.9:

8.4 Scambio a 3 registri - ASM chart

Nella gura 8.10 e rappresentato un sistema con 3 registri, da R1 a R3, e nella ` gura 8.11 il circuito di controllo che pu` essere usato per scambiare i contenuti o dei registri R1 eR2. Progettare una ASM chart che rappresenti questo sistema digitale e loperazione di scambio. Soluzione La ASM chart richiesta e in gura 8.12. `

220

Data Extern Bus

Clock

R1

R2

R3

R1in

R1out

R2in

R2out

R3in

R3out

Function

Control circuit

Figura 8.10:
R2 our , R3 in R1 out , R2 in R3 out , R1 in

Clock

Reset

Figura 8.11:

8.5 Scambio a 3 registri - ASM chart (2)

(a) Per la ASM chart ottenuta nellesercizio precedente, derivare la ASM chart che specica i segnali di controllo richiesti per controllare il datapath. Assumere che i multiplexer siano usati per realizzare un bus che collega i registri, come mostrato

221

Reset

S1 Load registers

w 1

S2 R3 S3 R1 S4 R2 R3 R3 R1

Figura 8.12: nella gura 8.13. (b) Scrivere il codice VHDL completo per il sistema del problema precedente, incluso il circuito di controllo del punto (a). Soluzione (a) La ASM chart di controllo richiesta e in gura 8.14. ` (b) Il codice VHDL e riportato nel seguito: ` LIBRARY ieee ; USE ieee.std _ogic_1164.all ; USE ieee.std_logic_unsigned.all ; USE work.components.all ; 222

Bus

R1 in Clock

R1

R2

in

R2

Rk in

Rk

Data S0 S j1 Multiplexers

Figura 8.13:
Reset

S1

w 1

S2 R1 out , R3 in S3 R2 out , R1 in S4 R3 out , R3 in

Figura 8.14:

223

ENTITY 3-reg_exch IS GENERIC ( N : INTEGER := 8 ) ; PORT ( Data : IN STD_LOGIC_VECTOR(N - 1 DOWNTO 0); Resetn, w : IN STD_LOGIC ; Clock : IN STD_LOGIC ; RinExt : IN STD_LOGIC_VECTOR(1 TO 3); BusWires : BUFFER STD_LOGIC_VECTOR(N- 1 DOWNTO 0)); END 3-reg_exch ; ARCHITECTURE Behavior OF 3-reg_exch IS TYPE State_ type IS ( S1, S2, S3, S4 ) ; SIGNAL y : State_type ; SIGNAL RinCtrl, Rin, Rout : STD_LOGIC_VECTOR(1 TO 3) ; SIGNAL R1, R2, R3 : STD_LOGIC_VECTOR(N - 1 DOWNTO 0); BEGIN FSM_transitions: BEGIN IF Resetn = y <=S1; ELSIF (Clock CASE y IS WHEN S1 WHEN S2 WHEN S3 WHEN S4 END CASE ; END IF ; END PROCESS ; PROCESS ( Resetn, Clock ) 0 THEN

EVENT AND Clock = 1 ) THEN => => => => IF w = 0 y <=S3; y <=S4; y <=S1; THEN y <= S1 ; ELSE y <= S2 ; END IF ;

FSM_outputs: PROCESS ( y ) BEGIN RinCtrl <= "000"; Rout <= "000" ; CASE y IS WHEN S1 => WHEN S2 => Rout(1) <= 1 ; RinCtrl(3) <= 1 WHEN S3 => Rout(2) <= 1 ; RinCtrl(1) <= 1 224

; ;

WHEN S4 => Rout(3) <= 1 ; RinCtrl(2) <= 1 END CASE ; END PROCESS ; Reg1: regne PORT MAP Reg2: regne PORT MAP Reg3: regne PORT MAP GENERIC MAP ( BusWires, GENERIC MAP ( BusWires, GENERIC MAP ( BusWires, ( N => N) Resetn, Rin(1), Clock, R1 ); ( N => N) Resetn, Rin(2), Clock, R2 ); ( N => N) Resetn, Rin(3), Clock, R3 );

Rin <= RinCtrl OR RinExt ; -- Mux WITH Rout SELECT BusWires <= R1 WHEN "100", R2 WHEN "010", R3 WHEN "001", Data WHEN OTHERS ; END Behavior ;

8.6 Ordinamento - Sorting

Data una lista di k numeri UNSIGNED di n bit memorizzati nei registri R0 , ...Rk1, progettare un circuito in grado di ordinare la lista (il contenuto dei registri) in ordine crescente. 1. Denire lo pseudo-codice dellalgoritmo 2. Derivare lASM chart dellalgoritmo 3. Progettare il Datapath corrispondente 4. Denire lASM chart del controllo del circuito per lordinamento 5. Scrivere il codice VHDL che rappresenta il circuito

Soluzione

225

Reset
S1 Ci 0

Load registers

s 1

S2 A S3 Cj

Ri , Cj C j+1

Ci

S4 B S5 Ci C i+1 Cj C j+1

Rj

B<A? 0 S8 A Ri

S6 Rj S7 Ri

A B

C j=k1? 1

S9 Done 1 s 1 0

C i=k2?

Figura 8.15: 1. Pseudo-codice dellalgoritmo Lo pseudo-codice dellalgoritmo e il seguente: `

226

f or i = 0 to k 2 do A = Ri ; f or j = i + 1 to k 1 do B = R j; i f B < A then Ri = B; R j = A; A = Ri ; end i f ; end f or; end f or; Lalgoritmo si basa sul ritrovamento del numero pi` piccolo nella sottolista u Ri ...Rk1 e lo spostamento di tale numero in Ri per i = 1, 2, ..., k 2. A ogni iterazione del ciclo pi` esterno il numero contenuto in Ri viene posizionato u in A. A ogni iterazione del ciclo pi` interno tale numero viene confrontato u con unaltro contenuto nel registro R j . Se il numero in R j e pi` piccolo di A ` u viene scambiato il contenuto di Ri e R j e A viene cambiato per memorizzare il nuovo contenuto di Ri . 2. ASM chart Nella gura 8.15 e riportata lASM chart che rappresenta lalgoritmo di or` dinamento. Nello stato iniziale S1, mentre s = 0, i registri vengono caricati dallingresso dati esterno e viene azzerato il contatore Ci che rappresenta i nel ciclo pi` esterno. Il caricamento esterno dei registri non e riportato in u ` queste note ma ovviamente presuppone che i segnali di Load vengano gestiti insieme a tutti i segnali necessari per lordinamento. Quando il circuito passa allo stato S2, viene caricato A con il contenuto di Ri . Viene inizializzato anche C j , che rappresenta j nel ciclo pi` interno, al valore di i. Lo u stato S3 viene utilizzato per inizializzare j al valore i + 1. Nello stato S4 viene caricato il valore di R j in B. Nello stato S5 vengono confrontati A e B, e se B < A, il circuito passa allo stato S6. Gli stati S6 ed S7 scambiano i valori di Ri e R j . Lo stato S8 carica Ri in A. Sebbene questo passo sia necessario solo nel caso in cui B < A, il controllo del usso e pi` semplice ` u se questa operazione viene effettuata in entrambi i casi. Se C j non e uguale ` a k 1 e Ci non e uguale a k 2 allora il circuito rimane nel ciclo pi` esterno ` u passando nello stato S2. 3. Datapath

227

Ci sono diversi modi di implementare il datapath del circuito che rispetti i requisiti dellASM chart mostrata precedentemente. Per semplicit` suppoa niamo che lordinamento venga fatto su 4 registri (k = 4).
DataIn n 0 1 RData WrInit

Rin 0

Rin 1

Rin 2

Rin 3

R0

R1 0 1 2 3

R3

Imux

ABData

Ain

Bin

E n

Rd

Clock DataOut 1 0 Bout A < B

BltA

Figura 8.16: Una possibilit` e illustrata nelle gure 8.16 e 8.17. La gura 8.16 mostra a` come i registri R0 , ..., Rk1 possano essere connessi ai registri A e B utiliz228

zando un multiplexer 4-to-1. I registri A e B sono connessi al sottocircuito comparatore e, per mezzo dei multiplexer, sono riconnessi allingresso dei registri R0 , ..., Rk1. I registri possono essere caricati con i dati iniziali (non ordinati) utilizzando le linee DataIn. I dati vengono scritti (caricati) in ogni registro applicando il segnale di controllo W rInit e inviando lindirizzo del registro sullingresso RAdd. Il buffer tri-state e pilotato dal segnale ` di controllo Rd e viene utilizzato per fornire in uscita i contenuti dei registri sulluscita DataOut.
0 2 LI EI L E R Counter Q LJ EJ L E R Counter Q 2

Clock

Ci

Cj
2 =k2 zi zj

2 Csel 0 1 =k1

Cmux RAdd 0 Int Imux 1

w0 , w 1

y0 y1

Rin Rin Rin Rin

WrInit En Wr

y2 y3

2to4 decoder

Figura 8.17: I segnali Rin0 , ..., Rink1 sono controllati da un decoder 2-to-4. Se Int = 1 il decoder e pilotato da uno dei contatori Ci o C j . Se Int = 0 allora il decoder ` e pilotato dallingresso esterno RAdd. I segnali zi e z j sono forzati a 1 se ` Ci = k 2 e C j = k 1. Una ASM chart che mostra i segnali di controllo utilizzati nel datapath e riportata in gura 8.18. ` 229

Reset
S1 LI, Int=0 0

s 1

S2 Int=1, Csel=0, Ain, LJ S3 EJ S4 Bin, Csel=1, Int=1 S5 EI EJ BltA 0 S8 Csel=0, Int=1, Ain 1 S6 Csel=1, Int=1, Wr, Aout S7 Csel=0, Int=1, Wr, Bout

zj 0 1 0 zi 1 S9 Done s 1 0

Figura 8.18: Il codice VHDL che descrive il circuito e : ` LIBRARY ieee; USE ieee.std_logic_1164.all; USE work.components.all; ENTITY sort IS GENERIC ( N : INTEGER := 4 ); 230

PORT ( Clock, Resetn : IN STD_LOGIC; s, WrInit, Rd : IN STD_LOGIC; DataIn : IN STD_LOGIC_VECTOR ( N-1 DOWNTO 0 ); RAdd : IN INTEGER RANGE 0 TO 3; DataOut : BUFFER STD_LOGIC_VECTOR ( N-1 DOWNTO 0 ); Done : BUFFER STD_LOGIC ); END sort; ARCHITECTURE Behavior OF sort IS TYPE State_type IS ( S1, S2, S3, S4, S5, S6, S7, S8, S9 ); SIGNAL y : State_type; SIGNAL Ci, Cj : INTEGER RANGE 0 TO 3; SIGNAL Rin : STD_LOGIC_VECTOR ( 3 DOWNTO 0 ); TYPE RegArray IS ARRAY ( 3 DOWNTO 0 ) OF STD_LOGIC_VECTOR ( N-1 DOWNTO 0 ); SIGNAL R : RegArray; SIGNAL RData, ABMux : STD_LOGIC_VECTOR ( N-1 DOWNTO 0 ); SIGNAL Int, Csel, Wr, BltA : STD_LOGIC; SIGNAL Ain, Bin, Aout, Bout : STD_LOGIC; SIGNAL LI, LJ, EI, EJ, zi, zj : STD_LOGIC; SIGNAL Zero: INTEGER RANGE 3 DOWNTO 0; -- dato parallelo per Ci=0 SIGNAL A, B, ABData : STD_LOGIC_VECTOR ( N-1 DOWNTO 0 ); BEGIN FSM_transitions: PROCESS (Resetn, Clock ) BEGIN IF Resetn = 0 THEN y <= S1; ELSEIF ( ClockEVENT AND Clock = 1 ) THEN CASE y IS WHEN S1 => IF s = 0THEN y <= S1; ELSE y <= S2; END IF; WHEN S2 => y <= S3; WHEN S3 => y <= S4; WHEN S4 => y <= S5; WHEN S5 => IF BltA = 1THEN y <= S6; ELSE y <= S8; END IF; 231

WHEN S6 => y <= S7; WHEN S7 => y <= S8; WHEN S8 => IF zj = 0 THEN y <= S4; ELSEIF zi = 0 THEN y <= S2; ELSE y <= S9; END IF; WHEN S9 => IF s = 1 THEN y <= S9; ELSE y <= S1; END IF; END CASE; END IF; END PROCESS; -- definizione degli output generati dalla FSM Int <= 0 WHEN y = S1 ELSE 1; Done <= 1 WHEN s = S9 ELSE 0; FSM_output: PROCESS ( y, zi, zj ) BEGIN LI <= 0; LJ <= 0; EI <= 0; EJ <= 0; Csel <= 0; Wr <= 0; Ain <= 0; Bin <= 0; Aout <= 0; Bout <= 0; CASE y IS WHEN S1 => LI <= 1; WHEN S2 => Ain <= 1; LJ <= 1; WHEN S3 => EJ <= 1; Csel <= 1; WHEN S4 => Bin <= 1; Csel <= 1; WHEN S5 => -- nessun output assegnato in questo stato WHEN S6 => Csel <= 1; Wr <= 1; Aout <= 1; WHEN S7 => Wr <= 1; Bout <= 1; WHEN S8 => Ain <= 1; IF zj = 0 THEN EJ <= 1; ELSE EJ <= 0; IF zi = 0 THEN EI <= 1; ELSE EI <= 0; END IF; 232

END IF; WHEN S9 => -- a Done \e assegnato il valore 1 -- dallistruzione condizionale -- fuori del processo END CASE; END PROCESS; -- definizione del datapath Zero <= 0; GenReg: FOR i IN 0 TO 3 GENERATE Reg: regne GENERIC MAP ( RData,Resetn,Rin(i),Clock,R(i) ); PORT MAP ( Rdata,Resetn,Rin(i),Clock,R(i) ); END GENERATE; RegA: regne GENERIC MAP ( N => N ) PORT MAP ( RData,Resetm,Ain,Clock,A ); RegB: regne GENERIC MAP ( N => N ) PORT MAP ( ABData,Resetn,Bin,Clock,B ); BltA <= 1 WHEN B < A ELSE 0; ABMux <= A WHEN Bout = 0 ELSE B; RData <= ABMux WHEN WrInit = 0 ELSE DataIn; OuterLoop: upcount GENERIC MAP ( modulus => 4 ) PORT MAP ( Resetn,Clock,EJ,LJ,Ci,Cj ); CMux <= Ci WHEN Csel = 0 ELSE Cj; IMux <= CMux WHEN Int = 1 ELSE RAdd; WITH IMux Select ABData <= R(0) WHEN 0, R(1) WHEN 1, R(2) WHEN 2, R(3) WHEN OTHERS; RicDec: PROCESS ( WrInit, Wr, IMux ) BEGIN IF ( WrInit OR Wr) = 1 THEN CASE IMux IS WHEN 0 => Rin <= "0001"; WHEN 1 => Rin <= "0010"; WHEN 2 => Rin <= "0100"; WHEN OTHERS => Rin <= "1000"; END CASE; ELSE Rin <= "0000"; END IF; END PROCESS; 233

zi <= 1 WHEN Ci = 2 ELSE 0; zj <= 1 WHEN Cj = 3 ELSE 0; DataOut <= ( OTHERS => z ) WHEN Rd = 0 ELSE ABData; END Behavior;

R0

R1

Rn1

0 0 0 D 1 Q 1 1 Q Q D Q

0 0 1 1 Q D Q

W Clk

Q0

Q1

Qn1

Figura 8.19:

8.7 Shift register

Nella gura 8.19 e rappresentato il circuito di uno shift register in cui lingresso di ` controllo del caricamento parallelo e indipendente dallingresso di enable. Dise` gnare un circuito alternativo di uno shift register che pu` compiere loperazione di o caricamento parallelo solo se lingresso di enable e contemporaneamente attivo. `
R0 L E

0 0

1
1

Clk

Q0

Figura 8.20:

234

Soluzione Nello shift register modicato lordine dei multiplexer che compiono le azioni di caricamento ed enable sono scambiate rispetto alla Figura 8.19. Il primo bit del circuito e mostrato nella gura 8.20. `

8.8 Counter
La ASM chart in gura 8.21, che descrive un circuito contatore, include uscite di tipo Moore negli stati S1, S2, ed S3, ed ha unuscita di tipo Mealy nello stato S2.
Reset

S1
Load A

0 0 1

s
1
S2 Shift A

s
S4

Done

S3

1
B B+1 A = 0?

0 0 a

Figura 8.21: (a) Illustrare come la ASM chart possa essere modicata in modo da avere nello stato S2 solo uscite di tipo Moore. 235

 (b) Disegnare la ASM chart per il circuito di controllo corrispondente alla parte (a). (c) Scrivere il codice VHDL che rappresenta il circuito di controllo modicato.

Soluzione (a) Una ASM chart che ha solo uscite di tipo Moore allo stato S2 e mostrata ` in gura 8.22.
Reset

S1
Load A

0 0 1

s
1
S2 Shift A

s
S4

Done

S3
Shift A B B+1

1
A = 0?

0 0 a0
1

Figura 8.22: (b) La ASM chart del circuito di controllo e in gura 8.23. ` (c) Il codice VHDL del circuito di controllo segue: 236

Reset

S1
LB

0 0 1

s
1
S2 EA

s
S4

Done = 1

S3

1
EA, EB z

0 0 a

Figura 8.23: LIBRARY ieee ; USE ieee.std_logic_1164.all ; USE work.components.shiftrne ; ENTITY cntr_cnt IS PORT ( Clock, Resetn : IN STD_LOGIC ; LA, s : IN STD_LOGIC ; Data : IN STD_LOGIC_VECTOR(7 DOWNTO 0) ; B : BUFFER INTEGER RANGE 0 to 8 ; Done : OUT STD_LOGIC ) ; END cntr_cnt; ARCHITECTURE Behavior OF cntr_cnt IS TYPE STATE_TYPE IS ( S1, S2, S3, S4 ) ; 237

SIGNAL y : STATE_TYPE ; SIGNAL A : STD_LOGIC_VECTOR(7 DOWNTO 0) ; SIGNAL z, EA, LB, EB, low : STD_LOGIC ; BEGIN FSM_transitions: PROCESS ( Resetn, Clock ) BEGIN IF Resetn = 0 THEN y <=S1; ELSIF (ClockEVENT AND Clock=1) THEN CASE y IS WHEN S1 => IF s = 0 THEN y <= S1 ; ELSE y <= S2 ; END IF ; WHEN S2 | S3 => IF z = 0 THEN IF A(0) = 0 THEN y <=S2; ELSE y <=S3; END IF ; ELSE y <=S4; END IF ; WHEN S4 => IF s = 1 THEN y <= S4 ; ELSE y <= S1 ; END IF ; END CASE ; END IF ; END PROCESS ; FSM_outputs: PROCESS ( y ) BEGIN EA <= 0 ; LB <= 0 ; EB <= 0 CASE y IS WHEN S1 => LB <= 1 ; WHEN S2 => EA <= 1 ; WHEN S3 => EA <= 1 ; EB <= 1 ; WHEN S4 => Done <= 1 ; END CASE ; 238

; Done <= 0 ;

END PROCESS ; -- Il datapath e descritto di seguito: PROCESS ( Resetn, Clock ) BEGIN IF Resetn = 0 THEN B <=0; ELSIF (Clock EVENT AND Clock = 1 ) THEN IF EB = 1 THEN IF LB = 1 THEN B <=0; ELSE B <=B+1; END IF ; END IF ; END IF ; END PROCESS ; low <= 0 ;

ShiftA: shiftrne GENERIC MAP ( N => 8 ) PORT MAP ( Data, LA, EA, low, Clock, A ) ; z <= 1 WHEN A = "00000000" ELSE 0 ;

END Behavior ;

8.9 Moltiplicatore somma/shift

La gura 8.24 mostra il datapath per un moltiplicatore Add/Shift. Il circuito usa uno shift register per B cos` che il bit meno signicativo b0 possa essere usato per decidere se A debba o no essere addizionato al registro che mantiene il prodotto parziale P. Un approccio differente pu` essere lutilizzo di un normale registro per o mantenere B e di un contatore e un multiplexer per selezionare i bit bi in ogni fase delloperazione di moltiplicazione. (a) Illustrare la ASM chart che usa un normale registro per B, invece di uno shift register. 239

LA

Data A

LB

Data B

Shiftleft
EA E

Shiftright
EB E

register

register

B Clock 2n n

Sum 0 2n Psel 1 0 2n DataP EP E 2n z b0

Register

2n

Figura 8.24: (b) Illustrare il datapath corrispondente. (c) Disegnare la ASM chart per il circuito di controllo corrispondente al punto precedente. (d) Scrivere il codice VHDL che rappresenta il circuito moltiplicatore.

240

Soluzione (a) La ASM chart richiesta e in gura 8.25. `

Reset

S1

Load A Load B

0 , C

0 0 1

s
1
S2 Shift left A, C C+1

s
S3

Done

1
P P+A C=n1

0 0 b

Figura 8.25: (b) Il datapath corrispondente e riportato in gura 8.26. ` (c) La ASM chart per il circuito di controllo e mostrata in gura 8.27. Si ` assuma che il segnale EB sia pilotato da una logica esterna. (d) Il codice VHDL del circuito e riportato nel seguito ` LIBRARY ieee ; USE ieee.std_logic_1164.all ; USE ieee.std_logic_unsigned.all ; USE work.components.all ; ENTITY add_sh IS 241

LA

Data A Data B n n LC 0

L LB EA E E

Shiftleft

Register

EC

Counter

C Clock 2n

log n 2

Sum 0 2n Psel 1 0 b 2n DataP EP E z C 2n nto1

Register

2n

Figura 8.26: GENERIC ( N : INTEGER := 8 ; NN : INTEGER := 16 ) ; PORT ( Clock : IN STD_LOGIC ; Resetn : IN STD_LOGIC ; LA, LB, s : IN STD_LOGIC ; DataA : IN STD_LOGIC_VECTOR(N - 1 DOWNTO 0); DataB : IN STD_LOGIC_VECTOR(N - 1 DOWNTO 0); P : BUFFER STD_LOGIC_VECTOR(NN - 1 DOWNTO 0); Done : OUT STD_LOGIC ) ; END add_sh ; ARCHITECTURE Behavior OF add_sh IS 242

Reset

S1
Psel = 0, EP, LC

0 s 1
0

1 s

S2

S3

Psel = 1, EA, EC

Done

EP

1 z 0

0 b C 1

Figura 8.27:

TYPE State_type IS ( S1, S2, S3 ) ; SIGNAL y : State_type ; SIGNAL Psel, EA, EP, Zero : STD_LOGIC ; SIGNAL B, N Zeros : STD_LOGIC_VECTOR(N - 1 DOWNTO 0) ; SIGNAL A, Ain, DataP, Sum : STD_LOGIC_VECTOR(NN - 1 DOWNTO 0); SIGNAL ZeroI, C : INTEGER RANGE 0 TO N - 1; SIGNAL EC, LC, Bc, z : STD_LOGIC ;

243

BEGIN FSM_transitions: PROCESS ( BEGIN IF Resetn = 0 THEN y <=S1; ELSIF (Clock EVENT AND THEN CASE y IS WHEN S1 => IF s = 0 THEN WHEN S2 => IF z = 0 WHEN S3 => IF s = 1 END CASE ; END IF ; END PROCESS ; Resetn, Clock )

Clock= 1 )

y <= S1 ; ELSE y <= S2 ; END IF ; THEN y <= S2 ; ELSE y <= S3 ; END IF ; THEN y <= S3 ; ELSE y <= S1 ; END IF ;

FSM_outputs: PROCESS ( y, Bc ) BEGIN EP <= 0 ; EA <= 0 ; Done <= 0 ; Psel <= 0 ; EC <= 0 ; LC <= 0 ; CASE y IS WHEN S1 => EP <= 1 ; EC <= 1 ; LC <= 1 ; WHEN S2 => Psel <= 1 ; EA <= 1 ; EC <= 1 ;LC<= 0 ; IF Bc = 1 THEN EP <= 1 ; ELSE EP <= 0 ; END IF ; WHEN S3 => Done <= 1 ; END CASE ; END PROCESS ; -- datapath

Zero <= N Zeros Ain <=N ShiftA: PORT

0 ; <= (OTHERS => 0 ); Zeros & DataA ; shiftlne GENERIC MAP ( N => NN ) MAP ( Ain, LA, EA, Zero, Clock, A ) ; 244

0 n Rsel 1 0 LA DataA n EB DataB n

LR ER

L E Leftshift register n w EA

L E Leftshift register n

Register
n

an1
A

EQ

Leftshift register n

cout

cin n

Clock

Figura 8.28: RegB: regne GENERIC MAP ( N => N) PORT MAP ( DataB, Resetn, LB, Clock, B ) ; Sum <=A+P; DataP <= Sum WHEN Psel= 1 ELSE (OTHERS => 0 ) ; RegP: regne GENERIC MAP ( N => NN ) PORT MAP ( DataP, Resetn, EP, Clock, P ) ; ZeroI <=0; -- Multiplexer per selezionare il bit C da B Bc <= B(C) ; upcounter: prob10 1 GENERIC MAP ( modulus => N) PORT MAP ( Resetn, Clock, EC, LC, ZeroI, C ) ; -- controlla se tutti gli n bit di B sono stati utilizzati z <= 1 WHEN (C = (N - 1)) ELSE 0 ; END Behavior ;

245

Figura 8.29:

8.10 Divisore - Codice VHDL

Scrivere il codice VHDL per il circuito divisore che ha il datapath riportato in gura 8.28 e il circuito di controllo rappresentato dalla ASM chart in gura 8.29.

246

Soluzione Il codice VHDL richiesto e riportato nel seguito: ` LIBRARY ieee ; USE ieee.std_logic _1164.all ; USE ieee.std_logic_unsigned.all ; USE work.components.all ; ENTITY Divisione IS GENERIC ( N : INTEGER := 8 ) ; PORT ( Clock, Resetn : IN STD_LOGIC ; DataA, DataB : IN STD_LOGIC_VECTOR(N - 1 DOWNTO 0); LA, EB, s : IN STD_LOGIC ; Q, R : OUT STD_LOGIC_VECTOR(N - 1 DOWNTO 0); Done : OUT STD_LOGIC ) ; END Divisione; ARCHITECTURE Behavior OF Divisione IS TYPE State_type IS (S1, S2, S3, S4 ) ; SIGNAL y : Stat_ type ; SIGNAL EC, LC, ER, LR, EA, EQ, LQ, Rsel, low, Cout, z: STD_LOGIC ; SIGNAL RminusB, AR, Rmux : STD_LOGIC_VECTOR(N - 1 DOWNTO 0); SIGNAL BR, RR, QR, Zero : STD_LOGIC_VECTOR(N - 1 DOWNTO 0); SIGNAL RminusBwCarry : STD_LOGIC_VECTOR(N DOWNTO 0) ; SIGNAL CR : INTEGER RANGE 0 TO N - 1; BEGIN FSM_transitions: PROCESS ( Resetn, Clock ) BEGIN IF Resetn = 0 THEN y <=S1; ELSIF (Clock EVENT AND Clock= 1 ) THEN CASE y IS WHEN S1 => IF s = 0 THEN y <= S1 ; ELSE y <= S2 ; END IF ; WHEN S2 => y <=S3; WHEN S3 => 247

IF z = 1 WHEN S4 => IF s = 1 END CASE ; END IF ; END PROCESS ;

THEN y <= S4 ; ELSE y <= S2 ; END IF ; THEN y <= S4 ; ELSE y <= S1 ; END IF ;

FSM_outputs: PROCESS ( y, s, Cout, z ) BEGIN Rsel <= 0 ; LR <= 0 ; ER <= 0 ; LC <= 0 ; EC <= 0 ; EA <= 0 ; EQ <= 0 ;Done <= 0 ; CASE y IS WHEN S1 => LR <= 1 ; LC <= 1 ; Rsel <= 0 ; WHEN S2 => ER <= 1 ; EA <= 1 ; WHEN S3 => EQ <= 1 ; Rsel <= 1 ; EC <= 1 ; IF Cout = 1 THEN LR <= 1 ; ELSE LR <= 0 ; END IF ; IF z = 0 THEN EC <= 1 ; ELSE EC <= 0 ; END IF ; WHEN S4 => Done <= 1 ; END CASE ; END PROCESS ; SHLR: shiftlne GENERIC MAP ( N => N) PORT MAP ( Rmux, LR, ER, AR(N - 1), Clock, RR ) ; low <= 0 ; SHLA: shiftlne GENERIC MAP ( N => N) PORT MAP ( DataA, LA, EA, low, Clock, AR ) ; LQ <= 0 ; Zero <= (OTHERS => 0 ) ; SHLQ: shiftlne GENERIC MAP ( N => N) PORT MAP ( Zero, LQ, EQ, Cout, Clock, QR ) ; REGB: regne GENERIC MAP ( N => N) PORT MAP ( DataB, Resetn, EB, Clock, BR ) ; RminusBwCarry <= ("0" & RR) + ("0" & (NOT BR)) +1 ; RminusB <= RminusBwCarry(N - 1 DOWNTO 0); Cout <= RminusBwCarry(N) ; Rmux <= RminusB WHEN Rsel= 1 ELSE Zero ;

248

Reset

S1 Lc, Ssel = 0, ES

s 1

S2 EC Ssel = 1, ES

0 z 1 S3
LA, EB

0 s 1

S4 Div

S5 Div, Done

zz

Figura 8.30: CNT C: PROCESS (Clock) BEGIN IF Clock EVENT AND Clock= 1 IF EC= 1 THEN 249

THEN

IF LC= 1 THEN CR<=N - 1 ; ELSE CR <=CR - 1 ; END IF ; END IF ; END IF; END PROCESS ; z <= 1 WHEN CR=0 ELSE 0 ; R <=RR; Q <=QR; END Behavior ;

8.11 ASM chart equivalente

Nella ASM chart in gura 8.30, i due stati S3 e S4 sono usati per elaborare il risultato M = Sum/k. Denire una ASM chart che combini gli stati S3 e S4 in un unico stato, chiamato S3. Soluzione Lo stato S3 si occupa di caricare gli operandi nel divisore, mentre S4 avvia loperazione di divisione. Questi stati possono essere fusi in un unico stato. Possiamo usare il ag z per segnalare la prima volta che entriamo nel nuovo stato equivalente. Quando z = 1 viene prodotto unuscita di Mealy che carica gli operandi e decrementa il contatore. Poi, il ag z va a 0. Il nuovo stato ora produce unuscita Mealy che comincia la divisione a patto che z = 0. La ASM chart di controllo del circuito e mostrata in gura 8.31. `

8.12 ASM chart equivalente - Codice VHDL

Scrivere il codice VHDL per la macchina stati complessa rappresentata dalla ASM chart denita nel problema precedente. Soluzione Il codice VHDL e: ` LIBRARY ieee ; USE ieee.std_logic_1164.all ;

250

Reset

S1 Lc, Ssel = 0, ES

s 1

S2 EC Ssel = 1, ES

0 z 1 S3

0 1 LA, EB, EC z 0 S4 Div, Done s 1

Div

0 zz

Figura 8.31: ENTITY Media_mob IS PORT ( Clock, Resetn, s, z, zz : IN STD_LOGIC ; EC, LC, Ssel, ES, LA, EB, Div, Done : OUT STD_LOGIC) ; END Media_mob;

251

ARCHITECTURE Behavior OF Media_mob IS TYPE STATE_TYPE IS (S1, S2, S3, S4) ; SIGNAL y : STATE_TYPE ; BEGIN FSM_transitions: PROCESS ( Resetn, Clock, s, z, zz ) BEGIN IF Resetn = 0 THEN y <=S1; ELSIF (Clock EVENT AND Clock= 1 )THEN CASE y IS WHEN S1 => IF s = 0 THEN y <= S1 ; ELSE y <= S2 ; END IF ; WHEN S2 => IF z = 0 THEN y <= S2 ; ELSE y <= S3 ; END IF ; WHEN S3 => IF z = 1 THEN y <=S3; ELSE IF zz = 0 THEN y <= S3 ; ELSE y <= S4 ; END IF ; END IF ; WHEN S4 => IF s = 1 THEN y <= S4 ; ELSE y <= S1 ; END IF ; END CASE ; END IF ; END PROCESS ; FSM_outputs: PROCESS ( y, z ) BEGIN LA <= 0 ; EB <= 0 ;EC <= 0 ; LC <= 0 ; ES <= 0 ; Ssel <= 0 ; Div <= 0 ; Done <= 0 ; CASE y IS WHEN S1 => LC <= 1 ;ES <= 1 ; WHEN S2 => ES <= 1 ; Ssel <= 1 ; IF z = 0 THEN EC <= 1 ; ELSE EC <= 0 ;END IF ; WHEN S3 => IF z = 0 THEN Div <= 1 ; LA <= 0 ;EB <= 0 ; EC <= 0 ; ELSE Div <= 0 ; LA <= 1 ; EB <= 1 ;EC <= 1 ; END IF ; 252

WHEN S4 => Div <= 1 ; Done <= 1 ; END CASE ; END PROCESS ; END Behavior ;

8.13 Trasformazioni di ASM chart

Nella ASM chart in gura 8.32, specichiamo lassegnazione C j Ci nello stato S2, poi nello stato S3 incrementiamo C j di 1. E possibile eliminare lo stato S3 se lassegnazione C j Ci + 1 avviene in S2? Spiegare ogni conseguenza che questo cambiamento ha sui circuiti di controllo e sul datapath. Soluzione Gli stati S2 ed S3 possono essere uniti in un unico stato eseguendo lassegnazione C j = Ci + 1. Il circuito richiederebbe un sommatore per incrementare Ci di 1 e le uscite di questo sommatore verrebbero caricate in parallelo nel contatore C j . Se invece di usare dei contatori per implementare C j e Ci utilizzassimo degli shift register, allora il risultato Ci + 1 potrebbe essere efcientemente calcolato collegando Ci agli ingressi dati per il caricamento in parallelo su C j cos` che i bit vengano scalati di una posizione.

8.14 Pseudo-codice per il sorting

Nel seguito si fornisce lo pseudo-codice per loperazione di ordinamento nella quale i registri che vengono ordinati sono indicizzati usando le variabili i e j. for i=0 to k-2 do A=R_{i}; for j=i+1 to k-1 do B=R_{j}; if B<A then R_{i}=B; R_{j}=A; A=R_{i}; end if; end for; end for; 253

Reset

S1 Ci Load registers 0 s 1 S2 A S3 Ci Cj + 1 Cj Cj + 1 Ri , Cj Ci 0

S4 B S5 Rj

S6 C Cj + 1 B < A? 0 1 Rj S7 Ri S8 A Ri B A

0 C j = k 1? 1 S9 Done 0 C i = k 2? 1 s 1 0

Figura 8.32:

254

Reset

S1 Ci Load registers 0 s 1 S2 A S3 Ci Cj + 1 Cj Cj + 1 Ri , Cj Ci 0

S4 B S5 Rj

S6 C Cj + 1 B < A? 0 1 Rj S7 Ri S8 A Ri B A

0 C j = k 1? 1 S9 Done 0 C i = k 2? 1 s 1 0

Figura 8.33: Nella ASM chart in gura 8.33, le variabili i e j sono implementate usando i contatori Ci e C j . Unapproccio differente consiste nel realizzare i e j con due shift register.

255

(a) Riprogettare il circuito per loperazione di ordinamento usando degli shift register invece dei contatori per i registri index R0 , ......, R3. (b) Scrivere il codice VHDL per il circuito progettato nella parte (a). (c) Discutere i relativi pregi e difetti del circuito progettato in confronto a quello che usa i contatori Ci e C j . Soluzione

1000 4 LI EI
L E

4 LJ L E Shift right

Shift right

EJ

Ci Clock

Cj C i (k2) => z i C j (k1) => z j

0 RAdd 2 2 to 4 decoder ExtAdd

1 4 Cmux Int

Csel

4 0 Rout
[0 3]

1 4 4 Rout 0

4 to 2 decoder

2 Imux

WrInit Wr Rout 1

Rin 0

Rin 1 Rout 2 Rin 2 Rout 3 Rin 3

Figura 8.34: 256

(a) La parte del datapath da modicare e mostrata in gura 8.34. La restante ` parte del circuito e la stessa della gura 8.35. `
DataIn ABmux n

0 n

1 RData

WrInit

Rin 0

Rin 1

Rin 2

Rin 3

R0

R1 0 1 2 3

R2

R3

Imux

ABData

Ain

Bin

E Rd n

Clock DataOut

Bout A

<
B

BitA

Figura 8.35: (b) il codice VHDL e riportano nel seguito: `

257

LIBRARY ieee ; USE ieee.std_logic_1164.all ; USE ieee.std_logic_unsigned.all ; USE work.components.all ; ENTITY Sort IS GENERIC ( N : INTEGER := 4 ) ; PORT ( Clock, Resetn : IN STD_LOGIC ; s, WrInit, Rd : IN STD_LOGIC ; DataIn : IN STD_LOGIC_VECTOR(N - 1 DOWNTO 0) ; RAdd : IN INTEGER RANGE 0 TO 3 ; DataOut : BUFFER STD_LOGIC_VECTOR(N - 1 DOWNTO 0); Done : BUFFER STD_LOGIC ) ; END Sort; ARCHITECTURE Behavior OF Sort IS TYPE STATE_TYPE IS ( S1, S2, S3, S4, S5, S6, S7, S8, S9) ; TYPE RegArray IS ARRAY(0 TO 3) OF STD_LOGIC_VECTOR(N -1 DOWNTO 0); SIGNAL y : STATE_TYPE ; SIGNAL Rin : STD_LOGIC_VECTOR(0 TO 3) ; -- controlli di scrittura del registro SIGNAL R : RegArray ; -- uscite del registro SIGNAL RData, ABMux : STD_LOGIC_VECTOR(N - 1 DOWNTO 0); -- input del registro SIGNAL Int, Csel, Wr, BltA : STD_LOGIC ; -SIGNAL CMux, IMux : INTEGER RANGE 0 TO 3 ; SIGNAL Ain, Bin, Aout, Bout : STD_LOGIC ; SIGNAL LI, LJ, EI, EJ, zi, zj : STD_LOGIC ; SIGNAL A, B, ABData : STD_LOGIC_VECTOR(N - 1 DOWNTO 0); -- Segnali ridefiniti SIGNAL Ci, Cj, Cmux : STD_LOGIC_VECTOR(0 TO 3); -- Nuovi segnali SIGNAL low : STD_LOGIC ; SIGNAL Rout : STD_LOGIC_VECTOR(0 TO 3); SIGNAL Addr0 : STD_LOGIC_VECTOR(0 TO 3); -- dati in parallelo per Ci SIGNAL ExtAdd : STD_LOGIC_VECTOR(0 TO 3); BEGIN

258

FSM_transitions: PROCESS ( Resetn, Clock ) BEGIN IF Resetn = 0 THEN y <=S1; ELSIF (Clock EVENT AND Clock = 1 )THEN CASE y IS WHEN S1 => IF S = 0 THEN y <= S1 ; ELSE y <= S2 ; END IF ; WHEN S2 => y <=S3; WHEN S3 => y <=S4; WHEN S4 => y <=S5; WHEN S5 => IF BltA = 1 THEN y <= S6 ; ELSE y <= S8 ; END IF ; WHEN S6 => y <=S7; WHEN S7 => y <=S8; WHEN S8 => IF zj = 0 THEN y <=S4; ELSIF zi = 0 THEN y <=S2; ELSE y <=S9; END IF ; WHEN S9 => IF s = 1 THEN y <= S9 ; ELSE y <= S1 ; END IF ; END CASE ; END IF ; END PROCESS ; Int <= 0 WHEN y = S1 ELSE 1 ; Done <= 1 WHEN y = S9 ELSE 0 ; FSM_outputs: PROCESS ( y, zi, zj ) BEGIN LI <= 0 ; LJ <= 0 ;EI<= 0 ; EJ <= 0 ; Csel <= 0 ; Wr <= 0 ; Ain <= 0 ; Bin <= 0 ; Aout <= 0 ; Bout <= 0 CASE y IS 259

WHEN S1 => LI <= 1 ; WHEN S2 => Ain <= 1 ; LJ <= 1 ; WHEN S3 => EJ <= 1 ; WHEN S4 => Bin <= 1 ; Csel <= 1 ; WHEN S5 => - nessuna uscita attiva in questo stato WHEN S6 => Csel <= 1 ; Wr <= 1 ; Aout <= 1 ; WHEN S7 => Wr <= 1 ; Bout <= 1 ; WHEN S8 => Ain <= 1 ; IF zj = 0 THEN EJ <= 1 ; ELSE EJ <= 0 ; IF zi = 0 THEN EI <= 1 ; ELSE EI <= 0 ; END IF ; END IF ; WHEN S9 => -- Done ha valore assegnato a 1 dallistruzione -di assegnazione condizionale END CASE ; END PROCESS ; -- definizione datapath GenReg: FOR i IN 0 TO 3 GENERATE Reg: regne GENERIC MAP ( N => N) PORT MAP ( RData, Resetn, Rin(i), Clock, R(i) ); END GENERATE ; RegA: regne PORT MAP RegB: regne PORT MAP GENERIC MAP ( N => N) ( ABData, Resetn, Ain, Clock, A ); GENERIC MAP ( N => N) ( ABData, Resetn, Bin, Clock, B );

BltA <= 1 WHEN B < A ELSE 0 ; ABMux <= A WHEN Bout= 0 ELSEB ; RData <= ABMux WHEN WrInit= 0 ELSE DataIn ; Addr0 <= "1000"; low <= 0 ; OuterLoop: shiftrne GENERIC MAP ( N => 4) PORT MAP ( Addr0, LI, EI, low, Clock, Ci ); InnerLoop: shiftrne GENERIC MAP ( N => 4) PORT MAP ( Ci, LJ, EJ, low, Clock, Cj ); 260

CMux <= Ci WHEN Csel= 0 Rout <= Cmux WHEN Int= 1

ELSE Cj ; ELSE ExtAdd ;

-- Lencoder 4-2 che guida Imux e implementato di seguito WITH Rout SELECT ABData <= R(0) WHEN "1000", R(1) WHEN "0100", R(2) WHEN "0010", R(3) WHEN OTHERS ; Rin <= Rout WHEN (WrInit OR Wr) = 1 ELSE "0000"; zi <= Ci(2); zj <= Cj(3); DataOut <= (OTHERS => Z ) WHEN Rd = 0 WITH Radd SELECT -- 2-to-4 decoder ExtAdd <= "1000" WHEN 0, "0100" WHEN 1, "0010" WHEN 2, "0001" WHEN OTHERS ; END Behavior ;

ELSE ABData ;

(c) Il maggior difetto dellutilizzo degli shift register al posto dei contatori e ` lincremento del numero di ip-op necessari. Ogni contatore utilizza log2 n ipop mentre ogni shift register richiede n ip-op. Comunque gli shift register non richiedono logica combinatoria per eseguire test come ad esempio il raggiungimento del valore di conteggio k 2: nello shift register si accede direttamente al bit k 2del registro per eseguire il test. Sarebbe possibile anche forzare il clock del datapath ad una frequenza pi` alta quando utilizziamo gli shift register, perch` u e pi` semplici dei contatori e quindi con precorsi critici ridotti. u

8.15 Ordinamento con buffer 3-state

La gura 8.36 mostra il datapath per loperazione di ordinamento che usa un buffer a tre stati per accedere ai registri. Descrivere il datapth usando il codice VHDL, denendo i sottocircuiti necessari. Descrivere il circuito di controllo usando il codice VHDL.

261

Figura 8.36: Soluzione Al momento manca.

8.16 Ordinamento - Uso moduli memoria lpm

Nel seguito e mostrato il codice VHDL per un circuito di ordinamento. Mostrare ` come modicare il codice per usare un sotto-circuito che rappresenti un blocco 262

k n di SRAM. Utilizzare il modulo l pm ram dq per il blocco di SRAM. Scegliere lopzione sincrona della SRAM cos` che tutti i cambiamenti ai contenuti della SRAM siano sincroni con il segnale di clock. (Suggerimento: usare il complemento del segnale di clock per sincronizzare le operazioni della SRAM perch` e questo approccio permette di utilizzare per la FSM lo stesso codice originario)

LIBRARY ieee; USE ieee.std_logic_1164.all; USE work.components.all; ENTITY sort_orig IS GENERIC (N : INTEGER := 4 ); PORT ( Clock, Resetn : IN STD_LOGIC; s, Wrinit, Rd : IN STD_LOGIC; DataIn : IN STD_LOGIC_VECTOR(N - 1 DOWNTO 0) RAdd : IN INTEGER RANGE 0 TO 3; DataOut :BUFFER STD_LOGIC_VECTOR (N -1 DOWNTO 0) Done : BUFFER STD_LOGIC); END sort_orig; ARCHITECTURE Behavior Of sort_orig IS TYPE State_type IS ( S1, S2, S3, S4, S5, S6, S7, S8, S9 ); TYPE RegArray IS ARRAY ( 3 DOWNTO 0) OF STD_LOGIC_VECTOR (N - 1 DOWNTO 0); SIGNAL y : State_type; SIGNAL Ci, Cj : INTEGER RANGE 0 TO 3; SIGNAL Rin : STD_LOGIC_VECTOR ( 3 DOWNTO 0 ); SIGNAL R : RegArray; SIGNAL RData, ABMux :STD_LOGIC_VECTOR (N-1 DOWNTO 0); SIGNAL Int, Csel, Wr, Blta : STD_LOGIC; SIGNAL CMux, IMux : INTEGER RANGE 0 TO 3; SIGNAL Ain, Bin, Aout, Bout : STD_LOGIC; SIGNAL LI, LJ, EI, EJ, zi, zj : STD_LOGIC; SIGNAL Zero: INTEGER RANGE 3 DOWNTO 0; -- dati in parallelo per Ci = 0 SIGNAL A, B, ABData : STD_LOGIC_VECTOR (N - 1 DOWNTO 0); BEGIN 263

FSM_transitions: PROCESS ( Resetn, CLock) BEGIN IF Resetn = 0 THEN y <= S1; ELSIF (ClockEVENT AND Clock = 1) THEN CASE y IS WHEN S1 => IF S = 0 THEN y <= S1; ELSE y <= S2; END IF; WHEN S2 => y <= S3; WHEN S3 => y <= S4; WHEN S4 => y <= S5; WHEN S5 => IF Blta = 1 THEN y <=S6; ELSE y <= S8; END IF; WHEN S6 => y <= S7; WHEN S7 => y <= S8: WHEN S8 => IF zj = 0 THEN y <= S4; ELSIF zi = 0 THEN y <= S2; ELSE y <= S9; END IF; WHEN S9 => IF s = 1 THEN y <= S9 ; ELSE y <= S1; END IF; END CASE; END IF; END PROCESS; -- definizione uscite generate dalla FSM Int <= 0 WHEN y = S1 ELSE 1; Done <= 1 WHEN y = S9 ELSE 0; FSM outputs: PROCESS ( y, zi, zj) BEGIN LI <= 0; LJ <= 0; EI <= 0; EJ <= 0; Csel <= 0: Wr <= 0: Ain <= 0; Bin <= 0; Aout <= 0; Bout <= 0; CASE y IS WHEN S1 => LI <= 1: WHEN S2 => Ain <= 1; LJ <= 1; WHEN S3 => EJ <= 1; WHEN S4 => Bin <= 1; Csel <= 1; WHEN S5 => -- nessuna uscita attiva per questo stato 264

WHEN S6 => Csel <= 1; Wr <= 1; Aout <= 1; WHEN S7 => Wr <= 1; Bout <= 1: WHEN S8 => Ain <= 1; IF zj = 0 THEN EJ <= 1; ELSE EJ <= 0; IF zi = 0 THEN EI <= 1; ELSE EI <= 0: END IF; END IF; WHEN S9 => -- Done ha valore 1 a causa dellassegnazione -- condizionata precedente END CASE; END PROCESS; -- definizione del datapath Zero <= 0; GenReg: FOR i IN 0 To 3 GENERATE Reg: regne GENERIC MAP ( N => N) PORT MAP ( RData, Resetn, Rin (i), Clock, R(i) ); END GENERATE; RegA: regne PORT MAP RegB: regne PORT MAP GENERIC MAP ( N => N) ( ABData, Resetn, Ain, CLock, A ); GENERIC MAP ( N => N) ( ABData, Resetn, Bin, Clock, B );

BltA <= 1 WHEN B < A ELSE 0; ABMux <= A WHEN Bout = 0 ELSE B; RData <= ABMux WHEN WrInit = 0 ELSE DataIn; OuterLoop; upcount GENERIC mAP ( PORT MAP ( Resetn, Clock, EI, InnerLoop: upcount GENERIC MAP ( PORT MAP ( Resetn, Clock, EJ, modulus => 4) LI, Zero, Ci); modulus => 4) LJ, Ci, Cj ) ;

265

CMux <= Ci WHEN Csel = 0 ELSE Cj; IMux <= Cmux WHEN Int ) 1 ELSE Radd; WITH IMux Select ABData <= R(0) WHEN R(1) R(2) R(3)

0, WHEN 1, WHEN 2; WHEN OTHERS;

RinDec: PROCESS ( WrInit, Wr, IMux ) BEGIN IF ( WrInit OR Wr ) = 1 THEN CASE IMux IS WHEN 0 => Rin <= "0001; WHEN 1 => Rin <= "0010; WHEN 2 => Rin <= "0100; WHEN OTHERS => Rin <= "1000; END CASE; ELSE Rin <= "0000; END IF; END PROCESS; Zi <= 1 WHEN Ci = 2 ELSE 0; Zj <= 1 WHEN Cj = 3 ELSE 0; DataOut <= ( OTHERS => Z ) WHEN Rd = 0 ELSE ABData; END Behavior;

Soluzione Il codice VHDL seguente mostra i cambiamenti necessari nel datapath afnch` e un blocco SRAM possa essere utilizzato al posto dei registri. Il blocco di SRAM e sincronizzato sul fronte di discesa del segnale di clock, quindi i cambiamenti ` prodotti nelle uscite da altri elementi del datapath devono essere stabili prima del fronte di discesa; il periodo del clock deve essere lungo abbastanza da prevenire questo problema.

266

LIBRARY ieee ; USE ieee.std_logic_1164.all ; USE ieee.std_logic_unsigned.all ; LIBRARY lpm ; USE lpm.lpm_components.all ; USE work.components.regne ; USE work.components.upcount ;

ENTITY sort_mod IS GENERIC ( N : INTEGER := 4 ) ; PORT ( Clock, Resetn : IN STD_LOGIC ; s, WrInit, Rd : IN_STD_LOGIC ; DataIn : IN STD_LOGIC_VECTOR(N - 1 DOWNTO 0) ; RAdd : IN INTEGER RANGE 0 TO 3 ; DataOut : BUFFER STD_LOGIC_VECTOR(N - 1 DOWNTO 0) ; Done : BUFFER STD_LOGIC ) ; END sort_mod ; ARCHITECTURE Behavior OF sort_mod IS TYPE STATE_TYPE IS ( S1, S2, S3, S4, S5, S6, S7, S8, S9 ) ; SIGNAL y : STATE_TYPE ; SIGNAL Ci, Cj : INTEGER RANGE 0 TO 3 ; -- uscita contatori Ci & Cj SIGNAL RData, ABMux : STD_LOGIC_VECTOR(N - 1 DOWNTO 0); SIGNAL Int, Csel, Wr, BltA : STD_LOGIC ; SIGNAL CMux, IMux : INTEGER RANGE 0 TO 3 ;-- indirizzi uscitemux SIGNAL Ain, Bin, Aout, Bout : STD_LOGIC ; SIGNAL LI, LJ, EI, EJ, zi, zj, WE, NClock : STD_LOGIC ; SIGNAL Zero : INTEGER RANGE 3 DOWNTO 0 ; -- dati in parallelo per Ci = 0 SIGNAL A, B, ABData : STD_LOGIC_VECTOR(N - 1 DOWNTO 0); SIGNAL MemAdd : STD_LOGIC_VECTOR(1 DOWNTO 0) ; -- SRAM address holder BEGIN FSM_transitions: PROCESS ( Resetn, Clock )

267

BEGIN ... codice non mostrato. Vedere il codice definito in precedenza END PROCESS ; FSM_ outputs: PROCESS ( y, s, BltA, zi, zj ) BEGIN ... codice non mostrato. Vedere codice definito in precedenza END PROCESS ; Int <= 0 Zero <=0; RegA: regne PORT MAP RegB: regne PORT MAP WHEN y = S1 ELSE 1 ;

GENERIC MAP ( N => N) ( ABData, Resetn, Ain, Clock, A ) ; GENERIC MAP ( N => N) ( ABData, Resetn, Bin, Clock, B ) ;

BltA <= 1 WHEN B < A ELSE 0 ; ABMux <= A WHEN Bout = 0 ELSE B ; RDAta <= ABMux WHEN WrInit = 0 ELSE DataIn ; OuterLoop: upcount GENERIC MAP ( PORT MAP ( Resetn, Clock, EI, InnerLoop: upcount GENERIC MAP ( PORT MAP ( Resetn, Clock, EJ, modulus => 4) LI, Zero, Ci ) ; modulus => 4) LJ, Ci, Cj ) ;

CMux <= Ci WHEN Csel = 0 ELSE Cj ; IMux <= Cmux WHEN Int = 1 ELSE Radd ; MemAdd <= CONV_STD_LOGIC_VECTOR(IMux, 2) ; WE <= WrInit OR Wr ; NClock <= NOT Clock; SRAM block : LPM_RAM_DQ GENERIC MAP ( LPM_WIDTH => 4, LPM_WIDTHAD => 2, 268

LPM_ADDRESS_CONTROL => "REGISTERED", LPM_INDATA => "REGISTERED", LPM_OUTDATA => "UNREGISTERED") PORT MAP ( address => MemAdd, we => WE, q => ABData, inclock => NClock, data => RData ) ; Zi <= 1 WHEN Ci = 2 ELSE 0 ; Zj <= 1 WHEN Cj = 3 ELSE 0 ; DataOut <= (OTHERS => Z ) WHEN Rd = 0 END Behavior ;

ELSE ABData ;

8.17 Media
La gura 8.37 mostra lo schema di un circuito che elabora loperazione di media su 4 campioni. Scrivere il codice VHDL che rappresenta il circuito utilizzando un array di registri invece di un blocco di SRAM. Per il sotto-circuito divisore , usare unoperazione di shift che divida per quattro. Soluzione Il codice VHDL e riportato nel seguito: ` LIBRARY ieee ; USE ieee.std_logic_1164.all ; USE ieee.std_logic_unsigned.all ; USE work.components.all ; ENTITY mean_circ IS GENERIC ( N : INTEGER := 8 ) ; PORT ( Clock, Resetn : IN STD_LOGIC ; Data : IN STD_LOGIC_VECTOR(N - 1 DOWNTO 0) ; RAdd : IN INTEGER RANGE 0 TO 3 ; s, ER : IN STD_LOGIC ; M : OUT STD_LOGIC_VECTOR(N - 1 DOWNTO 0) ; Done : OUT STD_LOGIC ) ; END mean_circ ;

269

MReg Data[7 ..0] Write data[7 ..0] we address[3 ..0] Adder BUSMUX 0 C L O C K R[7 ..0]
GND

q[7 ..0]

C[3 ..0] D O W N C O U N T Q[3 ..0]

A + REGNE B

RESETN E CLOCK

Q[7 ..0]

Clock Resetn

DIVIDER CLOCK RESETN S S Z ZZ C[3] C[2] C[1] C[0] k[7 ..0] EC LC SSEL ES LA EB DIV DONE CLOCK RESETN S LA EB DATAA[7 ..0] DATAB[7 ..0] DONE Q[7 ..0] Q[7 ..0] R[7 ..0] R[7 ..0]

Done

Figura 8.37: ARCHITECTURE Behavior OF mean_circ IS TYPE State_type IS ( S1, S2, S3, S4, S5 ) ; TYPE RegArray IS ARRAY(0 TO 3) OF STD_LOGIC_VECTOR(N - 1 DOWNTO 0); SIGNAL y : State_type ; SIGNAL Dec_RAdd, Rin : STD_LOGIC_VECTOR(0 TO 3) ; SIGNAL R : RegArray ; SIGNAL Ri, SR, Sin: STD_LOGIC_VECTOR (N - 1 DOWNTO 0); SIGNAL Sum : STD_LOGIC_VECTOR (N - 1 DOWNTO 0); 270

SIGNAL ES, Ssel, EC, LC, z : STD_LOGIC ; SIGNAL C : INTEGER RANGE 0 TO 3 ; SIGNAL LA, EB, zz, Div : STD_LOGIC ; BEGIN FSM_transitions: PROCESS ( Resetn, Clock ) BEGIN IF Resetn = 0 THEN y <=S1; ELSIF (Clock EVENT AND Clock = 1 ) THEN CASE y IS WHEN S1 => IF s = 0 THEN y <= S1 ; ELSE y <= S2 ; END IF ; WHEN S2 => IF z = 1 THEN y <= S3 ; ELSE y <= S2 ; END IF ; WHEN S3 => y <=S4; WHEN S4 => IF zz= 0 THEN y <= S4 ; ELSE y <= S5 ; END IF ; WHEN S5 => IF s = 1 THEN y <= S5 ; ELSE y <= S1 ; END IF ; END CASE ; END IF ; END PROCESS ; FSM_outputs: PROCESS ( y, z ) BEGIN EC <= 0 ; LC <= 0 ; Ssel <= 0 ; ES <= 0 ; Done <= 0 ; LA <= 0 ; EB <= 0 ; Div <= 0 ; CASE y IS WHEN S1 => LC <= 1 ; ES <= 1 ; WHEN S2 => ES <= 1 ; Ssel <= 1 ; 271

IF z= 0 THEN EC <= 1 ; ELSE EC <= 0 ; END IF ; WHEN S3 => LA <= 1 ; EB <= 1 ; WHEN S4 => Div <= 1 ; WHEN S5 => Div <= 1 ; Done <= 1 ; END CASE ; END PROCESS ; WITH RAdd SELECT -- 2-to-4 decoder Dec_RAdd <= "1000" WHEN 0, "0100" WHEN 1, "0010" WHEN 2, "0001" WHEN OTHERS ; Rin <= Dec_RAdd WHEN ER = 1 ELSE "0000" ;

GenReg: FOR i IN 0 TO 3 GENERATE Reg: regne GENERIC MAP ( N => N) PORT MAP ( Data, Resetn, Rin(i), Clock, R(i) ) ; END GENERATE ; Count: downcnt GENERIC MAP ( modulus => 4) PORT MAP ( Clock, EC, LC,C); z <= 1 WHEN C=0 ELSE 0 ; -- NOR GATE Sin <= Sum WHEN Ssel = 1 ELSE (OTHERS => 0 ) ; RegS: regne GENERIC MAP ( N => N) PORT MAP ( Sin, Resetn, ES, Clock, SR ) ; -- Registri Mux WITH C SELECT Ri <= R(0) WHEN 0, R(1) WHEN 1, R(2) WHEN 2, R(3) WHEN OTHERS ; Sum <= SR + Ri ; -- Divisore per 4 M <= "00" & SR(N - 1 DOWNTO 2); zz <= 1 ; END Behavior ; 272

RAdd

ER

w1

w0

En

2to4
y0 y1 y2 y3

Data

Register

Register

Register

Register

Clock

z Ssel n EC E L

ES

Register

LC

Downcounter

k1 Sum k + n n B Div s EB A LA EB n LA

Divider
R n M Q n zz Done

Figura 8.38:

273

8.18 Media (2)

Il circuito rappresentato in gura 8.38 usa un sommatore per elaborare la somma dei contenuti dei registri. Il sotto-circuito divisore usato per ottenere M = Sum/k contiene anche un sommatore. Mostrare come il circuito possa essere ridisegnato in modo da contenere solamente un unico sotto-circuito sommatore usato sia per loperazione di somma che di divisione. Illustrare solo la parte di circuito in pi` u necessaria a connettere il sommatore, e spiegarne il funzionamento. Soluzione
Reset

S1 LR Rsel = 0, LC; ER

EA, ER0

S2 ER, ER0, EA, Rsel = 1

cout 1

S3 Done LR EC

Figura 8.39: La gura 8.39 rappresenta la ASM chart e la gura 8.40 il circuito che realizza 274

il divisore. Da queste gure si pu` notare come il sotto-circuito divisore non o utilizzi il sommatore nello stato S1.
DataA LA n EB DataB n

L EA Clock E

Leftshift register n

Register

n B

cout

cin

0 n Rsel 1 0 ER0 LR ER L E Leftshift register n n rr 0 w Q Q D 0 1 0 q n1

n1 r n2.... r 0 R n Q n

Figura 8.40: Siccome il circuito di controllo del divisore si trova in S1 no a quando s = 0, e possibile utilizzare il sommatore in un altro circuito mentre si permane nello ` stato S1 e s = 0. 275

La gura 8.41 illustra le modiche necessarie al circuito divisore per farlo funzionare nel nuovo modo: occorre aggiungere un multiplexer per ogni ingresso dati del sommatore. La linea di selezione del multiplexer e pilotata dallingresso s del ` divisore ( questo segnale viene chiamato Div nel disegno, perch` e il segnale Div e` nel circuito della Media che porta lingresso s al sotto-circuito divisore). Quando Div = 1 il sommatore ha in ingresso i normali dati usati dalloperazione di divisione. Quando invece Div = 0 il sommatore riceve in ingresso dati esterni chiamati Op1 e Op2 , provenienti dal circuito di Media. Notare che gli ingressi Cin sul sommatore sono comandati dal segnale Div. Questa congurazione e necessaria ` perch` il divisore utilizza il suo sommatore anche per eseguire sottrazioni. e
Op1 n 0 1 R n 0 Op2 n 1 B n

AddIn0

AddIn1

Cout

Cout

Cin

Div

MeanOut DivOut

Figura 8.41:

8.19 Media (2) - Codice VHDL

Scrivere il codice VHDL per il circuito progettato nellesercizio precedente, inclusi entrambi i circuiti datapath e di controllo. Soluzione Di seguito e scritto il codice VHDL per il divisore originario che pu` essere ` o utilizzato nellesercizio proposto. 276

LIBRARY ieee; USE ieee.std_logic_1164.all; USE ieee.std_logic_unsigned.all; USE work.components.all; ENTITY divider IS GENERIC ( N:INTEGER := 8 ); PORT ( Clock : IN STD_LOGIC; Resetn : IN STD_LOGIC; s, LA, EB : IN STD_LOGIC; DataA: IN STD_LOGIC_VECTOR(N-1 DOWNTO 0); DataB: IN STD_LOGIC_VECTOR(N-1 DOWNTO 0); R, Q : BUFFER STD_LOGIC_VECTOR(N-1 DOWNTO 0); Done : OUT STD_LOGIC); END divider; ARCHITECTURE Behavior OF divider IS TYPE State_type IS (S1, S2, S3); SIGNAL SIGNAL SIGNAL SIGNAL SIGNAL SIGNAL BEGIN FSM_transitions: PROCESS (Resetn, Clock) BEGIN IF Resetn = 0 THEN y <= S1; ELSIF ( ClockEVENT AND Clock = 1) THEN CASE y IS WHEN S1 => IF s = 0 THEN y<=S1;ELSE y<=S2; END IF; WHEN S2 => IF z = 0 THEN y<=S2;ELSE y<=S3; END IF; WHEN S3 => IF s = 1 THEN y<=S3;ELSE y<=S1;END IF; END CASE; 277 y : State_type; Zero, Cout, z : STD_LOGIC; EA, Rsel, LR, ER, ER0, LC, EC, R0: STD_LOGIC; A, B, DataR : STD_LOGIC_VECTOR (N-1 DOWNTO 0); Sum : STD_LOGIC_VECTOR (N DOWNTO 0); Count: INTEGER RANGE 0 TO N-1;

END IF; END PROCESS; FSM_outputs: PROCESS (s, y, Cout, z) BEGIN LR <= 0; ER <= 0; ER0 <= 0; LC <= 0; EC <= 0; EA <= 0; Done <= 0; Rsel <= 0; CASE y IS WHEN S1 => LC <= 1; ER <= 1; IF s = 0 THEN LR <= 1; EA < 0; ER0 <= 0; ELSE LR < 0; EA <= 1; ER0 <= 1; END IF; WHEN S2 => Rsel z= 1; ER <= 1; ER0 <= 1; EA <= 1; IF Cout = 1 THEN LR <= 1; ELSE LR <= 0;END IF; IF z = 0 THEN EC <= 1; ELSE EC <= 0; END IF; WHEN S3 => Done <= 1; END CASE; END PROCESS; --definizione datapath Zero <= 0; RegB: regne GENERIC MAP ( N => N) PORT MAP (DataB, Resetn, EB; Clock, B); ShiftR: shiftlne GENERIC MAP (N => N) PORT MAP (DataR, LR; ER, R0, Clock, R); FF_R0: muxdff PORT MAP (Zero, A(N-1), ER0, Clock, R0); ShiftA: shiftlne GENERIC MAP (N =>N) PORT MAP (DataA, LA, EA, Cout, Clock, A); q <= A; Counter: downcnt GENERIC MAP(modulus => N) PORT MAP (Clock, EC, LC, Count); 278

z <=1 WHEN Count = 0 ELSE 0; SUM <= R &r0 + (NOT B+1) Cout <= Sum(N); DataR <= (OTHERS => 0) WHEN Rsel = 0 ELSE Sum; END Behavior;

Il codice richiesto e per il circuito di Media con il divisore modicato e ripor` ` tato nel seguito

LIBRARY ieee ; USE ieee.std_logic_1164.all ; USE ieee.std_logic_unsigned.all ; USE work.components.all ; ENTITY divider IS GENERIC ( N : INTEGER := 8 ) ; PORT ( Clock, Resetn : IN STD_LOGIC ; s, LA, EB : IN STD LOGIC ; DataA, DataB : IN STD_LOGIC_VECTOR(N - 1 DOWNTO 0); R, Q : BUFFER STD_LOGIC_VECTOR(N - 1 DOWNTO 0); Op1, Op2 : IN STD_LOGIC_VECTOR(N - 1 DOWNTO 0) ; -- nuove porte Result : OUT STD_LOGIC_VECTOR(N - 1 DOWNTO 0) ; -- nuova porta Done : OUT STD_LOGIC ) ; END divider ; ARCHITECTURE Behavior OF divider IS TYPE STATE_TYPE IS ( S1, S2, S3 ) ; SIGNAL SIGNAL SIGNAL SIGNAL SIGNAL SIGNAL SIGNAL SIGNAL y : STATE_TYPE ; Zero, Cout, z : STD_LOGIC ; EA, Rsel, LR, ER, ER0, LC, EC, R0 : STD_LOGIC ; A, B, DataR : STD_LOGIC_VECTOR(N - 1 DOWNTO 0) ; Sum : STD_LOGIC_VECTOR(N DOWNTO 0) ; Count : INTEGER RANGE 0 TO N - 1; AddIn1 : STD_LOGIC_VECTOR(N DOWNTO 0) ; AddIn2 : STD_LOGIC_VECTOR(N - 1 DOWNTO 0);

279

BEGIN FSM_transitions: PROCESS ( Resetn, Clock ) BEGIN ... codice non mostrato. END PROCESS ; FSM_outputs: PROCESS ( s, y, Cout, z ) BEGIN ... codice non mostrato. END PROCESS ; Zero <= 0 ;

RegB: regne GENERIC MAP ( N => N) PORT MAP ( DataB, Resetn, EB, Clock, B ) ; ShiftR: shiftlne GENERIC MAP ( N => N) PORT MAP ( DataR, LR, ER, R0, Clock, R ) ; FF R0: muxdff PORT MAP ( Zero, A(N - 1), ER0, Clock, R0 ) ; ShiftA: shiftlne GENERIC MAP ( N => N) PORT MAP ( DataA, LA, EA, Cout, Clock, A ) ; Q <=A; Counter: downcnt GENERIC MAP ( modulus => N) PORT MAP ( Clock, EC, LC, Count ) ; z <= 1 WHEN Count = 0 ELSE 0 ;

-- nuovo codice; vedere il problema precedente AddIn1 <= R & R0 WHEN s = 1 280 ELSE 0 \& Op1 ;

AddIn2 <= NOT B WHEN s = Sum <= AddIn1 + AddIn2 + s Cout <= Sum(N) ; DataR <= (OTHERS => 0 ) Result <= Sum(N - 1 DOWNTO END Behavior ;

1 ;

ELSE Op2 ;

WHEN Rsel = 0 0);

ELSE Sum ;

Il codice per il circuito della Media modicato e il seguente `

LIBRARY ieee ; USE ieee.std_logic_1164.all ; USE ieee.std_logic_unsigned.all ; USE work.components.all ; ENTITY Media is GENERIC ( N : INTEGER := 8 ) ; PORT ( Clock, Resetn : IN STD_LOGIC ; Data : IN STD_LOGIC_VECTOR(N - 1 DOWNTO 0); RAdd : IN INTEGER RANGE 0 TO 3 ; s, ER : IN STD LOGIC ; M : BUFFER STD_LOGIC_VECTOR(N- 1 DOWNTO 0); Done : OUT STD_LOGIC ) ; END Media ; ARCHITECTURE Behavior OF Media IS COMPONENT divider GENERIC ( N : INTEGER := 8 ) ; PORT ( Clock, Resetn : IN STD_LOGIC ; s, LA, EB : IN STD_LOGIC ; DataA, DataB: IN STD_LOGIC_VECTOR(N - 1 DOWNTO 0); R, Q : BUFFER STD_LOGIC_VECTOR(N - 1 DOWNTO 0) ; Op1, Op2 : IN STD_LOGIC_VECTOR(N - 1 DOWNTO 0) ; Result : OUT STD_LOGIC_VECTOR(N - 1 DOWNTO 0) ; Done : OUT STD_LOGIC ) ; END COMPONENT ; TYPE State_type IS ( S1, S2, S3, S4, S5 ) ; 281

TYPE RegArray IS ARRAY(0 TO 3) OF STD_LOGIC_VECTOR(N - 1 DOWNTO 0); SIGNAL y : State_type ; SIGNAL Dec_RAdd, Rin : STD_LOGIC_VECTOR(0 TO 3) ; SIGNAL R:RegArray ; SIGNAL Ri, SR, Sin: STD_LOGIC_VECTOR(N - 1 DOWNTO 0) ; SIGNAL Sum, Remainder, K : STD_LOGIC_VECTOR(N - 1 DOWNTO 0); SIGNAL ES, Ssel, EC, LC, z : STD_LOGIC ; SIGNAL C : INTEGER RANGE 0 TO 3 ; SIGNAL LA, EB, zz, Div : STD_LOGIC; BEGIN FSM_tran: PROCESS ( Resetn, Clock ) BEGIN IF Resetn = 0 THEN y <=S1; ELSIF (Clock EVENT AND Clock = 1 ) THEN CASE y IS WHEN S1 => IF s = 0 THEN y <= S1 ; ELSE y <= S2 ; END IF ; WHEN S2 => IF z = 1 THEN y <= S3 ; ELSE y <= S2 ; END IF ; WHEN S3 => y <=S4; WHEN S4 => IF zz= 0 THEN y <= S4 ; ELSE y <= S5 ; END IF ; WHEN S5 => IF s = 1 THEN y <= S5 ; ELSE y <= S1 ; END IF ; END CASE ; END IF ; END PROCESS ; FSM_outputs: PROCESS ( y, z ) BEGIN EC <= 0 ; LC <= 0 ; Ssel <= 0 ; ES <= 0 ; Done <= 0 ; LA <= 0 ; EB <= 0 ; Div <= 0 ; CASE y IS WHEN S1 => EC <= 1 ; LC <= 1 ; ES <= 1 ; WHEN S2 => 282

ES <= 1 ; Ssel <= 1 ; IF z= 0 THEN EC <= 1 ; ELSE EC <= 0 ; END IF ; WHEN S3 => LA <= 1 ; EB <= 1 ; WHEN S4 => Div <= 1 ; WHEN S5 => Div <= 1 ; Done <= 1 ; END CASE ; END PROCESS ; -- Decoder 2 - 4 WITH RAdd SELECT Dec RAdd <= "1000" WHEN 0, "0100" WHEN 1, "0010" WHEN 2, "0001" WHEN OTHERS ; Rin <= Dec_RAdd WHEN ER = 1 ELSE "0000" ; GenReg: FOR i IN 0 TO 3 GENERATE Reg: regne GENERIC MAP ( N => N) PORT MAP ( Data, Resetn, Rin(i), Clock, R(i) ) ; END GENERATE ; Count: downcnt GENERIC MAP ( modulus => 4) PORT MAP ( Clock, EC, LC, C ) ; z <= 1 WHEN C = 0 ELSE 0 ; -- NOR GATE Sin <= Sum WHEN Ssel = 1 ELSE (OTHERS => 0 ) ; RegS: regne GENERIC MAP ( N => N) PORT MAP ( Sin, Resetn, ES, Clock, SR ) ; -- Registri Mux WITH C SELECT Ri <= R(0) WHEN 0, R(1) WHEN 1, R(2) WHEN 2, R(3) WHEN OTHERS ; -- Sum <= SR + Ri ; K <= "00000100" ; DivideBy4: divider PORT MAP ( Clock=>Clock,Resetn =>Resetn, s=>Div, LA=>LA, EB=>EB,DataA=>SR,DataB=>K,R=>Remainder,Q=>M, Op1 => SR, Op2 => Ri, Result => Sum, Done => zz ); END Behavior ; 283

DataIn ABmux n

0 n

1 RData

WrInit

Rin 0

Rin 1

Rin 2

Rin 3

R0

R1 0 1 2 3

R2

R3

Imux

ABData

Ain

Bin

E Rd n

Clock DataOut

Bout A

<
B

BitA

Figura 8.42:

8.20 Pseudo-codice per un sorter

Lo pseudo-codice per effettuare unoperazione di ordinamento utilizza i registri A e B per mantenere i contenuti dei registri ordinati. Scrivere lo pseudocodice per loperazione di ordinamento che utilizza esclusivamente il registro A per mantenere temporaneamente i dati durante loperazione di ordinamento.

284

Reset

S1 Ci Load registers 0 0

s 1

S2 A S3 Cj Ci C +1 i C j +1 Ri
,

Cj

Ci

S4

S5 1 R j < A? Cj C j +1 S7 A Ri 0 S6 Rj A Ri Rj

Cj = k 1? S8 1 Done = 1 s 1 Ci = k 2? 1 0

Figura 8.43:

285

Fornire una corrispondente ASM chart che rappresenti il circuito datapath e di controllo necessari. Usare dei multiplexer per collegare i registri, come in gura 8.42. Denire una ASM chart separata per il circuito di controllo. for i=0 to k-2 do A=R_{i}; for j=i+1 to k-1 do B=R_{j}; if B<A then _{i}=B; $R_{j}=A; A=R_{i}; end if; end for; end for;

Soluzione Lo pseudo-codice modicato e il seguente ` for i=0 to k-2 do A=R_{i}; for j=i+1 to k-1 do if R_{j}<A then R_{i}=R_{j}; R_{j}=A; end if; A=R_{i}; end for; end for; e la corrispondente ASM chart e riportata in gura 8.43 ` Dalla ASM chart si nota come il datapath abbia bisogno di un multiplexer per permettere loperazione Ri R j . Un datapath in grado di svolgere le funzioni richieste e riportato in gura 8.44. ` La ASM chart per il circuito di controllo e in gura 8.45 `

8.21 VHDL di un sorter

Scrivere il codice VHDL per il circuito di ordinamento progettato nellesercizio precedente. 286

DataIn

WrInit n

Rin 0

Rin 1

Rin 2

Rin 3

Imux

Clock

Ain

E A n

Cj Rj

Rjout

Rd

<

RjltA

DataOut

Figura 8.44: Soluzione LIBRARY ieee ; USE ieee.std_logic_1164.all ; USE ieee.std_logic_unsigned.all ; USE work.components.all ; ENTITY sorter IS GENERIC ( N : INTEGER := 4 ; LOG2K : INTEGER := 2 ); PORT ( Clock, Resetn : IN STD LOGIC ; s, WrInit, Rd : IN STD LOGIC ; DataIn : IN STD LOGIC VECTOR(N - 1 DOWNTO 0) ; RAdd : IN INTEGER RANGE 0 TO 3 ; DataOut : BUFFER STD LOGIC VECTOR(N - 1 DOWNTO 0) ; Done : BUFFER STD LOGIC ) ; END sorter ; 287

Reset

S1 LI, Int = 0

s 1

S2 Int = 1, Csel = 0, Ain, LJ S3 EJ EI

S4

S5 Csel=0, Int = 1, Wr, Rjout 1 Rjlta EJ 0 S7 Csel = 0, Int = 1, Ain S6 Csel = 1, Int = 1, Wr, Aout

zj S8 1 Done = 1 s 1 zi 1 0

Figura 8.45:

288

ARCHITECTURE Behavior of sorter

IS

TYPE State_type IS ( S1, S2, S3, S4, S5, S6, S7, S8 ) ; SIGNAL y : State_type ; SIGNAL Ci, Cj : INTEGER RANGE 0 to 3 ; SIGNAL Rin : STD_LOGIC_VECTOR(0 TO 3) ; TYPE RegArray IS ARRAY(0 TO 3) OF STD_ LOGIC_VECTOR(N - 1 DOWNTO 0); SIGNALR:RegArray ; SIGNAL RData : STD_LOGIC_VECTOR(N - 1 DOWNTO 0); SIGNAL Int, Csel, Wr, RjltA : STD_LOGIC ; SIGNAL Cmux, Imux : INTEGER RANGE 0 TO 3 ; SIGNAL LI, LJ, EI, EJ, zi, zj, Ain, Rjout : STD_LOGIC ; SIGNAL Zero : INTEGER RANGE 0 TO 3 ; SIGNAL A, AData : STD_LOGIC_VECTOR(N - 1 DOWNTO 0); SIGNAL ARjMux, Rj : STD_LOGIC_VECTOR(N - 1 DOWNTO 0); BEGIN FSM_transitions: PROCESS ( Resetn, Clock ) BEGIN IF Resetn = 0 THEN y <=S1; ELSIF ( Clock EVENT AND Clock = 1 ) THEN CASE y IS WHEN S1 => IF s = 0 THEN y <= S1 ; ELSE y <= S2 ; END IF ; WHEN S2 => y <=S3; WHEN S3 => y <=S4; WHEN S4 => IF RjltA = 1 THEN y <= S5 ; ELSE y <= S7 ; END IF ; WHEN S5 => y <=S6; WHEN S6 => y <=S7; WHEN S7 => IF zj = 0 THEN y <=S4; ELSIF zi = 0 THEN y <=S2; ELSE y <=S8; END IF ; 289

WHEN S8 => IF s = 1 END CASE ; END IF ; END PROCESS ;

THEN y <= S8 ; ELSE y <= S1 ; END IF ;

Int <= 0 WHEN y = S1 ELSE 1 ; Done <= 1 WHEN y = S8 ELSE 0 ; FSM_outputs: PROCESS ( y, zi, zj ) BEGIN LI <= 0 ; LJ <= 0 ; EI <= 0 ; EJ <= 0 ; Csel <= 0 ; Wr <= 0 ; Ain <= 0 ; RjOut <= 0 ; CASE y IS WHEN S1 => LI <= 1 ; WHEN S2 => Ain <= 1 ; LJ <= 1 ; WHEN S3 => EJ <= 1 ; WHEN S4 => -- nessuna uscita attiva WHEN S5 => Wr <= 1 ; Rjout <= 1 ; WHEN S6 => Csel <= 1 ; Wr <= 1 ; WHEN S7 => Ain <= 1 ; IF zj = 0 THEN EJ <= 1 ; ELSE EJ <= 0 ; IF zi = 0 THEN EI <= 1 ; ELSE EI <= 0 ; END IF ; END IF ; WHEN S8 => -- nessuna uscita attiva END CASE ; END PROCESS ; Zero <=0; GenReg: FOR i IN 0 TO 3 GENERATE Reg: regne GENERIC MAP ( N => N) PORT MAP ( RData, Resetn, Rin(i), Clock, R(i) ); END GENERATE ; RegA: regne GENERIC MAP ( N => N) PORT MAP ( AData, Resetn, Ain, Clock, A ) ;

290

-- Nuovo datapath WITH Cj SELECT Rj <= R(0) WHEN R(1) R(2) R(3)

0, WHEN 1, WHEN 2, WHEN OTHERS ;

ARjMux <= Rj WHEN Rjout= 1 ELSE A ; RData <= ARjMux WHEN WRInit = 0 ELSE DataIn ; RjltA <= 1 WHEN Rj < A ELSE 0 ; -- Fine del nuovo datapath OuterLoop: upcount GENERIC MAP ( PORT MAP ( Resetn, Clock, EI, InnerLoop: upcount GENERIC MAP ( PORT MAP ( Resetn, Clock, EJ, modulus => 4) LI, Zero, Ci ) ; modulus => 4) LJ, Ci, Cj ) ;

Cmux <= Ci WHEN Csel = 0 ELSE Cj ; Imux <= Cmux WHEN Int = 1 ELSE Radd ; WITH Imux SELECT AData <= R(0) WHEN 0, R(1) WHEN 1, R(2) WHEN 2, R(3) WHEN OTHERS ; RinDec: PROCESS ( WrInit, Wr, Imux ) BEGIN IF (WrInit OR Wr) = 1 THEN CASE Imux IS WHEN 0 => Rin <= "1000"; WHEN 1 => Rin <= "0100"; WHEN 2 => Rin <= "0010"; WHEN OTHERS => Rin <= "0001"; END CASE ; ELSE Rin <= "0000"; END IF ; END PROCESS ; zi <= 1 zj <= 1 WHEN Ci = 2 ELSE 0 WHEN Cj = 3 ELSE 0 291 ; ;

DataOut <= (OTHERS => Z ) END Behavior ;

WHEN Rd= 0

ELSE AData ;

Data

Bus

Clock

R0

R3

A B

G G in R in R out
R in

R3 out

Ain G out AddSub

w Function

Control circuit

Extern Done

Figura 8.46:

8.22 Processore
Nella gura 8.46 e mostrato un circuito che opera come un semplice processore. ` Progettare una ASM chart che descriva il funzionamento di tal processore. Soluzione La ASM chart del processore e riportata in gura 8.47. `

292

Reset

T0

w 1

Load function register

T1

1 RX Data, Done I=0

0

1 RX RY , Done
I=1 0

A Rx
T2

1 I=2 G A+R Y G 0

A RY

T3 RX G, Done

Figura 8.47:

293

8.23 Processore (2)

(a) Per la ASM chart ottenuta nellesercizio precedente, denire la ASM chart che specichi i segnali di controllo richiesti per controllare il datapath nel processore. Assumere che siano usati dei multiplexer per implementare il bus che collega i registri, da R0 a R3, nel processore. (b) Scrivere il codice VHDL completo per il sistema nellesercizio precedente, incluso il circuito di controllo descritto nella parte (a). Soluzione (a) La ASM chart di controllo del processore e riportata in gura 8.48. ` (b) Il codice VHDL e ` LIBRARY ieee ; USE ieee.std_logic_1164.all ; USE ieee.std_logic_unsigned.all ; USE work.components.all ; ENTITY processor IS PORT ( Data : IN STD_LOGIC_VECTOR(7 DOWNTO 0) ; Clock, Resetn,w : IN STD_LOGIC ; F, Rx, Ry : IN STD_LOGIC_VECTOR(1 DOWNTO 0) ; Done : OUT STD_LOGIC ; BusWires : INOUT STD_LOGIC_VECTOR(7 DOWNTO 0) ) ; END processor ; ARCHITECTURE Behavior OF processor IS

TYPE State_Type IS ( T0, T1, T2, T3 ) ; SIGNAL SIGNAL SIGNAL SIGNAL SIGNAL SIGNAL SIGNAL BEGIN T : State_Type ; Gin, Gout, Extern : STD_LOGIC ; High, FRin, AddSub, Ain : STD_LOGIC ; Rin, Rout, X, Y : STD_LOGIC_VECTOR(0 TO 3) ; I : STD_LOGIC_VECTOR(1 DOWNTO 0) ; R0, R1, R2, R3, G, A, Sum : STD_LOGIC_VECTOR(7 DOWNTO 0) ; Func, FuncReg, Sel : STD_LOGIC_VECTOR(1 TO 6) ;

294

Reset

T0

w 1

FRin

T1

1 Rin = X, Extern, Done I=0

0

1 Rin = X, Rout = Y, Done

I=1 0

Ain, Rout = X T2 Gin, Rout = Y

1 I=2 AddSub = 0 0

AddSub = 1

T3 Gout, Rin = X, Done

Figura 8.48:

295

FSM_Transitions: PROCESS ( Clock, Resetn ) BEGIN IF Resetn = 0 THEN T <=T0; ELSIF Clock EVENT AND Clock = 1 THEN CASE T IS WHEN T0 => IF w = 0 THEN T <= T0 ; ELSE T <= T1 ; END IF ; WHEN T1 => IF I = "00" OR I = "01" THEN T <= T0 ; ELSE T <= T2 ; END IF ; WHEN T2 => T <=T3; WHEN T3 => T <=T0; END CASE ; END IF ; END PROCESS ; FSM_Outputs: PROCESS ( w, T, I ) BEGIN FRin <= 0 ; Rin <="0000" ; Rout <= "0000"; Done <= 0 Gin <= 0 ; Gout <= 0 ; Extern <= 0 ; Ain <= 0 ; AddSub <= 0 ; CASE T IS WHEN T0 => IF w = 1 THEN FRin <= 1 ; ELSE FRin <= 0 ; END IF ; WHEN T1 => Ain <= 1 ; -- non importa se viene caricato A -- quando non necessario IF I = "00" THEN Done <= 1 ; Rin <= X ; Rout <= "0000"; Extern <= 1 ; ELSIF I = "01" THEN Done <= 1 ; Rin <= X ; Rout <= Y ; Extern <= 0 ; ELSE Done <= 0 ; Rin <= "0000" ; Rout <=X ; Extern <= 0 ; END IF ; 296

WHEN T2 => Gin <= 1 ; Rout <=Y; IF I = "10" THEN AddSub <= 0 ; ELSE AddSub <= 1 ; END IF ; WHEN T3 => Gout <= 1 ; Rin <= X ; Done <= 1 END CASE ; END PROCESS ; Func <= F & Rx & Ry; functionreg: regne GENERIC MAP ( N => 6) PORT MAP ( Func, Resetn, FRin, Clock, FuncReg ) ; High <= 1 ;

I <= FuncReg(1 TO 2) ; decX: dec2to4 PORT MAP ( FuncReg(3 TO 4), High, X ) ; decY: dec2to4 PORT MAP ( FuncReg(5 TO 6), High, Y ) ; -- Nota: il valore di defalult del parametro GENERIC N e 8 -- per questo se non ce il GENERIC MAP viene preso il valore di defaut reg0: regne PORT MAP ( BusWires, Resetn, Rin(0), Clock, R0 ); reg1: regne PORT MAP ( BusWires, Resetn, Rin(1), Clock, R1 ); reg2: regne PORT MAP ( BusWires, Resetn, Rin(2), Clock, R2 ); reg3: regne PORT MAP ( BusWires, Resetn, Rin(3), Clock, R3 ); regA: regne PORT MAP ( BusWires, Resetn, Ain, Clock, A ) ; alu: WITH AddSub SELECT Sum <= A + BusWires WHEN 0 , A - BusWires WHEN OTHERS ; regG: regne PORT MAP ( Sum, Resetn, Gin, Clock, G ) ; Sel <= Rout & Gout & Extern ;

WITH Sel SELECT BusWires <= R0 WHEN "100000", R1 WHEN "010000", R2 WHEN "001000", R3 WHEN "000100", 297

G WHEN "000010", Data WHEN OTHERS; END Behavior ;

8.24 Semaforo
Progettare un circuito che controlli i semafori ad un incrocio. Il circuito genera le uscite G1,Y 1, R1 e G2,Y 2, R2. Queste uscite rappresentano gli stati di verde, giallo e rosso per ogni strada. Una luce accesa corrisponde a un segnale di uscita di valore 1. Le luci devono essere controllate nel modo seguente: quando G1 viene accesa deve rimanerlo per un periodo t1 e poi si spegne. Lo spegnimento di G1 deve provocare laccensione immediata di Y1 che dovrebbe rimanere accesa per un tempo t2 e poi deve essere spenta. Quando o G1 o Y 1 sono accese, R2 deve stare accesa e G2 e Y 2 devono essere spente. Spegnendo Y 1 si deve avere limmediata accensione di G2 per un tempo t1 . Quando viene spenta G2, Y 2 si deve accendere per un periodo t2 . Naturalmente, quando o G2 o Y 2 sono accese, R1 deve essere accesa e G1 e Y 1 spente. (a) Progettare la ASM chart che descriva il controllore dei semafori. Supporre che ci siano due down-counter, uno usato per misurare il ritardo t1e un altro per t2. Ogni contatore ha un ingresso di controllo per il caricamento parallelo e lenable. Questi ingressi sono usati per caricare un appropriato valore che rappresenti il ritardo t1 o t2 e che poi permetta al contatore di arrivare no a 0. (b) Progettare la ASM chart per il circuito di controllo del controllore dei semafori. (c) Scrivere il codice VHDL completo per il controllore dei semafori, incluso il circuito di controllo dalla parte (a) e i contatori per rappresentare t1 e t2. Usare una frequenza di clock opportuna e valori ragionevoli di conteggio per t1 e t2. Soluzione (a) La ASM chart richiesta e mostrata in gura 8.49. ` (b) Ognuno dei due contatori, C1 e C2, richiede lenable del clock e gli input di carico parallelo. Assumendo che i segnali di enable del clock siano EC1 ed EC2 e che gli input di carico parallelo siano LC1 e LC2, una tabella ASM per il circuito e la seguente mostrata in gura 8.50 ` (c) Il codice richiesto e ` LIBRARY ieee ; 298

Reset S1 C1 t1

S2 C1 C 1 1, G1, R2 C1 t1

1 0 C 1 = 0? 1 S5 C 2 t2 C2 C2 1, R1, Y2 0 C 2 = 0?

S3 C2 C2 1, Y1, R2 C 2 t2 1 0 C = 0? 2 0 1 S4 C1 t1 C1 C 1 1, R1, G2 C1 = 0?

Figura 8.49: USE ieee.std_logic_1164.all ; USE ieee.std_logic_unsigned.all ; ENTITY semaforo IS PORT ( Clock, Resetn : IN STD_LOGIC ; G1, Y1, R1 : OUT STD_LOGIC ; G2, Y2, R2 : OUT STD_LOGIC ) ; END semaforo ; 299

Reset S1 LC1

S2 EC1, G1, R2 LC1

1
0

zC1 1 S5
LC2

zC2

EC2, R1, Y2

S3
EC2, Y1, R2 LC2

0
zC2 zC1

1
S4
LC1 EC1, R1, G2

Figura 8.50:

ARCHITECTURE Behavior OF semaforo IS TYPE State_type IS ( S1, S2, S3, S4, S5 ) ; SIGNAL y : State_type ; 300

SIGNAL zC1, zC2, EC1, LC1, EC2, LC2 : STD LOGIC ; SIGNAL C1, C2, TICKS1, TICKS2 : STD LOGIC VECTOR(3 DOWNTO 0); BEGIN FSM_transition: PROCESS ( Clock, Resetn BEGIN IF Resetn = 0 THEN y <=S1; ELSIF Clock EVENT AND Clock = 1 CASE y IS WHEN S1 => y <=S2; WHEN S2 => IF zC1 = 0 THEN WHEN S3 => IF zC2 = 0 THEN WHEN S4 => IF zC1 = 0 THEN WHEN S5 => IF zC2 = 0 THEN END CASE ; END IF ; END PROCESS ; )

THEN

y y y y

<= <= <= <=

S2 S3 S4 S5

; ; ; ;

ELSE ELSE ELSE ELSE

y y y y

<= <= <= <=

S3 S4 S5 S2

; ; ; ;

END END END END

IF IF IF IF

; ; ; ;

FSM_outputs: PROCESS ( y, zC1, zC2 ) BEGIN G1 <= 0 ; Y1 <= 0 ; R1 <= 0 ; G2 <= 0 ; Y2 <= 0 ; R2 <= 0 ; LC1 <= 0 ; EC1 <= 0 ; EC2 <= 0 ; LC2 <= 0 CASE y IS WHEN S1 => LC1 <= 1 ; EC1 <= 1 ; WHEN S2 => EC1 <= 1 ; G1 <= 1 ; R2 <= 1 ; IF zC1 = 1 THEN LC2 <= 1 ; EC2 <= 1 ; ELSE LC2 <= 0 ; EC2 <= 0 ; END IF ; WHEN S3 => EC2 <= 1 ; Y1 <= 1 ; R2 <= 1 ; IF zC2 = 1 THEN LC1 <= 1 ; EC1 <= 1 ; ELSE LC1 <= 0 ; EC1 <= 0 ; END IF ; WHEN S4 => EC1 <= 1 ; R1 <= 1 ;G2 <= 1 ; IF zC1 = 1 THEN LC2 <= 1 ; EC2 <= 1 ; ELSE LC2 <= 0 ; EC2 <= 0 ; END IF ; WHEN S5 => EC2 <= 1 ; R1 <= 1 ;Y2 <= 1 ; 301

IF zC2 = 1 THEN LC1 <= 1 ELSE LC1 <= 0 ; EC1 <= 0 END CASE ; END PROCESS ; -- Costanti di setup TICKS1 <= "0011" ; -- 4 TICKS for C1 TICKS2 <= "0001" ; -- 2 TICKS for C2 -- Controllo per il conteggio degli zero zC1 <= 1 WHEN C1 = 0 ELSE 0 ; zC2 <= 1 WHEN C2 = 0 ELSE 0 ;

; EC1 <= 1 ; ; END IF ;

-- Si possono anche usare componenti down-counter CNT C1: PROCESS BEGIN WAIT UNTIL Clock EVENT AND Clock = 1 ; IF EC1 = 1 THEN IF LC1 = 1 THEN C1 <= TICKS1 ; ELSE C1 <= C1 - 1 ; END IF ; END IF ; END PROCESS ; CNT C2: PROCESS BEGIN WAIT UNTIL Clock EVENT AND Clock = 1 ; IF EC2 = 1 THEN IF LC2 = 1 THEN C2 <= TICKS2 ; ELSE C2 <= C2 - 1 ; END IF ; END IF ; END PROCESS ; END Behavior ;

8.25 Anti-rimbalzo
Supporre di aver bisogno di utilizzare un semplice interruttore on-off a due terminali come mostrato in gura 8.51. Illustrare come un contatore possa essere usato come un circuito anti-rimbalzo del segnale Data prodotto dallo switch. (Suggerimento: progettare una FSM che abbia Data come ingresso e produca luscita z, che e la versione senza rimbalzo di Data. Supporre di avere accesso a un se` gnale dingresso Clock con frequenza di 102.4kHz, che pu` essere usato dove o necessario).

302

V DD

Data

Figura 8.51: Soluzione Il circuito antirimbalzo e diviso in tre parti, come mostrato in gura 8.52. Il ` segnale Data dallo switch deve essere sincronizzato al segnale di102.4kHz utilizzando due ip-fop. Il segnale sincronizzato chiamato Sinc, deve essere inviato alla FSM. La FSM utilizza anche un contatore, che conta per 1024 cicli del segnale di 102.4kHz , generando un ritardo di 10ms.
1111111111 Sync Meta D Q D Q 10

Data

LC EC

L E

Down counter

102.4 KHz

Done

Figura 8.52:

303

La ASM chart del circuito e riportata in gura 8.53. La FSM ha come uscita ` z, che e la versione senza rimbalzo del segnale Data. `
Reset

S1 Z = 0, C 1023, LC 0 0 Sync 1 S2 Z = 1, C C 1, EC 1 S4 Z = 0, C

1 Done

C 1, EC

0 Sync

0 Done 1

Z = 1, C

1023, LC

Figura 8.53:

304

Capitolo 9 Memorie
9.1 Linee indirizzo e linee input-output
Le seguenti memorie sono classicate in base al numero di locazioni e al numero di bit per parola. Quante linee di indirizzo e di input-output dei dati sono necessarie per ogni caso? 1. 48K x 8 2. 512K x 32 3. 64M x 64 4. 2G x 1

Soluzione Si deniscono A e D il numero di linee di indirizzi e di dati rispettivamente. Mentre il numero di linee dati coincide ovviamente con il parallelismo della memoria, il numero di linee di indirizzo si ricava ricavando il numero di linee su cui e ` possibile effettuare la codica di tutte le locazioni richieste dalla memoria stessa. La tabella seguente mostra i valori attesi:

1) 2) 3) 4)

Tipo di memoria 48K x 8 512K x 32 64M x 64 2G x 1 305

A D 16 8 19 32 26 64 31 1

9.2 Decoder
Un chip di RAM 64K x 16 e realizzato con un array quadrato di celle elemen` tari ed e selezionato opportunamente dai decoder di riga e di colonna. Qual e la ` ` dimensione del decoder di riga e di colonna e quante porte logiche (AND) sono necessarie per decodicare un indirizzo? Soluzione Il numero complessivo di celle e 64K x 16 = 220 . Questo signica che la ` matrice di memoria sar` un quadrato di dimensioni 210 (gura 9.1). Il numero di a 10 mentre il numero di colonne da selezionare sar` pari a 26 . righe sar` pari a 2 a a Ogni colonna in realt` contiene una intera parola da 16 bit memorizzata. a
2
10

210

Figura 9.1:
1024

15 ADD 6 5 0

D E C

1024

16

16

Figura 9.2: 306

In conclusione i decoder da realizzare devono essere in grado di decodicare 1024 e 64 valori: Decoder di righe 210 10 bit 1024 Decoder di colonne 26 6 bit 64 Il circuito risultante e riportato in gura 9.2. `

9.3 Decoder (2)

Si supponga che il pi` grande decoder che si possa usare per decodicare riga e u colonna in un chip di RAM m x 1 abbia 14 bit di indirizzo e che sia impiegata la decodica su riga e colonna. 1. Qual e la dimensione massima ottenibile per ogni memoria m x 1? ` 2. Quanti chip ci vogliono per costruire una memoria di capacit` 2G x 1? a 3. Com` il circuito di decodica completo? e

Soluzione Dato che ogni decodica pu` gestire 14 linee di indirizzo, il numero totale o di linee, considerando sia la decodica diriga che di colonna, e pari a 28. Ne ` consegue che il numero massimo di locazioni indirizzabili vale 228 : 14 linee Row Column

228

Lorganizzazione dellarray di memoria con gli indirizzi di riga e di colonna e ` riportata in gura 9.3. Per sapere quanti circuiti integrati osno necessari per realizzare una memoria da 2 Giga, e sufciente dividere la capaci` richiesta per la ` a massima capacit` di ogni singolo chip: a numero di chip = 2G 231 = =8 228 228

Il circuito di decodica completo richiede che gli 8 chip vengano selezionati uno alla volta in funzione del contenuto di tre linee di indirizzo (A28 .....A30), oltre alle 28 necessarie per la decodica di ogni singolo circuito integrato. Il circuito di decodica nale richiede quindi un decoder 3-to-8 che pilota i segnali di chip enable (EN) delle decodiche di ogni singolo chip, come riportato in gura 9.4. 307

14

14
Figura 9.3:

A 30 A 29 A 28

S2 S1 S0

7 6 5 4 3 2 1

EN D E C 2
28

28

Figura 9.4:

9.4 DRAM - Locazioni

Una memoria DRAM ha 15 pin di indirizzo e la sua row address e 1 bit pi` lunga ` u della sua column address. Quante locazioni totali pu` avere la DRAM? o Soluzione Il numero totale di linee di indirizzo e 15 + 14 = 29, quindi il numero totale di ` 29 . locazioni indirizzabili singolarmente e 2 ` 215 214 = 229 = 512 MLocazioni 308

9.5 DRAM - Pin di indirizzo

Una memoria DRAM da 1G celle ha un parallelismo 4 bit e ha la row-address della stessa lunghezza della column-address. Quanti pin di indirizzo deve avere la DRAM? Soluzione Per prima cosa occorre denire quante locazioni ha la memoria; per questo basta dividere la capacit` per il parallelismo di parola (word). Questo porta ad a avere 256M locazioni indirizzabili da 28 bit. Dato che le due decodiche devono essere uguali, ogni decodica lavora su 14 pin. Ne consegue che i pin necessari per lindirizzamento completo sono 14: in ogni ciclo di memoria dapprima viene inviato il row address, e poi il column address. 1Gbit = 256 MAddress = 228 Address 214 Row e 214 Column 14 pin 4

9.6 DRAM - Refresh

Una memoria DRAM ha un intervallo di refresh di 128ms e ha 4096 righe. 1. Qual e lintervallo tra i cicli di refresh? ` 2. Qual e il tempo totale per il refresh se ogni ciclo di refresh impiega 60ns? ` 3. Qual e il minimo numero di pin di indirizzo della DRAM? ` 4. Qual e il tempo/perdita di efcienza della memoria a causa del refresh? `

Soluzione ` 1. E sufciente dividere lintervallo di refresh per il numero di righe della memoria, dato che in 128 ms occorre rinfrescare tutte le 4096 righe: 128ms = 31, 25s 4096 2. Il tempo totale usato dal refresh e pari al tempo di refresh di una riga per il ` numero di righe: 4096 60ns = 0, 25ms 309

3. 4096 = 212 righe sono indirizzabili con 12 linee: 4096 Righe 12 pin per il Row Address 4. La percentuale di tempo persa per il refresh si ottiene dividendo il tempo totale usato dal refresh per lintervallo di refresh (128ms): 0, 25ms = Perdita = 0, 00195 1, 9 128ms

9.7 Struttura memoria

1. Quanti chip di RAM 128K x 16 sono necessari per realizzare una memoria di 2 MB di capacit` ? a 2. Quante linee di indirizzo sono richieste per accedere ai 2 MB? Quante di queste linee sono connesse agli ingressi di indirizzo di tutti i chip? 3. Quante linee devono essere decodicate per generare i chip select (CS) per pilotare tutti i chip? Che tipo di decoder e necessario? ` Soluzione 1. La capacit` di 1 chip di RAM e 128K 16 = 2048Mb. Dato che il a ` parallelismo richiesto e 16 bit = 2B, ne consegue che il numero di circuiti ` integrati necessari e ` 2MB = 8 (2 MegaByte / 2Megabit) 2Mb 2. Accedendo a 2 byte per volta 2MB = 1M 220 20 linee. 2B Dato che tutti i chip hanno 128K locazioni, se ne deduce che sono necessarie 17 linee: 128K 217 17 linee 3. Si deve passare da 20 linee di indirizzo a 17 linee gestite da ogni singolo chip, dunque occorre un circuito che decodichi tre linee (20 - 17) per labilitazione degli 8 circuiti: 20 17 3 linee Decoder 3-to-8

310

9.8 Struttura memoria (2)

Utilizzando i chip di RAM 64K x 8 con pinout come in gura 9.5, costruire una RAM 512K x 16 utilizzando opportunamente dei decoder 3-to-8.

8 Data in

16 Address

Data out 8

CS

R/W

Figura 9.5:

Soluzione Dato che la memoria ha un parallelismo richiesto pari a 16, sono necessari 2 chip in parallelo. 2 chip in parallelo Per ottenere un numero di locazioni pari a 512K, sono necessari 8 circuiti abilitati da un decoder 3-to-8. Il circuito da realizzare e riportato in gura 9.6. ` 512K 512K = 8 chip e decoder 3-to-8 64K

311

DATA 0:7 ADD 0:15 ADD 0:15

DATA 8:15

A 18 A
17

S2 S1 S0

A 16

0 1 2 3 4 5 6 7

CS 0

CS

CS

CS 7

CS

CS

OUT 0:7
Figura 9.6:

OUT 8:15

312

Capitolo 10 Temi desame

10.1 Prova desame del 30-04-2009

` Quanto segue non e stato vericato completamente ma pu` essere utile come o traccia per la risoluzione. Esercizio 1 Si sintetizzi, utilizzando dei MULTIPLEXER a due vie, la funzione: f = X1 X2 X4 + X1 X 2 X 4 + X1 X3 X4 + X 3 X 4

Soluzione Utilizzando il teorema di espansione di Shannon, la funzione f pu` essere o riscritta nella forma: f = X4 (X1X2 + X1 X3 ) + X 4 (X1 X 2 + X 3 ) = X4 (X1(X2 + X3 )) + X 4 (X1 X 2 + X 3 ) ovvero, per poter sintetizzare la funzione con multiplexer a due vie: f = X4 (X1(X2 + X3 )) + X 4 (X1(X 2 + X 3 ) + X 3 ) In questo modo si pu` pensare di generare luscita f usando un livello di Mulo tiplexer a due vie controllato da X4 con a secondo livello una coppia di multiplexer, 313

X1 0 X3 X2 1 X4 0 f 1 "0" X1 0 1

Figura 10.1: sempre a due vie, controllati da X1 ). Il circuito risultante e riportato in gura in ` gura 10.1 . Esercizio 2 Per un sistema a microcontrollore con indirizzamento su 20 bit (A19 - A0 ) si realizzi una scheda di memoria SRAM di dimensioni 256K x 16 avendo a disposizione dei chip di memoria 64K x 8 come indicato in gura 10.2. Si supponga che le uscite Data out, di tipo 3-state, siano abilitate quando il segnale di lettura ` ` R/W e attivo a 1 e il chip di memoria e selezionato (CS = 1). La scheda deve rispondere nel range di indirizzi A19 - A0 = 10XX XXXX XXXX XXXX XXXX

Soluzione Nonostante con 20 bit di indirizzo sia possibile gestire una memoria di dimensioni superiori, per una SRAM 256K x 16 sono sufcienti log2 218 = 18bit. Avendo a disposizione blocchi di memoria da 64K 8 e possibile aumentare la lar` ghezza della singola locazione (parallellismo) mettendo due di questi blocchi in parallelo; cos` facendo si ottengono dei blocchi da 64K 16. Per raggiungere la 218 capacit` di memoria richiesta servono quindi 216 = 4 di questi macroblocchi. a Alla ne sar` quindi necessario impiegare 2 4 = 8 blocchi 64K 8 ciascuno dei a quali avr` in comune i seguenti segnali: a ADDR 15-0 da collegare agli ingressi Address 314

8 Data in

16 Address

Data out 8

CS

R/W

Figura 10.2: R \W che denisce se si stia facendo unoperazione di scrittura o di lettura nella generica memoria I restanti pin di ingresso sono collegati come riportato in gura 10.3. In particolare una colonna di chip e collegata ai segnali di dato DATA OU T (7 : 0) mentre ` laltra e collegata ai segnali di dato DATA OU T (15 : 8). ` La selezione delle 4 righe di memoria (le 4 coppie di circuiti integrati) avviene mediante un decoder 2-to-4 che e abilitato solo quando Add19 : 18 = 10 come ` richiesto dal testo. Le uscite del decoder vanno ai pin di CS delle memorie per abilitarne il funzionamento. Esercizio 3 Un circuito sincrono ha due ingressi XW ed una uscita impulsiva Z (di Mealy) che vale 1 solo se in corrispondenza degli ultimi due fronti di salita del clock si e ` vericata la situazione: XW = 00 (penultimo fronte) XW = 11 (ultimo fronte) Si progetti il circuito partendo dal diagramma a stati, utilizzando ip op di tipo D. Soluzione Il diagramma a stati e riportato in gura 10.4. `

315

DATA 158 DATA 07 ADD 015

R/W

8 Data in

8 Data in

16 Address

Data out 8

16 Address

Data out 8

CS

CS

R/W

R/W

8 Data in

8 Data in

16 Address

Data out 8

16 Address

Data out 8

CS

CS

R/W
Y3

R/W

Add17 Add16

B A G1

Y2 Y1 Y0

8 Data in

8 Data in

Add18 Add19

16 Address

Data out 8

16 Address

Data out 8

CS

CS

R/W

R/W

8 Data in

8 Data in

16 Address

Data out 8

16 Address

Data out 8

CS

CS

R/W

R/W

DATA OUT 70

DATA OUT 158

Figura 10.3:

316

Lassegnazione degli stati e molto semplice in quanto si tratta di due soli stati, ` per cui e sufciente una variabile di stato Y ; si assegna allo stato A: Y = 0 e allo ` stato B: Y = 1.
X=0 W=0/Z=0

11/0 01/0 10/0

00/0

01/0

01/0

01/0

Figura 10.4: Di conseguenza la tabella di transizione degli stati risulta: 00 0 1 1 1 x,w 01 11 0 0 0 0 10 0 0

mentre la tabella di uscita diventa: 00 0 0 x,w 01 11 0 0 0 1 10 0 0

0 1

Coprendo le mappe di Karnough nella forma SoP la variabile di stato futuro Y diventa Y = XW

mentre luscita varr` : a Z = XWY Il circuito nale rappresentante il cIrcuito realizzato con i ip op di tipo D e ri` portato in gura 10.5.

317

Si noti come si tratti di un circuito sequenziale strano nel senso che la variabile di stato Y non viene utilizzata nella rete combinatoria di stato futuro ma solo in quella di uscita. Ci` e dovuto alla semplicit` del diagramma a stati e al fatto che in o` a realt` e sufciente riconoscere una successione di due congurazioni di ingresso a` successive per attivare luscita Z.
Z

X D W CK Y

Figura 10.5: Esercizio 4 Si progetti, utilizzando la tecnica delle ASM Chart, un circuito digitale sincrono sul fronte di salita del clock CK ed in grado di realizzare il seguente algoritmo: Si prendono dallesterno 4 dati in ingresso di tipo SIGNED (in complemento a 2) su 8 bit che vengono memorizzati contemporaneamente in 4 registri RA, RB, RC e RD in corrispondenza dellattivazione del segnale DATA LOAD che arriva dallesterno, sincrono con il clock CK della macchina, e che rimane attivo per un colpo di clock. Dopodich in uscita si deve fornire, nello stesso e formato dei dati in ingresso (SIGNED su 8 bit), la somma dei 4 dati se non si sono vericati n overow (superamento massimo valore positivo) n underow e e (superamento massimo valore negativo), altrimenti occorre fornire in uscita RA in caso di overow o RD in caso di underow insieme alla coppia di segnali OV ERFLOW ERROR e U NDERFLOW ERROR attivi a 1 rispettivamente in caso di Overow e di Underow. Si supponga che in caso di errori multipli (pi` situazioni di Overow e Underu ow) venga memorizzato solo il primo evento di errore. La macchina parte non appena il segnale DATA LOAD e attivo, permettendo ` il caricamento dei dati. Il termine delle operazioni deve essere segnalato mediante un segnale di uscita END OPERATION. Alla ne delle operazioni la macchina deve restare in attesa di un altro fronte positivo di DATA LOAD prima di ripartire. In particolare si sviluppi: 318

a) Lo pseudocodice dellalgoritmo b) La ASM chart dellalgoritmo c) Il datapath e lASM chart del controllo d) Il codice VHDL dellintero sistema, denendo tutti i blocchi che vengono usati nel sistema a livello comportamentale.

Soluzione a) Lo pseudocodice dellalgoritmo e ` reg(0) <= A; reg(1) <= B; reg(2) <= C; reg(3) <= D; k <= 0; sum <= C; while(C<4 AND (NOT OVERFLOW) AND (NOT UNDERFLOW)) sum <= sum+reg(k); k=-k+1; end while; if(OVERFLOW) then sum <= reg(0); else if (UNDERFLOW) then sum <= reg(3); b) La ASM chart dellalgoritmo e riportata in gura 10.6. ` c) Il datapath in gura 10.7. d) LASM chart del controllo in gura 10.8. e ) Il codice VHDL dellintero sistema e ` LIBRARY ieee; USE ieee.std_logic_1164.all; ENTITY SUM4 IS PORT ( Clock, Data_Load, Reset : IN STD_LOGIC; End_Operation: OUT STD_LOGIC; RA,RB,RC,RD : IN STD_LOGIC_VECTOR(7 DOWNTO 0); SUM : BUFFER STD_LOGIC VECTOR(7 DOWNTO 0) ); END SUM4; 319

RST SUM_R<0 C<0

0 DATA_LOAD 1 DATA_LOAD

INIT

DONE

LOAD ALL

Output SUM

C>3

OVERFLOW

SUM<RA

UNDERFLOW

SUM<RD

0 SUM<SUM+R(C) C<C+1 OP

Execute ADD

Figura 10.6:

320

LA

RA 8 LOAD

LB

RB 8 LOAD

LC

RC 8 LOAD

LD

RD 8 LOAD

SEL1
8 8

ovf undrf

+
8

SEL 2
EN_COUNT EN_CNT CLR LSUM CLR_COUNT

8 LOAD
CLR

CLRSUM

CNT_OUT

SUM

Figura 10.7:

ARCHITECTURE RTL OF SUM4 IS TYPE STATO_T IS (RST, INIT, OP, DONE); SIGNAL A,B,C,D,MPX1,MPX2,S1: STD_LOGIC_VECTOR (7 DOWNTO 0); SIGNAL LA, LB, LC, LD, LSUM, SEL2, EN_COUNT, EN_COUNT, CLRSUM: STD_LOGIC; SIGNAL OVERFLOW_ERROR, UNDERFLOW_ERROR:STD_LOGIC; SIGNAL SEL1, CNT_OUT: STD_LOGIC_VECTOR(1 DOWNTO 0 ); SIGNAL STATO :STATO_T; --- Descrizione dei componenti usati a livello RTL -COMPONENT regne8 PORT ( Data_in: IN STD_LOGIC_VECTOR(7 DOWNTO 0); Data_out: OUT STD_LOGIC_VECTOR(7 DOWNTO 0); CK : IN STD_LOGIC; LOAD: IN STD_LOGIC); END COMPONENT; 321

RESET RST CLR_COUNT CLRSUM

DATA_LOAD

0 DATA_LOAD

DONE

LSUM INIT

LA LB LC LD

END_COUNT

OVERFLOW ERROR 0 OP

SEL1 = 0 LSUM

LSUM

UNDERFLOW ERROR 0 SEL1 = CNT_OUT EN_COUNT

SEL1 = 3 LSUM

Figura 10.8:

322

COMPONENT regne8_CLR PORT ( Data_in: IN STD_LOGIC_VECTOR(7 DOWNTO 0); Data_out: OUT STD_LOGIC_VECTOR(7 DOWNTO 0); CK : IN STD_LOGIC; LOAD: IN STD_LOGIC; CLEAR: IN STD_LOGIC); END COMPONENT; ----

etc....etc........ Tutti i componenti usati nel progetto

BEGIN TRANSITION_PROC: PROCESS(RESET, CLOCK) BEGIN IF (RESET=1) THEN STATO <= RST; ELSEIF (CLOCKEVENT AND CLOCK=1) THEN CASE (STATO) IS WHEN RST => IF (DATA_LOAD=1) THEN STATO <= INIT; ELSE STATO <= RST; END IF; WHEN INIT => IF ((END_COUNT=1 ) OR (OVERFLOW_ERROR=1 ) OR (UNDERFLOW_ERROR = 1)) THEN STATO <= DONE; ELSE STATO <= OP; END IF; WHEN OP => IF( (END_COUNT=1 ) OR (OVERFLOW_ERROR=1 ) OR (UNDERFLOW_ERROR = 1)) THEN STATO <= DONE; ELSE STATO <= OP; END IF; WHEN DONE => IF(DATA_LOAD=1) THEN STATO <= DONE; ELSE STATO <= RST; 323

END IF; END CASE; END IF; END PROCESS; OUTPUT_PROCESS: PROCESS (STATO, DATA_LOAD, OVERFLOW_ERROR, END_COUNT, UNDERFLOW_ERROR) BEGIN -Default LA <= 0;LB <= 0;LC <= 0;LD <= 0; LSUM <= 0;SEL2 <= 0;CLRSUM <= 0; EN_COUNT <= 0;CLR_COUNT <= 0; CASE (STATO) IS WHEN RST => -CLR_COUNT <= 1; CLRSUM <= 1; WHEN INIT => -LA <= 1;LB <= 1;LC <= 1;LD <= 1; IF (END_COUNT = 0) THEN IF (OVERFLOW_ERROR = 1)THEN SEL1 <= "00"; LSUM <= 1; ELSEIF (UNDERFLOW_ERROR = 1)THEN SEL1 <= "11"; LSUM <= 1; ELSE SEL1 <= CNT_OUT; EN_COUNT <= 1 END IF; END IF; WHEN OP => -IF (END_COUNT = 0) THEN IF (OVERFLOW_ERROR = 1)THEN SEL1 <= "00"; LSUM <= 1; ELSEIF (UNDERFLOW_ERROR = 1)THEN SEL1 <= "11"; LSUM <= 1; ELSE 324

WHEN DONE END CASE; END PROCESS;

SEL1 <= CNT_OUT; EN_COUNT <= 1 END IF; END IF; => LSUM <= 1

--Descrizione della -RegA: regne8 PORT MAP RegB: regne8 PORT MAP RegC: regne8 PORT MAP RegD: regne8 PORT MAP

netlist del circuito (RA, (RB, (RC, (RD, A, B, C, D, CLOCK, LA); CLOCK,LB); CLOCK, LC); CLOCK, LD);

Add8: Adder8 PORT MAP (MUX1,SEL, S1); Mpx1: Mpx_4way PORT MAP (A,B,C,D,SEL1,MPX1); Mpx2: Mpx_2way PORT MAP (MPX1, S1, SEL2, MPX2); RegSUM: regne_8_clr PORT MAP (MPX2, SUM, CLOCK, LSUM, CLRSUM); --etc....etc.... -END_COUNT <= SEL(1) AND SEL(0); END ARCHITECTURE; Esercizio 5 Nello schema di gura 10.30 il blocco f e realizzato con una LUT che imple` menta le seguenti funzioni: A = Q1 OR Q2 ; B = Q1 AND Q2; Si ipotizzi di avere la seguente tempistica: per i FF D : TCKQ = 6 ns (per entrambe le transizioni), TSU = 3 ns; per il FF JK : TCKQ = 2ns (per entrambe le transizioni) , TSU = 2 ns; per ogni inverter open-collector : TLH = 2 ns, THL = 1 ns;

325

Val Q1 D Q CK Q Q Q2 f B D Q Rpu A C J

Val S Q D

K R Q

Val

Figura 10.9: per la LUT: TLH = 3 ns, THL = 2 ns. Quale e la massima frequenza di clock con duty cycle 50% cui pu` funzionare ` o il circuito? Quale e il massimo tempo di hold dei ip op compatibile con il funziona` mento corretto del circuito? Soluzione Si devono distinguere 3 casi come in gura 10.10.

T_HL

T_LH

T_CYCLE

Figura 10.10:

1) THL D1 D2 :

T1 = TCKQ1 + TSU(D) = 6 ns + 3 ns = 9 ns

D1 JK: T2 = TCKQ1 + TLH(LUT ) + THL(INV ) + TSU(JK) = 6 ns + 3 ns + 1 ns + 2 ns = 12 ns THL = max(T1 , T2 ) = 12ns 2) TLH D2 D1 : TLH = T3 = 9ns 326 T3 = TCKQ2 + TSU(D) = 6 ns + 3 ns = 9 ns

3) TCYCLE D2 D3 : T4 =TCKQ2 + TLH(LUT ) + THL(INV ) + TSU(JK) = 6 ns + 3 ns +1 ns + 3 ns = 13 ns TCYCLE = T4 = 13ns Per determinare la massima frequenza di funzionamento di deve prendere il massimo tra il doppio di THL , TLH e il tempo di ciclo TCYCLE , ovvero: Tcycle min = max(2THL , 2TLH , TCYCLE ) = 24ns da cui fmax = 1 Tcycle min = 41.66MHz

Questa scelta nasce dal fatto di garantire un duty cycle pari a 0.5 (50% ) al clock di sistema. Esercizio 6 Si descrivano le differenze principali tra le memorie PROM, EPROM e FLASH.

10.2 Prova desame del 03-07-2009

` Quanto segue non e stato vericato completamente ma pu` essere utile come o traccia per la risoluzione. Esercizio 1 Si sintetizzi, utilizzando unicamente dei decoder 2-to-4 con Enable e porte OR, la funzione: f (x1 , x2 , x3 , x4 ) = m(0, 4, 6, 9, 12, 14).

Soluzione Dal testo dellesercizio estrapoliamo la seguente tabella di verit` : a

327

0 1 2 3 4 5 6 7 8 9 10 11 12 13 14 15

X1 X2 X3 0 0 0 0 0 0 0 0 1 0 0 1 0 1 0 0 1 0 0 1 1 0 1 1 1 0 0 1 0 0 1 0 1 1 0 1 1 1 0 1 1 0 1 1 1 1 1 1

X4 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1

f 1 0 0 0 1 0 1 0 0 1 0 0 1 0 1 0

La mappa di Karnough relativa alla tabella di verit` e riportata in gura 10.11. a`

X1 X2 X3 X4 00 01 11 10 00 01 11 10

1 1

1 1

1 1

Figura 10.11: Il circuito pu` essere realizzato con decoder 2-to-4 con Enable e una porta OR o come in gura 10.12: Il primo decoder viene utilizzato per selezionare uno degli enable dei quattro decoder posti a valle, in base alla combinazione degli ingressi X1 e X2. Questi decoder avranno tutti come ingressi X3 e X4 e le uscite per cui la funzione f e 1 ` sono collegate allingresso della porta OR.

328

X3 X4 En X3 X4 X1 X2 1 En 00 01 10 11 X3 X4 En X3 X4 En En

00 01 10 11

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

00 01 10 11

00 01 10 11

00 01 10 11

12 13 14 15

Figura 10.12: Esercizio 2 Si realizzi una memoria di capacit` 2Mbyte (2M x 8) avendo a disposizione a delle memorie SRAM 1Mbit x 4 del tipo indicato in gura 10.25. Il bus indirizzi del sistema dove occorre inserire la scheda di memoria e a 24 bit (A23-A0). Si ` supponga che le uscite Data out, di tipo 3-state, siano abilitate quando il segnale di lettura R/W e attivo a 1 e il chip di memoria e selezionato (CS = 1). La scheda ` ` deve rispondere nel range di indirizzi A23 - A0 = 100X XXXX XXXX XXXX XXXX XXXX ovvero i 2Mbyte sono allocati nello spazio di indirizzamento della macchina in cui i tre bit pi` signicativi dellindirizzo valgono 100. Ovviamente la memoria u non deve essere selezionata in nessuno degli altri casi.

329

4 Data in

20 Address

Data out 4

CS

R/W

Figura 10.13: Soluzione Si vuole ottenere una memoria da 2M x 8, avendo a disposizione memorie da 1M x 4. Si avr` pertanto bisogni di due memorie da 4 bit in parallelo per ottenere a il byte richiesto. Prendendo come riferimento la gura 10.14, ogni blocco ha 1milione di locazioni (1M), dunque 20 bit di ingresso dedicati alla selezione interna del blocco. Il segnale CS, se abilitato, permette di accedere alla coppia di chip che lavorano in parallelo, utilizzando ciascuno 4 bit di informazione. Il decoder 3-to-8 serve per abilitare i due banchi di memoria che risponderanno allindirizzo Add(23:21) = 100. Esercizio 3 Un circuito sincrono ha due ingressi IN e OUT ed una uscita FULL (di MOORE). Ad ogni fronte di salita del clock, la FSM campiona gli ingressi IN e OUT che si riferiscono alla condizione che in una stanza stia entrando una persona ` (IN=1) o stia uscendo una persona (OUT=1). E possibile che contemporaneamente una persona esca e unaltra entri (IN=OUT=1). Il circuito deve abilitare FULL = 1 non appena si verica la condizione che ci sono 3 persone nella stanza in modo da evitare che entrino altre persone. Si progetti il circuito partendo dal diagramma a stati, utilizzando ip op di tipo D. Soluzione 330

Data(1:4) Add(19:0)

4 Data in

Data(5:8)
Data out

4 Data in

20 Address

20 Address

Data out 4

Add(22)
2

0 1 2 3 4 5 6 7

CS

CS

Add(21)
1

R/W

R/W

Add(20)
0

Add(23)

En

Data(1:4) Add(19:0)

4 Data in

Data(5:8)
Data out

4 Data in

20 Address

20 Address

Data out 4

CS

CS

R/W

R/W

Data_out(1:4)

Data_out(5:8)

Figura 10.14: Il diagramma degli stati e mostrato in gura 10.15: ` La tabella degli stati relativa e: `

331

Stato Q1 0 0 1 1 0 0 1 1 0 0 1 1 0 0 1 1

Presente Q2 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1

Ingressi Stato In Out D1 0 0 0 0 0 0 0 1 1 0 1 1 1 0 0 1 0 0 1 1 0 1 1 1 0 0 1 0 0 0 0 1 1 0 1 1 1 0 0 1 0 0 1 1 1 1 1 1

Futuro D2 0 1 0 1 0 0 1 0 0 1 1 1 0 1 0 1

Reset In=0 Out=0 In=0 Out=0 In=0 Out=0 In=1 Out=0 In=1 Out=0 In=0 Out=0

In=1
Out=0

A/0
In=0 Out=1 In=0 Out=1

B/0
In=0 Out=1 In=1 Out=1

C/0
In=0 Out=1 In=1 Out=1

D/1

In=1 Out=0

In=1
Out=1

In=1 Out=1

Codifica Stati:

A=00

B=01 C=10 D=11

Figura 10.15:

332

Utilizzando la codica degli stati indicato in gura si pu` denire la rete di o stato futuro partendo dalle mappe di Karnough come in gura 10.16.

D1
Q1 Q2 In Out 00 01 11 10 00 01 11 10 In Out 00 01 Q1 Q2 00

D2

01

11

10

1 1 1 1 1

1 1 1
Figura 10.16:

1 1 1 1 1 1 1 1

11 10

Coprendo le mappe di Karnough si ottengono le seguenti funzioni booleane: D1 = Q1 In + Q1 Q0 + InOutQ0 + InOutQ1 D0 = Q0 In + InOutQ1 + InOutQ1 Q0 + OutQ0 La rete di uscita e semplice in quanto luscita FULL va a 1 solo nello stato ` D=11: FU LL = Q1 Q0 Il circuito nale e riportato in gura 10.17. ` Esercizio 4 Si progetti, utilizzando la tecnica delle ASM Chart, un circuito digitale sincrono sul fronte di salita del clock CK ed in grado di realizzare lalgoritmo della moltiplicazione di due numeri UNSIGNED con la tecnica delle somme e shift: si prendono dallesterno 2 dati in ingresso di tipo UNSIGNED su 8 bit che vengono memorizzati contemporaneamente in 2 registri RA (moltiplicando) e RB (moltiplicatore) in corrispondenza del primo fronte di clock dopo che un segnale esterno di START e andato a 1 per indicare che inizia loperazione. ` Lalgoritmo deve eseguire un loop dove ad ogni giro si prende un bit del moltiplicatore (RB) e si decide se sommare o meno al risultato parziale il valore del

333

Q1 IN Q1 Q0 Q0

D Q
IN OUT Q0 IN OUT Q1 IN Q0 IN OUT Q1 Clock

Q0

FULL

Q1

D Q
OUT Q0 IN OUT Q1 Q0 Clock

Q1

Figura 10.17: moltiplicando (RA) debitamente shiftato, realizzando cos` la tipica moltiplicazio ne seriale. Al termine della moltiplicazione si deve fornire sulluscita RC, di cui occorre denire il numero di bit corretto, il valore del risultato. Il termine delle operazioni deve essere segnalato mediante un segnale di uscita END OPERATION. Alla ne delle operazioni la macchina deve restare in attesa di un altro fronte positivo di START prima di ripartire. In particolare si sviluppi: a) Lo pseudocodice dellalgoritmo 334

Start

S0 Reset CTR Reset RC Reset RA

0 S 1 S1

LOAD RA LOAD RB

S2 SHIFT RIGHT RB S3 INC CTR RC <= RC + RA * RB_SHIFT_OUT SHIFT LEFT RA

0 CTR=8 1

Done
1 S=1 0

Figura 10.18:

335

b) La ASM chart dellalgoritmo c) Il datapath e lASM chart del controllo d) Il codice VHDL dellintero sistema, denendo tutti i blocchi che vengono usati nel sistema a livello comportamentale.

Soluzione

Lo pseudo codice e lasciato al lettore, essendo simile a quanto gi` visto a ` a lezione. La ASM chart dellalgoritmo e riportata in gura 10.18. ` Il codice VHDL e ` Library ieee; use ieee.std_logic_1164.all; use ieee.std_logic_unsigned.all; ENTITY Addshift IS PORT (s, clk, reset_n: IN STD_LOGIC; -- "s" sta per start DataA,DataB: IN STD_LOGIC_VECTOR(7 Downto 0); END_OPERATION: OUT STD_LOGIC; C: OUT STD_LOGIC_VECTOR(16 Downto 0) ); END ENTITY; ARCHITECTURE Behavior OF Addshift IS TYPE state_type IS (CB, LoadFSM, Shift, AddC, ShiftAB, SetDone); Signal y: state_type; Signal LoadA, ShA, LoadB, ShB, ResC, LoadC, ShC, Sel: STD_LOGIC; Signal A, SA, DataC: STD_LOGIC_VECTOR (15 Downto 0); Signal B: STD_LOGIC_VECTOR (15 Downto 0); BEGIN FSM_Evolution: Process(Clk) BEGIN IF Clkevent AND Clk=1 THEN 336

IF Reset_N=0 THEN y <= CB ELSE CASE y IS WHEN CB => if s=1 then y <=

LoadFSM else y <= CB;

endif; WHEN LoadFSM => y <= ShiftC; WHEN ShiftC => if B=0 then y <= SetDone elsif B(0)=0 then y <= AddC else y <= ShiftAB; endif; WHEN AddC => y <= ShiftAB; WHEN ShiftAB => y <= ShiftC; WHEN SetDone => y <= CB; end case; end if; end if; END PROCESS;

FSM_OUTPUTS: PROCESS(y) BEGIN LoadC <= 0; END_OPERATION <= 0; LoadA <= 0; LoadB <= 0; ShA <= 0; ShB <= 0; ShC <= 0; CASE y IS WHEN CB => WHEN LoadFSM => ResC <= 1; LoadA <= 1; LoadB <= 1; WHEN Shiftc => ShC <= 1; WHEN AddC => LoadC <= 1; WHEN ShiftAB => ShA <= 1; ShB <= 1; 337

WHEN SetDone => END_OPERATION <= 1; END CASE; END PROCESS; --Data Path RegA: PROCESS(Clk) BEGIN IF Clkevent AND Clk=1 THEN IF LoadA=1 THEN A <= 00000000&(DataA); ELSIF ShA=1 THEN A(0)=0; FOR i in 0 to 14 Loop A(i+1) <= A(i); END Loop; END IF; END IF; END PROCESS; RegB: PROCESS(Clk) BEGIN IF Clkevent AND Clk=1 THEN IF LoadB=1 THEN A <= 00000000&(DataB); ELSIF ShB=1 THEN B(15)=0; FOR i in 0 to 14 Loop B(i) <= B(i+1); END Loop; END IF; END IF; END PROCESS; DataC <= SA+B; END architecture;

In gura 10.19 e rappresentato il Datapath del circuito mente in gura 10.20 e ` ` riportato lASM chart del controllo

338

RA 8 0 LD_RB SHL_RB Clock 16 Reset_RA UP 8

Reset_RA LD_RA SHL_RA Clock

LSB

16

0
Clock

Count 8

EOP

16

+
16 16

LD_RC Reset_RA Clock

Figura 10.19: Esercizio 5 Nello schema di gura 10.21 i FF hanno le uscite Q inizializzate a 0. Si ipotizzi di avere la seguente tempistica: per i FF SR : TS,RQ = 3 ns (per entrambe le transizioni); per il FF JK : TCKQ = 6ns (per entrambe le transizioni) , TSU = 2 ns; per linverter: TLH = 2 ns, THL = 1 ns; Quale e la massima frequenza di clock con duty cycle 50% cui pu` funzionare ` o il circuito? Quali sono i massimi valori di hold ammessi per i ip op per non avere violazioni?

339

Start

S0 Rese_Ct<=1 Reset_RC<=1 Reset_RA<=1

0 S 1 Reset_C<=0 Reset_RA<=0 Reset_RC<=0 LD_RA<=1 LD_RB<=1 S1

S2 SHR_RB=1 S3 SHR_RB<=0 LD_RC<=1 SHL_RA<=1

0 EOP 1

Done
1 S=1

Figura 10.20:

340

Val A J

Val B S R Q C J

Val D

J CK

S Q

S Q

S Q

K R Q

K R Q

K R Q

Val

Val

Val

1
Soluzione

2
Figura 10.21:

Trattiamo il latch SR come un blocco combinatorio in quanto asincrono e consideriamo tutte le transizioni dei fronti contraddistinguendole con H (High) e L (Low). Numeriamo i tre ip op da sinistra a destra per poter denire i percorsi combinatori da analizzare. I percorsi e le transizioni sono: 1) 1->2 (H to L) = tCLKtoQ1 + tSU2 = 6 + 2 = 8ns 2) 1->3 (L to L) = tCLKtoQ1 + tSR + tSU3 = 6 + 3 + 2 = 11ns 3) 2->1 (H to L) = tCLKtoQ2 + tinvMax + tSU1 = 6 + 2 + 2 = 10ns 4) 2->3 (H to L) = tCLKtoQ2 + tinv + tSR + tSU3 = 6 + 2 + 3 + 2 = 13ns La fmax = 1/(2 13ns) = 38,46MHz, dal momento che t4 va moltiplicato per 2, dato che vogliamo il duty cycle del 50 per cento. Il tempo che ci interessa per non avere violazioni e t1>3 = 11ns; se il tempo di ` hold tH > 11ns, allora si verica una violazione che rende il circuito inutilizzabile. Esercizio 6 Si descrivano le principali tecniche costruttive delle interconnessioni interne ad una FPGA illustrandone vantaggi e svantaggi.

341

10.3 Prova desame del 07-09-2009

` Quanto segue non e stato vericato completamente ma pu` essere utile come o traccia per la risoluzione. Esercizio 1 Si sintetizzi, utilizzando unicamente delle porte NAND, la funzione: f (x1 , x2 , x3 , x4 ) = m(0, 4, 6, 9, 12, 14). Si sintetizzi poi la stessa funzione utilizzando solo porte NOR. Soluzione Dapprima si denisce la tabella di verit` della funzione al ne di sintetizzare a poi la funzione con porte NAND. Per questo si parte dalla rappresentazione della funzione booleana in somma di prodotti (SOP) e la si realizza sostituendo alle OR di livello dispari le NAND e alle AND di livello dispari altre porte NAND. La tabella di verit` e: a` x1 0 0 0 0 0 0 0 0 1 1 1 1 1 1 1 1 x2 0 0 0 0 1 1 1 1 0 0 0 0 1 1 1 1 x3 0 0 1 1 0 0 1 1 0 0 1 1 0 0 1 1 342 x4 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 f 1 0 0 0 1 0 1 0 0 1 0 0 1 0 1 0

Dalla tabella si ricava la mappa di Karnaugh di gura 10.22.

x1x2 x3x4 00 00 1 01 1 11 1 10 0

01

11

10

Figura 10.22:

X1

X2

X3

X4

Figura 10.23: La sintesi della mappa di Karnaugh come somma di prodotti (SOP) utile per la realizzazione con sole porte NAND e: ` f = x1 x3 x4 + x2 x4 + x1 x2 x3 x4 343

Figura 10.24: Il circuito derivante dalla mappa di Karnaugh e riportato in gura 10.23. ` Per sintetizzare la funzione con sole porte NOR si riscrive f come funzione 344

POS (prodotto di somme), coprendo gli zeri della mappa f = (x3 + x4 )(x1 + x4 )(x2 + x4 )(x1 + x2 + x4 )(x1 + x2 + x3 ) Per la realizzazione con porte NOR, partendo dalla forma POS si sostituiscono alle porte AND di livello dispari delle porte NOR e cos` pure per le porte OR di livello pari. , riportato in gura 10.24. Dal confronto delle due sintesi si vede come la copertura con delle NAND presenta un costo sensibilmente inferiore, in quanto con le NOR sono necessrie ben 13 porte a due e/o tre ingressi contro le 8 richieste con la copertura tradizionale degli uni e sentesi con NAND. Esercizio 2 Si realizzi una memoria di capacit` 3M x 12 avendo a disposizione delle mea morie SRAM 1Mbit x 4 del tipo indicato in gura 10.25. Il bus indirizzi del sistema dove occorre inserire la scheda di memoria e a 24 bit (A23-A0). Si sup` ponga che le uscite Data out, di tipo 3-state, siano abilitate quando il segnale di ` ` lettura R/W e attivo a 1 e il chip di memoria e selezionato (CS = 1). La scheda deve rispondere nel range di indirizzi a partire da A23 - A0 = 10XX XXXX XXXX XXXX XXXX XXXX
4 Data in

20 Address

Data out 4

CS

R/W

Figura 10.25: ovvero la memoria e allocata nello spazio di indirizzamento della macchina in ` cui i due bit pi` signicativi dellindirizzo valgono 10. Ovviamente la memoria u non deve essere selezionata in nessuno degli altri casi. Discutere cosa succede quando viene inviato lindirizzo A23 - A0 = 1011 XXXX XXXX XXXX XXXX XXXX 345

D11:D8
Dati OUT

D7:D4
Dati Add CS R/W OUT

D3:D0
Dati Add CS R/W OUT

A19:A0

Add CS R/W

Dati

OUT

Dati Add CS R/W

OUT

Dati Add CS R/W

OUT

A21 A20

00 01 10 11 EN

Add CS R/W

Dati Add CS R/W

OUT

Dati Add CS R/W

OUT

Dati Add CS R/W

OUT

00

A23 A22
EN

01 10 11

D11:D8
R/W

D7:D4

D3:D0

Figura 10.26: Soluzione Il circuito nale e riportato in gura 10.26. Ovviamente quando i bit pi` si` u gnicativi valgono 1011 la memoria non viene selezionata, in quanto luscita del decoder di peso 11 non e collegata ad alcun banco. ` Esercizio 3

346

Un circuito sincrono ha due ingressi X e Y ed una uscita U (di MOORE) . Ad ogni fronte di salita del clock, la FSM campiona gli ingressi X e Y. Luscita U deve assumere il valore 1 in corrispondenza del terzo di tre impulsi di sincronizzazione (clock) consecutivi in corrispondenza dei quali si sia vericata la situazione X = Y . Si progetti il circuito partendo dal diagramma a stati, utilizzando ip op di tipo D. Soluzione

Descrizione archi: XY

00/11
01/10 01/10 01/10

01/10

A/0
00/11

B/0
00/11

C/0

D/1

00/11

Figura 10.27: Il diagramma degli stati relativo alla macchina proposta e riportato in gura ` 10.27 in cui si vede come luscita U sia attiva solo nello stato D. La tabella con lassegnazione degli stati e riportata di seguito ` Stato presente A B C D Stato futuro Uscita 00 01 10 11 U A B B A 0 A C C A 0 A D D A 0 A D D A 1

347

Dal diagramma degli stati si ricava la tabella degli stati che fa uso di due variabili di stato y1 e y2 dato che ci sono 4 stati diversi da coprire. La tabella delle transizioni e `

Stato presente y2 0 0 1 1 y1 0 1 0 1 00 Y2Y1 00 00 00 00

Stato futuro Uscita 01 10 11 U Y2Y1 Y2Y1 Y2Y1 01 01 00 0 10 10 00 0 11 11 00 0 11 11 00 1

X Y

Y1

D Q Q

y1

Y2

D Q Q

y2

Clk

Figura 10.28: La rete di stato futuro si ottiene coprendo le mappe di Karnaugh relative alle due variabili di stato futuro Y1 e Y2 . Le equazioni risultanti sono Y 2 = XY (y1 + y2) + XY (y1 + y2 ) = (x y)(y1 + y2 ) Y 1 = XY (y1 + y2) + XY (y1 + y2 ) = (x y)(y1 + y2 ) mentre lequazione delluscita U vale U = y1 y2 348

Su queste ipotesi il cicuito nale che realizza quanto richiesto e riportato in ` gura 10.28. Esercizio 4 Si progetti, utilizzando la tecnica delle ASM Chart, un circuito digitale sincrono sul fronte di salita del clock CK ed in grado di realizzare in seguente algoritmo: Si prendono dallesterno 3 dati in ingresso di tipo STD LOGIC VECTOR su 8 bit che vengono memorizzati contemporaneamente in 3 registri RA, RB e RC in corrispondenza del primo fronte di clock dopo che un segnale esterno di START e ` andato a 1 per indicare che inizia loperazione. Per ogni dato si deve calcolare il numero di uni presenti e si deve fornire in uscita il dato con il massimo numero di uni nonch lindicazione, su due bit e INDEX[1:0], di quale sia il dato in questione ( 00 se RA, 01 se RB, 10 se RC) . Nellipotesi che due o piu dati abbiano lo stesso numero di bit a uno si segnali in uscita il registro con codice a due bit INDEX pi` grande (vuol dire che se ad u esempio RA e RC hanno lo stesso numero di uni codico in uscita RC, e cos` via). Il termine delle operazioni deve essere segnalato mediante un segnale di uscita END OPERATION. Alla ne delle operazioni la macchina deve restare in attesa di un altro fronte positivo di START prima di ripartire. In particolare si sviluppi: a) Lo pseudocodice dellalgoritmo b) La ASM chart dellalgoritmo c) Il datapath e lASM chart del controllo d) Il codice VHDL dellintero sistema, denendo tutti i blocchi che vengono usati nel sistema a livello comportamentale.

Soluzione a) Lo pseudo codice dellalgoritmo e ` Q_a=0; Q_b=0; Q_c=0; FOR i=0 to 7 349

RESET

S1 QA<0 QB<0 QC<0

Q<0 END_OP<0

U<0

0 START

S2 SHIFT DX A SHIFT DX B SHIFT DX C Q<Q+1 QA<QA+1 QB<QB+1 QC<QC+1

0 1
A=1? B=1? C=1?

0
START

Q=7

S6

END_OP< 1

00

INDEX

10

01
S3 U < QA S4 U < QB S5 U < QC

Figura 10.29: if RA_{i}=1 if RB_{i}=1 if RC_{i}=1 END LOOP; THEN THEN THEN Q_a=Q_a+1; Q_b=Q_b+1; Q_c=Q_c+1;

350

if ((Q_a>Q_b) THEN if & (Q_a>Q_c)) THEN U=Q_a ; INDEX = 00 ; else U=Q_c ; INDEX = 10 ; elseif (Q_b>Q_c) U= Q_b ; INDEX = 01; else U=Q_c ; INDEX = 10 ;

b) La ASM chart dellalgoritmo e riportata in gura 10.29 ` Esercizio 5 Nello schema di gura 10.30, i FF hanno le uscite Q inizializzate a 0. Si ipotizzi di avere la seguente tempistica: per i FF SR : TS,RQ = 4 ns (per entrambe le transizioni); per il FF JK : TCKQ = 5ns (per entrambe le transizioni) , TSU = 2 ns; per linverter: TLH = 2 ns, THL = 3 ns; Quale e la massima frequenza di clock con duty cycle 50% cui pu` funzionare ` o il circuito? Quali sono i massimi valori di hold ammessi per i ip op per non avere violazioni?

Val A J

Val B S R Q C J

Val D

J CK

S Q

S Q

S Q

K R Q

K R Q

K R Q

Val

Val

Val

Figura 10.30:

351

Soluzione

Per il calcolo della frequenza massima di clock con duty cycle del 50% consideriamo i ritardi massimi tra le diverse porte JK. Dal primo al secondo FF JK = t1 = TClkQ + TSU = 5 + 2 = 7ns Dal primo al terzo FF JK = t2 = TClkQ + THL + TSU = 5 + 3 + 2 = 10ns Dal secondo al terzo FF JK = t3 = TClkQ + THL + TSRQ + TSU = 5 + 3 + 4 + 2 = 14ns Dal terzo al primo FF JK = t4 = TClkQ + TSU = 5 + 2 = 7ns I tempi calcolati precedentemente si riferiscono a diverse condizioni da valutare e sono riportati in gura 10.31. In particolare il tempot1 si riferisce allintervallo che va dal fronte di discesa del clock a quello di salita, t2 e t4 al tempo necessario per effettuare un intero ciclo, mentre t3 si riferisce allintervallo dal fronte di salita del clock a quello di discesa immediatamente successivo.

Figura 10.31: Il tempo t3 (dal secondo al terzo FF JK) e il peggiore in assoluto ` = t3 = (5 + 3 + 4 + 2)ns = 14ns e siccome si riferisce ad un semi-periodo e da moltiplicare per 2 per avere il ` tempo di ciclo minimo con duty cycle del 50%. Dunque si avr` a fMAX =
1 2t3

1 28ns

35.7Mhz

352

Se il tempo di hold tH > 14ns nellipotesi di lavorare alla frequenza massima si avranno violazioni allingresso del terzo ip op. Esercizio 6 Si descrivano le memorie RAM dinamiche, evidenziandone il funzionamento, gli ingressi/uscite e la tempistica.

353