1

Język VHDL

Very high speed integrated Hardware Description Language

przemysłowy standard języka HDL

(IEEE Std 1076-1987, IEEE Std 1076-1993)

VHDL jest językiem przenośnym

może być stosowany przez systemy różnych firm

Powszechnie stosowany w specyfikacjach układów
cyfrowego przetwarzania sygnałów:

•

U. Meyer Baese, DSP with FPGAs, Springer, Berlin 2001,

•

K. K. Parchi, T. Nishitani, Digital Signal Processing for

Multimedia Systems, Marcel Dekker, Inc. New York 1999

2

Język VHDL

Š Zawiera użyteczne konstrukcje semantyczne

umożliwiające zwięzłą specyfikację złożonych
układów cyfrowych

Š Projekt może być opisany hierarchicznie (na wielu

poziomach)

Š Możliwe jest korzystanie z biblioteki gotowych

elementów i tworzenie podukładów (tzw.
komponentów)

3

Jednostka projektowa

ENTITY DECLARATION

ARCHITECTURE BODY

FUNKCJE

I DZIAŁANIE

entity HALFADD is

port (A,B : in bit;

SUM, CARRY : out bit);

end HALFADD;

architecture BEHAVE of HALFADD is

begin

SUM <= A xor B;

CARRY <= A and B;

end BEHAVE;

DESIGN ENTITY

WEJŚCIE/WYJŚCIE

PARAMETRY

JEDNOSTKA PROJEKTOWA

4

Jednostka projektowa języka VHDL

entity

architecture

architecture

architecture

Komunikacja

z otoczeniem

Działanie układu

5

Najprostsza struktura pliku

ENTITY halfadd IS
PORT (A, B

: IN bit;

SUM, CARRY : OUT bit);

END halfadd;
ARCHITECTURE behave OF halfadd IS

BEGIN

;

END behave;

Słowo kluczowe

Key Word

Deklaracje

Sygnałów we/wy

Sekcja opisu logicznego

To samo co w pliku
halfadd.vhd

Ta sama nazwa

SUM <= A xor B;

CARRY <= A and B;

6

Jednostka deklaracji

entity HALFADD is

port (A,B : in bit;

SUM, CARRY : out bit);

end HALFADD;

Deklaracja sygnałów

nazwa

tryb

typ danych

A

B

SUM

CARRY

7

Jednostka deklaracji

entity HALFADD is

port (A,B : in bit;

SUM, CARRY : out bit);

end HALFADD;

T

ry

b

y

por

tu

•in

- wejściowy

•out

- wyjściowy

•inout

- dwukierunkowy

•buffer

- wyjściowy z możliwością odczytu

Typy danych:

bit, bit_vector, integer, Boolean

8

Blok architektury

architecture BEHAVE of HALFADD is

begin

SUM <= A xor B;

CARRY <= A and B;

end BEHAVE;

Style specyfikacji

funkcjonalny (behavioralny)

przepływ danych (dataflow)

strukturalny

Działanie lub

budowa

A

B

SUM

CARRY

Architektura opisuje sposób działania jednostki (entity) lub jej

budowę (strukturę).

9

Blok architektury

architecture nazwa_arch of nazwa_jednostki is

begin

end nazwa_arch;

Definicje i deklaracje:
(typów, podtypów, stałych,
sygnałów, komponentów,
konfiguracji)

– instrukcje przypisania wartości do
sygnałów
– procesy
– komponenty

10

Elementy strukturalne języka VHDL

¾ Słowa kluczowe
¾ Identyfikatory
¾ Obiekty danych
¾ Operatory
¾ Atrybuty
¾ Instrukcje

11

Słowa kluczowe

IF, THEN, CASE...

BEGIN, END..

AND, OR, NAND, XOR...

SIGNAL, COMPONEN, IN, OUT

abs

downto

library

postponed

Srl

access

else

linkage

procedure

Subtype

after

elsif

literal

process

Then

alias

end

loop

pure

To

all

entity

map

range

Transport

and

exit

mod

record

Type

architecture

file

nand

register

Unaffected

array

for

new

reject

Units

assert

function

Next

rem

Until

attribute

generate

Nor

report

Use

begin

generic

Not

return

Variable

block

group

Null

rol

Wait

body

guarded

Of

ror

When

buffer

if

On

select

While

bus

impure

Open

severity

With

case

in

Or

signal

Xnor

component

inertial

Others

shared

Xor

configuration

inout

Out

sla

constant

is

Package

sll

disconnect

label

Port

sra

12

Š Identyfikatory mogą się składać z liter, cyfr

i podkreślników

Š Wielkość liter nie ma znaczenia
Š Nazwa musi się rozpoczynać od litery
Š Nazwa nie powinna być dłuższa niż 16 znaków
Š Nazwa powinna być znacząca

Ta_Sama_Nazwa

TA_SAMA_NAZWA

ta_sama_nazwa

16_bit_bus

: integer; -- bł

ę

dnie

_bus_16_bit_ : integer; -- bł

ę

dnie

bus_16_bit

: integer; -- O.K.

Identyfikatory

13

Obiekty danych

Obiekty danych służą do przechowywania wartości.
Wyróżnia się trzy klasy obiektów:

•

sygnał – signal

•

zmienne – variable

•

stałe – constant

Wartości zmiennych są przypisywane natychmiast,

wartości sygnałów – z pewnym opóźnieniem.

Odpowiednikiem sprzętowym sygnału jest ścieżka w

układzie scalonym.
Zmienna nie ma odpowiednika sprzętowego i służy do

obliczeń na wyższym poziomie abstrakcji.

14

Pojęcie typu danych

entity HALFADD is

port (A,B

: in bit;

SUM, CARRY : out bit);

end HALFADD;

Wartości dozwolone w sygnale typu bit:

′′′′

0

′′′′

′′′′

1

′′′′

Język VHDL jest bardzo silnie zorientowany na typy danych.
Każdy obiekt musi mieć zdefiniowany typ i może przechowywać
dane tylko tego typu.

SIGNAL signal_name : type_name ;

Przy operacji przyporządkowania sygnałów, typy danych
po każdej stronie operatora przyporządkowania muszą
być zgodne

15

Typy danych

BIT, BIT_VECTOR,

STD_LOGIC, STD_LOGIC_VECTOR,

(STD_ULOGIC),

SIGNED, UNSIGNED, INTEGER,

ENUMERATION, BOOLEAN

Wyróżnia się 10 typów danych sygnału:

16

Predefiniowane typy danych

STD_LOGIC, STD_LOGIC_VECTOR

LIBRARY IEEE;

use IEEE.Std_Logic_1164.all;

STD_LOGIC: 0, 1, Z, –,

L, H, U, X, W

STD_LOGIC_VECTOR jest tablicą obiektów z STD_LOGIC

17

Sygnał może być zdefiniowany w jednostce deklaracji oraz w części

deklaracyjnej architektury lub pakietu.

Sygnał posiada trzy cechy z nim skojarzone:

typ

wartość

Składnia

signal nazwa_syg: typ_syg[:=wart_pocz];

np.:

signal s1, s2 : bit;
signal liczba : integer := 7;

Sygnały

18

Stałe to takie obiekty danych, których wartości

nie zmieniają się w trakcie symulacji

Stałe mogą być zadeklarowane w jednostce

projektowej, pakiecie, procesie, architekturze,
funkcji i procedurze

Składnia:

Š

constant nazwa : typ := warto

ść

;

np.:
constant zero:STD_LOGIC_VECTOR(3 DOWNTO
0):=”0000”;

Stałe

19

Typ wyliczeniowy

Typ wyliczeniowy (enumeration type) może być definiowany przez użytkownika.
Przykład:
type MY_STATE is (RESET, IDLE, RW_CYCLE, INT_CYCLE);
...
signal STATE : MY_STATE;
signal TWO_BIT : bit_vector (0 to 1);
...
STATE <= RESET;

O.K.

Ale do sygnału STATE nie można przyporządkować
każdego 2-bitowego ciągu binarnego.

STATE <= ”00”

NIE

STATE <= TWO_BIT

NIE

20

Typ wyliczeniowy c.d.

Typ wyliczeniowy jest kodowany na minimalnej

liczbie bitów w zapisie wg NKB:

RESET <= ”00”

IDLE

<= ”01”

RW_CYCLE <= ”10”

INT_CYCLE <= ”11”

21

Tablice

Typy BIT_VECTOR oraz STD_LOGIC_VECTOR s

ą

tablicami sygnałów typu BIT i STD_LOGIC

Dane typu tablicowego mog

ą

by

ć

definiowane

przez u

ż

ytkownika

TYPE Byte IS ARRAY (7 DOWNTO 0) OF STD_LOGIC;

SIGNAL X : Byte;

Zakres tablicy jest definiowany pod

odpowiedni

ą

deklaracj

ą

za pomoc

ą

s

ł

ów

kluczowych: „to” „downto”

22

Tablice

signal Z_BUS:bit_vector(3 downto 0);

signal C_BUS:bit_vector(1 to 4);

Z_BUS <= C_BUS;

Przyporządkowanie dla danych tego samego typu i zakresu

Z_BUS(3) <= C_BUS(1);

Z_BUS(2) <= C_BUS(2);

Z_BUS(1) <= C_BUS(3);

Z_BUS(0) <= C_BUS(4);

Z_BUS(3 downto 2) <= "00";

C_BUS(2 to 4) <= Z_BUS(3 downto 1);

W przyporządkowaniu można odwo

ł

ywać się do fragmentów tablic

23

Dostarczają dodatkowych informacji o obiektach (np. sygnałach,

zmiennych, typach lub komponentach)

Pewna liczba atrybutów jest predefiniowana

Składnia

obiekt’atrybut[(parametr)];

Przykładowe atrybuty

‘EVENT – równy TRUE, gdy zachodzi zmiana wartości sygnału,

‘STABLE – równy TRUE, gdy nie zachodzi zmiana wartości sygnału

‘LEFT - zwraca lewą granicę zakresu

‘RIGHT - zwraca prawą granicę zakresu

‘RANGE - zwraca zakres typu

Atrybuty

24

Przykład (atrybuty)

type count is integer range 0 to 127

type states is (st1, st2, st3, st4);

count’left = 0

count’ right = 127

states’left = st1

states’high = st4

If Clock’event and Clock = ‘1’ then Q := D;

25

Operatory

INTEGER, BIT,BIT_VECTOR

**, ABS, NOT

różne

INTEGER

*, /, MOD, REM

mnożenia

INTEGER

+, –

znaku

INTEGER, BIT_VECTOR

+, –, &

dodawania

Argumenty – ten sam typ;
wynik - BOOLEAN

=, /=, <, <=, >, >=

relacji

BIT, BOOLEAN, BIT_VECTOR

AND, OR, NAND, NOR,
XOR, XNOR

logiczne

Typ danych

Operator

Klasa

operatorów

26

Operatory - przykłady

library IEEE;

use IEEE.Std_Logic_1164.all;

entity MVLS is

port (A,B,C : in std_logic;

Z

: out std_logic);

end MVLS ;

architecture EX of MVLS is

begin

Z <= A and not(B or C);

end EX ;

signal A_BUS, B_BUS, Z_BUS :

std_logic_vector (3 downto 0);

Z_BUS <= A_BUS and B_BUS;

Z_BUS(3) <= A_BUS(3) and B_BUS(3);

Z_BUS(2) <= A_BUS(2) and B_BUS(2);

Z_BUS(1) <= A_BUS(1) and B_BUS(1);

Z_BUS(0) <= A_BUS(0) and B_BUS(0);

if A = B then

Z <= '1';

else

Z <= '0';

end if;

27

Instrukcje

Współbieżne (Concurrent assignment statement)

Sekwencyjne (Sequential assignment statement)

WSPÓŁBIEŻNE I SEKWENCYJNE

28

Instrukcje

Współbieżne:

X <= A + B;

Z <= C + X;

Z <= C + X;

X <= A + B;

Zachowanie układu jest niezależne od kolejności

instrukcji przyporządkowania sygnałów.

Stosowane w specyfikacji typu „przepływ danych”

(dataflow description).

Sekwencyjne:

Instrukcje sekwencyjne są stosowane w specyfikacji behawioralnej

(behavioral description). Przede wszystkim w tzw. procesach (process).

Porządek zapisu instrukcji sekwencyjnych zmienia działanie układu.

29

Instrukcje współbieżne - przykład

Entity test1 Is
Port ( a, b : in bit;

c, d : out bit);

end test1;
architecture test1_body of test1 is

begin

c <= a and b;
d <= a or b;

end test1_body;

Entity test1 Is
Port ( a, b : in bit;

c, d : out bit);

end test1;
architecture test1_body of test1 is

begin

d <= a or b;
c <= a and b;

end test1_body;

Kolejność występowania instrukcji nie ma znaczenia

Są wykonywane
jednocześnie

30

Tak samo

c <= a and b;
d <= a or b;

d <= a or b;
c <= a and b;

Przykład c.d.

31

(Concurrent Signal Assignment Statements)

¾ podstawowe przypisanie do sygnału

(simple signal assignment statement)

¾ warunkowe przypisanie do sygnału

(conditional signal assignmenet statement)

¾ selektywne przypisanie do sygnału

(selected signal assignment statement)

– when – else

– with – select

Współbieżne instrukcje przypisania sygnału

32

Instrukcja podstawowa

Składnia:

signal_name <= expression;

signal_name <= expression after delay;

Przykład:

ENTITY simpsig IS

PORT (a, b: IN BIT;

c, d: OUT BIT) ;

END simpsig;

ARCHITECTURE arch1 OF simpsig IS

BEGIN

c <= a AND b;

d <= b;

END arch1;

33

Instrukcja podstawowa (przykładzik)

library ieee;

use ieee.std_logic_1164.all;

entity mux is port (

a, b, c, d : in std_logic ;

s:

in std_logic_vector (1 downto 0) ;

x:

out std_logic ) ;

end mux;

architecture archmux of mux is
begin

x <=

(a and not(s(1)) and not(s(0)))
or (b and not(s(1)) and (s(0))
or (c and (s(1) and not(s(0)))
or (d and (s(1) and (s(0));

end archmux

34

Instrukcja selektywna

Składnia:

with sel_sig

select

signal_name <= value_a when value1_of_sel_sig ,

value_b when value2_of_sel_sig ,

value_c when value3_of_sel_sig , ...

value_x when last_value_of_sel_sig;

35

Instrukcja selektywna -

with-select

Używana wewnątrz architektury

Podobieństwo do znanej instrukcji

case

Można określać kilka wartości lub zakres

Wartości nie mogą się powtarzać

Przykładzik:

with INT_A select

Z <= A when 0,

B when 1 to 3,
C when 4 | 6 | 8,
D when others;

36

Instrukcja warunkowa

Składnia:

signal_name <= value_a when condition1 else

value_b when condition2 else

value_c when condition3 else ...

value_x;

37

Instrukcja warunkowa -

when-else

Odpowiednik instrukcji

if-then-else

Składnia

sygnał <= wart1 when warunek1 else

wart2 when warunek2 else

[...]

wartN when warunekN;

A <= In1 when war1=1 else

In2 when war2=2 else

In3;

38

entity multiplekser is

-- jednostka o nazwie 'multiplekser'

port(i0,i1,i2,i3 : in bit;

-- deklaracja wejsc informacyjnych

s1,s0

: in bit;

-- deklaracja wejsc sterujacych

Y

: out bit); -- deklaracja wyjscia)

end multiplekser;

architecture opis of multiplekser is

-- architektura o nazwie 'opis' opisujaca jednostke multiplekser

signal wybor : integer range 0 to 3;

-- deklaracja sygnalu pomocniczego o nazwie 'wybor'

-- 'wybor' jest liczba calkowita z zakresu od 0 do 3

begin

with wybor select

Y <= i0 when 0,

i1 when 1,

i2 when 2,

i3 when others;

wybor <= 0 when s1='0' and s0='0' else

1 when s1='0' and s0='1' else

2 when s1='1' and s0='0' else

3;

end opis;

i0

i1
i2
i3

s1 s0

Y

Przykładzik (multiplekser)

39

Instrukcja podstawowa (przykład)

library ieee;

use ieee.std_logic_1164.all;

entity mux is port (

a, b, c, d: in std_logic_vector (3 downto 0);

s:

in std_logic_vector (1 downto 0);

x:

out std_logic_vector (3 downto 0));

end mux;

X

A

B

D

C

S1

S0

MUX

40

Instrukcja podstawowa (przykład c.d.)

architecture archmux of mux is
begin

x (3) <=

(a(3) and not(s(1)) and not(s(0)))

or (b(3) and not(s(1)) and (s(0))
or (c(3) and (s(1) and not(s(0)))
or (d(3) and (s(1) and (s(0));

x (2) <=

(a(2) and not(s(1)) and not(s(0)))

or (b(2) and not(s(1)) and (s(0))
or (c(2) and (s(1) and not(s(0)))
or (d(2) and (s(1) and (s(0));

x (1) <=

(a(1) and not(s(1)) and not(s(0)))

or (b(1) and not(s(1)) and (s(0))
or (c(1) and (s(1) and not(s(0)))
or (d(1) and (s(1) and (s(0));

x (0) <=

(a(0) and not(s(1)) and not(s(0)))

or (b(0) and not(s(1)) and (s(0))
or (c(0) and (s(1) and not(s(0)))
or (d(0) and (s(1) and (s(0));

end archmux

41

Instrukcja selektywna (przykład)

library

ieee;

use ieee.std_logic_1164.all;
entity mux is port(

a, b, c, d:

in std_logic_vector(3 downto 0);

s:

in std_logic_vector(1 downto 0);

x:

out std_logic_vector(3 downto 0);

end mux;

architecture archmux of mux is

begin
with s select

x <= a when ”00”,

b when ”01”,
c when ”10”,
d when others;

end archmux;

42

Instrukcja warunkowa (przykład)

library ieee;
use ieee.std_logic_1164.all;
entity mux is port (

a, b, c, d:in std_logic_vector (3 downto 0);
s:

in std_logic_vector (1 downto 0);

x:

out std_logic_vector (3 downto 0));

end mux;

architecture archmux of mux is
begin

x <= a

when (s = ”00”) else

b when (s = ”01”) else
c when (s = ”10”) else
d;

end archmux;

43

Ostrzeżenie przed pochopnym wnioskiem

Można podać wiele przykładów, w których
zastosowanie instrukcji podstawowej
prowadzi do znacznie lepszej implementacji

Jednym z nich jest komparator

(patrz Układy cyfrowe, bloki funkcjonalne)

Wniosek: instrukcja podstawowa jest niewygodna
do specyfikacji układów

44

LIBRARY ieee;

USE ieee.std_logic_1164.all;

USE ieee.std_logic_unsigned.all;

ENTITY compare_8bit IS

PORT (A, B:

IN

STD_LOGIC_VECTOR(7 DOWNTO 0);

AeqB, AgtB, AltB: OUT STD_LOGIC );

END compare_8bit;

ARCHITECTURE Behavior OF compare_8bit IS

BEGIN

AeqB <= '1' WHEN A = B ELSE '0';

AgtB <= '1' WHEN A > B ELSE '0';

AltB <= '1' WHEN A < B ELSE '0';

END Behavior;

Komparator wersja 1

45

LIBRARY ieee;

USE ieee.std_logic_1164.all;

USE ieee.std_logic_unsigned.all;

ENTITY compare_2_8bit IS

PORT (a7,a6,a5,a4,a3,a2,a1,a0:

IN

STD_LOGIC;

b7,b6,b5,b4,b3,b2,b1,b0:

IN

STD_LOGIC;

AeqB, AgtB, AltB:

OUT STD_LOGIC);

END compare_2_8bit;

ARCHITECTURE Behavior OF compare_2_8bit IS

SIGNAL i7,i6,i5,i4,i3,i2,i1,i0:

STD_LOGIC;

SIGNAL AequalB,AgreaterB,AlesserB: STD_LOGIC;

BEGIN

i7 <= NOT (a7 XOR b7);

i6 <= NOT (a6 XOR b6);

i5 <= NOT (a5 XOR b5);

i4 <= NOT (a4 XOR b4);

i3 <= NOT (a3 XOR b3);

i2 <= NOT (a2 XOR b2);

i1 <= NOT (a1 XOR b1);

i0 <= NOT (a0 XOR b0);

Komparator wersja 2

46

AequalB <= i7 AND i6 AND i5 AND i4 AND i3 AND i2 AND i1 AND i0;

AgreaterB <= (a7 AND (not b7)) OR (i7 AND a6 AND (not b6))

OR (i7 AND i6 AND a5 AND (not b5))

OR (i7 AND i6 AND i5 AND a4 AND (not b4))

OR (i7 AND i6 AND i5 AND i4 AND a3 AND (not b3))

OR (i7 AND i6 AND i5 AND i4 AND i3 AND a2 AND (not b2))

OR (i7 AND i6 AND i5 AND i4 AND i3 AND i2 AND a1 AND (not b1))

OR (i7 AND i6 AND i5 AND i4 AND i3 AND i2 AND i1 AND a0 AND

(not b0));

AlesserB <= NOT (AequalB OR AgreaterB);

AeqB <= AequalB;

AgtB <= AgreaterB;

AltB <= AlesserB;

END Behavior;

Komparator wersja 2 c.d.

47

Wersja 1:

MAX 7000: 48 makrokomórek, 27 expanderów
FLEX:

20 komórek

Wersja 2:

MAX 7000: 32 makrokomórki, 15 expanderów FLEX: 13
komórek

Specyfikacja za pomocą instrukcji
podstawowej prowadzi do dużo
lepszej implementacji!!!

Realizacje komparatora

48

Koder z priorytetem

w

3

w

2

w

1

w

0

y

1

y

0

z

0

0

0

0

−

−

0

0

0

0

1

0

0

1

0

0

1

∗

0

1

1

0

1

∗

∗

1

0

1

1

∗

∗

∗

1

1

1

Tablica prawdy

49

Koder z priorytetem (instrukcja warunkowa)

library ieee;

use

ieee.std_logic_1164.all;

entity priority is

port (w :

in

std_logic_vector (3

downto

0);

y:

out

std_logic_vector(1

downto

0);

z:

out

std_logic);

end priority;

architecture behavior of priority is

begin

y

<= ”11” when

w(3)

=

‘1’

else

”10” when

w(2)

=

‘1’

else

”01” when

w(1)

=

‘1’

else

”00”;

z

<= ‘0’ when

w =

”0000” else ‘1’;

end behavior;

50

Koder z priorytetem (instrukcja selektywna)

entity priority is

port (w :

in

std_logic_vector (3

downto

0);

y:

out

std_logic_vector(1

downto

0);

z:

out

std_logic);

end priority;

architecture behavior2 of

priority

is

begin

with w select

y <= "00" when "0001",

"01" when "0010",

"01" when "0011",

"10" when "0100",

"10" when "0101",

"10" when "0110",

"10" when "0111",

"11" when others;

with w select

z <= ‘0’ when "0000",

‘1’ when others;

end behavior2;

51

Instrukcje sekwencyjne

Instrukcje sekwencyjne są stosowane w specyfikacji
behawioralnej (behavioral description)

Przede wszystkim w tzw. procesach (process)

Proces

Instrukcja IF

Instrukcja CASE

52

Proces

Name :

PROCESS (sensitivity_list)

BEGIN

Instrukcja sekwencyjna #1

Instrukcja sekwencyjna #2

.......

Instrukcja sekwencyjna # N
END PROCESS

name

;

Składnia:
Process ( )
begin

..

end process

Lista czułości

Instrukcje sekwencyjne są
wykonywane kolejno
jedna po drugiej

Etykieta jest opcjonalna

53

Konstrukcja wykonywana równolegle

Występuje wewnątrz architektury

Zawiera opis zachowania

Instrukcje wewnętrzne wykonywane są

sekwencyjnie

Zawiera:

T

listę czułości (ang. sensitivity list);
jest to lista sygnałów, których zmiana
powoduje aktywację procesu

Procesy

54

Š Procesy nie mogą być zagnieżdżane
Š Wewnątrz architektury może występować dowolna liczba

procesów

Š W części deklaracyjnej można definiować: typy, podtypy,

stałe, atrybuty i zmienne

Š Nie można deklarować sygnałów
Š Składnia:

[etykieta:] process [ ( lista_czuło

ś

ci ) ] [ is ]

--definicje i deklaracje

begin

--instrukcje_sekwencyjne;

end process [ etykieta ] ;

Procesy c.d.

55

Przykładowa organizacja procesu

architecture A of E is

begin

-- concurrent statements

P1 : process

begin

-- sequential statements

end process P1;

-- concurrent statements

P2 : process

begin

-- sequential statements

end process P2;

-- concurrent statements

end A;

56

if

warunek

then

sekwencja_instrukcji1

{

elsif

warunek

then

sekwencja_instrukcji2 }

[

else

sekwencja_instrukcji3]

end if

;

Jest to instrukcja sekwencyjna

Część

elsif

może wystąpić dowolną ilość

razy

Część

else

nie musi wystąpić

Część

elsif

może używać wielokrotnie

Może być zagnieżdżana

Składnia:

Instrukcja warunkowa

if then else

57

elsif warunek

if warunek

elsif warunek

F

sekwencja_instrukcji2

sekwencja_instrukcji1

sekwencja_instrukcji3

sekwencja_instrukcji4

F

else

T

F

T

T

end if;

if then else

58

Przykład (bramka ex-or)

if (q < 10 ) then

a:= b;

elsif (q = 10) then

a:= c;

else a:= d;

end if;

entity xor_gate is

port ( a: in bit;

b: in bit;

y: out bit);

end xor_gate;

architecture xor_gate_arch1 of xor_gate is

begin

gate:process(a, b)

begin

if a=b then y<='0';

else y<='1';

end if;

end process gate;

end xor_gate_arch1;

architecture xor_gate_arch2 of xor_gate is

begin

Y <= '0' when a=b else '1';

end xor_gate_arch2;

59

Š Instrukcja sekwencyjna

Š Podobna do instrukcji

with select

Š Można określać kilka wartości lub zakres
Š Wartości nie mogą się powtarzać
Š Składnia (przykład):

case

zm_wielow

is

when

wybór1 => sekwencja1_instrukcji ;

when

wybór2 =>

sekwencja2_instrukcji ;

[

when others

=> sekwencja3_instrukcji ; ]

end case;

Instrukcja wyboru -

case

60

case inp is

when 0

=> Y <= A;

when 1 to 3 => Y <= B;

when 4|6|8

=> Y <= C;

when others => Y <= 'X';

end case;

entity mp is

port ( instr : in instrukcja;

addr

: in integer;

data

: inout integer:=0);

end mp;

architecture opis of mp is

type regtype is array (0 to 255) of integer;

signal a, b : integer;

signal reg

: regtype;

begin

process(instr)

begin

case instr is

when lda => a<= data;

when ldb => b<= data;

when add => a<= a + b;

when sub => a<= a - b;

when sta => reg(addr)<=a;

when stb => reg(addr)<=b;

when outa => data<= a;

when xfr => a <= b;

end case;

end process;

end opis;

case sterowanie is

when

"00" =>

sel := 1

when

"01" =>

sel := 1;

when

"10" =>

sel := 2;

when others => sel := 3;

end case;

Przykłady

61

Instrukcja

IF

if CONDITION then

-- sequential statements

end if;

if CONDITION then

-- sequential statements

else

-- sequential statements

end if;

if CONDITION then

-- sequential statements

elsif CONDITION then

-- sequential statements

elsif CONDITION then

-- sequential statements

else

-- sequential statements

end if;

62

Instrukcja

IF

(przykład)

process (A, B, C, X)

begin

if (X = "0000") then

Z <= A;

elsif (X <= "0101") then

Z <= B;

else

Z <= C;

end if;

end process;

63

Instrukcja

CASE

(składnia)

case OBJECT is

when VALUE_1 =>

-- statements

when VALUE_2 =>

-- statements

when VALUE_3 =>

--statements

--etc...

end case;

64

Instrukcja

CASE

(przykład)

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;

65

entity mux is port(

a, b, c, d: in bit;

s: in bit_vector(1 downto 0);

x: out bit);

end mux;

architecture archmux1 of mux is

begin

mux4_1: process (a, b, c, d, s)

begin

if s = "00" then

x <= a;

elsif s = "01" then

x <= b;

elsif s = "10" then

x <= c;

else

x <= d;

end if;

end process mux4_1;

end archmux1;

architecture archmux2 of mux is

begin

x <= a when (s = "00") else

b when (s = "01") else

c when (s = "10") else

d;

end archmux2;

Archmux1 i Archmux2

X

A

B

D

C

S1

S0

MUX

66

architecture archmux3 of mux is

begin

process (a,b,c,d,s)

begin

case s is

when "00" => x<= a;

when "01" => x<= b;

when "10" => x<= c;

when "11" => x<= d;

end case;

end process;

end archmux3;

architecture archmux4 of mux is

signal SEL : bit_vector(1 downto 0);

begin

with SEL select

x <= a when "00",

b when "01",

c when "10",

d when "11";

SEL <= s;

End archmux4;

Archmux3 i Archmux4

67

Architecture archmux5 of mux is

Begin

x

<=

(a and not(s(1)) and

not(s(0)))

OR

(b and not(s(1)) and s(0))

OR

(c and s(1) and not(s(0)))

OR

(d and s(1) and s(0));

end archmux5;

Archmux5

68

architecture archmux6 of mux is

begin

mux4_1: process (a, b, c, d, s)

begin

if s = "00" then

x <= a;

end if;

if s = "01" then

x <= b;

end if;

if s = "10" then

x <= c;

end if;

if s = "11" then

x <= d;

end if;

end process mux4_1;

end archmux6;

Archmux6

69

Archmux1 i Archmux2

A

B

C

D

S1

S0

N0

D

N0

C

N0B

X

70

Archmux3 i Archmux4

A

B

C

D

S1

S0

X

N0

E

N0

D

N0

C

N0

B

71

Archmux5

A

B

C

D

S1

S0

X

72

Archmux6

A

B

C

D

S1

S0

N0

D

N0

H

N0

G

N0

F

N0A

N0E

X

73

Synteza układów sekwencyjnych

VHDL umożliwia bezpośrednią reprezentację
automatu (układu sekwencyjnego). Tablicę
przejść-wyjść można bezpośrednio przetłumaczyć
na specyfikację VHDL.

Wystarczą do tego instrukcje sekwencyjne:
a) wyboru (CASE) oraz
b) warunkowa (IF THEN ELSE).

74

Automat

Case... When...

If... Then

Else

CLK’EVENT

and

CLK=‘1’

Wejścia

Stan następny
(next_state)

Stany bieżące
(present_state)

Układ kombinacyjny

Przerzutniki

75

Zasady specyfikacji automatu

Stany automatu są reprezentowane przez typ

wyliczeniowy, którego wartości są nazwami stanów

Funkcje przejść wyjść są realizowane instrukcjami CASE,

IF THEN wewnątrz PROCESU

Synchronizm zapewnia odpowiednie wyrażenie testujące

zbocze sygnału zegarowego

Specyfikacja jedno- lub dwu-procesowa

Problem kodowania stanów!

76

Przykład: automat Moore’a

x = 0

x = 0

x = 0

x = 1

x = 1

x = 1

A/z = 0

B/z = 0

C/z = 1

Rst

1

C

A

C

0

C

A

B

0

B

A

A

z

1

0

x

s

77

Automat: jednostka deklaracji

LIBRARY ieee;
USE ieee_std_logic_1164.all;

ENTITY automacik IS

PORT (Clock,Rst, x : IN STD_LOGIC;

z

: OUT STD_LOGIC);

END automacik;

78

ARCHITECTURE funkcja_przejsc OF automacik IS

TYPE State_type

IS (A, B, C);

SIGNAL Q : State_type;

BEGIN

PROCESS (Rst, Clock)
BEGIN

IF Rst = '0' THEN

Q <= A;

ELSIF (Clock'EVENT AND Clock = '1') THEN

CASE Q IS

WHEN A =>

IF x = '0' THEN Q <=A; ELSE Q <= B;
END IF;

WHEN B =>

IF x = '0' THEN Q <= A; ELSE Q <= C;
END IF;

WHEN C =>

IF x = '0' THEN Q <= A; ELSE Q <= C;

END IF;

END CASE;

END IF;

END PROCESS;
z <= '1' WHEN Q = C ELSE '0';

END funkcja_przejsc;

Automat Moore’a - wersja I

79

ARCHITECTURE funkcja_przejsc OF simple IS

TYPE State_type

IS (A, B, C);

SIGNAL Q_present, Q_next : State_type ;

BEGIN
PROCESS (x, Q_present)
BEGIN

CASE Q_present IS

WHEN A =>

IF x = '0' THEN Q_next <= A; ELSE Q_next <= B;
END IF;

WHEN B =>

IF x = '0' THEN Q_next <=A; ELSE Q_next <= C;
END IF;

WHEN C=>

IF x = '0' THEN Q_next <= A; ELSE Q_next <= C;
END IF;

END CASE;

END PROCESS;

PROCESS (Clock, Rst)
BEGIN

IF Rst = '0' THEN Q_present <= A;
ELSIF (Clock'EVENT AND Clock = '1') THEN
Q_present <= Q_next;
END IF;

END PROCESS;
z <= '1' WHEN Q_present = C ELSE '0';

END funkcja_przejsc;

Automat Moore’a - wersja II

80

ARCHITECTURE funkcja_przejsc OF simple IS
SIGNAL Q_present, Q_next: STD_LOGIC_VECTOR(1 DOWNTO 0)

CONSTANT A :STD_LOGIC_VECTOR(1 DOWNTO 0) := "00";
CONSTANT B :STD_LOGIC_VECTOR(1 DOWNTO 0) := "01";
CONSTANT C :STD_LOGIC_VECTOR(1 DOWNTO 0) := "11";

BEGIN
PROCESS (x, Q_present)
BEGIN

CASE Q_present IS

WHEN A =>

IF x = '0' THEN Q_next <= A; ELSE Q_next <= B;
END IF;

WHEN B =>

IF x = '0' THEN Q_next <= A; ELSE Q_next <= C;
END IF;

WHEN C =>

IF x = '0' THEN Q_next <= A; ELSE Q_next <= C;
END IF;

WHEN OTHERS => Q_next <= A;

END CASE;

END PROCESS;
PROCESS (Clock, Rst)
BEGIN
IF Rst = '0' THEN Q_next <= A; ELSIF (Clock'EVENT AND Clock = '1') THEN Q_present <= Q_next;
END IF;
END PROCESS;

z <= '1' WHEN Q_present = C ELSE '0';

END funkcja_przejsc;

Automat Moore’a z kodowaniem stanów

81

ASM

Diagramy stanów (tablice p-w) są niewystarczające do opisu US (FSM)
Mało elastyczne przy opisie skomplikowanych układów
Nie przystosowane do stopniowego ulepszania opisu
Nie opisują algorytmu, tzn. sekwencji czynności wykonywanych

w zależności od danych wejściowych

algorytm = sekwencja +przetwarzanie danych

oddzielają sterowanie od danych

Wady te są eliminowane w:

•

Algorithmic State Machine (ASM)

82

Graf ASM

Sygnały wyj.

lub

mikrooperacje

Nazwa stanu

Klatka stanu
(operacyjna)
typu Moore’a

Sygnały

wejściowe

0 (False)

1 (True)

Klatka decyzyjna

(warunkowa)

Sygnały wyjściowe

warunkowe

lub mikrooperacje

Klatka wyjściowa

warunkowa

(typu Mealy’ego)

...zbudowany z wierzchołków (klatek) i krawędzi

83

Graf ASM automatu Moore’a

z

1

C

A

C

0

C

A

B

0

B

A

A

z

1

0

x

s

84

Część

sterująca

(kontroler)

Wejścia
kontrolera

Stan

kontrolera

Wynik

Dane

wejściowe

Sygnały

sterujące

Stan części
operacyjnej

Część operacyjna

(Datapath)

Mikrooperacje

wywoływane przez

sygnały binarne

System cyfrowy

85

Wprowadzanie komponentu ...

. . . do nowej struktury

Deklaracja i podstawienie komponentu:

Komponent może być zadeklarowany w bloku architektury
lub w pakiecie

Instrukcja podstawienia jest też nazywana
instrukcją konkretyzacji

86

Podstawienie komponentu

Nagłówek: nazwa_komp PORT MAP (lista sygnałów)

Przyporządkowanie
sygnałów (asocjacja)

Dwa sposoby przyporządkowania:
a) asocjacja pozycyjna
b) asocjacja nazw

Instrukcja podstawienia (łączenia) komponentu to
współbieżna instrukcja określająca wzajemne połączenie
sygnałów i podukładów zwanych komponentami

87

Wielokrotne stosowanie komponentów:

Pakiet stanowi jednostkę projektową, w której są
zdefiniowane typy, komponenty i inne elementy, które mogą
być wykorzystane wielokrotnie w innych jednostkach
projektowych. Pakiety są przechowane w bibliotekach

Dostęp do pakietu osiąga się deklaracją:

LIBRARY work;
USE work.package_name.all;

work - robocza biblioteka, do której każdy kompilator VHDL ma
bezpośredni dostęp

pakiety

88

Typowe zadanie

Zbudować większy multiplekser mając do dyspozycji mniejsze

Mniejszy mux4to1

Większy mux16to1

Mniejszy zadeklarujemy w pakiecie

jako component

89

Deklaracja komponentu - przykład

LIBRARY ieee ;
USE ieee.std_logic_1164.all ;
PACKAGE mux4to1_package IS

COMPONENT mux4to1

PORT ( d0, d1, d2, d3 : IN STD_LOGIC ;

a

: IN

STD_LOGIC_VECTOR(1 DOWNTO 0) ;

y

: OUT

STD_LOGIC ) ;

END COMPONENT ;

END mux4to1_package ;

90

LIBRARY ieee ;
USE ieee.std_logic_1164.all ;
LIBRARY work ;
USE work.mux4to1_package.all ;

ENTITY mux16to1 IS

PORT ( d

: IN

STD_LOGIC_VECTOR(0 TO 15) ;

a

: IN

STD_LOGIC_VECTOR(3 DOWNTO 0) ;

y

: OUT

STD_LOGIC ) ;

END mux16to1 ;
ARCHITECTURE Structure OF mux16to1 IS

SIGNAL m : STD_LOGIC_VECTOR(0 TO 3) ;

BEGIN

Mux1: mux4to1 PORT MAP ( d(0), d(1), d(2), d(3), a(1 DOWNTO 0), m(0) ) ;
Mux2: mux4to1 PORT MAP ( d(4), d(5), d(6), d(7), a(1 DOWNTO 0), m(1) ) ;
Mux3: mux4to1 PORT MAP ( d(8), d(9), d(10), d(11), a(1 DOWNTO 0), m(2) ) ;
Mux4: mux4to1 PORT MAP ( d(12), d(13), d(14), d(15), a(1 DOWNTO 0), m(3) ) ;
Mux5: mux4to1 PORT MAP

( m(0), m(1), m(2), m(3), a(3 DOWNTO 2), y ) ;

END Structure ;

Podstawienie komponentu - przykład

91

Komponenty systemowe

Makrofunkcje, Megafunkcje
Zorientowane technologicznie, Niezależne od technologii

System MAX + plus II jest wyposażony w:

Library of Parameterized Modules (LPM)

Moduły w LPM są
a)

niezależne od technologii

b)

parametryzowane

92

Konfiguracja modułu LPM

Konfiguracja i wyposażenie jest definiowana parametrami

Moduł sumator/układ odejmujący: lpm_add_sub

a) LPM_WIDTH
b) LPM_CONFIGURATION

a) określa liczbę bitów sumatora
b) określa operację: liczby ze znakiem (signed) lub

liczby bez znaku (unsigned)