Introduzione al VHDL Lezione 3 - unimi.it• Il VHDL supporta istruzioni sequenziali all’interno...

Introduzione al VHDLLezione 3

Cristina Silvano

Università degli Studi di MilanoDipartimento di Scienze dell’InformazioneVia Comelico 39/41, I-20135 Milano (Italy)

Tel.: +39-2-5835-6306 e-mail: [email protected]

3/7/01 Cristina Silvano – Università degli Studi di Milano 2

Istruzioni Concorrenti e Sequenziali• Un modello VHDL è costituito da un insieme di:

• ISTRUZIONI CONCORRENTI

• ISTRUZIONI SEQUENZIALI.

• Il VHDL supporta il concetto di concorrenza anche attraverso il concetto di processi multipli che interagiscono in parallelo.

• Concetto di PROCESSO: Ogni processo esegue al suo interno istruzioni SEQUENZIALI . Un modello VHDL è un insieme di PROCESSI che interagiscono tra loro in parallelo (CONCORRENZA TRA PROCESSI ) e che si scambiano informazioni tramite i SEGNALI.

• Esempio di processo:OR: process (A, B)

begin

if (A = ‘1’ or B = '1‘) then

Z <= ‘1’;

else

Z <= ‘0’;

end if;

end process OR;

sensitivity list

sequential statements

label


Concorrenza tra Processi• Le istruzioni presenti all’interno di u processo sono eseguite in

sequenza, mentre processi multipli interagiscono in modalità concorrente.

• Un processo viene eseguito quando avviene un EVENTO nella sua SENSITIVITY LIST. L’esecuzione di un processo causa uno o più eventi alle sue uscite. Tali eventi posso attivare altri processi, ecc.


• All’interno di un’architettura possono essere presenti processi multipli concorrenti e istruzioni concorrenti: ad esempioarchitecture A of ENTITY is

begin

-- concurrent statements

P1: process (sensitivity list of signals)

begin

-- sequential statements;

end process P1;


P2: process (sensitivity list of signals)

begin

-- sequential statements

end process P2;


end A;

Processi Multipli Concorrenti e Istruzioni Concorrenti


Processi Multipli Concorrenti e Istruzioni Concorrenti

��

VLJVLJQQDOVDOV

VLJVLJQQDOVDOV VLJVLJQQDOVDOV


Istruzioni Concorrenti

• Eseguite in parallelo nello stesso istante di tempo.

• Il loro comportamento è indipendente dall’ordine con il quale sono scritte nel codice VHDL.

• Esempio: ISTRUZIONI DI ASSEGNAMENTO DEI SEGNALI:

X <= A and B;

Z <= C and X;

oppure

Z <= C and X;

X <= A and B;

• La struttura hardware corrispondente è intrinsecamente concorrentee composta dall’interconnessione di componenti elementari.

• Le attività sono svolte in parallelo dai diversi componenti.

A

B

C

Z

X


Istruzioni Sequenziali

• Il VHDL supporta istruzioni sequenziali all’interno di un processo.


• Eseguite in sequenza (una alla volta)

• Il loro comportamento dipende dall’ordine con il quale sono state scritte nel codice VHDL

• Esempio: un processo contiene istruzioni sequenziali (IF, CASE, …):

MUX: process (A, B, SEL)

begin

if (SEL = '1‘) then

Z <= A;

else

Z <= B;

end if;

end process MUX;

Istruzioni Sequenziali

sensitivity list


Costrutti di Controllo del Codice Sequenziale

• Controllo Condizionato:• Istruzioni IF

• Istruzione CASE

• Controllo Iterativo:• Istruzione LOOP


• Consente il controllo condizionato di istruzioni sequenziali basato sulla valutazione di un valore booleano.

• Formato:if CONDITION then


end if;

• Esempio:if (A = ’1’) then

COUNT := COUNT + 1;

end if;

• L’istruzione IF verifica una condizione ed esegue diverse istruzioni in base al risultato.

Istruzione IF


• Consente il controllo condizionato di due gruppi di istruzioni sequenziali basato sulla valutazione di una singola condizione.

• Formato:if CONDITION then


else

-- sequential_statements

end if;

• Esempio:if A = ’1’ then

ONES_COUNT := ONES_COUNT + 1;

else

OTHERS_COUNT := OTHERS_COUNT + 1;

end if;

Costrutto IF-ELSE


• Consente il controllo condizionato di alternative multiple basato sulla valutazione di condizioni multiple.

• Formato:if CONDITION_1 then


elsif CONDITION_2 then


else


end if

• In presenza di IF annidati viene eseguita la serie di istruzionisequenziali corrispondenti alla prima condizione che risulti vera⇒ Importante l’ordine di scrittura delle condizioni ⇒ PRIORITÀ

• Più di una condizione può risultare vera ⇒ viene eseguita la prima condizione che risulta vera.

Costrutto ELSIF


Esempio di Costrutto ELSIF

• Esempio:if A = ’1’ then

ONES_COUNT := ONES_COUNT + 1;

elsif A = ’0’ then

ZEROS_ COUNT := ZEROS_ COUNT + 1;

else

OTHERS_COUNT := OTHERS_COUNT + 1;

end if;


• Consente il controllo dell’esecuzione di istruzioni sequenziali basato sulla valutazione del valore assunto da un oggetto.

• Formato:case OBJECT is

when VALUE_1 => seq_statements;


-- etc...

end case;

• Esempio:case OP_CODE is

when ’0’ => OUT_1 <= IN_1;

when ’1’ => OUT_1 <= IN_0;

when others => null;

end case;

Istruzione CASE


• I possibili valori di un oggetto devono essere specificati solo una volta.

• Tutti i possibili valori dell’oggetto devono essere previsti• Esplicitamente

• Oppure attraverso la clausola when others

• L’oggetto può essere sostituito a un’espressione (ad esempio A and B) che può assumere valori costanti.

• Esempio:case EXPRESSION is



end case;

Istruzione CASE


• Esempio di processo contenente il costrutto CASE:process (A, B, C, X)

begin

case X is

when 0 to 4 =>

Z <= B;

when 5 =>

Z <= C;

when 7 | 9 =>

Z <= A;

when others =>

Z <= 0;

end case;

end process;

Esempio di Istruzione CASE

range

list


• Consente l’esecuzione ripetuta di una sequenza di istruzioni.

• Formato:[LOOP_label:] [iteration scheme] loop


end loop [LOOP_label];

iteration_scheme ::= while condition | for LOOP_parameter_specification

LOOP_parameter_specification ::= identifier in discrete_range

• Esempi:while (DAY = WEEK_DAY) loop

DAY := GET_NEXT_DAY(DAY);

end loop;

for I in 1 to 10 loop

I_SQUARED(I) := I * I;

end loop;

Istruzione FOR-LOOP


• Esempio:for I in 0 to 3 loop

-- statements

end loop;

• Esempio:entity EX is

port (A : in std_ulogic_vector (0 to 15);SEL : in integer range 0 to 15;

Z : out std_ulogic);end EX;

architecture RTL of EX isbegin

WHAT: process (A, SEL)begin

for I in 0 to 15 loopif SEL = I then

Z <= A(I);

end if;end loop;

end process WHAT;end RTL;

Esempi di Istruzione FOR-LOOP

fixed number of iterations


• Esempio:entity PAR_GEN isport (A : in std_ulogic_vector (3 downto 0);

PAR: out std_ulogic);end PAR_GEN;

architecture ARC of PAR_GEN isbegin

P1: process (A)variable TMP: std_ulogic;

beginTMP := ‘0’;

for I in A’low to A’high loop

TMP := TMP xor A(I);end loop;

PAR <= TMP;end process P1;

end ARC;

Esempio di Istruzione FOR-LOOP


Processo Combinatorio

process (sensitivity_list_of_inputs)

begin

-- default assignments;

-- combinatorial logic assignments;

end process;

INPUTS OUTPUTS


Esempio di Processo Combinatorio

MUX: process (A, B, SEL)

begin

if (SEL = '1‘) then

Z <= A;

else

Z <= B;

end if;

end process MUX;

A ZBSEL


Codice Sorgente di un Registro (1)

entity FLOP is

port (D, CLK : in std_ulogic;

Q : out std_ulogic);

end FLOP;

architecture A of FLOP is

begin

process

begin

wait until (CLK'event and CLK='1‘);

Q <= D;

end process;

end A;

D

CLK

Q


Codice Sorgente di un Registro (2)

entity FLOP is

port (D, CLK : in std_ulogic;


end FLOP;

architecture B of FLOP is

begin

process (CLK)

begin

if (CLK'event and CLK='1') then

Q <= D;

end if; -- no else clause

end process;

end B;

D

CLK

Q


Codice Sorgente di un Registro con Reset Asincrono

entity FLOP is

port (D, CLK, RST : in std_ulogic;


end FLOP;

architecture A of FLOP is

begin

process (CLK, RST)

begin

if (RST = '1’) then

Q <= 0;

elsif (CLK'event and CLK='1') then

Q <= D;


end process;

end A;

D

CLK

QRST


Descrizione RTL: Processo con Clock (1)

process -- clocked process with no reset

begin

wait until (CLK’event and CLK = ‘1’);

Q <= A + B;

-- all combinatorial logic assignments here;

end process;

AD

CLK

QB

first and only


Descrizione RTL: Processo con Clock (2)

process (CLK) --clocked process with no reset

begin

if (CLK’event and CLK = ‘1’) then

Q <= A + B;



end process;

AD

CLK

QB

first and only


Descrizione RTL: Processo con Clock e Reset Asincrono

process (CLK, RST) – clocked process with asynch. reset

begin

if (RST = ‘1’) then

Q <= 0;

elsif (CLK’event and CLK = ‘1’) then

Q <= A + B;



end process;

AD

CLK

QB

RST

first and only


Descrizione RTL: Esempio di Processo con Clock (1)

process

begin


X <= A + B;

Y <= C + D;

Z <= X + Y;

end process;

A

CLK

XB

CLK

ZYC

D


Descrizione RTL: Esempio di Processo con Clock (1)

process

begin


Z <= (A * B) + ( C * D)

end process;

CLK

A[0÷31]

*B[0÷31]

C[0÷31]

*D[0÷31]

+ Z [0÷31]


Latch Trasparente (Level Sensitive)

entity LATCH is

Port ( EN, D : in std_ulogic;

Q: out std_ulogic);

end LATCH;

architecture A of LATCH is

begin

process (EN, D)

begin

if (EN = ‘1’) then

Q <= D;

end if;

end process;

end A;

D

EN Q


Modalità per NON inserire Latch Trasparenti

process (A, B, COND)

begin

X <= ‘0’; -- default assignment

Y <= ‘1’; -- default assignment

if (COND) then

X <= A;

Y <= B;

end if;

end process;


Macchina a Stati Finiti (FSM) – Tipo Moore

IN

CLK

RST OUT

INNEXT_STATE

CLK

CURRENT_STATE

RST

NEXTSTATELOGIC

OUTPUTLOGIC

OUT


FSM – Tipo Moore

IDLE0

ST2

ST1

…

…

1…

1

0

1

…

…

RST


Codice Sorgente (1) di FSM – Tipo Moore

entity FSM is

port ( RST, CLK, IN : in bit;OUT : out bit);

end FSM;architecture MOORE of FSM is

type STATE_TYPE is (IDLE, ST1, ST2, …);signal CURRENT_STATE, NEXT_STATE : STATE_TYPE;

begin---------------------------------- Processo sequenziale--------------------------------

SEQ: process (CLK, RST)begin

if RST = '1' thenCURRENT_STATE <= IDLE;

elsif (CLK'event and CLK = '1') thenCURRENT_STATE <= NEXT_STATE;

end if;end process SEQ;


-------------------------------------------------------------- Processo Combinatorio per Next State Logic------------------------------------------------------------

COMB: process (CURRENT_STATE, IN)begin

case CURRENT_STATE iswhen IDLE =>

if (IN=‘1’) thenNEXT_STATE <= ST1;

elseNEXT_STATE <= ST2;

end if;when ST1 =>

if (…) thenNEXT_STATE <= …;

elseNEXT_STATE <= ..;

end if;when … =>

if (…) thenNEXT_STATE <= …;

elseNEXT_STATE <= …;

end if;end case;

end process COMB;

Codice Sorgente (1) di FSM – Tipo Moore (cont.)


Codice Sorgente (1) di FSM – Tipo Moore (cont.)------------------------------------------- Processo Combinatorio per Output Logic-----------------------------------------

OUT_LOGIC: process (CURRENT_STATE)begin


OUT <= ‘1’;when ST1 =>

OUT <= ‘0’;when … =>

OUT<= …;end case;

end process OUT_LOGIC;end MOORE;


Codice Sorgente (2) di FSM – Tipo Moore

entity FSM is

port ( RST, CLK, IN : in bit;OUT : out bit);

end FSM;architecture MOORE of FSM is

type STATE_TYPE is (IDLE, ST1, ST2, …);signal CURRENT_STATE, NEXT_STATE : STATE_TYPE;



if RST = '1' thenCURRENT_STATE <= IDLE;




Codice Sorgente (2) di FSM – Tipo Moore (cont.)---------------------------------------------------------------- Processo Combinatorio per Next State Logic e Output Logic--------------------------------------------------------------

COMB_OUT:process (CURRENT_STATE, IN)begin


OUT <= ‘1’;if (IN=‘1’) then

NEXT_STATE <= ST1;else

NEXT_STATE <= ST2;end if;

when ST1 =>OUT <= ‘0’;if (…) then

NEXT_STATE <= …;else

NEXT_STATE <= …;end if;

when … =>…

end case;end process COMB_OUT;

end MOORE;


Esempio: FSM_1 – Tipo Moore

ST2 01,-0

ST3

ST4 ST1

00

10,-1 0-

1-

11

11

01,-0

11

00

01

10

RST

10ST2ST2ST3ST3ST4

01ST4ST4ST4ST3ST3

11ST3ST1ST3ST3ST2

00ST2ST1ST2ST2ST1

Y_OUT10110100

CMD_IN[0÷1]

CLK

RST Y_OUT[0÷1]

FSM_1


Codice Sorgente (1) di FSM_1 – Tipo Moore

entity FSM_1 isport ( RST, CLK : in bit;

CMD_IN : in bit_vector (0 to 1);Y_OUT : out bit_vector (0 to 1));

end FSM2;architecture MOORE of FSM_1 is

type STATE_TYPE is ( ST1, ST2, ST3, ST4);signal CURRENT_STATE, NEXT_STATE : STATE_TYPE;



if RST = '1' thenCURRENT_STATE <= ST1;




Codice Sorgente (1) di FSM_1 - Tipo Moore (cont.)-------------------------------------------------------------- Processo Combinatorio per Next State Logic------------------------------------------------------------

COMB: process (current_state,CMD_IN)begin

case CURRENT_STATE iswhen ST1 =>

if (CMD_IN="00" or CMD_IN="01" or CMD_IN="10") thenNEXT_STATE <= ST2;


end if;when ST2 =>



end if;when ST3 =>



end if;


when ST4 =>if ( CMD_IN="00" or CMD_IN="01") then

NEXT_STATE <= ST3;else

NEXT_STATE <= ST2;end if;

end case;end process COMB;

------------------------------------------- Processo Combinatorio per Output Logic-----------------------------------------

OUT_LOGIC: process (CURRENT_STATE)begin

case CURRENT_STATE iswhen ST1 =>

Y_OUT <= "00";when ST2 =>



Y_OUT<= "10";end case;

end process OUT_LOGIC;end MOORE;

Codice Sorgente (1) di FSM_1 – Tipo Moore (cont.)


Esempio: FSM_A – Tipo Moore

1

0

S11

S2

S3S0

0

1

0

0

1

0

1

0

1

0S1S3S3

1S3S2S2

1S2S0S1

0S2S0S0

ZX = 1X = 0

X

CLK

Z

FSM_A


Codice Sorgente (2) di FSM_A – Tipo Moore

entity FSM_A is

port ( X, CLK : in bit;Z: out bit);

end FSM_A;architecture MOORE of FSM_A is

type STATE_TYPE is ( S0, S1, S2, S3);signal CURRENT_STATE, NEXT_STATE : STATE_TYPE;

beginSEQ: processbegin

wait until(CLK'event and CLK = '1');CURRENT_STATE <= NEXT_STATE;

end process SEQ;

COMB_OUT:process (CURRENT_STATE, X)begin

case CURRENT_STATE iswhen S0 =>

Z <= ‘0’;if (X = ‘0’) then

NEXT_STATE <= S0;else

NEXT_STATE <= S2;end if;


Codice Sorgente (2) di FSM_A – Tipo Moore (cont.)when S1 =>

Z <= ‘1’;if (X = ‘0’) then



when S2 =>Z <= ‘1’;if (X = ‘0’) then



when S3 =>Z <= ‘0’;if (X = ‘0’) then



end case;end process COMB_OUT;

end MOORE;


Macchina a Stati Finiti (FSM) – Tipo Mealy

CLK

IN

NEXT_STATE

CURRENT_STATERST

NEXT STATELOGIC and OUTPUT LOGIC OUT

IN

CLK

RST OUT


Esempio: FSM_B – Tipo Mealy

1/0

0/0

STA1/0

STC

STDSTB

0/1

1/1

0/0

0/0

1/0

X

CLK

Z

STA / 1STD / 0STD

STD / 0STC / 1STC

STD / 0STB / 0STB

STC / 0STB / 0STA

X = 1X = 0


Codice Sorgente di FSM_B – Tipo Mealyentity FSM_B is

port ( X, CLK : in bit;Z: out bit);

end FSM_B;architecture MEALY of FSM_B is

type STATE_TYPE is ( STA, STB, STC, STD);signal CURRENT_STATE, NEXT_STATE : STATE_TYPE;

beginSEQ: processbegin

wait until(CLK'event and CLK = '1');CURRENT_STATE <= NEXT_STATE;

end process SEQ;

COMB_OUT:process (CURRENT_STATE, X)begin

case CURRENT_STATE iswhen STA =>

if (X = ‘0’) thenZ <= ‘0’;NEXT_STATE <= STB;

elseZ <= ‘0’;NEXT_STATE <= STC;

end if;


when STB =>if (X = ‘0’) then

Z <= ‘0’;NEXT_STATE <= STB;

elseZ <= ‘0’;NEXT_STATE <= STD;

end if;when STC =>

if (X = ‘0’) thenZ <= ‘1’;NEXT_STATE <= STC;

elseZ <= ‘0’;NEXT_STATE <= STD;

end if;when STD =>

if (X = ‘0’) thenZ <= ‘0’;NEXT_STATE <= STD;

elseZ <= ‘1’;NEXT_STATE <= STA;

end if;end case;

end process COMB_OUT;end MEALY;

Codice Sorgente di una FSM_B – Tipo Mealy (cont.)

Introduzione al VHDL Lezione 3 - unimi.it• Il VHDL supporta istruzioni sequenziali all’interno...

Documents

Transcript of Introduzione al VHDL Lezione 3 - unimi.it• Il VHDL supporta istruzioni sequenziali all’interno...