Limbaje de descriere hardware (HDL)

Considerente privind VHDL si Verilog

Aplicatii ale HDL

Limbajele de descriere hardware (HDL - Hardware Description Language)
dezvoltate si optimizate pentru a descrie comportamentul sistemelor digitale.

modelul in HDL poate fi

refolosit pentru mai multe
proiecte

sunt limbaje

VHDL (VHSIC HDL - Very High Speed Integrated Circuit Hardware Description
Language) - standard IEEE 1076 din 1987. A fost refacut in 1993, devenind " standard IEEE
1076 /1993".
Verilog HDL este mai vechi decat VHDL si este utilizat intensiv din 1983. A devenit IEEE
standard 1364 I /1995.
Pentru a modela hardware in orice limbaj HDL sunt importante 2 aspecte: comportamentul
abstract si structura hardware.
VHDL/Verilog

comparatie

Capabilitatea:
Structura hardware poate fi modelala in ambele tipuri de limbaj. Alegerea unui tip de limbaj
se face in functie de preferinta personala, disponibilitate in uneltele de dezvoltare etc.

Figura 1. HDL capabilitati de modelare in

functie de nivelul de abstractizare

Compilarea
VHDL.
Multiple unitati de design (perechi entitate/arhitectura = entity/architecture), care se afla in
acelasi fisier sistem, pot fi compilate separate. Un design bine proiectat va avea fiecare unitate
in alt fisier.
Verilog.
Trebuie tinut cont de ordinea in care se face compilarea codului scris intr-un singur fisier si
compilarea mai multor fisiere. Rezultatele simularii se pot schimba prin simpla schimbare a
ordinii compilarii.

Tipuri de date
VHDL.
Se pot folosi mai multe tipuri de date definite in limbaj cat si definite de utilizator. Exista
functii dedicate care fac conversia dintr-un tip in alt tip de date. VHDL este preferat, deoarece
ofera o flexibilitate mai mare.
Verilog.
Comparat cu VHDL, tipurile de date din Verilog sunt mai simple, usor de folosit si apropiate
modelarii structurii hardware in opozitie cu modelarea hardware abstracta.
Nu sunt premise tipuri de date definite de utilizator.
Exemplu de tipuri de date: net, wire, reg (registru).

Reutilizarea design-ului
VHDL. Procedurile si functiile pot fi plasate in pachet (package) astfel incat sa fie disponibile
pentru orice design.
Verilog. Nu exista un concept de pachet ca in VHDL. Functiile si procedurile utilizate intr-un
model trebuie definite in modul. Pentru a le face accesibile din diferite module, se vor plasa in
fisiere separate si incluse unde este nevoie prin folosirea directivei de compilare include .

Usurinta de invatare
Verilog este probabil mai usor de invatat. VHDL poate parea mai putin intuitiv dar dupa
invatare este mai robust, mai puternic. Sunt mai multe posibilitati de a modela acelasi circuit,
mai ales pentru structuri mari, ierarhice.

Constructii de nivel inalt

VHDL. Sunt mai multe posibilitati in modelarea de nivel inalt in VHDL decat in Verilog. Tipul
de date abstract poate fi folosit cu urmatoarele declaratii:
* package pentru reutilizarea modelului,
* configuration - configurare structura design,
* generate pentru structuri repetitive,
* generic model generic care poate fi caracterizat individual, de exemplu latimea unui vector
Toate aceste declarati din limbaj sunt utile in sintetizarea unui model.
Verilog. In afara de parametrizarea unui model prin supraincarcarea parametrilor, nu exista
echivalent pentru modelare de nivel inalt.

Extensia de limbaj
VHDL. Are un atribut denumit 'foreign care permit arhitecturilor si subprogramelor sa fie
modelate in alte limbaje.
Verilog. Foloseste Programming Language Interface (PLI)
mecanism de interfata intre
modelul Verilog si uneltele de dezvoltare pentru Verilog. Un vanzator de unelte pentru Verilog
poate specifica functii in limbajul C si apelarea din descrierea surselor in Verilog.
Utilizarea acestor functii speciale va face ca modelele sa fie nestandard si se poate sa nu poata
fi folosite de alte unelte Verilog. Utilizarea nu este recomandata.

Biblioteci
VHDL. O biblioteca este pentru a stoca entitati compilate, arhitecturi, pachete si configuratii.
Sunt utile pentru proiecte cu multiple design-uri.
Verilog. Nu exista conceptul de biblioteca in Verilog. Aceasta se datoreaza faptului ca la
origini este un limbaj interpretativ.

Constructii de nivel low level

VHDL. Operatori logici simpli pentru 2 intrari care sunt construiti in limbaj: NOT, AND, OR,
NAND, NOR, XOR si XNOR. Orice specificare de timp trebuie facuta dupa clauza after.
Verilog. Verilog a fost dezvoltat avand la baza modelarea la nivel de poarta. Example: User
Defined Primitive(UDP), tabele de adevar si blocuri pentru specificarea intarzierilor intr-un
modul.

Gestionarea proiectelor mari

VHDL. Declaratiile configuration, generate, generic si package sunt foloste pentru a gestiona
proiecte mari.
Verilog. Nu exista declaratii care sa ajute gestionarea proiectelor mari.

Operatori
Majoritatea operatorilor sunt la fel in cele 2 limbaje. Verilog are operatori unari de reducere,
ceea ce in VHDL se rezolva prin bucle. VHDL are modul operator care nu este si in Verilog.
Parametrizarea modelelor.
VHDL. Un model specific de o anumite latime de biti poate fi instantiat printr-un model generic
de n-bit, folosind o declaratie de tip generic. Modelul generic nu va fi sintetizabil decat daca
este instantiat si este data valoarea generica.
Verilog. O latime specifica de bit intr-un model poate fi instantiata de la un model generic n-bit
folosind suprascrierea parametrilor. Modelul generic trebuie sa aiba o valoare implicita definita.
Proceduri si task-uri
VHDL permite apelarea procedurilor concurente. Verilog nu permite apelul concurent.
Usurinta intelegerii codului
VHDL este un limbaj concis cu radacini in limbajul Ada. Verilog este mai apropiat de C
deoarece constructia lui este 50% C si 50% Ada.

Replicarea structurala
VHDL. Declaratia generate statement permite folosirea unui numar de instante ale aceluiasi
design si conectarea potrivita a acestora.
Verilog. Nu are un echivalent pentru generate.

VHDL

Bazele limbajului

Limbajele HDL au doua atributii principale:

Modelare (simulare)
Descriere (sinteza)
VHDL are foarte multe capabilitati pentru a descrie comportarea componentelor electronice
de la porti logice pana la microprocesoare. (Se pot descrie fronturile crescatoare si respectiv
descrescatoare ale semnalelor, intarzierile prin porti, operatii functionale).

Concepte fundamentale: concurenta si ierarhia

VHDL furnizeaza 2 clase de

obiecte care pot fi folosite
pentru modelare in hardware

VHDL

Aria de utilizare

Hardware design
ASIC: technology mapping
FPGA: CLB mapping
Solutii standard, modele, descrieri comportamentale
Software design
VHDL - C interface (unelte specifice)
cercetare (hardware/software co-design). Intrebarea care se pune este ce parte
trebuie implementate in software si ce parte in hardware. (constrangerile vor fi
date de performante, cerinte si pret)

Standarde pentru limbajul VHDL

VHDL este construit prin folosirea mai multor standarde IEEE:
IEEE std 1076-1987

primul standard VHDL. Este referit prin abrevierea VHDL 87.

IEEE std 1076-1993

al doilea standard VHDL. Este referit prin abrevierea VHDL 93.

IEEE std 1164-1993 - package STD_LOGIC_1164. Include tipuri referitoare la hardware si functii de
conversie.
IEEE std 1076a - imbunatateste folosirea variabilelor partajate
IEEE std 1076.1 VHDL-AMS, - standard extins pentru analogic.
IEEE std 1076.2
pentru imaginare.
IEEE std 1076.3

pachete matematice. Este divizat intr-un pachet pentru numere reale si alt pachet
operatori si tipuri descrisi pentru sinteza.

IEEE std 1076.4 VITAL (VHDL Initiative Towards ASIC Libraries).

specificarea timpilor pentru simulare
IEEE std 1076.5

modelarea bibliotecilor in VHDL.

IEEE std 1076.6

defineste partea pentru sinteza RTL.

De exemplu folosit pentru

Concepte VHDL: concurenta si ierarhia

Se executa consecutiv, ca la orice limbaj de programare. Este importanta ordinea in care
apar atribuirile si declaratiile.

Execution of assignments:
Sequential
Concurrent

Methodologies: tehnici de
modelare

Abstraction
Modularity
Hierarchy
Declaratiile sunt active continuu, ordinea nu este importanta. Sunt potrivite pentru modele
paralele.

Abstractizare permite descrierea diferitelor parti din sistem. Informatia care este prea in
detaliu si nu este importanta pentru descriere va fi indepartata. Nivelul de abstractizare este
caracterizat de informatii comune pentru toate modelele de la acest nivel.
Nivelul de abstractizare in proiectarea IC

La nivelul comportamental se descrie functionarea modelului. Nu exista clock pentru

sistem, tranzitii ale semnalelor etc. Uzual, este simulabil, nu si sintetizabil.
Register Transfer Level (RTL) designul este divizat in elemente de logica combinationala
si elemente de stocare. Elementele de stocare (Flip Flops (FFs), latches) sunt controlate de un
ceas al sistemului. Descrierea la nivel RT este numita descriere sintetizabila.
La nivel logic, design-ul este reprezentat ca o lista de legaturi cu porti logice (AND, OR,
NOT, ) si elemente de stocare.

Descrierea comportamentala in VHDL

o <= transport i1 + i2 * i3 after 100 ns;

RT Level in VHDL

In VHDL comportamentul functional este modelat folosind procesul (processes).

La nivel RT:
proces combinational pur
proces comandat de ceas (implica FF si pot fi descrisi in termeni de masini de stare)

Gate Level in VHDL

Fiecare elemnt al circuitului (ex. U86) este instantiat ca si componenta (ND2) si este
conectata la semnalele corespunzatoare (n192, n191, n188). Fiecare poarta folosita
apartine unei biblioteci unde se gasesc si informatii aditionale cum ar fi aria, intarzierile de
propagare, capacitate etc.

Modularitatea si ierarhia

Modularitatea - Se partitioneaza blocuri functionale mari in unitati mici. Existenta subsistemelor

permite mai multor proiectanti sa lucreze in paralel la acelasi proiect.
Ierarhia un design poate fi alcatuit din module care la randul lor contin sub-module. Un nivel ierarhic
poate contine unul sau mai multe module cu un grad diferit de abstractizare.
Modularitatea si ierarhia permit organizarea unui proiect.

Procesul de proiectare incepe cu faza de specificare. Componenta care este proiectata este
definita in ceea ce priveste functiile, interfata etc.
Modulele continute trebuie definite la nivel de sistem (system level). Se descrie interfata (intrari,
iesiri, formatul datelor), marimea clock-ului, mecanismul de reset. Pe baza acestei informatii se
poate implementa si modelul de simulare. Modelul comportamental poate fi integrat in sistem
folosind modele deja existente.
La nivel logic (logic level) - modelul trebuie descris avand in vedere toate aspectele necesare
pentru a fi sintetizabil. In urma sintezei din descrierea modelului abstract se deriva functiile
boolean si se mapeaza elementele in blocurile logice configurabile ale FPGA sau in biblioteca de
porti pentru ASIC. Rezultatul este o lista de legaturi, netlist la nivel de poarta - gate level
Fiecare tranzitie la un nivel de abstractizare de nivel mai scazut va fi verificat prin validari
functionale (validation). Pentru acest scop, se simuleaza descrierea in asa fel incat pentru toti
stimulii (=semnale de intrare pentru simulare) se compara cu raspunsurile modulului.
VHDL este potrivit pentru proiectare de la system level la gate level.

Numai un subset al limbajului VHDL este sintetizabil!

Generalitati
Comentarii: '--' pana la sfarsitul liniei
Declaratiile se termina cu ';
Delimitator lista ','
Atribuire semnal: '<='
Nume definite de utilizator:
litere, numere, underscores
Incep cu o litera

---------------------------------- Example VHDL Code ----------------------------------signal mySignal: bit;

-- an example signal

MYsignal <= '0',

'1' AFTER 10 ns,
'0' after 10 ns,
'1' afTer 10 ns;

-- start with '0'

-- and toggle after
-- every 10 ns

Elemente structurale VHDL

Entity : descrie o interfata constituita dintr-o lista de porturi
Architecture : descrie functia unui modul corespunzator
Configuration : model, structura, ierarhie (in general este utilizata pentru simulare)
Process : permite o executie secventiala - eveniment controlat
Package : pentru design modular. Contine: solutii standard, tipuri de date, constante
Library : o colectie de unitati compilate VHDL (cod obiect)

Ex. declararea
unui port este
permisa numai
in entitate

Plasarea declaratiilor pentru diferite obiecte in VHDL

Entitate si arhitectura (Entitie / Architectures)

Fiecare descriere a unui design in VHDL va contine cel putin o pereche entity/architecture
( referita si ca design entity).
entity descrie circuitul asa cum apare din exterior, din perspectiva interfetei intrare/iesire. Se va
furniza interfata completa a circuitului (numele, directia si tipul de date pentru fiecare port).
architecture orice entitate va avea o arhitectura corespunzatoare care va descrie functia
acesteia. Orice este declarat in entitate, va fi automat accesibil in arhitectura.

Structura generala a
arhitecturii

Conectare ierarhica

Un modul poate fi alcatuit din mai multe sub-module. Conexiunea dintre submodule este definita
intr-o arhitectura de tip top module . Exemplu: un modul fulladder poate fi realizat din 2
module halfadders (module1, module2) si o poarta OR (module3).
O arhitectura structurala va contine o lista de componente si definirea interconexiunilor.

Declararea si instantierea unei componente

Instantierea componentelor : Asocierea numelor semnalelor

Un proces care este privit ca un intreg este

tratat concurent, ca orice declaratie dintr-o
arhitectura

Exemplu proces:

Exemplu proces:

Exemplu proces:

package

colecteaza declaratii folosite in mod global pentru diferite unitati de design. Este alcatuit
din: declaratii de tip, constante, sub-programe etc. Acestea vor fi vizibile in orice unitate de design dintrun proiect si pot fi compilate intr-o biblioteca pentru o utilizare ulterioara. Consta din 2 parti: parte
declarativa si optional dintr-un corp. Se va folosi use pentru a putea fi folosit in unitatile de design.

Exemplu:

Biblioteci (library)

Model de comunicare VHDL

Toate procesele se executa paralel, fara sa conteze entitatea sau nivelul ierarhic unde sunt
localizate. Comunica intre ele prin intermediul semnalelor. (signals)

Obiecte, tipuri de date si operatori

Obiectele (objects)

folosite pentru a reprezenta si stoca date.

Tipuri de baza (folosite la descrierea unui design pentru sinteza sau folosite pentru a crea
teste functionale unde de test): signals, variables si constants (semnale, variabile si
constante)
Fiecare obiect declarat are un tip de date specific - data type (cum ar fi bit sau integer) cu
un set unic de posibile valori. Exemplu: un obiect de tip bit poate avea numai doua valori
posibile, '0' si '1',

Nota: Simbolul VHDL <= - reprezinta operatorul de atribuire (asignare) (atribuie valoarea din partea
dreapta pentru variabila din partea stanga )

Tipuri de date Standard Logic

Standard Logic IEEE 1164
Pachetul std_logic_1164 este compilat intr-o biblioteca numita ieee, si include urmatoarele
tipuri de date:
Type Std_ulogic

reprezinta un singur fir (wire) care poate avea diferite valori logice

std_ulogic este un tip enumerare similar cu tipul bit din standardul 1076. Este un tip de
date unresolved . Un semnal de acest tip poate avea numai un singur driver,

Tipul std_ulogic_vector
Reprezinta o colectie de fire (wire) sau un bus de marime arbitrara.
type std_ulogic_vector is array ( natural range <> ) of std_ulogic;
Std_ulogic_vector
bit_vector.

reprezinta o arie de std_ulogic, si este analog cu tipul standard

Tipul Std_logic
Este un tip de date resolved bazat pe std_ulogic (este un sub-tip), cu urmatoarea
declaratie:
subtype std_logic is resolved std_ulogic;
In cazul driverelor multiple, cele noua valori std_logic sunt rezolvate cu valori dupa cum
urmeaza: ("std_logic" permite existenta driverelor multiple pentru un semnal simplu)

Tipul Std_logic_vector type std_logic_vector is array ( natural range <>) of std_logic;

Operatori standard:
Valorile, semnalele si variabilele unui tip pot fi combinate in expresii prin folosirea operatorilor

Exemplu: Descrierea unui comparator folosind IEEE 1164 standard logic

comentariu
declarare library se incarca biblioteca IEEE.
Use - specifica ce anume din biblioteca ieee
este disponibil pentru design-ul realizat
(declarat prin antitate si arhitectura). Forma
generala include 3 campuri, separate prin
punct.
std_logic si std_logic_vector, sunt tipuri de
date standard din IEEE 1164 standard si in
biblioteca asociata IEEE
Descrie functionalitatea
comparatorului

ANEXE

Problema: Realizarea unui algoritm si a unui circuit care realizeaza operatia de aflare a celui mai
mare divizor comun. Se vor folosi limbajele VHDL, Verilog, C
1) Se vor realiza la nivel de algoritm 3 algoritmi care vor determina cel mai mare divizor comun (Greatest
Common Divisor (GCD)) in C si in 2 limbaje de descriere hardware: VHDL si Verilog.
2) Se vor modela algoritmii GCD la nivelul RTL pentru sinteza in ambele tipuri de limbaje HDL, VHDL si
Verilog. Modelul trebuie sa fie generic, astfel incat sa fie aplicabil pt diferite latimi de biti.
Semnalul Load indica cand datele de intrare sunt valide
Semnalul led Done va fi activat in momentul ibn care datele de iesire sunt valide
Modelul Generic se va verifica pentru semnale de 8 biti..
3) Se vor face testari ale modelelor: 1) la nivel de algoritm se va folosi acelasi fisier 2). Se vor instantia
ambele modele RTL si la nivel de porta sintetizabila si se vor simula si testa in acelasi timp.
Fisierul de test:
file: gcd_test_data.txt
21
49
7
25
30
5
19
27
1
40
40
40
250
190
10
5
250
5

file: gcd_test_data_hex.txt
15
31
7
19
1E
5
13
1B
1
28
28
28
FA
6E
A
5
FA
5

// Decimal
// Decimal
// Decimal
// Decimal
// Decimal
// Decimal

21
25
19
40
250
5

49
30
27
40
190
250

7
5
1
40
10
5

Algoritmul folosit este dupa cum urmeaza:

Algoritmul modelat in C
#include <stdio.h>
main ()
{
int A_in, B_in, A, B, Swap, Y, Y_Ref, Passed;
FILE *file_pointer;
file_pointer = fopen("gcd_test_data.txt", "r");
Passed = 1;
while (!feof(file_pointer))
{
/*------------------------------------*/
/* Read test data from file
*/
/*------------------------------------*/
fscanf (file_pointer, "%d %d %d\n", &A_in, &B_in, &Y_Ref);
/*----------------------------------*/
/* Model GCD algorithm
*/
/*----------------------------------*/
A = A_in;
B = B_in;
if (A != 0 && B != 0)
{
while (B != 0)
{
while (A >= B)
{
A = A - B;
}
Swap = A;
A = B;
B = Swap;
}
}
else
{
A = 0;
}

Y = A;
/*------------------------------*/
/* Test GCD algorithm

*/

/*------------------------------*/
if (Y != Y_Ref)
{
printf ("Error. A=%d B=%d Y=%d Y_Ref= %d\n", A_in, B_in, Y, Y_Ref);
Passed = 0;
}
}
if (Passed = 1) printf ("GCD algorithm test passed ok\n");
}

Algoritmul descris in VHDL

Modelul in VHDL urmareste principiul din C. Cand se citesc valorile intregi din fisierul de test,
acestea vor fi introduse intr-o variabila, nu vor putea fi citite si assignate unui semnal. Rezultatele
vor fi inscrise intr-un fisier. Deoarece este la nivel de algoritm, entitatea folosita nu va contine nici
intrari si nici iesiri.
VHDL algorithmic level model
library STD;
use STD.TEXTIO.all;
entity GCD_ALG is
end entity GCD_ALG;
architecture ALGORITHM of GCD_ALG is
--------------------------------------------- Declare test data file and results file
-------------------------------------------file TestDataFile: text open
read_mode is "gcd_ test_data.txt";
file ResultsFile: text open write_mode is
"gcd_alg _test_results.txt";
begin
GCD: process
variable A_in, B_in, A, B, Swap, Y, Y_Ref: integer range 0 to 65535;
variable TestData: line;
variable BufLine: line;

variable Passed: bit := '1';

begin
while not endfile(TestDataFile) loop
-------------------------------------- Read test data from file
------------------------------------readline(TestDataFile, TestData);
read(TestData, A_in);
read(TestData, B_in);
read(TestData, Y_Ref);

------------------------------------- Model GCD algorithm

-----------------------------------A := A_in;
B := B_in;
if (A /= 0 and B /= 0) then
while (B /= 0) loop
while (A >= B) loop
A := A - B;
end loop;
Swap:= A;
A := B;
B := Swap;
end loop;
else
A := 0;
end if;
Y := A;
---------------------------------- Test GCD algorithm
--------------------------------if (Y /= Y_Ref) then -- has failed
Passed := '0';
write(Bufline, st ring'("GCD Error: A="));
write(Bufline, A_in);
write(Bufline, string'(" B="));
write(Bufline, B_in);
write(Bufline, string'(" Y="));
write(Bufline, Y);
write(Bufline, string'(" Y_Ref="));
write(Bufline, Y_Ref);
writeline(ResultsFile, Bufline);
end if;
end loop;
if (Passed = '1') then -- has passed
write(Bufline, string' ("GCD algorithm test has passed"));
writeline(ResultsFile, Bufline);
end if;
end process;
end architecture ALGORITHM;

Algoritmul in Verilog
Modelul Verilog va urma de asemenea principiile descrise in C.
O diferenta majora este aceea ca Verilog nu poate citi valori zecimale dintr-un fisier. Datele citite dintr-un
fisier sunt:
1) citire folosind $readmemh sau $readmemb si
2) stocarea in memorie. Datele de citire vor fi in format binary sau in hex. Se va folosi fisierul
"gcd_test_data_hex.txt"
Verilog algorithmic level model
module GCD_ALG;
parameter Width = 8;
reg [Width-1:0] A_in, B_in, A, B, Y, Y_Ref;
reg [Width-1:0] A_reg,B_reg,Swap;
parameter GCD_tests = 6;
integer N, M;
reg Passed, FailTime;
integer SimResults;
// Declare memory array for test data
// ---------------------------------reg [Width-1:1] AB_Y_Ref_Arr[1:GCD_tests*3];
//---------------------------------// Model GCD algorithm
//---------------------------------always @(A or B)
begin: GCD
A = A_in;
B = B_in;
if (A != 0 && B != 0)
while (B != 0)
while (A >= B) begin
A = A - B;
Swap = A;
A = B;
B = Swap;
end
else
A = 0;
Y = A;
end

//-----------------------------// Test GCD algorithm

//----------------------------initial begin
// Load contents of
// "gcd_test_data.txt" into array.
$readmemh("gcd_test_data_hex.txt", AB_Y_Ref_Arr);
// Open simulation results file
SimResults = $fopen("gcd.simres");
Passed = 1;
/ Set to 0 if fails
for (N=1; N<=GCD_tests; N=N+1) begin
A_in = AB_Y_Ref_Arr[(N*3)+1];
B_in = AB_Y_Ref_Arr[(N*3)+2];
Y_Ref=AB_Y_Ref_Arr[(N*3)+3];
#TestPeriod
if (Y != Y_Ref) begin
// has failed
Passed = 0;
$fdisplay (SimResults, " GCD Error:
A=%d B=%d Y=%d. Y should be %d", A_in, B_in, Y, Y_Ref);
end
end
if (Passed == 1) // has passed
$fdisplay (SimResults, "GCD algorithm test has passed");
$fclose (SimResults);
$finish;
end
endmodule

Proiectarea modelului la nivel RTL in VHDL si Verilog

Modelul va avea intrari si iesiri.
Intrari: Clock, Reset_N si Load,
Iesirea:Done.
Cand Load este la nivel logic 1, datele de intrare sunt disponibile la iesire si se incarca in registri separati
A_hold si B_ hold.
Cand Done=1, semnifica ca s-a calculat cel mai mare divizor comun.
Procesul va dura cativa cicli de ceas.
Modelul se imparte in 3 procese process (VHDL) si /always (Verilog)
I) primul process/always LOAD_SWAP. Presupune folosirea a doua registre care opereaza dupa cum urmeaza:
1) Reset_N = 0, A_hold and B_hold = zero.
2) Cand not 1) si Load = 1, datele in A si B sunt incarcate in A_hold si B_hold.
3) Cand not 1) sau 2) si A_hold este mai mic decat B_hold, valorile in A_hold si B_hold sunt schimbate intre
ele,
4) Cand not 1), 2) sau 3), A_hold este reincarcat cu aceeasi valoare. Valoarea A_hold - B_hold, din cel de al
doilea process/always statement, este incarcat in B_hold.
II) al doilea process/always SUBTRACT_TEST.
Primul if testeaza daca A_hold este mai mare sau egal cu B_hold.
Daca este asa, se face scaderea A_hold - B_hold, rezultatul este introdus in A_New care va fi incarcat in
B_hold pe urmatorul front crescator al ceasului.

Daca A_hold este mai mic decat B_hold, scaderea nu se face, A_New va avea valoarea B_hold, schimbarea
va fi facuta dupa urmatorul front pozitiv al semnalului de ceas.
Al doilea if verifica daca B_hold are valoarea 0.
Daca da, semnalul Done=1, valoarea A_ hold este incarcata la iesirea Y prin intermediul unei functii de
multiplexare.
Problema este sintetizabila pentru un model generic cu semnale de 8 biti.
In Verilog se seteaza parametrul Width=8. Nu mai nevoie de a fi instantiat separate inainte de a fi sintetizat.
In VHDL se foloseste generic. Valoarea este specificata numai in momentul instantierii

VHDL RTL model

library IEEE;
use IEEE.STD_Logic_1164.all, IEEE.Numeric_STD.all;
entity GCD is
generic (Width: natural);
port (Clock,Reset,Load: in std_logic;
A,B:

in unsigned(Width-1 downto 0);

Done:

out std_logic;

Y:

out unsigned(Width-1 downto 0));

end entity GCD;

architecture RTL of GCD is
signal A_New,A_Hold,B_Hold: unsigned(Width-1 downto 0);
signal A_lessthan_B: std_logic;
begin
----------------------------------------------------- Load 2 input registers and ensure B_Hold < A_Hold
---------------------------------------------------

LOAD_SWAP: process (Clock)

begin
if rising_edge(Clock) then
if (Reset = '0') then
A_Hold <= (others => '0');
B_Hold <= (others => '0');
elsif (Load = '1') then
A_Hold <= A;
B_Hold <= B;
else if (A_lessthan_B = '1') then
A_Hold <= B_Hold;
B_Hold <= A_New;
else A_Hold <= A _New;
end if;
end if;
end process LOAD_SWAP;

SUBTRACT_TEST: process (A_Hold, B_Hold)

begin
-------------------------------------------------------- Subtract B_Hold from A_Hold if A_Hold >= B_Hold
-----------------------------------------------------if (A_Hold >= B_Hold) then
A_lessthan_B <= '0';
A_New <= A_Hold - B_Hold;
else
A_lessthan_B <= '1';
A_New <= A_Hold;
end if;
-------------------------------------------------- Greatest common divisor found if B_Hold = 0
------------------------------------------------if (B_Hold = (others => '0')) then
Done <= '1';
Y <= A_Hold;
else
Done <= '0';
Y <= (others => '0');
end if;
end process SUBTRACT_TEST;
end architecture RTL;

Verilog RTL model

module GCD (Clock, Reset, Load, A, B, Done,
Y);
parameter Width = 8;
input Clock, Reset, Load;
input [Width-1:0] A, B;
output Done;
output [Width-1:0] Y;
reg A_lessthan_B, Done;
reg [Width-1:0] A_New, A_Hold, B_Hold, Y;
//---------------------------------------------------// Load 2 input registers and ensure B_Hold <
A_Hold
//---------------------------------------------------always @(posedge Clock)
begin: LOAD_SWAP
if (Reset) begin
A_Hold = 0;
B_Hold = 0;
end
else if (Load) begin
A_Hold = A;
B_Hold = B;
end
else if (A_lessthan_B) begin
A_Hold = B_Hold;
B_Hold = A_New;
end
else
A_Hold = A_New;
end

always @(A_Hold or B_Hold)

begin: SUBTRACT_TEST
//------------------------------------------------// Subtract B_Hold from
A_Hold if A_Hold >= B_Hold
//------------------------------------------------if (A_Hold >= B_Hold) begin
A_lessthan_ B = 0;
A_New = A_Hold - B_Hold;
end
else begin
A_lessthan_B = 1;
A_New = A_Hold;
end
//--------------------------------------------// Greatest common divisor
found if B_Hold = 0
//--------------------------------------------if (B_Hold == 0) begin
Done = 1;
Y = A_Hold;
end
else begin
Done = 0;
Y = 0;
end
end
endmodule

Referinte bibliografice:
[1] Douglas J. Smith - VHDL & Verilog Compared & Contrasted - Plus Modeled Example Written in
VHDL, Verilog and C
[2] - http://www.vhdl-online.de/tutorial/englisch/t_13.htm
[3] - Accolade VHDL Reference Guide - http://www.acc-eda.com/vhdlref/
[4] Prof. Sherief Reda Division of Engineering, Brown University Spring 2007 - Reconfigurable
Computing
[5] - Dr. Gilles SASSATELLI- Lecture on Reconfigurable Technologies, 2009

This document was created with Win2PDF available at http://www.daneprairie.com.

The unregistered version of Win2PDF is for evaluation or non-commercial use only.