{"id":597,"date":"2017-02-02T20:29:36","date_gmt":"2017-02-02T19:29:36","guid":{"rendered":"http:\/\/www.gtronic.it\/test\/?page_id=597"},"modified":"2017-02-27T18:13:39","modified_gmt":"2017-02-27T17:13:39","slug":"concetti-base-e-glossario","status":"publish","type":"page","link":"https:\/\/www.gtronic.it\/test\/index.php\/concetti-base-e-glossario\/","title":{"rendered":"Concetti base e glossario"},"content":{"rendered":"

VHDL: Concetto di entity.<\/strong><\/p>\n

Un entity \u00e8 un\u2019astrazione di un dispositivo che pu\u00f2\u00a0rappresentare un sistema completo, una scheda, un chip, una funzione o una porta logica. Una dichiarazione di entity descrive l\u2019I\/O di un progetto e pu\u00f2 includere anche parametri utilizzati per customizzare l\u2019entity stessa.
\nUn\u2019architettura descrive le funzioni di un\u2019entity. Un\u2019architettura pu\u00f2 contenere qualunque combinazione dei seguenti tipi di descrizione:
\n\u2022Behavioural;
\n\u2022Structural;
\n\u2022Dataflow.<\/p>\n

Nell’immagine un esempio di listato che mostra\u00a0l’implementazione di un behavioral.<\/p>\n

\"listato<\/p>\n

Viene chiamata descrizione comportamentale per il modo algoritmico in cui viene descritta l\u2019architettura. La descrizione comportamentale viene indicata, a volte, come descrizione ad alto livello a causa dell\u2019assomiglianza con i linguaggi di programmazione ad alto livello. Piuttosto che specificare la struttura o la netlist di un circuito, \u00e8 possibile specificare un insieme di istruzioni che, quando eseguite in sequenza, descrivono il funzionamento, o il comportamento, dell\u2019entit\u00e0, o di parte di essa. Il vantaggio di una descrizione ad alto livello \u00e8 che non \u00e8 necessario focalizzarsi sull\u2019implementazione a livello di gate.<\/p>\n

Il listato riportato sotto \u00e8 un esempio di descrizione di tipo dataflow di un comparatore a quattro bit.<\/p>\n

\"dataflow\"<\/p>\n

Questa \u00e8 un\u2019architettura di tipo dataflow perch\u00e9 specifica come i dati vengono trasferiti da segnale a segnale e da ingresso a uscita senza ricorrere all\u2019utilizzo di istruzioni sequenziali. La differenza principale con la descrizione di tipo behavioral \u00e8 che una utilizza i processi e l\u2019altra no. Per\u00f2 entrambe le descrizioni non sono di tipo strutturale. Conviene utilizzare le descrizioni di tipo dataflow nel caso in cui \u00e8 possibile scrivere semplici equazioni, istruzioni di assegnamento condizionato (WHEN-ELSE), o istruzioni di assegnamento selettivo (WITH-SELECT-WHEN), piuttosto che algoritmi completi. D\u2019altra parte, quando \u00e8 necessario utilizzare strutture annidate, sono preferibili le istruzioni sequenziali.<\/p>\n

Descrizione strutturale.<\/strong><\/p>\n

nel listato sottostante\u00a0c’\u00e8 la descrizione strutturale di un comparatore a 4 bit.<\/p>\n

\"structural\"<\/p>\n

La descrizione strutturale consiste di una netlist VHDL. Questa netlist \u00e8 molto simile alla netlist di uno schematico: I componenti sono elencati e connessi insieme mediante segnali. I progetti strutturali sono di tipo gerarchico. Nella figura (1) \u00e8 riportato lo schematico del comparatore a quattro bit descritto nel listato precedente.<\/p>\n

\"netlist\"<\/p>\n

Dichiarazione di Entity <\/span><\/p>\n

Una dichiarazione di entity descrive gli ingressi e le uscite del progetto. Pu\u00f2 anche descrivere parametri costanti. La dichiarazione di entity \u00e8 analoga al simbolo di uno schematico che descrive le connessioni di un componente con il resto del progetto. <\/span><\/p>\n

La struttura ho questo incapsulamento. \u00e8 messa in evidenza la relazione tra un progetto, la dichiarazione di entit\u00e0 e l’architeture body.<\/p>\n

\"entity\"entity<\/p>\n

\"simbolo<\/p>\n

Porte <\/span><\/p>\n

Ogni segnale di I\/O in una dichiarazione di entity \u00e8 chiamato <\/span>porta, <\/strong><\/span>ed \u00e8 analogo ad un pin nel simbolo di uno schematico. Ad una porta possono essere assegnati valori o essere usata all\u2019interno delle espressioni. L\u2019insieme delle porte definite in una entity \u00e8 chiamato dichiarazione delle porte. Ogni porta che viene dichiarata deve avere un nome, una direzione (<\/span>modo<\/strong><\/span>) e un data type.<\/span>MODI<\/strong><\/span>: i modi descrivono la direzione in cui un dato \u00e8 trasferito attraverso la porta. Il modo pu\u00f2 assumere uno dei quattro valori: IN, OUT, INOUT e BUFFER. Se il modo non viene specificato allora la porta di default \u00e8 in modo IN.L\u2019utilizzo dei modi \u00e8 il seguente: <\/span><\/p>\n

\u2022<\/span>IN<\/strong><\/span>. I dati fluiscono solo dentro l\u2019entit\u00e0. Il driver per una portadi modo IN \u00e8 al di fuori dell\u2019entit\u00e0. Il modo IN viene utilizzato principalmente per gli ingressi di clock, gli ingressi di controllo (come load, reset e enable) e per gli ingressi unidirezionali dei dati. <\/span><\/p>\n

\u2022<\/span>OUT<\/strong><\/span>. I dati fluiscono solo verso le porte di uscita dell\u2019entit\u00e0. Ildriver per una porta di modo OUT \u00e8 contenuto all\u2019interno dell\u2019entit\u00e0. Il modo OUT non permette la retroazione perch\u00e9 tale porta non \u00e8 considerata leggibile dall\u2019interno dell\u2019entit\u00e0. Il modo OUT \u00e8 utilizzato per le uscite.<\/span><\/p>\n

\u2022<\/span>BUFFER<\/strong><\/span>. Per utilizzare internamente la retroazione (cio\u00e8 per utilizzare una porta come driver all\u2019interno dell\u2019architettura), \u00e8 necessario dichiarare la porta in modalit\u00e0 BUFFER, o dichiarare un segnale separato da utilizzare all\u2019interno dell\u2019architettura come segnale interno. Una porta che viene dichiarata in modalit\u00e0 BUFFER \u00e8 simile ad una porta che \u00e8 dichiarata come OUT, eccetto che permette di effettuare internamente una retroazione. La modalit\u00e0 BUFFER non consente ad una porta di essere bidirezionale perch\u00e9 non consente alla porta di essere pilotata dall\u2019esterno dell\u2019entit\u00e0. Vanno fatte due considerazioni addizionali sull\u2019utilizzo della modalit\u00e0 BUFFER: (1) una porta in modalit\u00e0 BUFFER non consente di essere pilotata da pi\u00f9 driver; (2) una porta in modalit\u00e0 BUFFER pu\u00f2 essere connessa solo ad un segnale interno o ad un\u2019altra porta di modalit\u00e0 BUFFER di un\u2019altra entit\u00e0. Non pu\u00f2 essere connessa a nessun altra porta in nodalit\u00e0OUT o INOUT di un\u2019altra entit\u00e0, eccetto che passando attraverso un segnale interno. La modalit\u00e0 BUFFER \u00e8 utilizzata per porte che devono essere leggibili all\u2019interno dell\u2019entit\u00e0. <\/span><\/p>\n

\u2022<\/span>INOUT<\/strong><\/span>. Per segnali bidirezionali \u00e8 necessario dichiarare le porte di modo INOUT, questa modalit\u00e0 permette ai dati di fluire dentro o fuori dall\u2019entit\u00e0. In altre parole, il driver del segnale pu\u00f2 essere all\u2019interno o all\u2019esterno dell\u2019entit\u00e0. Ilmodo INOUT permette anche le retroazioni interne. Il modo INOUT \u00e8 in grado di sostituire tutti gli altri modi. Cio\u00e8, IN, OUT e BUFFER possono essere sostituiti dal modo INOUT (questa opzione \u00e8 sconsigliabile in quanto riduce molto la leggibilit\u00e0 del codice del progetto).<\/span><\/p>\n

\"Buffer\"<\/p>\n

modalit\u00e0 delle porte e le loro possibilit\u00e0 di collegamento con l\u2019interno e l\u2019esterno dell\u2019entit\u00e0.<\/p>\n

Tipi\u00a0associati alle porte.<\/strong><\/p>\n

Oltre a specificare i nomi e i modi delle porte \u00e8 necessario anche dichiarare il tipo delle porte. I tipi pi\u00f9 utili e meglio supportati per la sintesi forniti dal package IEEE std_logic_1164 sono i tipi STD_LOGIC e gli array derivati da questi. Come implica il nome, <\/span>standard logic<\/span><\/i>v uole essere un tipo standard utilizzato per descrivere i circuiti. La dichiarazione dei tipi deve essere resa visibile all\u2019entit\u00e0 per mezzo delle istruzioni LIBRARY e USE, come riportato del listato sotto:<\/span><\/p>\n

\"definizione<\/p>\n

Il VHDL \u00e8 un linguaggio fortemente tipizzato, cio\u00e8 i dati di differenti tipi base non possono essere assegnati gli uni agli altri senza utilizzare una funzione di conversione di tipo. Di seguito \u00e8 riportata una descrizione di alcuni dei tipi che pi\u00f9 comunemente si possono incontrare.<\/span><\/p>\n

Tipi scalari<\/strong><\/span>. I tipi scalari possiedono un ordine che permette l\u2019applicazione di operatori relazionali tra loro. Ci sono tre principali categorie di operatori scalari: enumerativi, interi, floating.<\/span><\/p>\n

Tipi enumerativi<\/strong><\/span>. Un tipo enumerativo \u00e8 una lista di valori che un oggetto di un dato tipo pu\u00f2 assumere. E\u2019 possibile definire la lista dei valori. I tipi enumerativi sono utilizzati spesso per definire lo stato delle macchine sequenziali:<\/span><\/p>\n

TYPE states IS (idle, preamble, data, jam, nofsd, error);<\/span><\/em><\/p>\n

Un segnale pu\u00f2 essere definito del tipo enumerativo appena dichiarato:<\/span><\/p>\n

SIGNAL current_state: states;<\/span><\/em><\/p>\n

Come tipo scalare, il tipo enumerativo \u00e8 ordinato. L\u2019ordine in cui i valori sono elencati nella dichiarazione del tipo, definiscono la loro relazione. Il valore a sinistra \u00e8 il pi\u00f9 piccolo di tutti gli altri valori. Ogni valore \u00e8 pi\u00f9 grande di quello a sinistra e pi\u00f9 piccolo di quello a destra. <\/span><\/p>\n

Ci sono altri due tipi enumerativi, predefiniti dallo standard IEEE 1076, che sono particolarmente utili per la sintesi: BIT e BOOLEAN. Essi sono definiti come segue: <\/span><\/p>\n

TYPE boolean IS (FALSE, TRUE); <\/span><\/em><\/p>\n

TYPE bit IS (\u20180\u2019,\u20191\u2019);<\/em> <\/span><\/p>\n

Lo standard IEEE 1164 definisce un tipo addizionale e diversi sottotipi che sono utilizzati consistentemente come standard sia per la simulazione che per la sintesi. Il tipo STD_LOGIC \u00e8 definito come segue: <\/span><\/p>\n

TYPE std_logicIS ( \u2018U\u2019, –Uninitialized
\n\u2018X\u2019, –Forcing Unknown
\n\u20180\u2019, –Forcing 0
\n\u20181\u2019, –Forcing 1
\n\u2018Z\u2019, –High impedance
\n\u2018W\u2019, –Weak Unknown
\n\u2018L\u2019, –Weak 0
\n\u2018H\u2019, –Weak 1
\n\u2018-\u2019, –Don\u2019tcare );<\/p>\n

I valori \u20180\u2019, \u20191\u2019, \u2018L\u2019 e \u2018H\u2019 sono valori logici che sono supportati dalla sintesi. I valori \u2018Z\u2019 e \u2018-\u2019 sono anch\u2019essi supportati dalla sintesi per i driver three state e per i valori don\u2019t care. I valori \u2018U\u2019, \u2018X\u2019 e \u2018W\u2019 non sono supportati dalla sintesi.<\/span>
\nNella maggior parte dei progetti viene utilizzato il tipo STD_LOGIC. E\u2019 pi\u00f9 versatile del tipo BIT perch\u00e9 fornisce il valore di alta impedenza \u2018Z\u2019 e il valore don\u2019t care \u2018-\u2019. Lo standard IEEE 1164 definisce array di STD_LOGIC come STD_LOGIC_VECTOR.
\nUna nota finale sul tipo STD_LOGIC: sebbene gli identificatori non sono case-sensitive, l\u2019interpretazione dei valori letterali come \u2018Z\u2019 e \u2018L\u2019 \u00e8 case-sensitive. Questo significa che \u2018z\u2019 non \u00e8 equivalente a \u2018Z\u2019.
\n\u2022Tipi interi.<\/strong> Nel VHDL sono predefiniti gli interi e gli operatori relazionali ed aritmetici sugli interi. Gli strumenti software che processano il VHDL devono supportare gli interi nel range da \u20132.147.483.647, -(231-1) a 2.147.483.647, (231-1). Un segnale o una variabile che \u00e8 di tipo intero e che deve essere sintetizzata nel circuitologico deve essere limitata in valore cio\u00e8:
\nVARIABLE a: INTEGER RANGE \u2013255 TO 255;<\/em>
\nNon tutti i sistemi di sintesi per logiche programmabili sono ingrado di trattare valori con segno.<\/span><\/p>\n

\u2022Tipo floating<\/strong>. I valori del tipo floating sono utilizzati per approssimare i numeri reali. Il solo tipo floating point predefinito e il REAL, che include al minimo il range tra \u20131.0E38 e +1.0E38. I tipi floating spesso non sono supportati dai programmi di sintesi (in particolare quelli per logiche programmabili) a causa della grande quantit\u00e0 di risorse richieste per l\u2019implementazione delle operazioni aritmetiche tra loro.
\nTipi composti<\/strong>. Ai tipi scalari pu\u00f2 essere assegnato solo un valore. I tipi composti possono invece assumere pi\u00f9 valori contemporaneamente. I tipi composti sono i tipi ARRAY e i tipi RECORD.
\n\u2022Tipi array<\/strong>. Un oggetto di tipo array consiste di elementi multipli dello stesso tipo. I tipi di array pi\u00f9 comunemente usati sono quelli predefiniti dagli standard IEEE 1076 e 1164:<\/p>\n

\"type\"<\/p>\n

Questi tipi sono comunemente utilizzati per indicare i bus.
\nQuando si utilizzano le stringhe di bit, \u00e8 possibile utilizzare una notazione opportuna per indicare se i bit delle stringhe sono specificati in binario, in ottale o in esadecimale. Se tuttavia la stringa \u00e8 specificata in binario pu\u00f2 essere assegnata solo ad un oggetto di tipo BIT_VECTOR e non ad un oggetto di tipo STD_LOGIC_VECTOR. Per i formati ottale ed esadecimale occorre trasformare la stringa binaria nel formato desiderato ad esempio:<\/p>\n

a <= X”7A”;<\/em><\/p>\n

Richiede che asia di 8 bit, dove a pu\u00f2 essere un BIT_VECTOR o uno STD_LOGIC_VECTOR il cui valore diventa \u201c01111010\u201d. La notazione per indicare le cifre esadecimali \u00e8 Xseguita dalla cifra esadecimale tra virgolette, per le ottalil\u2019indicatore \u00e8 Omentre per quelle binarie \u00e8 B.
\n\u2022Tipi record. Un oggetto di tipo record ha elementi multipli di tipi differenti. I singoli campi possono essere referenziati con il nome dell\u2019elemento, come nell\u2019esempio riportato sotto.<\/p>\n

\"typeiocell\"<\/p>\n

\"operatori\"<\/p>\n

Operatori Logici.<\/strong><\/p>\n

Gli operatori logici fondamentali in ambito booleano in VHDL sono i classici: AND,OR,NAND,XOR,XNOR,NOT<\/p>\n

In linea di massimo i compilatori li accettano sia se scritti in maiuscolo che in minuscolo. Sono operatori predefiniti per i tipi BIT e BOOLEAN o per i vettori di BIT o BOOLEAN. Lo standard IEEE 1164 estende questi operatori per il tipo STD_LOGIC e i suo vettore STD_LOGIC_VECTOR.
\nQuesti operatori non hanno un ordine di precedenza: sono richieste le parentesi<\/strong>.<\/p>\n

X <= (a OR b) AND c<\/p>\n

Se eliminiamo le parentesi la sintassi viene accettata ma la valutazione dell’espressione potrebbe risultare errata. Questo \u00e8 errato ->\u00a0 X <= a OR b AND c<\/p>\n

risulta valutata correttamente l’espressione:\u00a0 X <= a OR (b AND c)<\/p>\n

Si deve quindi prestare particolare attenzione.<\/p>\n

Operatori Relazionali.<\/strong><\/p>\n

Gli operatori relazionali sono utilizzati per testare l’uguaglianza, la disuguaglianza e l’ordinamento.<\/p>\n

=\u00a0\u00a0\u00a0\u00a0\u00a0\u00a0 Operatore di uguaglianza
\n\/=\u00a0\u00a0\u00a0\u00a0\u00a0 Operatore di disuguaglianza
\n<\u00a0\u00a0\u00a0\u00a0\u00a0\u00a0 Minore
\n>,>=\u00a0 Maggiore e maggiore uguale
\n<,<=\u00a0 Minore e minore uguale<\/strong><\/p>\n

Gli operatori = e \/= sono definiti per tutti i tipi di dati finora incontrati,
\nGli operatori >,>=, < e <= sono definiti per i tipi scalari o gli array con un range di valori discreto.
\nGli array sono uguali solo se le loro lunghezze sono equivalenti e tutti gli elementi corrispondenti sono uguali.
\nIl risultato degli operatori relazionali \u00e8 booleano (cio\u00e8, \u00e8 vero o falso).
\nI tipi di operandi in un\u2019operazione relazionale devono essere uguali.<\/p>\n

with – select -when<\/strong><\/p>\n

Sono\u00a0 <\/strong>operatori di assegnamento selettivo dei segnali.<\/p>\n

WITH selection_signal SELECT
\nsignal_name <= value_a WHEN value_1_of_selection_signal,
\nvalue_b WHEN value_2_of_selection_signal,
\nvalue_c WHEN value_3_of_selection_signal,
\nvalue_x WHEN ultimo_valore_della_selezione_signali;<\/p>\n

Al segnale signal_name viene assegnato un valore in base al valore corrente del segnale selection_signal. T utti i valori di selection_signal devono essere elencati nell\u2019istruzione WHEN e tali valori sono mutuamente esclusivi.<\/p>\n

\"esempio<\/p>\n

Mentre la condizione WHEN nell\u2019istruzione WITH-SELECT-WHEN deve specificare valori mutuamente esclusivi del segnale di selezione, la condizione WHEN in un\u2019istruzione WHEN-ELSE pu\u00f2 specificare qualunque semplice espressione.
\nSe le condizioni in un\u2019istruzione WHEN-ELSE non sono mutuamente esclusive, la priorit\u00e0 pi\u00f9 alta viene assegnata alla prima condizione WHEN elencata. Le priorit\u00e0 delle successive condizioni WHEN sono assegnate in base all\u2019ordine di apparizione.<\/p>\n

\"mux\"<\/p>\n

Nell’immagine la rete di selezione dei segnali w,x,y e z in base ai segnali mutuamente esclusivi a,b,c e d.<\/p>\n

\"mux<\/p>\n

Nell’immagine sopra la selezione dei segnali w,x,y e z in base ai segnali non mutuamente esclusivi a,b,c e d.<\/p>\n

IF – THEN – ELSE<\/strong><\/p>\n

L\u2019istruzione IF-THEN-ELSE \u00e8 utilizzata per selezionare un insieme di istruzioni da
\neseguire in base alla valutazione di una condizione o un\u2019insieme di condizioni.<\/p>\n

IF (condition) THEN
\ndo something;
\nELSE
\ndo something different;
\nEND IF;<\/p>\n

Se la condizione specificata viene trovata vera, vengono eseguite le istruzioni che
\nseguono la parola chiave THEN. Se la condizione viene trovata falsa, vengono eseguite
\nle istruzioni dopo ELSE. L\u2019insieme di istruzioni viene chiuso da END IF.
\nDato che le istruzioni sequenziali vengono eseguite nell\u2019ordine di apparizione, i seguenti
\nprocessi sono funzionalmente equivalenti<\/p>\n

\"12\"<\/p>\n

Con entrambi i processi, step assume il valore \u20181\u2019 se addr \u00e8 maggiore di 0F hex, e \u20180\u2019 se \u00e8 minore o uguale al valore indicato.<\/p>\n

il processo:<\/p>\n

\"process\"<\/p>\n

non descrive la stessa logica perch\u00e9 non \u00e8 assegnato n\u00e9 un valore di default n\u00e9 un valore di ELSE al segnale step. Il processo not_similar implica che step deve mantenere il suo valore se addr \u00e8 minore o uguale a 0F hex. Questa viene chiamata memoria implicita. Cos\u00ec, una volta che \u00e8 stato asserito, step rimarr\u00e0 sempre al valore asserito come mostrato nella\u00a0prossima figura\u00a0e definito dalla seguente equazione:<\/p>\n

step=addr(3)*addr(2)*addr(1)*addr(0) + step<\/p>\n

\"process1\"<\/p>\n

nella figura un esempio di memoria implicita.<\/p>\n

Se non si vuole che il valore di step venga memorizzato \u00e8 necessario includere un valore di default o completare l\u2019istruzione IF-THEN con un ELSE.
\nL\u2019istruzione IF-THEN_ELSE pu\u00f2 essere ulteriormente espansa includendo ELSIF per specificare ulteriori condizioni.
\nLa sintassi di questa operazione \u00e8<\/p>\n

\"process2\"<\/p>\n

Costrutto Case – When<\/strong><\/p>\n

L\u2019istruzione CASE-WHEN viene utilizzata per specificare un insieme di istruzioni da eseguire in base al valore di un segnale selezione. L\u2019istruzione CASE-WHEN pu\u00f2 essere utilizzata, per esempio, in modo equivalente all\u2019istruzione WITH-SELECT-WHEN.
\nLa sintassi \u00e8:<\/p>\n

\"process3\"<\/p>\n

Di seguito viene riportato un esempio di applicazione dell\u2019istruzione CASE-WHEN alla
\ncreazione di un decodificatore di indirizzi.<\/p>\n

\"13\"<\/p>\n

Logica sincrona Flip-Flop\u00a0 e Registri<\/strong><\/p>\n

implementazione VHDL di un FLIP FLOP tipo D<\/strong>.<\/p>\n

\"14\"<\/p>\n

descrizione e simbolo di un flip flip di tipo D che memorizza sul fronte positivo del clock<\/p>\n

implementazione in VHDL di un FLIP FLOP dipo T.<\/strong><\/em><\/p>\n

\"FF<\/p>\n

descrizione e simbolo di un flip flip di tipo T (toggle) che memorizza sul fronte positivo del clock<\/p>\n

implementazione di un REGISTRO a 8 bit in VHDL<\/strong>.<\/p>\n

\"registro<\/p>\n

Il registro di 8 bit con memorizzazione del dato sul fronte positivo del clock.<\/p>\n

WAIT – UNTIL<\/strong><\/p>\n

E\u2019 possibile descrivere il comportamento di un filp flop di tipo D anche mediante l\u2019istruzione WAIT-UNTIL invece di IF (clk\u2019 ENVENT AND clk=1):<\/p>\n

\"wait<\/p>\n

Questo processo non utilizza una sensitivity list, ma inizia con l\u2019istruzione WAIT. Un processo che utilizza un\u2019istruzione WAIT non pu\u00f2 avere una sesitivity list (l\u2019istruzione WAIT definisce implicitamente la sensitivity list). Per i circuiti che devono essere sintetizzati, l\u2019istruzione WAIT-UNTIL deve essere la prima del processo. A causa di questo, la logica sincrona descritta utilizzando l\u2019istruzione WAIT non pu\u00f2 essere resettata in modo asincrono.<\/p>\n

Sensibilit\u00e0 ai fronti dei segnali.<\/strong><\/p>\n

Le funzioni rising_edge<\/strong> e falling_edge <\/strong>rendono il sistema reattivo ai rispettivi fronti dei segnali.
\nIl package STD_LOGIC_1164 definisce le funzioni RISING_EDGE e FALLING_EDGE per rilevare i fronti di salita e di discesa dei segnali.
\nUna di queste funzioni pu\u00f2 essere utilizzata per sostituire l\u2019espressione (clk\u2019EVENT AND clk=\u20181\u2019) se il segnale clk \u00e8 di tipo STD_LOGIC.
\nQueste funzioni a volte sono preferite dai progettisti perch\u00e9 nelle simulazioni la funzione RISING_EDGE assicura che la transizione avviene tra \u20180\u2019 e \u20181\u2019 enon qualche altra transizione come ad esempio tra \u2018U\u2019 e \u20181\u2019.<\/p>\n

\"fronti\"<\/p>\n

Descrizione di un FLIP FLOP tipo D utilizzando la funzione RISING_EDGE.<\/p>\n

Reset e preset nella logica sincrona<\/strong>
\nLo standard VHDL non richiede che un circuito venga inizializzato o resettato. Lo standard specifica che per la simulazione, a meno che un segnale non sia esplicitamente inizializzato, un segnale viene inizializzato al valore \u2018left del suo tipo. Cos\u00ec, il tipo STD_LOGIC verr\u00e0 inizializzato a \u2018U\u2019, e un bit verr\u00e0 inizializzato a \u20180\u2019.
\nNell\u2019hardware, questo non \u00e8 sempre vero, non tutti i dispositivi si inizializzano nello stato di reset, ma in uno stato privo di significato.
\nE\u2019 possibile descrivere il reset e il preset di un dispositivo mediante una semplice modifica del codice VHDL come segue in cui nel flip flop di tipo D \u00e8 presente un reset di tipo asincrono:<\/p>\n

\"reset<\/p>\n

La sensitivity list indica che questo processo \u00e8 sensibile ai cambiamenti di clke reset. Se il segnale di resetviene messo a \u20181\u2019, al segnale qviene assegnato il valore \u20180\u2019 qualunque sia il valore di clk.
\nPer descrivere un preset al posto di un reset, \u00e8 possibile modificare la sensitivity list e scrivere.<\/p>\n

\"preset\"<\/p>\n

invece che:<\/p>\n

\"presetok\"<\/p>\n

E\u2019 possibile anche resettare(o presettare) un flip flop in modo sincrono ponendo la condizione di reset (o preset) all\u2019interno della porzione del processo che descrive la logica che \u00e8 sincrona con il clock, come segue in un esempio che riguarda un FLIP FLOP D (con reset sincrono)<\/p>\n

\"architet\"<\/p>\n

Generalmente la logica sincrona richiede risorse hardware addizionali rispetto a reset e presetasincrono.
\nIn VHDL \u00e8 possibile anche descrivere una combinazione di reset e\/o preset sincroni\/asincroni. Per esempio, un registro a 8 bit pu\u00f2 essere resettato a 0 ogni volta che il segnale resetva a \u20181\u2019, e pu\u00f2 essere inizializzato con tutti 1 e caricato dal fronte di salita del clock, come riportato nel listato che segueper un registro a 8 bit con reset asincrono e inizializzazione sincrona<\/strong>:<\/p>\n

\"preset<\/p>\n

Buffer three-state e segnali bidirezionali.<\/strong><\/p>\n

Descrizione comportamentale di un buffer tree-state.
\nI valori che un segnale three-state pu\u00f2 assumere sono \u20180\u2019, \u20181\u2019 e \u2018Z\u2019, e sono supportati tutti dal tipo STD_LOGIC.
\nL\u2019utilizzo dei buffer three-state viene illustrato mediante l\u2019esempio di un contatore a 8 bit caricabile:<\/p>\n

\"buffer<\/p>\n

Il processo chiamato oes<\/strong> \u00e8 utilizzato per descrivere l\u2019uscita three-state del contatore. Questo processo indica semplicemente che se oeviene messo a \u20181\u2019, il valore di cnt viene assegnato a cnt-oute se oeviene messo a \u20180\u2019, l\u2019uscita di questo dispositivi viene posta in alta impedenza. Il processo \u00e8 sensibile al cambiamento di entrambe le variabili oe e cnt, perch\u00e9 un cambiamento in entrambi i segnali provoca un cambiamento nell\u2019uscita cnt_out. Il processo oes<\/strong> descrive il comportamento di un buffer three-state.<\/p>\n

\"buffer<\/p>\n

Il controllo dei buffer three-state pu\u00f2 essere descritto anche con l\u2019istruzione WHEN-ELSE. Nel listato che segue, che \u00e8 una versione modificata del contatore a 8 bit, \u00e8 stata aggiunta un\u2019uscita addizionale, collision, che viene messa a \u20191\u2019 quando i segnali load e enable sono contemporaneamente posti a \u20181\u2019.<\/p>\n

\"buffer<\/p>\n

Segnali bidirezionali.<\/strong><\/p>\n

I segnali bidirezionali possono essere descritti con una piccola modifica dei listati del contatore visti in precedenza.<\/p>\n

\"buffer<\/p>\n

In questo caso il contatore viene caricato con il valore corrente sui pin associati con l\u2019uscita del contatore, questo significa che il valore caricato quando loadviene posto a \u20181\u2019 potrebbe essere il valore precedente del contatore oppure un valore posto sui pin da un altro dispositivo, a seconda dello stato di oe.<\/p>\n

for–generate<\/strong><\/p>\n

Se si volesse utilizzare un componente chiamato <\/span>threestate, <\/span><\/i>precedentemente creato, per implementare un buffer three-state per un bus di 32 bit, al posto di istanziare 32 buffer \u00e8 possibile utilizzare l\u2019istruzione FOR-GENERATE come segue: <\/span><\/p>\n

\"for-generate\"<\/p>\n

Questo tipo di istruzione viene implementato nella parte delle istruzioni concorrenti di un\u2019architettura, non all\u2019interno di un <\/strong><\/span>process<\/strong>. L<\/span><\/i>\u2018istruzione FOR-GENERATE richiede una label; in questo caso <\/span>gen_label.<\/span><\/i><\/p>\n

\"for-generate<\/p>\n

E\u2019 possibile utilizzare schemi pi\u00f9 complicati dell\u2019istruzione FOR-GENERATE in cui sono presenti assegnamenti di tipo condizionato, come ad esempio:<\/p>\n

\"for-generate<\/p>\n

Il\u00a0listato\u00a0 include l\u2019istruzione IF-THEN. Quando viene utilizzata insieme all\u2019istruzione FOR-GENERATE, l\u2019istruzione IF-THEN non pu\u00f2 includere un ELSE o un ELSIF.<\/p>\n

Convertire i buffer three-state in multiplexer<\/strong><\/p>\n

Alcune FPGA contengono al loro interno dei buffer three-state, altre no. Tuttavia, i progetti che utilizzano bus three-state possono essere convertiti in progetti che utilizzano i multiplexer. Alcuni strumenti di sintesi possono fare questo automaticamente. La conversione dei buffer three-state in multiplexer \u00e8 illustrata nella figura che segue:<\/p>\n

\"multiplexer\"<\/p>\n

I Cicli<\/strong><\/p>\n

I cicli sono utilizzati per implementare operazioni ripetitive, e possono essere sia cicli FOR che cicli WHILE. Il ciclo FOR esegue un numero predeterminato di iterazioni in base ad un valore di controllo. Il ciclo WHILE continua l\u2019esecuzione di un\u2019operazione finch\u00e9 non si verifica una condizione logica di controllo. Si consideri per esempio il ciclo che esegue il reset asincrono della FIFO<\/p>\n

\"for\"<\/p>\n

Questo ciclo che scandisce tutti gli 8 STD_LOGIC_VECTOR che compongono la FIFO, inizializza ogni elemento del vettore a \u20180\u2019. In un ciclo FOR, la variabile del ciclo viene dichiarata automaticamente. Al posto del ciclo FOR potrebbe essere utilizzato anche un ciclo WHILE, ma questo richiede delle dichiarazioni, delle inizializzazioni e un incremento della variabile di ciclo addizionali, come mostrato nell\u2019esempio sotto:<\/p>\n

\"loop\"<\/p>\n

Iterazioni condizionate.<\/strong><\/span><\/p>\n

L\u2019istruzione NEXT viene utilizzata per saltare un operazione in base al verificarsi di una determinata condizione. Si supponga per esempio che quando il segnale <\/span>rst <\/span><\/i>viene posto ad \u20181\u2019, tutti i registri della FIFO siano resettati eccetto che per il registro FIFO(4):<\/span><\/p>\n

\"next\"<\/p>\n

Oppure pu\u00f2 essere scritto utilizzando un ciclo WHILE:<\/p>\n

\"while\"<\/span><\/p>\n

Uscita dai cicli.<\/strong><\/p>\n

L\u2019istruzione EXIT viene utilizzata per uscire dai cicli, e pu\u00f2 essere utilizzata per testare una condizione illegale. La condizione deve essere verificata all\u2019istante della compilazione. Si supponga, per esempio, che la FIFO sia un componente che viene istanziato in un progetto gerarchico. Si supponga inoltre che la profondit\u00e0 della FIFO venga definita per mezzo di un parametro di tipo GENERIC. Si vuole uscire dal ciclo quando la profondit\u00e0 della FIFO diventa pi\u00f9 grande di un valore predeterminato. Ad esempio:<\/p>\n

\"exit\"<\/p>\n

Il frammento di codice riportato sopra pu\u00f2 essere riscritto come:<\/p>\n

\"exit1\"<\/p>\n

Progetto di una FIFO<\/strong><\/p>\n

Si vuole progettare una FIFO con profondit\u00e0 di 8 parole di 9 bit. Descrizione dei segnali: <\/span><\/p>\n

Quando il segnale <\/span>rd <\/span><\/i>viene posto a \u20181\u2019, l\u2019uscita della FIFO, <\/span>data_out<\/span><\/i>, deve essere abilitata.\u00a0<\/span><\/p>\n

Quando <\/span>rd <\/span><\/i>\u00e8 a \u20180\u2019, l\u2019uscita deve essere posta in alta impedenza. <\/span><\/p>\n

Quando il segnale di write <\/span>wr<\/span><\/i>viene posto a \u20181\u2019 si vuole scrivere in uno dei registri di 9 bit. <\/span><\/p>\n

I segnali <\/span>rdinc <\/span><\/i>e <\/span>wrinc<\/span><\/i>sono utilizzati per incrementare i puntatori di lettura e scrittura che indicano quale registro leggere e scrivere. <\/span><\/p>\n

Rdptrclr <\/span><\/i>e <\/span>wrptrclr <\/span><\/i>resettano i puntatori di lettura e scrittura e li indirizzano al primo registro della FIFO. <\/span><\/p>\n

Data_in <\/span><\/i>\u00e8 il dato che deve essere caricato in uno dei registri.La figura\u00a0mostra uno schema a blocchi della FIFO a 9 bit. <\/span><\/p>\n

\"FIFO\"<\/p>\n

Il listato riportato di seguito illustra un modo di implementare la FIFO che utilizza la progettazione gerarchica e strutturale.<\/p>\n

\"FIFO<\/p>\n

\"FIFO<\/p>\n

Progetto di macchine a stati finiti<\/strong><\/p>\n

In VHDL descrivere il comportamento di una macchina a stati finiti \u00e8 solo un problema di tradurre il diagramma a stati in una serie di istruzioni CASE-WHEN e IF-THEN-ELSE, come verr\u00e0 mostrato nell\u2019esempio illustrato di seguito. <\/span><\/p>\n

Si vuole descrivere un controller che viene utilizzato per abilitare e disabilitare i segnali di write enable (<\/span>we<\/span><\/i>) e output enable (<\/span>oe<\/span><\/i>) di un buffer di memoria durante la fase di lettura e scrittura. <\/span><\/p>\n

I segnali <\/span>ready <\/span><\/i>e <\/span>read_write <\/span><\/i>sono le uscite di un microprocessore e gli ingressi del controller. Una nuova transizione inizia quando il segnale <\/span>ready <\/span><\/i>viene posto a \u20181\u2019. Un ciclo di clock dopo l\u2019inizio della transizione il valore del segnale <\/span>read_write <\/span><\/i>determina se effettuare una transizione di lettura o scrittura. <\/span><\/p>\n

Se <\/span>read_write <\/span><\/i>viene posto uguale a \u20181\u2019, allora si esegue un ciclo di lettura, altrimenti si esegue un ciclo di scrittura.\u00a0 <\/span><\/p>\n

Un ciclo viene completato quando ready viene posto a \u20181\u2019, dopo di che pu\u00f2 iniziare una nuova transizione. <\/span><\/p>\n

Write enableviene posto a \u20181\u2019 durante il ciclo di scrittura e output enable viene posto a \u20181\u2019 durante un ciclo di lettura.Nella figura che segue viene riportato il diagramma a bolle del controller. <\/span><\/p>\n

\"stati<\/p>\n

Metodologia di progetto tradizionale.<\/strong><\/p>\n

Con il metodo di progetto tradizionale, il primo passo \u00e8 quello di disegnare il diagramma dal quale ricavare la tabella degli stati.<\/p>\n

E\u2019 possibile quindi fare l\u2019assegnamento degli stati e creare una tabella di transizione degli stati da cui si possono determinare le equazioni che determinano lo stato successivo e le uscite in base ai tipi di flip flop utilizzati per l\u2019implementazione.<\/p>\n

La figura del diagramma a bolle (o diagramma degli stati) \u00e8 mostrata sopra. In questa macchina non ci sono degli stati equivalenti.<\/p>\n

E\u2019 possibile combinare la tabella di assegnamento degli stati con la tabella di transizione degli stati, come \u00e8 riportato nella figura sotto.<\/p>\n

\"stati<\/p>\n

\"stati<\/p>\n

L\u2019assegnamento degli stati \u00e8 elencato nella colonna present state (PS). Si vuole utilizzare il minor numero possibile di registri per gli stati, cio\u00e8 due. <\/span><\/p>\n

La colonna next state (NS) mostra la transizione dallo stato presente verso lo stato successivo in base al valore dei due ingressi <\/span>read_write<\/span><\/i>e <\/span>ready<\/span><\/i>. <\/span><\/p>\n

Le uscite sono riportate nella colonna pi\u00f9 a destra.E\u2019 possibile determinare ora l\u2019equazione dello stato successivo per ognuno dei due bit di stato. <\/span><\/p>\n

Nelle equazioni mostrate, Q1 e Q0 rappresentano i valori dello stato successivo, e <\/span>q1<\/span><\/i>e <\/span>q0<\/span><\/i>rappresentano i valori dello stato presente. <\/span><\/p>\n

Le mappe di Karnaugh possono essere generate facilmente dalla tabella delle transizioni: ogni riga corrisponde ad uno stato, ogni colonna corrisponde ad una combinazione degli ingressi, e gli ingressi nella mappa di Karnaugh corrispondono ai valori di Q1 e Q0 trovati nella tabella delle transizioni. <\/span><\/p>\n

Le mappe di Karnaugh vengono poi utilizzate per trovar le equazioni minime assumendo che si utilizzino flip flop di tipo D. <\/span><\/p>\n

Le uscite sono funzioni solo dello stato presente (macchina di Moore). <\/span><\/p>\n

Le macchine a stati finiti in VHDL.<\/strong><\/p>\n

Il diagramma degli stati mostrato precedentemente pu\u00f2 essere facilmente tradotto in VHDL senza dover effettuare l\u2019assegnamento degli stati, generare la tabella di transizione degli stati, o determinare le equazioni che individuano lo stato successivo in base al tipo di flip flop disponibile.<\/p>\n

In VHDL ogni stato pu\u00f2 essere tradotto in un caso mediante una istruzione CASE WHEN.<\/p>\n

La transizione degli stati pu\u00f2 essere specificata mediante una serie di istruzioni IF-THEN-ELSE. Per esempio, per tradurre in VHDL un diagramma degli stati si inizia definendo un tipo enumerativo, formato dal nome degli stati, e dichiarando due segnali del tipo:<\/p>\n

\"tipo<\/p>\n

L\u2019operazione successiva da fare \u00e8 quella di creare un processo. <\/span><\/p>\n

Next_state <\/span><\/i>viene determinato tramite una funzione di <\/span>present_state <\/span><\/i>e degli ingressi (<\/span>ready<\/span><\/i>e <\/span>read_write<\/span><\/i>). Cos\u00ec il processo deve essere sensibile a questi segnali:<\/span><\/p>\n

\"state\"<\/p>\n

All\u2019interno del processo vengono descritte le transizioni della macchina a stati finiti. <\/span><\/p>\n

Viene aperta una istruzione CASE-WHEN e specificato il primo caso (condizione WHEN), cio\u00e8 lo stato di <\/span>idle<\/span><\/i>. Per questo caso, si specificano le uscite definite nello stato di <\/span>idle <\/span><\/i>e le transizioni che partono da esso.<\/span><\/p>\n

\"state1\"<\/p>\n

Ci sono due opzioni in questo caso (cio\u00e8, quando <\/span>present_state<\/span><\/i>\u00e8 <\/span>idle<\/span><\/i>): (1) la transizione allo stato <\/span>decision<\/span><\/i>se <\/span>ready <\/span><\/i>e uguale a \u20181\u2019 oppure (2) rimanere nello stato di <\/span>idle<\/span><\/i>. In questo caso la condizione di ELSE non \u00e8 richiesta perch\u00e9 viene utilizzata la memoria implicita e lo stato <\/span>next_state <\/span><\/i>rimane lo stesso. La codifica degli altri stati viene effettuata nello stesso modo: per ogni stato viene creato un ramo nell\u2019istruzione CASE (WHEN <\/span>state_name<\/span><\/i>=>), si specifica quali sono le uscite dello stato, e si definisce la transizione agli altri stati con un\u2019istruzione IF -THEN-ELSE. <\/span><\/p>\n

\"state2\"<\/p>\n

Il processo mostrato sopra indica che l\u2019assegnamento di <\/span>next_state <\/span><\/i>\u00e8 basato su <\/span>present_state <\/span><\/i>e sugli ingressi correnti, ma non indica quando <\/span>next_state <\/span><\/i>diventa <\/span>present_state<\/span><\/i>. <\/span><\/p>\n

Questo avviene in modo sincrono, sul fronte di salita del clock, come indicato in un secondo processo:<\/span><\/p>\n

\"state3\"<\/p>\n

Il codice completo della macchina a stati finiti \u00e8 il seguente:<\/p>\n

\"state4\"<\/p>\n

Memory controller.<\/strong><\/p>\n

\"memory<\/p>\n

Il memory controller mostrato nella figura sopra, ha il seguente funzionamento: altri dispositivi sul bus iniziano un accesso al buffer di memoria identificandolo sul bus con il suo indirizzo, F3 in esadecimale. Un ciclo di clock dopo, il segnale di <\/span>read_write <\/span><\/i>viene messo a \u20181\u2019 per indicare una lettura dal buffer di memoria; oppure viene messo a \u20180\u2019 per indicare una scrittura sul buffer di memoria. Se l\u2019accesso alla memoria \u00e8 una lettura, la lettura potrebbe essere di una sola parola o di un burst<\/strong> di quattro parole. La lettura di un burst \u00e8 indicata mettendo a \u20181\u2019 il segnale <\/span>burst <\/span><\/i>durante il primo ciclo di lettura, dopo di che il controller accede a quattro locazioni di memoria dal buffer. Le locazioni consecutive sono accedute mettendo il segnale <\/span>ready <\/span><\/i>a \u20181\u2019. Il controller mette <\/span>oe<\/span><\/i>(output enable) a \u20181\u2019 al buffer di memoria durante una lettura, e incrementa i due bit pi\u00f9 bassi dell\u2019indirizzo durante una lettura a burst. La scrittura nel buffer di memoria \u00e8 sempre una scrittura di una singola parola, mai di un burst. Durante una scrittura, <\/span>we <\/span><\/i>viene messo a \u20181\u2019, permettendo a <\/span>data <\/span><\/i>di essere scritto nella locazione di memoria specificata da <\/span>address<\/span><\/i>. Gli accessi in lettura e scrittura sono completati quando il segnale <\/span>ready <\/span><\/i>viene messo a \u20181\u2019.<\/span><\/p>\n

La figura successiva mostra il diagramma degli stati del memory controller.<\/p>\n

\"diagramma<\/p>\n

Il diagramma degli stati pu\u00f2 essere facilmente tradotto in una serie di istruzioni CASE-WHEN come segue (per ora non viene considerato un reset sincrono):<\/p>\n

\"case\"<\/p>\n

Reset sincrono un una macchina a stati finiti con due processi.<\/strong><\/p>\n

Questa macchina a stati finiti richiede un reset sincrono. Al posto di specificare la transizione di reset nello stato di <\/span>idle <\/span><\/i>in ogni ramo dell\u2019istruzione CASE, \u00e8 possibile includere un\u2019istruzione IF-THEN-ELSE all\u2019inizio del process per fare in modo che la macchina entri nello stato di <\/span>idle <\/span><\/i>se il segnale di <\/span>reset <\/span><\/i>viene messo a \u20181\u2019. Se il segnale di <\/span>reset <\/span><\/i>\u00e8 a \u20180\u2019, allora avvengono le transizioni di stato normali della macchina, come specificato nell\u2019istruzione CASE. Nell\u2019istruzione IF-THEN-ELSE \u00e8 necessario specificare anche come si vuole che siano le uscite (<\/span>oe<\/span><\/i>, <\/span>we<\/span><\/i>e <\/span>addr<\/span><\/i>) se il segnale di <\/span>reset <\/span><\/i>viene messo a \u20181\u2019. Se non vengono specificate le uscite in questa condizione, allora si ottiene l\u2019effetto di memoria implicita: verranno creati dei latch per assicurare che quando il <\/span>reset <\/span><\/i>viene messo a \u20181\u2019, le uscite mantengano il loro valore. Dato che, in questo caso, non si vuole che siano creati dei latch, viene specificato il valore <\/span>don\u2019t care <\/span><\/i>quando il segnale di reset viene messo a \u20181\u2019.<\/span><\/p>\n

Il codice richiesto per il reset \u00e8 il seguente:<\/p>\n

\"state<\/p>\n

Diversamente, la condizione di reset potrebbe essere messa dopo l\u2019istruzione CASE, come ultima istruzione nel process <\/span>state_comb<\/span><\/i>. In questo modo, potrebbe essere una semplice istruzione IF-THEN e sarebbe necessaria solo la transizione dello stato. Non \u00e8 pi\u00f9 richiesta la definizione del valore delle uscite. Il codice richiesto in questo caso \u00e8: <\/span><\/p>\n

\"state<\/p>\n

Il codice completo del memory controller \u00e8 mostrato nel listato sotto:<\/p>\n

\"state<\/p>\n

Il listato riportato nella pagina precedente descrive una macchina a stati finiti con due processi. Un processo che descrive la logica combinatoria, e un altro che descrive la sincronizzazione delle transizioni di stato con il clock, come illustrato nella figura seguente.<\/p>\n

\"case-when-diagram<\/p>\n

Reset asincrono<\/strong><\/span>. <\/span><\/p>\n

Se \u00e8 necessario utilizzare un reset asincrono invece che uno sincrono, allora \u00e8 possibile utilizzare uno schema di reset come quello riportato nel seguente listato:<\/p>\n

\"reset_asincrono\"<\/p>\n

Se il segnale di reset \u00e8 utilizzato solo durante l\u2019inizializzazione o i malfunzionamenti del sistema, allora \u00e8 preferibile utilizzare un reset di tipo asincrono. Questo principalmente perch\u00e9 un reset sincrono richiede risorse del dispositivo addizionali, inoltre elimina la possibilit\u00e0 di introdurre accidentalmente la memoria implicita.<\/p>\n

Il codice nel listato riportato sotto \u00e8 funzionalmente equivalente a quello riportato nel listato precedente, per\u00f2 utilizza solamente un processo per descrivere la transizione tra gli stati e la sincronizzazione delle transizioni con il clock. Una serie di istruzioni concorrenti addizionali sono utilizzate per descrivere il comportamento delle uscite.<\/p>\n

\"reset_asincrono_single<\/p>\n

Area, velocit\u00e0 e utilizzazione delle risorse del dispositivo.<\/strong><\/p>\n

Di seguito vengono illustrate quattro tecniche per generare l\u2019uscita delle macchine a stati finiti per le macchine di Moore:<\/span><\/p>\n

    \n
  1. decodifica dell\u2019uscita dai bit di stato in modo combinatorio\u2022decodifica dell\u2019uscita in registri di uscita paralleli<\/span><\/li>\n
  2. codifica dell\u2019uscita all\u2019interno dei bit di stato<\/span><\/li>\n
  3. codifica <\/span>one hot <\/span><\/i><\/strong>Ognuna di queste tecniche produce un\u2019implementazione logica con differenti caratteristiche di temporizzazione.<\/span><\/li>\n<\/ol>\n

    Decodifica dell\u2019uscita dai bit di stato in modo combinatorio.<\/strong><\/span><\/p>\n

    I listati precedenti descrivono le uscite che devono essere decodificate dallo stato presente dei bit di stato come riportato nella figura sotto. Questa decodifica combinatoria pu\u00f2 richiedere livelli di logica addizionali, rendendo cos\u00ec pi\u00f9 lenta la propagazione dall\u2019uscita dei bit di stato ai segnali di uscita del dispositivo.<\/p>\n

    \"stati<\/p>\n

    Decodifica dell\u2019uscita in registri di uscita paralleli<\/strong><\/p>\n

    Un modo per assicurare che le uscite della macchina a stati finiti arrivino ai pin del dispositivo pi\u00f9 rapidamente \u00e8 decodificare le uscite dai bit di stato prima che i bit di stato vengano memorizzati, e quindi immagazzinare l\u2019informazione decodificata in alcuni registri. Questo pu\u00f2 essere fatto sia con la descrizione della macchia a stati finiti con un processo che con due processi.<\/p>\n

    In entrambi i casi, l\u2019assegnamento a <\/span>addr <\/span><\/i>deve essere descritto fuori dal processo in cui sono definite le transizioni di stato. Invece di utilizzare le informazioni del <\/span>present_state <\/span><\/i>per determinare il valore di <\/span>addr<\/span><\/i>, viene utilizzata l\u2019informazione di <\/span>next_state <\/span><\/i>per determinare come dovrebbe essere il valore di <\/span>addr <\/span><\/i>durante il successivo ciclo di clock. Il concetto di immagazzinare il valore delle uscite in base al valore di <\/span>next_state <\/span><\/i>\u00e8 illustrato nella figura sotto.<\/span><\/p>\n

    \"stati<\/p>\n

    Per modificare il progetto del memory controller per includere la decodifica delle uscite in registri di uscita paralleli, il listato precedente viene modificato come riportato di seguito. I commenti sono utilizzati per indicare dove ci sono differenze nel codice.<\/p>\n

    \"stati<\/p>\n

    \"stati<\/p>\n

    In questo progetto \u00e8 stato dichiarato un segnale addizionale: <\/span>addr_d. <\/span><\/i>Questo viene utilizzato per decodificare in modo combinatorio come dovrebbe essere il valore di <\/span>addr <\/span><\/i>il ciclo di clock successivo. Questo viene fatto rimuovendo l\u2019istruzione di assegnamento del segnale <\/span>addr <\/span><\/i>dal istruzione CASE, e inserendo un\u2019istruzione di assegnamento dei segnali WITH-SELECT-WHEN, in cui il segnale di selezione \u00e8 <\/span>next_state<\/span><\/i>. Poi, il segnale <\/span>addr_d <\/span><\/i>viene memorizzato nel segnale <\/span>addr <\/span><\/i>sul fronte di salita del clock. Tutto questo viene descritto nel processo <\/span>state_clocked<\/span><\/i>. L\u2019istruzione WITH-SELECT-WHEN non \u00e8 necessario che sia posta tra i due processi potrebbe essere messa prima o dopo di loro.<\/span><\/p>\n

    Codifica dell\u2019uscita con i bit di stato<\/strong><\/p>\n

    Un contatore \u00e8 un esempio di una macchina a stati finiti nella quale le uscite sono i bit di stato. Questo metodo potrebbe funzionare meglio dei precedenti in alcuni casi particolari, ma richiede una scelta accurata della codifica degli stati: l\u2019uscita deve corrispondere al valore memorizzato nel registro degli stati, come mostrato nella figura sotto.<\/p>\n

    \"stati<\/p>\n

    Questo approccio rende la progettazione pi\u00f9 complicata da comprendere e cambiare, cos\u00ec \u00e8 raccomandata solo per i casi che richiedono ottimizzazioni di area e prestazioni non fornite dagli strumenti di sintesi, o automaticamente dalle direttive di implementazione.<\/p>\n

    Codifica one-hot<\/strong><\/p>\n

    Questa \u00e8 una tecnica che utilizza <\/span>n <\/span><\/i>flip flop per rappresentare una macchina a stati finiti con <\/span>n <\/span><\/i>stati. Ogni stato ha un suo proprio flip flop, e solo un flip flop \u00e8 “hot” (cio\u00e8 ha memorizzato un \u20181\u2019) ogni intervallo di tempo. Uno dei vantaggi della codifica “one hot” \u00e8 che il numero di porte richieste per decodificare l\u2019informazione degli stati per le uscite e per la transizione allo stato successivo e molto minore del numero di porte richiesto a questo scopo dagli altri metodi di codifica. Questa differenza nella complessit\u00e0 diventa pi\u00f9 evidente al crescere del numero degli stati. A seconda dell\u2019architettura del dispositivo utilizzato, una macchina a stati finiti con codifica <\/span>one hot <\/span><\/i>potrebbe richiedere meno risorse del dispositivo per l\u2019implementazione del progetto. Una logica per determinare lo stato successivo pi\u00f9 semplice richiede meno livelli di logica tra i registri di stato, permettendo cos\u00ec frequenze di funzionamento pi\u00f9 alte. La codifica <\/span>one hot <\/span><\/i>non \u00e8 sempre la miglior soluzione, principalmente perch\u00e9 richiede pi\u00f9 flip flop che una macchina a stati finiti codificata in modo sequenziale. In generale, la codifica <\/span>one hot <\/span><\/i>\u00e8 pi\u00f9 utile quando l\u2019architettura del dispositivo programmabile che si vuole utilizzare contiene un numero relativamente elevato di registri e poca logica combinatoria tra ogni registro. Per esempio, la codifica <\/span>one hot <\/span><\/i>risulta pi\u00f9 utile per le macchine a stati finiti implementate dentro alle FPGA, che generalmente hanno una densit\u00e0 di flip flop pi\u00f9 elevata che le CPLD ma un minor numero di porte logiche per flip flop. Finora si \u00e8 discusso di che cosa \u00e8 la codifica <\/span>one hot <\/span><\/i>e quando conviene utilizzarla, vediamo ora come descrivere una macchina a stati finiti con la codifica <\/span>one hot<\/span><\/i>. Fortunatamente, la codifica <\/span>one hot <\/span><\/i>richiede pochi o nessun cambiamento al codice sorgente, ma dipende dal software di sintesi che viene utilizzato. Molti software per la sintesi permettono di utilizzare alcune direttive di sintesi nella forma di istruzioni VHDL, o di opzioni GUI (come avviene nel software Foundation Express). Generare le uscite per una macchina a stati finiti con codifica <\/span>one hot <\/span><\/i>\u00e8 analogo a generare le uscite per macchine in cui le uscite sono decodificate dai registri di stato. La decodifica \u00e8 abbastanza semplice perch\u00e9 gli stati sono solo dei bit singoli e non un intero vettore. La logica di uscita consiste di una porta OR perch\u00e9 le macchine di Moore hanno le uscite che sono funzioni solo dello stato, e tutti gli stati in una macchina a stati finiti con codifica <\/span>one hot <\/span><\/i>sono rappresentati da un bit. In una FPGA, il ritardo associato ad una porta OR \u00e8 tipicamente accettabile ed \u00e8 un miglioramento rispetto alle decodifiche dell\u2019uscita che utilizzano un intero vettore di stato.<\/span><\/p>\n

    Macchine di Mealy<\/strong><\/p>\n

    Finora sono state trattate solo le macchine di Moore (figura sotto a) in cui le uscite sono funzioni solamente dello stato corrente. Le macchine di Mealy (figura sotto b) possono avere uscite che sono funzioni dello stato presente e dei segnali presenti in ingresso, come illustrato nella figura sotto.<\/p>\n

    \"macchine<\/p>\n

    Il lavoro addizionale che \u00e8 19necessario per descrivere le macchine di Mealy rispetto alle macchine di Moore \u00e8 minimo. Per implementare una macchina di Mealy occorre semplicemente descrivere un\u2019uscita come funzione sia dei bit di stato che degli ingressi. Per esempio, se vi \u00e8 un ingresso addizionale al memory controller chiamato <\/span>write_mask <\/span><\/i>che quando vale \u20181\u2019 non consente a <\/span>we <\/span><\/i>di essere abilitato, \u00e8 possibile descrivere la logica per <\/span>we <\/span><\/i>come <\/span><\/p>\n

    \"macchine<\/p>\n

    Questo rende <\/span>we <\/span><\/i>un\u2019uscita di Mealy.<\/span><\/p>\n

     <\/p>\n

     <\/p>\n

     <\/p>\n

     <\/p>\n

     <\/p>\n

     <\/p>\n

     <\/p>\n

     <\/p>\n

     <\/p>\n

     <\/p>\n

     <\/p>\n

     <\/p>\n

     <\/p>\n

     <\/p>\n

     <\/p>\n

     <\/p>\n

     <\/p>\n

     <\/p>\n

     <\/p>\n","protected":false},"excerpt":{"rendered":"

    VHDL: Concetto di entity. Un entity \u00e8 un\u2019astrazione di un dispositivo che pu\u00f2\u00a0rappresentare un sistema completo, una scheda, un chip, una funzione o una porta logica. Una dichiarazione di entity descrive l\u2019I\/O di un progetto e pu\u00f2 includere anche parametri … Continua a leggere→<\/span><\/a><\/p>\n","protected":false},"author":1,"featured_media":0,"parent":0,"menu_order":0,"comment_status":"closed","ping_status":"closed","template":"","meta":[],"_links":{"self":[{"href":"https:\/\/www.gtronic.it\/test\/index.php\/wp-json\/wp\/v2\/pages\/597"}],"collection":[{"href":"https:\/\/www.gtronic.it\/test\/index.php\/wp-json\/wp\/v2\/pages"}],"about":[{"href":"https:\/\/www.gtronic.it\/test\/index.php\/wp-json\/wp\/v2\/types\/page"}],"author":[{"embeddable":true,"href":"https:\/\/www.gtronic.it\/test\/index.php\/wp-json\/wp\/v2\/users\/1"}],"replies":[{"embeddable":true,"href":"https:\/\/www.gtronic.it\/test\/index.php\/wp-json\/wp\/v2\/comments?post=597"}],"version-history":[{"count":36,"href":"https:\/\/www.gtronic.it\/test\/index.php\/wp-json\/wp\/v2\/pages\/597\/revisions"}],"predecessor-version":[{"id":950,"href":"https:\/\/www.gtronic.it\/test\/index.php\/wp-json\/wp\/v2\/pages\/597\/revisions\/950"}],"wp:attachment":[{"href":"https:\/\/www.gtronic.it\/test\/index.php\/wp-json\/wp\/v2\/media?parent=597"}],"curies":[{"name":"wp","href":"https:\/\/api.w.org\/{rel}","templated":true}]}}