8.Organizare model

In acest capitol se va arata cum se poate scrie o descriere completa VHDL a unui sistem digital.

a)Unitati si biblioteci de design

Descrierile VHDL se scriu intr-un "design file" , se analizeaza cu un compiler care le introduce intrun "design library". O biblioteca este formata din mai multe unitati ("library units"). Unitatile de biblioteca primare sint declarathle de unitati, de package-uri si de configuratie. Unitatile de biblioteca secundare sint corpurile de package-uri si arhitecturile. Aceste unitati depind de specificarea interfetei lor, care se face in unitati primare. Deci unitatile de biblioteca primare trebuie analizate inaintea oricarei unitati secundare corespunzatoare.

Un fisier de design ("design file") contine mai multe unitati de biblioteca. Sintaxa este:

fisier_design ::= unitate design {unitate design }

unitate_design ::= clauza_context unitate_biblioteca

clauza_context ::={context }

context ::= clauza biblioteca I clauza use

clauza biblioteca ::= library lista nume logic ;

lista_nume_logic ::= nume logic { , nume_logic }

unitate_biblioteca ::= unitate primara unitate secundara

unitate_primara ::=declaratie_entitate declaratie-configuratie declaratie_package

unitate_secundara ::= arhitectura I corp_package

Bibliotecile sint referite folosind identificatori numiti NUME LOGICE. Numele logic trebuie tradus de sistemul de operare gazda in alt nume, dependent de implementare.

De exemplu, bibliotecile pot fi niste fisiere de baze de date, numele logic reprezentind numele unui fisier de baze de date. Unitatile dintr-o biblioteca pot fi referite prin prefixarea numelui for cu numele logic al bibliotecii. "ttl lib.ttl_10" se poate referi h unitatea "ttl_10" din biblioteca "ttl lib".

Clauza care precede fiecare unitate specifica ce alte biblioteci sau package-uri sint folosite. Scopeul numelor specifcate in clauza de context se intinde pina la sfirsitul unitatii de design.

Exista 2 biblioteci speciale care sint disponibile implicit tuturor unitatilor, si deci nu a necesar sa fie numite in clauze de context. WORK este biblioteca de lucru, in care vor fi plasate de catre analizor unitatile de design curente. Intr-o unitate se pot referi unitatile analizate anterior folosind numele bibliotecii "work". STD este o biblioteca de design care contine package-urile "standard" si "textio". "Standard" contine toate tipurile si functiile predefinite. Toate elementele din acest package sint implicit vizibile, deci nu e necesara clauza use pentru a le accesa.

b)Configuratii.

Am aratat cum se poate declara o specificare de componente intr-o descriere structurala, si cum se pot crea instante ale componentelor. Legatura dintre o entitate si componente se face prin declararea de configuratie. Intr-o astfel de declaratie se pot specifics constantele generice actuale pentru componente si blocuri.

Sintaxa este:

declarare_configuratie ::=configuration identificator of nume_entitate is

parte_declarativa_configuratie

configuratie bloc

end [ nume_configuratie ];

parte_declarativa_configuratie ::={ declarare configuratie }

declarare_configuratie ::= clauza_use

configuratie_bloc ::=

for specificare bloc

{ clauza_use }

{ conf iguratie }

end for ;

specificare_bloc ::= nume-arhitectura | eticheta_instructiune_bloc

configuratie ::= configuratie_bloc | configuratie_componenta

configuratie_componenta ::= for specificare_componenta

[ use legatura ; ]

[ configuratie_bloc ]

end for ;

specificare_componenta ::= lista_instantieri nume_componenta

lista_instantieri ::= eticheta_instantiere { , eticheta_instantiere }

others all

legatura ::=

aspect_entitate

[ map_generic ]

[ map port ]

aspect_entitate :.= entity nume_entitate [(identificator arhitectura)]

configuration nume-configuratie

open

map-generic ::= generic map (lista asociatii generic)

map port ::= port map (lists asociatii port)

Configuratia unei astfel de arhitecturi este:

configuration test_config of processor is

use work.processor_types. all

for block_structure

elemente configuratie

end for

end test_config;

In acest exemplu, continutul package-ului "processor types" din biblioteca de lucru curenta este vizibil, iar configurarea de bloc se refera la arhitectura "block structure" a entitatii "processor".

Se pot configura submodulele dintr-o arhitectura. Acestea contin blocuri si instante de componente. Iata o configurare de blocuri pentru arhitectura prezentata mai sus:

configuration test_config of processor is

use work.processor_types. all

for block_structure

for control_unit

elemente_configuratie

end for;

for data_path

elemente_configuratie

end for;

end_for;

end test_config;

Daca submodulul este o instanta a unei componente, configuratia componentei este folosita pentru a lega o entitate de instanta componentei.

Fie blocul "data-path", care contine o instanta a componentei "alu", declarata astfel:

data_path: block port(lista porturi);

port map (lista asociatii);

component alu

port(function: in alu_function; opl,op2: in bit_vector_32; result: out bit-vector-32);

end component ;

alte declaratii pentru data_path

begin

data_alu:alu

port map(function=>alu fn,opl=>bl,op2=>b2, result=>alu r);

alte declaratii pentru data_path

end block data_path;

Fie biblioteca "project cells" cu entitatea "alu cell" definita astfel:

entity alu_cell is

generic(width : positive);

port( function code : in alu_function; operand1, operand2 : in bit_vector(width-1 downto 0);

result : out bit_vector(width-1 downto 0); flags : out alu_flags); end alu_cell;

Entitatea are o arhitectura numita "behaviour". Aceasta entitate poate fi legata cu instanta "alu" daca porturile operanzi si rezultat pot fi puse in corespondenta cu porturile componentei, porturile "flags" putind fi lasate neconectate.

for data_path

for data_alu:alu

use entity project cells.alu_cell (behaviour)

generic map (width=>32)

port map (function code=>function, operandi=>opl, operand2=>op2, result=>result, flags=> open );

end for ;

alte declaratii pentru data path

end for ;

Daca biblioteca include si o configuratie "alu-struct" pentru o arhitectura a entitatii "alu_cell" atunci configuratia de bloc arata astfel:

for data_path

for data alu:alu

use configuration project_cells.alu_struct

generic map (width => 32)

port map (function code=>function, operandi=>opl, operand2=>op2,

result=>result, flags=> open );

end for ;

alte declaratii pentru data path

end for ;

c)Exemplu complet

Prezentam in continuare un fisier de design pentru exemplul din capitolul 1. Fisierul contine mai multe unitati de design care sint analizate in ordine. Prima unitate reprezinta declararea entitatii "count2". Urmeaza 2 entitati secundare - arhitecturi ale entitatii "count2". Urmeaza o alta deeclarare de entitate, un test pentru numarator ("test bench"). Urmeaza o unitate secundara, care reprezinta descrierea structurala a bancii de test. Urmeaza o declarare de configuratie, care face referiri la unitatile de bibliteca definite anterior, din biblioteca de lucru si deci nu a nevoie de clauza de context. Se observa ca entitatea "cunt2" este referita in cadrul configuratiei cu numele "work. count2". Urmeaza o declrare de configuratie cu arhitectura "structure" a entitatii "count2". Ea utilizeaza 2 unitati("misc.t flipflop", "misc. inverter") din biblioteca separata "misc", deci e necesara o clauza de biblioteca.

Aceasta descriere cuprinde toate unitatile intr-un singur fisier. Dar a posibil ca unitatile de design sa fie impartite pe mai multe fisiere ( cazul extrem fiind o unitate intrun fisiewr). Daca exista mai multe fisiere, ele trebuie compilate in ORDINEA corecta, si trebuie recompilate fisierele dependente de o unitate in care s-au operat modificari.

--unitate primara: declaratia entitatii count2

entity count2 is

generic(prop_delay: Time := 10 ns);

port(clock: in bit; q1,q0 . out bit);

end count2;

--unitate secundara: architectura-comportament pentru count2

architecture behaviour of count2 is

begin count_up: process (clock)

variable count-value: natural := 0;

begin if clock='1' then

count value:=(count value+1) mod4;

q0<=bit'val(count_value mod 2) after prop_delay;

q1<=bit'val(count_value/2) after prop delay;

end if ; end process count_up;

end behaviour ;

--unitate secundara: architectura-structura pentru count2

architecture structure of count2 is

component t_flipflop port(ck: in bit; q: out bit);

end component;

component inverter port(a: in bit;y: out bit);

end component;

signal ffo,ffi,inv_ff0: bit;

begin

bit-0: t-flipflop port map (ck=>clock, q=>ff0);

inv: inverter port map (a=>ff0, y=>inv ff0);

bit 1:t flipflop port map (ck=>inv-ff0, q=>ffl);

q0<=ff0; q1<=ff1;

end structure ;

--unitate primara: declaratia entitatii de testare

entity test _count2 is

end test count2;

--unitate secundara: arhitectura-structura pentru test

architecture structure of test_count2 is

signal clock,q0,q1: bit;

component count2

port(clock: in bit; q1,q0: out bit);

end component;

begin counter : count2

port map (clock => clock, q0 => q0, q1 => q1);

clock driver : process

begin wait for 100 ns;

end process clock_driver;

end structure;

-- unitate primara: configuratie cu architectura comportament

configuration test count2 behaviour of test_count2 is

for structure pentru test_count2

for counter : count2

use entity work.count2(behaviour);

end for;

end for ;

end test_count2_behaviour;

-- unitate primara: configuratie cu architectura

structura library misc;

configuration test_count2_structure of test_count2 is

for structure --pentru test_count2

for counter : count2

use entity work.count2(structure);

for structure --pentru count_2

for all :t_flipflop

use entity misc.t_flipflop(behaviour);

end for;

for all :inverter

use entity misc.inverter(behaviour);

end for;

end for;

end for;

end for;

end test_count2_structure;