Circuite integrate numerice

Sistem de control al unei tastaturi

matriceale 4x4
Contents
1. Introducere ..................................................................................................................................... 2
Echipament necesar ............................................................................................................................ 2
2. Aspecte teoretice ............................................................................................................................ 2
Tastatura matriceala ........................................................................................................................... 2
Diagrama de stri ................................................................................................................................ 4
Componente utilizate ......................................................................................................................... 4
3. Implementarea in Schematic ....................................................................................................... 4
Decodificatorul 2-4 ............................................................................................................................. 8
Codificatorul de prioritate ................................................................................................................ 11
Maina de stare ................................................................................................................................. 14
Sistemul de control al tastaturii ........................................................................................................ 18
Sistemul de afiare ............................................................................................................................ 22
Top-level ........................................................................................................................................... 27
4. Implementarea in limbaj VHDL ..................................................................................................... 29
Initializarea proiectului ..................................................................................................................... 29
Numaratorul pe 2 biti ....................................................................................................................... 33
Decodificatorul 2-4 ........................................................................................................................... 39
Codificatorul de prioritate ................................................................................................................ 41
Sistemul de afisare ............................................................................................................................ 44
Divizor de clock ................................................................................................................................. 46
Translatorul ....................................................................................................................................... 49
Top-level ........................................................................................................................................... 51
5. Implementare FPGA a programului in VHDL si Schematic ............................................................ 59



1. Introducere
Obiectivul principal al acestei lucrri este realizarea unei interfee cu o tastatur matriceal cu 16
taste si afiarea pe un display led cu 7 segmente a tastei apsate.
Echipament necesar
Xilinx ISE Design Suite 10.1
Plac FPGA Spartan 3 mpreun cu toate accesoriile
necesare funcionrii acesteia
Tastatur matriceal cu 16 taste

2. Aspecte teoretice
Tastatura matriceala
Schema unei tastaturi 4x4 de de acest tip este reprezentat in figura urmatoare:

Sunt necesare 4 intrri in tastatur pentru selecia coloanei prin aplicarea unei stri HIGH (1 logic) pe
una dintre acestea. O singur coloan poate fi selectat la un moment dat pentru o funcionare
corect a tastaturii.
La apsarea unei taste se nchide comutatorul acesteia iar ieirea din tastatur corespunzatoare linei
tastei va avea starea 1 logic, celelalte fiind deconectate. Pentru o funcionare corect se impune ca
strile HIGH-Z ale liniilor deconectate s fie eliminate, i nlocuite cu starea 0.
Rezistenele pull-up si pull-down sunt folosite n circuitele logice pentru a asigura ca intrrile s fie in
strile logice ateptate de ctre acestea n cazul n care dispozitivele externe sunt deconectate sau n
starea HIGH-Z. Diferena dintre acestea este aceea c cele pull-up aduc intrarea la starea 1 logic,
fiind conectate la sursa de tensiune, iar cele pull-down la starea 0 logic , fiind conectate la masa.
Se conecteaz aadar 4 rezistene pull-down la intrrile de la tastatur. Acestea pot fi instantiate n
modul schematic ca simboluri iar n VHDL ca i componente.



Diagrama de stri

Starea
curenta
Intrari Starea
urmatoare
Iesiri
Q
1
Q
0
keypress (P) Q
1
Q
0
count load
00 x 01 1 0
01 x 10 0 0
10 0 00 0 0
10 1 11 0 0
11 x 00 0 1

Din tabelul de stari prin simplificare rezulta urmtoarele functii
booleene de tranziie a strilor:


Expresiile logice ale ieirilor COUNT i LOAD vor fi:


Componente utilizate
Pentru selecia coloanei se vor folosi un numrtor pe 2 bii i un decodificator 2-4
Pentru citirea tastelor apsate se va folosi un codificator de prioritate pe 2 biti.
3. Implementarea in Schematic
Se deschide aplicaia Xilinx ISE 10.1 i se creeaz un nou proiect din meniul File ->
New Project.
Se alege locaia proiectului , numele i tipul acestuia, Schematic i se apas Next.


Se alege dispozitivul ce urmeaza a fi folosit, XC3S200 sau XC3S1000, n cazul n care se
dorete implementarea pe plac, altfel alegerea nefiind important. Programarea este posibil doar
daca tipul selectat coincide cu tipul plcii.


n continuare se apas Next, se ignor adugarea de surse, iar n final Finish.



Se creeaz o nou surs de tip Schematic. Click dreapta in panoul Sources, selectndu-
se apoi New Source.


n noua fereastr se introduce un nume pentru fiierul ce urmeaz a fi creat, selectnd ca tip
Schematic. Se apas Next i apoi Finish.
Sursa creat va fi primul nivel al ierarhiei componentelor, in care se vor regsi celelalte ca
simboluri.
Se ncepe crearea simbolurilor pentru componentele necesare.

Decodificatorul 2-4
Se creeaz o noua surs ca mai sus:

Se adaug in schem dou simboluri logice INV din panoul Sources, Symbols:

Cu ajutorul opiunii Add Wire din bara de instrumente sau folosind
scurttura Ctrl+W se adauga firele.
Se adaug dou intrri din bara de instrumente i se
redenumesc pentru a marca MSB i LSB.

Se adauga restul simbolurilor logice 4 pori AND2
:
Se conecteaz simbolurile nou adaugate i se creeaz ieirile, redenumite deasemenea
intuitiv.
Se verifica schema iar n final se creeaz simbolul componentei din panoul Processes
Create Schematic Symbol


Codificatorul de prioritate

Se incepe prin crearea unei magistrale (bus) pentru intrri. Sunt necesare 4 fire crora le
sunt adaugate nume: I(0), I(1), I(2), I(3).



Pentru aceasta se selecteaz din bara de instrumente Add Net Name i se introduce
numele dorit in panoul Processes- Options, Name. Se selecteaz apoi cu click firul dorit


Se adauga apoi unui al cincilea fir numele I(3:0):

Se adauga un Input marker pe acesta:


Se completeaz schema astfel:


Ieirea en va detecta prezena a cel puin o intrare HIGH, reprezentnd apsarea unei
taste.


Maina de stare
Se creeaz noua surs de tip Schematic:

Se adaug doua flip-flop-uri D din bibliotec (FDR) i se conecteaz in modul urmtor:



Se vor aduga dou intrri pentru clock i reset:

Se adaug urmatoarele componente necesare pentru tranziia strilor:

Se adaug o noua intrare keypress :

Se conecteaz componentele n modul urmtor


Se conecteaz cele doua ieiri load i count :


Schema final va arta astfel:


Se creaz simbolul componentei.
Sistemul de control al tastaturii
Se creaz o noua surs de tip Schematic.

S-au adugat un numrtor pe 2 bii (CB2RE) , un flip-flop D (FDR) i un registru de date pe 4
bii (FD4RE).
Dac s-au creat simbolurile componenetelor anterioare acestea se vor gsi in lista de
simboluri:

Se adaug codificatorul de prioritate, decodificatorul 2-4 i blocul mainii de stare.

Se adaug intrrile clock i reset i se conecteaz la
componente:

Se adaug intrarea din tastatur i se conecteaz la codificatorul de prioritate:

Se conecteaz intrrile i ieirile mainii de stare la celelalte componente:

Se conecteaz decodificatorul 2-4 la numrtor i la ieirea spre tastatur printr-un bus:


Se finalizeaz schema prin adugarea ieirilor bcd_out(3:0) , reprezentnd codul tastei si
update, reprezentnd existena unui nou cod al unei taste apsate la ieire.




Sistemul de afiare

Se va crea o nou sursa de tip Schematic" ca mai sus i una de tip VHDL Module din
panoul Sources-> New Source -> VHDL Module.
Se va folosi urmtorul cod VHDL de translatare a codurilor tastelor, date de poziionarea
acestora pe tastatur, n valorile acestora, date de inscripia de pe taste. Dup aceasta se va crea
simbolul translatorului.

Library IEEE;
use IEEE.STD_LOGIC_1164.ALL;
use IEEE.STD_LOGIC_ARITH.ALL;
use IEEE.STD_LOGIC_UNSIGNED.ALL;

---- Uncomment the following library declaration if instantiating
---- any Xilinx primitives in this code.
--library UNISIM;
--use UNISIM.Vcomponents.all;

ENTITY translator_ent IS
PORT( intrare: IN STD_LOGIC_VECTOR(0 to 3);
iesire: OUT STD_LOGIC_VECTOR(0 to 3));
END translator_ent;

ARCHITECTURE translator_arch OF translator_ent IS
BEGIN
WITH intrare SELECT
iesire <= 0001 WHEN 1111,
0010 WHEN 1110,
0011 WHEN 1101,
1010 WHEN 1100,
0100 WHEN 1011,
0101 WHEN 1010,
0110 WHEN 1001,
1011 WHEN 1000, -- B
0111 WHEN 0111, -- 7
1000 WHEN 0110, -- 8
1001 WHEN 0101, -- 9
1100 WHEN 0100, -- C
1110 WHEN 0011, -- E(*)
0000 WHEN 0010, -- 0
1111 WHEN 0001, -- F(#)
1101 WHEN 0000,
0000 WHEN OTHERS;
END translator_arch;


Decodificatorul BCD 7 segmente a fost realizat n laboratoarele anterioare. Pentru
introducerea n proiectul curent se va proceda astfel:
o se vor copia cele 8 fiiere Schematic n folderul proiectului
o pentru a aduga fiierele, click dreapta n panoul Sources, Add Source:
o se vor selecta cele 8 fiiere Schematic i apoi Open

o

o se vor crea simbolurilor celor 7 segmente
BCD4to7 va arta astfel:

Afiajul LED al placii este active-low, fiind necesare 7 inversoare fat de schema din
laboratoarele precedente pentru o afiare corect.
Se completeaz schema in modul
urmtor:

Se va mai aduga un registru de date pe 4 bii (FD4RE) care se va conecta la intrri i la
blocul translatorului.
Schema final a blocului de afiare va fi urmtoarea:


Top-level

Revenind la nivelul superior al proiectului, se vor aduga componentele deja create, precum
i rezistenelte pull-down discutate anterior astfel:




Schema final a proiectului va fi urmtoarea:


4. Implementarea in limbaj VHDL

La fel ca in orice limbaj evoluat de programare, proiectarea ierarhizata a aplicatiilor in VHDL,
prin utilizarea modulelor, permite descrierea proiectului pe mai multe nivele, imbunatateste
lizibilitatea si permite reutilizarea unor module.
O aplicatie poate fi descrisa la nivelul cel mai de sus (top module) printr-o sursa VHDL. In
aceasta sursa se definesc interfete corespunzatoare cu alte module situate pe nivele
inferioare, module care descriu parti componente ale aplicatiei.
Nu exista o limita a numarului de nivele ierarhice pe care un proiect poate sa-l contina. In
sursa VHDL de pe nivelul top se vor utiliza cuvinte cheie (instructiunile) component si port
map pentru a instantia modulele de pe nivelele inferioare.
Aplicatia va fi descrisa cu ajutorul a sapte module VHDL:
- un modul top numit tastatura (in cadrul caruia se va realiza legarea celorlalte
module);
- un modul numit num2biti, care va contine implementarea numaratorului pe 2 biti;
- un modul numit selcol, folosit pentru a selecta coloana activa a tastaturii;
- un modul numit decod_pri, un codificator de prioritate, folosit pentru a determina
linia apasata, in functie de semnalul primit de la tastatura.;
- un modul numit bcd4to7, cu implementarea decodificatorului pentru cele 7
segmente;
- un modul numit div_clock, folosit pentru a return un clock mai lent;
- un modul numit translator, folosit pentru ca semnalul obtinute in urma apasarii unei
taste sa fie in concordanta cu afisajul.

Urmeaza descrierea in amanunt si cu exemplificari a pasilor ce trebuie urmati in vederea
realizarii lucrarii:

Initializarea proiectului
Pasul 1)
Se porneste Xilinx ISE executand dublu-click pe iconita de pe Desktop.
Pasul 2)
Se incepe prin crearea unui nou proiect: se selecteaza din bara de meniuri File -> New
Project.


Aceasta va deschide casuta de dialog New Project Wizard, prin intermediul careia vom
stabili locatia proiectului (directorul de lucru), numele sau, precum si tipul modulului
principal al proiectului.


De mentionat ca mediul de programare va crea automat un director nou, in directorul de
lucru, avand exact aceeasi denumire cu cea a proiectului. Aici se vor salva toate fisierele
utilizate in cadrul proiectului. Totodata, este important de stiut ca denumirea proiectului
trebuie sa nu contina spatii.

Pasul 3)
Dupa completarea celor 3 campuri de mai sus se va trece la pasul urmator prin apasarea
butonului Next. O noua casuta de dialog va cere completarea celor mai importante
proprietati ale tipului de dispozitiv utilizat, dintre care familia de produse si numele
acestuia, tipul si pinout-ul circuitlui FPGA utilizat precum si programul de sinteza logica
utilizat pentru translatia sursei HDL ( implicit si limbajul HDL utlizat).


Pasul 4)
Dupa completarea campurilor precum in imaginea de mai sus, se trece la pasul urmator prin
apasarea pe Next. Urmatoarele doua casute de dialog nu necesita modificari, se vor sari
prin apasarea pe acelasi buton Next. Ultima fereastra prezinta un sumar al configuratiei
proiectului nou creat, iar prin apasarea pe butonul Finish se finalizeaza Wizard-ul de
creare a proiectului.


Se observa in partea din stanga sus a ferestrei de lucru numele proiectului creat, si
dedesuptul acestuia numele, dat implicit, dispozitivului de comanda de catre mediul de
lucru (in funcite de setarile din cea de-a doua casuta de dialog).


Realizarea modulelor VHDL
Vom trece prin a realiza submodulele priectului, pentru a defini initial entitatile compenente
ce vor fi folosite si legate in cadrul top modulului.
Numaratorul pe 2 biti

Pasul 1)
Pentru a realiza un modul VHDL in cadrul proiectului realizat anterior, se da click dreapta pe
numele acestuia sau pe numele device-ului si se alege din meniul pop-up aparut optiunea
New Source.



Pasul 2)
In fereastra care va aparea se va initia Wizard-ul pentru realizarea unei noi surse. Se
selecteaza din lista din partea stanga a ferestrei optiunea VHDL Module. In casuta cu
numele fisierului vom trece numele primului modul, si anume num2biti, avand grija ca
fisierul sa fie inclus in proiect, prin bifarea casutei Add to project. Initial, am ales sa
realizam implementarea numaratorului pe doi biti.

Pasul 3)
Se continua cu Next, urmand ca in fereastra ce va aparea pe ecran sa se completeze lista
porturilor de intrare si iesire pentru modulul creat. De mentionat ca acest pas se poate sari,
urmand ca porturile sa fie declarate chiar in cadrul sintaxei programului. De asemenea, este
important de stiut ca se pot face modificari ulterioare ale acestora, deci nu este obligatoriu
ca forma finala a entitatii sa fie definita aici.


Numele entitatii este completat implicit cu numele delcarat anterior, in timp ce numele
arhitecturii entitatii este implicit Behavioral. Acestaea poate fi modificate, in cazul de fata
in num2biti_ent si num2biti_arch, pentru a fi mai sugestive.
Pe prima coloana se scriu numele porturilor, pe cea de-a doua se alege tipul portului, care
poate fi in, out sau inout. Pe cea de-a treia coloana se poata bifa optiunea pentru
tipul de data vector, urmand ca pe ultimele doua coloane sa se completeze cel mai
semnificativ bit, respectiv cel mai putin semnificativ bit al structurii.

Pasul 4)
Dupa completare, se continua pe Next, urmand a viziualiza descrierea modulului astfel
creat intr-o noua fereastra si a confirma finalizarea wizard-ului prin click pe butonul
Finish.


In fereastra din dreapta va aparea acum un model pentru fisierul sursa VHDL, in care sunt
descrise bibliotecile implicite (cu ajutorul cuvintelor cheie library si use), precum si
forma primara a entitatii declarate (entity num2biti_ent) precum si a arhitecturii ei
(architecture).

Pasul 5)
Fisierul sursa VHDL trebuie acum completat (editat) cu descrierea arhitecturii entitatii. Sursa
completa este data in continuare:
entity num2biti_ent is
Port ( CLK : in STD_LOGIC;
ENABLE : in STD_LOGIC;
output : in STD_LOGIC_VECTOR (0 to 1));
end num2biti_ent;
architecture num2biti_arch of num2biti_ent is
SIGNAL count : STD_LOGIC_VECTOR(0 to 1) := "00";
BEGIN
PROCESS (CLK)
BEGIN
IF (ENABLE = '1' and RISING_EDGE(CLK)) THEN
count <= count + 1;
output <= count
END IF;
END PROCESS;
end num2biti_arch;


Se salveaza fisierul cu File->Save, sau cu click pe icoana corespunzatoare din Toolbar.

Pasul 6)
In panoul Sources apare acum si fisierul
asociat obiectului xc3s1000-4ft256, de
forma nume_modul (nume_fisier.vhdl) . Prin
selectarea numelui acestui obiect, in panoul
Processes vor aparea si procesele
disponibile: Design Entry Utilities, User
Constraints, Synthesize, Implement Design,
Generating Programming File si Configure
Target Device.



Verificarea sintaxei VHDL si corectarea erorilor sintactice se realizeaza astfel:
In panoul de procese se da click pe semnul + (care indica prezenta unui arbore de
subprocese) din dreptul procesului Synthesize si din lista de subprocese expandate se
lanseaza procesul Check Syntax. Lansarea si rularea oricarui proces sau subproces se face
prin double click pe proces sau click dreapta si din meniul pop-up se selecteaza Run.
Faptul ca un proces sau subproces s-a finalizat cu succes este marcat, in dreptul sau, printr-
un simbol checked() de culoare verde, in caz contrar aparand un simbol de esec(X) de
culoare rosie. Simbolul <<?>> sau <<!>> in galben (?,!) indica o atentionare (warning) legata
de rezultatul operatiei.
In cazul in care avem o eroare de sintaxa, ea este raportata in panoul de rapoarte (de regula
cu un mesaj final de forma Done: failed with exit code: 0001. sau Error: XST failed).
Se cauta in panoul de rapoarte locul-linia in sursa unde a aparut eroarea (marcat cu un
simbol rosu) ea fiind asociata cu numarul de linie corespunzator din fisierul sursa. Se
corecteaza eroarea sau erorile respective, se salveaza fisierul corectat si se repeta operatia
pana cand nu mai exista erori sintactice.
Finalizarea cu succes a unui proces sau sub-proces este indicata cu mesajul Process Check
Syntax completed successfully.

Odata completata si aceasta etapa, am realizat si compilat cu succes primul modul al
proiectului, si anume cel care realizeaza multiplexorul.
Decodificatorul 2-4
Urmeaza cel de-al doilea modul, decodificatorul 2-4, folosit pentru a selecta coloana activa a
tastaturii.
Se reiau, analog ca la primul modul creat, pasii 1) 6), cu urmatoarele mentiuni:
- In casuta cu numele fisierului vom trece numele celui de-al doilea modul, si anume
selcol.


- Lista porturilor de intrare/iesire pentru acest modul se completeaza astfel:


Observam in partea din stanga sus a ecranului ca lista modulelor proiectului a fost
actualizata cu fisierul VHDL pentru realizarea selectorului de.

- Sursa VHDL completa a selectorului este urmatoarea:
entity selcol_ent is
Port ( sel : in STD_LOGIC_VECTOR (0 to 1);
coloana : out STD_LOGIC_VECTOR (0 to 3));
end selcol_ent;

architecture selcol_arch of selcol_ent is
begin
WITH sel SELECT
coloana <= "1000" WHEN "00",
"0100" WHEN "01",
"0010" WHEN "10",
"0001" WHEN "11",
"0000" WHEN OTHERS;
end selcol_arch;



- Se salveaza fisierul editat cu File -> Save, sau cu click pe icoana corespunzatoare din
Toolbar.
- Se face apoi verificarea sintaxei VHDL si corectarea eventualelor erori sintactice prin
utilizarea aceluiasi subproces Check Syntax din arborele de subprocese al Synthesize.

Codificatorul de prioritate

Urmeaza cel de-al treilea modul, codificatorul de prioritate, folosit pentru a determina linia
apasata, in functie de semnalul primit de la tastatura.
Se reiau, analog ca la primele doua module create, pasii 1) 6), cu urmatoarele
mentiuni:
- In casuta cu numele fisierului vom trece numele modului ce descrie codificatorul, fie
aceste decod_pri.



- Lista porturilor de intrare/iesire pentru modulul codificatorului se completeaza astfel:


- Sintaxa care va descrie functionalitatea codificatorului de prioritate este urmatoarea:

entity decod_pri_ent is
Port ( intrare : in STD_LOGIC_VECTOR (0 to 3);
iesire : out STD_LOGIC_VECTOR (0 to 1));
end decod_pri_ent;

architecture decod_pri_arch of decod_pri_ent is
begin
PROCESS (intrare)
BEGINI
IF (intrare(0) = '1' ) THEN
iesire <= "00";
ELSIF (intrare(1) = '1') THEN
iesire <= "01";
ELSIF (intrare(2) = '1') THEN
iesire <= "10";
ELSIF (intrare(3) = '1') THEN
iesire <= "11";
END IF;
END PROCESS;
end decod_pri_arch;


Se salveaza fisierul editat cu File -> Save, sau cu click pe icoana
corespunzatoare din Toolbar.
Se face apoi verificarea sintaxei VHDL si corectarea eventualelor erori
sintactitce prin utilizarea aceluiasi subproces Check Syntax din arborele de
subprocese al Synthesize.


Sistemul de afisare

Urmeaza cel de-al patrulea modul, decodificator bcd-7 segmente, folosit pentru a afisa
rezultatul tastarii.
Se reiau, analog ca la module amterior create, pasii 1) 6), cu urmatoarele mentiuni:
- In casuta cu numele fisierului vom trece numele modului ce descrie decodificatorul,
fie aceste bcd4to7.



-Lista cu porturile de intrare/iesire pentru modulul nou creat se completeaza astfel:

- Se va completa sursa pentru decodificator bcd-7 segmente pentru a o aduce la
forma de mai jos:

entity bcd4to7_ent is
Port ( input : in STD_LOGIC_VECTOR (0 to 3);
output : out STD_LOGIC_VECTOR (0 to 6));
end bcd4to7_ent;

architecture bcd4to7_arch of bcd4to7_ent is
begin
WITH input SELECT
output <= "0000001" WHEN "0000", -- 0
"1001111" WHEN "0001", -- 1
"0010010" WHEN "0010", -- 2
"0000110" WHEN "0011", -- 3
"1001100" WHEN "0100", -- 4
"0100100" WHEN "0101", -- 5
"0100000" WHEN "0110", -- 6
"0001111" WHEN "0111", -- 7
"0000000" WHEN "1000", -- 8
"0000100" WHEN "1001", -- 9
"0001000" WHEN "1010", -- A
"1100000" WHEN "1011", -- b
"0110001" WHEN "1100", -- C
"1000010" WHEN "1101", -- d
"0110000" WHEN "1110", -- E
"0111000" WHEN "1111",
"1111111" WHEN OTHERS;
end bcd4to7_arch;



- Se salveaza fisierul editat cu File -> Save, sau cu click pe icoana corespunzatoare din
Toolbar.
- Se face apoi verificarea sintaxei VHDL si corectarea eventualelor erori sintactice prin
utilizarea aceluiasi subproces Check Sintax din arborele de subprocese Synthesize.


Divizor de clock

Urmeaza cel de-al cincilea modul, divizorul de clock, folosit pentru a mari perioada unui
clock.
Se reiau, analog ca la module amterior create, pasii 1) 6), cu urmatoarele mentiuni:
- In casuta cu numele fisierului vom trece numele modului ce descrie divizorul de
clock, fie aceste div_clock.


-Lista cu porturile de intrare/iesire pentru modulul nou creat se completeaza astfel:



- Se va completa sursa pentru divizorul de clock pentru a o aduce la forma de mai jos:

entity div_clock_ent is
Port ( clockin : in STD_LOGIC;
clockout : out STD_LOGIC);
end div_clock_ent;

architecture div_clock_arch of div_clock_ent is
begin
PROCESS (clockin)
VARIABLE cnt : INTEGER := 0;
BEGIN
IF (clockin'EVENT and clockin='1') THEN
cnt := cnt1 + 1;
IF (cnt = 1250000) THEN
clockout <= '1';
ELSIF (cnt = 2500000) THEN
clockout <= '0';
cnt1 := 0;
END IF;
END IF;
END PROCESS;
end div_clock_arch;



- Se salveaza fisierul editat cu File -> Save, sau cu click pe icoana corespunzatoare din
Toolbar.
- Se face apoi verificarea sintaxei VHDL si corectarea eventualelor erori sintactice prin
utilizarea aceluiasi subproces Check Sintax din arborele de subprocese Synthesize.


Translatorul

Urmeaza cel de-al saselea modul, translatorul, folosit pentru traduce semnalul obtinute in
urma apasarii unei taste intr-un semnal corespunzator astfel incat sa fie afisata tasta
respectiva pe BCD.
Se reiau, analog ca la module amterior create, pasii 1) 6), cu urmatoarele mentiuni:
- In casuta cu numele fisierului vom trece numele modului ce descrie translatorul, fie
aceste translator.


-Lista cu porturile de intrare/iesire pentru modulul nou creat se completeaza astfel:


- Se va completa sursa pentru divizorul de clock pentru a o aduce la forma de
mai jos:
entity translator_ent is
Port ( intrare : in STD_LOGIC_VECTOR (0 to 3);
iesire : out STD_LOGIC_VECTOR (0 to 3));
end translator_ent;

ARCHITECTURE translator_arch OF translator_ent IS
BEGIN
WITH intrare SELECT
iesire <= "0001" WHEN "1111", -- 1
"0010" WHEN "1110", -- 2
"0011" WHEN "1101", -- 3
"0100" WHEN "1011", -- A
"1010" WHEN "1100", -- 4
"0101" WHEN "1010", -- 5
"0110" WHEN "1001", -- 6
"1011" WHEN "1000", -- b
"0111" WHEN "0111", -- 7
"1000" WHEN "0110", -- 8
"1001" WHEN "0101", -- 9
"1100" WHEN "0100", -- C
"1110" WHEN "0011", -- E(*)
"0000" WHEN "0010", -- 0
"1111" WHEN "0001", -- F(#)
"1101" WHEN "0000", -- d
"0000" WHEN OTHERS;
END translator_arch;
end translator_arch;


- Se salveaza fisierul editat cu File -> Save, sau cu click pe icoana corespunzatoare din
Toolbar.
- Se face apoi verificarea sintaxei VHDL si corectarea eventualelor erori sintactice prin
utilizarea aceluiasi subproces Check Sintax din arborele de subprocese Synthesize.

Top-level

- In acest moment, avem la dispozitie toate submodule proiectului VHDL, sub forma
unor black-box-uri. O data realizate acestea, ramane de implementat modulul care va
realiza conectarea celor sase module definite anterior.
Pentru a vizualiza si a putea utiliza template-ul modulelor anterior create se ruleaza
subprocesul View HDL Instantiaton Template din procesul Design Utilities.


De exemplu, pentru decodificatorul bcd-7 segmente, avem urmatoarea intantiere:



COMPONENT se adauga in blocul ARCHITECTURE, inainte de BEGIN; se poate spune ca
instructiunea COMPONENT este o declarare a unei entitati; in interiorul fiecarei instructiuni
COMPONENT se copiaza ce este in blocul ENTITY al fiecarui fisier pe care vrem sa-l adaugam;
numele componentei va fi acelasi ca al entitatii.
PORT MAP realizeaza apelul acelor entitati; se foloseste in blocul ARCHITECTURE, dupa
BEGIN; primul cuvant reprezinta numele pe care vrem sa-l dam noi acestei instructiuni, iar
urmatorul reprezinta numele entitatii pe care vrem sa o mapam; urmeaza cuvintele cheie
PORT MAP, iar in paranteza se pun parametrii cu care se face apelarea entitatii.
Daca modurile parametrilor cu care apelam difera de modurile parametrilor din interiorul
entitatii, atunci va trebui sa-i declaram ca SIGNAL.



Ultimul modul VHDL va realiza schema functionarii unei tastaturi ca pe un black-box, care
va avea ca intrari semnalul de ceas si un vector de 4 biti reprezentand semalul de iesire al
tastaturii, si care va avea ca iesiri vectorul de 7 biti pentru comenzile catozilor celor 7
segmente si un vectorul de 4 biti pentru semnalul de intrare in tastatura.

Ultimul model VHDL se realizeaza in mod identic celor anterior create, urmand pasii 1) 6),
cu urmatoarele mentiuni:

- In casuta cu numele fisierului vom trece numele modului top, fie aceste tastatura.


- Lista porturilor se va completa astfel:



- Codul VHDL al modulului se va completa in felul urmator, folosind template-urile
generate de procesul View HDL Instantiaton Template utilizat pentru primele 6 module:

entity tastatura_ent is
Port ( CLOCK : in STD_LOGIC;
KBDIN : in STD_LOGIC_VECTOR (0 to 3);
KBDOUT : out STD_LOGIC_VECTOR (0 to 3);
segmente : out STD_LOGIC_VECTOR (0 to 6));
end tastatura_ent;

ARCHITECTURE tastatura_arch OF tastatura_ent IS

COMPONENT bcd4to7_ent
PORT( input : IN STD_LOGIC_VECTOR(0 to 3);
output : OUT STD_LOGIC_VECTOR(0 to 6));
END COMPONENT;

COMPONENT decod_pri_ent
PORT( intrare : IN STD_LOGIC_VECTOR(0 to 3);
iesire : OUT STD_LOGIC_VECTOR(0 to 1));
END COMPONENT;

COMPONENT div_clock_ent
PORT( clockin : IN STD_LOGIC;
clockout : OUT STD_LOGIC);
END COMPONENT;

COMPONENT num2biti_ent
PORT( CLK : IN STD_LOGIC;
ENABLE : IN STD_LOGIC;
output : OUT STD_LOGIC_VECTOR(0 to 1));
END COMPONENT;

COMPONENT selcol_ent
PORT( sel : IN STD_LOGIC_VECTOR(0 to 1);
coloana: OUT STD_LOGIC_VECTOR(0 to 3));
END COMPONENT;

COMPONENT PULLDOWN
port ( O : out std_logic);
END COMPONENT;

COMPONENT translator_ent
PORT( intrare: IN STD_LOGIC_VECTOR(0 to 3);
iesire: OUT STD_LOGIC_VECTOR(0 to 3));
END COMPONENT;

SIGNAL cod : STD_LOGIC_VECTOR(0 to 3):="0010";
SIGNAL bcddata : STD_LOGIC_VECTOR(0 to 3);
SIGNAL CLOCK2: STD_LOGIC;
SIGNAL ENABLE : STD_LOGIC;
SIGNAL sel : STD_LOGIC_VECTOR(0 to 1);
SIGNAL decinfo : STD_LOGIC_VECTOR(0 to 1);
SIGNAL KBDIN_AUX : STD_LOGIC_VECTOR(0 to 3);

BEGIN
KBDIN_AUX <= KBDIN;
pulldown_1: pulldown PORT MAP(O => KBDIN_AUX(0));
pulldown_2: pulldown PORT MAP(O => KBDIN_AUX(1));
pulldown_3: pulldown PORT MAP(O => KBDIN_AUX(2));
pulldown_4: pulldown PORT MAP(O => KBDIN_AUX(3));

bcd: bcd4to7_ent PORT MAP(bcddata, segmente);
decodificatorprioritate: decod_pri_ent PORT MAP(KBDIN_AUX, decinfo);
divizor_clock: div_clock_ent PORT MAP(CLOCK, CLOCK2);
numarator: num2biti_ent PORT MAP(CLOCK2, ENABLE, sel);
selcol: selcol_ent PORT MAP(sel, KBDOUT);
translator: translator_ent PORT MAP(cod, bcddata);

PROCESS (KBDIN)
BEGIN
IF (KBDIN_AUX(0) = '1' or KBDIN_AUX(1) = '1' OR KBDIN_AUX(2) = '1'
OR KBDIN_AUX(3) = '1') THEN
ENABLE <= '0';
cod(0 to 1) <= decinfo;
cod(2 to 3) <= sel;
ELSE
ENABLE <= '1';
END IF;
END PROCESS;
END tastatura_arch;

- Se salveaza fisierul editat cu File -> Save, sau cu dublu click pe icoana
corespunzatoare din Toolbar.
- Se face apoi verificarea sintaxei VHDL si corectarea eventualelor erori sintactice prin
utilizarea aceluiasi subproces Check Sintax din arborele de subprocese al Synthesize.

Se observa in partea din stanga sus, primele 6 module ca fiind subordonate ultimului modul
implementat. Acest lucru este realizat automat de catre program la intalnirea declararii
primelor 6 module ca si componente ale ultimului.




Pentru a vizualiza modelul black-box al proiectului final, se da click pe numele modulului
tastatura, se verifica sa fie setat ca si modulul top al proiectului, lucru ilustrat in figura de
mai sus prin cele 3 patratele in forma de triunghi dinaintea numelui sau, si se ruleaza apoi
subprocesul View RTL Schematic de la procesul Synthesize:



In fereastra din partea dreapta va aparea urmatoarea figura, reprezentand proiectul
implementat vazut ca un black-box:




5. Implementare FPGA a programului in VHDL si Schematic

Pentru implementare pe placa FPGA procedam
astfel:
selectam tastatura.vhd din toolbarul
Sources for: Implementation;
verificam sintaxa dand dublu click pe
Check Syntax
In toolbarul Process dam dublu click pe
Floorplan Aa/IO/Logic Post-Synthesis pentru a
seta pinii

In fereastra de mai jos ar trebui sa se introduca valori in coloana Loc,
corespunzatoare locatiei din fiecare I / O marker pe placa; valoarea BANK va fi introdusa
automat.



Acum, se conecteza placuta FGPA la PC utilizand
cablul JTAG furnizat dupa cum se arata in figura de
mai jos.
Se conecteaz apoi tastatura la slotul A2 pe rndul
superior de pini, ncepnd cu al treilea (a se vedea in
imaginea de mai jos). Intrarile/ieirile asociate
acestor pini se pot gsi in manualul de utilizare al
plcii. Se observ c pinul 1 apartine rndului
superior iar pinul 40 celui inferior.




Cu placa FPGA alimentata se poate incepe verificarea programului urmand pasi de mai jos:
Se porneste programul iMPACT prin dublu-clic pe Configure Target Device din fereastra
Processes (in cazul in care apare un avertisment spunand ca nu exista nici un fisier de
proiect iMPACT, se va face clic pe OK) .


In cazul in care casua de dialog Configure Devices apare, se selecteaza Configure devices
using Boundary-Scan (JTAG) si Automatically connect to cable and identify Boundary-Scan
chain si se apasa Finish.


Dupa realizarea cu succes a testelor, cand apare meniul selectati fisierul,se va alege
documentul generat mai devreme (ar trebui sa existe doar unul dintre aceste fisiere in
directorul proiectului). Se selecteaza acel fisier si se apasa Open. Pentru al doilea dispozitiv
(Flash-ROM-ul de pe placuTa), se poate selecta Bypass, pentru ca nu se folosete .

Configurarea se va incheia cu o fereastra pentru a selecta proprietatile de programare
dispozitiv. Ar trebui fie toate casutele nemarcate ca in figurile urmatoare:


Odata cu atribuirea fisierelor programului, se face click dreapta pe dispozitivul din stanga si
se selecteaza Program; acest lucru va dura cateva secunde, dupa care ar trebui sa apara
mesajul: "Program Succeeded".



Astfel am incheiat implemenarea pe placa FPGA atat a programului facut in Schematic cat si
a celui in cod VHDL.