Formulario - elettronica dei sistemi digitali

Fondamenti dei sistemi digitali

Note: Segnali digitali, livelli logici e margini di rumoreUn segnale digitale assume un insieme finito di valori (di solito due: bit, tipicamente 0 V e V_DD); con N bit si distinguono 2^N livelli. Il valore logico di un'uscita è garantito sopra V_OH (uno) e sotto V_OL (zero); un ingresso è letto come uno sopra V_IH e come zero sotto V_IL, con intervalli di ingresso più larghi di quelli di uscita. I margini di rumore sono NM_H = V_OH − V_IH e NM_L = V_IL − V_OL. La caratteristica di trasferimento statica (VTC) ha la soglia logica V_M (V_out = V_in); V_IL e V_IH sono i punti a pendenza −1. La proprietà rigenerativa (pendenza alta nella zona di transizione, guadagno maggiore di 1) ripulisce il segnale a ogni stadio ed è legata alla bistabilità della coppia di inverter in retroazione. Altre figure di merito: fan-in, fan-out, tempi di propagazione, potenza, costo.Segnali digitali, livelli logici e margini di rumore → · Rappresentazione dei numeri e dell'informazioneUn'informazione digitale è una stringa di bit. Numeri senza segno: N bit rappresentano 0…2^N − 1; in esadecimale ogni cifra raggruppa 4 bit. Numeri con segno: complemento a due (range −2^(N−1)…2^(N−1) − 1; si nega invertendo i bit e sommando 1; il bit più significativo è il segno e l'estensione di segno lo replica). Il BCD codifica ogni cifra decimale con 4 bit (0…9) e si ottiene dal binario con l'algoritmo double dabble (shift a sinistra, e +3 a ogni gruppo maggiore di 4 prima dello shift). Il codice Gray cambia un solo bit tra valori consecutivi. I numeri frazionari si trattano in virgola fissa (4 bit di parte frazionaria = multipli di 1/16), i caratteri in ASCII, gli errori con un bit di parità.Rappresentazione dei numeri e dell'informazione →

• $N$ bit distinguono $2^N$ livelli; risoluzione su un'escursione $\Delta V$: $\frac{\Delta V}{2^N}$ (16 bit su 1 V: $15{,}3\ \mu$V).
• Uscita valida: $V_{out}<V_{OL}$ (0) o $>V_{OH}$ (1); ingresso letto come 0 sotto $V_{IL}$ e come 1 sopra $V_{IH}$, con $V_{OL}<V_{IL}<V_{IH}<V_{OH}$. Margini: $NM_L=V_{IL}-V_{OL}$, $NM_H=V_{OH}-V_{IH}$.
• VTCcaratteristica di trasferimento statica V_out(V_in): soglia logica $V_M$ dove $V_{out}=V_{in}$; $V_{IL}$ e $V_{IH}$ dove la pendenza è $-1$. Rigenerazione: guadagno $>1$ nella transizione.
• Senza segno: $0\ldots2^N-1$. Complemento a due: $v=-b_{N-1}2^{N-1}+\sum_{i=0}^{N-2}b_i2^i$, range $-2^{N-1}\ldots2^{N-1}-1$; negazione = inverti i bit $+1$; $A-B=A+\overline B+1$; overflow se due operandi dello stesso segno danno segno opposto.
• BCD: 4 bit per cifra; double dabble: prima di ogni shift a sinistra ogni gruppo $>4$ riceve $+3$. Gray: $g=b\oplus(b\gg1)$. Virgola fissa: intero$/2^F$.

Il transistor MOS

Note: Il transistor MOS come interruttore - soglia, caratteristiche e capacitàIl MOS ha quattro terminali (gate, source, drain, bulk); il bulk dell'n-MOS va a massa, quello del p-MOS a V_DD. Il canale esiste (inversione) per V_GS > V_T nell'n-MOS (V_T > 0) e per V_GS < V_T nel p-MOS (V_T < 0). La soglia cresce in modulo con la tensione di source rispetto al bulk (effetto body): V_T = V_T0 + γ(√|−2Φ_F+V_SB| − √|2Φ_F|). Corrente: lineare per V_DS < V_GS − V_T, I_D = k'(W/L)[(V_GS−V_T)V_DS − V_DS²/2]; saturazione per V_DS > V_GS − V_T, I_D = (k'/2)(W/L)(V_GS−V_T)²(1+λV_DS). In digitale il transistor è un interruttore con resistenza equivalente R_eq ∝ 1/Z (Z = W/L) e capacità di gate C_g = C_ox W L, di drain e source ∝ W. Raddoppiando Z la resistenza dimezza e le capacità raddoppiano.Il transistor MOS come interruttore - soglia, caratteristiche e capacità →

• Canale per $V_{GS}>V_T$ (n-MOS, $V_T>0$) e $V_{GS}<V_T$ (p-MOS, $V_T<0$). Effetto body: $V_{T}=V_{T0}+\gamma\big(\sqrt{|-2\Phi_F+V_{SB}|}-\sqrt{|2\Phi_F|}\big)$.
• Con $Z=\frac WL$, $k'=\mu C_{ox}$ ($k'_n>0$, $k'_p<0$): spento $I_D=0$ per $V_{GS}\le V_T$; lineare ($V_{DS}<V_{GS}-V_T$) $I_D=k'_nZ\big[(V_{GS}-V_T)V_{DS}-\frac12V_{DS}^2\big]$; saturazione ($V_{DS}\ge V_{GS}-V_T$) $I_D=\frac12k'_nZ(V_{GS}-V_T)^2(1+\lambda_nV_{DS})$.
• Resistenza equivalente in commutazione: $R_{eq}\simeq\frac34\frac{V_{DD}}{I_{DSAT}}\big(1-\frac79\lambda V_{DD}\big)$; $R_n=\frac{R_{n0}}{Z_n}$, $R_p=\frac{R_{p0}}{Z_p}$ ($R_{eq}\propto\frac1Z$, le capacità crescono con $Z$).

L'invertitore CMOS

Note: Invertitore CMOS - caratteristica di trasferimento staticaL'inverter CMOS ha un p-MOS verso V_DD e un n-MOS verso massa con gli ingressi collegati: V_OH = V_DD, V_OL = 0, nessun cammino diretto in continua (consumo statico nullo). La VTC ha cinque regioni (n-MOS off; n sat/p lin; entrambi sat in V_M; n lin/p sat; p off). Con entrambi in saturazione e λ = 0: V_M = (V_Tn + r(V_DD + V_Tp))/(1 + r) con r = √(|k'_p|Z_p/(k'_n Z_n)). Bilanciamento statico (V_M = V_DD/2 con V_Tn = |V_Tp|): Z_p/Z_n = k'_n/|k'_p| (circa 3,8). Scalare Z_n e Z_p dello stesso fattore lascia V_M invariata e moltiplica la corrente di picco; aumentare Z_p/Z_n alza V_M, V_IL e V_IH; V_M segue V_DD. Margini NM_L = V_IL, NM_H = V_DD − V_IH (circa 1 V a 2,5 V).Invertitore CMOS - caratteristica di trasferimento statica → · Invertitore CMOS - ritardo di propagazioneIn commutazione l'inverter è un circuito RC del primo ordine: il tempo di propagazione al 50% vale t_p = ln2·τ = 0,69·R·C. Con R_n e R_p resistenze equivalenti e C_L = C_int + C_ext (intrinseca = capacità di drain di n-MOS e p-MOS; estrinseca = gate delle porte pilotate e interconnessioni): t_pHL = 0,69 R_n C_L, t_pLH = 0,69 R_p C_L. Con Z_p = βZ_n, R_p/R_n = r/β (r = R_p0/R_n0 ≈ 2,4): il bilanciamento dinamico (t_pHL = t_pLH) richiede β = r, mentre il minimo del ritardo medio con carico a gate si ha per β = √r. Moltiplicando Z_n e Z_p per S: t_p = t_p0 (1 + C_ext/(S C_int,ref)): a carico estrinseco dominante raddoppiare le larghezze dimezza il ritardo; con carico intrinseco dominante non cambia (autocaricamento).Invertitore CMOS - ritardo di propagazione → · Catene di inverter e buffer CMOSPer pilotare un carico grande C_L partendo da un ingresso piccolo C_in si usa una catena di N inverter di dimensioni crescenti (buffer). Il ritardo totale è t_p = t_p0 Σ (1 + f_j/γ), con f_j = C_gin,j+1/C_gin,j il fan-out dello stadio j e γ = C_int/C_g (circa 1-2). Il minimo, a N fissato, si ha con lo stesso fan-out in tutti gli stadi, f = F^(1/N) con F = C_L/C_in (ogni stadio è la media geometrica dei vicini e ha lo stesso ritardo): t_p = N t_p0 (1 + F^(1/N)/γ). Il numero ottimo di stadi si trova da ln f = 1 + γ/f (f = e per γ = 0, f ≈ 3,6 per γ = 1, N = ln F / ln f). Un anello di N inverter (N dispari, N ≥ 3) oscilla con periodo 2N t_p.Catene di inverter e buffer CMOS → · Consumo di potenza nei circuiti CMOSNella logica CMOS il consumo è quasi tutto dinamico. Per ogni carica di C_L da 0 a V_DD l'alimentazione eroga E_DD = C_L V_DD²; metà (½C_L V_DD²) viene immagazzinata nella capacità e metà dissipata nel p-MOS, indipendentemente dal valore di R; nella scarica l'energia immagazzinata è dissipata nell'n-MOS e dall'alimentazione non si assorbe nulla. La potenza media è P = α C_L V_DD² f (α = probabilità di una transizione 0→1 per periodo; per un inverter che commuta a ogni ciclo α = 1; con probabilità di uno p₁ all'uscita α = p₁(1−p₁) se i valori successivi sono indipendenti). Non dipende dalle dimensioni dei transistor (solo da C_L), scala col quadrato di V_DD (dimezzare V_DD: potenza ÷4) ma abbassare V_DD rallenta il circuito. Si aggiungono la corrente di corto circuito (ingressi lenti) e le correnti di perdita.Consumo di potenza nei circuiti CMOS →

• $V_{OH}=V_{DD}$, $V_{OL}=0$, consumo statico nullo. Entrambi in saturazione ($\lambda=0$): $V_M=\frac{V_{Tn}+r(V_{DD}+V_{Tp})}{1+r}$, $r=\sqrt{\frac{|k'_p|Z_p}{k'_nZ_n}}$. Bilanciamento ($V_M=\frac{V_{DD}}2$, $V_{Tn}=|V_{Tp}|$): $\frac{Z_p}{Z_n}=\frac{k'_n}{|k'_p|}$. Margini: $NM_L=V_{IL}$, $NM_H=V_{DD}-V_{IH}$.

• Ritardo al 50%: $t_p=\ln2\,\tau=0{,}69\,RC$; $t_{pHL}=0{,}69R_nC_L$, $t_{pLH}=0{,}69R_pC_L$, $C_L=C_{int}+C_{ext}$. Con $Z_p=\beta Z_n$ e $r=\frac{R_{p0}}{R_{n0}}$: $R_p=\frac r\beta R_n$; bilanciamento dinamico $\beta=r$, minimo del ritardo medio con carico a gate $\beta_{opt}=\sqrt r$.
• Scala $S$: $t_p=t_{p0}\big(1+\frac{C_{ext}}{S\,C_{int,ref}}\big)$, $t_{p0}=0{,}69R_{ref}C_{int,ref}$ (con carico intrinseco dominante $S$ non serve).

• Buffer di $N$ inverter: $t_p=t_{p0}\sum_j\big(1+\frac{f_j}\gamma\big)$, $f_j=\frac{C_{gin,j+1}}{C_{gin,j}}$, $\gamma=\frac{C_{int}}{C_g}\approx1$-$2$. Minimo con fan-out uguale: $f=\sqrt[N]F$, $F=\frac{C_L}{C_{in}}$, $t_p=N\,t_{p0}\big(1+\frac{\sqrt[N]F}\gamma\big)$; $N$ ottimo da $\ln f=1+\frac\gamma f$. Anello di $N$ inverter ($N$ dispari): periodo $2Nt_p$.

• Potenza dinamica: $E_{DD}=C_LV_{DD}^2$ per carica (metà immagazzinata, metà dissipata nel p-MOS); $P_{din}=\alpha\,C_LV_{DD}^2f_{CLK}$, $\alpha$ = probabilità di transizione $0\to1$ ($\alpha=p_0p_1$). Non dipende da $Z$; scala con $V_{DD}^2$.

Porte logiche CMOS e processo di fabbricazione

Note: Porte logiche CMOS - struttura statica complementare e dimensionamentoUna porta CMOS statica complementare ha una rete di pull-down (PDN, n-MOS) verso massa e una di pull-up (PUN, p-MOS) verso V_DD, duali tra loro: serie ↔ parallelo. La PDN conduce quando la funzione f degli ingressi vale 1 e porta l'uscita a 0, quindi F = NOT f (le porte a uno stadio sono invertenti). Serie di n-MOS = AND, parallelo = OR; i p-MOS (chiusi con ingresso basso) fanno l'opposto. Escursione completa, nessun consumo statico, ritardo da R e C di uscita. Dimensionamento: si parte dall'inverter di riferimento (Z_n = 1, Z_p = r ≈ 2,4) e si scala ogni transistor del numero di transistor della serie peggiore a cui appartiene, così che la resistenza nel caso peggiore uguagli quella dell'inverter (NAND2: Z_n = 2, Z_p = r; NOR2: Z_n = 1, Z_p = 2r). Per un obiettivo R_pd = R*: Z_n = m R_n0/R* con m transistor in serie nel cammino peggiore. Per minimizzare la capacità di uscita si collegano all'uscita meno drain possibile.Porte logiche CMOS - struttura statica complementare e dimensionamento → · Porte logiche CMOS - ritardo di Elmore, fan-in e consumoIl ritardo di una porta dipende dalla configurazione degli ingressi: si calcola il caso peggiore (un solo cammino conduttivo, il più resistivo) e il caso migliore. Per una rete RC con transistor in serie si usa il ritardo di Elmore: t = 0,69 Σ_k C_k · R_k, con R_k la resistenza totale tra il nodo k e il generatore (massa o V_DD) lungo il cammino e C_k la capacità del nodo. Per NAND2 con R_n = R_p: t_pLH (caso peggiore) = 0,69 R_p C, t_pHL = 0,69·2R_n C, quindi t_pHL = 2 t_pLH; per NOR2 è l'opposto. Una NOR a N ingressi (tutti i transistor uguali, nodi interni trascurati): t_pLH = 0,69 R_p C N(N+1), t_pHL = 0,69 R_n C (N+1): il ritardo cresce col quadrato del fan-in, perciò si evitano fan-in maggiori di 4. Rimedi: dimensionamento progressivo (transistor più grandi dal lato opposto all'uscita), riordino degli ingressi (il più tardivo vicino all'uscita), cascata di porte con meno ingressi, buffer. La potenza dinamica dipende dalla probabilità di commutazione.Porte logiche CMOS - ritardo di Elmore, fan-in e consumo → · Processo di fabbricazione CMOS, layout e parassitiUn circuito integrato CMOS si realizza su un wafer di silicio con una sequenza di passi fotolitografici: ogni maschera ottica riporta la geometria planare di uno strato (layer) e permette di sviluppare in modo selettivo il fotoresist, che protegge le zone non da attaccare o da drogare. Ordine: regioni attive e trincee di isolamento (STI), impianto delle well, deposizione e sagomatura del polisilicio (gate), impianto di source/drain (n+ e p+, il polisilicio si droga insieme), contatti e via, piste metalliche. Il progettista descrive il circuito con il layout (una maschera per layer) nel rispetto delle regole di layout (spessore, spaziatura, sovrapposizione), verificate dal DRC. Gli elementi parassiti sono resistenze (R = R_□·L/W), capacità (area più bordo, C = C_A·A + C_b·P) e transistor bipolari; le interconnessioni lunghe hanno ritardo ≈ 0,38 R C (rete distribuita). Il package deve avere basse parassite, robustezza, smaltimento del calore e costo basso.Processo di fabbricazione CMOS, layout e parassiti → · Logica pseudo-nMOS e logiche a caricoNella logica pseudo-nMOS (a rapporto, ratioed) la PUN della CMOS complementare è sostituita da un solo p-MOS con gate a massa, sempre acceso, che fa da carico per la PDN a n-MOS. Così servono N+1 transistor invece di 2N e la capacità di ingresso è minore, ma l'uscita bassa non è 0: V_OL si ricava uguagliando la corrente dell'n-MOS (zona lineare) a quella del p-MOS (saturazione), ed esiste potenza statica quando l'uscita è bassa (P = V_DD·I). V_OH = V_DD. Per V_OL piccola serve Z_n ≫ Z_p; il ritardo di salita è lento (carica solo il p-MOS debole: t_pLH = 0,69 R_p C_L), quello di discesa è più veloce (t_pHL ≈ 0,69 R_n C_L). Lo stesso schema (carichi p-MOS a massa) si ritrova nelle ROM a NOR.Logica pseudo-nMOS e logiche a carico → · Logica a pass-transistor e gate di trasmissioneNella logica a pass-transistor gli ingressi pilotano sia i gate sia i terminali di source/drain di una rete di interruttori (N transistor per N ingressi, nessun consumo statico, alcune funzioni, come AND, MUX e XOR, richiedono pochi transistor). Gli n-MOS trasmettono bene gli 0 ma male gli 1 (V_DD − V_Tn, con effetto body: circa 1,8 V da 2,5 V), i p-MOS al contrario (V_Tp in modulo per lo 0): il livello degradato non è rigenerato e può far condurre un inverter successivo (consumo statico). Il gate di trasmissione (n-MOS e p-MOS in parallelo, con G e nG complementari) trasmette bene entrambi i livelli, con resistenza R_n‖R_p quasi costante, ma costa due transistor e raddoppia le capacità. Una catena di n pass-transistor ha ritardo ∝ n² (Elmore, 0,69 R C n(n+1)/2): si inseriscono buffer ogni m = 1,7√(t_buf/(R_eq C)) stadi.Logica a pass-transistor e gate di trasmissione → · Logiche dinamiche - precarica e valutazioneNelle logiche dinamiche l'uscita non è sempre collegata a V_DD o a massa: il valore è conservato come carica su un nodo capacitivo in alta impedenza. Una porta dinamica ha un p-MOS di precarica e un n-MOS di valutazione pilotati dal clock e una sola rete di pull-down (N + 2 transistor): con Clk = 0 l'uscita è precaricata a V_DD, con Clk = 1 la PDN la scarica se conduce. Vantaggi: escursione piena (V_OL = 0), nessun consumo statico, nessun contrasto, capacità di ingresso ridotta, commutazioni più veloci; svantaggi: gli ingressi devono essere stabili in valutazione, la carica si perde per perdite (serve un refresh minimo di clock), la condivisione di carica con i nodi interni può abbassare l'uscita, e le porte non sono direttamente cascabili (si risolve con la logica domino, inverter in uscita, solo funzioni non invertenti).Logiche dinamiche - precarica e valutazione →

• Porta complementare: PDN (n-MOS) e PUN (p-MOS) duali (serie $\leftrightarrow$ parallelo), $F=\overline f$, $2N$ transistor, nessun cammino $V_{DD}$-massa. Dimensionamento: $Z_n=m\,Z_{ref}$ con $m$ = transistor del cammino serie peggiore (NAND2: $Z_n=2$, $Z_p=r$; NOR2: $Z_n=1$, $Z_p=2r$); con $R_{PD}=R^*$: $Z_n=\frac{mR_{n0}}{R^*}$.
• Elmore: $t_p=0{,}69\sum_kC_kR_k^{path}$; $N$ n-MOS in serie $t_{pHL}=0{,}69R_n(C_1+2C_2+\dots+NC_L)$. NAND2 ($R_n=R_p$): $t_{pHL}=2t_{pLH}$ (caso peggiore); NOR2 il contrario. Fan-in $N$ (nodi interni trascurati): NOR $t_{pLH}=0{,}69R_pC\,N(N+1)$, $t_{pHL}=0{,}69R_nC\,(N+1)$ (NAND scambiato): quadratico, evitare fan-in $>4$.

• Processo: $R=R_\square\frac LW$, $C=C_AA+C_bP$; linea distribuita $t_p\approx0{,}38\,RC$; $Z=\frac WL$ dalle dimensioni del layout.
• Pseudo-nMOS ($N+1$ transistor, p-MOS con gate a massa sempre acceso): $V_{OH}=V_{DD}$, $V_{OL}\approx\frac{|k'_p|Z_p(V_{DD}-|V_{Tp}|)^2}{2k'_nZ_n(V_{DD}-V_{Tn})}$, potenza statica $V_{DD}I$ a uscita bassa, $t_{pLH}=0{,}69R_pC_L$ lento.
• Pass-transistor: n-MOS trasmette bene lo 0 e l'1 degradato $V_{DD}-V_{Tn}$ (con effetto body); p-MOS il contrario; gate di trasmissione n$\parallel$p trasmette entrambi. Catena di $n$: $t_p=0{,}69R_{eq}C\frac{n(n+1)}2\propto n^2$; buffer ogni $m_{opt}\approx1{,}7\sqrt{\frac{t_{buf}}{R_{eq}C}}$.
• Dinamica: $N+2$ transistor, $Clk=0$ precarica $F=V_{DD}$, $Clk=1$ valutazione; charge sharing $V_{out}=V_{DD}\frac{C_L}{C_L+C_a}$; non cascabili senza inverter (logica domino).

Elementi di memoria

Note: Latch, registri e parametri temporaliUn circuito sequenziale ha uno stato memorizzato in due modi: retroazione positiva (due inverter in anello, bistabile, i latch statici) o immagazzinamento di carica (circuiti dinamici). Un latch è sensibile al livello del clock (trasparente quando il clock è attivo, memorizza quando non lo è), un registro (flip-flop) è sensibile al fronte e si realizza con due latch sulle fasi opposte (master-slave). Il latch SR a porte NOR/NAND non ammette la combinazione S = R = 1 perché passando da lì alla memoria lo stato finale è imprevedibile. Parametri temporali del registro: ritardo clock-uscita t_c-q, tempo di setup t_su (dato stabile prima del fronte), tempo di hold t_hold (dato stabile dopo il fronte). Periodo minimo: T_min = t_c-q + t_p,logic(max) + t_su; vincolo di hold: t_cd,reg + t_cd,logic > t_hold. La pipeline spezza la logica con registri per aumentare la frequenza (a spese della latenza).Latch, registri e parametri temporali → · Registri dinamici, C2MOS, TSPC e registri a scorrimentoI registri dinamici memorizzano il bit come carica su un nodo capacitivo in alta impedenza: meno transistor e commutazioni più rapide dei registri statici, ma il dato si perde (serve un clock minimo) e il master-slave con gate di trasmissione è sensibile alla sovrapposizione dei clock (race). Il registro C2MOS (clocked CMOS) usa inverter con transistor di clock in serie: è insensibile alla sovrapposizione dei clock (0-0 e 1-1) se i fronti sono ripidi, perché durante la sovrapposizione ciascuno stadio può solo caricare o solo scaricare il nodo, mai propagare. Il TSPC usa una sola fase di clock (nessun clock invertito) e permette di inglobare logica nei latch. Un registro a scorrimento è una cascata di registri D: a ogni fronte il dato avanza di una posizione (conversione serie-parallelo, ritardi, FIFO); il collegamento diretto richiede t_c-q > t_hold.Registri dinamici, C2MOS, TSPC e registri a scorrimento → · Memorie a semiconduttore - struttura a matrice, decoder e ROMLe memorie a semiconduttore si classificano in lettura/scrittura (SRAM, DRAM: volatili) e sola lettura (ROM a maschera, PROM, EPROM, EEPROM, Flash: non volatili); l'accesso è casuale o non casuale (FIFO, registri a scorrimento, CAM). La struttura è a matrice di celle: una word line (WL) seleziona una riga attraverso il decoder di riga (N indirizzi → 2^N WL), una bit line (BL) porta il dato alla colonna scelta dal decoder/multiplexer di colonna e dal sense amplifier. La ROM a NOR ha per ogni bit line un p-MOS di carico e n-MOS dove il bit è 0 (con WL alta tirano la BL a massa): compatta e veloce; la ROM a NAND ha serie di n-MOS ed è molto più piccola ma più lenta. Ritardo di una WL: R del polisilicio × C dei gate (Elmore); di una BL: C dei drain con la R dei transistor o del carico.Memorie a semiconduttore - struttura a matrice, decoder e ROM → · Memorie non volatili - gate flottante, EPROM, EEPROM e FlashLe memorie non volatili conservano il dato senza alimentazione. La PROM a fusibili (o antifusibili) si programma una volta interrompendo (o creando) un collegamento. Le memorie riprogrammabili usano il transistor a gate flottante: un gate di polisilicio isolato tra il canale e il gate di controllo; la carica (elettroni) intrappolata sul gate flottante aumenta la soglia vista dal gate di controllo, così il transistor programmato resta spento a tutte le tensioni di lettura (V_T,prog > V_DD). EPROM: programmazione per iniezione di portatori caldi, cancellazione collettiva con raggi UV. EEPROM (transistor FLOTOX, effetto tunnel Fowler-Nordheim attraverso un ossido sottile): cancellazione elettrica della singola cella, ma due transistor per cella (area quasi doppia). Flash: variante dell'EEPROM con una sola cella-transistor e cancellazione a blocchi o settori, struttura NOR o NAND.Memorie non volatili - gate flottante, EPROM, EEPROM e Flash → · SRAM e DRAMSRAM e DRAM sono memorie volatili ad accesso casuale. La cella SRAM a 6 transistor è un latch di due inverter (M1-M4) con due n-MOS di accesso (M5, M6) pilotati dalla word line: uscita differenziale, veloce, grande. Lettura: BL e BL̄ precaricate, l'n-MOS driver abbassa leggermente il lato che memorizza 0 (il transistor driver deve essere più forte di quello di accesso, così il nodo non supera la soglia degli inverter); scrittura: una BL forzata a 0 porta il nodo sotto la soglia logica degli inverter in retroazione positiva, che poi si ribaltano. La DRAM a 1 transistor ha un n-MOS di accesso e una capacità di storage C_S: scrittura caricando C_S dalla BL (si perde V_T: bootstrap della WL), lettura per ridistribuzione di carica con la BL precaricata, ΔV = C_S/(C_BL + C_S)(V_X − V_PRE) ≈ 100-250 mV, distruttiva: servono sense amplifier per ogni BL e refresh periodico. Celle DRAM a 3 transistor: lettura non distruttiva.SRAM e DRAM →

• Latch positivo: $Q=CLK\cdot D+\overline{CLK}\cdot Q$; registro = due latch opposti (master-slave). Latch SR: $S\,R=00$ memoria, $01\to0$, $10\to1$, $11$ proibito.
• Parametri: $t_{c\text{-}q}$, $t_{su}$ (stabile prima del fronte), $t_{hold}$ (stabile dopo). Frequenza: $T_{min}\ge t_{c\text{-}q}+t_{p,logic}^{max}+t_{su}$, $f_{max}=\frac1{T_{min}}$. Hold: $t_{cd,reg}+t_{cd,logic}>t_{hold}$ (non dipende da $T$). Pipeline: frequenza maggiore, latenza maggiore.
• Registri dinamici: carica su nodo in alta impedenza; C$^2$MOS insensibile alla sovrapposizione dei clock, TSPC con una sola fase; shift register: il dato avanza di una posizione per fronte.
• Matrice: $N$ indirizzi di riga $\to2^N$ WL; ROM NOR (veloce, $V_{OL}$ pseudo-nMOS) e NAND (compatta, lenta, WL non selezionate alte). Gate flottante: $\Delta V_T=-\frac{Q_{FG}}{C_{cg}}$; EPROM cancellata con UV, EEPROM per cella (Fowler-Nordheim), Flash a blocchi.
• SRAM 6T: lettura con driver più forte dell'accesso, scrittura con accesso più forte del pull-up. DRAM 1T: lettura per ridistribuzione di carica $\Delta V=\frac{C_S}{C_{BL}+C_S}(V_{X,W}-V_{PRE})$, distruttiva, con refresh.

Blocchi funzionali dei sistemi digitali

Note: Blocchi logici di un microprocessore - ALU, bus e logica tri-stateUn microprocessore semplice è formato da un'unità di controllo (decodifica le istruzioni e abilita gli altri blocchi), una ALU (operazioni aritmetiche e logiche), la memoria e i registri, collegati da bus (linee condivise unidirezionali o bidirezionali). La ALU combina un sommatore con un'unità logica e un multiplexer di selezione dell'operazione: la sottrazione è A + B̄ + 1 (XOR su B e riporto in ingresso a 1), le flag (zero, riporto, segno, overflow) descrivono il risultato. Un bus è una linea pilotata da più sorgenti: per evitare conflitti ogni uscita collegata è tri-state (il segnale enable la mette in alta impedenza) oppure open-drain (solo PDN: ciascuna può imporre 0, serve un pull-up per l'1).Blocchi logici di un microprocessore - ALU, bus e logica tri-state → · Sommatori - full adder e ripple-carryLa somma di due bit con riporto in ingresso è realizzata dal full adder: S = A ⊕ B ⊕ C_in, C_out = AB + BC_in + AC_in. Con generate G = AB, propagate P = A ⊕ B (e delete D = Ā B̄) si scrive C_out = G + P·C_in e S = P ⊕ C_in: G e P non dipendono dal riporto in ingresso (fase di set-up), solo C_out ed S ne dipendono. Il sommatore ripple-carry collega N full adder in cascata: il riporto attraversa gli stadi uno dopo l'altro, nel caso peggiore t_add = (N−1) t_carry + t_sum (lineare in N). Il ritardo effettivo dipende dagli operandi: un generate o un delete azzera la catena, un propagate la prolunga; per operandi uguali bit a bit vale t_carry + t_sum.Sommatori - full adder e ripple-carry → · Sommatori veloci - carry-bypass, carry-select e square-rootIl ripple-carry ha ritardo lineare in N. Il carry-bypass divide i bit in blocchi da M: se tutti i propagate del blocco valgono 1 (BP = P0P1…P_{M−1} = 1) un multiplexer fa saltare il riporto dall'ingresso all'uscita del blocco. Ritardo: t = t_setup + M t_carry + (N/M − 1) t_mux + (M−1) t_carry + t_sum, ottimo per M = √(N t_mux/(2 t_carry)); è determinato principalmente dal tempo di riporto. Il carry-select calcola in ogni blocco le somme per riporto 0 e per riporto 1 e un mux sceglie quella giusta: t = t_setup + M t_carry + (N/M) t_mux + t_sum, M ottimo √(N t_mux/t_carry); lo square-root carry-select usa blocchi di dimensione crescente (M, M+1, M+2…) perché il riporto arriva ogni volta un mux dopo: N ≈ K²/2 e t = t_setup + M t_carry + √(2N) t_mux + t_sum, cioè ritardo ∝ √N.Sommatori veloci - carry-bypass, carry-select e square-root → · Traslatori, comparatori e moltiplicatoriOltre ai sommatori, la ALU contiene traslatori (shifter), comparatori e moltiplicatori. Lo shift a sinistra di k posizioni moltiplica per 2^k; lo shift a destra aritmetico (con replica del bit di segno) divide per 2^k nel complemento a due; il barrel shifter realizza qualsiasi traslazione fino a N − 1 posizioni con log₂N livelli di multiplexer 2→1. Il comparatore di uguaglianza è l'AND delle XNOR bit a bit; quello di grandezza confronta partendo dal bit più significativo (GT = g_{N−1} + e_{N−1}(g_{N−2} + e_{N−2}(…))) oppure usa la sottrazione e le flag. Il moltiplicatore a matrice (array) forma N² prodotti parziali con porte AND e li somma con N(N−1) full adder; il ritardo cresce come 2N t_carry; moltiplicatori ad albero (Wallace) e sequenziali (shift-and-add) sono alternative; le FPGA hanno blocchi DSP dedicati.Traslatori, comparatori e moltiplicatori →

• Full adder: $S=A\oplus B\oplus C_{in}$, $C_{out}=AB+BC_{in}+AC_{in}$; con $G=AB$, $P=A\oplus B$, $D=\overline A\,\overline B$: $C_{out}=G+P\,C_{in}$, $S=P\oplus C_{in}$. Ripple-carry: $t_{add}=(N-1)t_c+t_s$ (lineare).
• Carry-bypass (blocchi da $M$): $t=t_{setup}+(2M-1)t_{carry}+\big(\frac NM-1\big)t_{mux}+t_{sum}$, $M_{opt}=\sqrt{\frac{N\,t_{mux}}{2\,t_{carry}}}$. Linear carry-select: $t=t_{setup}+Mt_{carry}+\frac NMt_{mux}+t_{sum}$, $M_{opt}=\sqrt{\frac{N\,t_{mux}}{t_{carry}}}$. Square-root select (blocchi $M,M+1,\dots$): $N=MK+\frac{K(K-1)}2\approx\frac{K^2}2$, $t\approx t_{setup}+Mt_{carry}+\sqrt{2N}\,t_{mux}+t_{sum}\propto\sqrt N$.

• ALU: sottrazione $A+\overline B+1$; flag Z, C, N, V con $V=C_{N-1}\oplus C_N$. Bus: tri-state con $en$ (uscita $Z$), open-drain con pull-up.
• Shift a sinistra di $k$: $\times2^k$; ASR replica il segno; barrel shifter: $\log_2N$ livelli di mux $2\to1$. Comparatore: $EQ=\prod e_i$, $GT=g_{N-1}+e_{N-1}\big(g_{N-2}+e_{N-2}(\dots)\big)$. Moltiplicatore a matrice: $N^2$ AND, $N(N-1)$ full adder, prodotto a $2N$ bit.

Circuiti logici programmabili e FPGA

Note: Dispositivi logici programmabili - PROM, PLA, PAL e CPLDUn componente logico programmabile (PLD) è un circuito integrato a catalogo la cui funzione logica viene fissata da una programmazione che altera la struttura del circuito (non va confusa con la programmazione software di un microprocessore). I meccanismi sono fusibili, antifusibili (una volta), EPROM/EEPROM/Flash (reversibili e non volatili) e celle SRAM (reversibili ma volatili). Le architetture semplici (SPLD) sono due piani AND-OR: PROM (AND fisso, cioè un decoder di tutti i mintermini, OR programmabile), PLA (entrambi programmabili, dimensione indipendente dal numero di ingressi, più lenta) e PAL (AND programmabile, OR fisso, più veloce). I CPLD sono matrici di blocchi SPLD con interconnessioni programmabili, le FPGA hanno molti blocchi logici piccoli (LUT + registro) in una griglia di interconnessioni complessa, configurata da SRAM.Dispositivi logici programmabili - PROM, PLA, PAL e CPLD → · FPGA - LUT, slice e risorse della famiglia 7Una FPGA è una matrice di blocchi logici configurabili (CLB) immersi in una griglia di interconnessioni programmabili, con risorse dedicate: block RAM, blocchi DSP, gestione del clock (MMCM, PLL), blocchi di I/O e transceiver. La memoria di configurazione è SRAM. L'elemento base è la LUT: una memoria SRAM con 2^k celle che realizza una qualsiasi funzione di k ingressi (i segnali di selezione del multiplexer sono gli ingressi della funzione). Nella famiglia 7 di Xilinx un CLB ha 2 slice; uno slice ha 4 LUT a 6 ingressi (ciascuna divisibile in due LUT a 5), multiplexer larghi F7/F8 (funzioni a 7-8 ingressi), una catena di riporto veloce, 4 flip-flop/latch più 4 flip-flop. Nei SLICEM la LUT può essere usata come RAM distribuita o registro a scorrimento (SRL32), nei SLICEL solo come logica.FPGA - LUT, slice e risorse della famiglia 7 →

• LUT a $k$ ingressi: $2^k$ celle SRAM + mux $2^k\to1$, qualsiasi funzione di $k$ variabili, ritardo costante ($y=ab+\overline c$: contenuto $10101011$).
• Famiglia 7: CLB = 2 slice; slice = 4 LUT6 (o 8 LUT5), mux F7/F8, catena di riporto, 4+4 flip-flop; SLICEM: LUT come RAM distribuita o SRL32; SLICEL: solo logica. Block RAM 36 kb, DSP $25\times18$.

VHDL e progetto su FPGA

Note: VHDL - struttura, tipi di dato e processiVHDL è un linguaggio di descrizione dell'hardware: un listato non è una sequenza di istruzioni eseguite da un processore ma la descrizione di un circuito, che la sintesi traduce in uno schema (LUT, flip-flop, multiplexer). Ogni modulo ha una entity (interfaccia: port con modo in, out, inout e tipo; eventuali generic) e una architecture (parte dichiarativa: segnali, costanti, componenti; parte assertiva dopo begin: assegnazioni concorrenti e processi). Le istruzioni nell'architecture sono concorrenti: l'ordine in cui sono scritte non conta. Un process esegue le proprie istruzioni in modo sequenziale quando un segnale della lista di sensibilità cambia. Segnali (<=, aggiornati alla fine del delta cycle, definiti nella parte dichiarativa) e variabili (:=, immediate, solo dentro il processo) hanno semantica diversa. Tipi: bit, boolean, integer, std_logic (a 9 valori, tra cui 'Z', 'X', 'U'), std_logic_vector, unsigned e signed (numeric_std).VHDL - struttura, tipi di dato e processi → · VHDL - logica combinatoriaUna logica combinatoria in VHDL si descrive con assegnazioni concorrenti (semplici, condizionate when-else con priorità, selezionate with-select senza priorità) o con processi sensibili a tutti gli ingressi (if/elsif, case). Nel processo ogni uscita va assegnata in tutti i rami e la lista di sensibilità deve contenere tutti i segnali letti: altrimenti la sintesi inferisce un latch (memoria). L'aritmetica si fa con unsigned/signed di numeric_std (to_unsigned, to_integer, resize, conversioni di tipo) e con un bit in più per il riporto. Cicli for e istruzioni generate creano hardware replicato (non cicli nel tempo). La descrizione strutturale istanzia componenti con component e port map (per posizione o per nome, anche con generic map), e permette di costruire sistemi gerarchici.VHDL - logica combinatoria → · VHDL - logica sequenziale e registriIn VHDL la logica sequenziale si descrive con processi sensibili al clock. Un registro D (flip-flop sul fronte) si scrive process(clk) con if rising_edge(clk); un latch è un processo sensibile al livello (if clk='1' then q<=d) senza altri rami. Il reset è sincrono se testato dentro rising_edge(clk) (la lista di sensibilità contiene solo clk), asincrono se testato prima, con RST nella lista di sensibilità (if rst='1' then ... elsif rising_edge(clk)). Registri a n bit con generic, registri a scorrimento (con load), contatori (up/down, con enable) si ottengono con la stessa struttura. In un progetto sincrono tutti i registri usano lo stesso clock (nessun clock generato da logica: si usano abilitazioni), i segnali esterni asincroni come i pulsanti si campionano con uno o più flip-flop (debouncing) e le cifre di un display si multiplexano con un contatore.VHDL - logica sequenziale e registri → · Macchine a stati finiti in VHDLUna macchina a stati finiti (FSM) ha uno stato S(k) che evolve secondo la funzione di stato prossimo S(k+1) = F(S(k), X(k)) e produce uscite Y(k) = G(S(k), X(k)) (modello di Mealy: dipendono anche dall'ingresso, possono cambiare subito) oppure Y(k) = G(S(k)) (modello di Moore: dipendono solo dallo stato, cambiano solo ai fronti di clock). In VHDL si definisce un tipo enumerato per gli stati e si scrive in due processi: uno sequenziale (registro di stato con reset: state_reg <= state_next al fronte) e uno combinatorio (case sullo stato che assegna state_next, con un valore di default, e le uscite); lo stile a processo singolo registra anche le uscite. La progettazione parte dal diagramma degli stati, passa alla tabella di transizione e al codice.Macchine a stati finiti in VHDL → · Simulazione, testbench, vincoli di temporizzazione e flusso su FPGAUn progetto VHDL si verifica per simulazione con un testbench: una entity senza porte che istanzia il circuito sotto test (UUT), genera il clock (process con wait for e inversione), applica gli stimoli e controlla le uscite con assert/report/severity (note, warning, error, failure) o leggendo vettori da file (textio). Il flusso su FPGA è: descrizione VHDL, simulazione funzionale, sintesi (rete di LUT e flip-flop), implementazione (piazzamento e instradamento), analisi di temporizzazione, generazione del bitstream e programmazione della scheda. I vincoli (file XDC) assegnano i pin e definiscono il clock (periodo); l'analisi di temporizzazione verifica per ogni cammino registro-registro lo slack di setup, T − (t_c-q + t_logica + t_routing + t_su), e di hold; con slack negativo la frequenza è troppo alta: f_max = 1/(T − WNS).Simulazione, testbench, vincoli di temporizzazione e flusso su FPGA →

• Latch inferito: nel processo combinatorio ogni uscita va assegnata in tutti i rami e la sensibilità deve essere completa. for e generate replicano hardware.
• FSM: $S(k+1)=F(S(k),X(k))$; Moore $Y=G(S)$ (cambia al fronte), Mealy $Y=G(S,X)$ (cambia con l'ingresso). Due processi: registro di stato e logica di stato prossimo con default state_next <= state_reg;.

process (RST, CLK)                         -- registro di stato
begin
  if RST = '1' then state_reg <= idle;
  elsif rising_edge(CLK) then state_reg <= state_next;
  end if;
end process;
process (state_reg, START)                 -- stato prossimo e uscite
begin
  state_next <= state_reg;
  case state_reg is
    when idle     => CHECK <= '0'; if START = '1' then state_next <= counting; end if;
    when counting => CHECK <= '1'; if START = '0' then state_next <= idle; end if;
  end case;
end process;

• Temporizzazione su FPGA: slack di setup $=T-(t_{c\text{-}q}+t_{logica}+t_{routing}-t_{skew}+t_{su})$; hold $=t_{c\text{-}q}+t_{cd}+t_{routing}-t_{skew}-t_{hold}$ (indipendente da $T$); $f_{max}=\frac1{T-WNS}$ con WNSworst negative slack, lo slack peggiore tra tutti i cammini. Vincolo di clock: create_clock -period 10 per 100 MHz.