Esercitazioni di Sistemi Elettronici Digitali

Selezione e risoluzione esercizi a cura del Prof. Maurizio Zamboni

Traduzione e impaginazione con l’ausilio 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

. . . . . .

. . . . . .

. . . . . .

. . . . . .

. . . . . .

. . . . . .

. . . . . .

. . . . . .

. . . . . .

. . . . . .

. . . . . .

2

. . . . . . . . . . .

. . . . . . . . . . .

. . . . . . . . . . .

. . . . . . . . . . .

. . . . . . . . . . .

. . . . . . . . . . .

. . . . . . . . . . .

. . . . . . . . . . .

. . . . . . . . . . .

. . . . . . . . . . .

. . . . . . . . . . .

. . . . . . . . . . .

. . . . . . . . . . .

. . . . . . . . . . .

. . . . . . . . . . .

. . . . . . . . . . .

3

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 . . . .

. . . . .

. . . . .

. . . . .

. . . . .

. . . . .

. . . . .

. . . . .

. . . . .

. . . . .

. . . . .

. . . . .

. . . . .

. . . . .

4

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 Overflow . . . . . . . . . . . . . . . . . . . . . . . . . . . . 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 grafica 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-flop SR sincrono con flip-flop di tipo D . . 6.2 Latch SR Set- Dominant . . . . . . . . . . . . 6.3 Flip flop MS a set dominante . . . . . . . . . . 6.4 Flip flop MS a Set dominante - verifica . . . . . 6.5 Flip flop 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 flip flop T . . . . . . . . . . . . . . . . 6.11 JK negative-edge-triggered . . . . . . . . . . . 6.12 Confronto tra circuiti con flip flop . . . . . . . 6.13 Flip flop D negative edge triggered . . . . . . 6.14 Flip-flop di tipo D . . . . . . . . . . . . . . . . 6.15 Confronto tra diversi tipi di flip-flop D e latch . 6.16 Flip-flop 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 verifica . . . . . . . . 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 flip flop . . . . . . . . . . . . . Up/Down counter con flip flop T . . . . . . . . . . . . Up/Down counter con flip flop 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 flop T . . . . . . . . . . . . . . . . . . . . . . . . 7.2 VHDL - Flip flop 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

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

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

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

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

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

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

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

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

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

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

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

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

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

9

. . . . . . . .

. . . . . . . .

. . . . . . . .

. . . . . . . .

. . . . . . . .

. . . . . . . .

. . . . . . . .

. . . . . . . .

. . . . . . . .

. . . . . . . .

. . . . . . . .

. . . . . . . .

. . . . . . . .

. . . . . . . .

. . . . . . . .

. . . . . . . .

5

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

6

1 Copertura mappe di Karnough Progettare un circuito digitale che abbia tre ingressi. Soluzione La tabella di verit` della funzione f che rappresenta l’uscita 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 7 . x1 . in u caso contrario l’uscita deve essere a 0.Capitolo 1 Algebra Booleana . x2 e x3 e che produca come uscita il valore 1 se due o pi` variabili d’ingresso assumono il valore 1.Circuiti Combinatori di base 1.

PoS) sia nella forma Somma di Prodotti (Sum of Products . 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 . 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. x2 e x3 e che produca come uscita il valore 1 se esattamente una o due variabili in ingresso assumono il valore 1.x3 x1 .SoP). 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 . in caso contrario l’uscita deve essere a 0. Si calcoli la funzione sia nella forma Prodotto di Somme (Product of Sums .2 Copertura mappe di Karnough Determinare la funzione logica f di un circuito che abbia tre ingressi.

si deriva in modo esaustivo la seguente tabella di verit` : a 9 .3 Copertura con Sum of Product (SoP) Dalla figura seguente (fig. x2 . supposto combinatorio.1) che rappresenta il comportamento nel tempo del circuito combinatorio da analizzare. x1 x2 x3 f 1 0 1 0 1 0 1 0 Time Figura 1.1: Soluzione Dalla forma d’onda proposta che rappresenta il comportamento del circuito. sintetizzare la funzione f (x1 . x3 ) nella forma “SoP”. 1.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.

x3 ) nella forma pi` semplice di Somme di Prodotti “SoP”.4 Copertura con Sum of Product Si consideri il diagramma temporale riportato in figura 1. 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.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 . u Soluzione Dalla forma d’onda riportata in figura 1.2 e si sintetizzi la funzione f (x1 .2 si deriva la tabella di verit` : a 10 .

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 .x1 x2 x3 f 1 0 1 0 1 0 1 0 Time Figura 1.

1. x2 . 6. 3. 7). 4. 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. disegnare il circuito pi` eleu mentare che la implementi utilizzando solo porte NAND. x3 ) = Σ m(1.5 Sintesi con porte NAND Data la funzione f (x1 .3: f 12 . 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 .

3: ` Se si utilizza la tecnica di sintesi con solo porte NAND si deve ricordare che l’OR del primo livello e’ realizzabile con una NAND.4: f La sintesi della funzione logica f nella forma SoP e riportata in figura 1.La funzione booleana f risultante e ` f = x1 x3 + x1 x2 + x1 x3 x1 x2 x3 Figura 1. come pure le funzioni AND di secondo livello (vedi teoria).4 1. In questo caso la realizzazione e quella riportata ` in figura 1.6 Sintesi con porte NOR Ripetere l’esercizio 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 .

come riportato in figura 1.5: f x1 x2 x3 Figura 1.6: ` f 14 .6: Utilizzando la sintesi con solo porte NOR si deve considerare che l’AND di primo livello e realizzabile con un NOR come pure le porte OR di secondo livello ` (vedi teoria).La soluzione tradizionale prevede un AND di termini OR di secondo livello. la soluzione e riportata in figura 1.5: x1 x2 x3 Figura 1.

1: f Soluzione Il metodo delle trasformazioni richiede. 3 e 4 ingressi.1 usando il metodo delle trasformazioni supponendo di avere a disposizione solo inverter e NAND a 2. A B C D E F Figura 2.1 Sintesi con porte NAND Mappare unicamente con blocchi logici di tipo NAND il circuito riportato nella figura 2.Capitolo 2 Sintesi dei Circuiti Combinatori di Base 2. nel caso proposto. di trasformare dapprima le porte logiche di tipo OR in porte NAND con gli ingressi negati (logica- 15 .

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). ottenendo il circuito di figura 2. Se ne deduce che il circuito pu` essere trasformato come in figura 2.mente equivalenti) mentre le porte AND si trasformano in NAND seguiti da un inverter.2. Soluzione La prima cosa da fare e derivare la tabella di verit` della funzione: ` a 16 .2: Successivamente si eliminano le serie di due inverter non inglobabili nelle porte NAND.3: 2. o A B C D f E F Figura 2.

w2 00 01 11 0 1 1 1 1 0 1 0 w3 10 0 0 La scelta della copertura mediante multiplexer richiede di definire una variabile (se si usano MPX 2-to-1) di controllo o selezione del multiplexer e definire le funzioni logiche relative agli ingressi del multiplexer stesso.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 l’uso di multiplexer.A B C f D E F Figura 2. a w1 . 17 .

15) con un MPX 4-to-1 e porte logiche elementari.C. Soluzione Come al solito la prima cosa da fare e predisporre la tabella di verit` della ` a funzione F: 18 . 11. 2. B. D) = Σ m(1. 12. riportato in figura. w2 0 f w3 1 w1 Figura 2. 14.3 Multiplexer 4-to-1 Implementare la funzione F(A. 3.Dall’analisi 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 l’uscita sia esprimibile e come m = w2 + w3 mentre per le ultime 4 linee con w1 a 1 l’uscita e definita dalla ` funzione n = w2 w3 . Collegare A e B alle linee di selezione del MPX. 4.4: 2.4 sar` composto dal a MPX a due vie e dalle porte logiche che realizzano le due sotto-funzioni m e n. Ne consegue che il circuito finale. 13.

Il circuito risultante e in ` figura 2.5. 2.A3 Interconnettere i due MPX in modo da minimizzare la logica richiesta per la selezione dei dati da 0000 a 1110. per cui occorre definire le funzioni logiche aggiuntive Fi da realizzare sui 4 ingressi del MPX nelle varie combinazioni delle variabili di selezione. Soluzione La tabella di verit` prevede che l’indirizzo A3 discrimini quando far passare i a dati D0 .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 . 19 .... D7 (A3 = 0) dai dati D8 .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).. funzione delle variabili C e D. D14 (A3 = 1). Queste funzioni devono essere implementate con porte logiche esterne.. Le variabili da considerare sono ovviamente C e D per cui definiamo nei 4 casi la funzione Fi .

` 20 . anche A3 per discriminare tra gli ingressi Di e l’uscita di MPX1. mentre i restanti 7 dati (D8 . D14 * # Se A3 = 0 passa in uscita * mentre se A3 = 1 passa #. La selezione di MPX1 e affidata ai bit meno significativi dell’indirizzo di sele` zione A0 . Il circuito risultante e riportato in figura 2.D14 ) sono collegati al secondo MPX (MPX2) che ha ancora un ingresso di dato libero che sar` collegato all’uscita di a MPX1. occorre quindi usare due multiplexer a 8 vie (MPX 8-to-1).. .D7 ). .6. 0 1 .A2 ..5: A3 0 . . D7 D8 . mentre la selezione di MPX2 deve considerare. oltre agli stessi tre bit di indirizzo.. 1 B D0 . . . .C D 00 01 F 10 11 V DD S1 S2 A Figura 2. . . La soluzione migliore consiste nel collegare al primo MPX (MPX1) i primi 8 dati (D0 .

w2 . la scelta non e particolarmente critica. Soluzione La funzione f da sintetizzare vale f (w1 . w3 ) = Σ m(0. w2 .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. Ipotizziamo di selezionare w1 come variabile di riferimento. 2. 6). w3 ) = w1 w2 w3 + w1 w2 w3 + w1 w2 w3 + w1 w2 w3 Utilizzando il teorema di espansione di Shannon si deve dapprima identificare la variabile di riferimento e definire successivamente i due cofattori relativi.6: 2. in caso differente. In questo caso. occorre valutare ` 21 . utilizzare il teorema dell’espansione di Shannon per derivare un circuito con un multiplexer a due vie ed altre porte logiche. 3. dato che in tutti e 4 i minterm della funzione sono presenti tutte le variabili booleane.5 Espansione di Shannon Data la funzione f (w1 .

w2 . ` Il circuito risultante e in figura 2.7: 22 . w3 )w1 + fw1 (0. w2 . w2 . Con la scelta di w1 . w3 )w1 con fw1 (1. dove la variabile di riferimento e usata come selezione.7. ` ′ ′ ′ ′ w 2 0 f w 3 1 w 1 Figura 2. w2 . w3 ) = w2 w3 + w2 w3 + w2 w3 = w3 + w2 w3 = (w2 + w3 ) Il risultato dell’espansione e quindi: ` f = w1 (w2 w3 ) + w1 (w2 + w3 ) L’uso del teorema di Shannon permette di sintetizzare la funzione con un multiplexer. w3 ) = w2 w3 e con fw1 (0.la complessit` dei cofattori per ogni variabile di riferimento per la scelta della a soluzione a costo minimo. la funzione f diventa: f = fw1 (1.

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.2.6 Espansione di Shannon Ripetere l’esercizio precedente per realizzare la funzione f (w1 . w3 ) = Σ m(0. w3 ) = w1 w3 + w1 w3 = w1 ′ f (w1 . w2 . w2 . calcoliamo tutti i cofattori relativi ad ogni variabile per poter scegliere la soluzione a costo minimo: w1 w2 w3 f (1. Il circuito e in figura 2. 7). 6. 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. w2 . 1. w3 ) = w2 w2 + w2 w3 + w2 w3 ′ f (0. 1) = w1 w2 ′ f (w1 .8: 23 . w2 . 4. w3 ) = w1 w3 + w1 w3 = w3 ′ f (w1 .8 ` w3 0 f w1 1 w2 Figura 2. 0. w3 ) = w2 w3 ′ f (w1 .

w2 .7 Sintesi con Decoder Mostrare come la funzione f (w1 . 2. 7) possa essere implementata utilizzando un decoder binario 3-to-8 e porte logiche OR. 5. 4.8 Sintesi multiuscite con Decoder Un circuito combinatorio e definito dalle tre seguenti funzioni Booleane: ` F1 = X + Z + XY Z F2 = X + Z + XY Z F3 = XY Z + X + Z 24 . 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. w3 ) = Σ m(0.9. che nel nostro caso sar` sempre abilitato (E = 1).9: 2. 3.2. Il circuito finale e riportato in figura 2. ` w1 w2 w3 A2 A1 A0 0 1 2 3 f 4 5 6 1 EN 7 Figura 2. Soluzione La soluzione con decoder richiede che le variabili wi siano usate come variabili di ingresso del decoder.

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 (figura 2.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 .10).10: 25 . 0 1 X A2 2 3 Y A1 4 5 Z A0 6 7 F3 F2 F1 Figura 2.

scegliamo w2 come varabile di riferimento. Definire la tavola di verit` implementata all’interno di ogni LUT. trovare un circuito che implementi f utilizzando il numero minimo di circuti Look-Up-Table LUT a 2 ingressi. lavorando come delle tabelle che realizzano la tavola di verit` a “programmata” al loro interno. Ne consegue allora: 1 0 f = fw2 (w1 . 1. mentre la seconda (LUT2) realizza la funzione f . w2 ) Le tavole di verit` delle due LUT sono a 26 . w2 ) f = ξ(g. LUT L1 : LUT L2 : g = f (w1 . Data la funzione.9 Sintesi con LUT a due ingressi Data la funzione f = w1 w2 + w2 w3 + w1 w2 w3 . Per questo e utile utilizzare il teorema di espansione di Shannon per definire le funzioni ` intermedie utili per la sintesi.2. 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. a Soluzione Le LUT sono dei circuiti logici in grado di esprimere qualunque funzione logica degli ingressi. 0. w3 )w2 + fw2 (w1 . dato che compare in ogni minterm. occorre definire funzioni ` di due variabili da implementare lele LUT e comporle opportunamente. Dato che la funzione f e composta da tre variabili.

11.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 finale e riportato in figura 2. 6.11: 2. w3 . 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 l’espansione di Shannon conviene fattorizzare w2 come variabile di riferimento dato che compare in tutti i minterm della funzione. 9.10 Sintesi con LUT a tre ingressi Data la funzione f (w1 . 14. ` w1 L1 w3 g L2 f w2 Figura 2. 3. w4 ) = Σ m(0. derivarne un’implementazione utilizzando il minimo numero possibile di LUT a tre ingressi. w2 . Esprimiamo quindi f nel modo seguente 0 1 f = w2 fw2 + w2 fw2 27 . 1. 8. 15).

In figura 2. la prima delle quali serve per realizzare la funzione g. La seconda LUT e sottoutilizzata dato che l’esercizio richiede di utilizzare LUT a tre ingressi ` mentre solo due di essi sono utilizzati per g e w2 .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 dell’altro.11 Sintesi con Blocchi MPX-based Alcuni produttori di circuiti logici programmabili producono FPGA che hanno il blocco logico multiplexer-based illustrato in figura 2. ` w1 w3 w4 LUT g w2 LUT f Figura 2. In realt` si tratta di casi reali a dove nei circuiti programmabili tutte le LUT sono solitamente di uguali capacit` a e dimensione. mentre la seconda realizza la funziona f .12: 2.12 e riportato lo schema. Mostrare come la funzione f = w2 w3 + w1 w3 + w2 w3 possa essere implementata utilizzando un solo blocco logico del tipo illustrato. la funzione f si pu` esprimere cos`: o ı f = w2 g + w2 g Per sintetizzare la funzione sono sufficienti due LUT. 28 .13 come blocco base per i circuiti combinatori.

13: Soluzione Scegliamo w3 come variabile di controllo dell’espansione di Shannon della funzione f e utilizziamola per pilotare il MPX pi` vicino all’uscita: u 1 0 f = fw3 w3 + fw3 w3 w2 1 0 w1 1 Figura 2.i1 i2 i3 i4 i5 i6 i7 i8 f Figura 2.14: con i due fattori 1 fw3 = w1 + w2 0 fw3 = w2 29 .

15. w3 0 w2 0 1 w2 1 w1 0 1 Figura 2.15: Il circuito finale risulta quindi come riportato in figura 2.16: 0 1 0 1 30 . realizzando le funzioni riportate nelle figure 2.14 e 2. w2 0 0 1 1 Figura 2.I due cofattori sono realizzati con i multiplexer restanti.16.

1.Capitolo 3 Fondamenti di VHDL 3. o e che e stato ricavato usando il metodo della scomposizione.1 VHDL . ` 31 .Descrizione di funzioni booleane Scrivere il codice VHDL che implementi la funzione booleana f identificata 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 figura 3.

32 .all. 3. BEGIN g <= x1 OR x2 OR x3. : IN STD_LOGIC. x4 f END f_g_h. Il codice e riportato di seguito: ` LIBRARY ieee. k : STD_LOGIC.x1 x2 x5 x3 g f k x4 Figura 3. USE ieee. END LogicFunc.1: Il codice VHDL prodotto non fa altro che replicare le porte logiche costituenti la funzione f . : OUT STD_LOGIC). ENTITY f_g_h IS PORT ( x1. x3.Sintesi con porte NAND Scrivere il codice VHDL che implementi il circuito riportato in figura 3. f <= (k AND g) OR (NOT k AND NOT g).2 VHDL . usando le funzioni d’appoggio g e k.2 e realizzato con porte logiche AND e OR.std_logic_1164. ARCHITECTURE LogicFunc OF f_g_h IS SIGNAL g. x2. utilizzando solamente porte logiche di tipo NAND. k <= (NOT x3 AND x4) OR (x3 AND NOT x4).

3: f Prima di procedere con la scrittura del codice VHDL. le due porte AND intermedie non o sono trasformate mediante l’aggiunta delle coppie di porte NOT in uscita dato che l’OR successivo viene gi` trasformato con una inversione in ingresso che quindi a andr` a fare parte della NAND finale. Tale metodo consiste nel trasformare a le porte OR in NAND con gli ingressi invertiti e aggiungere all’uscita delle AND coppie di inverter. utilizzando il metodo della trasformazione delle porta gi` analizzato nel capitolo precedente. per` . Nell’esercizio proposto. a Il circuito intermedio e riportato in figura 3.x1 x2 x3 x4 x5 x6 x7 Figura 3. e necessario trasformare ` il circuito con sole porte NAND. ` Procedendo alla trasformazione del circuito si ottiene il circuito finale riportato in 33 .2: f Soluzione x1 x2 x3 x4 x5 x6 x7 Figura 3.3.

4 che viene descritto dal codice VHDL seguente: LIBRARY ieee. x5. f_bar : STD_LOGIC. h <= x4 NAND ((x5 NAND x5) NAND (X6 NAND x6)).4: figura 3.x1 x2 x3 x4 x5 x6 x7 g f h l Figura 3. END Logica_NAND. ARCHITECTURE LogicFunc OF Logica_NAND IS SIGNAL g. x6. USE ieee. f : OUT STD_LOGIC). ENTITY Logica_NAND IS PORT ( x1. x3. x4. x7 : IN STD_LOGIC. l.all. f <= f_bar NAND f_bar. f_bar <= g NAND (h NAND l). BEGIN g <= (x1 NAND x1) NAND (x2 NAND X3). 34 . h.std_logic_1164. END LogicFunc. x2. l <= x7 NAND x7.

3. 7. 12.3 VHDL . 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. 2. 5. 1. x4 ) = Σ m(0. in modo testuale. x3 . ricordando l’uso delle parentesi per mantenere la gerarchia desiderata delle operazioni quando non espressamente definita dal linguaggio: 35 . 8. 4. gli operatori booleani definiti. 9. 15). 14.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 . 11.

Encoder 8-to-3 Scrivere il codice VHDL che descriva un Encoder 8-to-3 usando le istruzioni di Assegnamento Condizionato. x2. 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 definito come un array di 3 bit dello stesso tipo (STD LOGIC).std_logic_1164. Soluzione La funzione Encoder codifica in modo binario pesato la posizione dell’unico ingresso che in ogni istante e pari a 1. PORT ( x1. USE ieee. y : OUT STD_LOGIC_VECTOR ( 1 DOWNTO 0 )). IS AND AND AND x4). 3.all. ENTITY Encoder_8_to_3 IS. 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. x3. f : OUT STD_LOGIC). Il codice VHDL risultante e: ` LIBRARY ieee. 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. x4 : IN STD_LOGIC.4 VHDL . ENTITY Sintesi_PoS IS.LIBRARY ieee.all. END Sintesi_PoS. USE ieee. END Encoder_8_to_3. PORT ( w : IN STD_LOGIC_VECTOR ( 7 DOWNTO 0 ).std_logic_1164. ARCHITECTURE Behavior OF Encoder_8_to_3 IS 36 .

all. 37 .std_logic_1164.5: g 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. a f e d Figura 3.BEGIN y <= "000" WHEN "001" WHEN "010" WHEN "011" WHEN "100" WHEN "101" WHEN "110" WHEN "111". Si usano le istruzioni di assegnamento condizionato per esprimere le relazioni booleane nel seguente codice VHDL: LIBRARY ieee.5. USE ieee. END Behavior.5 VHDL .Decoder BCD 7 segmenti Scrivere il codice VHDL che descriva un convertitore BCD-7 segmenti basato sulla codifica dei segmenti riportata nella figura 3. w w w w w w w = = = = = = = "00000001" "00000010" "00000100" "00001000" "00010000" "00100000" "01000000" ELSE ELSE ELSE ELSE ELSE ELSE ELSE 3. Tali segmenti sono la porta di uscita del blocco e sono rappresentati dal vettore a 7 bit LEDS.

abcdefg leds <= "1111110" "0110000" "1101101" "1111001" "0110011" "1011011" "1011111" "1110000" "1111111" "1111011" "0000000" END Behavior. "0110".ENTITY BCD_to_7_Segmenti IS PORT ( bcd : IN STD_LOGIC_VECTOR ( 3 DOWNTO 0 ). OF BCD_to_7_Segmenti IS WHEN WHEN WHEN WHEN WHEN WHEN WHEN WHEN WHEN WHEN WHEN "0000". "1000". "0001". -. END BCD_to_7_Segmenti. LEDS : OUT STD_LOGIC_VECTOR ( 1 TO 7 )).rimane spento 38 . ARCHITECTURE Behavior BEGIN WITH bcd SELECT -. "0111". "0101".negli altri casi il display -. "1001". "0010". "0100". "0011". OTHERS.

1: 39 . 6).1 PLA di tipo NOR-NOR . VDD x 1 x2 x3 VDD P1 P2 P3 P4 f1 f2 Figura 4. con lo stessa struttura riportata in figura 4. 3. 5. x2 . x3 ) = Σ m(0.SoP Disegnare lo schema di una PLA programmabile in logica NOR-NOR.1.Capitolo 4 FPGA 4. per implementare la funzione f1 (x1 .

in grado di realizzare le usuali coperture logiche sotto forma di somma di prodotti (AND-OR). l’uscita 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 . esegue l’OR logico. degli ingreso si collegati ad ogni linea. in logica NOR.2: In accordo al testo del problema. Il piano di uscita OR della PLA esegue a tutti gli effetti l’OR dei termini provenienti dal piano di ingresso (AND) che per` . 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.Soluzione Lo schema riportato in figura 4.1 si riferisce ad una PLA realizzata con tecnologia NOR-NOR con inversione finale. con inversione. Per sintetizzare quindi ogni minterm.

ogni termine Pi per poter essere sintetizzato in modo congruente con un minterm della funzione booleana. che f = S1 + S2 + S3 + S4 ovvero f = S1 · S2 · S3 · S4 Dunque. basta ricordare. 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 figura 4. Se si vuole una giustificazione logica a quanto detto.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. deve essere espresso mediante una somma di termini in forma negata (per realizzare la funzione NOR definita).2 PLA di tipo NOR-NOR .PoS Mostrare come la funzione f dell’esercizio precedente possa essere realizzata con una PLA senza inverter a valle delle porte logiche NOR di uscita. dove la logica NOR-NOR realizza la classica somma di prodotti gi` a studiata in precedenza. facendo ricorso alla terminologia riportata in figura 4. Soluzione In questo caso si tratta di una vera e propria sintesi mediante una struttura a due livelli. 4. la funzione originaria f f = x1 x2 x3 + x1 x2 x3 + x1 x2 x3 + x1 x2 x3 41 . 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 (nell’esercizio precedente comparivano i termini nella versione complementata).3.

x1 x2 x3 S1 S2 S3 S4 f Figura 4.4 mostra un esempio di PLA realizzato con tecnologia nMOS-like in logica NOR-NOR sfruttando la caratteristica delle con42 .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 figura 4.3 PLA nMOS-LIKE Ripetere l’esercizio precedente con una PLA in logica NOR-NOR realizzata con tecnologia MOS (nMOS-like) come nella figura 4. Soluzione Il circuito presentato in figura 4.4 che segue.3 ` 4.

7). si nota che la linea stessa andr` a zero non appena X1 o X2 o X3 sono a uno. Il circuito cos` risultante e riportato in figura 4. ı ` 4. 4. Se ne deduce che per ottenere la stessa funzione logica dell’esercizio precedente e sufficiente sostituire la X di ogni connessione prevista in figura 4. Se ad esempio si analizza il funzionamento della linea che genera S2 .x1 x2 x3 S1 S2 S3 S4 f Figura 4. Soluzione Il circuito che realizza la funzione f richiesta potrebbe essere benissimo realizzato con le PLA tradizionali definite negli esercizi precedenti. In questo caso 43 . mandando in conduzione il a corrispondente transistore nMOS.4: nessioni wired-or per realizzare i piani AND e OR della struttura. Analogamente la linea verticale che produce l’uscita f realizza la funzione NOR dei termini Si collegati ad essa. mostrare come possa essere realizzata utilizzando due LUT a due ingressi. 3.3 con un tran` sistore nMOS collegato a massa e pilotato sul gate dal corrispondente ingresso. 6. Di conseguenza ogni linea orizzontale realizza la funzione NOR degli ingressi collegati ad essa.5.4 PLA con LUT Data la funzione f (x1 . x3 ) = Σ m(2. x2 .

L’organizzazione interna delle LUT e simile a quella di una memoria in cui ` si “programma” il valore dell’uscita per ogni combinazione degli ingressi (locazioni).x1 x2 x3 S1 S2 S3 S4 f Figura 4. 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 .5: per` si richiede di utilizzare dei blocchi intermedi in grado di realizzare funzioni o logiche programmabili: le Look Up Table o LUT. Occorre quindi semplicemente definire il contenuto di ogni LUT che realizzer` la funzione f richiesta.

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 figura 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 l’operatore 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 verificare che x ⊕ (x ⊕ y) = y . Soluzione L’operatore XOR e associativo, quindi: `

48

x ⊕ (x ⊕ y) = (x ⊕ x) ⊕ y = 0⊕y =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 definire il complemento a due del sottraendo e di sommarlo al minuendo (si ipotizza in questo esercizio che non ci sia possibilit` di overflow, 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 definiti in complemento a 2 con segno (SIGNED). Usare l’estensione di segno per uguagliare la lunghezza degli operandi; indicare dove avviene un overflow 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 verifica una condizione di overflow 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 nell’ipotesi che gli ingressi siano su 4-bit e l’output sia il complemento a due dell’ingresso 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 significativa 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 =C⊕D 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 dell’algoritmo iterativo di generazione del complemento a due, ovvero, partendo dal bit meno significativo si lasciano inalterati tutti i bit fino al primo uno che rimane invariato, dopodich` si procede a complementare tutti i bit pi` e u significativi. 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 definiscono le funzioni booleane S = Bit ⊕Cin Cout = Bit +Cin Lo schema risultante del circuito e riportato In figura 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

2: 5. a meno che gli ingressi siano gi` complementati a altrove (come nel caso a). ` 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. Il costo complessivo per il caso a e pari a 4 + 0 + 6 + 10 + 14 = 34. u A3 A2 A1 A0 C4 S3 S2 S1 S0 Figura 5. 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.pi` un OR a due ingressi pi` il costo di due inverter per complementare le u u due variabili di ingresso).10 Overflow Dimostrare la validit` dell’espressione Overflow = cn ⊕ cn−1 per la somma dei a numeri di tipo SIGNED su n bit. mentre il caso a presenta un ritardo dato comunque da quello di un inverter pi` quello di due porte logiche. 53 . ` Il costo complessivo per il caso b e pari a 4 x (2 + 6 + 2) = 40.

Soluzione Dall’espressione canonica che definisce il bit di somma sk a partire dai due ingressi xk e yk e il carry in ingresso ck−1 sk = xk ⊕ yk ⊕ ck−1 54 . Dalla tavola di verit` si ricava l’espressione dell’overflow: a Over f low = cn cn−1 + cn cn−1 = cn ⊕ cn−1 5.Soluzione Creiamo la tavola di verit` a xn−1 0 0 0 0 1 1 1 1 yn−1 0 0 1 1 0 0 1 1 cn−1 0 1 0 1 0 1 0 1 cn 0 0 0 1 0 1 1 1 sn−1 (bit di segno) Overflow 0 0 1 1 1 0 0 0 1 0 0 0 0 1 1 0 Da notare che l’overflow non avviene quando si sommano due numeri con segno opposto. sia ck−1 il segnale di carry-out dal bit in posizione k −1 verso il bit pi` significativo.11 Carry-out Dati due numeri SIGNED su n bit. e sk e il bit di somma corrisponu ` dente. dimostrare la validit` dell’espressione u a ck−1 = xk ⊕ yk ⊕ sk dove xk e yk sono gli ingressi pi` significativi .

11011110 = 01010011 11011111 + 3.segue che: xk ⊕ yk ⊕ sk = (xk ⊕ yk ) ⊕ (xk ⊕ yk ⊕ ck−1 ) = (xk ⊕ yk ) ⊕ (xk ⊕ yk ) ⊕ ck−1 = 0 ⊕ ck−1 = ck−1 5. 11011111 + 10111000 4.11101100 Soluzione 00110110 + 1. 00110110 + 01000101 2. 00110110 .12 Addizioni e sottrazioni con segno Eseguire le seguenti operazioni su numeri SIGNED in complemento a 2 e indicare quando si verifica un overflow. 10111000 = 10010111 54 + 69 = 123 117 + -34 = 83 -33 + -72 = -105 55 . Controllare i risultati convertendo in decimale il risultato. 11010011 .00101011 5. 01110101 . 1. 01000101 = 01111011 01110101 + 2. 01110101 + 11011110 3.11010110 6.

Cn−1 = 1). Complemento a 2 di 00101011 = 11010101 00110110 + 11010101 = 00001011 54 43 11 = 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. Questa e la condizione da verifi` care per rilevare la presenza di overflow nel caso di un’operazione di somma/sottrazione. si pu` verificare overflow 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. Complemento a 2 di 11101100 = 00010100 11010011 + 00010100 = 11100111 -45 -20 -25 = 5. ma il carry del bit pree cedente e a 1 (Cn−1 = 1) provocando quindi un risultato con segno ` opposto al segno dei due operandi da sommare. a) 100111 + 111001 b) 001011 + 100110 56 . Questo si pu` verificare in due casi: o • C’` un riporto oltre il bit di segno (Cn = 1) senza che dal bit precee dente ci sia un riporto (Cn−1 = 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). La teoria dice che dati due numeri con segno su n bit. indicando eventuali condizioni di overflow. 6.4. Complemento a 2 di 11010110 = 00101010 01110101 + 00101010 = 10011111 117 -42 = Overflow!!! 159 = -97 L’overflow si verifica perch´ l’EXOR dei bit di carry Cn e Cn−1 nella some ma effettuata vale 1 (Cn = 0.

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 Overflow −33 −18 9 −9 a) + b) + c) + d) + 5. 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 . Dividere il circuito nelle seguenti parti 1. Soluzione I due numeri su cui operare sono Ai e Bi .14 Somma e sottrazione in modulo e segno Progettare un sommatore/sottrattore in modulo e segno a 5 bit. generatore del segno e controllo logico dell’operazione di addizione/sottrazione. sommatore/sottrattore di numeri UNSIGNED utilizzando il complemento a 2 per il minuendo della sottrazione. 2. 3. correzione logica selettiva del risultato del complemento a 2.

B3 . A2 . A0 B4 . B1 . B0 La prima cosa da definire 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 Definiamo 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 figura 5. A3 . e quella di definizione del segno del risultato sono definiti dall’analisi del tipo di operazione effettuata. che gestisce l’abilitazione di un complementatore a due pilotato. A1 .3 ` La logica di correzione. B2 .S/A A4 . 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 Overflow Overflow .

. B S/A A4 B4 Sub A3.. 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.4) ( C out = 0 )..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 figura 5. quindi si ha A < B e quindi al risultato occorre applicare la correzione. ` Le funzioni logiche che determinano il bit di correzione Corr.B 3 .. il segno del risultato AB4 e il bit di overflow V sono: 59 .... A 0 0 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.... In tal caso A+(2n −B) non genera carry.

15 Somma di 3 numeri di 4 bit Progettare un circuito che permetta di sommare 3 numeri UNSIGNED di 4 bit.73 che mostra il circuito finale.y0). I due bit pi` significativi del risultato si ottengono prenu dendo i carry generati dai due sommatori e sommandoli mediante un Half Adder.. −7 −8 1001 1000 +7 0111 . Caso in cui non viene oltrepassata la linea dello 0 0001 Figura 5. ... In questo modo si ottengono i 4 bit meno significativi del risultato (y3 . 0 +1 +2 . .0000 1111 −1 . come riportato in figura 6.4: Corr = Sub ·C out Sign = A4 + Corr V = Sub ·C out 5. Soluzione Per realizzare il circuito occorre considerare che un sommatore e in grado di ` effettuare una somma solo di due addendi. 60 . . 5. poi si prendono i bit del risultato e si somma il terzo addendo C. La soluzione consiste quindi nel prendere i primi due addendi (A e B) e sommarli. Utilizzare sommatori a 4 bit e ogni altra porta logica necessaria.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..

nella somma con la costante. occorre avere a disposizione un sommatore a 8 bit con la possibilit` di sommare il numero +2 o -2. Sull’altro ingresso si invia il numero xi e si effettua la somma.A c B C c c HA s y5 y4 y3 y2 y1 y0 Figura 5. x0 resti invariato. Se si vuole ottimizzare il progetto ed utilizzare la tecnica della Contrazione. a Se si usa la codifica in complemento a 2. e sufficiente codificare i due numeri ` +2 e -2 e riportarli su uno degli ingressi del sommatore mediante un multiplexer controllato dalla variabile Sub.5: Soluzione Per realizzare il circuito che incrementa (Sub = 0) e decrementa (Sub = 1) di due una parola su 8 bit. dato che si deve sempre sommare ad esso il valore 0. si pu` osservare come la codifica 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. ad x1 invece deve 61 .

Il circuito ottimizzato con la tecnica della Contrazione che esegue quanto richiesto e riportato in figura 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).6: 5.6. Tutti i bit pi` significativi u (x2 . x5 . 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 dell’eventuale riporto u proveniente da x1 . ` 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. ` Soluzione Sia Y = y3 y2 y1 y0 il complemento a 9 del digit BCD X = x3 x2 x1 x0 . Per questo e sufficiente inserire una catena di FA con riporto ` che dipende dal segnale di controllo Sub. Y e definito ` dalla seguente tavola di verit` : a 62 . si propaga un Carry al bit successivo. x4 . x3 .sempre essere sommato 1 e quindi il valore di uscita sar` il suo complemento e a in caso valga 1. x6 .

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. Il testo del problema richiede di effettuare la somma dei due digit con eventuale riporto sul digit pi` significativo.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 significativo ` ` del risultato. se x + y > 9.. 63 . Soluzione Si supponga che i due numeri da sommare siano x e y definiti in BCD su 4 bit.. u x3 . in caso contrario... Usare la tecnica della “contrazione” per ottimizzare il circuito finale. il riporto deve essere fatto sul digit successivo e occorre normalizzare il risultato ovvero va effettuata una correzione.

Si deve generare artificialmente un riporto e riportare il digit meno significativo nell’intervallo 0-9 sommando 6. 9 < x + y ≤ 15 Non si genera internamente il riporto C out verso il digit pi` significatiu vo. x + y > 15 u Si genera C out verso il digit pi` significativo.0010 C out=1 64 = 12 + 6 . 2. Si deve quindi generare il riporto grazie a C out ma il digit meno significativo del risultato e corretto.7: La correzione avviene in 2 casi: 1.x 4 Carry_out y 4 C_in Sommatore 4 bit z 3−0 4 Adjust (add 6) if z>9 6 Adjust 1 0 0 Sommatore 4 bit 4 C_out S 0 Figura 5. ` Esempio: 7 + 5 = 1. 12 0111 + 0101 = 01100 + 00110 1.

8: S2 S1 S0 Il codice VHDL del circuito richiesto (senza le ottimizzazioni ottenute con la tecnica della Contrazione) e : ` 65 . 9 = 17 1000 + 1001 = 1. L’equazione 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.7 ` La realizzazione con la tecnica della contrazione della parte di correzione richiede l’analisi dei bit di somma parziali Zi e del Carry out dello stesso sommatore. Carry_out z3 z1 z2 z3 z3 z2 Adjust z1 z0 Sommatore 2 bit C_out S3 Figura 5. Il circuito finale che esegue la correzione a partire dalle uscite del sommatore a 4 bit che genera Zi e ` riportato in figura 5.8.8 + 2.0111 C out=1 Lo schema del circuito che realizza quanto definito dall’algoritmo di somma dei numeri in BCD e riportato in figura 5.

19 Sottrazione BCD Derivare uno schema a blocchi per implementare la sottrazione di due operandi in formato BCD. La u ` sottrazione S = X −Y si effettua trovando il complemento a 10 di Y e sommandolo a X. USE iee. Siano dati due numeri X e Y (in notazione BCD) in complemento a 10. SIGNAL Adjust : STD_LOGIC. ENTITY BCD IS PORT ( X. 66 . Y S END BCD. s <= Z WHEN ( Adjust = ’0’ ) ELSE Z + 6. In tale rappresentazione il segno e 0 per i numeri positivi.all. dati X = 068 e Y = 043.all. Suggerimento: La sottrazione e facilmente realizzabile se gli operandi sono rap` presentati in complemento a 10 (radice del complemento). ARCHITECURE Behavior OF BCD IS SIGNAL Z : STD_LOGIC_VECTOR ( 4 DOWNTO 0). : IN STD_LOGIC_VECTOR ( 3 DOWNTO 0 ).LIBRERY ieee.std_logic_1164. : OUT STD_LOGIC_VECTOR ( 4 DOWNTO 0 )). 5. Si noti come i complementi a 10 e a 2 siano i complementi alle radici nel sistema di numerazione.std_logic_unsigned. ignorando qualsiasi riporto (carry) del digit di segno. e 9 per quelli negativi. dove le radici sono rispettivamente 10 e 2. allora il complemento a 10 di Y e 957 e ` ′ S = 068 + 957 = 1025. BEGIN Z <= ( ’0’ & X ) + Y. tali che il segno del digit pi` significativo sia 0 per i numeri positivi e 9 per i negativi. Ignorando il riporto (carry out) del digit di segno si ottiene il risultato corretto S = 025. USE ieee. Adjust <= ’1’ WHEN Z > 9 ELSE ’0’. ` 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. Per esempio. END Behavior.

9. Il complemento a 10 di Y pu` essere effettuato aggiungendo 1 al complemento a o 9 di Y.9: 5. che rappresenta −1110 in complemento a 10. lo schema a blocchi del circuito che permette quindi di effettuare addizioni e sottrazioni in BCD pu` essere visto in figura 5. Il blocco che realizza il complemento a 9 e stato derivato in un esercizio prece` dente. allora S = 032 + 957 = 989. il pi` significativo dei quali e il bit di segno (0 per i numeri u ` positivi.Come altro esempio si considerino X = 032 e Y = 043. dove il segnale Add/Sub viene o utilizzato per discriminare somme e sottrazioni.) Verificare la validit` della risposta con qualche a 67 . 9 per i numeri negativi. X Y complementatore a9 MUX Add/Sub Sommatore BCD S Figura 5.20 Interpretazione grafica di un numero BCD a 3 digit con segno Mostrare sul cerchio dei numeri un’interpretazione grafica di un numero decimale in BCS a 3 digit.

000 001 998 999 997 996 002 003 004 096 904 903 902 901 900 099 098 097 Figura 5. Nella tabella sottostante si definisce la tabella di verit` relativa alla somma di due numeri a mediante un half-adder ternario. 1 e 2. tale che due bits vengono usato per 68 .10.10: Per verificare la rappresentazione supponiamo. Questo vuol dire rappresentare −3 in complemento a 10 ovvero 997 = −3 e identificato il punto sul cerchio sommare 5 vuol dire muoversi in senso orario di 5 posizioni. Progettare il circuito che implementi tale halfadder. la sottrazione 4 − (+8) = −4. Tali numeri sono riportati sul cerchio dei numeri come in figura 5. implica partire da 004(= +4) e contare in senso antiorario (sottrarre) per 8 numeri.21 Half-adder ternario In un sistema di numerazione ternario vi sono tre possibili valori: 0. usando una codifica binaria dei segnali. ` 5. Soluzione La rappresentazione grafica sul cerchio dei numeri prevede di considerare tutti i numeri del tipo 0XX se positivi e 9XX se negativi. ` Come altro esempio.esempio. Il risultato e quindi 002(= +2). il risultato e 996(= −4). ad esempio. di effettuare l’addizione −3 + (+5) = 2.

Le funzioni logiche che minimizzano la copertura del circuito sono: 69 . 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 L’half-adder. e/o b1 = b0 01. Minimizzare il costo del circuito. possono essere trattate come condizioni di don’t care. 01 = (1)3 e ` 10 = (2)3. ` Poich´ la somma di due numeri produce al massimo un singolo carry. con una codifica binaria. I dati ida sommare sono A = a1 a0 e B = b1 b0 mentre la somma ternaria e Sum = s1 s0 . pu` essere definito 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.ogni dato ternario. Si usi la notazione che segue: 00 = (0)3 . l’uscita e Carry e un segnale binario.

pu` essere definito 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 codifica binaria su due bit per gli ingressi A e B e per l’uscita S gi` utilizzata nell’esercizio precedente. Soluzione Il full-adder ternario. la tabella pu` essere definita come segue: a o 70 .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. usando l’approccio descritto nel problema precedente.22 Full-adder ternario Progettare un full-adder ternario.

Soluzione Le sottrazioni 26 − 27 = 99 e 18 − 34 = 84 hanno un significato se i numeri su due digit da 00 a 99 sono interpretati come segue: da 00 a 49 sono numeri positivi 71 . 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.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 don’t care.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.

(da 0 a 49). per ogni bit del sommatore: Si = Ai BiCi + Ai BiCi + Ai BiCi + Ai BiCi Ci+1 = Ai Bi + AiCi + BiCi Soluzione 72 . partendo dai due addendi A1 A0 . (da −50 a −1). pi` eventuali inverter per le variabili di u input.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 . Questo schema e illustrato sul cerchio dei numeri in figura 5.24 Sommatore binario 2-bit Progettare un circuito combinatorio che implementi un sommatore binario a 2-bit. B1 B0 . mentre i numeri da 50 a 99 sono numeri negativi. 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.11 e su questo si ` possono verificare i calcoli effettuati nelle due sottrazioni. Progettare l’intero circuito sintetizzando ognuna delle tre uscite mediante un circuito a due livelli. e generando i bit di somma S1 S0 . Iniziare il progetto con le equazioni che seguono.

12: 73 .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 significativi 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.

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. Soluzione 74 . verificare che il circuito realizza un full-adder.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.5. del tipo 74283. e ` implementato come in figura 5.25 Sommatore 4-bit Il circuito logico del primo stadio di un sommatore a 4-bit. 5.12.

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 significativo) e 3 FullAdder procedendo poi con la tecnica di riduzione per contrazione (Design by Contraction) come definito a lezione.13. 5. u Soluzione In figura 5. e dia in uscita il risultato su 4 bit pi` il bit di Carry. 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 figura 5. Soluzione La conta si effettua usando dei Full Adder che contano in binario il numero di 1 presenti in ingresso: 1.+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. In seguito ripetere l’esercio zio con un numero UNSIGNED a 6 bit e infine con un numero UNSIGNED a 8 bit. ` 75 . progettare un circuito che realizzi ci` .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.

14: 3. mentre il secondo stadio somma le uscite del primo stadio di peso omologo. 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 c HA s 20 y 0 Figura 5.13: 2. Si usa un HA nel secondo livello invece di un FA per ottimizzare il circuito dovendo sommare solo 2 bit di peso meno significativo.14.x1 S x2 x3 Figura 5. come riportato in figura 5. Numero UNSIGNED su 6 bit: In questo caso sono necessari due stadi di somma. Numero UNSIGNED su 8 bit: 76 . Nel primo si sommano tre ingressi per volta.

Il secondo stadio permette di generare il bit meno significativo del risultato (y0 ) e prepara il bit di peso 21 che viene generato dal HA del terzo stadio di peso inferiore.15: 77 .La somma di 8 bit richiede tre stadi di somma. x1 x2 x3 x4 x5 x6 x 7 x8 c HA s c FA s c FA s c FA s c FA s c HA s c HA s 2 y 3 3 2 y 2 2 2 y 1 1 2 y 0 0 Figura 5. In figura 5. L’Half adder di peso superiore invece genera i due bit pi` u significativi del risultato (y3 e y2 ).15 si nota come nel primo stadio ci sono 2 FA e un HA per la somma degli 8 ingressi.

x ≤ y. x > y e x ≥ y. N = 0 (Risultato non corretto ma condizione vera) – x positivo. Definiamo le funzioni che calcolano le diseguaglianze richieste: • x<y – x e y hanno lo stesso segno → non si genera mai overflow (V = 0) se (x − y) e negativo → N = 1 e la condizione e vera ` ` – x negativo. y positivo ∗ V = 0. si effettua la differenza dei due numeri x − y. N e V vengono calcolati con il solito metodo e sono riportati in figura 5. ricorrendo al concetto di somma con il complemento a due del sottraendo (y). Il circuito quindi usa 4 FA in cui l’ingresso y viene complementato e il bit di Carryin del primo stadio (C0 ) e fisso a ` 1. dove il bit pi`u significativo rappresenta il segno: ı sign x3 y3 x2 y2 x1 y1 x0 y0 Per poter definire i flag di confronto e le relazioni di maggioranza. N = 1 (Risultato corretto e condizione vera) ∗ V = 1. N = (Negative) e V = (Over f low) da cui definire le relazioni x = y.29 Comparatore > = < Realizzare un circuito che compari due numeri SIGNED a 4 bit e generi i flag Z = (Zero). minoranza.. Soluzione I due numeri da confrontare su 4 bit nella forma SIGNED in complemento a due sono xi e yi .16.5. etc. I bit di Z. y negativo ∗ la condizione non e mai vera ` • x=y – Si verifica sempre quando Z = 1 (condizione vera) • x>y 78 . x < y.

N = 0 (Risultato corretto e condizione vera) ∗ V = 1. y negativo ∗ V = 0. 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 < y→V +N =1 • x=y→Z=1 • x ≤ y → V + N +Z = 1 79 . Z = 0 e la condizione ` e verificata ` – se x e y hanno segno opposto x positivo.16: – se x e y hanno lo stesso segno → non si verifica mai overflow V = 0 Se (x−y) e positivo e maggiore di zero → N = 0.x3 y3 x2 y2 x1 y1 x0 y0 C4 FA S3 C3 FA S2 C2 FA S1 C1 FA S0 C0 1 V N Z Figura 5.

17 .17: 80 .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. La realizzazione e molto ` ` semplice in quanto i due numeri sono uguali solo quando sono uguali bit a bit. Soluzione Una possibile soluzione e riportata in figura 5. Per questo e sufficiente una catena di XOR con tanto di NOR in uscita per verificare ` che ci sia l’uguaglianza su tutti i bit da confrontare. x y 7 7 x 1 y1 x0 y0 Uguaglianza Figura 5.• x > y = x ≤ y → V + N +Z = 1 • x≥y=x < y → V +N =1 5.

18: Procedendo dal bit pi` significativo al bit meno significativo 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 . 81 . e dia come risultato il bit X.31 Comparatore su 4-bit Progettare un circuito combinatorio che confronti due numeri UNSIGNED di 4 bit.5. Soluzione A3 B3 A2 B2 A1 B1 A0 B0 X Figura 5. 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). che pu` assumere il valore X = 1 se A < B e o X = 0 se A ≥ B.

Sulla base di quanto sopra.18. Lo schema del circuito e riportato in figura 5. ` 5.32 Comparatore su 4-bit modulare Ripetere l’esercizio precedente. 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 . 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 significativi.19: 82 . usando come circuito base un blocco con tre ingressi e un’uscita in grado di discriminare la condizione di maggiore su un singolo bit. Soluzione A B C in C out A B C in C out XC 4 A3 B3 C3 A2 B2 C2 A1 B1 C1 A0 B0 ’0’ Figura 5.

Il riporto della sottrazione ad ogni bit vale 1 solo se per i bit meno significativi.33 Comparatore su 4-bit realizzato con un sottrattore a 4 bit Ripetere l’esercizio precedente.. tutta la logica che non partecio pa alla generazione del borrow ma serve solo per definire i bit del risultato della sottrazione. Ne consegue quindi che l’uscita del circuito deve essere X = Br4 In figura 5. Si consideri ora il borrow del bit pi` significativo: se il riporto Br4 = 1. vale la condizione A < B. di conseguen` za. Per produrre l’uscita X e quindi necessario considerare solo il borrow che indi` ca proprio tale condizione: dal bit LSB fino a questo vale la relazione A < B. utilizzando un sottrattore a 4 bit e la tecnica della contrazione. l’uscita X che definisce il risultato della comparazione e il riporto ` della sottrazione e vale X = 1 se A < B e X = 0 se A ≥ B. compreso quello in analisi.. rispetto ad un normale sommatore la somma e rimpiaz` zata dalla differenza e il carry dal riporto (borrow). In figura 5. Per tutti gli altri bit di peso superiore. usando la tecnica della contrazione.3.Ogni blocco base ha due ingressi di un bit A e B e un segnale Cin che propaga l’informazione se per i bit meno significativi delle due parole da confrontare e ` vera la condizione A ≥ B (Cin = 0) o A < B (Cin = 1). L’uscita Cout varr` 1 se tutti a gli stadi meno significativi.20 e riportato lo schema del circuito da cui si ricava la presenza di tre ` 83 . il blocco logico implementato deve realizzare l’equazione appena descritta. ovvero Br0 = 0. risulta Br1 = A0 B0 . Per tale motivo si pu` ridurre. per contrazione. Soluzione In un sottrattore A − B. 5. partendo proprio da quello che genera il borrow..19 e riportato lo schema del singolo blocco logico nonch´ la catena ` e di blocchi che costituiscono tutto il circuito richiesto.. L’equazione per il calcolo del riporto Br nella posizione i + 1 e : ` Bri+1 = Ai Bi + Ai Bri + Bi Bri per i = 0. allora u A < B. portano al risultato A < B. Il riporto di ingresso al LSB del sottrattore e 0.

Per generare un circuito modulare.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. Lo schema logico e u ` riportato in figura 5. oppure se sia vero che A = B.20: 5. per la realizzazione di quanto richiesto. Ogni cella ha come ingressi Ai . usando la tecnica della contrazione. sono necessarie due catene di carry: Gi (Greater = maggiore) e Ei (Equal = uguale).blocchi identici per la gestione del Brin /Brout nei bit pi` significativi nonch´ l’and u e e l’inverter per la gestione del primo riporto. B3 Bi X Br i+1 A3 A B2 B Br A2 B1 B A1 Ai Br i A0 B0 i i Ai Br i i Br i i+1 Br i+1 Figura 5. Si utilizzi. un circuito modulare sulla falsariga di quanto definito negli esercizi precedenti. da replicare ad ogni bit. Soluzione In questo problema il circuito deve avere due uscite relative alle due decisioni che devono essere prese: se sia vero che A > B. iniziando con G0 = 0 e E0 = 1. I carry passano attraverso il circuito dal bit meno significativo verso il pi` significativo. le equazioni delle celle sono : Ei+1 = Ai Bi Ei + Ai Bi Ei Gi+1 = Ai Bi Ei + (Ai + Bi )Ei 84 . Usando le mappe di karnaugh per la sintesi.21 dove il bit meno significativo si trova a destra e le catene di carry corrono da destra verso sinistra. Bi . Gi e Ei mentre Gi+1 e Ei+1 sono le uscite del blocco che si collegheranno al blocco successivo.

21: 5. Discutere i pro e i contro di tale implementazione. 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 1 E4 G4 i Ei i Ei i Ei i Ei E0 =1 Gi Gi Gi Gi G0=0 Figura 5.22 pu` essere usato come blocco base in un sommatore o carry-ripple.Usando la tecnica della sintesi multilivello. 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 .35 Sommatore Ripple-Carry Il circuito in figura 5.

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. 5. 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. una porta NOT per invertire il carry in proveniente dall’esterno. L’aspetto 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. 86 .in ingresso. nell’ipotesi di avere a disposizione dei blocchi elementari di somma a 2 bit con generazione dei bit G e P.23: La soluzione per la versione a 4-bit del sommatore gerarchico e rappresentata ` in figura 5. a Lo svantaggio e la propagazione di ci = 1 attraverso l’NMOS pi` in alto che crea ` u quindi una catena di NMOS in serie lungo gli stadi.36 Carry-Lookahead Gerarchico Si realizzi un sommatore Carry-lookahed gerarchico a 4 bit.23.

Il blocco di somma a 2 bit (ADD 2bit) oltre a generare i due bit di uscita di somma. 87 . 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". a LIBRARY ieee. I due blocchi sottostanti realizzano le funzioni booleane di creazione dei carry. "1001". Output : OUT STD_LOGIC_VECTOR(3 DOWNTO 0)). "0111".std_logic_1164. 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. ENTITY Circuito IS PORT(Input :I N STD_LOGIC_VECTOR(3 DOWNTO 0).37 Codice VHDL ignoto Si consideri il codice VHDL sottostante. END Circuito. genera i bit di Generate (Gi ) e Propagate (Pi ) secondo le equazioni descritte di seguito. si trovi la relazione fra i segnali Input e Out put e si identifichi 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.all. "1010". "0110". "1011". "1101". USE ieee.

perch` non ` e descrive prontamente le funzionalit` di un moltiplicatore. u producendo l’Out put su quattro bit. "1001" WHEN "1111"."0110" WHEN "1110". END behav.24: 88 . a 5. 0 m3 m2 m1 m0 q0 PP1 0 0 q 1 q2 q3 PP2 0 p 7 p 6 p 5 p 4 p 3 p 2 p 1 p 0 Figura 5. Lo stile del codice e mediocre. Esso moltiplica i due bit meno significativi dell’ Input con i due bit bit pi` significativi dello stesso dato. "0000" WHEN OTHERS. Soluzione Il codice rappresenta un moltiplicatore a due bit. Determinare il ritardo lungo il percorso critico in termini di numero di porte.38 Percorso critico di un moltiplicatore Determinare il percorso critico (critical path) del moltiplicatore parallelo descritto in figura 5.24.

27) che causa il ritardo critico.Soluzione Il circuito moltiplicatore illustrato in figura 5. la ` prima delle quali contiene blocchi del tipo riportato in figura 5. m k+1 mk q0 q1 c out FA c in Figura 5. mentre le restanti due righe sono costituite da blocchi logici come quelli riportati in figura 5.26: Il percorso pi` lungo (vedi figura 5.25: Bit of PPi mk qj c out FA c in Figura 5.24 e composto da tre righe.25.26. va dagli u input m0 e m1 all’output p7 attraversando orizzontalmente tutta la prima linea 89 .

25: LIBRARY ieee. mkp1 : IN 90 STD_LOGIC. ENTITY row0 IS. il circuito di base delle altre due righe (figura 5. PORT ( q0.std_logic_1164.27. cin.27: di blocchi per poi scendere verticalmente fino all’ultima linea e dopo spostarsi ulteriormente verso sinistra fino alla fine dei blocchi dove c’` appunto l’uscita p7 . Soluzione • Codice VHDL del circuito di base che realizza il blocco base della prima riga del moltiplicatore e riportato in figura 5. 5.39 VHDL di un moltiplicatore Scrivere il codice VHDL che descrive il moltiplicatore dell’esercizio precedente partendo dal circuito che realizza la prima riga (figura 5.all. .0 m3 m2 m1 m0 q0 PP1 0 0 q1 q2 q3 PP2 0 p 7 p 6 p 5 p 4 p 3 p 2 p 1 p 0 Figura 5.26 ) e il circuito completo.25). e come indicato dalla linea tratteggiata nella figura 5. USE ieee. mk. q1.

cout : OUT STD_LOGIC ).s. • Codice VHDL del moltiplicatore completo: 91 . cout <= ( cin AND a0 ) OR ( cin AND BitPPi ) OR ( a0 AND BitPPi ). a1 : STD_LOGIC. cout END row0. s <= cin XOR a0 XOR BitPPi. cout <= ( cin AND a0 ) OR ( cin AND a1 ) OR ( a0 AND a1 ).26: LIBRARY ieee. cin. USE ieee. PORT ( qj. BEGIN a0 <= qj ANK mk. ARCHITECTURE LogicFunc OF row1 IS SIGNAL a0 : STD_LOGIC. END row1. s. END LogicFunc. END LogicFunc. s <= cin XOR a0 XOR a1. BitPPi : IN STD_LOGIC.std_logic_1164. a1 <= q1 AND mk. ENTITY row1 IS. mk. BEGIN a0 <= q0 AND mkp1. : OUT STD_LOGIC ). • Codice VHDL del circuito che realizza il blocco base della seconda e terza riga del moltiplicatore e riportato in figura 5. ARCHITECTURE LogicFunc OF row0 IS SIGNAL a0.all.

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

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

Mostrare come un flip-flop SR sincrono ` possa essere costruito a partire da un flip-flop di tipo D.1: 94 .1 Flip-flop SR sincrono con flip-flop di tipo D Un flip-flop sincrono SR e un flip-flop che ha gli ingressi SET e RESET come ` un SR.Capitolo 6 Circuiti sequenziali 6.00.11 B Q=0 SR=10. ma e sensibile al fronte di clock.11 Figura 6. 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.00 SR=01.

lo stato proibito di fatto non esiste. ` Per non avere rete d’uscita. ovvero per far s` che l’uscita coincida con la vaı riabile di stato.Rispetto ad SR normale. Nell’esempio si suppone che si tratti di un SR “Reset Dominant” ovvero che nella condizione di stato proibito domini il reset.2: Il circuito finale che realizza quanto richiesto e descritto in figura 6.1.2. Il diagramma a stati del circuito e riportato in figura 6. ` 95 . 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 L’equazione che determina lo stato futuro Y vale Y = S · R + y · S · R = R · (S + y · S) = R · (S + y) S R CK D y Q Figura 6. si effettua la seguente assegnazione degli stati. ma si assegna lo stesso una codifica dell’uscita.

3 ha un comportamento non prevedibile se gli ingressi S e R sono entrambi uguali a 1 quando il segnale Clk commuta a 0.4.2 Latch SR Set. Progettare un tal tipo di latch (SR gated set-dominant ) e disegnarne il circuito. 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 l’uscita del latch a essere comunque uguale a 1.6. quando sia S che R sono uguali a 1. ha come ingressi Set e Reset. l’uscita del flip-flop e 1. Esso differisce da un comune SR-FF master-slave dal fatto che.4: 6.Dominant R R’ Q Clk Q S S’ Figura 6. Soluzione Il circuito richiesto e in figura 6. ` R Q S Q Figura 6.3 Flip flop MS a set dominante Un flip-flop a set dominante Master-Slave. ` 96 .3: Il latch SR di tipo gated in figura 6.

10.01 10. c) Progettare il flip-flop a set dominante usando un SR-FF.5. b) Ricavare il diagramma degli stati per tale flip-flop.11 00. porte logiche e inverter. dove le uscite A e B rappresentano gli ingressi di Set e Reset di un FF-SR tradizionale. Soluzione La tabella degli stati del flip flop 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 figura 6.a) Determinare la tabella degli stati del flip-flop a set dominante. 97 . dove l’uscita coincide con il ` valore dello stato (0 o 1).11 0 01 1 Figura 6.5: Per definire il circuito si identifica dapprima la tabella delle transizioni. 00.

` A S Q Q CLOCK S R B R Figura 6.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 figura 6.6: 6.verifica Verificare manualmente la validit` della soluzione del problema precedente relaa tivo al flip flop a Set dominante . Soluzione La verifica manuale semplicemente prende in considerazione il circuito di figura 6.6.6 e la tabella degli stati prevista e ne compara i risultati con quella ottenuta verificando a mano: 98 .4 Flip flop MS a Set dominante . Considerare tutte le transizioni di S e R con il clock uguale a 0.

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 verificato B Q(t+1) 0 0 1 0 0 1 0 1 0 1 1 0 0 1 0 1 Clock D Figura 6.8: 99 .7: D Clock D Q Qa Qa Qb Qb Qc Qc Clk Q D Q Q D Q Q Figura 6.

Assumendo che gli ingressi D e Clock vengano inviati al circuito riportato in figura 6.9: 6.6. 100 . Clock D Qa Qb Qc Figura 6.6 Latch SR Il circuito in fig. Soluzione Le forme d’onda richieste sono riportate in figura 6. Soluzione Il circuito in figura 6.8. 6. Cos` il valore di S viene caricato nel latch quando ı S o R viene asserito (settato a 1).7.10 pu` essere modificato per implementare un latch SR? o Motivare la risposta.10 pu` diventare un latch SR connettendo S all’ingresso o Data e SorR all’ingresso Load. Qb e Qc .9.5 Flip flop di tipi diversi Considerare il diagramma temporale mostrato in figura 6. disegnare le forme d’onda dei segnali Qa . Bisogna assicurarsi che il segnale Data rimanga stabile mentre il segnale Load viene settato a 1 altrimenti il circuito non funziona come richiesto.

11: Soluzione Il circuito e riportato in figura 6. Disegnare un latch simile usando porte NAND.11 mostra un latch realizzato con porte NOR.Load Data TG1 A B Output TG2 Figura 6.10: 6.12. Ricavare la sua tabella di verit` e il diagramma temporale a che illustri il suo funzionamento. ` 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 .7 Latch Nand-Nand La figura 6. R Qa S Qb Figura 6.

Soluzione 102 .9 Divisore di frequenza Dato un segnale di clock a 100 MHz. assumendo ritardi ragionevoli.13: 6.13.12: 6. ` S Q Clock Q R Figura 6.8 Latch SR gated Disegnare un circuito che implementi un latch SR gated usando solo porte NAND. Soluzione Il circuito richiesto e in figura 6.R Q b S Q a Figura 6. ricavare un circuito usando flip-flop di tipo D per generare segnali di clock a 50 MHz e 25 MHz. Disegnare il diagramma temporale per tutti i segnali di clock.

Soluzione 103 .15 ` 100 MHz 50 MHz 25 MHz 12.Il circuito e riportato in figura 6.14: Il diagramma temporale richiesto e in figura 6.14.10 JK con flip flop T Realizzare un flip-flop JK utilizzando un flip-flop T e altre porte logiche.5 MHz Figura 6.5 MHz 0 ns 10 ns 20 ns 30 ns 40 ns 50 ns 60 ns 70 ns Figura 6. ` 1 T Q T Q T Q 100 MHz Q Q Q 50 MHz 25 MHz 12.15: 6.

17.16: 6. Le due porte NAND hanno un tempo di propagazione maggiore (circa il quadruplo) delle altre porte del circuito.11 JK negative-edge-triggered Si consideri il circuito in figura 6. ` J T K Q Clock Q Q Q Figura 6.16.Il circuito richiesto e in figura 6. Come si comporta questo circuito rispetto a quelli discussi precedentemente in questo capitolo? A E B D C Figura 6.17: 104 .

Si pu` trovare nel circuiti integrati o standard tipo 74LS107A (con l’aggiunta dell’ingresso Clear che qui non viene mostrato). K = B.18: J D K Q Q Q Q Clock Figura 6. Clock = C.19: 105 . qual e la o ` differenza chiave tra i due? J Clock K S Clk R Q S Clk Q Q Q R Q Q Figura 6. Pu` essere usato per lo stesso scopo? In caso contrario.18.Soluzione Questo circuito si comporta come un flip-flop JK negative-edge-triggered (in cui J = A. Lo si confronti con il circuito in figura 6.19. Q = D e Q = E). 6.12 Confronto tra circuiti con flip flop Si consideri il circuito riportato in figura 6.

18 e un flip-flop JK master-slave ed e affetto dal problema ` ` chiamato spesso ones − catching: si consideri la situazione in cui l’uscita Q e al ` livello basso e i segnali Clock.20. il master va a 1 e questo valore verr` erroneamente trasferito allo slave quando Clock va al livello alto.13 Flip flop D negative edge triggered Progettare un circuito con porte NOR. Q Clock Q D Figura 6.21. ora se Clock rimane stabile a 0 mentre J commuta da 0 a 1 per poi tornare a 0. J e K sono a 0. che implementi un flip-flop D negative-edge-triggered. 6.19 si comporta invece in modo corretto.20 in un flip flop sempre di tipo D sensibile al fronte di discesa (Negative-edge-triggered) come riportato in figura 6.20: Soluzione Applicando pi` volte le leggi di DeMorgan` possibile trasformare il flip flop u e D positive-edge-triggered in figura 6.Soluzione Il circuito in figura 6. simile a quello in figura 6. Il circuito a in figura 6. 106 .

22: Soluzione Una possibile simulazione del circuito e riportata in figura 6. Q C Q D Figura 6.Q Clock Q D Figura 6.22. 107 .14 Flip-flop di tipo D Uno schema alternativo per un flip-flop D positive-edge-triggered e mostrato in ` figura 6. Dalla simulazione si comprende come il circuto si comporti proprio come un flip-flop di tipo D con C che agisce come segnale di clock e D come segnale di dato.21: 6.23. Verificare manualmente che presenti effettivamente il comportamento previsto. dove si ipo` tizza che ogni porta logica presenti un ritardo arbitrario.

Disegnare e forme d’onda d’uscita Qi per il latch ed ognuno dei flip-flop assumendo che la propagazione del ritardo negli elementi con memoria sia trascurabile e che inizialmente le uscite siano a 0.15 Confronto tra diversi tipi di flip-flop D e latch C D D C D Q Q’ Latch Q1 Q1 D C Q2 D Q Q2 Q’ M−S Triggered D D C Q3 D Q Q3 Q’ Triggered D Figura 6. 108 .C D Q Q Figura 6.24 sono rappresentate le forme d’onda relative ai due segnali C e D applicati ai tre tipi di flip-flop/latch definiti a sinistra.24: Nella parte destra della figura 6.23: 6.

16 Flip-flop SR Nella figura 6. 109 .27. S e R che sono applicati agli ingressi di tre tipi differenti di flip-flop di tipo SR.25. Per ognuno dei flip-flop disegnare le forme d’onda d’uscita Qi assumendo che la propagazione del ritardo negli elementi con memoria sia trascurabile e che inizialmente le uscite siano a 0. C D Q1 Q2 Q3 Figura 6.Soluzione Le forme d’onda richieste sono riportate in figura 6. Soluzione Le forme d’onda richieste sono riportate in figura 6.25: 6.26 sono rappresentate le forme d’onda di tre segnali C.

un ingresso di dato D e un ingresso di load L.C S R S S Q Q1 Q1 R R Q SR S Q2 S Q C R C Q2 R Q S C Master−Slave Triggered SR Q3 S Q Q3 C R R Q Master−Slave Triggered SR Figura 6. Se. Il nuovo oggetto ha un clock C.17 Flip Flop LH Progettare un nuovo tipo di flip flop Positive-Edge-Triggered chiamato LH. su un fronte positivo di C.26: 6. se invece L = 1 il valore di D verr` a a memorizzato. L e uguale a 0. Progettare il flip-flop usando solo dei flip flop SR (ingressi attivi bassi). Soluzione 110 . porte NAND e inverter. allora il valore correntemente memorizzato ` nel flip flop sar` mantenuto (stato di memoria).

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 .C S R Q1 Q2 Q3 Unknown Figura 6.27: Per realizzare il flip flop di tipo Positive Edge Triggered. si pu` usare la tecnica o gi` sperimentata per realizzare un flip flop D mediante due SR collegati mediante a due fasi del clock realizzando un flip flop Master Slave. D L R R Q S S Q C Figura 6.

29: Clock 1 0 D 1 0 A 1 0 Q 1 0 Figura 6. completare il diagramma temporale (avente risoluzione di 1 ns) in figura 6. 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.30. 6.18 Latch D gated Nella figura 6. Assumendo che i tempi di propagazione sia delle porte NAND sia dell’inverter siano pari ad 1ns.29 viene mostrato un latch D di tipo gated.Il circuito che realizza il flop flop LH richiesto e definito in figura 6.30: Soluzione 112 .28. D Q Clock Q A Figura 6.

` CK r0 r1 r2 r3 Q Q Q Q d0 d1 d2 d3 PL S 0 1 2 3 Figura 6.Clock 1 0 D 1 0 A 1 0 Q 1 0 Figura 6.32: 6.31: Il diagramma temporale richiesto e riportato in figura 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 configurazione di ingresso r (PL = 1).31. Progettare un circuito per 113 .

.. 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 significativo) o a sinistra. Quello che genera d2 e ` ` 114 .33 e evidenziato il circuito che genera d1 .33: La realizzazione delle funzioni definite per di richiede delle catene di multiplexer.. In figura 6. .realizzare uno shift register di questo tipo su 4 bit.32. 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 D q0 0 1 r1 S 0 1 d1 D q1 PL d2 D q2 d3 D q3 Figura 6. Lo schema a blocchi del circuito e riportato in figura 6. l’ipotesi di avere gli ingressi seriali ` forzati a 0 elimina tali ingressi. Si ipotizzi che gli ingressi seriali siano forzati a 0.

se U /D = 0 il contatore decrementa ad ogni colpo di clock (conta “down” ↓).identico mentre quelli all’estremit` (d0 e d3 ) non hanno il multiplexer controllato a da S ma solo una porta logica. D1 .20 Up/Down counter Progettare un up/down counter a 3 bit utilizzando flip-flop di tipo D. 6. 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 flip flop 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 flip flop di stato D2 . D0 sono riportate di seguito 115 . Inserire un ingresso di controllo chiamato U /D. Se U /D = 1 il contatore viene incrementato ad ogni colpo di clock (conta “up” ↑).

U /D 11 10 D1 : 00 00 1 01 Q0 . 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 . Q1 01 11 10 1 1 1 1 1 1 La copertura delle mappe di Karnaugh permette di definire le funzioni boolenane da sintetizzare per la realizzazione del circuito.D2 : 00 1 Q2 .U /D 11 1 10 D0 : 00 00 1 01 1 Q0 . Q1 01 11 10 1 1 1 1 1 1 1 00 01 Q0 . Q1 01 11 10 1 1 1 1 1 1 Q2 .U /D 11 10 Q2 .

34: ` D1 e definito nel modo seguente: ` D1 = Q2 ( Q1 + Q0 + U /D ) + Q2 ( Q1 + Q0 + U /D ) = = Q1 + Q0 + U /D = = Q1 + (Q0 + U /D) 117 .= Q2 (Q1 + Q0 + Q0 + U /D) + Q2 (Q1 Q0 U /D + Q1 Q0 U /D) Se si utilizza la variabile d’appoggio 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 semplificazioni: • 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 figura 6.

dato che l’uscita Z dipende non solo dallo stato ma anche dall’ingresso X .35. 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 figura 6. ha due ingressi.36 insieme ` alla tabella degli stati. Nella tabella seguente e invece riportato il diagramma ` degli stati della macchina.21 Derivazione tabella e diagramma degli stati Un circuito sequenziale con due flip-flop D. Dall’analisi del circuito e delle equazioni costitutive si evince che si tratta di una macchina a stati di tipo Mealy. 118 . X e Y e un’uscita Z ed e caratterizzato dalle seguenti equazioni: ` DA = XA + XY . mentre il diagramma a stati ` ricavato dalle equazioni costitutive e invece rappresentato in figura 6. rispettivamente con uscite A e B.U/D Q1 0 Q0 Q1 1 Q0 Figura 6.34: Infine si definisce la funzione booleana per D0 D0 = Q0 Q2 D2 6.

X A Y D Q CLOCK Q’ X B Z D Q CLOCK Q’ 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 .

120 .22 Derivazione tabella e diagramma degli stati (2) Un circuito sequenziale ha 3 flip-flop D le cui uscite sono i segnali A. uno relativo a tutte le transizioni nel caso in cui X=0 e l’altro per X=1 (in pratica occorre definire il diagramma degli stati nell’ipotesi che l’ingresso sia fisso ad uno dei due valori indicati. 11/1 11/0 S3 S1 0X/0 Allocazione Stati S0 − 00 S1 − 01 S2 − 10 S3 − 11 Figura 6. b) Disegnare due diagrammi a stati parziali. a parte il segnale di clock. come si genera il diagramma degli stati complessivo? ). L’unico ingresso esterno. X0/0 10/1 S0 11/0 10/0 11/1 10/1 S2 0X/0 0X/0 . B e C mentre i rispettivi ingressi di dato sono DA .36: 6. 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. DB e DC .Descrizione archi: XY/Z 0X/0 .

Il circuito implementa la seguente rete di stato futuro: D = X ⊕Y ⊕ S con D. Ricavare la tabella degli stati e il diagramma degli stati del circuito sequenziale.37. 6. 121 . ingresso del D-FF.23 Derivazione tabella e diagramma degli stati (3) Un circuito sequenziale e composto da un flip-flop di tipo D con uscita S (che ` rappresenta anche l’unica uscita del circuito) e ha due ingressi X e Y. Si noti come il diagramma degli stati completo si ottenga semplicemente combinando i due diagrammi parziali.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 figura 6.

` 122 .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 figura 6.38.X=0 000 100 110 011 001 010 111 101 X=1 001 100 010 101 011 111 000 110 Figura 6.

11/1 0 1 01/0 .Descrizione archi: XY/S 00/0 . 10/0 Figura 6.38: 6. 11/0 01/1 . 10/1 00/1 .24 Diagramma a stati Determinare il diagramma a stati di un circuito sequenziale specificato 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 .

Nella figura e riportata la sequenza di archi da ` 124 .25 Generazione sequenza di verifica Generare una sequenza per verificare il circuito descritto dalla tabella degli stati dell’esercizio precedente.40 e riportato il diagramma degli stati con il segnale di Reset per ` forzare la macchina nello stato 00. La sequenza deve permettere di visitare tutti gli archi del diagramma a partire dallo stato AB = 00.Soluzione Descrizione archi: XY/Z 00/0 01/0 00/1 0 11/0 1 10/1 0x/0 . per ridurre la lunghezza della sequenza di simulazione. ` 6. assumiamo che il simulatore possa manipolare gli ingressi XY in modo da poter seguire tutti gli archi del diagramma a stati. 01/0 Figura 6. Soluzione Nella figura 6.39.39: Il diagramma degli stati richiesto e riportato in figura 6. a tal fine si supponga che sia disponibile un segnale esterno di Reset per poter inizializzare la macchina dallo stato 00. 01/1 11/1 01/1 . 10/0 3 11/1 2 11/0 x0/1 .

11. 01. Soluzione Dall’analisi della tabella degli stati si pu` ricavare il circuito definito in figura o 6.10. 00. 00.1 00/0 2 8 00/1 01/0 3 Reset 0 11/0 1 14 x0/0.15) sono associati i valori da fornire agli ingressi XY per forzare la transizione lungo l’arco voluto. x0. ad ogni numero (1.42. 11.10/0 7 11 3 12 11/1 15 13 2 9 5 11/0 x0/1. 01. 01. x0.41. 11..01/0 6 10 SEQUENZA: Reset.26 Progetto FSM e simulazione Progettare il circuito specificato nei due esercizi precedenti e usare la sequenza dell’esercizio precedente per eseguire una simulazione del circuito. La sequenza di test per il circuito (ingressi e uscite) e invece riportata in ` figura 6. 01.40: provare per verificare la macchina. 11. 10 Figura 6. 01. 6. 125 .01/1 11/1 10/1 4 01/1.

un ingresso X e un’uscita Y.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 Z Figura 6. Lo schema del circuito e mostrato in figura 6.43. Ricavare la Tabella degli Stati e ` il Diagramma degli stati del circuito. 126 .42: 6.41: Clock Reset X Y A B Figura 6.27 Tabella e diagramma degli stati Un circuito sequenziale ha due flip-flop SR.

44.S A B S B R X CLK R Y Figura 6. 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 figura 6.43: Soluzione Le equazioni di stato futuro per i quattro ingressi ai flip-flop (due di tipo Set e due di tipo Reset) sono: SA = B SB = X ⊕ A RA = B. ` 127 .

il circuito compie la transizione da AB= 00 a 10 a 11 a 01. ed un ingresso X . ritornando a 00. Quando X=0.28 Progetto FSM Progettare un circuito sequenziale con due flip-flop di tipo D le cui uscita siano A. lo stato del circuito rimane immutato mentre quando X=1. e B.Descrizione archi: X/Y 0/0 1/1 0 1/0 0/1 1/0 2 0/0 3 1/1 0/1 1 Figura 6. per poi ripartire con lo stesso algoritmo. Soluzione La tabella degli stati relativa al funzionamento del circuito e riportata nel ` seguito.44: 6. 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 .

01/0 Reset B 10/1 . 10/1 A 00/0 . 11/1 01/1 .46: 129 . riportata in o figura 6. ` ` Descrizione archi: X1 X2 / Z 00/0 . 11/0 01/0 . 10/0 C 00/1 .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.29 Progetto FSM (2) Per il diagramma degli stati riportato in figura 6.Se si definiscono Da e Db le variabili di stato futuro associate alle variabili di stato A e B si pu` definire la mappa di Karnaugh per le due uscite.46: 6. 11/1 10/0 . 11/0 D Figura 6. Da XB A 00 01 0 1 11 10 Db XB A 0 1 00 01 11 10 1 1 1 1 1 1 1 Figura 6.45.

porte NAND e inverter. 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 .Q2 00 01 10 11 La tabella degli stati che realizza il diagramma degli stati richiesto e riportata ` nella tabella sottostante. e ricavare la tabella degli stati codificati. Soluzione Si esegue dapprima l’allocazione degli stati secondo la seguente tabella: Stato A B C D Q1 .a) Ricavare la tabella degli stati per il circuito. c) Ricavare un circuito ottimizzato usando D-FF. dove Q1 e Q2 rappresentano le variabili di stato. b) Eseguire l’assegnazione degli stati per il circuito usando 2 bit di codifica.

B. 6.47.46. per quanto riguarda la rete di stato presente e i ` flip flop di stato. ottimizzato nell’uso di sole porte NAND. e di uscita Z. Soluzione 131 . e riportato nelle figure 6.47: Il circuito richiesto. e 6.48 per quanto riguarda la rete di uscita. La simulazione deve includere l’ingresso X e le variabili di stato A. La sequenza di ingresso usata nella simulazione deve includere tutte le transizioni in figura 6.X1 X2 D Q Q1 CLK Q’ D Q Q2 CLK Q’ Figura 6. inverter e flipflop.30 Simulazione Progetto FSM (2) Effettuare una simulazione logica di verifica del progetto dell’esercizio precedente.

48: La simulazione logica si presenta come in figura 6.49: 6. e ricavare la tabella degli stati codificata. c) Progettare il circuito ottimizzato usando D-FF.49. b) Eseguire l’assegnazione degli stati per il circuito usando 3 bit di codifica per i 6 stati.50: a) Ricavare la tabella degli stati per il circuito.Q1 Q2 X1’ Q1 Q2’ X2’ Q2 X1 X2 Q1’ X1 X2’ Z Figura 6. porte NAND e inverter. 132 . Clock Reset X Y A B Figura 6. Si utilizzi uno dei bit di codifica come bit di uscita per ottimizzare la logica.31 Progetto FSM (3) Per il diagramma a stati riportato in figura 6.

Si e scelto di utilizzare la ` ` variabile Q3 come variabile di uscita (Z = Q3 ).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 codifica degli stati e riportata nella seguente tabella. 133 .

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’ Q’ 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 Q’ Figura 6.Q2 .Stato Codifica: Q1 .51: 134 .

. Gli stati 100 e 111 non erano utilizzati nel disegno originale e quindi sono da considerarsi come stati don’t care. 135 . In generale per` e sempre opportuno definire u o ` come stato futuro di uno stato non raggiungibile teoricamente nel diagramma. un’unico ingresso X e l’uscita Z. uno stato di reset (nell’esempio 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.51. La copertura di tali stati pu` essere fatta in molti o modi.32 Ottimizzazione di FSM Si vuole riprogettare il circuito dato in figura 6. a) Trovare la tabella degli stati per il circuito e sostituire gli stati codificati con lettere (A. considerando lo stato futuro relativo come una sequenza di don’t care.. C. Il circuito realizza una macchina a stati finiti con tre variabili di stato (Y1 .52 al fine di ridurne il costo in termini di gate. da coprire nel modo pi` opportuno.Ai due stati non presenti nel diagramma degli stati (denominati H e G) sono stati assegnati i codici 000 e 111.. Y2 e Y3 ). ` X Y3’ X’ Y’ Y3 D Q CLOCK Y1 Q’ Y1’ X’ Y3’ Y2 X’ Y2’ Y3 CLOCK X D Q Q’ Y2 Y2’ D Q CLOCK Z Q’ Y3’ Figura 6.52: 6. B.). Una possibile implementazione del circuito e riportata in figura 6.

L’indicazione del fatto che esistano solo sei stati raggiungibili permette di assegnare ad ognuno di essi una label da A a F e a estrapolare. ad esempio gli stati A. Soluzione Come prima cosa da fare. 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 verifica dell’equivalenza degli stati porta a identificare diversi percorsi equivalenti. la tabella delle transizioni degli stati. F prevedono le stesse transizioni e la stessa 136 . 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. c) Assegnare i nuovi stati in modo tale che l’uscita coincida con una delle variabili di stato. C.Y2 .b) Ricercare la presenza di stati equivalenti e fonderli in una nuova assegnazione degli stati ottimizzata. in questo esercizio di reverseengineering.Z A 000 B 001 C 010 D 011 E 101 F 110 Su tale base e possibile ricavare. La codifica scelta e dunque ` Stato Codifica: Y1 . dal circuito. occorre ricavare la tabella degli stati a partire dal circuito proposto. dall’analisi delle equazioni di stato futuro.

Stop e Run Un circuito digitale di controllo ha 3 ingressi: Start. 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 flip flop con un costo pari a 14 x 3 = 42. Z) M 00 N 01 O 11 dove Y e una variabile di stato insieme a Z. Analogamente a gli stati B e E sono equivalenti e possono essere accorpati con il nome dello stato N. Di conseguenza una possibile codifica degli stati e ` Stato Codifica (Y. Per completezza rinominiamo lo stato D in O. Stop e Clock oltre a un segnale di uscita Run. 6.33 Start. 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 flip flop DY e DZ : DY = Y ZX DZ = ZX +Y Z Per il calcolo del costo complessivo del caso in esame.uscita: per semplicit` possono essere accorpati nell’unico stato M. Uno dei due bit e la variabile d’uscita Z che sar` quindi 1 negli ` a stati N e O. I segnali Start e Stop hanno una durata indeterminata che 137 . N e O cui possiamo associare una a codifica su due bit. ` Nel caso ottimizzato si ha un costo pari a 2 flip flop (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. Il costo complessivo del u circuito originario e quindi 21 + 42 = 63. A questo punto il sistema avr` tre stati M.

ipotizzando di associare allo stato Run la variabile di stato futuro RunFut. Il segnale Run deve rimanere alto finch` il segnale di Stop e non va a 1.53. dopo di che deve tornare a 0.53: Dalla tabella degli stati. si ricava la seguente tabella delle transizioni: 138 . con la scelta di assegnare lo stato 0 al caso in cui Run = 0. Scrivere il codice VHDL del circuito progettato Soluzione Le due condizione da verificare 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 ` figura 6. 1. il circuito deve generare Run = 1. Quando il segnale Start va a 1. Progettare il circuito di controllo 2.potrebbe coprire diversi colpi di clock. START = 1 RUN 0 RUN 1 STOP = 1 Figura 6. Tutti i cambiamenti del segnale di Run devono essere sincronizzati con il fronte di salita del segnale di Clock.

Stop 00 01 11 10 1 1 1 La funzione booleana che copre la variabile RunFut e ` RunFut = Start · Stop + Stop · Run 139 .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.

• Determinare il diagramma degli stati del complementatore a 2 seriale • Definire la tavola degli stati per il complementatore a 2 seriale 140 . altrimenti resta a 0. ARCHITECTURE Behavior OF Start_stop_run IS BEGIN PROCESS (Clock) BEGIN IF Clock’EVENT AND Clock = ’1’ THEN IF Stop = ’1’ THEN Run <= ’0’.std_logic_1164. il corrispondente bit in uscita deve apparire sull’uscita Z nello stesso colpo di clock (si usi una macchina di Mealy).Il circuito finale che realizza quanto richiesto e riportato in figura 6. ` Il codice VHDL e ` LIBRARY ieee. ELSE Run <= Start OR Run.54. Per indicare che una sequenza e terminata e che il circuito deve essere inizializzato per ` ricevere un’altra sequenza. Stop : IN STD_LOGIC. Start. l’ingresso Y rimane a 1 per un ciclo di clock.34 Complementatore a 2 seriale Progettare un complementatore a 2 seriale che accetti sull’ingresso X un numero INTEGER binario di lunghezza arbitraria partendo dal bit meno significativo. USE ieee. 6. ENTITY Start_stop_run IS PORT ( Clock. Quando arriva un bit sull’ingresso X . END IF. Run : BUFFER STD_LOGIC ). END Start_stop_run.all. END IF. END PROCESS.

56: Lo schema logico e a blocchi del circuito che si vuole realizzare e riportato ` in figura 6. si deve operare con una macchina di Mealy. il cui diagramma degli stati e rappresentato in figura 6. Dall’analisi del diagramma degli stati si ricava la tabella delle transizioni: 141 . dato che l’algoritmo di complementazione a due parte dal bit meno significativo).57 dove sugli archi sono riportate ` le condizione sugli ingressi XY e il valore dell’uscita Z.Soluzione x LSB x y x z fine ck Figura 6.56. Dato che i bit di uscita devono essere disponibili nello stesso colpo di clock del loro arrivo in ingresso. ovviamente. Il segnale Y definisce la fine della sequenza che viene inviata secondo il diagramma temporale definito in figura 6. Il flusso di bit in ingresso viene inviato all’ingresso X del circuito (dapprima l’LSB .55: CK x y 1 2 3 4 z 1 uscita 2 3 4 Reset e uscita z non definita Figura 6.55. I due stati sono identificati dalla variabile Q.

57: X 0 0 1 1 0 0 1 1 Y 0 1 0 1 0 1 0 1 Qn−1 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 .XY/Z −1/ − Run Q=1 Reset Q=0 10/1 −1/ − 00/0 10/0 00/1 Figura 6.

35 NRZI In molti sistemi di comunicazione. Ricavare il diagramma degli stati del circuito utilizzando una macchina a stati di Mealy 2. Progettare un circuito che converta a ogni sequenza di zeri e uni in una sequenza di formato NRZI. L’USB utilizza una versione specifica che si rif` al non-return-to-zero inverted (NZRI). allora il bit inviato nel formato NRZI imme` diatamente ha una transizione (cambia da 0 a 1 e viceversa). Soluzione La macchina a stati che si deve realizzare deve praticamente commutare l’uscita in presenza di uno zero e lasciarla inlterata in presenza di un uno in ingresso: 0→ Commutazione 1→ Mantiene il valore vecchio 143 . Questa trasformazione e illustrata dall’esempio seguente in cui si suppone che ` il valore iniziale del messaggio NRZI sia 1: Messaggio: Messaggio NZRI: 10001110011010 10100001000110 1. Progettare il circuito utilizzando un flip-flop D e altre porte logiche.6. • Se il bit del messaggio e a 1. allora il bit nel formato NRZI rimane fissato a ` 0 o 1 a seconda del valore del bit precedente trasmesso in formato NRZI. Ricavare la tabella degli stati del circuito 3. il segnale trasmesso sulla linea utilizza un formato non-return-to-zero (NZR). Il comportamento di tale protocollo e definito nel modo seguente: ` • Se il bit del messaggio e a 0.

Ci sono due stati identificati con i simboli OU T (0) e OU T (1).59. progettando un circuito sequenziale che trasformi un messaggio NRZI in un messaggio normale.standard Ripetere l’esercizio precedente. 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 definito in figura 6. 6. Reset X=0 / Z=1 OUT (0) OUT (1) X=0 / Z=0 X=1 / Z=0 X=1 / Z=1 Figura 6. La specifica per tale circuito e la ` seguente: 144 .58 e riportato il dia` gramma degli stati per la macchina. nell’ipotesi che l’ingresso seriale dei dati sia X e l’uscita codificata in formato NRZI sia Z.Realizzare la FSM con una macchina di Mealy implica che sugli archi si definisca il valore dell’uscita che si deve inviare.36 Conversione NRZI . In figura 6.58: La tabella degli stati e riportata nella tabella seguente.

allora il bit del messaggio da decodificare e un 1.X D CK Z Reset Figura 6. ` Soluzione Il diagramma degli stati del circuito proposto e riportato in figura 6.60.60: Dal diagramma degli stati si pu` derivare la tabella di allocazione e di transio zione degli stati: 145 . allora il bit del messaggio da decodificare e uno 0. ` X=1/Z=1 X=1/Z=0 X=0/Z=1 0 X=0/Z=0 1 Figura 6. ` b) Se non avviene nessuna transizione tra i bit adiacenti nel messaggio NRZI.59: a) Se avviene una transizione da 0 a 1 o da 1 a 0 tra bit successivi nel messaggio NRZI.

62. ` X D Q CLK Z Q’ Figura 6. LD CE D0 D1 D2 D3 Q0 Q1 Q2 Q 3 CO Figura 6.61: 6. come quello riportato in figura 6.37 Contatore da 11 a 233 Utilizzando due contatori a 4 bit.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 figura 6. realizzare un contatore che conti da 11 a 233 (decimale).61.62: 146 . Aggiungere la logica necessaria affinch` quando il segnale INIT = 1 il contatore si inizializzi al valore 11 in modo e sincrono con il clock CK.

Progettare un circuito sequenziale sincrono che inizi a generare la sequenza quando l’ingresso E = 1.Soluzione Il contatore proposto in figura 6.63. Occorre contare fino al numero 233 che si rappresenta su 8 bit nel modo seguente: 233 = 11101001. Si deve infine prevedere un segnale esterno INIT di inizializzazione del contatore. questa deve essere portata a termine. Arrivato a fine conta si deve tornare al valore 11 che sar` quindi caricato tramite un a impulso sul segnale LD. Altrimenti. ` CK INIT LD CE D0 D1 D2 D3 Q 0 Q 0 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. Una volta iniziata la generazione della sequenza. Il circuito progettato e riportato in figura 6. se E = 0. 147 .63: 6. Se E rimane alto anche dopo la fine della sequenza essa deve essere ripetuta. l’uscita deve rimanere fissa a 1.38 Generatore di sequenze per USB Una linea di comunicazione Universal Serial Bus (USB) richiede un circuito che generi la sequenza 00000001. Il circuito da progettare deve quindi contare da 11 = 00001011 fino a 233.62 ha due segnali di controllo per il caricamento sincrono (LD) e l’abilitazione alla conta (CE).

64: Il diagramma degli stati del circuito e riportato in figura 6. E=0 0/0 1/0 2/0 3/0 4/0 5/0 6/0 7/1 E=1 Figura 6. ` 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 .• Definire il diagramma degli stati del circuito utilizzando una macchina a stati di Moore • Determinare la tabella degli stati • Progettare il circuito utilizzando un flip-flop D e altre porte logiche. Includere il Reset per configurare il circuito nell’appropriato stato iniziale nel quale viene controllato l’ingresso E per determinare se si debba generare la sequenza 00000001.64 dove la condi` zione E=1 e quella che fa attivare la sequenza di uscita. 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.

in tal caso ` la condizione di reset del circuito coincide con il set dei tre flip flop che sono utilizzati per la realizzazione del circuito che e riportato in figura 6. Si poteva ` ovviamente scegliere una qualsiasi altra allocazione degli stati.65. coincidente con la verifica della condizione E=1. 6.E’ Z D0’ CLOCK Q’ S D Q D0 D1 D0 D1 CLOCK S Q’ D Q Z D0’ D2 D Q D1’ D2 D0 D1’ D2’ RESET CLOCK S Q’ D2 Figura 6.65: Nell’allocazione degli stati proposta. 149 . e associata allo stato 111. la condizione di stato idle (stato 7). ad esempio se allo stato 7 fosse stato associato il codice 000 i tre flip flop del circuito dovevano essere resettati dal segnale di RESET esterno invece che essere settati a 1.39 Generatore di sequenza Ripetere l’esercizio precedente per la sequenza 01111110 che e usata in un diffe` rente protocollo di comunicazione di rete.

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 dell’esercizio precedente. ovviamente. E=0 0/0 1/1 2/1 3/1 4/1 5/1 6/1 7/1 E=1 Figura 6. ` 6. Si noti come la rete di stato ` futuro coincida.67.66: La tabella dell’allocazione 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 figura 6. Differisce solo la rete di uscita.66 e si presenta ` fondamentalmente identico a quello dell’esercizio precedente.Zero Insertion La sequenza 01111110 nel problema precedente e usata come flag in un proto` collo di comunicazione seriale per rappresentare l’inizio di un messaggio e deve 150 . 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).Soluzione In questo caso il diagramma degli stati e riportato in figura 6. con quella dell’esercizio precedente. dato che l’evoluzione tra i vari stati e la medesima.40 Generatore di sequenza .

si usa la tecnica dello Zero Insertion: ogni volta o che ci sono pi` di 5 uni di seguito da inviare. Poich` questo non e pu` essere garantito in generale. uno 0 viene inserito nel flusso di uscita Z. indicando che non deve essere applicato nessun ingresso per un ciclo di clock (situazione di stallo). mentre l’altra uscita S va a 1. Il circuito ha due uscite. Il messaggio da inviare entra quindi in modo seriale nell’ingresso X di un circuito sequenziale chiamato Zero-Insertion. Z e S.67: ovviamente essere una sequenza che non compare in nessuna altra parte della comunicazione. Come conseguenza. La tecnica della Zero-Insertion e illustrata dal seguente esempio: ` Sequenza di X: 01111100111111100001011110101 Sequenza di Z: 0111110001111101100001011110101 Sequenza di S: 0000001000000010000000000000000 151 .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. Quando un quinto uno appare in sequenza su X. al massimo possono comparire non pi` di cinu que 1 in sequenza in qualunque altra sezione nel messaggio. Questo e necessario perch` l’inserimento 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. si inserisce in modo arbitrario uno 0 u nella sequenza dei bit inviati.

b) Ricavare la tabella degli stati per il circuito e fare l’assegnazione degli stati.S=0 3 Figura 6.S=0 X=1/Z=1.S=0 0 X=x/Z=0.S=0 X=0/Z=0. c) Progettare il circuito usando D-FF e porte logiche.S=0 4 X=1/Z=1.S=0 2 X=1/Z=1.S=1 X=0/Z=0. I due stati non assegnati sono il 6 (110) e il 7 (111). 152 . si ricava la seguente tabella delle transizioni.68 ` X=0/Z=0.S=0 X=0/Z=0.68: Supponendo di associare ad ogni stato il codice binario relativo al numero dello stato.S=0 5 X=0/Z=0.a) Ricavare il diagramma a stati del circuito.S=0 X=1/Z=1.S=0 1 X=1/Z=1. Soluzione Il diagramma a stati del circuito e riportato in figura 6.

Soluzione Non disponibile. deve apparire il corrispondente bit di sull’uscita Z nello stesso ciclo di clock. l’ingresso Y assume il valore alto per un ciclo di clock. Sull’ingresso X del rilevatore seriale viene inviato un numero in binario di lunghezza arbitraria a partire dal bit pi` significau tivo.41 Rilevatore del primo uno in una sequenza Progettare un rilevatore seriale di sequenza che fornisca un’uscita attiva al riconoscimento del primo uno ricevuto. Finch` all’ingresso X giungono degli 0. • Determinare il diagramma degli stati per il rivelatore seriale • Definire la tabella degli stati • Progettare il circuito utilizzando dei flip flop di tipo D. Per indicare che la sequenza e terminata e che il circuito pu` iniziare ` o a ricevere una nuova sequenza. Per tutti i valori seguenti che arrivano su X . altrimenti Y = 0. rendendo quindi necessario l’uso di una macchina di Mealy. Quando giunge un bit sull’ingresso X .69. Z = 0.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 definita in precedenza e in figura ` 6. Z = 1. l’uscita Z = 0. 6. Quane do all’ingresso X arriva il primo 1. 153 .

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

porte NAND e inverter e usando la tecnica one-hot per la codifica degli stati. come richiesto dal problema. E questi stati. Progettare il circuito sequenziale con gli ingressi XA .XB . corrispondente alla condizione sequenza non 155 . 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 l’uscita dello stato E come variabile d’uscita U . mentre vale 0 quando il lucchetto e ` bloccato. B. Soluzione L’analisi degli stati del circuito evidenzia la necessit` di codificare 5 stati. 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 flip-flop per implementa` re il meccanismo di bloccaggio (Lock) facendo evolvere lo stato della macchina nella condizione ABCDE = 10000.XD .XC . il reset L e il clock C utilizzando solo D-FF. uno a per il reset e e 4 per il riconoscimento progressivo della sequenza.la sequenza corretta e si sblocca il lucchetto. Definendo A. D. C.

Per tale motivo il segnale L viene inviato al Set del flip flop che genera A e al Reset di tutti gli altri flip flop.riconosciuta .70. X_D ’ D X_C ’ C X_B ’ B S L D Q CLOCK Q’ A X_A ’ A A D Q X_A B CLOCK R B Q’ D Q X_B C CLOCK R Q’ C X_C D Q CLOCK R D Q’ D X_D E D Q CLOCK Q’ R E = U Figura 6. Il circuito finale e ` riportato in figura 6.Lucchetto chiuso).70: 156 .

Se le transazioni nell’ handshake avvengono nell’ordine corretto. per ogni transazione. devono presentare i fronti nello stesso ordine definito in figura 6. E=0. CLK R A E Figura 6. Gli stati a ` 5.. e un’uscita. Il controllore ha gli ingressi R e A.71. un reset asincrono RESET.71: Si progetti un circuito.6. Soluzione Il diagrammi degli stati richiesto e in figura 6. Se le transazioni avvengono fuori ordine. Questi segnali sono sincroni con il clock e. b) Ricavare la tabella di transizione degli stati per il circuito. e a) Ricavare il diagramma a stati del circuito di controllo. 6 e 7 non sono assegnati e quindi le righe relative sono dei don’t care. L’interazione di questi segnali e ` molto spesso riferita come handshake. allora E diventa 1 e rimane attivo finch` il reset asincrono RESET=1non resetta il canale di comunicazione.43 Controllore di Handshake Una coppia di segnali. controllore di handshake. 157 . Error (E).72 ` La tabella di verit` del circuto e rappresentata nella seguente tabella. che verifichi che l’ordine delle azioni associate ai due segnali segua le regole del protocollo definito con l’handshake. Request (R) e Acknowledge (A) e usata per coordinare le ` transazioni tra una CPU e il suo sistema di I/O.

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 .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.

Riprogettare il circuito usando la codifica one-hot per gli stati. Si ricava quindi dapprima la tabella degli stati e delle transizioni partendo dalla realizzazione con due flip flop A e B.73.6. Il diagramma a stati e ` mostrato in figura 6. 1 0 00/1 01/0 0 1 1 11/0 0 0 10/0 1 Figura 6. Nella tabella sono riportate le transizioni in entrambe le codifiche: 159 .73: Soluzione La codifica one-hot prevede che ogni stato sia rappresentato da una codice con tutti zeri tranne uno. un ingresso X e un’uscita Y. relativo allo stato in questione. Y2.44 Progetto FSM con tecnica One-Hot Un circuito sequenziale realizzato con la tecnica degli stati codificati in binario puro ha due flip-flop A e B. sar` necessario utilizzare una codifica su 4 bit con a conseguente impiego di 4 flip-flop Y4. Y1. Y3. Dato che nel diagramma degli stati sono presenti 4 stati.

74: Utilizzando la tecnica one-hot si ricavano le equazioni della rete di stato futuro (Di e l’ingresso di stato futuro del flip flop con uscita Yi ) per l’implementazione ` richiesta: 160 .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.

Poich´ non ha ingressi. a) Progettare il circuito usando D-FF e assumendo per gli stati non specificati nella tabella una condizione di don’t care. Soluzione Sulla base di quanto definito nel testo. il circuito semplicemente commuta da e stato a stato ad ogni colpo di clock evolvendo secondo la tabella degli stati. b) Aggiungere la logica necessaria al circuito per inizializzare il circuito nello stato 000 in corrispondenza del reset esterno.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 flip-flop. ` 6. Un reset asincrono esterno permette di inizializzare il circuito allo stato 000.74. I due 161 .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 finale e riportato in figura 6. occorre dapprima completare la tabella degli stati inserendo gli stati non raggiungibili teoricamente dal circuito.

Si ottiene dunque ClearA = Reset ClearB = Reset ClearC = Reset 162 . Su questa base. 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 flip flop i cui ingressi chiameremo DA . 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. coprendo le tre mappe di Karnough relative alle tre uscite dei flip flop A. per i quali si ipotizza quindi di avere dei don’t care come stati futuri. b) Per forzare lo stato 000 e sufficiente che i flip flop abbiano il Clear (attivo ` basso) collegato al segnale di Reset esterno. DB e DC .stati non indicati sono gli stati 010 e 101. B e C dei flip flop.

26 mette in luce il fatto che alcuni archi possono essere compattati. porte AND.11/1 10/0. e inverter. analogamente la transizione B → C avviene solo se Y = 1.11/1 B 01/1. riducendo la complessit` delle condizioni a di transizione il pi` possibile. Effettuare poi un’assegnazione degli stati opportuna e progettare il corrispondente circuito sequenziale utilizzando flip-flop di tipo D.10/0 00/1.11/0 C 00/0.10/1 Figura 6.75. riducendo il numero di variabili da considerare (nell’esempio da due ad una).46 FSM equivalenti Trovare la tabella degli stati di una macchina a stati che sia equivalente al diagramma degli stati riportato in figura 6.01/0 Reset 10/0.01/1 D 01/1. Ad esempio la transizione A → B avviene tutte le volte che X=1. Ragionando allo stesso modo per le altre transizioni si pu` ottenere la tabella o degli stati riportata immediatamente nel seguito: 163 .6. Cercare di rendere l’uscita il pi` possibile di Moore u u (definita solo dallo stato invece che dagli archi) e discutere vantaggi e svantaggi della trasformazione. porte OR. Descrizione archi: XY/Z 00/0.11/0 A 00/1.75: Soluzione L’analisi del diagramma degli stati di figura 6.

6. La macchina accetta pezzi da 5 cent (N=1) . vale 1 nello stato D. mentre nello stato B e C e legata al valore degli ingressi. Quando la somma delle monete inserite e pari a 25 cent o maggiore. Tale distributore vende caramelle al prezzo di 25 cent.76.47 FSM distributore automatico Si vuole ricavare il diagramma degli stati di una FSM di un distributore automatico. pezzi da 10 cent (D= 1) e pezzi da 25 cent (Q=1).77.76: L’ultima colonna della tabella rappresenta l’uscita che ha il valore 0 nello stato A.Stato A Stato Codificato 00 Condizione Stato Futuro Stato futuro Codificato X X A B A C D A D C 00 01 Uscita 0 B 01 Y Y 00 10 X C 10 X X 11 00 Y D 11 XY +X Y XY+XY 11 10 1 X’ Reset X A Z=0 Y’ B Z=X’ X Y C Z=Y XY+X’Y’ X’ D Z=1 XY’+X’Y Figura 6. ma si e solo ridotto in qualche modo la dipendenza di Z dagli ingressi. la macchina ` 164 . ` Ne consegue che la macchina non e veramente trasformata in una macchina di ` Moore. Il circuito che realizza quanto indicato e invece riportato in figura ` 6. cadauna. ` Il diagramma degli stati compattato e modificato come sopra e riportato in ` figura 6.

77: eroga una caramella imponendo DJ uguale a 1 e riportando tutto allo stato iniziale.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. Se viene inserito un importo inferiore a 25 centesimi e viene premuto il pulsante CR (Coin Return). 165 . In tutti gli altri stati RC=0. Realizzare il diagramma degli stati con una macchina di Moore. ritornando alle condizioni iniziali. allora le monete depositate nel distributore devono essere rilasciate nell’apposito slot di uscita della macchina portando RC=1 e resettando la macchina. Per tutti gli altri stati DJ=0.

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 N’D N’ x D’ x Q CR x D’ x N’ x Q’ 10 cent N’D’Q 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.78: Il diagramma degli stati della FSM e riportato in figura 6. 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 .

Soluzione Stato Init Codifica 1000000 Condizione N D Q N’D’Q’ 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 Codifica 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 CR’N’D’Q’ 0001000 N D Q CR CR’N’D’Q’ 0000100 N D+Q CR CR’N’D’Q’ 0000010 N+D+Q CR CR’N’D’Q’ 0000001 1 0100000 0010000 10cent 15cent 20cent Dispense La tabella degli stati e delle transizioni soprariportata identifica gli stati e la loro codifica come richiesta.48 FSM distributore automatico (2) Progettare un circuito sequenziale per il diagramma degli stati della macchina a stati del problema precedente. porte AND. porte OR ed inverter. Usare la tecnica di codifica one -hot per l’assegnazione degli stati. nonch´ le condizioni relative alle transizioni tra i vari e stati. La sintesi deve utilizzare solo flip flop D.6. 167 .

ingressi dei flip flop 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. e R (Root Beer). L (Lemon Soda). Ogni uscita del flip flop di stato ha assegnato come nome lo stato stesso. Quando sono inseriti 1. Tale distributore vende tutte le bevande a 1. per cui la codifica one-hot necessita di 7 flip-flop.Nella colonna delle uscite viene riportata solo l’uscita che in ogni stato e attiva ` a 1. la bevanda selezionata e fornita dal distributore ` ` che viene riportato allo stato iniziale.49 Distributore di bibite Si ricavi il diagrammi della macchina a stati per un distributore di bevande. Le uscite a 0 non vengono riportate. Quando la somma dei soldi e maggiore di £1. dove le uscite (di ` Moore) sono riportate vicino agli stati solo quando attive (a 1). O (Orange Soda).50£ a bottiglia.5£ allora un LED della macchina si illumina per indicare che la bevanda pu` essere selezionata. 168 . per esempio due banconote da £1. Le scelte o dei pulsanti sono C (Cola).50. Un’altra caratteristica del distributore e un ` LED che avverte l’utente che non sono disponibili due monete (cio` due gettoni e da 25 cent) per il resto qualora venga inserita una banconota da 1£. La macchina accetta solo banconote da 1£ (D=1) e monete da 25 centesimi (Q=1).79. Quando un pulsante e premuto. La FSM ha 7 stati. Su tale base e ` possibile identificare la rete di stato futuro e la rete di uscita: Rete di stato futuro . la macchina d` il ` a resto (due monete da 25 centesimi). Soluzione Il diagramma degli stati richiesti e riportato in figura 6.

D D No_Change No Ch DR D LT2Q DR DR DR DR DR CLOR Init Reset Q 25c Q 50c Q 75c Q 100c Q 125c 150c LED 200c Return_2_Quartes DR C L O Disp_Orange R Disp_Cola Disp_Lemon Disp_Root_Beer Figura 6.51 Contatore a 4 bit con T flip flop Disegnare un circuito che implementi un contatore a 4 bit sincrono con caricamento parallelo utilizzando dei flip-flop T. Simulare tale circuito e disegnare un diagramma temporale che ne verifichi il funzionamento desiderato. 6.79: 6. Soluzione il circuito richiesto e in figura 6. Soluzione Non disponibile. ` 169 .80.50 Sintesi di un JK Sintetizzare un circuito che implementi il codice scritto per l’esercizio precedente usando degli strumenti CAD.

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” ↑).Enable 0 1 T Q Q0 D0 Q 0 1 T Q Q1 D1 Q 0 1 T Q Q2 D2 Q 0 1 T Q Q3 D3 Q Output carry Load Clock Figura 6. Soluzione 170 .52 Up/Down counter con flip flop T Progettare un up/down counter a 3 bit utilizzando flip-flop di tipo T. se U /D = 0 il contatore decrementa ad ogni colpo di clock (conta “down” ↓).80: 6.

54 Contatore Il circuito in figura 6. In che sequenza conta? 171 . ` Up/Down 1 T Q Q0 0 1 T Q Q1 Q 0 1 T Q Q2 Q Clock Q Figura 6.82.81: 6.83 sembra essere un contatore.53 Up/Down counter con flip flop D Ripetere il problema precedente usando flip-flop D.81. ` Up/Down D Q Q0 0 1 D Q Q1 Q 0 1 D Q Q2 Q Clock Q Figura 6.Il circuito richiesto e riportato in figura 6. Soluzione Il circuito richiesto e riportato in figura 6.82: 6.

111. 172 .84. Il circuito ` dovrebbe usare porte logiche e sotto-circuiti come flip-flop. 010.83: Soluzione La sequenza di conteggio e 000. ` 6. etc. (b) Progettare un circuito in grado di effettuare la misura sperimentale del ritardo t p usando i segnali Interval e Reset.85. L’uscita di ogni inverter e un segnale periodico con un certo periodo. i cui diagrammi temporali sono mostrati in figura 6. Scrivere un’equazione che esprima il periodo dell’uscita f in funzione di t p e n. come mostrato in figura 6. contatori. ` f Figura 6. L’intervallo di tempo in cui Interval = 1 e pari a 100ns. registri.Q 0 Q 1 Q 2 1 T Q T Q T Q Clock Q Q Q Figura 6.84: (a) Tutti gli inverter sono identici e hanno lo stesso ritardo t p.55 Ring Oscillator Un ring-oscillator e un circuito con un certo numero dispari n di inverter connessi ` in una struttura ad anello chiuso. 001.

Cos` a ı ` sufficiente si ricava Tcycle .85: Soluzione (a) Il periodo dell’onda quadra prodotta dal ring oscillator vale Tcycle = 2 · n · t p Reset Interval Reset E Counter f Count Figura 6.RESET INTERVAL 100 ns 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). E quindi utilizzare un contatore come in figura 6. 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 . basta poi dividere tale tempo per 2 · n e si ottiene t p.86.

viene prodotto un impulso sia sull’uscita ` f sia su quella g. Il suo comportamento e descritto dal diagramma temporale riportato in figura 6. XOR e multiplexer 2-to-1 abbia un ritardo di propagazione tgate di 1 ns. f e g. e due uscite. Qual e la massima frequenza ` di clock alla quale il circuito pu` funzionare correttamente? o Soluzione 174 .56 Progetto di un circuito generatore di impulsi Un circuito logico ha due ingressi.57 Calcolo delay massimo e frequenza massima Per ogni flip-flop nel contatore riportato in figura 6. Clock e Start. Clock 1 0 Start 1 0 f 1 0 g 1 0 Figura 6. Quando ` un impulso e inviato all’ingresso Start.88. assumere che il tempo di set-up tsu sia di 3 ns. ` 6.89.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). il tempo di hold th sia pari a 1 ns e il tempo di propagazione clock-to-output tCK→Q di 1 ns. Soluzione Il circuito richiesto e riportato in figura 6.87. Assumere che ogni porta AND. secondo il diagramma temporale mostrato in figura.

passando attraverso la successione delle prime tre porte AND in cascata e inserendosi. all’ingresso del flip flop che genera Q3 . si scopre che il massimo ritardo combinatorio si ottiene uscendo dal flip flop che genera Qo 0. 175 .Start Clock Reset 3 bit counter f g Figura 6. tramite la porta EX-OR e il multiplexer.89. Nel caso proposto occorre riconoscere quale sia il percorso pi` lungo per la u definizione della massima frequenza operativa. Analizzando a fondo il circuito in figura 6.88: I tempi relativi ai componenti presenti nel circuito sono riportati nella tabella seguente: tsu = 3ns th = 1ns tCK→Q = 1ns tgate = 1ns Ricordiamo che il calcolo del percorso critico (critical path) richiede di calcolare tutti i percorsi che partono da ogni flip flop e arrivano all’ingresso di tutti flip flop 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 specifici). A questo ritardo occorre sommare il ritardo clock-to-output del flip flop posto all’inizio del path (il tutto scatta quando sul fronte del segnale di clock l’uscita Q0 commuta) e ad esso bisogna aggiungere il tempo di set-up del flip flop posto in fondo al path.

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 .

90. allora w0 s w1 Figura 6.dato che si deve garantire tale tempo prima di poter sentire il prossimo fronte di sincronizzazione del clock senza avere problemi di metastabilit` . il tempo di hold th sia pari a 1 ns e il tempo di propagazione clock-to-output tCK→Q di 1 ns. 1 MHz 9ns 6. Assumere che ogni porta AND.89 usando i parametri temporali seguenti: per ogni flip-flop assumere che il tempo di set-up tsu sia di 0.90: f 177 . OR e XOR abbia un ritardo di propagazione tgate di 1. a Se ne deduce quindi che il percorso critico e: ` tCK→Q0 → 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.contatore Determinare la massima frequenza di funzionamento per il circuito dell’esercizio precedente riportatoin figura 6. Soluzione Non esistendo il componente multiplexer in libreria.6ns.2ns mentre il ritardo di ogni inverter sia pari 1.58 Massima frequenza di funzionamento . occorre come prima cosa realizzarlo.1ns e non si abbia in libreria nessuna porta di tipo mutiplexer. Se si realizza come in figura 6.

9 ns Quindi FMAX = 1/9.01MHz 6.6 = 9.Bus con registri Ripetere il problema precedente per il circuito in figura 6.5ns mentre il ritardo di ogni inverter sia pari 1. Assumere inoltre che ogni porta AND abbia tAND = 1.5+0.91: Soluzione 178 .91 nell’ipotesi che k = 4.9 = 101.tmux = tNOT + tAND + tOR = 1.0+3*(1.89 Tmin = tCK→Q + 3(tAND) + tXOR + tMUX + tsu = 1.2 = 3.1+1.2+1.2)+1.1ns Bus R1 in R1 R2 in R2 Rk in Rk Clock Data S0 S j−1 Multiplexers Figura 6.59 Massima frequenza di funzionamento . il tempo di hold th sia pari a 1 ns e il tempo di propagazione clock-to-output tCK→Q di 1 ns.4ns. usando i parametri temporali seguenti: per i flip-flop assumere che il tempo di set-up tsu sia di 0.6ns.2+3.5 ns Per il circuito in figura 6. ogni porta OR abbia tOR = 1.

Dato che in figura 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 figura 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 = tCK→Q + 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 flop T
Scrivere il codice VHDL che descrive un flip-flop 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 Clock’EVENT 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 flop JK
Scrivere il codice VHDL che descrive un flip-flop 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 Clock’EVENT 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` modificare questo codice per implementare un crossbar-switch? o Soluzione (a) Il circuito descritto e riportato in figura 7.1 `

182

S x1
0 1

y1

x2

D

Q

y2

Clk

Q

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 d’uscita z = 0. E’permesso 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 figura 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 Clock’EVENT 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

3. 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 d’appoggio K che effettui l’EXOR dei due ingressi W1 e W2 : 1 se = 0 se = K = w1 + w2 w1 w2 Figura 7. e un’uscita z.3: k Il circuito che realizza la funzione K e riportato in figura 7. w1 e w2 . ` 186 .7. altrimenti z = 0. Se w1 = w2 per 4 cicli di clock consecutivi il circuito deve forzare z = 1.Riconoscimento di 2 ingressi uguali per 4 colpi di clock Un circuito sequenziale ha 2 ingressi.5 VHDL . La sua funzione e ` di comparare le sequenze in ingresso sui due ingressi.

STD_LOGIC. D ). SIGNAL K : STD_LOGIC. ` 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. BEGIN k <= w1 XOR w2.4: Il codice VHDL che descrive la macchina e: ` LIBRARY ieee. ARCHITECTURE Behavior OF Same_inputs IS TYPE State_type IS ( A. USE ieee.all. C. ENTITY Same_inputs IS PORT ( Clock : IN Resetn : IN w1. SIGNAL y : State_type. w2 : IN z : OUT END Same_inputs. STD_LOGIC ).Il diagramma a stati della macchina a stati e riportato in figura 7. STD_LOGIC. B. STD_LOGIC.4. Clock ) 187 . PROCESS ( Resetn.std_logic_1164.

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. ELSE y <= A. END IF. ELSE y <= A. END IF. ELSE ( Clock’EVENT AND Clock = ’1’ ) THEN CASE y IS WHEN A => IF k = ’0’ THEN y <= B.5. WHEN D => IF k = ’0’ THEN y<= D. z <= ’1’ WHEN y = D AND k = ’0’ ELSE ’0’.BEGIN IF Resetn = ’0’ THEN y <= A. ` 188 . END Behavior. WHEN C => IF k = ’0’ THEN y <= D. ` Scrivere poi il codice VHDL che descrive tale macchina a stati. END CASE. END PROCESS. END IF.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. ELSE y <= A. ELSE y <= A.6 VHDL . Soluzione Il diagramma a stati della macchina da realizzare e in figura 7. Ogni 3 bit sull’ingresso w in 3 cicli a di clock successivi. END IF. END IF. WHEN B => IF k = ’0’ THEN y <= C. 7.

USE ieee.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.std_logic_1164.all.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. ENTITY Parity_3 IS PORT ( Clock : IN STD_LOGIC. 189 .

BEGIN IF Resetn = ’0’ THEN y <= A ELSE ( Clock’EVENT AND Clock = ’1’ ) THEN CASE y IS WHEN A => IF w = ’0’ THEN y <= B. WHEN E => IF w = ’0’ THEN y<= F. : OUT STD_LOGIC ). E. END IF. END IF.Resetn w p END Parity_3. END IF. C. WHEN D => IF w = ’0’ THEN y<= A. Clock ). WHEN B => IF w = ’0’ THEN y <= D. WHEN F => IF w = ’0’ THEN y<= B. END IF. WHEN C => IF w = ’0’ THEN y <= E. END IF. : IN STD_LOGIC. END IF. ). F. ELSE y <= F. ARCHITECTURE Behavior OF Parity_3 IS TYPE State_type IS ( A. ELSE y <= E. ELSE y <= A. B. : IN STD_LOGIC. SIGNAL y : State_type. BEGIN PROCESS ( Resetn. END IF. ELSE y <= D. 190 . ELSE y <= C. END CASE. ELSE y <= C.

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

END IF . Soluzione Il codice VHDL richiesto e: ` LIBRARY ieee . END IF .all .all . U : IN STD_LOGIC . Clock. ELSIF U = ’1’ THEN Q <= Q+1 . 192 .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. ELSIF Clock’EVENT AND Clock = ’1’ THEN IF L = ’1’ THEN Q <= R . Resetn. END cntr_24 . USE ieee.STD_LOGIC unsigned. 7. Q : BUFFER STD_LOGIC_VECTOR(23 DOWNTO 0) ) . ENTITY cntr_24 IS PORT ( R : IN STD_LOGIC_VECTOR(23 DOWNTO 0) .std_logic_1164. Resetn ) BEGIN IF Resetn = ’0’ THEN Q <= (OTHERS => ’0’) . USE ieee. ARCHITECTURE Behavior OF cntr_24 IS BEGIN PROCESS ( Clock. L. END PROCESS .END Behavior . ELSE Q <= Q-1 .8 VHDL .

END upcount.Up/Down counter a 24 bit parametrico Modificare il codice VHDL seguente aggiungendo un parametro che setti il numero di flip flop nel contatore. BEGIN PROCESS ( Clock.END Behavior . E : IN STD_LOGIC.all.std_logic_unsigned. ` ` definito come GENERIC e di tipo INTEGER. ARCHITECTURE Behavior OF upcount IS SIGNAL Count: STD_LOGIC_VECTOR(3 DOWNTO 0).all. LIBRARY ieee. END PROCESS. ENTITY upcount IS PORT ( Clock. Q : OUT STD_LOGIC_VECTOR(3 DOWNTO 0)). Il parametro aggiunto e N. 193 .std_logic_1164. Resetn. END Behavior. Resetn ) BEGIN IF Resetn=’0’ THEN Count <= "0000".9 VHDL . END IF. ELSIF (Clock’EVENT AND Clock=’1’) THEN IF E=’1’ THEN Count <= Count+1. ELSE Count <= Count. END IF. USE ieee. 7. Q <= Count. Soluzione Il codice VHDL richiesto e riportato nel seguito. USE ieee.

END IF . ENTITY upcount_mod IS GENERIC ( N : INTEGER := 4 ) . USE ieee. Resetn ) BEGIN IF Resetn = ’0’ THEN Count <= (OTHERS ELSIF Clock’EVENT AND Clock = IF E = ’1’ THEN Count <= Count ELSE Count <= Count END IF . Q : OUT STD_LOGIC_VECTOR ( N-1 DOWNTO 0) ) . PORT ( Clock. USE ieee.std_logic_1164. ` LIBRARY ieee .all . ’1’ THEN + 1 .LIBRARY ieee . Resetn. BEGIN PROCESS ( Clock. 194 . Soluzione Il codice richiesto e riportato nel seguito. E : IN STD_LOGIC .Contatore up a 12 bit Scrivere il codice VHDL comportamentale che descrive un contatore up a modulo 12 con reset sincrono.all . END upcount_mod . END Behavior . Q <= Count .std_logic_unsigned. .10 VHDL . => ’0’) . 7. ARCHITECTURE Behavior OF upcount_mod IS SIGNAL Count : STD_LOGIC_VECTOR ( N-1 DOWNTO 0 ) . END PROCESS .

L : IN STD_LOGIC . ELSIF Clock’EVENT AND IF L = ’1’ THEN Q <= R .std_logic_1164. Clock = ’1’ THEN THEN 0 . END IF .Descrizione gerarchica Scrivere il codice VHDL gerarchico (strutturale) che descrive il circuito in figura 7.11 VHDL .7 usando come sotto-circuito il contatore disegnato in figura 7. 7. Q + 1 .6. ELSE IF Q = 11 Q <= ELSE Q <= END IF . END Behavior . 195 . ARCHITECTURE Behavior OF cntr_mod_12 IS BEGIN PROCESS ( Clock. Resetn. Resetn ) BEGIN IF Resetn = ’0’ THEN Q <= 0 . ENTITY cntr_mod_12 IS PORT ( R : IN INTEGER RANGE 0 TO 11 . END cntr_mod_12 .USE ieee.all . Q : BUFFER INTEGER RANGE 0 TO 11 ) . Clock. END IF . END PROCESS .

` LIBRARY ieee .std_logic_1164. 196 .all .6: Soluzione Il codice VHDL richiesto e riportato nel seguito. USE ieee.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.

Load : IN STD_LOGIC . ARCHITECTURE Structure OF bcd_counter IS COMPONENT count_4bit PORT ( D : IN STD_LOGIC_VECTOR(3 DOWNTO 0) . Enable. END COMPONENT .1 0 0 0 0 Enable D0 D1 D2 D3 Q Q Q Q 0 1 2 } } BCD 0 3 Load Clock Clock Clear 0 0 0 0 Enable D0 D1 D2 D3 Q Q Q Q 0 1 BCD 1 2 3 Load Clock Figura 7.7: ENTITY bcd_counter IS PORT ( Clock. Clock. Clear : IN STD_LOGIC . BCD1 : BUFFER STD_LOGIC_VECTOR(3 DOWNTO 0) ) . BCD0. END bcd_counter . Q : BUFFER STD_LOGIC_VECTOR(3 DOWNTO 0) ) . 197 .

Q => BCD1 ) .12 VHDL .all . Load1 : STD_LOGIC . Load => Load1. Load => Load0. END Structure . cnt1: count_4bit PORT MAP ( Clock => Clock. Enab1 : STD_LOGIC . USE ieee. SIGNAL Enab0. ENTITY johnson_cntr IS PORT ( Clock. SIGNAL Zero : STD_LOGIC_VECTOR(3 DOWNTO 0) . Resetn : IN STD_LOGIC . Soluzione Il codice VHDL del contatore Johnson (vedi appunti di teoria) e riportato nel ` seguito: LIBRARY ieee . ARCHITECTURE Behavior OF johnson_cntr IS 198 . Load0 <= Enab1 OR Clear . D => Zero.Johnson counter Scrivere il codice VHDL che descrive un contatore Johnson a 8 bit.std_logic_1164. END johnson_cntr . cnt0: count_4bit PORT MAP ( Clock => Clock. Load1 <= (BCD1(0) AND BCD1(3)) OR Clear . Q => BCD0 ) . Sintetizzare il codice con gli strumenti CAD e fare una simulazione temporale che mostri la sequenza di conteggio. Enable => Enab0. Enable => Enab1.SIGNAL Load0. Q : BUFFER STD_LOGIC_VECTOR(0 TO 7) ) . BEGIN Zero <= "0000’’ . Enab1 <= BCD0(0) AND BCD0(3) . 7. Enab0 <= ’1’ . D => Zero.

END PROCESS . 7.13 VHDL . END IF . USE ieee. ELSIF Clock’EVENT AND Clock = ’1’ THEN Q <= (NOT Q(7)) & Q(0 TO 6) . LIBRARY ieee. ARCHITECTURE Behavior OF shiftn IS BEGIN PROCESS BEGIN WAIT UNTIL Clock’EVENT ADN Clock=’1’. L. Q : BUFFER STD_LOGIC_VECTOR(N-1 DOWNTO 0)). Resetn ) BEGIN IF Resetn = ’0’ THEN Q <= "00000000’’ .BEGIN PROCESS ( Clock. col parametro N che indica il numero di flip-flop nel contatore. END shiftn. Clock : IN STD_LOGIC. ENTITY shiftn IS GENERIC (N:INTEGER:=8). w : IN STD_LOGIC. END Behavior . 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. 199 . PORT ( R : IN STD_LOGIC_VECTOR(N-1 DOWNTO 0).all.std_logic_1164.Ring Counter Scrivere il codice VHDL comportamentale che descriva un ring-counter. IF L=’1’ THEN Q <= R.

ENTITY ring_counter IS GENERIC ( N : INTEGER := 8 ) . Q(0) <= Q(N-1) .ELSE Genbits: FOR i IN 0 TO N-2 LOOP Q(i) <= Q(i+1). PORT ( Clock.std_logic_1164. ARCHITECTURE Behavior OF ring_counter IS BEGIN PROCESS ( Clock. USE ieee. END Behavior. END LOOP . END IF . parametrico sul numero di flip flop (N) e descritto con lo stile indicato nel testo dell’esercizio. Q : BUFFER STD_LOGIC_VECTOR(0 TO N-1) ) . Soluzione Il codice proposto. Q(N-1) <= w. END PROCESS. END ring_counter . END LOOP. e riportato ora: ` LIBRARY ieee . Start : IN STD_LOGIC . Start ) BEGIN IF Start = ’1’ THEN Q <= (OTHERS => ’0’) .all . END PROCESS . END IF. ELSIF Clock’EVENT AND Clock = ’1’ THEN GenBits: FOR i IN 1 TO N-1 LOOP Q(i) <= Q(i-1) . 200 . Q(0) <= ’1’ .

Descrizione comportamentale Scrivere il codice VHDL comportamentale che descrive le funzionalit` del circuia to riportato in figura 7. 7.14 VHDL .END Behavior ..STD_LOGIC unsigned. USE ieee. Clock Sum[3. 201 .8.0] REG data[3.all . Reset : IN STD_LOGIC ..std_logic_1164. USE ieee.. ENTITY add_Q_Data IS PORT ( Clock.0] A A+B B reset clock result[3..0] datab[3...0] Reset Figura 7.0] q[3...8: Soluzione Il codice richiesto e: ` LIBRARY ieee . Data : IN STD_LOGIC_VECTOR(3 DOWNTO 0) .0] Data[3.0] Q[3.0] dataa[3.all .

sintetizzarlo e farne una simulazione temporale. Extern RinExt BusWires END swap. USE ieee. ELSIF Clock’EVENT AND Clock = ’1’ THEN Q <= Q + Data . END add_Q_Data. R3: STD_LOGIC_VECTOR(7 DOWNTO 0). END Behavior . ENTITY swap IS PORT ( Data Resetn. R2. SIGNAL R1. STD_LOGIC_VECTOR(7 DOWNTO 0)).15 Simulazione e sintesi CAD Di seguito viene proposto il codice VHDL che descrive un sistema digitale che scambia il contenuto di due registri. Usare gli strumenti CAD per creare uno schema del sistema.all. STD_LOGIC.components. STD_LOGIC. USE work. ARCHITECTURE Behavior OF add_Q_Data IS BEGIN PROCESS ( Clock. : : : : : IN IN IN IN INOUT STD_LOGIC_VECTOR(7 DOWNTO 0). BEGIN control: shiftr GENERIC MAP (K => 3) 202 . usando R3 come registro temporaneo. w Clock. STD_LOGIC_VECTOR(1 TO 3). Reset ) BEGIN IF Reset = ’1’ THEN Q <= ’’0000’’. END IF . Q: STD_LOGIC_VECTOR(1 TO 3). LIBRARY ieee. ARCHITECTURE Behavior OF swap IS SIGNAL Rin. END PROCESS . Rout.all. R1 e R2.Q : BUFFER STD_LOGIC_VECTOR(3 DOWNTO 0) ) .std_logic_1164. 7.

tri3: trin PORT MAP (R3. Q). Rin(1). tri2: trin PORT MAP (R2. w. BusWires). END Behavior. tri1: trin PORT MAP (R1. BusWires). Rout(3) <= Q(3).R2 in out R3 . Rin(1) <= RinExt(1) OR Q(3). BusWires). reg2: regn PORT MAP (BusWires.9: 203 . Clock. tri_ext: trin PORT MAP (DATA. Rin(2). R2).R1 in out w D Q D Q D Q Clock Q Q Q Reset Figura 7. reg3: regn PORT MAP (BusWires. Rin(3). Extern. Clock. Rout(3). 7. Rin(3) <= RinExt(3) OR Q(1). Rout(1). R1). Clock. Clock. reg1: regn PORT MAP (BusWires.9. BusWires). Rout(2). Rin(2) <= RinExt(2) OR Q(2). Soluzione Non disponibile. R3).R3 in out R1 .Rout(2) <= Q(1).PORT MAP (Resetn. R2 . Rout(1) <= Q(2).16 Simulazione e sintesi CAD (2) Ripetere il problema precedente usando il circuito di controllo mostrato in figura 7.

encoder: WITH S SELECT S <= "00" WHEN "000" 204 .Soluzione Non disponibile.components.Rout(2) <= Q(1). reg1: regn PORT MAP (BusWires. Clock. Clock. SIGNAL R1. BUFFER STD_LOGIC_VECTOR(7 DOWNTO 0)). Rin(3). ARCHITECTURE Behavior OF swapmux IS SIGNAL Rin. : : : : : IN STD_LOGIC_VECTOR(7 DOWNTO 0). Q).all. IN STD_LOGIC. R2. Rin(1).17 Simulazione e sintesi CAD (3) Modificare il seguente codice VHDL in modo da usare il circuito di controllo del problema precedente. ENTITY swapmux IS PORT ( Data Resetn. w. R2).std_logic_1164.all. R3: STD_LOGIC_VECTOR(7 DOWNTO 0). Q: STD_LOGIC_VECTOR(1 TO 3). USE work. reg2: regn PORT MAP (BusWires. IN STD_LOGIC. Rin(3) <= RinExt(3) OR Q(1). Rout(1) <= Q(2). Rin(2) <= RinExt(2) OR Q(2). Clock. Rout(3) <= Q(3). Clock. BEGIN control: shiftr GENERIC MAP (K => 3) PORT MAP (Resetn. w Clock RinExt BusWires END swapmux. SIGNAL S: STD_LOGIC_VECTOR(1 DOWNTO 0). R1). R3). LIBRARY ieee. reg3: regn PORT MAP (BusWires. Rin(1) <= RinExt(1) OR Q(3). USE ieee. Sintetizzare il codice ottenuto per implementarlo in un chip e farne una simulazione temporale. IN STD_LOGIC_VECTOR(1 TO 3). Rin(2). 7.

Contatore BCD a 4 digit Scrivere il codice VHDL comportamentale che descrive un contatore BCD a 4 digit. ENTITY digit IS PORT ( Clock. Clear.18 VHDL . nine : OUT STD_LOGIC ) . USE ieee. USE ieee. ARCHITECTURE Spec OF digit IS BEGIN 205 . 7. E : IN STD_LOGIC ."10" WHEN "100" "01" WHEN "010" "11" WHEN OTHERS.all . BCD_digit : BUFFER STD_LOGIC_VECTOR(3 DOWNTO 0) . END Behavior. muxes: --eight 4-to-1 multiplexers WITH S SELECT BusWires <= Data WHEN "00" R1 WHEN "01" R2 WHEN "10" R3 WHEN OTHERS. Soluzione Il code VHDL richiesto del contatore BCD a un digit e: ` LIBRARY ieee . END digit . Soluzione Non disponibile.all .STD_LOGIC unsigned.std_logic_1164.

PROCESS (BCD_digit) BEGIN IF BCD_digit = ’’1001’’ THEN nine <= ’1’ . USE ieee. END IF . ELSE BCD_digit <= BCD_digit + ’1’ .std_logic_1164. BCD0 : BUFFER STD_LOGIC_VECTOR(3 DOWNTO 0)) .all . ARCHITECTURE Behavior OF 4_BCD_count IS SIGNAL Carry : STD_LOGIC_VECTOR(4 DOWNTO 1) . BCD1. END IF . E : IN STD_LOGIC . USE ieee. BCD3. BCD2. Clear. END Spec . mentre il codice del contatore a 4 digit e ` LIBRARY ieee .STD_LOGIC unsigned. END IF . ELSIF E = ’1’ THEN IF BCD digit = ’’1001’’ THEN BCD_digit <= "0000’’ . END PROCESS . END PROCESS . ENTITY 4_BCD_count IS PORT ( Clock.all . 206 . ELSE nine <= ’0’ . END 4_BCD_count. END IF .PROCESS (Clock) BEGIN IF Clock’EVENT AND Clock = ’1’ THEN IF Clear = ’1’ THEN BCD_digit <= "0000’’ .

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

Definire l’ASM chart per il controllo del circuito 4.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.B. 1. end while. Discutere i pro e i contro del circuito confrontandolo con quello canonico (visto a lezione) Soluzione 208 . Scrivere il codice VHDL che rappresenta il circuito del divisore 5. Derivare il datapath in grado di realizzare la parte di esecuzione dell’algoritmo di divisione 3.Capitolo 8 Progettazione di sistemi digitali 8.B ) > 0 ) do R = R . Definire un ASM chart che interpreti l’algoritmo definito dallo pseudocodice 2. R = A. Q = Q + 1. while (( R .

Il datapath che esegue la parte operativa dell’algoritmo e riportato in figura ` 8. 209 . Si noti ` come siano definiti tre stati computazionali (S1.1.2. La ASM chart dell’algoritmo di divisione e riportata in figura 8. Reset S1 Load A Load B Q 0 0 s 1 S3 0 s 1 S2 Done R Q R−B Q+1 1 R−B>=0? Figura 8. S2 e S3).1: 0 2.1.

std_logic_1164.std_logic_unsigned. Q : OUT INTEGER RANGE 0 TO P2N-1.all. ENTITY Divider IS GENERIC ( N : INTEGER := 8.all.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. In figura 8. USE ieee. s : IN STD_LOGIC. USE work. DataA. DataB : IN STD_LOGIC_VECTOR(N-1 DOWNTO 0). P2N : INTEGER := 256 ).all.2: 3.R sel A LoadB B 1 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 R−B Q Figura 8. R : BUFFER STD_LOGIC_VECTOR (N-1 DOWNTO 0). Il codice VHDL che descrive tutto il circuito che esegue la divisione e ` riportato di seguito: LIBRARY ieee. Resetn.components. PORT ( Clock. LoadA. LoadB : IN STD_LOGIC. 210 . USE ieee. 4.

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

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

8. LQ. Definire l’ASM chart del controllo del circuito 5. Scrivere il codice VHDL che descrive il circuito che calcola il logaritmo Soluzione 213 . se i due numeri A e B sono piccoli.RegB: regne GENERIC MAP ( N => N ) PORT MAP ( DataB. B ). Q ). CntQ: prob10_1 GENERIC MAP ( modulus => P2N ) PORT MAP ( Resetn. Cout <= RminusBwCarry ( N ). Resetn. END Behavior. Zero. mentre il metodo delle sottrazioni ripetute impiega 2n cicli nel caso peggiore che si verifica quando si divide per 1. RminusB <= RminusBwCarry ( N-1 DOWNTO 0 ).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. RminusBwCarry <= ("0" & R) + ("0" & (NOT B)) + 1. il metodo delle sottrazioni ripetute e un’approccio non particolarmente penalizzante rispetto ` all’algoritmo completo. Infatti l’algoritmo presentato a lezione e in grado di eseguire una divisione ` in n cicli per n bit in ingresso. Definire la ASM chart dell’algoritmo 3. 5. LoadB. Pro e contro: Questa versione dell’algoritmo di divisione e meno efficiente ` nel worst case se confrontata all’altra implementazione mostrata a lezione. Derivare il datapath corrispondente all’unit` di esecuzione che relizza l’ala goritmo 4. Clock. In particolare: 1. Zero <= 0. D’altra parte. Mostrare tutti i passi del progetto e illustrare ogni assunzione fatta. Definire lo pseudocodice dell’algoritmo da implementare 2. Clock. EQ.

end while. 214 . L sia il ` logaritmo da calcolare rispetto al numero K. – 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 Shift−right K Done = 1 1 L L+1 K > 1? 0 Figura 8. Dall’analisi della ` ASM chart si nota come sia necessario uno shift-register per dividere K per due e un contatore per L.1. L = L + 1. La ASM chart dello pseudocodice e riportata in figura 8. Lo pseudocodice che realizza l’algoritmo e definito nel seguito.4: 2.4. – si assuma che K ≥ 1 L = 0. while ( K > 1 ) do K = K / 2.

5. Come si pu` notare ci sono principalmente tre blocchi: uno shift regio ster. un contatore ed un rilevatore di maggioranza per definire se il numero K e maggiore di uno.all. USE ieee.components. ENTITY Log_2 IS PORT ( Clock. L : BUFFER INTERGER RANGE 0 TO 7. USE ieee.5: 4. 215 .std_logic_1164. s : IN STD_LOGIC.all.3. Il codice VHDL del circuito e: ` LIBRARY ieee. USE work. ` LK Data n L L LL 0 log n 2 EK E Shift−right EL E Counter K n Clock L K > 1? Kgt1 Figura 8. Il Datapath che esegue la parte operativa dell’algoritmo e riportato in figura ` 8.std_logic_unsigned. ` 5.all. La ASM chart del controllo del circuito e riportata in figura 8. Resetn. Data : IN STD_LOGIC_VECTOR ( 7 DOWNTO 0 ).6. LK.

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

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

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. contenenti numeri SIGNED caricabili tramite l’ingresso dati IN a 16 bit per eseguire le seguenti operazioni assumendo una rappresentazione in complemento a 2 e ignorando l’overflow: 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.END Behavior.3 Scambio a 3 registri . 218 .progetto Progettare un circuito digitale con 3 registri a 16 bit AR. BR e CR.7: 8.

` La ASM chart del circuito di controllo che controlla e gestisce il datapath nei vari passi algoritmici e in figura 8. Se il numero in AR e maggiore di zero. Se il numero in AR e zero.8: La ASM chart dell’algoritmo e riportata in figura 8. 3.9. moltiplicare il contenuto di AR per 2 ` e trasferire il risultato in CR.8. ` Scrivere il codice VHDL che implementa tale circuito. Il datapath che realizza l’algoritmo proposto e riportato in figura 8. Se il numero in AR e minore di zero. ` 219 . moltiplicare il contenuto di BR per ` 2 e trasferire il risultato in CR.7. 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. 4. Si tratta di un algoritmo ` a 5 stati che gestisce il caricamento dei dati (SB ) e le operazioni richieste (stati SCi ). resettare il registro CR a 0.2. Lo stato SA rappresenta lo stato di idle.

LB. LC.11 il circuito di controllo che pu` essere usato per scambiare i contenuti o dei registri R1 eR2.10 e rappresentato un sistema con 3 registri.Reset SA LA.4 Scambio a 3 registri . Soluzione La ASM chart richiesta e in figura 8.12. RSTC 0 Ottimizzazioni SEL = NEG RSTC = Zero 0 G=O? SB 1 LA 1 −1 (<0) S C1 LB LC SEL 1 1 1 Zero.ASM chart Nella figura 8. ` 220 . SEL.9: 8. e nella ` figura 8. da R1 a R3. NEG S C 2(=0) 10 LB RSTC 1 1 00 (>0) S C3 LB LC 1 1 Figura 8. Progettare una ASM chart che rappresenti questo sistema digitale e l’operazione di scambio.

11: 8. R1 in w D Q D Q D Q Clock Q Q Q Reset Figura 8.Data Extern Bus Clock R1 R2 R3 R1in R1out R2in R2out R3in R3out Function Control circuit Figura 8.ASM chart (2) (a) Per la ASM chart ottenuta nell’esercizio precedente. derivare la ASM chart che specifica i segnali di controllo richiesti per controllare il datapath. Assumere che i multiplexer siano usati per realizzare un bus che collega i registri. R2 in R3 out .10: R2 our . come mostrato 221 . R3 in R1 out .5 Scambio a 3 registri .

USE work. 222 . USE ieee.components.14. (b) Scrivere il codice VHDL completo per il sistema del problema precedente.all . ` (b) Il codice VHDL e riportato nel seguito: ` LIBRARY ieee .all . incluso il circuito di controllo del punto (a).all .12: nella figura 8. USE ieee.std_logic_unsigned.13.Reset S1 Load registers 0 w 1 S2 R3 S3 R1 S4 R2 R3 R3 R1 Figura 8.std _ogic_1164. Soluzione (a) La ASM chart di controllo richiesta e in figura 8.

R1 in S4 R3 out . R3 in S3 R2 out . R3 in Figura 8.14: 223 .Bus R1 in Clock R1 R2 in R2 Rk in Rk Data S0 S j−1 Multiplexers Figura 8.13: Reset S1 0 w 1 S2 R1 out .

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

GENERIC MAP ( BusWires. Clock. Rin(2). Rin(3). Clock. progettare un circuito in grado di ordinare la lista (il contenuto dei registri) in ordine crescente. R1 ). -. 8. END Behavior . . R3 WHEN "001". Scrivere il codice VHDL che rappresenta il circuito Soluzione 225 . Progettare il Datapath corrispondente 4. Data WHEN OTHERS . Derivare l’ASM chart dell’algoritmo 3. Clock.WHEN S4 => Rout(3) <= ’ 1’ .. Definire l’ASM chart del controllo del circuito per l’ordinamento 5. . ( N => N) Resetn. GENERIC MAP ( BusWires.Mux WITH Rout SELECT BusWires <= R1 WHEN "100". ( N => N) Resetn. Rin <= RinCtrl OR RinExt . Reg1: regne PORT MAP Reg2: regne PORT MAP Reg3: regne PORT MAP GENERIC MAP ( BusWires. RinCtrl(2) <= ’ 1’ END CASE . R2 WHEN "010". R2 ). Rin(1)..Sorting Data una lista di k numeri UNSIGNED di n bit memorizzati nei registri R0 . Definire lo pseudo-codice dell’algoritmo 2. 1.Rk−1. END PROCESS . R3 ).6 Ordinamento . ( N => N) Resetn.

15: 1. Pseudo-codice dell’algoritmo Lo pseudo-codice dell’algoritmo e il seguente: ` 226 .Reset S1 Ci 0 Load registers 0 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 1 S6 Rj S7 Ri A B 0 C j=k−1? 1 S9 Done 1 s 1 0 0 C i=k−2? Figura 8.

il circuito passa allo stato S6.. end i f . 3. i registri vengono caricati dall’ingresso dati esterno e viene azzerato il contatore Ci che rappresenta i nel ciclo pi` esterno.. che rappresenta j nel ciclo pi` interno. end f or. i f B < A then Ri = B. A ogni iterazione del ciclo pi` esterno il numero contenuto in Ri viene posizionato u in A. Lo u stato S3 viene utilizzato per inizializzare j al valore i + 1.. Nello stato iniziale S1. il controllo del flusso e pi` semplice ` u se questa operazione viene effettuata in entrambi i casi. Sebbene questo passo sia necessario solo nel caso in cui B < A. al valore di i. 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 . Quando il circuito passa allo stato S2.f or i = 0 to k − 2 do A = Ri .15 e riportata l’ASM chart che rappresenta l’algoritmo di or` dinamento. R j = A.Rk−1 e lo spostamento di tale numero in Ri per i = 1. e se B < A. 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. k − 2. 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 l’ordinamento. Viene inizializzato anche C j . viene caricato A con il contenuto di Ri . . 2. A = Ri . Nello stato S4 viene caricato il valore di R j in B. Lo stato S8 carica Ri in A. A ogni iterazione del ciclo pi` interno tale numero viene confrontato u con un’altro contenuto nel registro R j . Datapath 227 .. Gli stati S6 ed S7 scambiano i valori di Ri e R j . end f or. L’algoritmo si basa sul ritrovamento del numero pi` piccolo nella sottolista u Ri . 2.. Nello stato S5 vengono confrontati A e B. mentre s = 0. f or j = i + 1 to k − 1 do B = R j. ASM chart Nella figura 8.

. .16 e 8. DataIn n 0 1 RData WrInit Rin 0 E Rin 1 E Rin 2 E Rin 3 E R0 R1 0 1 2 3 R 2 R3 Imux ABData Ain E Bin E n Rd Clock DataOut 1 0 Bout A < B BltA Figura 8. Per semplicit` suppoa niamo che l’ordinamento venga fatto su 4 registri (k = 4). La figura 8.16: Una possibilit` e illustrata nelle figure 8..16 mostra a` come i registri R0 .17.Ci sono diversi modi di implementare il datapath del circuito che rispetti i requisiti dell’ASM chart mostrata precedentemente. Rk−1 possano essere connessi ai registri A e B utiliz228 ..

sono riconnessi all’ingresso dei registri R0 . Una ASM chart che mostra i segnali di controllo utilizzati nel datapath e riportata in figura 8... Il buffer tri-state e pilotato dal segnale ` di controllo Rd e viene utilizzato per fornire in uscita i contenuti dei registri sull’uscita DataOut. 0 2 LI EI L E R Counter Q LJ EJ L E R Counter Q 2 Clock Ci Cj 2 =k−2 zi zj 2 Csel 0 1 =k−1 Cmux RAdd 0 Int Imux 1 2 w0 . w 1 y0 y1 Rin Rin Rin Rin 0 1 WrInit En Wr y2 y3 2 3 2−to−4 decoder Figura 8. Rk−1. Se Int = 0 allora il decoder ` e pilotato dall’ingresso esterno RAdd. I segnali zi e z j sono forzati a 1 se ` Ci = k − 2 e C j = k − 1.zando un multiplexer 4-to-1. per mezzo dei multiplexer. ` 229 . .17: I segnali Rin0 . I registri A e B sono connessi al sottocircuito comparatore e. ... Se Int = 1 il decoder e pilotato da uno dei contatori Ci o C j . 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 l’indirizzo del registro sull’ingresso RAdd.. Rink−1 sono controllati da un decoder 2-to-4.18.

Aout S7 Csel=0. LJ S3 EJ S4 Bin. Int=0 0 s 1 S2 Int=1.all. USE ieee. Bout zj 0 1 0 zi 1 S9 Done s 1 0 Figura 8. USE work.all. Csel=0. Int=1. Wr. ENTITY sort IS GENERIC ( N : INTEGER := 4 ).components.Reset S1 LI. Ain 1 S6 Csel=1. 230 . Csel=1.std_logic_1164. Wr. Int=1. Int=1. Ain.18: Il codice VHDL che descrive il circuito e : ` LIBRARY ieee. Int=1 S5 EI EJ BltA 0 S8 Csel=0.

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

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

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

20: 234 . ` R0 L E 0 0 W 1 1 D Q Clk Q’ Q0 Figura 8. zj <= ’1’ WHEN Cj = 3 ELSE ’0’. DataOut <= ( OTHERS => ’z’ ) WHEN Rd = ’0’ ELSE ABData.19 e rappresentato il circuito di uno shift register in cui l’ingresso di ` controllo del caricamento parallelo e indipendente dall’ingresso di enable.zi <= ’1’ WHEN Ci = 2 ELSE ’0’. E R0 L R1 Rn−1 0 0 0 0 D 1 Q 1 1 Q’ Q’ D Q 0 0 1 1 Q’ D Q W Clk 1 Q0 Q1 Qn−1 Figura 8. END Behavior. Dise` gnare un circuito alternativo di uno shift register che pu` compiere l’operazione di o caricamento parallelo solo se l’ingresso di enable e contemporaneamente attivo.7 Shift register Nella figura 8.19: 8.

include uscite di tipo Moore negli stati S1.8 Counter La ASM chart in figura 8.19.21.20. ` 8. ed ha un’uscita di tipo Mealy nello stato S2.21: • (a) Illustrare come la ASM chart possa essere modificata in modo da avere nello stato S2 solo uscite di tipo Moore. che descrive un circuito contatore. S2. Il primo bit del circuito e mostrato nella figura 8. ed S3. 235 . Reset S1 Load A B 0 0 0 1 s 1 S2 Shift A s S4 Done S3 1 B B+1 A = 0? 0 0 a 0 1 Figura 8.Soluzione Nello shift register modificato l’ordine dei multiplexer che compiono le azioni di caricamento ed enable sono scambiate rispetto alla Figura 8.

• (b) Disegnare la ASM chart per il circuito di controllo corrispondente alla parte (a). Soluzione (a) Una ASM chart che ha solo uscite di tipo Moore allo stato S2 e mostrata ` in figura 8. ` (c) Il codice VHDL del circuito di controllo segue: 236 . Reset S1 Load A B 0 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. • (c) Scrivere il codice VHDL che rappresenta il circuito di controllo modificato.22: (b) La ASM chart del circuito di controllo e in figura 8.22.23.

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

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

EA. END IF . END IF . END Behavior . ShiftA: shiftrne GENERIC MAP ( N => 8 ) PORT MAP ( Data. 239 . ELSE B <=B+1. 8. Il circuito usa uno shift register per B cos` che il bit meno significativo b0 possa essere usato per ı decidere se A debba o no essere addizionato al registro che mantiene il prodotto parziale P. Clock. LA.9 Moltiplicatore somma/shift La figura 8. ELSIF (Clock’ EVENT AND Clock = ’ 1’ ) THEN IF EB = ’ 1’ THEN IF LB = ’ 1’ THEN B <=0. low. -. A ) .END PROCESS . Un approccio differente pu` essere l’utilizzo di un normale registro per o mantenere B e di un contatore e un multiplexer per selezionare i bit bi in ogni fase dell’operazione di moltiplicazione. Clock ) BEGIN IF Resetn = ’ 0’ THEN B <=0. END PROCESS . z <= ’ 1’ WHEN A = "00000000" ELSE ’ 0’ . low <= ’ 0’ .Il datapath e’ descritto di seguito: PROCESS ( Resetn. invece di uno shift register. END IF .24 mostra il datapath per un moltiplicatore Add/Shift. (a) Illustrare la ASM chart che usa un normale registro per B.

LA 0 Data A LB Data B n n n L L Shift−left EA E Shift−right EB E register register B Clock 2n n + Sum 0 2n Psel 1 0 2n DataP EP E 2n z b0 Register 2n P Figura 8. (d) Scrivere il codice VHDL che rappresenta il circuito moltiplicatore. (c) Disegnare la ASM chart per il circuito di controllo corrispondente al punto precedente.24: (b) Illustrare il datapath corrispondente. 240 .

components. C 0 0 0 1 s 1 S2 Shift left A. C C+1 s S3 Done 1 P P+A C=n−1 0 0 b C 1 Figura 8. USE ieee.std_logic_unsigned.all .26.25: (b) Il datapath corrispondente e riportato in figura 8. USE work. Si ` assuma che il segnale EB sia pilotato da una logica esterna. ENTITY add_sh IS 241 . USE ieee.all . ` (c) La ASM chart per il circuito di controllo e mostrata in figura 8.25. (d) Il codice VHDL del circuito e riportato nel seguito ` LIBRARY ieee . ` Reset S1 Load A Load B B 0 .std_logic_1164.27.all .Soluzione (a) La ASM chart richiesta e in figura 8.

DataB : IN STD_LOGIC_VECTOR(N . NN : INTEGER := 16 ) .1 DOWNTO 0).26: GENERIC ( N : INTEGER := 8 .1 DOWNTO 0). s : IN STD_LOGIC . Done : OUT STD_LOGIC ) . END add_sh . Resetn : IN STD_LOGIC . PORT ( Clock : IN STD_LOGIC . LB.LA 0 Data A Data B n n LC 0 L LB EA E E L Shift−left Register EC E Counter C Clock 2n + n log n 2 Sum 0 2n Psel 1 0 b 2n DataP EP E z C 2n n−to−1 Register 2n P Figura 8.1 DOWNTO 0). ARCHITECTURE Behavior OF add_sh IS 242 . LA. DataA : IN STD_LOGIC_VECTOR(N . P : BUFFER STD_LOGIC_VECTOR(NN .

27: TYPE State_type IS ( S1. SIGNAL ZeroI. SIGNAL B. SIGNAL Psel. SIGNAL y : State_type . SIGNAL A. EP. C : INTEGER RANGE 0 TO N . N Zeros : STD_LOGIC_VECTOR(N .Reset S1 Psel = 0. Bc. EP. Sum : STD_LOGIC_VECTOR(NN . Zero : STD_LOGIC . S2. Ain.1 DOWNTO 0) .1. LC. S3 ) . EA. EC Done EP 1 z 0 0 b C 1 Figura 8. 243 . SIGNAL EC. EA. z : STD_LOGIC . LC 0 s 1 0 1 s S2 S3 Psel = 1. DataP.1 DOWNTO 0).

END PROCESS . CASE y IS WHEN S1 => EP <= ’ 1’ . Bc ) BEGIN EP <= ’ 0’ . THEN y <= S3 . END CASE .BEGIN FSM_transitions: PROCESS ( BEGIN IF Resetn = ’ 0’ THEN y <=S1.datapath Zero <= N Zeros Ain <=N ShiftA: PORT ’ 0’ . EA <= ’ 1’ . <= (OTHERS => ’ 0’ ). END IF . Zero. shiftlne GENERIC MAP ( N => NN ) MAP ( Ain. EA <= ’ 0’ . END PROCESS . LC <= ’ 1’ . IF Bc = ’ 1’ THEN EP <= ’ 1’ . Done <= ’ 0’ . EC <= ’ 1’ . END IF . Clock. -. Clock ) Clock=’ 1’ ) y <= S1 .LC<= ’ 0’ . WHEN S3 => Done <= ’ 1’ . LA. THEN y <= S2 . Resetn. EC <=’ 1’ . WHEN S2 => Psel <= ’ 1’ . Psel <= ’ 0’ . FSM_outputs: PROCESS ( y. Zeros & DataA . END IF . ELSE y <= S1 . END IF . ELSE y <= S3 . 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 . 244 . END IF . LC <= ’ 0’ . EC <= ’ 0’ . EA. ELSE y <= S2 . A ) . ELSE EP <= ’ 0’ .

Clock. C ) . Clock. END Behavior . Sum <=A+P.28: RegB: regne GENERIC MAP ( N => N) PORT MAP ( DataB. LC. B ) . P ) . EC. Resetn. ZeroI <=0.controlla se tutti gli n bit di B sono stati utilizzati z <= ’ 1’ WHEN (C = (N . LB.0 n Rsel 1 0 LA DataA n EB DataB n LR ER L E Left−shift register n w EA L E Left−shift register n E Register n an−1 A B EQ E Left−shift register n w cout + cin n 1 Clock Q R Figura 8. DataP <= Sum WHEN Psel=’ 1’ ELSE (OTHERS => ’ 0’ ) .Multiplexer per selezionare il bit C da B Bc <= B(C) . -. Resetn. 245 . upcounter: prob10 1 GENERIC MAP ( modulus => N) PORT MAP ( Resetn. ZeroI. -. Clock.1)) ELSE ’ 0’ . RegP: regne GENERIC MAP ( N => NN ) PORT MAP ( DataP. EP.

Codice VHDL Scrivere il codice VHDL per il circuito divisore che ha il datapath riportato in figura 8.29: 8.29. 246 .Figura 8.28 e il circuito di controllo rappresentato dalla ASM chart in figura 8.10 Divisore .

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

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

Done 0 zz 1 Figura 8. Ssel = 0. ES 0 z 1 S3 LA. ES 0 s 1 S2 EC Ssel = 1.30: CNT C: PROCESS (Clock) BEGIN IF Clock’ EVENT AND Clock=’ 1’ IF EC=’ 1’ THEN 249 THEN .Reset S1 Lc. EB 0 s 1 S4 Div S5 Div.

Soluzione Lo stato S3 si occupa di caricare gli operandi nel divisore. chiamato S3.std_logic_1164. END Behavior . mentre S4 avvia l’operazione di divisione. Possiamo usare il flag z per segnalare la prima volta che entriamo nel nuovo stato equivalente. Definire una ASM chart che combini gli stati S3 e S4 in un unico stato.Codice VHDL Scrivere il codice VHDL per la macchina stati complessa rappresentata dalla ASM chart definita nel problema precedente. Q <=QR. END IF.1 . END IF .all . ` 8. 250 . Questi stati possono essere fusi in un unico stato.1 .31. ELSE CR <=CR . il flag z va a 0. La ASM chart di controllo del circuito e mostrata in figura 8. Quando z = 1 viene prodotto un’uscita di Mealy che carica gli operandi e decrementa il contatore. Soluzione Il codice VHDL e: ` LIBRARY ieee .30. Poi. END PROCESS . END IF . USE ieee. z <= ’ 1’ WHEN CR=0 ELSE ’ 0’ . Il nuovo stato ora produce un’uscita Mealy che comincia la divisione a patto che z = 0.IF LC=’ 1’ THEN CR<=N .12 ASM chart equivalente . 8. i due stati S3 e S4 sono usati per elaborare il risultato M = Sum/k.11 ASM chart equivalente Nella ASM chart in figura 8. R <=RR.

LC. z. Done : OUT STD_LOGIC) . EB. EB.Reset S1 Lc. Ssel = 0. Done s 1 Div 0 zz 1 Figura 8. ES 0 s 1 S2 EC Ssel = 1. EC. LA.31: ENTITY Media_mob IS PORT ( Clock. Resetn. ES. 251 . ES 0 z 1 S3 0 1 LA. zz : IN STD_LOGIC . END Media_mob. Ssel. Div. s. EC z 0 S4 Div.

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

if B<A then R_{i}=B. A=R_{i}. for i=0 to k-2 do A=R_{i}. 253 . 8. poi nello stato S3 incrementiamo C j di 1. end for. END Behavior . Soluzione Gli stati S2 ed S3 possono essere uniti in un unico stato eseguendo l’assegnazione C j = Ci + 1. END CASE . allora il risultato Ci + 1 potrebbe essere efficientemente calcolato collegando Ci agli ingressi dati per il caricamento in parallelo su C j cos` che i bit ı vengano scalati di una posizione.32. Il circuito richiederebbe un sommatore per incrementare Ci di 1 e le uscite di questo sommatore verrebbero caricate in parallelo nel contatore C j . specifichiamo l’assegnazione C j ← Ci nello stato S2. R_{j}=A. end for.14 Pseudo-codice per il sorting Nel seguito si fornisce lo pseudo-codice per l’operazione di ordinamento nella quale i registri che vengono ordinati sono indicizzati usando le variabili i e j. Se invece di usare dei contatori per implementare C j e Ci utilizzassimo degli shift register. end if. for j=i+1 to k-1 do B=R_{j}. END PROCESS . 8. E’ possibile eliminare lo stato S3 se l’assegnazione C j ← Ci + 1 avviene in S2? Spiegare ogni conseguenza che questo cambiamento ha sui circuiti di controllo e sul datapath. Done <= ’ 1’ .WHEN S4 => Div <= ’ 1’ .13 Trasformazioni di ASM chart Nella ASM chart in figura 8.

32: 254 . 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.Reset S1 Ci Load registers 0 s 1 S2 A S3 Ci Cj + 1 Cj Cj + 1 Ri .

255 .33. Un’approccio differente consiste nel realizzare i e j con due shift register. 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. le variabili i e j sono implementate usando i contatori Ci e C j .Reset S1 Ci Load registers 0 s 1 S2 A S3 Ci Cj + 1 Cj Cj + 1 Ri .33: Nella ASM chart in figura 8.

R3. Soluzione 1000 4 LI EI L E 4 LJ L E Shift − right Shift − right EJ Ci Clock Cj C i (k−2) => z i C j (k−1) => 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..(a) Riprogettare il circuito per l’operazione di ordinamento usando degli shift register invece dei contatori per i registri index R0 . .34: 256 . (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 ....

(a) La parte del datapath da modificare e mostrata in figura 8.35: (b) il codice VHDL e riportano nel seguito: ` 257 . La restante ` parte del circuito e la stessa della figura 8.34. ` DataIn ABmux n 0 n 1 RData WrInit Rin 0 E Rin 1 E Rin 2 E Rin 3 E R0 R1 0 1 2 3 R2 R3 Imux ABData Ain E Bin E Rd n Clock DataOut 1 0 Bout A < B BitA Figura 8.35.

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

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 dall’istruzione -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 ;

-- L’encoder 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 dell’utilizzo degli shift register al posto dei contatori e ` l’incremento del numero di flip-flop necessari. Ogni contatore utilizza log2 n flipflop mentre ogni shift register richiede n flip-flop. 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 figura 8.36 mostra il datapath per l’operazione di ordinamento che usa un buffer a tre stati per accedere ai registri. Descrivere il datapth usando il codice VHDL, definendo 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 modificare 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 l’opzione 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 (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; -- 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 dell’assegnazione -- 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

quindi i cambiamenti ` prodotti nelle uscite da altri elementi del datapath devono essere stabili prima del fronte di discesa. WITH IMux Select ABData <= R(0) WHEN R(1) R(2) R(3) 0. IMux ) BEGIN IF ( WrInit OR Wr ) = ’1’ THEN CASE IMux IS WHEN 0 => Rin <= "0001’’. END PROCESS. Wr. Soluzione Il codice VHDL seguente mostra i cambiamenti necessari nel datapath affinch` e un blocco SRAM possa essere utilizzato al posto dei registri. WHEN OTHERS => Rin <= "1000’’. ELSE Rin <= "0000’’. END CASE. RinDec: PROCESS ( WrInit. Zi <= ’1’ WHEN Ci = 2 ELSE ’0’. WHEN 1 => Rin <= "0010’’. 266 . WHEN 1. il periodo del clock deve essere lungo abbastanza da prevenire questo problema. END IF. DataOut <= ( OTHERS => ’Z’ ) WHEN Rd = ’0’ ELSE ABData. WHEN OTHERS. IMux <= Cmux WHEN Int ) ’1’ ELSE Radd. END Behavior. WHEN 2. Il blocco di SRAM e sincronizzato sul fronte di discesa del segnale di clock. WHEN 2 => Rin <= "0100’’. Zj <= ’1’ WHEN Cj = 3 ELSE ’0’.CMux <= Ci WHEN Csel = ’0’ ELSE Cj.

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

CMux <= Ci WHEN Csel = ’ 0’ ELSE Cj . Clock. Ain. LPM_WIDTHAD => 2. RegA: regne PORT MAP RegB: regne PORT MAP WHEN y = S1 ELSE ’ 1’ . zi. FSM_ outputs: PROCESS ( y.. Zero. 268 . SRAM block : LPM_RAM_DQ GENERIC MAP ( LPM_WIDTH => 4. Resetn. modulus => 4) LJ. Ci. OuterLoop: upcount GENERIC MAP ( PORT MAP ( Resetn. Clock. ABMux <= A WHEN Bout = ’ 0’ ELSE B . Vedere codice definito in precedenza END PROCESS . BltA <= ’ 1’ WHEN B < A ELSE ’ 0’ . B ) . IMux <= Cmux WHEN Int = ’ 1’ ELSE Radd . Vedere il codice definito in precedenza END PROCESS . Resetn. GENERIC MAP ( N => N) ( ABData. EI. codice non mostrato. Clock.. Bin.BEGIN . codice non mostrato. Clock. Int <= ’ 0’ Zero <=0. modulus => 4) LI. Ci ) . NClock <= NOT Clock. BltA. Cj ) . GENERIC MAP ( N => N) ( ABData. MemAdd <= CONV_STD_LOGIC_VECTOR(IMux. WE <= WrInit OR Wr . s. 2) .. InnerLoop: upcount GENERIC MAP ( PORT MAP ( Resetn. zj ) BEGIN .. RDAta <= ABMux WHEN WrInit = ’ 0’ ELSE DataIn . A ) . EJ.

ENTITY mean_circ IS GENERIC ( N : INTEGER := 8 ) . Data : IN STD_LOGIC_VECTOR(N .37 mostra lo schema di un circuito che elabora l’operazione di media su 4 campioni. LPM_OUTDATA => "UNREGISTERED") PORT MAP ( address => MemAdd. data => RData ) . 269 . Scrivere il codice VHDL che rappresenta il circuito utilizzando un array di registri invece di un blocco di SRAM.1 DOWNTO 0) . Zj <= ’ 1’ WHEN Cj = 3 ELSE ’ 0’ . ELSE ABData . PORT ( Clock.components. ER : IN STD_LOGIC . USE ieee. q => ABData. 8. Soluzione Il codice VHDL e riportato nel seguito: ` LIBRARY ieee . Per il sotto-circuito divisore . END mean_circ . Resetn : IN STD_LOGIC . DataOut <= (OTHERS => ’ Z’ ) WHEN Rd = ’ 0’ END Behavior .all . RAdd : IN INTEGER RANGE 0 TO 3 . s.all . we => WE. USE work.17 Media La figura 8. Zi <= ’ 1’ WHEN Ci = 2 ELSE ’ 0’ . USE ieee.LPM_ADDRESS_CONTROL => "REGISTERED".1 DOWNTO 0) . Done : OUT STD_LOGIC ) . M : OUT STD_LOGIC_VECTOR(N .std_logic_unsigned. inclock => NClock. usare un’operazione di shift che divida per quattro.std_logic_1164. LPM_INDATA => "REGISTERED".all .

.0] Adder BUSMUX 0 C L O C K R[7 ..0] EC LC SSEL ES LA EB DIV DONE CLOCK RESETN S LA EB DATAA[7 . SIGNAL Dec_RAdd. SIGNAL Sum : STD_LOGIC_VECTOR (N .0] we address[3 ..0] A + REGNE B 1 RESETN E CLOCK Q[7 . 270 ..0] DATAB[7 .37: ARCHITECTURE Behavior OF mean_circ IS TYPE State_type IS ( S1.0] R[7 .0] Done Figura 8.. SR..0] Q[7 . S5 ) .0] DONE Q[7 . SIGNAL R : RegArray . TYPE RegArray IS ARRAY(0 TO 3) OF STD_LOGIC_VECTOR(N .0] D O W N C O U N T Q[3 .0] C[3 .0] E L Clock Resetn DIVIDER CLOCK RESETN S S Z ZZ C[3] C[2] C[1] C[0] k[7 .1 DOWNTO 0)... S4.MReg Data[7 . SIGNAL y : State_type ... Rin : STD_LOGIC_VECTOR(0 TO 3) .1 DOWNTO 0).. Sin: STD_LOGIC_VECTOR (N ..0] Write data[7 .. S3.0] GND q[7 .0] R[7 ..1 DOWNTO 0). SIGNAL Ri. S2..

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

RegS: regne GENERIC MAP ( N => N) PORT MAP ( Sin. "0010" WHEN 2. EC. Rin(i). Count: downcnt GENERIC MAP ( modulus => 4) PORT MAP ( Clock. WITH RAdd SELECT -. END IF . "0001" WHEN OTHERS . Clock.2-to-4 decoder Dec_RAdd <= "1000" WHEN 0. Clock. R(3) WHEN OTHERS . -. ES. -.Divisore per 4 M <= "00" & SR(N .NOR GATE Sin <= Sum WHEN Ssel = ’ 1’ ELSE (OTHERS => ’ 0’ ) . LC. Rin <= Dec_RAdd WHEN ER = ’ 1’ ELSE "0000" .Registri Mux WITH C SELECT Ri <= R(0) WHEN 0. -. R(2) WHEN 2. WHEN S3 => LA <= ’ 1’ . R(1) WHEN 1. Done <= ’ 1’ . END CASE .1 DOWNTO 2). END PROCESS . 272 . zz <= ’ 1’ .C). EB <= ’ 1’ .IF z=’ 0’ THEN EC <= ’ 1’ . R(i) ) . END Behavior . z <=’ 1’ WHEN C=0 ELSE ’ 0’ . WHEN S5 => Div <= ’ 1’ . Resetn. END GENERATE . ELSE EC <= ’ 0’ . "0100" WHEN 1. GenReg: FOR i IN 0 TO 3 GENERATE Reg: regne GENERIC MAP ( N => N) PORT MAP ( Data. Resetn. SR ) . WHEN S4 => Div <= ’ 1’ . Sum <= SR + Ri .

38: 273 .RAdd ER w1 w0 En 2−to−4 y0 y1 y2 y3 Data n E Register E Register E Register E Register Clock 0 z Ssel n EC E L ES E Register LC Down−counter k−1 Sum k + n n B Div s EB A LA EB n LA Divider R n M Q n zz Done Figura 8.

Il sotto-circuito divisore usato per ottenere M = Sum/k contiene anche un sommatore.40 il circuito che realizza 274 .39 rappresenta la ASM chart e la figura 8.39: La figura 8. ER0 S2 ER. Mostrare come il circuito possa essere ridisegnato in modo da contenere solamente un unico sotto-circuito sommatore usato sia per l’operazione di somma che di divisione.38 usa un sommatore per elaborare la somma dei contenuti dei registri. Soluzione Reset S1 LR Rsel = 0. ER 0 s 1 EA. Rsel = 1 0 s 1 0 cout 1 S3 Done LR EC 1 z 0 Figura 8.8. LC. Illustrare solo la parte di circuito in pi` u necessaria a connettere il sommatore. e spiegarne il funzionamento.18 Media (2) Il circuito rappresentato in figura 8. ER0. EA.

. r 0 R n Q n Figura 8... DataA LA n EB DataB n L EA Clock E Left−shift register n w Register n B cout + cin 1 n 0 n Rsel 1 0 ER0 LR ER L E Left−shift register n n rr 0 w Q Q D 0 1 0 q n−1 n−1 r n−2. e possibile utilizzare il sommatore in un altro circuito mentre si permane nello ` stato S1 e s = 0.40: Siccome il circuito di controllo del divisore si trova in S1 fino a quando s = 0. Da queste figure si pu` notare come il sotto-circuito divisore non o utilizzi il sommatore nello stato S1. 275 .il divisore.

La linea di selezione del multiplexer e pilotata dall’ingresso s del ` divisore ( questo segnale viene chiamato Div nel disegno.La figura 8. e Op1 n 0 1 R n 0 Op2 n 1 B n AddIn0 AddIn1 Cout Cout + Cin Div MeanOut DivOut Figura 8. inclusi entrambi i circuiti datapath e di controllo.19 Media (2) . Soluzione Di seguito e scritto il codice VHDL per il divisore originario che pu` essere ` o utilizzato nell’esercizio proposto.Codice VHDL Scrivere il codice VHDL per il circuito progettato nell’esercizio precedente. Quando Div = 1 il sommatore ha in ingresso i normali dati usati dall’operazione di divisione. Notare che gli ingressi Cin sul sommatore sono comandati dal segnale Div. 276 . perch` e il segnale Div e` nel circuito della Media che porta l’ingresso s al sotto-circuito divisore).41: 8. Quando invece Div = 0 il sommatore riceve in ingresso dati esterni chiamati Op1 e Op2 .41 illustra le modifiche necessarie al circuito divisore per farlo funzionare nel nuovo modo: occorre aggiungere un multiplexer per ogni ingresso dati del sommatore. provenienti dal circuito di Media. Questa configurazione e necessaria ` perch` il divisore utilizza il suo sommatore anche per eseguire sottrazioni.

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

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

Zero. LC. Op1. SIGNAL SIGNAL SIGNAL SIGNAL SIGNAL SIGNAL SIGNAL SIGNAL y : STATE_TYPE .all . END Behavior. -. EB : IN STD LOGIC . 279 . s.nuova porta Done : OUT STD_LOGIC ) . Sum : STD_LOGIC_VECTOR(N DOWNTO 0) . DataR <= (OTHERS => ’0’) WHEN Rsel = ’0’ ELSE Sum. Count : INTEGER RANGE 0 TO N .components. USE ieee. PORT ( Clock.1 DOWNTO 0). USE work. LA.std_logic_1164. ARCHITECTURE Behavior OF divider IS TYPE STATE_TYPE IS ( S1. Cout.all . S2. z : STD_LOGIC . EC. A. END divider .1 DOWNTO 0) . -. Q : BUFFER STD_LOGIC_VECTOR(N . Rsel.1 DOWNTO 0).1 DOWNTO 0) . LR. R. S3 ) . DataA. B. Op2 : IN STD_LOGIC_VECTOR(N . R0 : STD_LOGIC . DataB : IN STD_LOGIC_VECTOR(N .nuove porte Result : OUT STD_LOGIC_VECTOR(N . ER.1.1 DOWNTO 0) . AddIn1 : STD_LOGIC_VECTOR(N DOWNTO 0) .1 DOWNTO 0).all .std_logic_unsigned. DataR : STD_LOGIC_VECTOR(N . EA. Resetn : IN STD_LOGIC . ER0. SUM <= R &r0 + (NOT B+1) Cout <= Sum(N). AddIn2 : STD_LOGIC_VECTOR(N . Il codice richiesto e per il circuito di Media con il divisore modificato e ripor` ` tato nel seguito LIBRARY ieee . USE ieee.z <=’1’ WHEN Count = 0 ELSE ’0’. ENTITY divider IS GENERIC ( N : INTEGER := 8 ) .

R0 ) . R ) . Count ) . END PROCESS . LA. Clock. ShiftR: shiftlne GENERIC MAP ( N => N) PORT MAP ( DataR. EB. Clock.1). ER0. EC. LR. B ) .. R0. EA. A(N . LC. Cout. -. Counter: downcnt GENERIC MAP ( modulus => N) PORT MAP ( Clock.. FF R0: muxdff PORT MAP ( Zero. .nuovo codice. codice non mostrato.BEGIN FSM_transitions: PROCESS ( Resetn. Resetn. Clock. z <= ’ 1’ WHEN Count = 0 ELSE ’ 0’ . Clock ) BEGIN . ER. END PROCESS . Cout. Q <=A.. ShiftA: shiftlne GENERIC MAP ( N => N) PORT MAP ( DataA. Zero <= ’ 0’ . z ) BEGIN . Clock. vedere il problema precedente AddIn1 <= R & R0 WHEN s = ’ 1’ 280 ELSE ’ 0’ \& Op1 . y. RegB: regne GENERIC MAP ( N => N) PORT MAP ( DataB. codice non mostrato.. A ) . FSM_outputs: PROCESS ( s.

R. S3. Done : OUT STD_LOGIC ) .1 DOWNTO 0) .1 DOWNTO 0) . PORT ( Clock. S4. Op1. Il codice per il circuito della Media modificato e il seguente ` LIBRARY ieee . S2. RAdd : IN INTEGER RANGE 0 TO 3 . TYPE State_type IS ( S1. Resetn : IN STD_LOGIC .1 DOWNTO END Behavior . LA. EB : IN STD_LOGIC .std_logic_unsigned. END Media . S5 ) .components. PORT ( Clock. ENTITY Media is GENERIC ( N : INTEGER := 8 ) . Q : BUFFER STD_LOGIC_VECTOR(N . USE work. END COMPONENT . ELSE Sum . Resetn : IN STD_LOGIC . s. USE ieee. M : BUFFER STD_LOGIC_VECTOR(N.AddIn2 <= NOT B WHEN s = ’ Sum <= AddIn1 + AddIn2 + s Cout <= Sum(N) .all . DataA. ELSE Op2 . 281 . DataB: IN STD_LOGIC_VECTOR(N . ER : IN STD LOGIC .all . ARCHITECTURE Behavior OF Media IS COMPONENT divider GENERIC ( N : INTEGER := 8 ) . DataR <= (OTHERS => ’ 0’ ) Result <= Sum(N . Done : OUT STD_LOGIC ) . Op2 : IN STD_LOGIC_VECTOR(N .1 DOWNTO 0) .1 DOWNTO 0). USE ieee.1 DOWNTO 0).all . Data : IN STD_LOGIC_VECTOR(N .std_logic_1164. 1’ . WHEN Rsel = ’ 0’ 0). Result : OUT STD_LOGIC_VECTOR(N .1 DOWNTO 0). s.

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

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

Scrivere lo pseudocodice per l’operazione di ordinamento che utilizza esclusivamente il registro A per mantenere temporaneamente i dati durante l’operazione di ordinamento. 284 .DataIn ABmux n 0 n 1 RData WrInit Rin 0 E Rin 1 E Rin 2 E Rin 3 E R0 R1 0 1 2 3 R2 R3 Imux ABData Ain E Bin E Rd n Clock DataOut 1 0 Bout A < B BitA Figura 8.20 Pseudo-codice per un sorter Lo pseudo-codice per effettuare un’operazione di ordinamento utilizza i registri A e B per mantenere i contenuti dei registri ordinati.42: 8.

43: 285 .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 0 Cj = k −1? S8 1 Done = 1 s 1 Ci = k −2? 1 0 0 Figura 8.

for j=i+1 to k-1 do if R_{j}<A then R_{i}=R_{j}. end for. end for. A=R_{i}. Definire una ASM chart separata per il circuito di controllo.42. end for. e la corrispondente ASM chart e riportata in figura 8.44. end if. end if. if B<A then _{i}=B. 286 .43 ` Dalla ASM chart si nota come il datapath abbia bisogno di un multiplexer per permettere l’operazione Ri ← R j . for i=0 to k-2 do A=R_{i}. Soluzione Lo pseudo-codice modificato e il seguente ` for i=0 to k-2 do A=R_{i}. $R_{j}=A. R_{j}=A. end for.45 ` 8. ` La ASM chart per il circuito di controllo e in figura 8. Usare dei multiplexer per collegare i registri. A=R_{i}. Un datapath in grado di svolgere le funzioni richieste e riportato in figura 8. for j=i+1 to k-1 do B=R_{j}.21 VHDL di un sorter Scrivere il codice VHDL per il circuito di ordinamento progettato nell’esercizio precedente.Fornire una corrispondente ASM chart che rappresenti il circuito datapath e di controllo necessari. come in figura 8.

s. 287 .std_logic_1164.1 DOWNTO 0) . RAdd : IN INTEGER RANGE 0 TO 3 . Rd : IN STD LOGIC .std_logic_unsigned. DataIn : IN STD LOGIC VECTOR(N . LOG2K : INTEGER := 2 ). Resetn : IN STD LOGIC .all . PORT ( Clock. USE work.44: Soluzione LIBRARY ieee .all .DataIn WrInit n Rin 0 E Rin 1 E Rin 2 E Rin 3 E Imux Clock Ain E A n Cj Rj n Rjout Rd < RjltA DataOut Figura 8. Done : BUFFER STD LOGIC ) . WrInit.components. DataOut : BUFFER STD LOGIC VECTOR(N . ENTITY sorter IS GENERIC ( N : INTEGER := 4 . END sorter .all .1 DOWNTO 0) . USE ieee. USE ieee.

Ain S6 Csel = 1. Wr. Int = 1. Csel = 0.45: 288 . Wr. Int = 0 0 s 1 S2 Int = 1. Ain.Reset S1 LI. Rjout 1 Rjlta EJ 0 S7 Csel = 0. Int = 1. Aout 0 zj S8 1 Done = 1 s 1 zi 1 0 0 Figura 8. LJ S3 EJ EI S4 S5 Csel=0. Int = 1.

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

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

R(2) WHEN 2. END CASE . modulus => 4) LI. RinDec: PROCESS ( WrInit. RjltA <= ’ 1’ WHEN Rj < A ELSE ’ 0’ . modulus => 4) LJ. Ci. WHEN 1. WHEN OTHERS => Rin <= "0001". Imux <= Cmux WHEN Int = ’ 1’ ELSE Radd . Clock. R(1) WHEN 1. Cj ) .Nuovo datapath WITH Cj SELECT Rj <= R(0) WHEN R(1) R(2) R(3) 0. ARjMux <= Rj WHEN Rjout=’ 1’ ELSE A . END PROCESS .-. WHEN 2. . WITH Imux SELECT AData <= R(0) WHEN 0. Wr. R(3) WHEN OTHERS . ELSE Rin <= "0000". Ci ) . EJ. WHEN OTHERS . RData <= ARjMux WHEN WRInit = ’ 0’ ELSE DataIn . . -. Clock. Zero. InnerLoop: upcount GENERIC MAP ( PORT MAP ( Resetn. zi <= ’ 1’ zj <= ’ 1’ WHEN Ci = 2 ELSE ’ 0’ WHEN Cj = 3 ELSE ’ 0’ 291 .Fine del nuovo datapath OuterLoop: upcount GENERIC MAP ( PORT MAP ( Resetn. Imux ) BEGIN IF (WrInit OR Wr) = ’ 1’ THEN CASE Imux IS WHEN 0 => Rin <= "1000". WHEN 1 => Rin <= "0100". Cmux <= Ci WHEN Csel = ’ 0’ ELSE Cj . END IF . WHEN 2 => Rin <= "0010". EI.

46: 8.DataOut <= (OTHERS => ’ Z’ ) END Behavior . 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. ` 292 .46 e mostrato un circuito che opera come un semplice processore.47. WHEN Rd=’ 0’ ELSE AData . Soluzione La ASM chart del processore e riportata in figura 8.22 Processore Nella figura 8. ` Progettare una ASM chart che descriva il funzionamento di tal processore.

Done I=0 0 1 RX RY . Done Figura 8.Reset T0 0 w 1 Load function register T1 1 RX Data.47: 293 . Done I=1 0 A Rx T2 1 I=2 G A+R Y G 0 A − RY T3 RX G.

23 Processore (2) (a) Per la ASM chart ottenuta nell’esercizio precedente. FuncReg. R3. High. USE ieee. Resetn. (b) Scrivere il codice VHDL completo per il sistema nell’esercizio precedente.w : IN STD_LOGIC . Func. G.std_logic_unsigned.48. Gin. Y : STD_LOGIC_VECTOR(0 TO 3) . USE ieee.all . AddSub.std_logic_1164. A. da R0 a R3.all . incluso il circuito di controllo descritto nella parte (a). Rout. Sum : STD_LOGIC_VECTOR(7 DOWNTO 0) . Rx. END processor . SIGNAL SIGNAL SIGNAL SIGNAL SIGNAL SIGNAL SIGNAL BEGIN T : State_Type . Done : OUT STD_LOGIC . USE work. FRin. 294 . F. Ry : IN STD_LOGIC_VECTOR(1 DOWNTO 0) . R1. ENTITY processor IS PORT ( Data : IN STD_LOGIC_VECTOR(7 DOWNTO 0) . X. I : STD_LOGIC_VECTOR(1 DOWNTO 0) . Gout.components. Assumere che siano usati dei multiplexer per implementare il bus che collega i registri. ARCHITECTURE Behavior OF processor IS TYPE State_Type IS ( T0. BusWires : INOUT STD_LOGIC_VECTOR(7 DOWNTO 0) ) . nel processore. R0. R2. ` (b) Il codice VHDL e ` LIBRARY ieee . Rin.8. T1. definire la ASM chart che specifichi i segnali di controllo richiesti per controllare il datapath nel processore. T2. Extern : STD_LOGIC . Sel : STD_LOGIC_VECTOR(1 TO 6) . Ain : STD_LOGIC . Clock. T3 ) . Soluzione (a) La ASM chart di controllo del processore e riportata in figura 8.all .

Rin = X. Extern. Done I=0 0 1 Rin = X. Rout = Y. Rout = Y 1 I=2 AddSub = 0 0 AddSub = 1 T3 Gout.48: 295 . Done I=1 0 Ain. Done Figura 8. Rout = X T2 Gin.Reset T0 0 w 1 FRin T1 1 Rin = X.

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

Clock. High. Resetn. reg1: regne PORT MAP ( BusWires. I <= FuncReg(1 TO 2) . Resetn. -. Gin. ELSE AddSub <= ’ 1’ . decX: dec2to4 PORT MAP ( FuncReg(3 TO 4). Resetn. FRin. FuncReg ) . Clock. Resetn.Nota: il valore di defalult del parametro GENERIC N e’ 8 -. regG: regne PORT MAP ( Sum. A ) . Clock.per questo se non c’e’ il GENERIC MAP viene preso il valore di defaut reg0: regne PORT MAP ( BusWires. alu: WITH AddSub SELECT Sum <= A + BusWires WHEN ’ 0’ . Clock. R3 ). Rin(0). END PROCESS . R2 WHEN "001000". Done <= ’ 1’ END CASE . WITH Sel SELECT BusWires <= R0 WHEN "100000".WHEN T2 => Gin <= ’ 1’ . R2 ). Ain. Rin <= X . Rin(2). Resetn. . WHEN T3 => Gout <= ’ 1’ . reg3: regne PORT MAP ( BusWires. Y ) . Clock. reg2: regne PORT MAP ( BusWires. IF I = "10" THEN AddSub <= ’ 0’ . Func <= F & Rx & Ry. 297 . Resetn. decY: dec2to4 PORT MAP ( FuncReg(5 TO 6). Rin(3). functionreg: regne GENERIC MAP ( N => 6) PORT MAP ( Func. Clock. G ) . R1 ). R0 ). Resetn. END IF . Rout <=Y. regA: regne PORT MAP ( BusWires. R3 WHEN "000100". High. Clock. Rin(1). R1 WHEN "010000". X ) . High <= ’ 1’ . A . Sel <= Rout & Gout & Extern .BusWires WHEN OTHERS .

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

R2 : OUT STD_LOGIC ) . Y1. R1. ENTITY semaforo IS PORT ( Clock. R2 C 2 t2 1 0 C = 0? 2 0 1 S4 C1 t1 C1 C 1 − 1.std_logic_unsigned.Reset S1 C1 t1 S2 C1 C 1 − 1. G2. R1 : OUT STD_LOGIC . USE ieee.49: USE ieee. Y2.all . Y2 0 C 2 = 0? S3 C2 C2 − 1. G2 C1 = 0? Figura 8. G1. END semaforo . R1. 299 . Resetn : IN STD_LOGIC .all . R2 C1 t1 1 0 C 1 = 0? 1 S5 C 2 t2 C2 C2 − 1.std_logic_1164. Y1. G1.

G2 Figura 8. S3. Y1. Y2 S3 EC2. R1.50: ARCHITECTURE Behavior OF semaforo IS TYPE State_type IS ( S1. SIGNAL y : State_type . R2 LC1 1 0 zC1 1 S5 LC2 zC2 0 EC2. S4. R2 LC2 1 0 zC2 zC1 0 1 S4 LC1 EC1. G1. 300 . S2.Reset S1 LC1 S2 EC1. R1. S5 ) .

EC1 <=’ 0’ . Y1 <= ’ 1’ . R2 <= ’ 1’ .Y2 <= ’ 1’ . G1 <= ’ 1’ . ELSE LC2 <= ’ 0’ . LC1. Y2 <= ’ 0’ . TICKS2 : STD LOGIC VECTOR(3 DOWNTO 0). LC1 <= ’ 0’ . . EC2 <= ’ 1’ . ELSE LC1 <= ’ 0’ . R2 <= ’ 0’ . C2.SIGNAL zC1. ) THEN y y y y <= <= <= <= S2 S3 S4 S5 . EC2 <= ’ 0’ . . END IF . LC2 : STD LOGIC . EC2. END IF . ELSE LC2 <= ’ 0’ . EC1. EC2 <= ’ 1’ . . TICKS1. 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 . ELSIF Clock’ EVENT AND Clock = ’ 1’ CASE y IS WHEN S1 => y <=S2. R1 <= ’ 0’ . R1 <=’ 1’ . WHEN S2 => EC1 <= ’ 1’ . WHEN S3 => EC2 <= ’ 1’ . 301 . IF zC1 = ’ 1’ THEN LC2 <= ’ 1’ . FSM_outputs: PROCESS ( y. WHEN S4 => EC1 <= ’ 1’ . SIGNAL C1. Y1 <= ’ 0’ . EC2 <= ’ 0’ . EC1 <= ’ 1’ . Resetn BEGIN IF Resetn = ’ 0’ THEN y <=S1. zC2. BEGIN FSM_transition: PROCESS ( Clock. . G2 <= ’ 0’ . . END IF . R1 <=’ 1’ . EC1 <= ’ 1’ . LC2 <= ’ 0’ CASE y IS WHEN S1 => LC1 <= ’ 1’ . IF zC1 = ’ 1’ THEN LC2 <= ’ 1’ . END END END END IF IF IF IF . R2 <= ’ 1’ .G2 <= ’ 1’ . . WHEN S5 => EC2 <= ’ 1’ . IF zC2 = ’ 1’ THEN LC1 <= ’ 1’ . EC1 <= ’ 0’ . zC2 ) BEGIN G1 <= ’ 0’ . END IF . . END PROCESS . . . EC2 <= ’ 0’ . ELSE ELSE ELSE ELSE y y y y <= <= <= <= S3 S4 S5 S2 . . zC1.

che pu` essere usato dove o necessario). 8. IF EC1 = ’ 1’ THEN IF LC1 = ’ 1’ THEN C1 <= TICKS1 .1 .2 TICKS for C2 -. Supporre di avere accesso a un se` gnale d’ingresso Clock con frequenza di 102.25 Anti-rimbalzo Supporre di aver bisogno di utilizzare un semplice interruttore on-off a due terminali come mostrato in figura 8. 302 .Controllo per il conteggio degli zero zC1 <= ’ 1’ WHEN C1 = 0 ELSE’ 0’ .IF zC2 = ’ 1’ THEN LC1 <= ’ 1’ ELSE LC1 <= ’ 0’ .Si possono anche usare componenti down-counter CNT C1: PROCESS BEGIN WAIT UNTIL Clock’ EVENT AND Clock = ’ 1’ . END IF . ELSE C1 <= C1 . . zC2 <= ’ 1’ WHEN C2 = 0 ELSE’ 0’ . CNT C2: PROCESS BEGIN WAIT UNTIL Clock’ EVENT AND Clock = ’ 1’ . -. -.4kHz. Illustrare come un contatore possa essere usato come un circuito anti-rimbalzo del segnale Data prodotto dallo switch. -. END IF . END IF . END PROCESS .Costanti di setup TICKS1 <= "0011" . (Suggerimento: progettare una FSM che abbia Data come ingresso e produca l’uscita z. END PROCESS . che e la versione senza rimbalzo di Data. ELSE C2 <= C2 . IF EC2 = ’ 1’ THEN IF LC2 = ’ 1’ THEN C2 <= TICKS2 . EC1 <= ’ 1’ . END IF . END IF .51. -.4 TICKS for C1 TICKS2 <= "0001" . EC1 <= ’ 0’ END CASE . END PROCESS .1 . END Behavior . .

52: 303 . Il segnale sincronizzato chiamato Sinc.51: Soluzione Il circuito antirimbalzo e diviso in tre parti. 1111111111 Sync Meta D Q D Q 10 Data LC EC L E Down − counter 102. come mostrato in figura 8. generando un ritardo di 10ms. La FSM utilizza anche un contatore.4kHz . Il ` segnale Data dallo switch deve essere sincronizzato al segnale di102.52.4kHz utilizzando due flip-fop. deve essere inviato alla FSM.4 KHz Done Figura 8.V DD R Data Figura 8. che conta per 1024 cicli del segnale di 102.

` Reset S1 Z = 0. che e la versione senza rimbalzo del segnale Data. C 1023. LC Figura 8. EC 1 S4 Z = 0. EC 0 Sync 0 Done 1 Z = 1.53. La FSM ha come uscita ` z. C 1023. LC 0 0 Sync 1 S2 Z = 1.La ASM chart del circuito e riportata in figura 8. C 1 Done C − 1.53: 304 . C C − 1.

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 . 512K x 32 3.1 Linee indirizzo e linee input-output Le seguenti memorie sono classificate in base al numero di locazioni e al numero di bit per parola.Capitolo 9 Memorie 9. 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 codifica di tutte le locazioni richieste dalla memoria stessa. 2G x 1 Soluzione Si definiscono A e D il numero di linee di indirizzi e di dati rispettivamente. Quante linee di indirizzo e di input-output dei dati sono necessarie per ogni caso? 1. 64M x 64 4. 48K x 8 2.

1: 1024 15 ADD 6 5 0 D E C 1024 16 16 Figura 9.2: 306 . Qual e la ` ` dimensione del decoder di riga e di colonna e quante porte logiche (AND) sono necessarie per decodificare un indirizzo? Soluzione Il numero complessivo di celle e 64K x 16 = 220 . Il numero di a 10 mentre il numero di colonne da selezionare sar` pari a 26 .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. Questo significa che la ` matrice di memoria sar` un quadrato di dimensioni 210 (figura 9. righe sar` pari a 2 a a Ogni colonna in realt` contiene una intera parola da 16 bit memorizzata.1). a 2 10 210 Figura 9.9.

3. e sufficiente 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 decodifica completo richiede che gli 8 chip vengano selezionati uno alla volta in funzione del contenuto di tre linee di indirizzo (A28 . 1.. considerando sia la decodifica diriga che di colonna.. Qual e la dimensione massima ottenibile per ogni memoria m x 1? ` 2. Ne ` consegue che il numero massimo di locazioni indirizzabili vale 228 : 14 linee → Row → Column } 228 L’organizzazione dell’array di memoria con gli indirizzi di riga e di colonna e ` riportata in figura 9. e pari a 28.A30). Com’` il circuito di decodifica completo? e Soluzione Dato che ogni decodifica pu` gestire 14 linee di indirizzo. Quanti chip ci vogliono per costruire una memoria di capacit` 2G x 1? a 3. come riportato in figura 9.4.2. il numero totale o di linee.3 Decoder (2) Si supponga che il pi` grande decoder che si possa usare per decodificare riga e u colonna in un chip di RAM “m x 1” abbia 14 bit di indirizzo e che sia impiegata la decodifica su riga e colonna. 307 .. Il circuito di decodifica finale richiede quindi un decoder 3-to-8 che pilota i segnali di chip enable (EN) delle decodifiche di ogni singolo chip. Per sapere quanti circuiti integrati osno necessari per realizzare una memoria da 2 Giga..In conclusione i decoder da realizzare devono essere in grado di decodificare 1024 e 64 valori: Decoder di righe → 210 → 10 bit → 1024 Decoder di colonne → 26 → 6 bit → 64 Il circuito risultante e riportato in figura 9. oltre alle 28 necessarie per la decodifica di ogni singolo circuito integrato. ` 9.

locazioni indirizzabili singolarmente e 2 ` 215 · 214 = 229 = 512 MLocazioni 308 .4: 9.14 14 Figura 9.4 DRAM .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. quindi il numero totale di ` 29 .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.

e poi il column address. per questo basta dividere la capacit` per il parallelismo di parola (word). Qual e il tempo totale per il refresh se ogni ciclo di refresh impiega 60ns? ` 3. Dato che le due decodifiche devono essere uguali.9. Ne consegue che i pin necessari per l’indirizzamento completo sono 14: in ogni ciclo di memoria dapprima viene inviato il row address. Quanti pin di indirizzo deve avere la DRAM? Soluzione Per prima cosa occorre definire quante locazioni ha la memoria. 25ms 309 . Il tempo totale usato dal refresh e pari al tempo di refresh di una riga per il ` numero di righe: 4096 × 60ns = 0. E sufficiente dividere l’intervallo di refresh per il numero di righe della memoria.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.Refresh Una memoria DRAM ha un intervallo di refresh di 128ms e ha 4096 righe.5 DRAM . 1. Questo porta ad a avere 256M locazioni indirizzabili da 28 bit.6 DRAM . Qual e il tempo/perdita di efficienza della memoria a causa del refresh? ` Soluzione ` 1. 25µs 4096 2. Qual e il minimo numero di pin di indirizzo della DRAM? ` 4. 1Gbit = 256 MAddress = 228 Address → 214 Row e 214 Column → 14 pin 4 9. ogni decodifica lavora su 14 pin. dato che in 128 ms occorre rinfrescare tutte le 4096 righe: 128ms = 31. Qual e l’intervallo tra i cicli di refresh? ` 2.

7 Struttura memoria 1. Accedendo a 2 byte per volta 2MB = 1M → 220 → 20 linee.3. 4096 = 212 righe sono indirizzabili con 12 linee: 4096 Righe → 12 pin per il Row Address 4. 25ms = Perdita = 0. dunque occorre un circuito che decodifichi tre linee (20 . La capacit` di 1 chip di RAM e 128K × 16 = 2048Mb. → 2B Dato che tutti i chip hanno 128K locazioni. Dato che il a ` parallelismo richiesto e 16 bit = 2B. se ne deduce che sono necessarie 17 linee: → 128K → 217 → 17 linee 3. 9 128ms 9. 00195 → 1.17) per l’abilitazione degli 8 circuiti: 20 → 17 3 linee → Decoder 3-to-8 310 . 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. La percentuale di tempo persa per il refresh si ottiene dividendo il tempo totale usato dal refresh per l’intervallo di refresh (128ms): 0. Quante linee devono essere decodificate per generare i chip select (CS) per pilotare tutti i chip? Che tipo di decoder e necessario? ` Soluzione 1. ne consegue che il numero di circuiti ` integrati necessari e ` 2MB → = 8 (2 MegaByte / 2Megabit) 2Mb 2. Quanti chip di RAM 128K x 16 sono necessari per realizzare una memoria di 2 MB di capacit` ? a 2. Si deve passare da 20 linee di indirizzo a 17 linee gestite da ogni singolo chip.

sono necessari 2 chip in parallelo. Il circuito da realizzare e riportato in figura 9. 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. ` 512K → 512K = 8 chip e decoder 3-to-8 64K 311 . → 2 chip in parallelo Per ottenere un numero di locazioni pari a 512K. costruire una RAM 512K x 16 utilizzando opportunamente dei decoder 3-to-8.5. sono necessari 8 circuiti abilitati da un decoder 3-to-8.8 Struttura memoria (2) Utilizzando i chip di RAM 64K x 8 con pinout come in figura 9.9.6.

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 d’esame 10. 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.1 Prova d’esame del 30-04-2009 ` Quanto segue non e stato verificato completamente ma pu` essere utile come o traccia per la risoluzione. 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. 313 . 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 l’uscita f usando un livello di Mulo tiplexer a due vie controllato da X4 con a secondo livello una coppia di multiplexer. Esercizio 1 Si sintetizzi. utilizzando dei MULTIPLEXER a due vie.

Per raggiungere la ı 218 capacit` di memoria richiesta servono quindi 216 = 4 di questi macroblocchi.1 . Il circuito risultante e riportato in figura in ` figura 10. siano abilitate quando il segnale di lettura ` ` R/W e attivo a 1 e il chip di memoria e selezionato (CS = 1). di tipo 3-state. cos` facendo si ottengono dei blocchi da 64K · 16. controllati da X1 ). a Alla fine 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 .2. 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. Si supponga che le uscite Data out. La scheda deve rispondere nel range di indirizzi A19 .1: sempre a due vie.X1 0 X3 X2 1 X4 0 f 1 "0" X1 0 1 Figura 10. 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 figura 10.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 sufficienti log2 218 = 18bit.

` 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.3. utilizzando flip flop di tipo D. 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 ` verificata la situazione: XW = 00 (penultimo fronte) XW = 11 (ultimo fronte) Si progetti il circuito partendo dal diagramma a stati.4.8 Data in 16 Address Data out 8 CS R/W Figura 10.2: • R \W che definisce se si stia facendo un’operazione di scrittura o di lettura nella generica memoria I restanti pin di ingresso sono collegati come riportato in figura 10. In particolare una colonna di chip e collegata ai segnali di dato DATA OU T (7 : 0) mentre ` l’altra e collegata ai segnali di dato DATA OU T (15 : 8). Le uscite del decoder vanno ai pin di CS delle memorie per abilitarne il funzionamento. ` 315 . Soluzione Il diagramma a stati e riportato in figura 10.

DATA 15−8 DATA 0−7 ADD 0−15 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 7−0 DATA OUT 15−8 Figura 10.3: 316 .

5.4: Di conseguenza la tabella di transizione degli stati risulta: 00 0 1 1 1 x. ` per cui e sufficiente una variabile di stato Y . 317 . si assegna allo stato A: Y = 0 e allo ` stato B: Y = 1.w 01 11 0 0 0 1 10 0 0 y 0 1 Coprendo le mappe di Karnough nella forma SoP la variabile di stato futuro Y diventa Y = XW mentre l’uscita varr` : a Z = XWY Il circuito finale rappresentante il cIrcuito realizzato con i flip flop di tipo D e ri` portato in figura 10.w 01 11 0 0 0 0 10 0 0 y mentre la tabella di uscita diventa: 00 0 0 x. X=0 W=0/Z=0 11/0 01/0 10/0 A B 00/0 01/0 01/0 01/0 Figura 10.L’assegnazione degli stati e molto semplice in quanto si tratta di due soli stati.

RB. Ci` e dovuto alla semplicit` del diagramma a stati e al fatto che in o` a realt` e sufficiente riconoscere una successione di due configurazioni di ingresso a` successive per attivare l’uscita Z. In particolare si sviluppi: 318 . permettendo ` il caricamento dei dati. Il termine delle operazioni deve essere segnalato mediante un segnale di uscita END OPERATION.5: Esercizio 4 Si progetti. Z X D W CK Y Figura 10. utilizzando la tecnica delle ASM Chart. Si supponga che in caso di errori multipli (pi` situazioni di Overflow e Underu flow) venga memorizzato solo il primo evento di errore. sincrono con il clock CK della macchina.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. La macchina parte non appena il segnale DATA LOAD e attivo. nello stesso e formato dei dati in ingresso (SIGNED su 8 bit). la somma dei 4 dati se non si sono verificati n´ overflow (superamento massimo valore positivo) n´ underflow e e (superamento massimo valore negativo). Alla fine delle operazioni la macchina deve restare in attesa di un altro fronte positivo di DATA LOAD prima di ripartire. RC e RD in corrispondenza dell’attivazione del segnale DATA LOAD che arriva dall’esterno. e che rimane attivo per un colpo di clock. un circuito digitale sincrono sul fronte di salita del clock CK ed in grado di realizzare il seguente algoritmo: Si prendono dall’esterno 4 dati in ingresso di tipo SIGNED (in complemento a 2) su 8 bit che vengono memorizzati contemporaneamente in 4 registri RA. Dopodich´ in uscita si deve fornire. altrimenti occorre fornire in uscita RA in caso di overflow o RD in caso di underflow insieme alla coppia di segnali OV ERFLOW ERROR e U NDERFLOW ERROR attivi a 1 rispettivamente in caso di Overflow e di Underflow.

8. USE ieee. ENTITY SUM4 IS PORT ( Clock.RC.std_logic_1164. while(C<4 AND (NOT OVERFLOW) AND (NOT UNDERFLOW)) sum <= sum+reg(k). 319 . reg(3) <= D. e ) Il codice VHDL dell’intero sistema e ` LIBRARY ieee.6. definendo tutti i blocchi che vengono usati nel sistema a livello comportamentale. sum <= C.7. SUM : BUFFER STD_LOGIC VECTOR(7 DOWNTO 0) ). end while. else if (UNDERFLOW) then sum <= reg(3).all. reg(1) <= B. END SUM4.a) Lo pseudocodice dell’algoritmo b) La ASM chart dell’algoritmo c) Il datapath e l’ASM chart del controllo d) Il codice VHDL dell’intero sistema. k=-k+1. Soluzione a) Lo pseudocodice dell’algoritmo e ` reg(0) <= A.RB. Data_Load. reg(2) <= C. if(OVERFLOW) then sum <= reg(0). d) L’ASM chart del controllo in figura 10. End_Operation: OUT STD_LOGIC.RD : IN STD_LOGIC_VECTOR(7 DOWNTO 0). k <= 0. b) La ASM chart dell’algoritmo e riportata in figura 10. RA. ` c) Il datapath in figura 10. Reset : IN STD_LOGIC.

RST SUM_R<−0 C<−0 0 DATA_LOAD 1 DATA_LOAD INIT DONE LOAD ALL Output SUM C>3 0 OVERFLOW SUM<−RA 0 UNDERFLOW SUM<−RD 0 SUM<−SUM+R(C) C<−C+1 OP Execute ADD Figura 10.6: 320 .

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

8: 322 .RESET RST CLR_COUNT CLRSUM 0 DATA_LOAD 0 DATA_LOAD 1 DONE LSUM INIT LA LB LC LD END_COUNT 1 OVERFLOW ERROR 0 OP SEL1 = 0 LSUM LSUM UNDERFLOW ERROR 0 SEL1 = CNT_OUT EN_COUNT SEL1 = 3 LSUM Figura 10.

ELSEIF (CLOCK’EVENT AND CLOCK=’1’) THEN CASE (STATO) IS WHEN RST => IF (DATA_LOAD=’1’) THEN STATO <= INIT.. CK : IN STD_LOGIC.. ELSE STATO <= OP. ELSE STATO <= RST. END IF. WHEN DONE => IF(DATA_LOAD=’1’) THEN STATO <= DONE. END COMPONENT. LOAD: IN STD_LOGIC.COMPONENT regne8_CLR PORT ( Data_in: IN STD_LOGIC_VECTOR(7 DOWNTO 0).. END IF. CLOCK) BEGIN IF (RESET=’1’) THEN STATO <= RST. WHEN OP => IF( (END_COUNT=’1’ ) OR (OVERFLOW_ERROR=’1’ ) OR (UNDERFLOW_ERROR = ’1’)) THEN STATO <= DONE. ELSE STATO <= OP... CLEAR: IN STD_LOGIC).... ---- etc. END IF. 323 .. ELSE STATO <= RST. Tutti i componenti usati nel progetto BEGIN TRANSITION_PROC: PROCESS(RESET. Data_out: OUT STD_LOGIC_VECTOR(7 DOWNTO 0)..etc. WHEN INIT => IF ((END_COUNT=’1’ ) OR (OVERFLOW_ERROR=’1’ ) OR (UNDERFLOW_ERROR = ’1’)) THEN STATO <= DONE.

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

LA). (RC.. S1). SUM. per ogni inverter open-collector : TLH = 2 ns. CLOCK. CLOCK. S1. LC). SEL1 <= CNT_OUT.SEL. EN_COUNT <= ’1’’ END IF. Esercizio 5 Nello schema di figura 10. END IF. CLOCK. CLOCK. TSU = 3 ns. LSUM. B = Q1 AND Q2. SEL2. C. (RB. per il FF JK : TCK→Q = 2ns (per entrambe le transizioni) .SEL1. Si ipotizzi di avere la seguente tempistica: per i FF D : TCK→Q = 6 ns (per entrambe le transizioni). Add8: Adder8 PORT MAP (MUX1. -END_COUNT <= SEL(1) AND SEL(0).30 il blocco f e realizzato con una LUT che imple` menta le seguenti funzioni: A = Q1 OR Q2 .etc. RegSUM: regne_8_clr PORT MAP (MPX2.LB). END PROCESS.C.. LD). TSU = 2 ns. --etc.B. B. CLRSUM).WHEN DONE END CASE..D. CLOCK. D.MPX1)... (RD.. THL = 1 ns. => LSUM <= ’1’ --Descrizione della -RegA: regne8 PORT MAP RegB: regne8 PORT MAP RegC: regne8 PORT MAP RegD: regne8 PORT MAP netlist del circuito (RA. Mpx2: Mpx_2way PORT MAP (MPX1. Mpx1: Mpx_4way PORT MAP (A. END ARCHITECTURE. MPX2). 325 . A.

T2 ) = 12ns 2) TLH D2 → D1 : TLH = T3 = 9ns 326 T3 = TCK→Q2 + TSU(D) = 6 ns + 3 ns = 9 ns .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 flip flop compatibile con il funziona` mento corretto del circuito? Soluzione Si devono distinguere 3 casi come in figura 10.10: 1) THL D1 → D2 : T1 = TCK→Q1 + TSU(D) = 6 ns + 3 ns = 9 ns D1 → JK: T2 = TCK→Q1 + TLH(LUT ) + THL(INV ) + TSU(JK) = 6 ns + 3 ns + 1 ns + 2 ns = 12 ns THL = max(T1 .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. T_HL T_LH T_CYCLE Figura 10.10.

12. 14). TCYCLE ) = 24ns da cui fmax = 1 Tcycle min = 41. Soluzione Dal testo dell’esercizio estrapoliamo la seguente tabella di verit` : a 327 . utilizzando unicamente dei decoder 2-to-4 con Enable e porte OR. x2 . 10. 4. TLH e il tempo di ciclo TCYCLE .5 (50% ) al clock di sistema.66MHz Questa scelta nasce dal fatto di garantire un duty cycle pari a 0. Esercizio 1 Si sintetizzi. x3 . la funzione: f (x1 . x4 ) = Σ m(0. ovvero: Tcycle min = max(2THL . Esercizio 6 Si descrivano le differenze principali tra le memorie PROM. 6. 2TLH .2 Prova d’esame del 03-07-2009 ` Quanto segue non e stato verificato completamente ma pu` essere utile come o traccia per la risoluzione. EPROM e FLASH. 9.3) TCYCLE D2 → D3 : T4 =TCK→Q2 + 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 .

in base alla combinazione degli ingressi X1 e X2.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 figura 10.11: Il circuito pu` essere realizzato con decoder 2-to-4 con Enable e una porta OR o come in figura 10.11. a` X1 X2 X3 X4 00 01 11 10 00 01 11 10 1 1 1 1 1 1 Figura 10. 328 .12: Il primo decoder viene utilizzato per selezionare uno degli enable dei quattro decoder posti a valle. Questi decoder avranno tutti come ingressi X3 e X4 e le uscite per cui la funzione f e 1 ` sono collegate all’ingresso della porta OR.

La scheda ` ` deve rispondere nel range di indirizzi A23 . Ovviamente la memoria u non deve essere selezionata in nessuno degli altri casi. Si ` supponga che le uscite Data out. siano abilitate quando il segnale di lettura R/W e attivo a 1 e il chip di memoria e selezionato (CS = 1).A0 = 100X XXXX XXXX XXXX XXXX XXXX ovvero i 2Mbyte sono allocati nello spazio di indirizzamento della macchina in cui i tre bit pi` significativi dell’indirizzo valgono 100.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 figura 10.25. 329 . di tipo 3-state.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. Il bus indirizzi del sistema dove occorre inserire la scheda di memoria e a 24 bit (A23-A0).

13: Soluzione Si vuole ottenere una memoria da 2M x 8. Soluzione 330 . Il decoder 3-to-8 serve per abilitare i due banchi di memoria che risponderanno all’indirizzo Add(23:21) = 100. Si avr` pertanto bisogni di due memorie da 4 bit in parallelo per ottenere a il byte richiesto.14. Ad ogni fronte di salita del clock. utilizzando ciascuno 4 bit di informazione. Prendendo come riferimento la figura 10. avendo a disposizione memorie da 1M x 4. dunque 20 bit di ingresso dedicati alla selezione interna del blocco. Esercizio 3 Un circuito sincrono ha due ingressi IN e OUT ed una uscita FULL (di MOORE). permette di accedere alla coppia di chip che lavorano in parallelo. E possibile che contemporaneamente una persona esca e un’altra entri (IN=OUT=1). 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). Si progetti il circuito partendo dal diagramma a stati. utilizzando flip flop di tipo D. se abilitato.4 Data in 20 Address Data out 4 CS R/W Figura 10. Il segnale CS. Il circuito deve abilitare FULL = 1 non appena si verifica la condizione che ci sono 3 persone nella stanza in modo da evitare che entrino altre persone. ogni blocco ha 1milione di locazioni (1M).

Data(1:4) Add(19:0) 4 Data in Data(5:8) Data out 4 Data in 20 Address 4 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 4 20 Address Data out 4 CS CS R/W R/W Data_out(1:4) Data_out(5:8) Figura 10.15: ` La tabella degli stati relativa e: ` 331 .14: Il diagramma degli stati e mostrato in figura 10.

15: 332 .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.

` L’algoritmo 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 . ` Esercizio 4 Si progetti.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 l’uscita FULL va a 1 solo nello stato ` D=11: FU LL = Q1 Q0 Il circuito finale e riportato in figura 10.16. utilizzando la tecnica delle ASM Chart.17. un circuito digitale sincrono sul fronte di salita del clock CK ed in grado di realizzare l’algoritmo della moltiplicazione di due numeri UNSIGNED con la tecnica delle somme e shift: si prendono dall’esterno 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 l’operazione.Utilizzando la codifica degli stati indicato in figura si pu` definire la rete di o stato futuro partendo dalle mappe di Karnough come in figura 10. 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.

realizzando cos` la tipica moltiplicazioı ne seriale.17: moltiplicando (RA) debitamente shiftato. Il termine delle operazioni deve essere segnalato mediante un segnale di uscita END OPERATION. di cui occorre definire il numero di bit corretto. il valore del risultato. Al termine della moltiplicazione si deve fornire sull’uscita RC.Q1 IN Q1 Q0 Q0 D Q IN OUT Q0 IN OUT Q1 IN Q0 IN OUT Q1 Clock Q’ Q0 FULL Q1 D Q OUT Q0 IN OUT Q1 Q0 Clock Q’ Q1 Figura 10. Alla fine 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 dell’algoritmo 334 .

18: 335 .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.

` Il codice VHDL e ` Library ieee. END ENTITY. La ASM chart dell’algoritmo e riportata in figura 10. Signal A. Soluzione Lo pseudo codice e lasciato al lettore. SetDone).all.std_logic_1164. ShC.b) La ASM chart dell’algoritmo c) Il datapath e l’ASM chart del controllo d) Il codice VHDL dell’intero sistema."s" sta per start DataA. LoadB. ShA.18. use ieee. Sel: STD_LOGIC. ResC. ShB. -. LoadFSM. clk. C: OUT STD_LOGIC_VECTOR(16 Downto 0) ). Shift. use ieee. Signal y: state_type. ARCHITECTURE Behavior OF Addshift IS TYPE state_type IS (CB. Signal LoadA. Signal B: STD_LOGIC_VECTOR (15 Downto 0). DataC: STD_LOGIC_VECTOR (15 Downto 0). AddC. essendo simile a quanto gi` visto a ` a lezione. definendo tutti i blocchi che vengono usati nel sistema a livello comportamentale. ENTITY Addshift IS PORT (s. reset_n: IN STD_LOGIC. LoadC. BEGIN FSM_Evolution: Process(Clk) BEGIN IF Clk’event AND Clk=’1’ THEN 336 . ShiftAB.DataB: IN STD_LOGIC_VECTOR(7 Downto 0). SA.std_logic_unsigned.all. END_OPERATION: OUT STD_LOGIC.

337 . LoadA <= ’0’. end if. WHEN ShiftC => if B=0 then y <= SetDone elsif B(0)=’0’ then y <= AddC else y <= ShiftAB. WHEN LoadFSM => y <= ShiftC. LoadB <= ’0’. WHEN AddC => y <= ShiftAB. WHEN Shiftc => ShC <= ’1’. LoadA <= ’1’. WHEN AddC => LoadC <= ’1’. LoadB <= ’1’. endif. FSM_OUTPUTS: PROCESS(y) BEGIN LoadC <= ’0’. WHEN ShiftAB => ShA <= ’1’. end if. END_OPERATION <= ’0’. CASE y IS WHEN CB => WHEN LoadFSM => ResC <= ’1’. WHEN ShiftAB => y <= ShiftC. ShC <= ’0’. end case. ShB <= ’0’. ShB <= ’1’.IF Reset_N=’0’ THEN y <= CB ELSE CASE y IS WHEN CB => if s=’1’ then y <= LoadFSM else y <= CB. ShA <= ’0’. endif. END PROCESS. WHEN SetDone => y <= CB.

WHEN SetDone => END_OPERATION <= ’1’. END Loop. END Loop. END IF. FOR i in 0 to 14 Loop A(i+1) <= A(i). ELSIF ShB=’1’ THEN B(15)=’0’. END CASE.19 e rappresentato il Datapath del circuito mente in figura 10. END architecture. END PROCESS. ELSIF ShA=’1’ THEN A(0)=’0’. END PROCESS. END IF. RegB: PROCESS(Clk) BEGIN IF Clk’event AND Clk=’1’ THEN IF LoadB=’1’ THEN A <= ’’00000000’’&(DataB).20 e ` ` riportato l’ASM chart del controllo 338 . END PROCESS. DataC <= SA+B. In figura 10. END IF. FOR i in 0 to 14 Loop B(i) <= B(i+1). END IF. --Data Path RegA: PROCESS(Clk) BEGIN IF Clk’event AND Clk=’1’ THEN IF LoadA=’1’ THEN A <= ’’00000000’’&(DataA).

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 flip flop per non avere violazioni? 339 . THL = 1 ns. per il FF JK : TCK→Q = 6ns (per entrambe le transizioni) .19: Esercizio 5 Nello schema di figura 10. TSU = 2 ns. per l’inverter: TLH = 2 ns.R→Q = 3 ns (per entrambe le transizioni). Si ipotizzi di avere la seguente tempistica: per i FF SR : TS.21 i FF hanno le uscite Q inizializzate a 0.0 RA 8 0 LD_RB SHL_RB Clock 16 Reset_RA UP 8 Reset_RA LD_RA SHL_RA Clock LSB 16 1 0 Clock Count 8 EOP 16 + 16 16 LD_RC Reset_RA Clock Figura 10.

20: 340 .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.

46MHz.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. allora si verifica una violazione che rende il circuito inutilizzabile. 341 .21: 3 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). dal momento che t4 va moltiplicato per 2. Il tempo che ci interessa per non avere violazioni e t1−>3 = 11ns. dato che vogliamo il duty cycle del 50 per cento. Numeriamo i tre flip flop da sinistra a destra per poter definire 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. Esercizio 6 Si descrivano le principali tecniche costruttive delle interconnessioni interne ad una FPGA illustrandone vantaggi e svantaggi. se il tempo di ` hold tH > 11ns.

Soluzione Dapprima si definisce la tabella di verit` della funzione al fine di sintetizzare a poi la funzione con porte NAND. 6. x2 . 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 . 14).3 Prova d’esame del 07-09-2009 ` Quanto segue non e stato verificato completamente ma pu` essere utile come o traccia per la risoluzione. x4 ) = Σ m(0. Si sintetizzi poi la stessa funzione utilizzando solo porte NOR. utilizzando unicamente delle porte NAND. 12. 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 funzione: f (x1 . 9. 4. x3 . Esercizio 1 Si sintetizzi.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 .Dalla tabella si ricava la mappa di Karnaugh di figura 10. x1x2 x3x4 00 00 1 01 1 11 1 10 0 01 0 0 0 1 11 0 0 0 0 10 0 1 1 0 Figura 10.22: X1 X2 f X3 X4 Figura 10.22.

24: Il circuito derivante dalla mappa di Karnaugh e riportato in figura 10.23.Figura 10. ` Per sintetizzare la funzione con sole porte NOR si riscrive f come funzione 344 .

.POS (prodotto di somme). La scheda deve rispondere nel range di indirizzi a partire da A23 . Dal confronto delle due sintesi si vede come la copertura con delle NAND presenta un costo sensibilmente inferiore. coprendo gli zeri della mappa f = (x3 + x4 )(x1 + x4 )(x2 + x4 )(x1 + x2 + x4 )(x1 + x2 + x3 ) Per la realizzazione con porte NOR.25: ovvero la memoria e allocata nello spazio di indirizzamento della macchina in ` cui i due bit pi` significativi dell’indirizzo valgono 10. Ovviamente la memoria u non deve essere selezionata in nessuno degli altri casi. riportato in figura 10. di tipo 3-state.25.A0 = 1011 XXXX XXXX XXXX XXXX XXXX 345 . 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 figura 10. Il bus indirizzi del sistema dove occorre inserire la scheda di memoria e a 24 bit (A23-A0).24. 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. 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.A0 = 10XX XXXX XXXX XXXX XXXX XXXX 4 Data in 20 Address Data out 4 CS R/W Figura 10. Si sup` ponga che le uscite Data out. Discutere cosa succede quando viene inviato l’indirizzo A23 . siano abilitate quando il segnale di ` ` lettura R/W e attivo a 1 e il chip di memoria e selezionato (CS = 1).

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 finale e riportato in figura 10.26. in quanto l’uscita del decoder di peso 11 non e collegata ad alcun banco. ` Esercizio 3 346 . Ovviamente quando i bit pi` si` u gnificativi valgono 1011 la memoria non viene selezionata.

27: Il diagramma degli stati relativo alla macchina proposta e riportato in figura ` 10. L’uscita U deve assumere il valore 1 in corrispondenza del terzo di tre impulsi di sincronizzazione (clock) consecutivi in corrispondenza dei quali si sia verificata la situazione X = Y . La tabella con l’assegnazione 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 . utilizzando flip flop di tipo D. Si progetti il circuito partendo dal diagramma a stati. la FSM campiona gli ingressi X e Y.27 in cui si vede come l’uscita U sia attiva solo nello stato D. Ad ogni fronte di salita del clock.Un circuito sincrono ha due ingressi X e Y ed una uscita U (di MOORE) . 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.

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 U 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 l’equazione dell’uscita U vale U = y1 y2 348 .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.

FOR i=0 to 7 349 . ı Il termine delle operazioni deve essere segnalato mediante un segnale di uscita END OPERATION. In particolare si sviluppi: a) Lo pseudocodice dell’algoritmo b) La ASM chart dell’algoritmo c) Il datapath e l’ASM chart del controllo d) Il codice VHDL dell’intero sistema. 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´ l’indicazione. 10 se RC) .28. Q_c=0. un circuito digitale sincrono sul fronte di salita del clock CK ed in grado di realizzare in seguente algoritmo: Si prendono dall’esterno 3 dati in ingresso di tipo STD LOGIC VECTOR su 8 bit che vengono memorizzati contemporaneamente in 3 registri RA. su due bit e INDEX[1:0]. definendo tutti i blocchi che vengono usati nel sistema a livello comportamentale. Soluzione a) Lo pseudo codice dell’algoritmo e ` Q_a=0. 01 se RB. Q_b=0. Nell’ipotesi 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 codifico in uscita RC. Esercizio 4 Si progetti. di quale sia il dato in questione ( 00 se 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 l’operazione. e cos` via).Su queste ipotesi il cicuito finale che realizza quanto richiesto e riportato in ` figura 10. utilizzando la tecnica delle ASM Chart. Alla fine delle operazioni la macchina deve restare in attesa di un altro fronte positivo di START prima di ripartire.

350 . Q_c=Q_c+1.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 1 Q=7 1 S6 END_OP<− 1 00 INDEX 10 01 S3 U <− QA S4 U <− QB S5 U <− QC Figura 10. Q_b=Q_b+1. THEN THEN THEN Q_a=Q_a+1.29: if RA_{i}=’1’ if RB_{i}=’1’ if RC_{i}=’1’ END LOOP.

INDEX = 10 .29 ` Esercizio 5 Nello schema di figura 10. Si ipotizzi di avere la seguente tempistica: per i FF SR : TS. b) La ASM chart dell’algoritmo e riportata in figura 10. i FF hanno le uscite Q inizializzate a 0. TSU = 2 ns.30: 351 . INDEX = 00 . INDEX = 01. else U=Q_c . elseif (Q_b>Q_c) U= Q_b .if ((Q_a>Q_b) THEN if & (Q_a>Q_c)) THEN U=Q_a . 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 flip flop 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. THL = 3 ns. per l’inverter: TLH = 2 ns. else U=Q_c .R→Q = 4 ns (per entrambe le transizioni). per il FF JK : TCK→Q = 5ns (per entrambe le transizioni) . INDEX = 10 .30.

t2 e t4 al tempo necessario per effettuare un intero ciclo. mentre t3 si riferisce all’intervallo dal fronte di salita del clock a quello di discesa immediatamente successivo. Figura 10.Soluzione Per il calcolo della frequenza massima di clock con duty cycle del 50% consideriamo i ritardi massimi tra le diverse porte JK. Dunque si avr` a fMAX = 1 2t3 = 1 28ns ≃ 35.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%.31. In particolare il tempot1 si riferisce all’intervallo che va dal fronte di discesa del clock a quello di salita. Dal primo al secondo FF JK =⇒ t1 = TClk→Q + TSU = 5 + 2 = 7ns Dal primo al terzo FF JK =⇒ t2 = TClk→Q + THL + TSU = 5 + 3 + 2 = 10ns Dal secondo al terzo FF JK =⇒ t3 = TClk→Q + THL + TSR→Q + TSU = 5 + 3 + 4 + 2 = 14ns Dal terzo al primo FF JK =⇒ t4 = TClk→Q + TSU = 5 + 2 = 7ns I tempi calcolati precedentemente si riferiscono a diverse condizioni da valutare e sono riportati in figura 10.7Mhz 352 .

Esercizio 6 Si descrivano le memorie RAM dinamiche. evidenziandone il funzionamento. 353 . gli ingressi/uscite e la tempistica.Se il tempo di hold tH > 14ns nell’ipotesi di lavorare alla frequenza massima si avranno violazioni all’ingresso del terzo flip flop.

Sign up to vote on this title
UsefulNot useful