Formulario - elettronica industriale

Aritmetica (Numeri binari e complemento a dueI processori lavorano con un numero fisso di bit $n$. I naturali vanno da $0$ a $2^n-1$; per i negativi si usa il complemento a due: $C_2(N)=2^n-N=\overline N+1$ (si invertono tutti i bit e si somma 1). Con $n$ bit rappresenta $-2^{n-1}\le N\le2^{n-1}-1$, ha un solo zero e unifica somma e sottrazione. Quando il risultato esce dall'intervallo c'è overflow; gli overflow intermedi si compensano se il risultato finale è rappresentabile. La lunghezza di parola non è l'accuratezza.Numeri binari e complemento a due →, Virgola fissa - formati n.m e normalizzazioneIn virgola fissa il processore fa aritmetica sugli interi (con segno) e il fattore di scalacostante per cui si moltiplica un valore reale per ottenere l'intero memorizzato $2^{m}$ resta sottinteso: il formato n.m dice che dei bit disponibili $n$ sono la parte intera (compreso il segno se il numero è con segno, S; nessun segno se U) e $m$ la parte frazionaria. Il valore è $\text{codice}/2^m$. Passare dal formato n.m al decimale, o viceversa, è il calcolo più frequente dell'esame: su 16 bit $\text{valore}=\text{codice}/2^m$, l'intervallo è $[0,2^n)$ (U) oppure $[-2^{n-1},2^{n-1})$ (S), la risoluzione è $2^{-m}$.Virgola fissa - formati n.m e normalizzazione →)

• Complemento a 2codifica dei numeri con segno su n bit su $n$ bit: $C_2(N)=2^n-N=\mathrm{NEG}(N)+1$; intervallo $[-2^{n-1},\,2^{n-1}-1]$; $A-B=A+\mathrm{NEG}(B)+1$.
• Formato $n.m$ su $W=n+m$ bit: $x=C/2^m$; U: $[0,2^n)$; S: $[-2^{n-1},2^{n-1})$ (il segno è in $n$); risoluzione $2^{-m}$; errore massimo $2^{-(m+1)}$; $\varepsilon=C/2^m-x$ (+ se eccesso). Q15 = 1.15 S.
• Scelta del formato (Rappresentare un valore reale in virgola fissa - formato ottimo ed errorePer rappresentare un reale $x$ su $W$ bit a virgola fissa si sceglie il formato che minimizza l'erroresceglie la rappresentazione per cui la differenza tra il valore rappresentato e quello vero è la più piccola possibile: il maggior numero di bit frazionari $m$ compatibile con l'intervallo ($n=W-m$ bit interi, con U se $x\ge0$, con S se $x<0$). Poi $C=\mathrm{round}(x\cdot2^m)$, scritto in esadecimale (per un negativo, in complemento a 2), e l'errore $\varepsilon=\frac{C}{2^m}-x$, positivo se in eccesso, ha modulo $\le2^{-(m+1)}$. Se invece è dato l'errore massimo, i bit minimi si ricavano da $2^{-(m+1)}\le\varepsilon_{max}$.Rappresentare un valore reale in virgola fissa - formato ottimo ed errore →): U se $x\ge0$, S se $x<0$; $n$ minimo per contenere $x$; $m=W-n$; $C=\mathrm{round}(x2^m)$, negativo: $C+2^W$.
• Prodotto: $m=m_1+m_2$; shift a destra di $m_1+m_2-m$; 1.15 × 1.15 = 2.30 (shift sinistra di 1 per 1.31) (Operazioni in virgola fissa - somma, prodotto e riallineamentoIn virgola fissa il processore opera sugli interi e non sa dov'è la virgola: tocca al programmatore. Regola 1: si sommano solo dati con lo stesso formato (stesso $m$). Regola 2: il prodotto di $n_1.m_1$ per $n_2.m_2$ ha $m_1+m_2$ bit frazionari e il doppio dei bit: va riallineato con uno shift a destra di $m_2$ posizioni (per riportarlo a $m_1$) o preso dalla parte alta. Con la normalizzazione frazionaria $1.15$ il prodotto è $2.30$ e basta uno shift a sinistra di 1 prima di prendere la parte alta. I fattori di scala si scelgono per evitare overflow e perdita di risoluzione.Operazioni in virgola fissa - somma, prodotto e riallineamento →).
• Virgola mobile 16 bit (1+4+11, $B=7$): $x=(-1)^S(1+F)2^{E-7}$; zero = parola nulla; somma: allineare l'esponente minore (Virgola mobile - formato IEEE 754 e formato a 16 bitIn virgola mobile un numero è $(-1)^S,(1+F),2^{E-B}$: segno $S$, mantissa frazionaria $F$ (con l'$1$ iniziale implicito) ed esponente $E$ con offset $B$. La precisione relativa è costante ($\varepsilon=2^{-n_F}$) e cambia la spaziatura tra i valori; in $n$ bit si rappresentano gli stessi $2^n$ numeri della virgola fissa, ma distribuiti diversamente. Nello standard IEEE 754 a 32 bit: 1 bit di segno, 8 di esponente ($B=127$), 23 di mantissa. All'esame compare un formato a 16 bit (1+4+11, $B=7$): codifica, decodifica e somma con allineamento degli esponenti. Il campo esponente tutto a 0 con mantissa nulla è lo zero.Virgola mobile - formato IEEE 754 e formato a 16 bit →).
• Overflowrisultato fuori dall'intervallo rappresentabile: $V=C_{in,n-1}\oplus C_{out,n-1}$; carry look-ahead: $g_i=A_iB_i$, $p_i=A_i+B_i$, $C_{i+1}=g_i+p_iC_i$; ripple 8 bit 17 τ, CLA 6 τ (ALU - sommatore, overflow, carry look-ahead e shiftL'ALU è un insieme di celle a 1 bit (full adder + selettori) collegate in parallelo: somma, sottrae ($A-B=A+\overline B+1$: si inverte $B$ e si porta il riporto iniziale a 1), fa AND/OR. Il ritardo è dominato dal riporto: nel ripple-carry cresce linearmente con i bit; col carry look-aheadtecnica che calcola in anticipo i riporti da generazione e propagazione, riducendo il ritardo i riporti si calcolano da generazione $g_i=A_iB_i$ e propagazione $p_i=A_i+B_i$ in pochi livelli di logica. L'overflow è $V=C_{in,n-1}\oplus C_{out,n-1}$. Gli shift logici inseriscono 0, gli aritmetici estendono il segno; il barrel shiftercircuito che sposta una parola di un numero qualsiasi di posizioni in un solo ciclo sposta di $m$ posti in un ciclo.ALU - sommatore, overflow, carry look-ahead e shift →).
• Boothalgoritmo di moltiplicazione per numeri con segno basato sulla lettura a coppie dei bit del moltiplicatore: coppia $Q_0q_{-1}$: 10 → $A-M$, 01 → $A+M$, shift aritmetico a ogni passo (Moltiplicazione e algoritmo di BoothLa moltiplicazione hardware imita il calcolo a mano: somme e shift ripetuti. Per numeri senza segno si somma il moltiplicando se il bit del moltiplicatore è 1 e si fa shift a destra del prodotto parziale; il moltiplicatore sta nella metà bassa del registro del prodotto. Per i numeri con segno serve l'algoritmo di Booth: si guardano i bit del moltiplicatore a coppie (bit corrente, bit precedente, all'inizio 0): 10 → si sottrae il moltiplicando, 01 → si somma, 00/11 → niente; poi shift aritmeticoscorrimento che conserva il segno: a destra ripete il bit di segno a destra. Dopo $n$ passi si hanno $2n$ bit in complemento a 2. Va eseguito sui compiti d'esame a mano con lo schema di registri $A,|,Q,|,q_{-1}$.Moltiplicazione e algoritmo di Booth →).
• Divisione: $D=Q\,d+R$, quoziente verso zero; con serie $Q\approx N\prod(1+Z^{2^k})$, errore $Z^{2^n}$ (Moltiplicatori veloci e divisionePer il controllo real-time serve un moltiplicatore a ciclo singolo: a look-up table (la tabella cresce come $2^{2n}\cdot2n$ bit, quindi si fa solo a pochi bit e si compongono prodotti da 4 bit: $A\cdot B=A_HB_H,2^{8}+(A_HB_L+A_LB_H)2^4+A_LB_L$) oppure a matrice (schiera di AND e sommatori, ritardo $\sim2n$; varianti a somma per colonne e di Wallace). La divisione hardware si fa con sottrazioni successive (con ripristino) su valori positivi e il segno alla fine ($D=Q,d+R$); con $n$ bit ci sono vincoli su dividendo e divisore. Senza divisore hardware: $Q=N/D$ con la serie $\frac{N(1+Z)(1+Z^2)\cdots}{1-Z^{2^n}}$, $D=1-Z$, $0{,}5<D<1$.Moltiplicatori veloci e divisione →).

Architettura, pipeline e memorie

• $T_{cal}=T_{clk}\sum N_iNC_i$ (Misura delle prestazioni - tempo di calcolo e indici MIPSLe prestazioni di un processore si misurano col tempo di calcolo di un programma: $T_{cal}=T_{clk}\sum_{i}N_i,NC_i$ (periodo di clock per numero di istruzioni di classe $i$ per cicli medi della classe). Aumentare la velocità vuol dire ridurre $T_{clk}$, i cicli per istruzione (organizzazione) o il numero di istruzioni (architettura). Gli indici MIPS, DMIPS, FLOPS misurano solo un picco e non permettono di confrontare famiglie diverse: si usa il benchmarking (kernel benchmarking per i DSP).Misura delle prestazioni - tempo di calcolo e indici MIPS →); $NC_{medio}=\sum f_iNC_i$ (Unità di controllo - cablata, microprogrammata, singolo ciclo e multicicloL'unità di controllo preleva (fetch), decodifica ed esegue le istruzioni generando i segnali che attivano registri, ALU e memoria. Può essere cablata (logica dedicata, veloce, poco flessibile, oggi la norma) o microprogrammata (una piccola CPU con ROM di microcodice: flessibile ma lenta e grande). Con un solo bus le operazioni vanno distribuite su più segmenti di clock (multiciclo: il clock è dettato dall'unità più lenta); con memorie e ALU separate si può fare singolo ciclo (il clock è dettato dall'istruzione più lenta). Il tempo medio per istruzione dipende dal mix di istruzioni: $NC=\sum f_i,NC_i$.Unità di controllo - cablata, microprogrammata, singolo ciclo e multiciclo →).
• Pipeline: $N$ istruzioni in $(n+N-1)T_{clk}$; $S=\frac{Nn}{n+N-1}\le n$ (Pipeline - accelerazione e conflittiLa pipeline divide l'esecuzione in $n$ stadi (fetch, decodifica, lettura, esecuzione, scrittura) che lavorano contemporaneamente su istruzioni diverse. Il clock è dettato dallo stadio più lento; a regime si completa un'istruzione per ciclo. Per $N$ istruzioni servono $(n+N-1),T_{clk}$: l'accelerazione rispetto al multiciclo tende a $n$ ma è sempre minore (riempimento, conflitti). I conflitti sono strutturali (stessa risorsa), sui dati (RAW...) e di controllo (salti): si risolvono con stalli (interlocking), bypass, sovrapposizione, riordino, salti ritardati. La latenza di una singola istruzione non diminuisce.Pipeline - accelerazione e conflitti →).
• Wait-stateciclo di attesa inserito quando la memoria è più lenta del processore: $T_A<(N+N_w)T_{clk}$; memoria $=L\cdot W/8$ byte; cache $S=\frac{t_{acc}}{ht_c+(1-h)t_{acc}}$ (Memorie esterne e cache - wait state e speed-upUna memoria con tempo di accesso $T_A$ è accessibile in $N$ cicli di clock se $T_A<N,T_{clk}$; altrimenti servono $N_w$ cicli di attesa (wait-state) con $T_A<(N+N_w)T_{clk}$. Un wait-state costa molto (+100% se $N=1$): spesso conviene abbassare il clock. La cache è una memoria piccola e veloce con le informazioni più richieste: se l'hit ratio è $h$, lo speed-up è $S=\dfrac{t_{acc}}{h,t_c+(1-h),t_{acc}}$ (massimo $t_{acc}/t_c$ per $h=1$, tipico $h\approx0{,}95$). Organizzazioni: a mappatura diretta (TAG, linea, word; la più semplice), associativaorganizzazione in cui ogni linea può stare in qualunque posizione della cache (qualunque linea ovunque, costosa), parzialmente associativa (più cache dirette in parallelo). Nei DSP la cache è spesso solo per le istruzioni.Memorie esterne e cache - wait state e speed-up →, Memorie - gerarchia, SRAM, DRAM, ROM e FLASHNei µC e DSP si usa solo memoria a stato solido ad accesso immediato, interna (on chip) o esterna. Parametri: dimensione, velocità (tempo di accesso, latenza, banda), consumo, integrazione. La memoria è gerarchica (registri → cache → SRAM interna → esterna) grazie alla localitàtendenza dei programmi a riusare gli stessi dati e a usare dati vicini in memoria spaziale e temporale. Tipi: SRAM (veloce, 4-6 transistori per cella, volatile, nessun refresh), DRAM (carica in un MOS, serve il refresh, più densa e a minor consumo), ROM/OTP/EPROM/EEPROM e FLASH (gate flottante: scrittura per elettroni caldi, cancellazione per effetto tunnel, solo per blocchi, $>10^5$ cicli). Una "RAM" è qualunque memoria con tempo di accesso indipendente dalla posizione.Memorie - gerarchia, SRAM, DRAM, ROM e FLASH →).

Interruzioni (Sistemi di interruzioni - latenza, nesting e sostenibilitàCon $N$ sorgenti, ciascuna ISR $i$ ha durata $T_{d,i}$ (spesso già comprensiva della latenza intrinseca $T_{LI}$ e dell'istruzione in corso) e periodo minimo $T_{p,i}$. Condizione necessaria: $\sum_iT_{d,i}/T_{p,i}<1$ (la percentuale di impegno della CPU è la somma). Condizione di intervallo per ogni $i$ (priorità 1 = massima): $T_{d,i}+\sum_{k<i}n_k,T_{d,k};[+\max(T_{RC},\max_{j>i}T_{d,j})\text{ senza nesting}]\le T_{p,i}$, con $n_k=\lceil T_{p,i}/T_{p,k}\rceil$. Latenza massima della priorità $n$: con nesting $T_{LI}+\sum_{i<n}T_{ex,i}$; senza nesting si aggiunge $\max_{j>n}T_{ex,j}$.Sistemi di interruzioni - latenza, nesting e sostenibilità →)

• Utilizzo: $\sum T_{d,i}/T_{p,i}<1$.
• Condizione di intervallo (priorità 1 = massima): $T_{d,i}+\sum_{k<i}\lceil T_{p,i}/T_{p,k}\rceil T_{d,k}\;[+\max(T_{RC},\max_{j>i}T_{d,j})]\le T_{p,i}$; l'ultimo termine solo senza nesting.
• Latenza: con nestingannidamento delle interruzioni: una ISR di priorità maggiore interrompe una di priorità minore $T_{LI}+\sum_{i<n}T_{ex,i}$; senza $+\max_{j>n}T_{ex,j}$.

Convertitori (Campionamento, aliasing e sample and holdCampionare vuol dire prendere i valori di $s(t)$ a istanti $kT_c$ ($T_c$ periodo, $f_c=1/T_c$). Teorema di Shannon: se lo spettro è nullo sopra $BW$, $s(t)$ si ricostruisce esattamente da campioni con $f_c\ge2BW$. Lo spettro campionato è la replica periodica (ogni $f_c$) dello spettro originale; se $f_c<2BW$ le repliche si sovrappongono: aliasing (una sinusoide a $f$ campionata a $1{,}25f$ appare a $0{,}25f$). Si previene con un filtro anti-aliasing sotto $f_c/2$ e col sovracampionamento. Il sample and holdcircuito che campiona il segnale e lo mantiene costante durante la conversione tiene il segnale costante durante la conversione.Campionamento, aliasing e sample and hold →, ADC e DAC - risoluzione, SNR, ENOB ed erroriUn convertitore a $n$ bit con fondo scala $FSR$ ha risoluzione $LSB=FSR/2^n$; il codice vale $C=\mathrm{round}(V/LSB)$ e la tensione corrispondente è $V=C\cdot LSB$ con incertezza $\pm\frac12LSB$ (errore di quantizzazione). Con un modello a rumore uniforme di potenza $LSB^2/12$ il SNR di una sinusoide a fondo scala è $6{,}02,n+1{,}76$ dB; dal SNR misurato si ricava il numero di bit efficaci $ENOB=\frac{SNR-1{,}76}{6{,}02}$. Gli errori reali (offset, guadagno, INL, DNL, missing code) abbassano l'accuratezza. Accuratezza ≠ precisione: alta accuratezza implica alta precisione, non viceversa.ADC e DAC - risoluzione, SNR, ENOB ed errori →, Architetture di ADC e DACADC flash: $2^n-1$ comparatori in parallelo, il più veloce (GS/s) ma costoso, $n<10$. A gradinata/a rampa: contatore + DAC (o rampa) + comparatore, $T_{conv}\le2^n$ cicli di clock (lentissimo). SAR: ricerca binaria con DAC e comparatore, $T_{conv}=(n+1)$ cicli: il più usato nei µC. Sigma-delta: ADC a 1 bit + DAC a 1 bit in retroazione e filtro digitale, sovracampionamento (molti bit, banda ridotta). Multistadio/pipeline: più ADC a pochi bit in serie; la pipeline triplica (con 3 stadi) la frequenza di conversione. DAC: a resistenze pesate, a traliccio R-2R ($V_o=-V_{ref},C/2^n$, corrente costante), a voltage scaling (monotono), seriale.Architetture di ADC e DAC →)

• Shannon $f_c\ge2BW$; $LSB=FSR/2^n$; $C=\mathrm{round}(V/LSB)$; $SNR=6{,}02n+1{,}76$ dB; $ENOB=\frac{SNR-1{,}76}{6{,}02}$.
• SAR: $T=(n+1)/F_{clk}$; $f_{Nyq}=f_c/2$; gradinata/rampa: $\le2^n$ cicli; flash: $2^n-1$ comparatori; pipeline 3×4 bit: $f_c=F_{clk}/5$. DAC R-2R: $V_o=-V_{ref}C/2^n$.

Filtri e regolatori (Filtri numerici IIR e FIRUn filtro numerico è una equazione alle differenzerelazione che dà il campione di uscita in funzione di campioni di ingresso e di uscita passati $y(k)=\sum_ib_ix(k-i)+\sum_ia_iy(k-i)$. IIR (ricorsivo: qualche $a_i\ne0$) ha risposta impulsiva infinita e bastano pochi termini; FIR (tutti $a_i=0$) è sempre stabile ma richiede molti termini. Il passa-basso IIR del primo ordine $y(k)=b,x(k)+a,y(k-1)$ con $a+b=1$ ha guadagno 1 ed è stabile se $|a|<1$; la risposta al gradino è $y(k)=1-a^{k+1}$. Il filtro analogico equivalente (Eulero) ha $\tau=\dfrac{a,T_c}{1-a}$ e $f_T=\dfrac1{2\pi\tau}$. La media mobile di $N$ campioni è un FIR passa-basso che si assesta in $N$ passi.Filtri numerici IIR e FIR →, Discretizzazione di Eulero e TustinPer realizzare numericamente un filtro o regolatore $F(s)$ si approssima $\frac1s$ con un integratore a tempo discreto. Eulero: $\boxed{s=\dfrac{1-z^{-1}}{T_c}}$ (da $\mathrm{Int}(nT)=\mathrm{Int}((n-1)T)+T,x(n)$). Così $\dfrac{1+s\tau_z}{1+s\tau_p}$ diventa $y(k)=\dfrac{\tau_p}{T_c+\tau_p}y(k-1)+\dfrac{T_c+\tau_z}{T_c+\tau_p}x(k)-\dfrac{\tau_z}{T_c+\tau_p}x(k-1)$. Il passaggio inverso (da algoritmo a $F(s)$) usa $z^{-1}\approx1-sT_c$. L'approssimazione è affidabile solo fino a circa $f_c/10$ (distorsione, warping); Tustin $s=\frac2{T_c}\frac{1-z^{-1}}{1+z^{-1}}$ è più fedele.Discretizzazione di Eulero e Tustin →, Regolatori PI e PID digitaliIl PI digitale è $y(k)=k_p,e(k)+y_I(k)$ con $y_I(k)=k_I',e(k)+y_I(k-1)$ e $k_I'=k_iT_c$ (con una MAC bastano 3 cicli). Nel PID la derivata si calcola come $\frac{k_d}{T_c}[e(k)-e(k-1)]$ ed è sensibile al rumore: si usa la versione filtrata $y_d(k)=\frac{k_d}{T_c+\tau_L}[e(k)-e(k-1)]+\frac{\tau_L}{T_c+\tau_L}y_d(k-1)$ o una media su più campioni. Con la saturazione dell'attuatore serve l'anti-wind-up: $|y_I|\le L(k)=Y_{max}-|k_pe(k)|$. Il controllo dead-beatcontrollo che porta l'errore a zero in un numero finito di passi (predittivo) azzera l'errore in un numero finito di passi ma è poco usato in industria.Regolatori PI e PID digitali →)

• PB IIR: $y=a\,y(k-1)+b\,x(k)$; gradino $\frac b{1-a}(1-a^{k+1})$; guadagno $\frac b{1-a}$; $\tau=\frac{a}{1-a}T_c$; $f_T=\frac1{2\pi\tau}$; $N\ge\frac{\ln(1-p)}{\ln a}$.
• Eulerometodo di discretizzazione che sostituisce s con (1 meno z alla meno 1) diviso il periodo di campionamento $s=\frac{1-z^{-1}}{T_c}$; $\frac{1+s\tau_z}{1+s\tau_p}$: $a=\frac{\tau_p}{T_c+\tau_p}$, $b_0=\frac{T_c+\tau_z}{T_c+\tau_p}$, $b_1=-\frac{\tau_z}{T_c+\tau_p}$; passa-alto $\frac{\tau_z}{T_c+\tau_p}\Delta x$; PI $\frac{1+s\tau_z}{s\tau_p}$: $y=y_{k-1}+\frac{T_c+\tau_z}{\tau_p}x_k-\frac{\tau_z}{\tau_p}x_{k-1}$. Inverso: $\tau_p=\frac{a_1T_c}{1-a_1}$, $\tau_z=-\frac{b_1T_c}{b_0+b_1}$.
• PI: $y=k_pe+y_I$, $y_I=k_I'e+y_{I,k-1}$, $k_I'=k_iT_c$; anti-wind-uplimitazione della parte integrale per evitare la sovraelongazione quando l'attuatore è saturo $|y_I|\le Y_{max}-|k_pe|$.
• Realizzazione (Realizzare un filtro o un regolatore a virgola fissaRealizzare in C un filtro a virgola fissa vuol dire scegliere per ogni dato il formato (coefficienti $<1$ in 0.16 U, coefficienti $>1$ in 1.15, 4.12, 5.11 S...), moltiplicare con aritmetica a 32 bit ($16\times16\to32$) e riportare il prodotto al formato di arrivo con uno shift a destrascorrimento dei bit verso destra: equivale a dividere per una potenza di 2; per sommare due prodotti con scale diverse si fa lo shift prima di sommare. Con $a+b=2^{16}$ il filtro $y=\big(a,y_{k-1}+b,(u\ll4)\big)\gg16$ non va in overflow in un uint32_t. Nel codice il formato di ogni variabile va dichiarato in un commento; la funzione $\sin x\approx x-\frac{x^3}6+\frac{x^5}{120}$ mostra come si approssima una funzione con polinomi a coefficienti in virgola fissa.Realizzare un filtro o un regolatore a virgola fissa →, Quantizzazione, fattori di scala e cicli limiteUn algoritmo di filtro o regolatore pensato per un processore ideale va adattato alla realtà: temporizzazionedistribuzione nel tempo delle operazioni di un algoritmo (l'algoritmo nella ISR dell'ADC, durata minore di $T_c$), acquisizione (condizionamento del segnale per sfruttare tutto il fondo scala dell'ADC), fattori di scala (normalizzazione intera o 1.15; evitare overflow), quantizzazione di ingresso, uscita, coefficienti e prodotti (sposta i poli, genera errori a regime e cicli limite). Una frequenza di campionamento troppo alta rende più critica la quantizzazione dei coefficienti: va scelta coerente con la lunghezza di parola.Quantizzazione, fattori di scala e cicli limite →): coefficienti $<1$ in 0.16 U; (a*yo+b*(u<<4))>>16.

Timer, PWM, PLL (Timer - prescaler, compare, capture e watchdogUn timer è un contatore binario di periodi di clock: $f_{cont}=f_{clk}/PSC$ ($PSC$ = fattore del prescaler). In modalità compare/match genera un evento (interruzione, reset del conteggio, azione su un pin) quando il conteggio raggiunge il registro di match: per un evento ogni $T$ servono $N=T,f_{clk}/PSC\le2^{16}$ conteggi, e si prende il minimo $PSC$ (massima risoluzione). Con uscita in modo toggle la frequenza dell'onda quadra è metà di quella degli eventi, il duty-cycle 50%. In modalità capture il valore del contatore, salvato a due fronti, dà il periodo: $T=C_2-C_1$ (corretto anche con un overflow), risoluzione $1/f_{clk}$. Il watchdog reinizializza il sistema se non viene azzerato in tempo.Timer - prescaler, compare, capture e watchdog →, Modulazione PWM - duty-cycle, risoluzione e demodulazioneLa PWM trasferisce un segnale modulante $V^$ nella larghezza degli impulsi di un'onda quadra a frequenza fissa: con duty-cycle $d=t_1/T$ e livelli $\pm\frac E2$ la media è $V_{med}=(d-\frac12)E=E,\frac{V^}{V_p}$. L'informazione sta nel valor medio; il resto dello spettro (armoniche della portante) si elimina con un passa-basso (demodulazione). Il modulatore digitale è un timer: contatore + comparatore, $N=f_{clk}/f_{PWM}$ conteggi per periodo, risoluzione $n=\log_2N$ bit (massima frequenza per $n$ bit: $f_{clk}/2^n$), registro di compare = duty-cycle. Servono almeno 8 bit per evitare cicli limite.Modulazione PWM - duty-cycle, risoluzione e demodulazione →, PWM e ADC - ritardo di risposta e sincronizzazioneUn modulatore PWM digitale ritarda la risposta: il duty-cycle si aggiorna una volta per periodo (al massimo si attende $T_{PWM}$; $T_{PWM}/2$ se si aggiorna a ogni semiperiodo). Perciò il controllo digitale deve avere banda ben sotto $f_{PWM}$ (cross-over $\lesssim f_{PWM}/10$, margine di fase $\ge60^\circ$). Si campiona di solito a $f_c=f_{PWM}$: viola Shannon, ma se l'ADC è sincronizzato con la portante (trigger dal timer PWM) l'aliasing estrae il valor medio, senza ripple. Il campionamento va fatto a metà del tempo di ON (leading edge: $\frac{DT}2$, in generale a metà dell'impulso) o al picco/valle del contatore (PWM simmetrica).PWM e ADC - ritardo di risposta e sincronizzazione →, PLL digitale con i timerUn PLL (anello ad aggancio di fase) tiene un segnale generato a frequenza e fase in relazione costante con un riferimento. In un µC si realizza con un timer in capture (misura il periodo del riferimento) e uno in compare (genera gli impulsi). L'errore di fase $\Delta\phi$ (intervallo tra due eventi) va portato a 0 con un regolatore sul periodo $P$ degli impulsi: compensare solo l'errore istantaneo non basta, serve un PI: $P_{int}(k)=P_{int}(k-1)+\frac{\Delta\phi(k)}N$, $P(k+1)=P_{int}(k)+\frac{\Delta\phi(k)}N$ (con $N$ = rapporto delle frequenze), che è dead-beat (errore nullo in un passo, polo in $z=0$). In pratica si riducono i guadagni per robustezza.PLL digitale con i timer →)

• Timer: $N_{tot}=Tf_{clk}$, $PSC=\lceil N_{tot}/2^{16}\rceil$, match $N_{tot}/PSC$; togglemodalità in cui l'uscita cambia livello a ogni evento: $f_{out}=f_{eventi}/2$; capturemodalità in cui il timer salva il conteggio quando arriva un evento esterno $T=C_2-C_1$, $f_{clk}\ge f_{max}/\varepsilon$, $\le2^{16}f_{min}$.
• PWM: $N=f_{clk}/f_{PWM}$, bit $\log_2N$, $f_{PWM,max}=f_{clk}/2^n$; $V_{med}=(d-\frac12)E$ o $dV_{DD}$; attenuazione 1° ordine $\sqrt{1+(\omega/\omega_p)^2}$; ritardo ≤ $T_{PWM}$; campionare a $DN/2$ (leading edgemodulazione PWM con fronte di salita all'inizio del periodo).
• PLL dead-beatcontrollo che annulla l'errore in un numero finito di passi: $P_{int}=P_{int}+\frac{\Delta\phi}N$, $P=P_{int}+\frac{\Delta\phi}N$.

Comunicazione e codice (Comunicazione seriale - UART, RS232, RS422 e RS485La trasmissione serialeche trasmette i bit uno dopo l'altro su una sola linea invia un bit alla volta su pochi fili. Asincrona (UART): senza clock comune, ogni dato è inquadrato da 1 bit di start, 5-8 bit di dati, parità opzionale e 1-2 bit di stop; per 8 bit di dati servono 10 bit sulla linea (efficienza 80%); tempo di bit $BT=1/bps$; il ricevitore campiona a $1{,}5,BT,2{,}5,BT,\dots$ dal fronte di start e tollera uno scostamento di frequenza di circa $\pm5{,}3%$ (o $4{,}6%$ con campionamento a 16×). Sincrona: il trasmettitore invia anche il clock (e il frame sync), efficienza 100%. Livelli fisici: RS232 ($\pm12$ V, 1 = $-12$ V), RS422/RS485 (differenziale, doppino, 10 Mbit/s su $<15$ m; RS485 multi-trasmettitore), loop di corrente 0-20 mA.Comunicazione seriale - UART, RS232, RS422 e RS485 →, Bus I2C, SPI e CANI2C: bus seriale sincrono a 2 fili (SDA dati, SCL clock, con resistenze di pull-up), un master (il µC) e molti slave con indirizzo a 7 bit; byte da 9 bit (8 + ACK dato dal ricevitore abbassando SDA); start: SDA scende con SCL alto; stop: SDA sale con SCL alto; 100 kbit/s (normale), 400 kbit/s (fast); half-duplex. SPISerial Peripheral Interface: bus seriale sincrono a quattro fili: 4 fili (MOSI, MISO, SCK, CS), full duplex, master e slave selezionati da CS, 4 modi (CPOL, CPHA). CAN: bus differenziale (120 Ω) asincrono, messaggi etichettati da un identificatore (11 o 29 bit), arbitraggio automatico (vince l'ID più basso), bit stuffing dopo 5 bit uguali, CRC a 15 bit, contatori di errori (127, 255).Bus I2C, SPI e CAN →, Comunicazione wireless - ASK, OOK, FSK, PLL e antenneMolti µC integrano un trasmettitore RF semplice: PLL che genera la portante a $N$ volte la frequenza di un quarzo, amplificatore (LNA) e antenna con rete di adattamento. Modulazioni digitali: ASK (due livelli di ampiezza), OOK (un livello è zero), FSK (due frequenze). In analogico si usa l'FM con VCO e PLL (CD4046). Il PLL è un anello di retroazione: comparatore di fase, filtro passa-basso, VCO ($k_{VCO}=\frac{f_{max}-f_{min}}{V_{max}-V_{min}}$), divisore per $N$; a regime errore nullo di frequenza e di fase. Antenne a microstriscia: loop (lunghezza $\lesssim\lambda/10$), patch ($f_r\simeq\frac c{2L\sqrt{\varepsilon_r}}$). Standard: Wi-Fi 802.11, Bluetooth 802.15.1, ZigBee 802.15.4 (2,4 GHz, 250 kbit/s, rete mesh, basso consumo).Comunicazione wireless - ASK, OOK, FSK, PLL e antenne →, Microcontrollori STM32 - clock, timer, ADC e codice HALI µC STM32 (core ARM Cortex-M) del corso si configurano con la libreria HAL: si riempiono strutture C (...InitTypeDef) con valori simbolici e si chiamano funzioni di libreria. Clock (STM32F334R8): oscillatore esterno HSE 8 MHz × PLL (MUL9) = SYSCLK 72 MHz (massimo); AHB ÷1, APB1 ÷2 (36 MHz), APB2 ÷1 (72 MHz); clock dell'ADC = clock del bus ÷ divisore (÷6 → 12 MHz). Timer in PWM: $f=f{clk}/((PSC+1)(Period+1))$, Pulse = duty $\times$ conteggi. Toggle: onda quadra a metà della frequenza di match. ADC: SAR a 12 bit, conversioni injected avviate da un trigger del timer, lettura con interruzione.Microcontrollori STM32 - clock, timer, ADC e codice HAL →, Linguaggio C per i microcontrollori - puntatori, tipi e operatoriNei µC a 32 bit (ARM) un char è 1 byte, short 2, int e long 4, i puntatori 4 (sizeof(pa)=4). x++ restituisce il valore prima dell'incremento, ++x dopo; (p++) legge e poi sposta il puntatore di sizeof(p) byte. Una macro senza parentesi interne si espande come testo (#define square(x) (xx): 64/square(4) = 64/(44) = 4). Il prodotto di due uint16_t è un int a 32 bit con segno: per un uint16_t*uint16_t grande serve il cast a uint32_t prima del prodotto. Divisione intera e resto: $-13/4=-3$, $-13%4=-1$. Per i registri periferici: volatile.Linguaggio C per i microcontrollori - puntatori, tipi e operatori →)

• UART: 10 bit per byte (8 dati), $BT=1/bps$, clock a $16\,bps$, tolleranza 5,3% (4,6%); I2C: 9 bit per byte, 100/400 kbit/s; CAN: ID minore vince, stuffing dopo 5 bit, errori 127/255.
• STM32F334: HSE 8 MHz × 9 = 72 MHz; APB1 36 MHz; APB2 72 MHz; ADC 12 MHz con ÷6; PWM: Period $=N-1$, Pulse $=DN$.
• C (32 bit): sizeof(puntatore)=4; i++ valore prima; macro = testo; / e % verso zero.