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

Jednostka deklaracji

entity HALFADD is

port (A,B : in bit;

SUM, CARRY : out bit);

end HALFADD;

Deklaracja sygnałów

S nazwa
S tryb
S typ danych

A

B

SUM

CARRY

6

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,

7

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ę).

8

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

9

Elementy strukturalne języka VHDL

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

10

Słowa kluczowe

IF, THEN, CASE...

BEGIN, END..

AND, OR, NAND, XOR...

SIGNAL, COMPONENT, 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

11

Š 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

12

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.

13

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 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 przypisania sygnałów, typy danych po
każdej stronie operatora przypisania muszą być zgodne

14

Typy danych

BIT, BIT_VECTOR,

STD_LOGIC, STD_LOGIC_VECTOR,

(STD_ULOGIC),

SIGNED, UNSIGNED, INTEGER,

ENUMERATION, BOOLEAN

Wyróżnia się 10 typów danych:

15

Standardowe 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

16

Sygnał może być zdefiniowany w jednostce deklaracji oraz w

części deklaracyjnej architektury lub pakietu.

Signal nazwa_syg:typ_syg[:=wart_pocz];

np.:

signal s1, s2 : bit;

signal liczba : integer := 7;

variable nazwa_zm: typ_zm [ograniczenia]

np.:

variable u: integer range 0 to 127;

Sygnały i zmienne

17

Stałe mogą być zadeklarowane w jednostce projektowej,

pakiecie, procesie, architekturze...

constant nazwa : typ := warto

ść

;

np.:

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

Stałe

18

Typ wyliczeniowy

Typ wyliczeniowy (enumeration type) może być definiowany przez użytkownika.
Przykład:
type MY_STATE is (State1, State2, State3, State4);
...
signal STATE : MY_STATE;
signal TWO_BIT : bit_vector (0 to 1);
...
STATE <= State1; 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

19

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”

20

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

21

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;

22

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

23

Instrukcje

Współbieżne (Concurrent assignment statement)

Sekwencyjne (Sequential assignment statement)

WSPÓŁBIEŻNE I SEKWENCYJNE

24

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.

25

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

26

(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

27

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;

28

Instrukcja podstawowa (przykład)

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;

29

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

30

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;

31

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;

32

Instrukcja selektywna -

with-select

Odpowiednik 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;

33

Instrukcja warunkowa

Składnia:

signal_name <= value_a when condition1 else

value_b when condition2 else

value_c when condition3 else ...

value_x;

34

Instrukcja warunkowa -

when-else

Odpowiednik instrukcji

if-then-else

Condition jest wyrażeniem boolowskim, a

nie zbiorem wartości

A <= In1 when war1=1 else

In2 when war2=2 else

In3;

35

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;

36

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;

37

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

38

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

39

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

40

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.

41

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

42

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

43

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;

44

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;

45

Instrukcje sekwencyjne

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

Przede wszystkim w tzw. procesach (process)

Proces

Instrukcja IF

Instrukcja CASE

46

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

47

Konstrukcja wykonywana równolegle

Występuje wewnątrz architektury

Zawiera opis behawioralny

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

48

Š 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.

49

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ą

liczbę 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

50

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

51

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;

52

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

53

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

54

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

55

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

56

Archmux1 i Archmux2

A

B

C

D

S1

S0

N0

D

N0

C

N0B

X

57

Archmux3 i Archmux4

A

B

C

D

S1

S0

X

N0

E

N0

D

N0

C

N0

B

58

Archmux5

A

B

C

D

S1

S0

X

59

Archmux6

A

B

C

D

S1

S0

N0

D

N0

H

N0

G

N0

F

N0A

N0E

X

60

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.

Wszystkie inne metody, polegające na
oddzielnej syntezie części kombinacyjnej, a
następnie na dołączaniu do niej rejestru,

nie mają sensu

61

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

62

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!

63

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

64

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;

65

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

66

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

67

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

68

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)

69

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

70

Graf ASM automatu Moore’a

z

1

C

A

C

0

C

A

B

0

B

A

A

z

1

0

x

s

71

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

72

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

73

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

74

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

75

Deklaracja komponentu - przykład

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

COMPONENT mux4to1

PORT ( w0, w1, w2, w3 : IN

STD_LOGIC ;

s

: IN

STD_LOGIC_VECTOR(1 DOWNTO 0) ;

f

: OUT

STD_LOGIC ) ;

END COMPONENT ;

END mux4to1_package ;

76

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

ENTITY mux16to1 IS

PORT ( w

: IN

STD_LOGIC_VECTOR(0 TO 15) ;

s

: IN

STD_LOGIC_VECTOR(3 DOWNTO 0) ;

f

: OUT

STD_LOGIC ) ;

END mux16to1 ;
ARCHITECTURE Structure OF mux16to1 IS

SIGNAL m : STD_LOGIC_VECTOR(0 TO 3) ;

BEGIN

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

( m(0), m(1), m(2), m(3), s(3 DOWNTO 2), f ) ;

END Structure ;

Podstawienie komponentu - przykład

77

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

78

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)