You are on page 1of 8

Alati za razvoj digitalnih sustava

2. domaća zadaća
Zadatak 1 (8 bodova)

Realizirati sklop prikazan slikom. Ulazi u sklop su a, b, c, d i clk, a izlaz x. Pored ovih signala potrebno je
predvidjeti signal za sinkroni reset registara. Pretpostaviti da signali a, b, c i d sadrže vrijednosti u dvojnom
komplementu.
(Napomena: MSBs označava Most Significant Bits tj. najznačajnije bitove.)

Zadatak 2 (9 bodova)

Realizirati sklop prikazan slikom. Ulazi u sklop su 12-bitni podatak Din, clk i sinkroni reset rst, a izlaz je
12-bitni podatak Dout. ROM memoriju sa 128 lokacija realizirati korištenjem blok RAM-a. Blok RAM realizirati
korištenjem slijednog opisa.
Adresni generator realizirati kao sinkrono brojilo.

Zadatak 3 (10 bodova)


Zadan je RTL model sklopa čiji entitet ima oblik

entity filter is
port( clk : in std_logic;
reset : in std_logic;
Din : in std_logic_vector(11 downto 0);
Dout : out std_logic_vector(13 downto 0) );
end filter;

Uz pretpostavku da je frekvencija takta 50MHz, potrebno je razviti ispitno okruženje koje sadrži pobudne signale.
Signal reset mora biti aktivan barem prvih 16 perioda takta. Vrijednosti signala Din treba predstavljati niz
počevši od najveće do najmanje pozitivne vrijednosti. Signal Din potrebno je generirati svaki rastući brid takta i to
nakon deaktivacije signala reset. Napisati komandnu datoteku za pokretanje funkcijske simulacije. Pretpostaviti
da su podaci Din i Dout u formatu signed.

Zadatak 4 (10 bodova)


Potrebno je razviti RTL model dvopristupne sinkrone ROM memorije korištenjem blok RAM memorije.
Sadržaj memorije potrebno je zadati u datoteci s imenom rom.txt. Memorija mora imati generičku
širinu adresne i podatkovne riječi.
Zadatak 5 (7 bodova)
Korištenjem isključivo komponente iz biblioteke čiji je opis dan, realizirati 4/1 multipleksor. Ulazi
u sklop su 4 1-bitna signala, a, b, c, d, 2-bitni upravljački signal, s, a izlazni signal je y.

Zadatak 6 (3 boda)
Opisati izvedbu distribuiranog RAM-a. Koje resurse unutar FPGA sklopa troši distribuirani
RAM?

Zadatak 7 (3 boda)
Opisati izvedbu množila u Spartan3 FPGA sklopovima. Na koji način se mogu modelirati
množila? Kako će sintetizator razlikovati množila sa predznakom i bez predznaka?
RJEŠENJA
Zadatak 1 (službeno rješenje s Ferweba)
library IEEE;
use IEEE.STD_LOGIC_1164.ALL;
use IEEE.STD_LOGIC_SIGNED.ALL;

entity zad1 is
port (
clk : in std_logic;
reset : in std_logic;
a , b, c, d: in std_logic_vector(11 downto 0);
x : out std_logic_vector(11 downto 0));
end zad1;

architecture RTL of zad1 is


-- local signals
signal mul_c_d : std_logic_vector(23 downto 0);
signal mul_c_d_short : std_logic_vector(11 downto 0);
signal sum_a_b : std_logic_vector(11 downto 0);
signal sub_a_b : std_logic_vector(11 downto 0);
signal mul2 : std_logic_vector(23 downto 0);
signal mul2_short : std_logic_vector(11 downto 0);
signal reg1, reg2, reg3 : std_logic_vector(11 downto 0);
signal sum_regs : std_logic_vector(11 downto 0);
signal reg_out : std_logic_vector(11 downto 0);
begin
-- multiplying c x d
mul_c_d <= c * d;
mul_c_d_short <= mul_c_d(23 downto 12);
-- sum and subtract of a and b
sum_a_b <= a + b;
sub_a_b <= a - b;
-- multiplying signals sub_a_b and mul_c_d_short
mul2 <= sub_a_b * mul_c_d_short;
mul2_short <= mul2(23 downto 12);

process(clk) -- register for signal d, mul2_short, sum_a_b


begin
if rising_edge(clk) then
if reset = '1' then
reg1 <= (others => '0');
reg2 <= (others => '0');
reg3 <= (others => '0');
else
reg1 <= d;
reg2 <= mul2_short;
reg3 <= sum_a_b;
end if;
end if;
end process;

-- sum of signals reg1, reg2, reg3


sum_regs <= reg1 + reg2 + reg3;

process(clk) -- output register


begin
if rising_edge(clk) then
if reset = '1' then
reg_out <= (others => '0');
else
reg_out <= sum_regs;
end if;
end if;
end process;

-- output mapping
x <= reg_out;

end RTL;
Zadatak 2 (službeno rješenje s Ferweba)
library IEEE;
use IEEE.STD_LOGIC_1164.ALL;
use IEEE.STD_LOGIC_SIGNED.ALL;

entity zad2 is
port (
clk : in std_logic;
reset : in std_logic;
Din : in std_logic_vector(11 downto 0);
Dout : out std_logic_vector(11 downto 0));
end zad2;

architecture RTL of zad2 is

-- local signals
signal mul_out : std_logic_vector(23 downto 0);
signal sum_out, reg_out : std_logic_vector(11 downto 0);
signal mem_location : std_logic_vector(6 downto 0);
-- block RAM
type BRAM is array (0 to 127) of std_logic_vector(11 downto 0);
signal rom : BRAM;
signal we : std_logic;
signal data_in, data_out : std_logic_vector(11 downto 0) := (others => '0');

begin
-- ROM memory
process (clk) is
begin
if rising_edge(clk) then
if (we = '1') then
rom(conv_integer(mem_location)) <= data_in;
else
data_out <= rom(conv_integer(mem_location));
end if;
end if;
end process;

-- address generator
process (clk) is
begin
if rising_edge(clk) then
if (reset = '1') then
mem_location <= (others => '0');
else
mem_location <= mem_location + 1;
end if;
end if;
end process;

-- multiplier
mul_out <= Din * data_out;
-- sumator
sum_out <= mul_out(23 downto 12) + reg_out;

-- register
process (clk) is
begin
if rising_edge(clk) then
if (reset = '1') then
reg_out <= (others => '0');
else
reg_out <= sum_out;
end if;
end if;
end process;

-- output mapping
Dout <= reg_out;
end RTL;
Zadatak 3
###############################################################################################
## filter_tb.vhd ##
###############################################################################################
library IEEE;
use IEEE.STD_LOGIC_1164.ALL;
use IEEE.NUMERIC_STD.ALL;

entity filter_tb is
end entity filter_tb;

architecture Beh of filter_tb is


component filter is -- deklaracija komponente
port (
clk: in std_logic;
reset: in std_logic;
Din: in std_logic_vector(11 downto 0);
Dout: out std_logic_vector(13 downto 0));
end component filter;

signal clk: std_logic := '0';


signal reset: std_logic := '1';
signal Din: std_logic_vector(11 downto 0);
signal Dout: std_logic_vector(13 downto 0);
constant T_CLK: time := 20 ns; -- 50 MHz

begin
-- instanciranje komponente
uut: component filter port map (
clk => clk,
reset => reset,
Din => Din,
Dout => Dout );

clk <= not clk after T_CLK / 2; -- pobuda za clk


reset <= '1', '0' after 16 * T_CLK; -- pobuda za reset

Din_pobuda: process is -- pobuda za Din


begin
wait until reset = '0';
for i in 2**Din'length - 1 downto 1 loop – generiraj od najviše do najniže pozitivne vrijednosti
wait until rising_edge(clk);
Din <= std_logic_vector(to_signed(i, 12));
end loop;
wait; -- nemoj više generirati Din
end process Din_pobuda;
end architecture Beh;

###############################################################################################
## filter_tb.do ##
###############################################################################################
# ZAVRŠAVANJE PRETHODNE SIMULACIJE (AKO JE ONA U TOKU)
quit –sim

# KOMANDE ZA PREVOĐENJE SVIH VHDL MODELA PROJEKTA


vlib filter_lib # biblioteka u koju će se spremiti svi prevedeni VHDL modeli
vcom -work filter_lib -93 -explicit filter.vhd # prevođenje komponente
vcom -work filter_lib -93 -explicit filter_tb.vhd # prevođenje ispitnog okruženja

# POKRETANJE SIMULACIJE
vsim filter_lib.filter_tb -t 10ps

# KOMANDE ZA PRIKAZ VALNIH OBLIKA KOJE ŽELIMO PROMATRATI


onerror {resume} # ignoriraj pogrešku ako naiđeš na nju (ali je ispiši u komandni prozor)
add wave -noupdate -format Logic /filter_tb/clk # prikaz clk-a
add wave -noupdate -format Logic /filter_tb/reset # prikaz reset-a
add wave -noupdate -format Literal -radix signed /filter_tb/Din # prikaz Din-a
add wave -noupdate -format Literal -radix signed /filter_tb/Dout # prikaz Dout-a

# ODSIMULIRAJ 600 NANOSEKUNDI


run 600ns
Zadatak 4
library IEEE;
use IEEE.STD_LOGIC_1164.ALL;
use IEEE.STD_LOGIC_UNSIGNED.ALL;
library STD;
use STD.TEXTIO.ALL;

entity dvopristupni_ROM is
generic (
ADDR_WIDTH : integer := 8;
DATA_WIDTH : integer := 8);
port (
clk : in std_logic;
AddrA, AddrB : in std_logic_vector(ADDR_WIDTH - 1 downto 0);
EnableA, EnableB : in std_logic;
DoutA, DoutB : out std_logic_vector(DATA_WIDTH - 1 downto 0));
end entity dvopristupni_ROM;

architecture RTL of dvopristupni_ROM is

type ROM_type is array (0 to 2**ADDR_WIDTH - 1) of std_logic_vector(DATA_WIDTH - 1 downto 0);

-- funkcija za punjenje ROM-a iz datoteke pri inicijalizaciji


impure function ROM_init (file_name : in string) return ROM_type is

file FID : text open read_mode is file_name; -- otvaranje datoteke za čitanje


variable file_line : line;
variable podatak : bit_vector(DATA_WIDTH-1 downto 0); -- varijabla u koju čitamo
variable ROM : ROM_type; -- ROM koji će funkcija vratiti
begin
for i in ROM_type'range loop
readline(FID, file_line);
read(file_line, podatak); -- read za std_logic_vector ne postoji (zato koristimo bit_vector)
ROM(i) := to_stdlogicvector(podatak); -- pretvorba bit_vectora u std_logic_vector
end loop;
end function ROM_init;

signal ROM : ROM_type := ROM_init("rom.txt"); -- memorija

begin
-- izlaz A
outputA: process (clk) is
begin
if rising_edge(clk) then
if (EnableA = '1') then
DoutA <= ROM(conv_integer(AddrA));
end if;
end if;
end process outputA;

-- izlaz B
outputB: process (clk) is
begin
if rising_edge(clk) then
if (EnableB = '1') then
DoutB <= ROM(conv_integer(AddrB));
end if;
end if;
end process outputB;

end architecture RTL;


Zadatak 5 (službeno rješenje s Ferweba)
library IEEE;
use IEEE.STD_LOGIC_1164.ALL;
library UNISIM;
use UNISIM.VCOMPONENTS.ALL;

entity zad5 is
port (
a, b, c, d : in std_logic;
s : in std_logic_vector(1 downto 0);
y : out std_logic
);
end zad5;

architecture RTL of zad5 is

-- local signals
signal o1, o2 : std_logic;

begin

MUXF6_inst1 : MUXF6 port map (


O => o1,
I0 => a,
I1 => b,
S => s(0));
MUXF6_inst2 : MUXF6 port map (
O => o2,
I0 => c,
I1 => d,
S => s(0));
MUXF6_inst3 : MUXF6 port map (
O => y,
I0 => o1,
I1 => o2,
S => s(1));
end RTL;

Zadatak 6
Distribuirani RAM koristi se kada je potreban RAM manjeg kapaciteta. Kod Spartana 3, unutar svakog CLB-a
(configurable logic blocka) postoje dva M odsječka (SLICEM) koji svaki sadrži po jedan 4-ulazni LUT (lookup
table). Ti LUT-ovi se konfiguriraju pomoću 16 bistabila (svaki predstavlja jedan izlaz funkcije 4 varijable).
Osim što služe za konfiguraciju LUT-a, u te bistabile može se i pisati te tako dobivamo distribuirani RAM
16x1 bit. Kombiniranjem više LUT-ova može se dobiti distribuirani RAM većeg kapaciteta te dvopristupni
(dual-port) distribuirani RAM.
Distrubuirani RAM unutar FPGA sklopa troši LUT-ove.
Zadatak 7
Množila unutar Spartan 3 FPGA sklopova izvedena su kao fizički nezavisne jedinice. Ovisno o odabranoj
verziji Spartana 3, ima ih od 4 do preko 100 na jednom čipu, a množe signed operande veličine 18-bitova te
daju signed rezultat veličine 36 bitova.
Množila se mogu modelirati slijednim ili strukturnim opisom. Kod slijednog opisa može se modelirati
kombinacijsko množilo ili množilo s izlaznim registrom.
Sintetizator razlikuje množila s predznakom i množila bez predznaka ovisno o tome iz kojeg se paketa koristi
operator ∗ (STD_LOGIC_SIGNED ili STD_LOGIC_UNSIGNED).