Formulario - circuiti digitali

Sistemi digitali e rappresentazione dell'informazione

Note: Sistemi digitali, segnali binari e livelli di astrazioneUn sistema digitale elabora grandezze discrete; quello binario le codifica con due soli livelli (0 e 1), associati a due intervalli di tensione con ingresso più largo dell'uscita (margine di rumore, proprietà rigenerativa). Precisione = numero di bit, non ampiezza della tensione. Il calcolatore ha memoria, CPU (unità di controllo + datapath) e I/O. La progettazione procede per livelli di astrazione, dal transistor all'algoritmo; il corso copre i livelli intermedi (porte, trasferimento tra registri, microarchitettura), con descrizioni in VHDL.Sistemi digitali, segnali binari e livelli di astrazione → · Basi di numerazione e conversioni - binario, ottale ed esadecimaleUn numero in base $r$ vale $\sum a_i r^i$ (cifre $a_i\in{0,\dots,r-1}$). Conversioni: base $r\to$ decimale con la somma pesata; decimale $\to$ base $r$ per divisioni successive (parte intera, resti letti dal basso) e moltiplicazioni successive (parte frazionaria, parti intere lette dall'alto); binario $\leftrightarrow$ ottale/esadecimale a gruppi di 3/4 bit. Somma, differenza e prodotto binari seguono le regole decimali con cifre 0 e 1; la differenza ha prestiti, il prodotto somma prodotti parziali traslati.Basi di numerazione e conversioni - binario, ottale ed esadecimale → · Codici binari - BCD, ASCII, Unicode, parità e GrayUn codice binario a $n$ bit distingue $2^n$ elementi. BCD: una cifra decimale ogni 4 bit (1010–1111 non usati; 10 richiede 8 bit, non è il binario del numero). ASCII: 7 bit per 128 caratteri, la cifra ASCII è 011 seguito dal BCD. Unicode/UTF-8: da 1 a 4 byte, compatibile con ASCII. Bit di parità: rileva errori su un numero dispari di bit. Distanza di Hamming = numero di bit diversi. Codice Gray: numeri consecutivi differiscono di un solo bit (sensori di posizione); si costruisce per riflessione o con $g_i=b_i\oplus b_{i+1}$.Codici binari - BCD, ASCII, Unicode, parità e Gray → · Numeri con segno, complemento a 2, sottrazione e overflowSottrazione senza segno: se $M\ge N$ nessun prestito in uscita, altrimenti il risultato $M-N+2^n$ è scorretto. Complemento a 1: $2^n-1-N$ (inversione bit a bit); complemento a 2: $2^n-N=$ complemento a 1 $+1$. Numeri con segno: segno e modulo (due zeri, intervallo simmetrico) oppure complemento a 2 (un solo zero, da $-2^{n-1}$ a $2^{n-1}-1$, MSB di peso $-2^{n-1}$). In complemento a 2 somma e sottrazione sono la stessa addizione: $A-B=A+\overline B+1$, riporto in uscita scartato. Overflow: senza segno $\Leftrightarrow C_{out}=1$ nella somma; con segno $\Leftrightarrow C_{in,MSB}\ne C_{out,MSB}$ (due operandi dello stesso segno con risultato di segno opposto).Numeri con segno, complemento a 2, sottrazione e overflow →

• Un codice a $n$ bit ha $2^n$ configurazioni (401 valori richiedono 9 bit). Intervalli di tensione: l'ingresso accetta un intervallo più largo di quello prodotto in uscita. Margini: $NM_H=V_{OH,\min}-V_{IH,\min}$, $NM_L=V_{IL,\max}-V_{OL,\max}$.

• Base $r$: $N=\sum a_ir^i$. Una cifra ottale $=3$ bit, esadecimale $=4$ bit, raggruppando dalla virgola. Decimale $\to$ binario: parte intera con resti letti dal basso, frazione moltiplicando per 2 e leggendo le parti intere dall'alto ($0{,}4$ è periodico). Capacità: 1 GB decimale $=10^9$ B, binario $2^{30}$ B.
• BCD: 4 bit per cifra ($185=0001\,1000\,0101$), $1010$-$1111$ inutilizzati. ASCII: 7 bit, 128 caratteri. Distanza di Hammingnumero di bit in cui due parole differiscono. Parità: rileva un numero dispari di errori. Gray: $g_i=b_i\oplus b_{i+1}$, parole consecutive a distanza 1.
• Complementi: a 1 $=2^n-1-N$ (inversione), a 2 $=2^n-N=$ a 1 $+1$. Complemento a 2: un solo zero, intervallo da $-2^{n-1}$ a $2^{n-1}-1$, il MSB ha peso $-2^{n-1}$ ($11110011=-13$); estensione del segno. Somma: riporto in uscita scartato; sottrazione $A-B=A+\overline B+1$.
• Overflow: senza segno (somma) $C_{out}=1$; con segno $V=C_{in,MSB}\oplus C_{out,MSB}$ (stesso segno degli addendi e segno opposto nel risultato; segni diversi $\Rightarrow$ mai overflow). $70+80=10010110$ ($V=1$).

Algebra di Boole, porte logiche e minimizzazione

Note: Algebra di Boole - assiomi, teoremi e complemento di una funzioneL'algebra di Boole opera su variabili a due valori con AND, OR, NOT. Identità fondamentali (neutro, idempotenza, complemento, commutativa, associativa, distributiva in entrambe le forme), dualità (si scambiano AND/OR e 0/1), De Morgan $\overline{X+Y}=\overline X,\overline Y$, assorbimento $X+XY=X$, $X+\overline XY=X+Y$, adiacenza $XY+X\overline Y=X$, consenso $XY+\overline XZ+YZ=XY+\overline XZ$. Si dimostrano per induzione perfetta (tabella) o algebricamente. Il complemento di una funzione si ottiene con De Morgan o con duale + negazione dei letterali. Costo: numero di letterali o di ingressi delle porte.Algebra di Boole - assiomi, teoremi e complemento di una funzione → · Porte logiche, ritardi e porte universaliLe porte AND, OR, NOT realizzano le operazioni dell'algebra di Boole; NAND, NOR, XOR e XNOR ne derivano. Ogni funzione si descrive con la tabella di verità ($2^n$ righe). XOR a più ingressi = funzione di disparità (1 se gli 1 sono in numero dispari). Una porta reale ha ritardo di propagazione $t_G$ (diverso per 0→1 e 1→0): in un diagramma temporale l'uscita cambia $t_G$ dopo l'ingresso. NAND e NOR sono universali: bastano da sole a realizzare qualunque funzione. In VHDL: and, or, not, nand, nor, xor, xnor.Porte logiche, ritardi e porte universali → · Forme canoniche - mintermini, maxtermini, SOP e POSUn mintermine è un prodotto che contiene una e una sola volta tutte le variabili (dirette o negate) e vale 1 su una sola riga della tabella di verità; un maxtermine è la somma duale e vale 0 su una sola riga; con $n$ variabili ci sono $2^n$ mintermini e $2^n$ maxtermini, e $\overline{m_i}=M_i$. Forma canonica SOP = somma dei mintermini delle righe con $F=1$; POS = prodotto dei maxtermini delle righe con $F=0$. Le forme canoniche si ricavano sempre dalla tabella ma sono ridondanti: servono come punto di partenza per la minimizzazione. SOP e POS si realizzano con circuiti a due livelli.Forme canoniche - mintermini, maxtermini, SOP e POS → · Mappe di Karnaugh - implicanti e copertura minimaLa mappa di Karnaugh è la tabella di verità disposta in una griglia con righe e colonne in codice Gray, così che celle adiacenti (anche tra bordi opposti) differiscano in una sola variabile. Si raggruppano gli 1 in rettangoli di $2^k$ celle: ogni gruppo elimina $k$ variabili e dà un prodotto. Implicante primo = gruppo massimo; essenziale = unico a coprire un mintermine; la copertura minima contiene tutti gli essenziali più il minimo di altri primi (può non essere unica). Efficace fino a 4 variabili.Mappe di Karnaugh - implicanti e copertura minima → · Mappe di Karnaugh - POS, condizioni di don't care e paritàPer la POS minima si raggruppano gli 0 della mappa, si ottiene la SOP minima di $\overline F$ e si scrive $F$ come prodotto di somme (variabile diretta se vale 0 nel gruppo, negata se vale 1). Le condizioni di don't care (X) sono combinazioni di ingresso che non si presentano o la cui uscita è indifferente: si usano come 1 o come 0 a seconda di quel che allarga i gruppi (mai raggruppamenti fatti solo di X). Le funzioni XOR a più variabili (disparità) e XNOR (parità) hanno mappa a scacchiera: non si semplificano con i gruppi.Mappe di Karnaugh - POS, condizioni di don't care e parità →

• Identità: $X+0=X$, $X\cdot1=X$, $X+1=1$, $X\cdot0=0$, $X+\overline X=1$, $X\overline X=0$; distributiva doppia $X(Y+Z)=XY+XZ$ e $X+YZ=(X+Y)(X+Z)$. De Morgan: $\overline{X+Y}=\overline X\,\overline Y$, $\overline{XY}=\overline X+\overline Y$.
• Teoremi: assorbimento $X+XY=X$, $X+\overline XY=X+Y$; adiacenza $XY+X\overline Y=X$; consenso $XY+\overline XZ+YZ=XY+\overline XZ$.
• Porte: NAND $=\overline{XY}$, NOR $=\overline{X+Y}$, XOR $=1$ se diversi (a più ingressi: disparità), $X\oplus0=X$, $X\oplus1=\overline X$. Universali NAND e NOR; XOR con 4 NAND: $n_1=\overline{ab}$, $n_2=\overline{an_1}$, $n_3=\overline{bn_1}$, $y=\overline{n_2n_3}$. Ritardo $t_G$: l'uscita cambia $t_G$ dopo l'ingresso.
• Mintermine $m_i$: prodotto di tutte le variabili, diretta se il bit è 1, negata se 0. Maxtermine $M_i$: somma, negata se il bit è 1. $\overline{m_i}=M_i$. SOP canonica $=\sum m$ (righe con $F=1$); POS canonica $=\prod M$ (righe con $F=0$). Esempio $X\overline Y+YZ=\sum m(3,4,5,7)=\prod M(0,1,2,6)$. $2^{2^n}$ funzioni di $n$ variabili.
• Mappa di Karnaugh (righe e colonne in Gray $00,01,11,10$, bordi adiacenti): un gruppo di $2^k$ uni elimina $k$ variabili; IP = gruppo massimo, IPE = unico a coprire un 1; copertura minima = tutti gli IPE più il minimo di IP per gli 1 rimasti. POS: si raggruppano gli 0 e ogni gruppo dà una somma, diretta se 0, negata se 1. Don't care: usati come 0 o 1 per ingrandire i gruppi, mai gruppi di sole X. XOR a più ingressi: mappa a scacchiera, non semplificabile.

Progettazione di reti combinatorie

Note: Progettazione di una rete combinatoria - approccio gerarchico e porte NAND-NORUna rete combinatoria ha uscite che dipendono solo dagli ingressi presenti (nessuna memoria, nessuna retroazione); una sequenziale dipende anche dalla storia (stato, memoria, feedback). Progetto: specifiche, tabella di verità, funzione a costo minimo, diagramma logico, verifica. Con molti ingressi si usa l'approccio gerarchico (blocchi e sottoblocchi riusabili; regolarità). Blocchi base: funzioni di una variabile, vettori, enabling. Mappatura tecnologica: in CMOS NAND e NOR sono più compatte, quindi SOP $\to$ NAND-NAND e POS $\to$ NOR-NOR.Progettazione di una rete combinatoria - approccio gerarchico e porte NAND-NOR → · Decoder, encoder e priority encoderUn decoder $n$-to-$m$ ($m\le2^n$) converte un ingresso binario a $n$ bit in un'uscita 1-hot (un solo 1, nella posizione indicata): le sue uscite sono i mintermini degli ingressi, realizzati con $m$ AND; per decoder grandi si usa l'approccio gerarchico (costo in ingressi: 3-to-8 = 27, 6-to-64 = 182) e un enable. Ogni funzione = decoder + OR dei suoi mintermini. L'encoder fa l'operazione inversa (1-hot $\to$ binario) ma sbaglia con più ingressi a 1 o tutti a 0: il priority encoder risolve con una priorità e un'uscita V (valid).Decoder, encoder e priority encoder → · Multiplexer e funzioni logiche realizzate con decoder e multiplexerIl multiplexer (MUX) $2^n$-to-1 ha $2^n$ ingressi dati, $n$ ingressi di selezione e un'uscita che copia l'ingresso selezionato: $Y=\sum_i m_i(S),I_i$. Si realizza con decoder + AND di enable + OR (costo 22 per il 4-to-1) o direttamente (costo 18). Un MUX $2^n$-to-1 realizza qualunque funzione di $n$ variabili (ingressi dati = colonna della tabella di verità); con un MUX $2^{n-1}$-to-1 si usano le $n-1$ variabili come selezione e gli ingressi dati valgono $0$, $1$, $X$ o $\overline X$ (l'ultima variabile). I MUX a vettori selezionano gruppi di bit.Multiplexer e funzioni logiche realizzate con decoder e multiplexer →

• Combinatoria: uscite funzione dei soli ingressi attuali. SOP $\to$ NAND-NAND $F=\overline{\overline{P_1}\cdots\overline{P_k}}$, POS $\to$ NOR-NOR. Comparatore a 4 bit: $N_i=A_i\oplus B_i$, $E=\overline{N_0+N_1+N_2+N_3}$. Enabling: $F=X\cdot EN$.
• Decoder $n$-to-$2^n$: uscite $D_i=m_i$ (1-hot). Una funzione è un decoder più una OR dei mintermini ($S=\sum m(1,2,4,7)$, $C=\sum m(3,5,6,7)$). Encoder ottale: $A_0=D_1+D_3+D_5+D_7$, $A_1=D_2+D_3+D_6+D_7$, $A_2=D_4+\dots+D_7$. Priority encoder a 4 ingressi: $A_1=D_3+D_2$, $A_0=D_3+\overline{D_2}D_1$, $V=D_3+D_2+D_1+D_0$.
• Multiplexer: $Y=\sum m_i(S)\,I_i$; 2-to-1 $Y=\overline SI_0+SI_1$. Una funzione di $n$ variabili: tutte sulla selezione con $I_i=F(i)$; oppure $n-1$ sulla selezione e dati in $\{0,1,X,\overline X\}$ secondo $(F(X{=}0),F(X{=}1))$.

VHDL per la logica combinatoria

Note: Introduzione al VHDL - entity, architecture, tipi e livelli di descrizioneVHDL è un linguaggio di descrizione dell'hardware (HDL), non di programmazione: le dichiarazioni sono concorrenti e descrivono blocchi di circuito; serve per documentare, simulare e sintetizzare. Un blocco ha una entity (nome e porte in/out) e almeno una architecture (cosa c'è dentro: structural con component e port map, dataflow con equazioni booleane, behavioral con comportamento). Tipi: std_logic (da 1164: '0','1','X','Z','U','-',...), std_logic_vector, bit, boolean, integer. Signal per i collegamenti interni, constant per i valori fissi.Introduzione al VHDL - entity, architecture, tipi e livelli di descrizione → · VHDL - istruzioni concorrenti, process e testbenchLe istruzioni concorrenti VHDL sono l'assegnazione di segnale, when-else (logica prioritaria, condizioni valutate in ordine) e with-select (logica parallela: tutti i casi coperti da una sola scelta, others obbligatorio). Un process è un'istruzione concorrente il cui corpo è sequenziale (if, case, loop); parte quando cambia un segnale della sensitivity list (per la logica combinatoria: tutti gli ingressi); i segnali si aggiornano alla sospensione e vince l'ultima assegnazione. Un if senza else (o un caso non coperto) crea memoria non voluta. Il testbench è codice di simulazione con entity vuota, DUT istanziato e un process di stimoli con wait.VHDL - istruzioni concorrenti, process e testbench →

• Più driver sullo stesso segnale danno 'X'. In un process vince l'ultima assegnazione. if senza else o case incompleto $\Rightarrow$ latch: ogni uscita va assegnata in ogni ramo. Testbench: entity vuota, DUT, process di stimoli con wait for, wait; finale, assert.

Sommatori e sottrattori binari

Note: Sommatori binari - half adder, full adder e ripple carryHalf adder (2 ingressi): $S=X\oplus Y$, $C=XY$. Full adder (3 ingressi, con riporto in ingresso $Z$): $S=X\oplus Y\oplus Z$, $C=XY+XZ+YZ=G+PZ$ con $P=X\oplus Y$, $G=XY$; si realizza con due half adder e una OR. Il ripple carry adder a $n$ bit concatena $n$ full adder: il riporto "ondeggia" dal LSB al MSB, quindi il ritardo cresce linearmente con $n$. È un circuito iterativo (gerarchico e regolare). Il moltiplicatore a 2 bit usa 4 AND e 2 half adder.Sommatori binari - half adder, full adder e ripple carry →

• Half adder: $S=X\oplus Y$, $C=XY$. Full adder: $S=X\oplus Y\oplus Z=\sum m(1,2,4,7)$, $C=XY+XZ+YZ=\sum m(3,5,6,7)$; con $P=X\oplus Y$, $G=XY$: $S=P\oplus Z$, $C=G+PZ$. Ripple carry: $n$ full adder in cascata, ritardo $\sim2n\,t_G$ (lineare); $1011+0101=0000$ con $C_4=1$.

Reti sequenziali: latch, flip-flop e macchine a stati

Note: Elementi di memoria - latch SR, latch D e flip-flop DUn circuito sequenziale ha uscite che dipendono da ingressi e stato (memoria); è un circuito combinatorio con elementi di memoria in retroazione; stato presente = uscite dei FF, stato futuro = ingressi dei FF. Sincrono (clock) o asincrono. Latch SR (NOR): S=1,R=0 set; S=0,R=1 reset; 00 memoria; 11 proibito. Latch D: C=1 trasparente (Q=D), C=0 memoria, sensibile al livello. Flip-flop D edge-triggered = due latch D in cascata (master-slave) con clock opposti: cambia solo sul fronte attivo e non è trasparente. Si assume D flip-flop positive-edge-triggered.Elementi di memoria - latch SR, latch D e flip-flop D → · Temporizzazione dei flip-flop - setup, hold e frequenza massima di clockUn flip-flop memorizza il dato corretto solo se l'ingresso è stabile per $t_s$ (setup) prima e $t_h$ (hold) dopo il fronte di clock; l'uscita cambia dopo il tempo di propagazione $t_{pd,FF}$ dal fronte. In un circuito sincrono il periodo deve soddisfare $T\ge t_{pd,FF}+t_{COMB}+t_{s,FF}+t_{slack}$, quindi $f_{max}=1/T_{min}$; abbassare la frequenza risolve le violazioni di setup. Il vincolo di hold $t_{pd,FF,min}+t_{COMB,min}\ge t_h$ non dipende dal clock (e non si risolve rallentandolo). Il clock skew modifica i vincoli.Temporizzazione dei flip-flop - setup, hold e frequenza massima di clock → · Analisi delle reti sequenziali - tabella e diagramma degli stati, Mealy e MooreAnalizzare una rete sequenziale sincrona significa ricavare, dal circuito, le equazioni di ingresso dei flip-flop (stato futuro) e dell'uscita, la tabella degli stati ($2^{m+n}$ righe per $m$ FF e $n$ ingressi), il diagramma degli stati (cerchi = stati, frecce = transizioni con ingresso/uscita) e la simulazione temporale. Mealy: uscita funzione di stato e ingresso (scritta sulle frecce, può cambiare tra due fronti di clock); Moore: uscita funzione del solo stato (scritta nel cerchio, cambia solo al fronte). Due stati sono equivalenti se danno le stesse uscite e portano a stati equivalenti: si fondono per ridurre i FF.Analisi delle reti sequenziali - tabella e diagramma degli stati, Mealy e Moore → · Sintesi delle reti sequenziali - riconoscitore di sequenza e codifica degli statiSintesi di una rete sequenziale sincrona: specifiche $\to$ diagramma degli stati $\to$ tabella (riduzione degli stati equivalenti) $\to$ codifica binaria degli stati $\to$ scelta del FF (D PET) $\to$ equazioni di ingresso dei FF e delle uscite $\to$ minimizzazione $\to$ circuito e verifica. Lo stato riassume la parte di storia utile; per i riconoscitori si ha uno stato per ogni prefisso riconosciuto, riusando gli stati (sovrapposizioni). Reset: stato iniziale noto. Codifica Gray (numero minimo di FF) vs 1-hot (un FF per stato, logica più semplice): per il riconoscitore 1101 Gray costa circa la metà.Sintesi delle reti sequenziali - riconoscitore di sequenza e codifica degli stati →

• Latch SR (NOR): $SR=00$ memoria, $01$ reset, $10$ set, $11$ proibito. Latch D: $C=1$ trasparente ($Q=D$), $C=0$ memoria. Flip-flop D a fronte di salita (due latch con clock opposti): $Q(t+1)=D$ solo sul fronte.

• Parametri: $t_s$ (setup, $D$ stabile prima del fronte), $t_h$ (hold, stabile dopo), $t_{pd,FF}$ (dal fronte a $Q$ stabile). Periodo: $T\ge t_{pd,FF}+t_{COMB}+t_{s,FF}+t_{slack}$, $f_{max}=\frac1{T_{min}}$ (ritardi massimi, cammino critico); il setup si cura abbassando la frequenza. Hold: $t_{pd,FF,\min}+t_{COMB,\min}\ge t_h$, indipendente dal clock: si aggiunge ritardo ai percorsi corti.

• Mealy: uscita(stato, ingresso), scritta sulle frecce ingresso/uscita, meno stati. Moore: uscita(stato), scritta nel cerchio, cambia solo al fronte. Equazioni di ingresso dei FF D: $A(t+1)=D_A$; tabella con $2^{m+n}$ righe; stati equivalenti si fondono.
• Sintesi: specifiche, diagramma, tabella, codifica con $n=\lceil\log_2m\rceil$ bit, equazioni dei $D$, minimizzazione, verifica. Riconoscitore di $1101$ (Mealy, sovrapposto): $S_4$ con $X=1$ dà $Z=1$; codifica Gray $S_1..S_4=00,01,11,10$ dà $D_A=BX+AB$, $D_B=X$, $Z=A\overline BX$; one-hot usa 4 FF.

VHDL per la logica sequenziale

Note: VHDL - latch, flip-flop e reset sincrono e asincronoIn VHDL un elemento di memoria si descrive con un process il cui ramo non assegna sempre il segnale: latch D = process(D,C) con if C='1' then Q<=D; flip-flop positive-edge-triggered = process(CLK) con if CLK'event and CLK='1'. Reset asincrono: RST nella sensitivity list e testato per primo (if RST='1' ... elsif fronte); reset sincrono: solo CLK in lista e RST testato dentro al ramo del fronte (serve un fronte per averne effetto). Il testbench di un circuito sincrono ha un process che genera il clock e uno che applica gli ingressi lontano dal fronte attivo.VHDL - latch, flip-flop e reset sincrono e asincrono → · VHDL - macchine a stati finiti e testbench sequenzialeUna macchina a stati finiti (FSM) si descrive in VHDL, in stile behavioral, con un tipo enumerato per gli stati e tre process: (1) registro di stato con reset (asincrono) e aggiornamento state<=next_state sul fronte; (2) stato futuro come funzione combinatoria di stato e ingresso (case state, default next_state<=state); (3) uscita come funzione combinatoria di stato (Moore) o di stato e ingresso (Mealy). Il testbench ha il process del clock e il process degli ingressi (reset iniziale, sequenza di test che percorre tutti gli stati).VHDL - macchine a stati finiti e testbench sequenziale →

• FSM a tre process: registro di stato (reset e state <= next_state al fronte), next_state con case state e default next_state <= state;, uscita (Mealy: sensibilità (X, state); Moore: (state)). Testbench sincrono: process del clock e process degli ingressi lontani dal fronte.

Tecnologie implementative

Note: Porte CMOS e parametri tecnologici dei circuiti integratiNei circuiti integrati digitali (CMOS) i MOSFET si modellano come interruttori: nMOS chiuso se il gate vale 1, pMOS chiuso se il gate vale 0. Una porta CMOS ha una rete di pull-up (PUN, solo pMOS) verso Vdd e una di pull-down (PDN, solo nMOS) verso massa, duali: una è ON e l'altra OFF. NAND: nMOS in serie e pMOS in parallelo; NOR: nMOS in parallelo e pMOS in serie; una porta a $n$ ingressi ha $2n$ transistor. Parametri: fan-in, fan-out, margine di rumore, ritardo di propagazione ($t_{pHL}$, $t_{pLH}$, limita la frequenza di clock), dissipazione di potenza, costo (area di silicio; costi NRE e di produzione).Porte CMOS e parametri tecnologici dei circuiti integrati → · Logica programmabile - ROM, PLA, PAL e FPGAI dispositivi logici programmabili (PLD) hanno strutture logiche configurabili dal costruttore o dall'utente (configurazione $\ne$ programmazione software): ROM ($2^k$ parole da $n$ bit: decoder + OR programmabili), PLA (AND e OR programmabili, termini prodotto condivisi tra le uscite), PAL (AND programmabili, OR fisse, niente condivisione), FPGA (blocchi logici con LUT e flip-flop, interconnessioni e I/O programmabili, memoria di configurazione volatile o no). La programmazione può essere irreversibile (fuse/anti-fuse, mask) o riconfigurabile (SRAM, gate flottante).Logica programmabile - ROM, PLA, PAL e FPGA →

• CMOS: nMOS chiuso con gate $=1$, pMOS chiuso con gate $=0$. Porta con PUN (pMOS) a $V_{dd}$ e PDN (nMOS) a massa, duali: NAND = nMOS in serie e pMOS in parallelo, NOR il contrario; $2n$ transistor per $n$ ingressi. Potenza $\alpha CV_{dd}^2f$; frequenza $\propto\frac1{\sum\text{ritardi peggiori}}$.

Registri, contatori e sistemi non programmabili

Note: Registri e microoperazioniUn registro a $n$ bit è formato da $n$ flip-flop (più porte) con clock comune; il caricamento si controlla con clock gating (OR con il clock: risparmia potenza ma introduce ritardi e clock skew) oppure, meglio, con load enable (MUX + D FF: $Q\leftarrow D$ se EN=1, $Q\leftarrow Q$ altrimenti). Un sistema digitale complesso si divide in datapath (registri e blocchi aritmetico-logici) e unità di controllo (FSM che invia i segnali di controllo e riceve i segnali di stato). Le microoperazioni, scritte in RTL (es. $K_1:R_2\leftarrow R_1$), sono di trasferimento, aritmetiche, logiche (con maschere: AND azzera, OR pone a 1, XOR complementa) e di scorrimento.Registri e microoperazioni → · Registri a scorrimento e contatoriPiù sorgenti per un registro di destinazione si gestiscono con un MUX che sceglie la sorgente (e un encoder se i segnali di controllo sono 1-hot) più il Load. Lo shift register è una catena di FF con uscita di ognuno collegata all'ingresso del successivo: ingresso e uscita seriali, caricamento parallelo (Shift ha priorità su Load), versione bidirezionale con un MUX 4-to-1 per stadio (S1S0: 00 hold, 01 shift left, 10 shift right, 11 load). Usi: conversione serie/parallelo, interfacce, linee di ritardo, generatori pseudo-casuali. Contatori: ripple (asincrono, il clock di ogni FF è l'uscita del precedente, ritardo crescente) e sincrono (stesso clock, più veloce; EN e CO per la cascata).Registri a scorrimento e contatori → · Datapath e unità di controllo - un sistema digitale non programmabileUna cella di registro è un flip-flop con la logica per le microoperazioni; un registro a $n$ bit ha $n$ celle e logica di controllo condivisa. Un sistema programmabile (CPU) ha un'unità di controllo che esegue istruzioni lette da una memoria (PC); in un sistema non programmabile la unità di controllo decide le microoperazioni solo da ingressi e segnali di stato del datapath. Esempio completo: sommare cinque valori consecutivi con start, res, busy; datapath con ACC_REG, OUT_REG, CNT_REG (decrementer, MUX, segnale di stato zero); microoperazioni (op_acc_idle/clr/acc/upd_out, op_cnt_idle/cnt/reload); unità di controllo a 3 stati (ready, acc, init), macchina di Mealy.Datapath e unità di controllo - un sistema digitale non programmabile →

• Registro a $n$ bit: $n$ FF D con clock comune; load enable (MUX + D FF) preferibile al clock gating. RTL: $K_1:R_2\leftarrow R_1$; microoperazioni simultanee separate da virgola. Maschere: AND azzera, OR pone a 1, XOR complementa. $A-B$: $R_1\leftarrow R_1+\overline{R_2}+1$.
• Shift register: SI in $Q_0$, SO $=Q_3$, ritardo di 4 cicli; $sl$ verso il MSB, $sr$ verso il LSB; bidirezionale con MUX 4-to-1 ($S_1S_0=00$ hold, $01$ shift left, $10$ shift right, $11$ load).
• Contatore ripple (asincrono): il clock di ogni FF è $\overline Q$ del precedente, ritardo $\sim n\,t_p$. Sincrono: stesso clock, XOR e AND, $EN$ e $CO$ in cascata, più veloce.

• Sistema non programmabile = datapath (registri e ALU) + unità di controllo (FSM con segnali di controllo e di stato); la CU non ha PC né istruzioni da memoria.

Memorie

Note: Memorie ROM e RAM - SRAM, DRAM e organizzazione dei chipUna memoria è un insieme di celle (word da più bit) con circuiteria di controllo. Classificazioni: sola lettura (ROM) o lettura/scrittura; ad accesso casuale (RAM), seriale (SAM) o ibrido (Flash); volatile (SRAM, DRAM) o non volatile. Una RAM $2^k\times n$ ha $k$ bit di indirizzo (indipendenti da $n$), $n$ bit dati, read/write e chip select. SRAM: cella bistabile (latch), veloce, senza refresh; DRAM: condensatore, più densa, con refresh. Organizzazione: decoder di riga e colonna (coincident selection), uscite tri-state, array di chip (più chip per più parole, più bit per più linee dati).Memorie ROM e RAM - SRAM, DRAM e organizzazione dei chip →

• RAM $2^k\times n$: $k$ bit di indirizzo (indipendenti da $n$), $n$ bit di dato, read/write, Chip Select ($1\mathrm K\times16$: 10 bit di indirizzo). ROM: decoder più OR programmabili, combinatoria. SRAM: latch, veloce, senza refresh (cache); DRAM: condensatore, refresh, più densa (memoria principale).
• Array: $4\times64\mathrm K\times8\to256\mathrm K\times8$ con decoder 2-to-4 su 2 bit di indirizzo in più (uscite non selezionate in Hi-Z); $2\times64\mathrm K\times8\to64\mathrm K\times16$ allargando il parallelismo.

Un semplice microprocessore e pipeline

Note: Un semplice microprocessore - datapath, ALU e register fileUn calcolatore semplificato ma completo ha datapath, unità di controllo e memoria. Il datapath contiene un register file ($2^m$ registri da $n$ bit, due porte di lettura A e B e una di scrittura), un MUX B (registro o costante), una unità funzionale = ALU + shifter e un MUX D (risultato o dato dalla memoria); segnala V, C, N, Z. La ALU unisce un circuito aritmetico (sommatore con logica di ingresso per $B$: $0$, $B$, $\overline B$, tutti 1, più $C_{in}$) e uno logico (AND, OR, XOR, NOT) tramite un MUX. Le 15 microoperazioni si scelgono con un codice FS a 4 bit; la control word del datapath è di 16 bit (DA, AA, BA, MB, FS, MD, RW).Un semplice microprocessore - datapath, ALU e register file → · Un semplice microprocessore - istruzioni, ciclo singolo e cicli multipliIstruzioni a 16 bit: opcode (7 bit) + DR, SA, SB/OP (3 bit ciascuno) oppure formato di salto con offset a 6 bit (AD sinistro + AD destro, relativo al PC e con estensione di segno). Insieme di istruzioni load/store (solo LD e ST accedono ai dati): MOVA, INC, ADD, SUB, ..., LDI, ADI, LD, ST, BRZ, BRN, JMP. Nel computer a ciclo singolo (due memorie separate) il decoder combinatorio ricava MB, MD, RW, MW, PL, JB, BC dai bit 15, 14, 13, 9 dell'istruzione e $FS$ dai bit 12–9; il periodo di clock è la somma dei ritardi lungo il cammino peggiore (9,8 ns nell'esempio). Nel computer a cicli multipli (memoria unica) servono IR, registri interni R8–R15 e un decoder sequenziale: fetch (INF) + uno o più stati di esecuzione.Un semplice microprocessore - istruzioni, ciclo singolo e cicli multipli → · Pipeline, hazard e architetture RISC e CISCLa pipeline divide l'esecuzione in stadi separati da registri (IF, DOF, EX, WB) che lavorano in parallelo su istruzioni diverse: la latenza di una istruzione non cambia, il throughput aumenta di un fattore minore del numero di stadi (ritardo dei FF, stadio più lento). Con $k$ stadi e $N$ istruzioni servono $k+N-1$ cicli (riempimento e svuotamento). Gli hazard bloccano la pipeline: di dato (operando non ancora scritto: rimedi NOP, stall, forwarding) e di controllo (salti: bolle, branch prediction). RISC: istruzioni semplici, load/store, formato unico, 32 registri con R0$=0$; CISC: istruzioni complesse, più modi di indirizzamento, formato variabile, controllo microprogrammato.Pipeline, hazard e architetture RISC e CISC →

• Datapath: register file $2^m\cdot n$ (letture $AA$, $BA$, scrittura $DA$, $RW$), MUX B ($MB$), unità funzionale ALU + shifter ($FS$), MUX D ($MD$), stato $V,C,N,Z$. ALU aritmetica $G=A+Y+C_{in}$ con $Y\in\{0,B,\overline B,1\dots1\}$. Control word di 16 bit: DA(3) AA(3) BA(3) MB(1) FS(4) MD(1) RW(1); $R_1\leftarrow R_2-R_3$: $001\,010\,011\,0\,0101\,0\,1$.

• Ciclo singolo: periodo = somma dei ritardi lungo il cammino ($0{,}2+4+0{,}6+0{,}2+4+0{,}2+0{,}6=9{,}8$ ns, circa 102 MHz). Cicli multipli: una memoria, IR, minimo 2 cicli per istruzione. PC-relativo: offset di 6 bit con segno.
• Pipeline con $k$ stadi e $N$ istruzioni: $k+N-1$ cicli. La latenza non diminuisce, il throughput cresce fino a $\sim k$ volte (meno: ritardo dei FF e stadio più lento); $2{,}4$ ns in 3 stadi $0{,}8/1{,}0/1{,}0$ dà $T=1$ ns, speedup $2{,}4$. Hazard di dato: NOP, stall, forwarding. Hazard di controllo: NOP (2 cicli persi) o branch prediction.

Input-output e gerarchia di memoria

Note: Interfacce di input-output - strobing, handshaking, interrupt e DMALe periferiche (tastiera, disco, display) hanno velocità, codici e funzionamento diversi dalla CPU: servono interfacce che sincronizzano e adattano i dati. Un unico bus collega più periferiche, ognuna con un decoder di indirizzo (memory-mapped: indirizzi comuni con la memoria; isolated: linee di controllo separate). Controllo asincrono con strobing (senza conferma) o handshaking (con conferma, più robusto). Trasmissione seriale (meno linee) o parallela; simplex, half e full duplex; USB a pacchetti con codifica NRZI. Modi di trasferimento: I/O programmato (busy-wait, spreca la CPU), interrupt (priorità: daisy chain, parallela con maschera), DMA (il controllore prende il bus con BR/BG e trasferisce senza CPU).Interfacce di input-output - strobing, handshaking, interrupt e DMA → · Cache e memoria virtuale - mappatura e tabelle delle pagineLe memorie sono in gerarchia (SRAM piccole e veloci, DRAM più grandi e lente, dischi enormi e lenti) perché la CPU riutilizza dati vicini nel tempo e nello spazio (località). Cache hit/miss, hit rate; mappatura diretta (indice = bit meno significativi, tag = bit alti), completamente associativa (tag = indirizzo intero, confronto in parallelo con memoria associativa), a $k$ vie (un blocco può stare in $k$ locazioni di un solo insieme). La memoria virtuale espone a ogni programma l'intera memoria con una traduzione indirizzo virtuale $\to$ fisico a pagine (tabella delle pagine con bit valid, dirty, used); il TLB accelera la traduzione; page fault = pagina da recuperare dal disco.Cache e memoria virtuale - mappatura e tabelle delle pagine →

• Tempo di accesso al disco = seek + ritardo rotazionale + controller ($9+4{,}17+0{,}2+0{,}04\approx13{,}4$ ms). Strobing senza conferma, handshaking con conferma; seriale/parallela, simplex/half/full duplex; memory-mapped o isolated I/O. Interrupt vettorizzati con priorità (software, daisy chain, parallela); DMA: il controllore prende il bus (BR/BG).
• Cache: $t_{medio}=t_{hit}+m\cdot t_{pen}$ ($1+0{,}05\cdot50=3{,}5$ ns). Diretta: indice = bit meno significativi, tag = bit alti, un solo posto; completamente associativa: tag = indirizzo; a $k$ vie: $k$ posti per insieme. Memoria virtuale: tabella delle pagine (frame, valid, dirty, used), offset invariato, TLB per evitare l'accesso doppio, page fault se la pagina è su disco.

Verifica dei propri risultati

Note: Verificare reti logiche e automi con PythonPython serve a controllare i propri conti: tabelle di verità con itertools.product, minimizzazione con sympy (SOPform/POSform con mintermini e don't care), equivalenza di due espressioni con satisfiable(Not(Equivalent(...))), simulazione di una macchina a stati con un dizionario (stato, ingresso) $\to$ (stato futuro, uscita) confrontata con una definizione indipendente, somma in complemento a 2 con rilevazione dell'overflow. Non sostituisce il metodo da sapere a mano (mappe di Karnaugh, tabelle degli stati) ma evita errori di calcolo.Verificare reti logiche e automi con Python →