DEIS

Dipartimento di Elettronica Informatica e Sistemistica

Universita di Bologna

Introduzione al
linguaggio VHDL
PARTE I

Stefano Mattoccia
e-mail: smattoccia@deis.unibo.it
Telefono: +39 051 2093860

Bologna, 4 marzo 2004

Il VHDL e un linguaggio per la sintesi

automatica e la simulazione di circuiti
digitali
VHDL: VHSIC Hardware Description Language
VHSIC: Very High Speed Integrated Circuit

Standardizzato nel 1993 (IEEE Standard 1076-1993)

Libri
Zainalabedin Navabi, VHDL: Analysis and modelling of
digital systems (2nd Ed), McGraw-Hill 1998
Douglas Perry, VHDL - Third Edition, McGraw-Hill 1998
Kevin Skahill, VHDL for Programmable Logic, Addison-Wesley
Internet
Sito di Reti Logiche L-A Cesena, www.ingce.unibo.it
http://www.fpga.com.cn/hdl/training/vhdl_intr.pdf
http://www.ee.pdx.edu/~mperkows/CLASS_VHDL_99/005.pdf
.
Dispense corso Reti Logiche
Introduzione alle esercitazioni di laboratorio
www.ingce.unibo.it/corsi_di_laurea/piano_studi/programma_didattico_01_02/reti_logiche/IndiceMateriale.htm

Software
Altera Max Plus (versione 10)
www.altera.com
www.ingce.unibo.it/corsi_di_laurea/piano_studi/programma_didattico_01_02/reti_logiche/IndiceMateriale.htmd

Schema logico

Design Entry
Sintesi (Compilazione)

Simulazione

NO

Funzionamento
previsto?

SI
Trasferimento al Chip
(Target FPGA)

Descrizione
Testuale
(VHDL)

Strutturale
Structural

(Blocchi interconnessi)

Comportamentale
Behavioural

Nella rappresentazione comportamentale (Behavioural) un componente

viene descritto mediante il suo comportamento ingresso-uscita.
Si descrive come dovra rispondere la rete ma non la sua struttura.
I0

Z<=1 se gli ingressi

I1 e I0 sono diversi;

I1

Nella rappresentazione strutturale (Structural) un componente e

descritto connettendo tra loro pi blocchi. Lapproccio e basato su
un linguaggio testuale (VHDL) ma risulta concettualmente analogo al
design-entry mediante schema logico.

Esempio: Decoder

Effettuando il design entry

mediante schema logico ed
effettuando la simulazione si
perviene alle seguenti forme
donda.

Una possibile codifica in VHDL della rete combinatoria dellesempio

potrebbe essere la seguente:

-- Possibile codifica VHDL del decoder

LIBRARY ieee;
USE ieee.std_logic_1164.all;
ENTITY decoder_vhdl IS
PORT (a, b
: IN BIT;
u0,u1,u2,u3 : OUT BIT);
END decoder_vhdl;
ARCHITECTURE arch_decoder_vhdl OF decoder_vhdl IS
BEGIN
-- attivazione (concorrente) dei segnali
-- non e importante lordine
u3 <= (a AND b) ;
u2 <= ((NOT a) AND b);
u1 <= (a AND (NOT b));
u0 <= ((NOT a) AND (NOT b));
END arch_ decoder_vhdl;

Come risulta dal confronto tra le due simulazioni, ottenute

rispettivamente dal design entry mediante schema logico e mediante
VHDL, i due approcci sono equivalenti,
Simulazione: codice VHDL

Simulazione: schema logico

Elementi che caratterizzano

il linguaggio VHDL
Il VHDL essendo un linguaggio di programmazione per la descrizione
dellHARDWARE presenta delle sostanziali differenze rispetto ai
linguaggi di programmazione standard (i.e. C, Java, Pascal).
In particolare vi sono due caratteristiche che differenziano il VHDL
rispetto ai linguaggi di programmazione convenzionali:

Timing

Concurrency

La capacit di poter gestire i tempi di

propagazione dei segnali allinterno
dei circuiti digitali

La capacit di simulare lo svolgimento di

pi operazioni contemporanee, tipica dei
dispositivi Hardware

Timing & Concurrency

La propagazione dei segnali tra i vari componenti che compongono un un
circuito digitale avviene attraverso fili o bus.
Nella realt la propagazione dei segnali non avviene istantaneamente
perch ritardata dalle caratteristiche fisiche delle connessioni
(fenomeni parassiti). Si consideri ad esempio la seguente rete logica

Rete ideale

Volendo descrivere come si propaga il segnale dal punto x verso a

e b con un linguaggio di programmazione ad alto livello (ad
esempio il C) si potrebbe scrivere:
a:=x;

/* assegna x ad a */

b:=x;

/* assegna x a b */

Prima osservazione (PROBLEMA DI TIMING):

La rappresentazione attraverso le due assegnazioni del lucido
precedente non contempla i ritardi di propagazione del segnale che
in realt ci sono. La rete seguente evidenzia le capacit parassite
associate ai due tratti della connessione tra il gate di ingresso e
i due gate in uscita (lungo percorsi da x a a da x a b) Queste
capacit determinano il ritardo di propagazione del segnale.

Rete reale con capacit

parassite che impongono
la variazione dei segnali
a e b in ritardo rispetto
alla variazione di x

Seconda osservazione (PROBLEMA DI CONCURRENCY):

Solitamente i linguaggi di programmazione prevedono che due
istruzioni di assegnazione vengano eseguite nella sequenza in cui
compaiono nel programma.Nella realt il segnale elettrico parte da
x e si propaga contemporaneamente verso a e b (non prima su a e poi
su b come avverrebbe con il codice della pagina precedente scritto
in C).

Il VHDL, essendo orientato allhardware deve essere in grado di

descrivere sia il TIMING sia la CONCURRENCY dei segnali:
(TIMING) rendendo possibile la gestione dei ritardi con cui si
propagano i segnali digitali allinterno della rete
(CONCURRENCY) Eseguendo pi istruzioni (processi) contemporaneamente

Considerando la rete dellesempio precedente. Se ogni capacit

introduce un ritardo pari a 1 unit_delay () il codice VHDL che
sintetizza il funzionamento reale della rete potrebbe essere il
seguente:
a<=x AFTER 4*unit_delay
b<=x AFTER 3*unit_delay

Da un punto di vista logico le 2 istruzioni

sono eseguite contemporaneamente
in VHDL (esecuzione concorrente)

x
t
a
b

CONCURRENCY
Quando un programmatore sviluppa del codice con un linguaggio ad
alto livello (i.e. C, Java, Pascal) immagina di scomporre il
problema in una serie di istruzioni che saranno eseguite in modo
sequenziale. PARADIGMA DI PROGRAMMAZIONE SEQUENZIALE.
Al contrario, un progettista hardware decompone il progetto in
blocchi interconnessi che reagiscono ad eventi e generano eventi.
Gli eventi sono le transizioni dei segnali: ogni transizione di un
ingresso, di unuscita o del clock un evento. Ogni evento impone
che tutti i blocchi dipendenti da tale evento vengano valutati.
Lordine in cui vengono valutati i blocchi deve essere ininfluente
sul risultato finale(cioe, qualunque sia lordine di valutazione
delle espressioni associate ai singoli blocchi, lo stato
complessivo raggiunto dalla rete quando tutti gli eventi sono
stati gestiti deve essere sempre il medesimo). Il tipo di
programmazione che consente di modellare questo tipo di
funzionamento e il PARADIGMA DI PROGRAMMAZIONE PARALLELA: infatti
visto che il risultato dellelaborazione deve essere indipendente
dalla sequenza in cui le istruzioni sono state eseguite, allora
possiamo concludere che tutte le istruzioni possono anche essere
eseguite in parallelo,senza che mai una istruzione, per essere
eseguita, debba attendere il completamento di unaltra.

Ad esempio, si pensi ad una rete combinatoria di tipo SP.

Il programmma che descrive questa rete deve generare un risultato
(uscita di ciascun gate) che dipende solo dal valore degli ingressi e
non dallordine con il quale vengono valutati gli and e lor.
Le istruzioni che descrivono i blocchi possono essere codificate
secondo il paradigma della programmazione parallela

T1 <=

A AND B;

T2 <=

C AND D;

TN <=

E AND F;

U <= T1 OR T2 OR T3;

U <= T1 OR T2 OR T3;

Equivalenti

T1 <=

A AND B;

T2 <=

C AND D;

TN <=

E AND F;

Oggetti definiti in VHDL

Oggetto VHDL: entit alla quale e associato un valore
Sono definite 4 classi di oggetti:

Segnali

Variabili

Costanti

Files

Rappresentano connessioni hardware ( input, output, etc).

Ad ogni segnale associata una evoluzione temporale.
Le assegnazioni sono effettuate mediante loperatore <=.

Non hanno alcun significato hardware. Sono utilizzate per

memorizzare valori temporanei. Le variabili possono essere
dichiarate, o avere valori assegnati, solo allinterno di
blocchi sequenziali del codice VHDL. Il simbolo di
assegnamento :=
Rappresentano valori costanti di un determinato tipo. Il
loro valore non pu essere cambiato. Attraverso lo
statement GENERIC il VHDL dispone di un meccanismo per
passare parametri non hardware (es ritardi) di un
componente.
Oggetti che possono essere dichiarati ed utilizzati sia in
blocchi concorrenti che in blocchi sequenziali.

Data types
Nel linguaggio VHDL (Standard Package) sono predefiniti i
seguenti tipi di dato:
BIT

(0,1)

BIT_VECTOR
BOOLEAN (TRUE,FALSE)
INTEGER
REAL
TIME

Oltre ai tipi predefiniti e possibile utilizzarne altri

disponendo di specifiche librerie (es LIBRARY IEEE).

E possibile definire dei vettori di bit utilizzando il tipo di

dato BIT_VECTOR...

Formalismo scalare
a3
PORT ( a3,a2,a1,a0 : IN BIT;
y1,y0 : OUT BIT);

y1

a2
ENTITY

a1
a0

y0

MSB

Formalismo vettoriale (bus)

Y[1..0]

A[3..0]
PORT ( a : IN BIT_VECTOR(3 DOWNTO 0);
y : OUT BIT_VECTOR(1 DOWNTO 0));

LSB

ENTITY

In VHDL gli elementi dei vettori possono essere referenziati attraverso gli
indici.
Ad esempio:

y(2) <= a(1)

E inoltre possibile assegnare una sequenza di cifre.

Ad esempio y <= 01;

Per costanti binarie di un singolo bit si utilizza il simbolo

mentre per

configurazioni binarie composte da 2 o pi bit si utilizza il simbolo

Ad esempio:
a <= 1;
b_vettore <= 100111;

E anche possibile effettuare assegnazioni ad un numero limitato di bit del

vettore (bit-slicing).

Ad esempio:

b_vettore(4 downto 2) <= 101

1 0 1

b_vettore

LIBRARY IEEE
Mediante lutilizzo di librerie (keyword LIBRARY) e possibile
aggiungere al VHDL standard nuovi tipi di dato, nuove funzioni,
etc. Il meccanismo e analogo a quello utilizzato dai linguaggi
di programmazione ad alto livello.

LIBRARY IEEE
Tale libreria contiene i seguenti packages:
std_logic_1164 (definisce la std_logic e relative funzioni)
std_logic_arith (funzioni aritmetiche)
std_logic_signed (funzioni aritmetiche su numeri con segno
std_logic_unsigned (funzioni aritmetiche su numeri senza
segno)

VHDL & Altera Max+ Plus II

Altera Max+ Plus II fornisce un compilatore per codice

vhdl. Esistono alcune regole che e necessario tenere in
considerazione utilizzando lambiente Altera.
E disponibile un editor di testo per codice VHDL
allinterno dellambiente software ma e possibile
utilizzare anche editor esterni.

Il linguaggio VHDL NON E case sensitive. Per convenzione

le lettere maiuscole per le parole chiave del linguaggio

utilizzeremo

I file di testo che contengono il codice VHDL DEVONO avere estensione .vhd

Il nome del file VHDL (estensione .vhd) DEVE coincidere con il nome
assegnato all ENTITY.

Concetti fondamentali per la descrizione di

circuiti digitali con il linguaggio VHDL
Entity
Architecture

Internals
(behavioural,
structural,
...)
Input

Output

Data una interface description (ENTITY) sono possibili

diverse architectural specification (ARCHITECTURE)

ENTITY esempio IS
PORT()

ARCHITECTURE
behavioural OF
esempio IS .

ARCHITECTURE
structural OF
esempio IS .

..

ARCHITECTURE
.

-- Sintassi di un blocco descritto mediante VHDL

LIBRRY IEEE;
-- Standard IEEE library
USE IEEE.std_logic_1164.all; -- Standard logic package

Inclusione di librerie

-- Entity declaration

Interface specification
ENTITY nome_entity

IS
A

PORT(signal_name : direction type);

GENERIC(generic_name: type := default_value);

B
S

END nome_entity;

-- Architecture description
ARCHITECTURE architettura_entity OF nome_entity IS
<architecture declarations>
BEGIN
<processing statements>
END architettura_entity ;

Architectural specification

Entity
-- Entity declaration
ENTITY nome_entity

IS

PORT(signal_name: direction type);

GENERIC(generic_name: type := default_value);

END nome_entity;

Mediante il costrutto GENERIC si definiscono tipicamente delle

costanti. Queste possono essere utilizzate ad esempio per definire
dei tempi di ritardo,

GENERIC(delay: time := 1 ns);

Mediante il costrutto PORT si specificano:

quali sono i segnali della rete esaminata (signal_names)

(direction) quali segnali sono di input (IN), di output (OUT),
bidirezionali (INOUT)
(type) di che tipo sono i segnali

Architecture
-- Architecture description
ARCHITECTURE architettura_entity OF nome_entity IS
<architecture declarations>
BEGIN
<processing statements>
END architettura_entity ;

Allinterno della sezione ARCHITECTURE viene specificata la logica della rete.

Allinterno della sezione ARCHITECTURE (in <architecture declarations>)
possibile definire degli oggetti. Tali oggetti sono tipicamente dei segnali
(vedi esempio 2) e possono essere utilizzati (scope) solo allinterno della
architecture description. E possibile utilizzare i data types definiti
allinterno del VHDL o disponibili mediante lutilizzo di librerie
aggiuntive. Ad esempio:
SIGNAL T1,T0 : BIT;

La parte nella quale viene specificata la logica vera e propria della rete
il <processing statements>, compresa tra BEGIN ed END.

Per il <processing statements> esistono due distinti modelli di elaborazione...

CONCURRENT PROCESSING
Le espressioni comprese tra BEGIN ed END vengono elaborate tutte
contemporaneamente. Non ha alcun significato lordine con il quale appaiono
nel codice VHDL.

ARCHITECTURE

BEGIN
<concurrent
<concurrent
<concurrent
.
.
.
<concurrent

END;

statement 1>
statement 2>
statement 3>

statement n>

SEQUENTIAL PROCESSING
Mediante listruzione PROCESS e possibile definire una sequenza di istruzioni che
verranno elaborate secondo il paradigma di programmazione sequenziale. Allinterno
di un blocco PROCESS le istruzioni sono elaborate in modo sequenziale dallalto
verso il basso (nellordine in cui vengono scritte). Ogni processo e eseguito in
modo concorrente rispetto ad altri processi o istruzioni concorrenti definite
nellarchitecture.
ARCHITECTURE
BEGIN
PROCESS(sensitivity_list)
<sequential statement 1>
<sequential statement 2>
.
.
.
<sequential statement n>

END PROCESS;
END

sensitivity_list
Lista degli segnali (eventi) ai quali le istruzioni del processo sono
sensibili. Rappresentano quindi gli eventi che possono modificare le
espressioni definite allinterno di un processo. Se nessuno di questi
eventi si verifica il processo rimane inattivo.

Operatori logici definiti in VHDL

And:

AND

Or:

OR

Not:

NOT

Nand:

NAND

Nor:

NOR

Xor:

XOR

Xnor:

XNOR
Esempi:
Y<= NOT A;
Z<= a AND b;

Tali operatori agiscono su tipi predefiniti: BIT, BOOLEAN, BIT_VECTOR.

Se sono usati vettori il numero di bit dei due operandi deve essere lo stesso.

Operatori relazionali definiti in VHDL

Tali operatori agiscono su operandi dello stesso tipo e ritornano un valore
BOOLEAN (TRUE o FALSE).

Uguale:

Diverso:

/=

Minore:

<

Minore Uguale:

<=

Maggiore:

>

Maggiore Uguale:

>=

Esempi:
a_boolean <= op1 > op2;
b_boolean <= op1 /= op2;

Operatori come +, -, <, >, <= ,>= sono definiti solo per il tipo INTEGER.

Altri operatori definiti in VHDL

In VHDL sono definiti altri operatori, quali:

SHIFT
SOMMA
SOTTRAZIONE
MOLTIPLICAZIONE

Consultare il manuale del VHDL per una descrizione dettagliata di tali

operatori.

CONCURRENT STATEMENTS
Concurrent statements possono essere utilizzati solo al di
fuori di un processo e da un punto di vista concettuale sono
eseguiti in modo concorrente. Per questo motivo lordine con
il quale vengono scritti non e importante.

Concurrent signal assignements

Selective signal assignements (WITH-SELECT-WHEN)
Conditional signal assignements (WHEN-ELSE)

WITH-SELECT-WHEN
Selected signal assignement

WITH <expression> SELECT

<signal_name>

<= <signal/value> WHEN <condition1>,

<signal/value> WHEN <condition2>,
.
.
.
<signal/value> WHEN OTHERS;

Esempio (and2)
AND2

ENTITY and2with IS
PORT (a : IN BIT_VECTOR (1 DOWNTO 0);
y : OUT BIT);
END and2with;
ARCHITECTURE arch_and2with OF and2with IS
BEGIN
WITH a SELECT
y <= 1' WHEN "11",
0' WHEN 00,
0' WHEN 01,
0' WHEN 10;
END arch_and2with;
and2with.vhd

Una realizzazione pi semplice potrebbe essere la seguente

Esempio (and2)
AND2

ENTITY and2withothers IS
PORT (a : IN BIT_VECTOR (1 DOWNTO 0);
y : OUT BIT);
END and2withothers;
ARCHITECTURE arch_and2withothers OF and2withothers IS
BEGIN
WITH a SELECT
y <= 1' WHEN 11",
0' WHEN OTHERS;
END arch_and2withothers;
and2withothers.vhd

WHEN-ELSE
Conditional signal assignement

<signal_name> <= <signal/value> WHEN <condition1> ELSE

<signal/value> WHEN <condition2> ELSE
.
.
.
<signal/value> WHEN <conditionN> ELSE
<signal/value>;

Esempio (and2)
AND2

ENTITY and2 IS
PORT (a, b : IN BIT;
y
: OUT BIT);
END and2;
ARCHITECTURE arch_and2 OF and2 IS
BEGIN
y<='1' WHEN (A='1' AND B='1') ELSE
'0';
END arch_and2;
and2.vhd

Nel caso pi condizioni siano verificate al segnale di uscita e assegnato il

primo valore che soddisfa la catena dei WHEN.

Codice VHDL che sintetizza lAND a 2 ingressi utilizzando il costrutto WHEN-ELSE

Esempio (and2)
AND2

ENTITY and2whenelse1 IS
PORT (a: IN BIT_VECTOR (1 DOWNTO 0);
y
: OUT BIT);
END and2whenelse1;
ARCHITECTURE arch_and2whenelse1 OF and2whenelse1 IS
BEGIN
y <= 0' WHEN a(0)=0 ELSE
0' WHEN a(1)=0 ELSE
1;
END arch_and2whenelse1;
and2whenelse1.vhd

Unaltra soluzione, sempre utilizzando WHEN-ELSE, potrebbe essere la seguente..

Esempio (and2)
AND2

ENTITY and2whenelse2 IS
PORT (a: IN BIT_VECTOR (1 DOWNTO 0);
y
: OUT BIT);
END and2whenelse2;
ARCHITECTURE arch_and2whenelse2 OF and2whenelse2 IS
BEGIN
y <= 0' WHEN a(0)=0 ELSE
1' WHEN a(1)=1 ELSE
0;
END arch_and2whenelse2;
and2whenelse2.vhd

Oppure...

Esempio (and2)
AND2

ENTITY and2whenelse3 IS
PORT (a : IN BIT_VECTOR (1 DOWNTO 0);
y : OUT BIT);
END and2whenelse3;
ARCHITECTURE arch_and2whenelse3 OF and2whenelse3 IS
BEGIN
y <= 1' WHEN a=11 ELSE
0;
END arch_and2whenelse3;
and2whenelse3.vhd

DEIS-Dipartimento di Elettronica Informatica e Sistemistica

Universita di Bologna, Sede di Cesena

Introduzione al
linguaggio VHDL
PARTE II

Stefano Mattoccia
e-mail: smattoccia@deis.unibo.it
Telefono: +39 0547 614559

Cesena, 23 Novembre 2001

Consideriamo una semplice rete combinatoria:

un Multiplexer a 2 vie

A se S = 0

A
B

Mux a 2 Vie

Z=
B se S = 1

Logicamente:

A
B

Z = AS + BS

Mux
2-1

Design entry mediante schema logico (.gdf)

AND2
5

INPUT
VCC

NOT
1
3

OR2
OUTPUT
6

INPUT
VCC
AND2

INPUT
VCC

Risultato della simulazione

Codice VHDL che sintetizza il multiplexer a 2 vie

-- esempio 1 (Multiplexer a 2 vie)

esempio1.vhd

ENTITY esempio1 IS
A
B

Mux
2-1

PORT (A,B,S : IN BIT;

Z : OUT BIT);
Z
END esempio1;

ARCHITECTURE arch_esempio1 OF esempio1 IS

BEGIN
Z<=(A AND (NOT S)) OR (B AND S);
END

arch_esempio1;

Oppure...
Le tre assegnazioni vengono eseguite in modo paralello (concorrente)

-- esempio 2 (Multiplexer a 2 vie)

A
B

Mux
2-1

esempio2.vhd

ENTITY esempio2 IS
PORT (A,B,S : IN BIT;
Z : OUT BIT);
END esempio2;
ARCHITECTURE arch_esempio2 OF esempio2 IS
SIGNAL TA,TB: BIT;
BEGIN
TA<=A AND (NOT S);
TB<=B AND S;
Z<=TA OR TB;
END

arch_esempio2;

Il risultato e indipendente dallordine con il quale vengono scritte nel codice le 3

assegnazioni (esecuzione parallela). Infatti...

-- esempio 3 (Multiplexer a 2 vie)

ENTITY esempio3 IS
PORT (A,B,S : IN BIT;
Z : OUT BIT);
END esempio3;

A
B

Mux
2-1

esempio3.vhd

Z
ARCHITECTURE arch_esempio3 OF esempio3 IS
SIGNAL TA,TB: BIT;

S
BEGIN
Z<=TA OR TB;
TA<=A AND (NOT S);
TB<=B AND S;
END

arch_esempio3;

Il codice del mux a 2 con VHDL utilizzando WHEN-ELSE

-- esempio 4 (Multiplexer a 2 vie) con WHEN-ELSE

A
B

Mux
2-1

ENTITY esempio3 IS
PORT (A,B,S : IN BIT;
Z : OUT BIT);
END esempio3;
ARCHITECTURE arch_esempio3 OF esempio3 IS
BEGIN
Z<=A WHEN S='0' ELSE B;
END

arch_esempio3;

esempio4.vhd

Rete combinatoria
Rilevatore di priorit (Priority Encoder)

X3
X2

Priority

X1

P1 P0 =

P1
P0

11

se

x3 =1 e x2=- e x1=-

10

se

x3 =0 e x2=1 e x1=-

01

se

x3 =0 e x2=0 e x1=1

00

se

x3 =0 e x2=0 e x1=0

Priority 1
priority1.vhd

ENTITY priority1 IS
PORT (x3,x2,x1 : IN BIT;
p : OUT BIT_vector(1 DOWNTO 0));
END priority1;
ARCHITECTURE arch_priority1 OF priority1 IS
BEGIN
p<="00"
"01"
"10"
"11"

WHEN
WHEN
WHEN
WHEN

((x3='0')
((x3='0')
((x3='0')
((x3='1')

END arch_priority1;

AND
AND
AND
AND

(x2='0') AND
(x2='0') AND
(x2='1') AND
((x2='1') OR

(x1='0'))
(x1='1'))
((x1='1')
(x2='0'))

ELSE
ELSE
OR (X1='0'))) ELSE
AND ((x1='1') OR (X1='0')));

Priority 2
priority2.vhd

ENTITY priority2 IS
PORT (x3,x2,x1 : IN BIT;
p : OUT BIT_vector(1 DOWNTO 0));
END priority2;
ARCHITECTURE arch_priority2 OF priority2 IS
BEGIN
p<=11" WHEN x3=1' ELSE
10" WHEN x2=1' ELSE
01 WHEN x1=1' ELSE
00;
END arch_priority2;

Priority2Wrong (ERRATO)
E importante lordine con il quale vengono eseguiti i test WHEN-ELSE !

ENTITY priority2wrong IS
PORT (x3,x2,x1 : IN BIT;
p : OUT BIT_vector(1 DOWNTO 0));
END priority2wrong;

priority2wrong.vhd

ARCHITECTURE arch_priority2wrong OF priority2wrong IS

BEGIN
p<=10" WHEN x2=1' ELSE
01" WHEN x1=1' ELSE
11 WHEN x3=1' ELSE
00;
END arch_priority2wrong;

Priority 4
priority4.vhd

ENTITY priority2 IS
PORT (
X : IN BIT_vector(3 DOWNTO 1);
p : OUT BIT_vector(1 DOWNTO 0));
END priority2;
ARCHITECTURE arch_priority2 OF priority2 IS
BEGIN
WITH X SELECT
P <= "00" WHEN
"01"
"10"
"10"
"11"

"000",
WHEN "001",
WHEN "010",
WHEN "011",
WHEN OTHERS;

END arch_priority2;

PriorityProcess1
ENTITY priorityprocess1 IS
PORT (x3,x2,x1 : IN BIT;
p : OUT BIT_vector(1 DOWNTO 0));
END priorityprocess1;

priorityprocess1.vhd

ARCHITECTURE arch_priorityprocess1 OF priorityprocess1 IS

BEGIN
PROCESS(x3,x2,x1) -- sensitivity list
BEGIN
IF
(x3='1') THEN p<="11";
ELSIF (x2='1') THEN p<="10";
ELSIF (x1='1') THEN p<="01";
ELSE
p<="00";
END IF;
END PROCESS;
END arch_priorityprocess1;

SEQUENTIAL STATEMENTS
Sequential statements possono essere utilizzati solo
allinterno di processi (PROCESS), funzioni (FUNCTION) e
procedure (PROCEDURE).
Lassegnamento dei segnali allinterno di un processo e
sequenziale e lordine con il quale vengono effettuati gli
assegnamenti influenza la logica di funzionamento.
Linsieme delle istruzioni (statements) che costituiscono un
processo costituiscono un concurrent statement.

IF-THEN-ELSE
CASE-WHEN
LOOP
WAIT

IF-THEN-ELSE
IF <condition> THEN
<istruzione1>;
ELSE
<istruzione2>;
END IF;

Il costrutto IF-THEN-ELSE e utilizzato per eseguire un set

di istruzioni selezionate sulla base del valore di una espressione
booleana ( <condition> ). Ad esempio:
processo1: PROCESS (a,b,c)
BEGIN
IF a=1 THEN
z=1;
ELSE
z=0;
END IF;
END PROCESS;

IF-THEN-ELSE-ELSIF

IF <condition1> THEN
<itruzione1>;
ELSIF <condition2> THEN
<istruzione2>;
ELSE
<istruzione3>;
END IF;

Il costrutto IF-THEN-ELSE pu essere espanso ulteriormente per

consentire la valutazione di pi condizioni attraverso lutilizzo
di ELSIF.
Si noti come lesecuzione di <instruzione3> sia subordinata alla
mancata verifica delle condizioni <condition1> e <condition2>.

CASE-WHEN

CASE <selection_signal> IS
WHEN
WHEN
WHEN
..
..
WHEN
WHEN

<value_1_selection_signal> => <istruzione_1>;

<value_2_selection_signal> => <istruzione_2>;
<value_3_selection_signal> => <istruzione_3>;
..
..
..
..
<value_n_selection_signal> => <istruzione_n>;
OTHERS => <istruzione_others>;

END CASE;
Il costrutto CASE-WHEN e utilizzato per eseguire un set di
istruzioni selezionate sulla base del valore di uno specifico
SEGNALE <selection_signal>.
La parola chiave OTHERS e utilizzata per eseguire il set di
istruzioni <instruzione_others> nel caso nessuna condizione sia
verificata.

LOOP
WHILE (<condition>) LOOP
<instruction>;

WHILE-LOOP

END LOOP;

FOR <var> IN <min_value> TO <max_value> LOOP

<instruction>;

FOR-LOOP (0FORWARD)

END LOOP;

FOR <var> IN <max_value> DOWNTO <min_value> LOOP

<instruction>;

FOR-LOOP (BACKWARD)

END LOOP;
Allinterno di un ciclo possibile interrompere literazione
corrente e passare a quella successiva utilizzando listruzione
NEXT.
Un ciclo pu essere completamente interrotto attraverso
listruzione EXIT.

Segnali VS Variabili
Esiste una sostanziale differenza su come viene effettuato
lassegnamento di un valore ad un segnale e ad una variabile
allinterno di un processo (esecuzione sequenziale).
I valori assegnati alle variabili hanno effetto istantaneamente
mentre i valori assegnati ai segnali vengono aggiornati solo
alluscita del processo.

Half-Adder a 1 bit
Progettare una rete che esegua la somma di due numeri di 1 bit:

S = X + Y

Cout

HA
1 Bit

Cout

Sum

0
0
1
1

0
1
0
1

0
0
0
1

0
1
1
0

Sum

ENTITY ha IS
PORT (X,Y
S,COUT
END ha;

ha_base.vhd
: IN
: OUT

BIT;
BIT);

ARCHITECTURE arch_ha OF ha IS
BEGIN
-- Somma
S<=X XOR Y;
-- Carry
COUT<= A AND Y;
END arch_ha;

Half Adder progettato

utilizzando lesecuzione
concorrente

ENTITY ha_base1 IS
PORT (X,Y
: IN
S,COUT : OUT
END ha_base1;

ha_base1.vhd
BIT;
BIT);

ARCHITECTURE arch_ha_base1 OF ha_base1 IS

BEGIN
PROCESS(X,Y)
VARIABLE ST,CT :BIT;
BEGIN
-- Somma
ST:= X XOR Y;
-- Carry
CT:= X AND Y;
-- assegna valori ai segnali S e COUT
S<=ST;
COUT<= CT;
END PROCESS;
END arch_ha_base1;

Half Adder progettato

utilizzando lesecuzione
sequenziale (PROCESS) e
le variabili

ENTITY ha IS
PORT (X,Y
S,COUT
END ha;

ha.vhd
: IN
: OUT

BIT;
BIT);

ARCHITECTURE arch_ha OF ha IS
BEGIN
PROCESS(X,Y)
BEGIN
IF X /= Y
THEN S<='1';
ELSE S<='0';
END IF;
IF ( X='1' AND Y='1' )
THEN COUT<='1';
ELSE COUT<='0';
END IF;
END PROCESS;
END arch_ha;

Half Adder progettato

utilizzando lesecuzione
sequenziale (PROCESS) e il
costrutto IF-THEN-ELSE.

ENTITY ha1 IS
PORT(X,Y
S,COUT
END ha1;

ha1.vhd
: IN
: OUT

BIT;
BIT);

ARCHITECTURE arch_ha1 OF ha1 IS

BEGIN
PROCESS(X,Y)
BEGIN
-- Somma
IF X /= Y
THEN S<='1';
ELSE S<='0';
END IF;

Half Adder progettato

utilizzando lesecuzione
sequenziale (PROCESS) e il
costrutto IF-THEN-ELSE.
Sono presenti assegnamenti
multipli al segnale COUT.

-- Carry-Out
COUT<='0';
IF ( X='1' AND Y='1' )
THEN COUT<='1';
END IF;
END PROCESS;
END arch_ha1;

Attenzione, il compilatore con questo codice genera un warning

segnalando che esistono assegnamenti multipli al segnale COUT. Solo
lultimo assegnamento avr effetto. E bene evitare queste situazioni
utilizzando i costrutti del VHDL (e.g. ELSE) o segnali temporanei
(VARIABLE).

Il risultato della simulazione sul codice ha1.vhd della

pagina precedente comunque corretto, come mostrato nella
figura seguente.

Full-Adder a 1 bit
Progettare Full Adder a

1 bit:

Sum = X + Y + Cin

Cin
X

Cout

FA
1 Bit

Sum

C1T

C2T

S1T
S2T

ENTITY fa IS
PORT (X,Y,CIN : IN
S,COUT : OUT
END fa;

fa.vhd
BIT;
BIT);

ARCHITECTURE arch_fa OF fa IS
BEGIN
PROCESS(X,Y,CIN)
VARIABLE S1T,S2T,C1T,C2T :BIT;
BEGIN
-- Primo Ha
C1T:= X AND Y;
S1T:= X XOR Y;
-- Secondo Ha
C2T:=S1T AND CIN;
S2T:=S1T XOR CIN;
-- assegna valori ai segnali S e COUT
S<=S2T;
COUT<= C1T OR C2T;
END PROCESS;
END arch_fa;

Half Adder progettato

utilizzando lesecuzione
sequenziale (PROCESS) e
segnali temporanei
(VARIABLE).

Full-Adder a 4 bit

Progettare un Full Adder a

Full Adder a 1 bit

Cin
X
Y

4 bit utilizzando 4

4
4

FA
4 Bit

Cout
Sum

Cin
Sum(0)
X(0)

1 BIT
FULLADDER

Y(0)

Cout(0)

Sum(1)
X(1)

1 BIT
FULLADDER

Y(1)

Cout(1)

Sum(2)
X(2)

1 BIT
FULLADDER

Y(2)
Cout(2)

Sum(3)
X(3)

1 BIT
FULLADDER

Y(3)
Cout(3)

Una possibile sintesi (non ottimale) VHDL del sommatore a 4 bit

mostrato nel lucido seguente.

ENTITY fa_4bit_noloop IS
PORT (X,Y
: IN BIT_VECTOR(3 DOWNTO 0);
CIN
: IN BIT;
S,COUT : OUT BIT_VECTOR(3 DOWNTO 0));
END fa_4bit_noloop;

Fa_4bit_noloop.vhd

ARCHITECTURE arch_fa_4bit_noloop OF fa_4bit_noloop IS

BEGIN
PROCESS(X,Y,CIN)
VARIABLE TX,TY,TCOUT
VARIABLE CARRY_IN,CARRY_OUT
VARIABLE S1T,S2T,C1T,C2T

:BIT_VECTOR(3 DOWNTO 0);

:BIT;
:BIT;

BEGIN
-- inizializza variabili
TX:=X;
TY:=Y;
-- *****************
-- *** Primo FA ****
-- *****************
CARRY_IN:=CIN;
-- Primo Ha
C1T:= TX(0) AND TY(0);
S1T:= TX(0) XOR TY(0);
-- Secondo Ha
C2T:=S1T AND CARRY_IN;
S2T:=S1T XOR CARRY_IN;
-- assegna valore al segnale S(0)
S(0)<=S2T;
-- assegna valore al segnale COUT(0)
CARRY_OUT:=C1T OR C2T;
COUT(0)<= CARRY_OUT;

1/3

Full Adder a 4 bit

progettato utilizzando
lesecuzione sequenziale
(PROCESS) e segnali
temporanei (VARIABLE).

-- ******************
-- *** Secondo FA ***
-- ******************
-- riporto da precedente operazione
CARRY_IN:=CARRY_OUT;
-- Primo Ha
C1T:= TX(1) AND TY(1);
S1T:= TX(1) XOR TY(1);
-- Secondo Ha
C2T:=S1T AND CARRY_IN;
S2T:=S1T XOR CARRY_IN;
-- assegna valore al segnale S(1)
S(1)<=S2T;
-- assegna valore al segnale COUT(1)
CARRY_OUT:=C1T OR C2T;
COUT(1)<= CARRY_OUT;
-- *****************
-- *** Terzo FA ****
-- *****************
-- riporto da precedente operazione
CARRY_IN:=CARRY_OUT;
-- Primo Ha
C1T:= TX(2) AND TY(2);
S1T:= TX(2) XOR TY(2);
-- Secondo Ha
C2T:=S1T AND CARRY_IN;
S2T:=S1T XOR CARRY_IN;
-- assegna valore al segnale S(2)
S(2)<=S2T;
-- assegna valore al segnale COUT(2)
CARRY_OUT:=C1T OR C2T;
COUT(2)<= CARRY_OUT;

2/3

-- *****************
-- *** Quarto FA ***
-- *****************
-- riporto da precedente operazione
CARRY_IN:=CARRY_OUT;
-- Primo Ha
C1T:= TX(3) AND TY(3);
S1T:= TX(3) XOR TY(3);
-- Secondo Ha
C2T:=S1T AND CARRY_IN;
S2T:=S1T XOR CARRY_IN;
-- assegna valore al segnale S(3)
S(3)<=S2T;
-- assegna valore al segnale COUT(3)
CARRY_OUT:=C1T OR C2T;
COUT(3)<= CARRY_OUT;
END PROCESS;
END arch_fa_4bit_noloop;

3/3

Sommatore a 4 bit: risultato della simulazione

Sfruttando la modularit del sommatore a 4 bit e utilizzando

listruzione LOOP e possibile scrivere una versione pi
compatta del codice VHDL, come mostrato nel lucido seguente.

ENTITY fa_4bit IS
PORT (X,Y
: IN
CIN
: IN
S,COUT : OUT
END fa_4bit;

BIT_VECTOR(3 DOWNTO 0);

BIT;
BIT_VECTOR(3 DOWNTO 0));

Fa_4bit.vhd

ARCHITECTURE arch_fa_4bit OF fa_4bit IS

BEGIN
PROCESS(X,Y,CIN)
VARIABLE TX,TY,TCOUT
:BIT_VECTOR(3 DOWNTO 0);
VARIABLE CARRY_IN,CARRY_OUT :BIT;
VARIABLE S1T,S2T,C1T,C2T
:BIT;
BEGIN
-- inizializza variabili prima di iniziare il loop
TX:=X;
TY:=Y;
FOR i IN 0 TO 3 LOOP
-- seleziona il corretto carry in ingresso
IF (i=0) THEN
CARRY_IN:=CIN;
ELSE
CARRY_IN:=CARRY_OUT;
END IF;
-- Primo Ha
C1T:= TX(i) AND TY(i);
S1T:= TX(i) XOR TY(i);
-- Secondo Ha
C2T:=S1T AND CARRY_IN;
S2T:=S1T XOR CARRY_IN;
-- assegna valore al segnale S
S(i)<=S2T;
-- assegna valori al segnale COUT
CARRY_OUT:=C1T OR C2T;
COUT(i)<= CARRY_OUT;
END LOOP;
END PROCESS;
END arch_fa_4

1/1

Full Adder a 4 bit

progettato
utilizzando
lesecuzione
sequenziale
(PROCESS), segnali
temporanei
(VARIABLE) e
listruzione
costrutto LOOP.

Sommatore a 4 bit: risultato della simulazione

Il codice della diapositiva precedente, scritto per il Full

Adder a 4 bit, si presta ad essere facilmente esteso al caso
di un sommatore a N bit...

DEIS-Dipartimento di Elettronica Informatica e Sistemistica

Universita di Bologna, Sede di Cesena

Introduzione al
linguaggio VHDL
PARTE III

Stefano Mattoccia
e-mail: smattoccia@deis.unibo.it
Telefono: +39 0547 614559

Cesena, 23 Novembre 2001

Full-Adder a N bit

Il VHDL consente un elevato grado di astrazione.

Si supponga di dover progettare un sommatore ad N bit partendo

dal codice del sommatore a 4 bit mostrato nelle pagine
precedenti...

Cin
X
Y

FA
N Bit

Consideriamo per esempio il caso di N=16.

Cout
Sum

ENTITY fa_Nbit IS
GENERIC(N: NATURAL :=16);
PORT (X,Y
: IN
BIT_VECTOR(N-1 DOWNTO 0);
CIN
: IN
BIT;
S,COUT : OUT BIT_VECTOR(N-1 DOWNTO 0));
END fa_Nbit;
ARCHITECTURE arch_fa_Nbit OF fa_Nbit IS
BEGIN
PROCESS(X,Y,CIN)
VARIABLE TX,TY,TCOUT
VARIABLE CARRY_IN,CARRY_OUT
VARIABLE S1T,S2T,C1T,C2T

Fa_Nbit.vhd

Codice VHDL di
un generico
sommatore a N
bit.
Caso specifico
di N=16.

:BIT_VECTOR(N-1 DOWNTO 0);

:BIT;
:BIT;

BEGIN
-- inizializza variabili prima di iniziare il loop
TX:=X;
TY:=Y;
FOR i IN 0 TO N-1 LOOP
IF (i=0) THEN
CARRY_IN:=CIN;
ELSE
CARRY_IN:=CARRY_OUT;
END IF;
-- Primo Ha
C1T:= TX(i) AND TY(i);
S1T:= TX(i) XOR TY(i);
-- Secondo Ha
C2T:=S1T AND CARRY_IN;
S2T:=S1T XOR CARRY_IN;
-- assegna valore al segnale S
S(i)<=S2T;
-- assegna valori al segnale COUT
CARRY_OUT:=C1T OR C2T;
COUT(i)<= CARRY_OUT;
END LOOP;
END PROCESS;
END arch_fa_Nbit;

Sommatore a N bit: risultato della simulazione (N=16)

Avendo a disposizione un generico sommatore ad N bit e

immediato progettare una semplice ALU a N bit...

ALU a N bit

codice di operazione

c
flag

Propriet
del
risultato

I operando
ALU

Y
II operando

U risultato
u = Fc (X , Y)

ALU base a N bit

C0

CI
CI 4 BIT
a0 ADDER
a1
a2
a3
s0
s1
s2
s3
b0
b1
b2
b3
CO

Y
0

M
U
1X

CI
C0
0

0
X+Y

1 X-Y-1

1
X+Y+1
X-Y

Flag
U

Segnali di flag
c

ZF

ZERO FLAG: vale 1 se il

risultato vale 0.

SF

SIGN FLAG: vale 1 se il

risultato negativo.

CF

CARRY FLAG: vale 1 se

CO=1 .

Flag

X
ALU
Y

OVF OVERFLOW FLAG: vale 1 in caso di traboccamento

del risultato di unoperazione fra numeri relativi
rappresentati in complemento a 2.
PF

PARITY FLAG: vale 1 se il bit di parit del risultato

vale 1.

Generazione dei flag per una ALU a N bit

ZF = (S0 + S1 + S2 + + SN-1)
SF = SN-1
CF = CoutN-1
OVF = CoutN-2 CoutN-1
PF = S0 S1 S2 SN-1

alu_Nbit.vhd
ENTITY alu_Nbit IS
GENERIC(N: NATURAL :=4);
PORT (X,Y
: IN
BIT_VECTOR(N-1 DOWNTO 0); -- input
CIN,C0
: IN
BIT;
-- control bits
S,COUT
: OUT BIT_VECTOR(N-1 DOWNTO 0); -- output bits
SF,CF,OVF
: OUT BIT);
-- flags
END alu_Nbit;
ARCHITECTURE arch_alu_Nbit OF alu_Nbit IS
BEGIN
PROCESS(X,Y,CIN,C0)
VARIABLE TX,TY,TCOUT
:BIT_VECTOR(N-1 DOWNTO 0);
VARIABLE CARRY_IN,CARRY_OUT
:BIT;
VARIABLE S1T,S2T,C1T,C2T
:BIT;
BEGIN
-- ****** rete di pre-laborazione ********
TX:=X;
CASE (C0) IS
WHEN '0' => TY:=Y;
WHEN '1' => TY:=NOT(Y);
END CASE;
FOR i IN 0 TO N-1 LOOP
-- seleziona il corretto carry in ingresso
IF (i=0) THEN
-- riporto in ingresso al sommatore CIN
CARRY_IN:=CIN;
ELSE
-- riporto da precedente operazione
CARRY_IN:=CARRY_OUT;
END IF;
-- Primo Ha
C1T:= TX(i) AND TY(i);
S1T:= TX(i) XOR TY(i);
-- Secondo Ha
C2T:=S1T AND CARRY_IN;
S2T:=S1T XOR CARRY_IN;
-- assegna valore al segnale S
S(i)<=S2T;
-- assegna valori al segnale COUT
CARRY_OUT:=C1T OR C2T;
COUT(i)<= CARRY_OUT;
1/2
END LOOP;

Codice VHDL di una

semplice ALU a N
bit.
Caso specifico di
N=4.

-- ******** Flags ***********

-- Se il MSB e' '1' il segno e' negativo
IF (S2T='1')
THEN SF<='1';
ELSE SF<='0';
END IF;
-- Se il Cout dell'ultimo sommatore e' '1' allora CF='1'
IF (CARRY_OUT='1')
THEN CF<='1';
ELSE CF<='0';
END IF;
-- Verifica Overflow (complemento a 2)
IF ((CARRY_OUT XOR CARRY_IN)='1')
THEN OVF<='1';
ELSE OVF<='0';
END IF;
END PROCESS;
END arch_alu_Nbit;

2/2

Questo esempio mette in evidenza come il VHDL consenta di

progettare reti logiche modulari facilitando il lavoro del
progettista.
Nel caso specifico della ALU, e possibile progettare ALU a N bit
con un N qualsiasi cambiando un solo parametro del codice VHDL!

ALU a N bit: risultato della simulazione (N=4)

Esercizio: scrivere il codice VHDL che sintetizza il flag di
zero (ZF) e il flag di parit (PF).

WAIT
Listruzione WAIT consente di sospendere lesecuzione di un processo
fino al verificarsi di un determinato evento.
Gli eventi che possono essere utilizzati in VHDL per riprendere
lesecuzione di un processo sono riassumibili nelle seguenti 3
categorie:

il cambiamento di uno o pi segnali (WAIT ON)

il verificarsi di una espressione booleana (WAIT UNTIL)
la fine di un determinato intervallo di tempo (WAIT FOR)

Listruzione WAIT e tipicamente utilizzata nel progetto di reti

sequenziali sincrone perch consente di bloccare levoluzione di
un processo fino a che non si verifica un evento (es. fronte del
segnale di clock).
In un processo se si utilizza listruzione WAIT non si deve definire
la sensitivity list.

Formalmente, la sintassi dellistruzione WAIT e la seguente:

WAIT ON <signal_changes>;
es: WAIT ON clock,a,b

WAIT UNTIL <expression_is_TRUE>;

es: WAIT UNTIL ((4*x)<50);

WAIT FOR <specific_amount_of_time>

es: WAIT FOR 50 ns;

Flip-Flop D
Il codice seguente mostra la realizzazione in VHDL di un Flip-Flop D
utilizzando listruzione WAIT.
Il segnale di ingresso deve propagarsi in uscita quando si verifica
un fronte positivo del clock.
ENTITY flipflopD IS
PORT(D,CLOCK : IN
Q
: OUT

fliflopd.vhd

BIT;
BIT);

END flipflopD;
ARCHITECTURE arch_flipflopD OF flipflopD IS
BEGIN
PROCESS
BEGIN
WAIT UNTIL CLOCK = '1' AND CLOCK'EVENT;
Q<=D;
END PROCESS;
END arch_flipflopD;

Codice VHDL che sintetizza un Flip-Flop D

Flip Flop D: risultato della simulazione

Segnali ed attributi
In VHDL ai segnali sono associati degli attributi.
Tali attributi consentono di avere informazioni sullevoluzione temporale
dei segnali.

EVENT
ACTIVE
LAST_VALUE
LAST_EVENT
LAST_ACTIVE

Esempio: Listruzione WAIT UNTIL CLOCK = '1' AND CLOCK'EVENT;

blocca lesecuzione del processo fino a che:
a) il segnale di clock e a livello logico 1
b) si verifica un evento (fronte) sul segnale di clock

Flip-Flop D con RESET sincrono

ENTITY flipflopD_reset_sincrono IS
PORT(D,CLOCK,RESET
Q

: IN
: OUT

BIT;
BIT);

END flipflopD_reset_sincrono;
ARCHITECTURE arch_flipflopD OF flipflopD _reset_sincrono IS
BEGIN
PROCESS
BEGIN
WAIT UNTIL CLOCK = '1' AND CLOCK'EVENT;
IF (RESET=1)
THEN
Q<=0;
ELSE
Q<=D;
END IF;
END PROCESS;
END arch_flipflopD;

Codice VHDL che sintetizza un Flip-Flop D

con segnale di RESET sincrono

Flip Flop D con RESET sincrono: risultato della simulazione

Contatore modulo N
Si desidera progettare un contatore modulo N in VHDL.
Il contatore presenta un ingresso di clock e tre ingressi
sincroni HOLD, UP e RESET:
HOLD

- se 1 blocca il conteggio

UP

- se 1 conta in avanti, se 0 conta indietro

RESET

- se 1 azzera luscita

Clock
HOLD
UP
RESET

Contatore
modulo N

N
Z

Perch e importante limitare il range del tipo di dato utilizzato

per memorizzare lo stato ?
(mediante TYPE SMALL_INTEGER IS RANGE 0 TO 12; per un contatore modulo 12)?

Codice VHDL che sintetizza un generico contatore modulo N (N=12)

--

counterbase.vhd
dimensione della base di conteggio

: SMALL_INTEGER :=12;
: SMALL_INTEGER :=11);

---

base di conteggio
max valore di conteggio (BASE-1)

: IN
: IN
: OUT

-- clock
-- control inputs (sincroni)
-- output bits

PACKAGE MYTYPES IS
TYPE SMALL_INTEGER IS RANGE 0 TO 12;
END PACKAGE;
USE WORK.MYTYPES.ALL;
ENTITY CounterBase IS
GENERIC(BASE
MAX
PORT (CLOCK
HOLD,UP,RESET
Z
END CounterBase;

BIT;
BIT;
SMALL_INTEGER);

1/2

ARCHITECTURE arch_CounterBase OF CounterBase IS

BEGIN
PROCESS
VARIABLE STATO :SMALL_INTEGER;
BEGIN
WAIT UNTIL (CLOCK='1' AND CLOCK'EVENT);
-- fronte positivo del clock
IF (UP='1' AND HOLD='0')
THEN
IF (STATO=MAX)
THEN STATO:=0;
ELSE STATO:=(STATO+1);
END IF;
END IF;
IF (UP='0' AND HOLD='0')
THEN
IF (STATO=0)
THEN STATO:=MAX;
ELSE STATO:=STATO-1;
END IF;
END IF;
-- Reset prioritario rispetto ad HOLD e UP
IF (RESET='1')
THEN STATO:=0;
END IF;
Z<=STATO;
END PROCESS;
END arch_CounterBase;

2/2

Contatore modulo N: risultato della simulazione (N=12)

Esercizio: data modularit del codice presentato e facile

ottenere un contatore utilizzabile per il conteggio dei secondi
di un orologio digitale (modulo 60).
Soluzione: inclusa nel file counter60.vhd reperibile presso il
sito web di Reti Logiche L-A e/o Laboratorio di Informatica L-A.

Contatore BCD
Si desidera progettare un contatore BCD modulo 60.

4
Reset

Contatore
BCD
(modulo 60)

Clock

SEC_H

[0..5]

SEC_L

[0..9]

PACKAGE MYTYPES IS
TYPE SMALL_INTEGER IS RANGE 0 TO 10;
END PACKAGE;

-- dimensione base massima conteggio

USE WORK.MYTYPES.ALL;
ENTITY CounterBCD IS
PORT (CLOCK
RESET
SECH
SECL
END CounterBCD;

:
:
:
:

IN
IN
OUT
OUT

BIT;
BIT;
SMALL_INTEGER;
SMALL_INTEGER);

-----

clock
control input (sincrono)
output, cifra piu' significativa dei secondi
output, cifra meno significativa dei sec

ARCHITECTURE arch_CounterBCD OF CounterBCD IS

SIGNAL SECONDI_L :SMALL_INTEGER;
SIGNAL SECONDI_H :SMALL_INTEGER;
BEGIN
-- @@@@@@@@@@@@@@ SECONDI 'LOW' @@@@@@@@@@@@@@@@
LOW:PROCESS
VARIABLE STATOL :SMALL_INTEGER;
BEGIN
WAIT UNTIL (CLOCK='1' AND CLOCK'EVENT);
IF (STATOL=9)
THEN STATOL:=0;
ELSE STATOL:=(STATOL+1);
END IF;
-- Reset (prioritario)
IF (RESET='1')
THEN
STATOL:=0;
END IF;
SECONDI_L<=STATOL;
END PROCESS;

counterbbcd.vhd
1/2

-- @@@@@@@@@@@@@@ SECONDI 'HIGH' @@@@@@@@@@@@@@@@

HIGH:PROCESS
VARIABLE STATOH :SMALL_INTEGER;
BEGIN
WAIT UNTIL (CLOCK='1' AND CLOCK'EVENT);
IF (SECONDI_L=9) THEN
IF (STATOH=5)
THEN STATOH:=0;
ELSE STATOH:=(STATOH+1);
END IF;
END IF;

-- Reset (prioritario)
IF (RESET='1')
THEN STATOH:=0;
END IF;
SECONDI_H<=STATOH;
END PROCESS;
-- assegnamenti (concorrenti)
SECL<=SECONDI_L;
SECH<=SECONDI_H;

END arch_CounterBCD;

2/2

Contatore BCD modulo 60: risultato della simulazione

Contatore BCD modulo 60 con uscita

codificata con codice a 7 segmenti
Si desidera progettare un contatore BCD modulo 60 con uscite
in grado di pilotare due display a 7 segmenti.

4
4
Clock
Reset

Contatore
BCD
(modulo 60)

7
7

SEC_H

[0..5]

SEC_L

[0..9]

PACKAGE MYTYPES IS
TYPE SMALL_INTEGER IS RANGE 0 TO 10; -- dimensione base massima di conteggio
END PACKAGE;
USE WORK.MYTYPES.ALL;
ENTITY CounterBCD7segmenti IS
PORT (CLOCK
: IN
RESET
: IN
SECH
: OUT
SECL
: OUT
SEGMENTI_H
: OUT
SEGMENTI_L
: OUT

BIT;
BIT;
SMALL_INTEGER;
SMALL_INTEGER;
BIT_VECTOR(6 DOWNTO 0);
BIT_VECTOR(6 DOWNTO 0));

-----

clock
control input (sincrono)
output, cifra piu' significativa dei secondi
output, cifra meno significativa dei secondi

END CounterBCD7segmenti;
ARCHITECTURE arch_CounterBCD7segmenti OF CounterBCD7segmenti IS
SIGNAL SECONDI_L :SMALL_INTEGER;
SIGNAL SECONDI_H :SMALL_INTEGER;
BEGIN
-- @@@@@@@@@@@@@@ SECONDI 'LOW' @@@@@@@@@@@@@@@@
LOW:PROCESS
VARIABLE STATOL :SMALL_INTEGER;
BEGIN
WAIT UNTIL (CLOCK='1' AND CLOCK'EVENT);
IF (STATOL=9)
THEN STATOL:=0;
ELSE STATOL:=(STATOL+1);
END IF;
-- Reset (prioritario)
IF (RESET='1')
THEN
STATOL:=0;
END IF;
SECONDI_L<=STATOL;
END PROCESS;

counterbbcd7segmenti.vhd
1/3

-- @@@@@@@@@@@@@@ SECONDI 'HIGH' @@@@@@@@@@@@@@@@

HIGH:PROCESS
VARIABLE STATOH :SMALL_INTEGER;
BEGIN
WAIT UNTIL (CLOCK='1' AND CLOCK'EVENT);
IF (SECONDI_L=9) THEN
IF (STATOH=5)
THEN STATOH:=0;
ELSE STATOH:=(STATOH+1);
END IF;
END IF;
-- Reset (prioritario)
IF (RESET='1')
THEN STATOH:=0;
END IF;
SECONDI_H<=STATOH;
END PROCESS;
-- @@@@@@@@@ BCD -> 7 Segmenti (LOW) @@@@@@@@@@
-gfedcba
WITH SECONDI_L SELECT
SEGMENTI_L<="1000000"
"1111001"
"0100100"
"0110000"
"0011001"
"0010010"
"0000010"
"1111000"
"0000000"
"0010000"
"0110000"

WHEN
WHEN
WHEN
WHEN
WHEN
WHEN
WHEN
WHEN
WHEN
WHEN
WHEN

0,
1,
2,
3,
4,
5,
6,
7,
8,
9,
OTHERS;

-- Errore (E)

2/3

-- @@@@@@@@@ BCD -> 7 Segmenti (HIGH) @@@@@@@@@@

--

gfedcba

WITH SECONDI_H SELECT

SEGMENTI_H<="1000000"
"1111001"
"0100100"
"0110000"
"0011001"
"0010010"
"0110000"

WHEN
WHEN
WHEN
WHEN
WHEN
WHEN
WHEN

0,
1,
2,
3,
4,
5,
OTHERS;

-- Errore (E)

-- assegnamenti (concorrenti)
SECL<=SECONDI_L;
SECH<=SECONDI_H;

END arch_CounterBCD7segmenti;

a
f

c
d

Rete di controllo di un semaforo

Si desidera progettare una rete logica che controlli il flusso di un
semaforo secondo le seguenti specifiche:
Se RESET attivo tutte le luci del semaforo devono essere spente.
Quando il RESET si disattiver il semaforo deve partire con la prima fase
di ROSSO.
Se FLASHING attivo la luce gialla deve lampeggiare e le altre due luci
devono essere spente.
Altrimenti il semaforo deve funzionare in modo standard rimando ROSSO per 5
periodi di clock, VERDE per 3 periodi di clock e con le luci GIALLE e VERDI
attive per altri 3 periodi di clock.

RESET

Centralina
Semaforica
FLASHING

CLOCK

Il principio di funzionamento del semaforo che si intende progettare e

illustrato dalle forme donda seguenti:

CLOCK

FLASHING

RESET

10

semaforo.vhd
PACKAGE MYTYPES IS
TYPE SMALL_INTEGER IS RANGE 0 TO 11;
END PACKAGE;

--

dimensione della base di conteggio

USE WORK.MYTYPES.ALL;
ENTITY semaforo IS
GENERIC(BASE
MAX
PERIODO_ROSSO
PERIODO_VERDE
PERIODO_GIALLO
PORT (CLOCK
FLASHING
RESET
Z
R,G,V

:
:
:
:
:

:
:
:
:
:

SMALL_INTEGER
SMALL_INTEGER
SMALL_INTEGER
SMALL_INTEGER
SMALL_INTEGER

IN
BIT;
IN
BIT;
IN
BIT;
OUT SMALL_INTEGER;
OUT BIT);

------

:=11;
:=10;
:=5;
:=3;
:=3);

------

base di conteggio
max valore di conteggio (BASE-1)
durata segnale rosso
durata segnale verde
durata segnale verde-giallo

Clock
Se attivo (1) il semaforo lampeggia
Reset
Output contatore (debug)
output bits (R,G,V)

END semaforo;
ARCHITECTURE arch_semaforo OF semaforo IS
BEGIN
PROCESS
VARIABLE STATO
VARIABLE ROSSO,VERDE,GIALLO

:SMALL_INTEGER;
: BIT;
1/3

BEGIN
WAIT UNTIL (CLOCK='1' AND CLOCK'EVENT);
-- fronte positivo del clock
-- funzionamento standard
IF (FLASHING='0')
THEN
-- aggiorna stato
IF (STATO<BASE)
THEN
STATO:=STATO+1;
ELSE
STATO:=0;
END IF;

END IF;

-- elabora uscite in fnzione dello stato

IF (STATO<=PERIODO_ROSSO)
THEN
-- Rosso
ROSSO:='1';
VERDE:='0';
GIALLO:='0';
ELSIF (STATO<=(PERIODO_ROSSO+PERIODO_VERDE))
THEN
-- Verde
ROSSO:='0';
VERDE:='1';
GIALLO:='0';
ELSE
-- Verde-Giallo
ROSSO:='0';
VERDE:='1';
GIALLO:='1';
END IF;
2/3

-- semaforo lampeggiante ?
IF (FLASHING='1')
THEN
STATO:=0;
ROSSO:='0';
VERDE:='0';
GIALLO:=NOT(GIALLO);
END IF;
-- Reset ? (prioritario)
IF (RESET='1')
THEN
STATO:=0;
ROSSO:='0';
VERDE:='0';
GIALLO:='0';
END IF;
R<=ROSSO;
V<=VERDE;
G<=GIALLO;
Z<=STATO;
END PROCESS;
END arch_semaforo;

3/3

Controllo di un semaforo : risultato della simulazione

Lapproccio seguito per il progetto della rete di controllo di
un semaforo risulta sostanzialmente diverso dalla sintesi
mediante metodi canonici studiati nel Corso di Reti Logiche.
Anche in questo caso si evidenzia la modularit della sintesi
attraverso il VHDL: cambiando pochi parametri del codice si
ottiene una rete di controllo adattabile alle diverse fasi di
controllo di un semaforo generico.

Modelli di ritardo disponibili in VHDL

Il ritardo del Not elettronico

+E
causa: Vi

Vu

alta
bassa
tempo

Vi
effetto: Vu
alta

T1

T2

bassa
tempo

Il ritardo di propagazione

ritardo di propagazione: tp

Ritardo puro
tp
t < tp

Ritardo inerziale

nessun
effetto
tp

Il modello del ritardo inerziale il pi vicino alla realt.

Il ritardo puro (o matematico) per pi facile da simulare.

In VHDL(*) sono simulabili

entrambi i tipi di ritardo:

Ritardo Inerziale (default)

y <= a AFTER 5 ns;

Ritardo Puro
y <= TRANSPORT a AFTER 5 ns;

(*) Altera Max + II effettua la sintesi su dispositivi con ritardi specifici.