VHDL
Appunti di lezione
Modulo 3
Sistemi Digitali (Controlli)
Prof. Francesco Sforza
1
Sommario
1.
Elementi di base del linguaggio VHDL. ............................. 3
1.1.
Ex Or a “componenti discreti” facendo uso di signal
(descrizione DATA FLOW).......................................................... 6
1.2.
Flip Flop
Set Reset .................................................................. 7
1.3.
Flip Flop
D Latch .................................................................... 8
1.4.
Flip Flop
D Latch “Behavioral” ............................................. 9
1.5.
Flip Flop
J/K
1.6.
Flip Flop
D Master Slave ...................................................... 11
1.7.
Flip Flop
D Master Slave (“Behavioral”)............................ 12
“Behavioral”.............................................. 10
2.
Circuiti combinatori complessi .............................................. 13
3.
Algorithmic State Machines in VHDL............................ 17
4.
Descrizione strutturale .......................................................... 21
5.
Pilotaggio motore passo - passo ........................................... 25
2
Con il linguaggio (V)HDL si descrivono i circuiti con un: Very
(High Scale of Integration Circuits ) Hardware Description
Language.
I circuiti creati con il VHDL serviranno a 2 scopi :
la simulazione
il fitting
1.
Elementi di base del linguaggio VHDL.
I circuiti normalmente vengono descritti tramite due strutture
interconnesse: l’ENTITY e l’ ARCHITECTURE.
Tramite l’ENTITY viene definita l’interfaccia esterna del circuito
che si vuole creare, cioè vengono definiti i pin (che verranno
chiamati PORT) di ingresso e di uscita del circuito.
Tramite l’ARCHITECTURE si definisce il funzionamento interno
del circuito. Esistono diversi stili di scrittura: i fondamentali sono
3: STRUCTURAL, BEHAVIORAL, DATA FLOW.
N.B. ogni riga di codice andrà conclusa con il punto e virgola.
ENTITY
La sintassi per introdurre una ENTITY
costrutto:
ENTITY …… IS PORT (
Nome_pin_uscita : OUT
Nome_pin_ingresso : IN
richiede
il seguente
BIT;
BIT);
END … ;
Quando si vogliono usare simboli maggiormente flessibili dei bit si
ricorre alle standard_logic; sono così disponibili i valori 0, 1,
FALSE, TRUE, LOW, HIGH, X, Z.
Per richiamare la libreria che li contiene sarà necessario far precedere
la dichiarazione di ENTITY dalle seguenti 2 linee di programma:
3
LIBRARY ieee;
USE ieee.std_logic_1164.all;
In questo caso si possono usare per le uscite le espressioni BUFFER
e INOUT; BUFFER sta a significare che il pin è pilotato da un F/F
ed è disponibile per essere riportato ad un nodo interno; INOUT sta
a significare che il pin può essere usato come pin di ingresso e/o di
uscita.
ARCHITECTURE
La sintassi per introdurre una ARCHITECTURE è la seguente:
ARCHITECTURE
…… of …… is
begin
………………
end ……;
Lo stile che verrà usato dopo il begin farà rientrare il vostro
progetto in una delle tre categorie citate precedentemente:
STRUCTURAL, BEHAVIORAL, DATA FLOW; questo stile
dipenderà dai gusti individuali, dalle necessità del progetto (in
particolare se sviluppato da più persone contemporaneamente), dalle
risorse disponibili, dall’orientamento verso la simulazione piuttosto
che non verso il fitting.
Descrizioni behavioral e Data Flow
Nella descrizione DATA FLOW l’architecture viene espressa
avendo molto chiaro l’esatto aspetto circuitale del sistema che si
vuole realizzare
In questo tipo di rappresentazione viene rappresentato il cammino
delle informazioni all’interno dell’hardware, da cui il nome: “flusso
dei dati”
A questo proposito sono utili e necessari i nodi circuitali interni: i
così detti SIGNAL.
Si noti bene che nell’entity compaiono solo i pin (PORT) che si
affacciano esternamente al circuito. I SIGNAL sono nodi elettrici
effettivamente presenti nel circuito, ma non visibili all’esterno;
vengono dichiarati all’interno dell’architecture, prima del begin, e
4
devono essere dello stesso tipo dei pin di IN e OUT, normalmente
std_logic oppure bit.
SINTASSI: SIGNAL nome,[nome] : std_logic;
Nella descrizione BEHAVIORAL
l’architecture
descrive il
funzionamento del sistema, prescindendo dall’eventuale aspetto
circuitale che esso potrà assumere, l’enfasi è posta tutta sulla
modalità di funzionamento (“behavior”) e sui pin “sensibili” che il
circuito potrà presentare; a questo proposito va ricordato che due
categorie di pin d’ingresso si distaccano grandemente da tutti gli
altri: i pin di clock e i pin di Chip Select (comunque i pin che
pilotano il 3_STATE sulle uscite).
Si pensi al clock di un F/F master slave: solo se esso è attivo avrà
senso l’insieme dei segnali presenti sugli altri pin d’ingresso!!!
Nella descrizione BEHAVIORAL compariranno elementi tipici dei
linguaggi di programmazione ad alto livello quali le strutture di
controllo del flusso di programma: i cicli FOR, gli IF, i CASE.
Parallelamente si farà esteso ricorso ai PROCESS, cioè ai dei
sottoprogrammi che descriveranno il funzionamento del circuito (o
parte di esso) quando avviene un cambiamento su un particolare pin
(o signal interno).
RIFERIMENTI:
Il costrutto CASE compare nel punto 8 a pag. 12 (ASM –
automi)
Il costrutto IF compare ai punti 5 e 6 , pag. 7 e seguenti
Il costrutto FOR non è illustrato in questo volumetto.
PROCESS: esempi di process appaiono ai punti 6, 8, 9 da pag. 7
in avanti.
N.B. la descrizione strutturale viene trattata da pag. 21
5
1.1. Ex Or a “componenti discreti” facendo uso
di signal (descrizione DATA FLOW)
Nel nostro primo listato VHDL è descritta una porta ex or vista
come un circutito, quello che appare in figura; vengono introdotti
due SIGNAL (cioè nodi circuitali non associati a dei pin) x e z
Descrizione data flow
entity xor is port
(a,b: in bit;
y1,y2: out bit);
end xor;
architecture pippo of xor is
signal x,z: bit;
begin
x<=not (a) and b;
z<=a and not(b);
y1<=x or z;
descrizione behavioral
entity xor is port
(a,b: in bit;
y2: out bit);
end xor;
architecture pippo of xor is
begin
y2 <=a xor b;
end pippo;
y2<=a xor b;
end pippo;
Ex Or “Behavioral”
La port logica Ex Or può più comodamente essere descritta in base al
suo funzionamento, cioè al suo comportamento (“behavior” in
inglese); il listato VHDL si semplifica grandemente.
6
1.2. Flip Flop
Set Reset
Il circuito rappresentato in figura verrà poi descritto da una entity di
tipo DATA FLOW, infatti le uscite saranno rappresentate da
equazioni booleane che fanno esplicito riferimento alla struttura del
circuito del flip flop.
BUFFER: le uscite del F/F Set Reset vengono utilizzate non solo
come pin di pura uscita in quanto pilotano gli ingressi delle nand;
una uscita che viene retroazionata per pilotare un nodo interno deve
essere descritta da un BUFFER oppure da una INOUT:
Per usare le uscite di tipo BUFFER utilizziamo la libreria standard
logic.
library ieee;
use ieee.std_logic_1164.all;
entity SR is port(
in s,r:
std_logic;
q,qn: buffer std_logic);
end SR;
architecture funz of SR is
begin
q <= qn nand s;
qn <= q nand r;
end Enzo;
7
1.3. Flip Flop
D Latch
Anche il circuito seguente viene descritto da una architecture di tipo
DATA FLOW.
library ieee;
use ieee.std_logic_1164.all;
entity ff_d is port(
din, clock: in std_logic;
q, qn: buffer std_logic);
end ff_d;
architecture enzo of ff_d is
signal s1, s2, s3: std_logic;
begin
s1<=not (din);
s2<=clock nand din;
s3<=s1 nand clock;
q<=s2 nand qn;
qn<=s3 nand q;
end enzo;
8
1.4. Flip Flop
D Latch “Behavioral”
Il Flip Flop può più comodamente essere descritto in base al suo
funzionamento, cioè al suo comportamento (“behavior” in inglese);
il listato VHDL si semplifica grandemente.
library ieee;
use ieee.std_logic_1164.all;
entity ff_d is
port
(in, clock: in std_logic;
q, qn: buffer std_logic);
end ff_d;
architecture enzo of ff_d is
begin
if clock =’1’
then q <= din; qn <= not(din);
else q <= q; qn <= qn;
--memoria
end if;
end enzo;
Occhio !!! in questo tipo di flip flop non ci sono i
trasparente quando clock è alto.
fronti, è
9
1.5. Flip Flop
J/K
“Behavioral”
Tabella di verità del Flip Flop J/K
J
K
clock
0
0
↑
0
1
↑
1
0
↑
1
1
↑
N.B. comm = commuta
Q
Qn
mem
0
1
comm
mem
1
0
comm
--Listato VHDL
library ieee;
use ieee.std_logic_1164.all;
entity ff_jk is
port
(j,k, clock: in std_logic;
q, qn: buffer std_logic);
end ff_jk;
architecture enzo of ff_jk is
begin
process (clock) begin
if (clock'event and clock ='1') then
if
(j ='1' and k ='1) then q <= qn; qn <= q;
else if (j ='0' and k ='1') then q <= '0'; qn <= '1';
else if (j ='1' and k ='0') then q <= '1'; qn <= '0';
end if;
end if;
end if;
else q <= q; qn <= qn;
end if;
end process;
end enzo;
In figura appare il risultato della simulazione dove si ha conferma
della tabella di verità:
10
Flip Flop
1.6.
D Master Slave
Anche il circuito seguente viene descritto da una architecture di tipo
DATA FLOW.
library ieee;
use ieee.std_logic_1164.all;
entity ff_d is
port
(din, clock: in std_logic;
q, qn: buffer std_logic);
end ff_d;
architecture enzo of ff_d is
signal s1, s2, s3, s4, s5, s6, s7: std_logic;
begin
s1<=not (din);
s2<=clock nand din;
s3<=s1 nand clock;
s4<=s2 nand s5;
s5<=s3 nand s4;
s6<=not(clock) nand s4;
s7<=not(clock) nand s5;
q<=s6 nand qn;
qn<=s7 nand q;
end enzo;
La posizione dei SIGNAL è abbastanza evidente, anche se non
riportata sul disegno.
11
1.7. Flip Flop
D Master Slave (“Behavioral”)
architecture enzo of ff_d is
begin
process (clock) begin
if (clock’event and clock =’0’)
then q <= din; qn <= not(din);
else q <= q; qn <= qn;--memoria
end if;
end process;
end enzo;
12
2.
Circuiti combinatori complessi
In questo paragrafo si analizza un DMX usato come line selector,
quindi con l’ingresso sempre a 0;quando en = 0 l’uscita selezionata
con gli ingressi s2,s1,s0 sarà = 0 e le altre saranno = 1; nel caso en
= ENABLE sia a
1 allora tutte le uscite saranno
= 1
(deselezionate).
Descrizione sequenziale
library ieee;
use ieee.std_logic_1164.all;
entity dmx is port(
en :
in std_logic;
s : in std_logic_vector (2 downto 0);
y:
out std_logic_vector(7downto 0));
end dmx;
architecture funz of dmx is
begin
process (en, s) begin
if en = '1' then y <= "11111111";
else
if s = "000" then y <= "11111110";
else
if s = "001" then y <= "11111101";
else
if s = "010" then y <= "11111011";
else
if s = "011" then y <= "11110111";
else
if s = "100" then y <= "11101111";
else
if s = "101" then y <= "11011111";
else
if s = "110" then y <= "10111111";
else
if s = "111" then y <= "01111111";
end if;end if;end if;end if;end if;end if;end if;end if;end if;
end process ;
end funz;
13
Il risultato della simulazione è il seguente:
Con l’espressione “descrizione sequenziale” si intende
una
descrizione in cui l’algoritmo fa uso di “righe di programma” che
hanno senso solo se eseguite in un preciso ordine, ad esempio in
questo caso con la serie degli IF; il tutto è racchiuso all’interno di un
“process” cosa che implica:
1) che l’insieme dei passi di cui è composto un processo, se pur
sequenziale come algoritmo, è da intendersi come eseguito nello
stesso istante
2) che il processo ha luogo solo quando si ha una variazione su uno
dei pin o signal elencati nella “sensitivity list” (posta tra parentesi
dopo la parola “process” e prima del begin).
Descizione concorrente
library ieee;
use ieee.std_logic_1164.all;
entity dmx_w is port(
en : in std_logic;
s : in std_logic_vector (2 downto 0);
y : out std_logic_vector(7downto 0));
end dmx_w;
14
architecture funz of dmx_w is
begin
y <= "11111110"
when (en ='0' and s = "000") else
"11111101"
when (en ='0' and s = "001") else
"11111011"
when (en ='0' and s = "010") else
"11110111"
when (en ='0' and s = "011") else
"11101111"
when (en ='0' and s = "100") else
"11011111"
when (en ='0' and s = "101") else
"10111111"
when (en ='0' and s = "110") else
"01111111"
when (en ='0' and s = "111") else
"11111111";
end funz;
In una “procedura concorrente” l’ordine degli statement all’interno
dell’algoritmo non è importante; le righe di programma potrebbero
essere tra loro scambiate. ATTENZIONE !!! questo non significa
che possa essere alterata la sintassi del comando usato, in questo
caso il comando “when ... else”.
In presenza di costrutti concorrenti non è necessario usare processi.
Assegnazione dei pin
Come passo finale dell’iter di progettazione è necessario operare il
così detto “fitting” del VHDL dentro un componente (ovviamente
programmabile). Useremo il programma WARP, in quanto Orcad
non è in grado di operare questa funzione.
Verrà generato anche un file .jed che servirà per la programmazione
fisica del componente (una PAL 22V10).
Vengono aggiunte nell’entity due righe di programma:
entity
port
(en :
s : in
y :
dmx_w is
in std_logic;
std_logic_vector (2 downto 0);
out std_logic_vector(7downto 0));
ATTRIBUTE part_name of dmx_w:ENTITY IS "C22v10";
ATTRIBUTE pin_numbers of dmx_w:ENTITY IS
"s(0):2 s(1):3 " --The spaces after 3 and 5 are necessary
& "s(2):4 en:5 "; --for concatenation (& operator)
--signal y(x) will be assined a pin by warp
end dmx_w;
15
1)
nella prima riga di programma
ATTRIBUTE part_name of dmx_w:ENTITY IS "C22v10";
Si assegna il tipo di componente, in questo caso una PAL 22V10
2)
nella seconda riga (n.b. la riga finisce dove c’è il punto e
virgola) si definiscono i pin veri e propri
ATTRIBUTE
pin_numbers
of
dmx_w:ENTITY
IS
"s(0):2 s(1):3 "
--The spaces after 3 and 5 are necessary
& "s(2):4 en:5 "; --for concatenation (& operator)
--signal y(x) will be assined pins by warp
Nel file di report generato da WARP
componente:
si ha la struttura del
Nel file di report si ha anche l’insieme delle equazioni che portano
alle uscite; nel nostro caso non si sono effettuate semplificazioni
(scelta possibile nella finestra “Generic Options”).
16
3.
Algorithmic State Machines in VHDL
Nel progetto che viene qui illustrato si vuole realizzare una ASM,
in italiano “un automa”, utilizzando il linguaggio VHDL.
Con la tecnica delle macchine a stati è assolutamente necessario
avere le idee molto chiare riguardo alla ASM che si intende
realizzare.
In questo capitolo faremo riferimento ad un contatore a due bit che
può operare in modo UP (conteggio in avanti) oppure in modo
DOWN (conteggio all’indietro); la selezione tra i due modi avviene
attraverso il pin “U” e può essere effettuata in ogni momento,
anche a conteggio in corso.
Di seguito è indicata la rappresentazione esterna, cioè la “scatola
nera”, del dispositivo desiderato (fig. 1)
Fig. 1
Tabella di funzionamento
U=1
A
B
0
0
1
1
0
1
0
1
U=0
17
Lo scorso anno (modulo 2) avete imparato a sviluppare lo schema
elettrico dell’ASM ricavando in un primo tempo le tabelle di
transizione degli stati, poi quelle di eccitazione ed infine i circuiti
che pilotavano i flip flop del tipo prescelto.
Il listato VHDL corrispondente è il seguente:
library ieee;
use ieee.std_logic_1164.all;
--------------------------------------------------------------entity macchina_a_stati is port
(u :in std_logic;
clk :in std_logic;
qa,qb : buffer std_logic);
end macchina_a_stati;
18
--ENTITY
architecture A_stati of macchina_a_stati is --ARCHITECTURE
type passaggi is (s0,s1,s2,s3);
signal s_presente , s_futuro : passaggi;
--2 dichiarazioni relative alle ASM
--
begin
process (s_presente,u) begin
case s_presente is
--in questo primo processo si stabilisce
--solo il prossimo stato
-- la lista di sensitività non prevede il clock
when s0 => qa <= '0', qb <= '0';
if (u='1') then s_futuro <= s1;
else s_futuro <= s3;
end if;
when s1 => qa <= '0', qb <= '1';
if (i='u') then s_futuro <= S2;
else s_futuro <= s0;
end if;
when s2 => qa <= '1', qb <= '0';
if (u='1') then s_futuro <= s3;
else s_futuro <= s1;
end if;
when s3 => qa <= '1', qb <= '1';
if (u='1') then s_futuro <= s0;
else s_futuro <= s2;
end if;
end case;
end process;
process (clk) begin
if (clk'event and clk = '1')
then s_presente <= s_futuro;
end if;
end process;
end A_stati;
--in questo secondo processo, attivato
--dal fronte di salita del clock, avviene il
--cambiamento di stato: lo sto futuro diventa
-- lo stato presente.
Forme d’onda attese:
19
Commenti al listato VHDL:
N.B.1) la decisione di ricorrere ad una descrizione facente uso di
STATE MACHINES si riflette nella presenza di due linee di
programma poste immediatamente dopo la dichiarazione di
Architecture e prima del begin dell’architecture stessa:
type
signal
passaggi is (s0,s1,s2,s3);
s_presente , s_futuro :
passaggi;
con la dichiarazione di type si definisce un gruppo di valori
che si chiama passaggi: implicitamente essi vengono contati ed
associati al numero adeguati di Flip Flop: nel nostro caso 2
con la dichiarazione di signal si assegnano a dei nodi
circuitali le due variabili s_presente e s_futuro che saranno due
nomi transitori per s0,s1,s2,s3
N.B.2) seconda caratteristica del programma (non legata alla
presenza di ASM) è la presenza del costrutto case:
case …. is
when ….
end case;
N.B.3)
a)
nel programma sono presenti 2 process:
il primo process (sensibile a U ed a s_presente)
il secondo process (sensibile a clk)
Nel primo viene stabilito lo stato futuro (cosa che dipende solo
dallo stato presente e dagli ingressi, che non dovrebbero cambiare
nel l’intervallo tra due fronti attivi del clock, cioè dovrebbero essere
sincroni con questo).
Nel secondo avviene il cambiamento di stato in occasione del fronte
attivo (in questo esempio di salita) del clock.
20
4.
Descrizione strutturale
Nel progetto che viene qui illustrato si vuole realizzare un flip flop
S/R a porte NAND con il linguaggio VHDL nel “dialetto”
STRUCTURAL.
Con questa tecnica descrittiva si intende rappresentare circuiti così
come appaiono in un disegno schematico, senza necessariamente
capirne il funzionamento di insieme.
E’ ovvio che senza la comprensione del funzionamento non sarà
possibile capire i risultati della simulazione.
Di seguito è dato lo schema del S/R a porte NAND (fig. 1)
Fig. 1
Nella descrizione STRUCTURAL è necessario appoggiarsi ad una
libreria esterna, dove devono essere contenuti gli elementi circuitali
usati, nel nostro caso le nand2 (NAND a 2 ingressi) cui noi, in
questo caso, assegnamo il nome di
u0 e u1.
LIBRERIA
In questo file è contenuta la descrizione del componente nand2.
Il file si chiama
nand2.vhd
e deve essere posizionato
“Simulation Resources” nella sottocartella “In Design”.
in
21
Fig. 2
LIBRARY ieee;
USE ieee.std_logic_1164.all;
PACKAGE
mio IS
COMPONENT nand2
PORT (
y : OUT std_logic;
in_a,in_b : IN std_logic);
END COMPONENT;
END mio;
------------------------------------------LIBRARY ieee;
USE ieee.std_logic_1164.all;
ENTITY nand2 IS
PORT (
in_a,in_b : IN std_logic;
--qui è importante l'ordine !!!
y : BUFFER std_logic);
--qui è importante l'ordine !!!
22
END nand2;
-----------------------------------------ARCHITECTURE testbench OF nand2 IS
BEGIN
y
<= in_a nand in_b;
END testbench;
N.B.1
in figura 2 non compare una struttura realmente esistente
sull’hard disk, bensì una struttura logica. Per inserire un file nella
cartella “In Design” si deve posizionare il cursore sopra la cartella e
ciccare sul tasto destro del mouse; comparirà ADD FILE.
N.B.2
Nel file di libreria compare un costrutto particolare:
PACKAGE pinco_pallino
COMPONENT
END COMPONENT;
END
pinco_pallino;
Le ENTITY, le PACKAGE e le ARCHITECTURE, sono tutte
unità di progetto (in particolare le package e le entity sono unità
primarie).
Le unità PACKAGE servono a rendere visibile un componente al
di fuori del file cui appartengono.
N.B. vanno ripetute (essendo unità indipendenti) le dichiarazioni
delle librerie di appoggio IEEE.
23
PROGETTO DI TIPO “STRUCTURAL”
CHE FA USO DI UNA LIBRERIA
Il file che segue si chiama S_R.vhd ed è il file principale vhd del
progetto.
LIBRARY ieee;
USE ieee.std_logic_1164.all;
ENTITY s_r IS
PORT (
q,qn : BUFFER std_logic;
s,r
: IN std_logic);
END s_r;
ARCHITECTURE
funz of s_r is
begin
u0:
u1:
nand2 port map (s,qn,q);
nand2 port map (r,q,qn);
end funz;
Come si può notare, nel file precedente compare l’espressione
PORT MAP; questa espressione “mappa i pin” del componente
nand2 (contenuto in una libreria esterna) nell’ordine in cui sono stati
scritti nell’entity contenuta nella libreria!!!
Nella nostra libreria, nell’entity di nand2, i primi 2 pin sono in_a e
in_b di INGRESSO; il terzo è y, un buffer cioè un particolare tipo
di pin di USCITA).
N.B. u0 e u1 sottolineano la rappresentazione “circuitale” di
questa variante del VHDL: esiste un “componente” u0, con i pin
mappati come vogliamo noi (vedere elenco), esiste un componente
“u1”, con i pin mappati come da elenco, etc.
24
5.
Pilotaggio motore passo - passo
Si vuole realizzare un dispositivo che piloti un motore passo passo.
Questo tipo di motore richiede che vengano attivati in una
particolare sequenza gli avvolgimenti dello statore.
Noi useremo il motore a 5V della RS siglato 440-420
Vengono di seguito fornite le caratteristiche elettriche e la tabella di
pilotaggio.
In questo caso col termine “ON” si intende
“passaggio di
corrente”, ne segue che (dato che BRowN è a +5V) si tratterà
sostanzialmente di uno “0”. Questi valori attivi bassi verranno forniti
da dei BJT NPN BC317 (configurazione Emettitore Comune) che
dovranno essere pilotati con degli stati alti sulla base, quindi il
dispositivo sotto progetto genererà degli “1” in corrispondenza
degli “ON”.
25
Il circuito che si intende realizzare prevederà quindi un componente
programmabile PAL/PLD che piloterà dei BJT (che costituiranno il
così detto “stadio di potenza”) che infine forniranno la necessaria
corrente al motore.
N.B. I buffer che compaiono in figura sono necessari in quanto le
uscite della PAL 22V10 non sono in grado di pilotare i BJT.
26
In figura è fornito il DIAGRAMMA DEGLI STATI
NB qa = colore bianco qc = colore rosso
qb = colore blu qd = colore giallo
S = stop, attivo alto, il motore si ferma
A = 1, avanti A = 0, indietro (il motore gira in senso inverso)
Fig. 1
ASM
realizzazione con VHDL
library ieee;
use ieee.std_logic_1164.all;
entity pilotaggio is port (
a,s,clock: in std_logic;
bianco,blu,rosso,giallo: inout std_logic);
end pilotaggio;
27
architecture pilotaggio2 of pilotaggio is
type stati_usati is(s0,s1,s2,s3);
signal stato_presente, stato_futuro: stati_usati;
begin
process (stato_presente,a,s) begin
case stato_presente is
when s0=>bianco<='1'; blu<='1'; rosso<='0'; giallo<='0';
if (s='1' ) then stato_futuro<=s0;
--memoria = fermo
else if (a='1') then stato_futuro<=s1; --avanti
else stato_futuro<=s3;
--indietro
end if;
end if;
when s1=>bianco<='0'; blu<='1'; rosso<='1'; giallo<='0';
if (s='1') then stato_futuro<=s1;
else if (a='1') then stato_futuro<=s2;
else
stato_futuro<=s0;
end if;
end if;
when s2=>bianco<='0'; blu<='0'; rosso<='1'; giallo<='1';
if (s='1') then stato_futuro<=s2;
else if (a='1') then stato_futuro<=s3;
else stato_futuro<=s1;
end if;
end if;
when s3=>bianco<='1'; blu<='0'; rosso<='0'; giallo<='1';
if (s='1') then stato_futuro<=s3;
else if (a='1' ) then stato_futuro<=s0;
else stato_futuro<=s2;
end if;
end if;
end case;
end process;
if (clock'event and clock ='1') then
stato_presente <= stato_futuro;
end if;
end process;
end pilotaggio2;
28
Le forme d'onda in uscita sono riportate in figura: trattandosi di
una simulazione sotto Express non compaiono ritardi tra il fronte
attivo del clock (in questo caso di salita) e le var iazioni delle uscite.
Eseguita la simulazione sotto Express, si passa quindi al “FITTING”
in un PLD!
Fitting sta ad indicare l’insieme di procedure che portano il nostro
circuito descritto in VHDL ad essere compilato in funzione di un
particolare Dispositivo Logico Programmabile (PLD in inglese),
nuovamente simulato ed infine fisicamente realizzato tramite un
programmatore di PAL/PLD (disponendo di un file JED).
Il programma che permette la portabilità verso una PAL è WARP.
La PAL / PLD è la 22V10.
Nella fase di compilazione i punti critici sono i seguenti:
1) nel menu device si devono seguire i campi indicati in figura; il
campo critico è l’OUTPUT che deve essere di tipo JEDEC normale
per il programmatore di fascia bassa che abbiamo in E5.
29
2) In fase di ottimizzazione si deve scegliere “none” per evitare
“spifferi di circa 1 ns come appare in figura:
30
Ecco come appare la simulazione (sotto NOVA) qualora si eviti
ogni ottimizzazione (opzione “none”).
31
Al termine della compilazione si ha a disposizione un file JED ed
anche un file di report (nome_nostro.rpt) che contine, verso la fine
anche la piedinatura della nostra PAL/PLD.
32
ASM:
realizzazione a componenti discreti
Il medesimo dispositivo può essere realizzato con il metodo classico
di progettazione che prevede la stesura della tabella di transizione
degli stati e della tabella di eccitazione dei f/f, la progettazione dei
circuiti di pilotaggio dei f/f ed infine la progettazione dei circuiti di
uscita (programma di modulo 2).
Passo 1) : si disegna il “diagramma” dell’automa/ASM, vedi fig, 1
Passo 2) : si stende la tabella di transizione degli stati; si noti bene
che ad ogni stato sono riservate tante righe quante sono le possibili
combinazioni degli ingressi; ognuna di queste combinazioni
rappresenta un if ed è rappresentata da una freccia nel diagramma
degli stati.
Stato
presente
S0
S0
S0
S0
S1
S1
S1
S1
S2
S2
S2
S2
S3
S3
S3
S3
Ingressi
SA
0
0
1
1
0
0
1
1
0
0
1
1
0
0
1
1
0
1
0
1
0
1
0
1
0
1
0
1
0
1
0
1
Stato
futuro
S3
S1
S0
S0
S0
S2
S1
S1
S1
S3
S2
S2
S2
S0
S3
S3
A questo punto si deve associare al singolo stato un valore, a
piacere, univoco, binario, che a livello hardware sostituirà il nome
“umano” S0, S1 etc.
Normalmente si usano gli interi nel loro ordine naturale.
33
Questo valore binario si troverà in uscita ai f/f di stato X,Y, etc.
Passo 3) : si stende la tabella di eccitazione.
La tabella, pensata per dei f/f J/K, è la seguente:
Stato
presente
Xt Yt
0
0
0
0
0
0
0
0
1
1
1
1
1
1
1
1
0
0
0
0
1
1
1
1
0
0
0
0
1
1
1
1
Ingressi
S
0
0
1
1
0
0
1
1
0
0
1
1
0
0
1
1
Stato futuro
X t +1 Y t +1
A
0
1
0
1
0
1
0
1
0
1
0
1
0
1
0
1
1
0
0
0
0
1
0
0
0
1
1
1
1
0
1
1
1
1
0
0
0
0
1
1
1
1
0
0
0
0
1
1
1
0
0
0
0
1
0
0
X
X
X
X
X
X
X
X
J flip flop X
X t _Yt
S_A
1
0
X
X
J x = S ⋅ A ⋅Y + S ⋅ A ⋅Y
34
0
1
X
X
Jy Ky
Jx Kx
0
0
X
X
0
0
X
X
X
X
X
X
X
X
X
X
1
0
0
0
0
1
0
0
1
1
0
0
X
X
X
X
1
1
0
0
X
X
X
X
X
X
X
X
1
1
0
0
X
X
X
X
1
1
0
0
K flip flop X
X t _Yt
S_A
X
X
0
1
X
X
1
0
X
X
0
0
X
X
0
0
1
X
X
1
0
X
X
0
0
X
X
0
X
1
1
X
X
0
0
X
X
0
0
X
K x = S ⋅ A ⋅Y + S ⋅ A ⋅Y
J flip flop Y
X t _Yt
S_A
1
X
X
1
Jy = S
K flip flop Y
X t _Yt
S_A
X
1
1
X
Ky = S
Di seguito è riportato il circuito complessivo del solo automa:
35
Xt
Yt
Nel circuito finale gli stati al tempo t sono fisicamente rappresentati
dai valori delle uscite dei flip flop e sono una rappresentazione
binaria dei “nomi umani” S0, s1, etc.
Lo stato futuro sarà determinato dal valore degli ingressi e dallo stato
in cui la macchina si trova (cioè dal valore di Xt e Yt).
I pin J e K saranno pilotati da dei circuiti combinatori che avranno
come ingresso gli stati al tempo t e gli ingressi.
Il pin di clock esiste e non viene mai citato, ovviamente le
transizioni avverranno in concomitanza al presentarsi del fronte di
clock attivo.
L’andamento delle uscite dei soli f/f è dato in figura (si tratta di un
contatore a due bit, UP/DOWN, con STOP):
36
In questa pagina sono illustrati i circuiti combinatori presenti nel
sistema:
Circuito X_pilotaggio
Circuito Y_pilotaggio
.
Circuito decodifica (uscite)
37
L’andamento complessivo del circuito è dato dalle forme d’onda
mostrate nella fig. seguente; si noti che il fronte attivo è quello di
discesa e che sono considerati i ritardi dei componenti utilizzati; ne
segue che i f/f di stato e le uscite non cambiano valore
istantaneamente al fronte di discesa, ma successivamente.
In questa figura compaiono i nomi “interni” a Express per le uscite
dei due flip flop di stato: n00848 corrisponde a Xt, n00863
corrisponde a Yt.
38
39
40