KEMENTRIAN RISET TEKNOLOGI DAN PENDIDIKAN TINGGI

POLITEKNIK ELEKTRONIKA NEGERI SURABAYA

ELECTRONIC ENGINERING POLYTECHNIC INSTITUTE OF SURABAYA
(EEPIS)
JL. RAYA ITS KEPUTIH SUKOLILO SURABAYA 60111 INDONESIA
TELP.(031) 5947280 FAX. (031) 5946114

Piranti Terprogram

LAPORAN

JUDUL : Perencanaan FPGA dengan simulasi (Test

Bench)

PERCOBAAN : 2

NAMA : Made Wira Narendra Wirsuyana

KELAS : 2 D3 EB

NRP : 1103191043

DOSEN : Pak Arif Irwansyah

TANGGAL : 15 Oktober 2020

 Percobaan 2

Perancangan FPGA dengan simulasi (Test Bench)

2.1. Tujuan :
• Membuat simulasi Test Bench VHDL
• Implementasi rancangan pada FPGA devais
• Mampu merancang dan mendemonstrasikan testbench untuk menguji dan
mensimulasikan rangkaian yang dibuat. serta melaporkan hasil percobaannya

2.2. Landasan Teori

Testbench VHDL digunakan untuk simulasi dan verifikasi desain FPGA. Verifikasi
diperlukan untuk memastikan bahwa desain memenuhi persyaratan waktu dan juga
digunakan untuk mensimulasikan fungsionalitas dari spesifikasi desain yang diperlukan.

Testbenches (test bench) adalah alat utama verifikasi desain HDL. Verifikasi testbench
penting karena memverifikasi fungsionalitas desain sebelum memasukkannya ke perangkat
keras sebenarnya. Verifikasi desain digital adalah pekerjaan yang rumit dan memakan
waktu, karena sifat perangkat keras FPGA yang harus memenuhi persyaratan waktu dengan
sukses untuk memastikan fungsionalitas yang tepat dari desain.

• Contohnya design under test (DUT), pada dasarnya sebuah desain yang membutuhkan
teknisi verifikasi untuk menulis testbench.
• Merangsang DUT dengan menerapkan vektor uji ke model, umumnya, teknisi verifikasi
menghasilkan nomor pseudo-random untuk mencakup semua skenario pengujian.
• Tampilkan hasil keluaran ke terminal dan / atau buat jendela bentuk gelombang untuk
persepsi visual, dan terkadang gunakan untuk debugging juga.
• Membandingkan hasil aktual dengan hasil yang diharapkan untuk menyimpulkan
verifikasi dan persyaratan desain.
• Secara otomatis memberikan indikasi lulus atau gagal.

Metodologi dasar test bench adalah memanggil fungsionalitas desain, kemudian

merangsangnya dengan menerapkan vektor uji yang berbeda. Test bench yang efisien
melakukan fungsi tambahan untuk memastikan bahwa desain memenuhi semua persyaratan,
yaitu berisi logika untuk menentukan apakah keluaran dari testbench adalah yang
diharapkan atau menyimpang dari hasil yang diharapkan. Artikel selanjutnya menjelaskan
struktur testbench yang efisien, dan memberikan contoh testbench yang memeriksa sendiri
— yang mengotomatiskan perbandingan hasil testbench aktual dengan yang diharapkan.

Gambar berikut menunjukkan arsitektur umum testbench. Testbench dapat memberikan

hasil baik sebagai nilai output ke terminal perangkat lunak verifikasi yang mendasarinya
misalnya, Modelsim, bangku uji membantu untuk men-debug desain melalui bentuk
gelombang digital, atau kami juga dapat menulis bangku uji yang efisien untuk membuat
verifikasi otomatis dengan hasil yang telah ditentukan sebelumnya simpan ke dalam
Database dan hasil debugging.
 Testbenches dapat ditulis dalam VHDL atau Verilog. Karena bangku pengujian
hanya digunakan untuk simulasi, mereka tidak dibatasi oleh batasan semantik yang
berlaku untuk subset bahasa RTL yang digunakan dalam sintesis. Singkatnya,
Testbenches tidak bergantung pada kendala bahasa dan perangkat keras, memberikan
manfaat bagi insinyur verifikasi untuk menggunakan konstruksi perilaku yang
tersedia. Dengan demikian, bangku tes dapat ditulis lebih umum, membuatnya lebih
mudah dirawat.

Testbenche lebih mudah dipelihara karena digunakan untuk memberikan hasil

simulasi saja, membuatnya tidak tergantung pada batasan semantik, membuatnya juga
tidak tergantung pada urutan alur kerja sintesis. Jadi, bangku pengujian dapat
menggunakan semua konstruksi perilaku.

Bagian berikut adalah bagian testbench VHDL yang umum:

• Entity and Component Declaration

• Signal Declaration
• Port mapping of Top-Level Design
• Stimulus

Generating Clock Signal

Logika sekuensial harus dimulai dengan pembuatan sinyal clock. Jam berulang dapat
dengan mudah diimplementasikan di VHDL. Berikut ini adalah kode VHDL untuk
pembuatan clock:

-- Declare a clock period constant.

Constant ClockPeriod: TIME := 10 ns;

-- Clock Generation method 1:

Clock <= not Clock after ClockPeriod / 2;

-- Clock Generation method 2:

GENERATE_CLOCK: process

Begin wait for (ClockPeriod / 2)

Clock <= ’1’;

wait for (ClockPeriod / 2)

Clock <= ’0’;

end process;

Generating Reset Signal

-- Declare a reset signal.

reset <= ‘1’, ‘0’ after T/2;

Self-Checking Testbenches

Testbench yang memeriksa sendiri adalah sejenis testbench cerdas yang memeriksa hasil
aktual terhadap hasil yang diharapkan pada waktu proses, bukan di akhir simulasi seperti
dalam perbandingan Database. Teknik ini berguna untuk pelacakan kesalahan, sangat
membantu untuk membuat log kesalahan, membantu untuk men-debug desain, waktu
debugging dipersingkat secara signifikan, membantu menemukan terjadinya kesalahan.

Contoh:

Stimulus dapat dihasilkan dengan MATLAB atau Python Script dan testbench
memasukkannya ke dalam desain yang sedang diuji. Tes Design Under menghasilkan respon
dan testbench menyimpannya ke dalam sebuah file. Hasilnya dibandingkan melalui testbench
untuk mendapatkan fungsionalitas perilaku dari desain.

Test Bench Tips

Merencanakan desain digital yang baik membantu mencapai performa sirkuit yang lebih
baik, merencanakan testbench yang baik akan meningkatkan waktu simulasi.

Ketahui simulator sebelum menulis testbench

Ada beberapa simulator HDL yang tersedia di pasaran misalnya, Modelsim, Vivado,
semua simulator ini memenuhi standar industri HDL. Simulator yang berbeda memiliki
fitur, kapabilitas, dan karakteristik kinerja yang berbeda, serta menghasilkan hasil
simulasi yang berbeda pula.
Simulasi berbasis peristiwa vs. berbasis siklus

Simulator menggunakan metode simulasi berbasis kejadian atau siklus. Simulator

berbasis peristiwa memicu ketika input, sinyal, atau gerbang mengubah nilainya. Dalam
simulator berbasis peristiwa, nilai penundaan dapat dikaitkan dengan gerbang dan jaring
untuk mencapai simulasi waktu yang optimal.

Simulator berbasis siklus menargetkan desain sinkron. Simulator ini menganalisis

hasil pada siklus jam. Fitur ini membuat simulator berbasis siklus lebih cepat dan lebih
hemat memori daripada simulator berbasis peristiwa.

Hindari menggunakan loop tak terbatas

Loop tak terbatas tidak boleh digunakan untuk memberikan rangsangan desain.
Biasanya, jam ditentukan di dalam loop tak terbatas (misalnya, loop "menunggu" di
VHDL).

Pisahkan rangsangan menjadi blok logis

Dalam proses VHDL blok bekerja secara paralel. Stimulus testbench menjadi lebih
mudah untuk diimplementasikan dan di-debug jika rangsangan independen dibagi
menjadi beberapa blok terpisah. Dalam hal ini, setiap blok stimulus bekerja secara paralel
pada waktu simulasi nol. Penggunaan blok stimulus terpisah menghasilkan bangku tes
yang lebih mudah dibuat, didebug, dipelihara, dan ditingkatkan.

Desain modular

TB harus dapat digunakan kembali tanpa modifikasi yang sulit

• Struktur TB harus cukup sederhana agar orang lain memahami perilakunya.

• Ini harus mudah dijalankan - Tidak banyak ketergantungan pada file atau skrip.
• Bangku uji yang baik menyebarkan semua generik dan konstanta ke DUT.

Testbench yang dapat disintesis

Menulis bangku pengujian yang sinkron dan dapat disintesis adalah praktik yang baik
jika, misalnya, desainnya menyertakan penyeberangan domain jam, agar berfungsi pada
FPGA. Ini adalah desain praktik yang baik bahwa testbench menyertakan semua batasan
yang dapat disintesis.

Penghitung Batas Waktu

Gunakan penghitung waktu tunggu untuk mendeteksi jika desain tidak merespons
sama sekali! - Anda tidak boleh bergantung pada desainer yang memeriksa bentuk
gelombang.
 Input Tes Acak

Masukan uji acak baik untuk menemukan kasing sudut, mudah diproduksi,
memungkinkan kumpulan vektor uji yang besar. Gunakan generator bilangan pseudo-
random untuk menghasilkan seri yang sama jika seednya sama.

Assertion

Ini adalah praktik yang baik untuk menggunakan pernyataan, ini bagus untuk deteksi
peristiwa, Memeriksa tidak adanya peristiwa tertentu, yang merupakan tanda kegagalan.

Sintaks dasar pernyataan laporan di VHDL adalah:

report <message_string> [severity <severity_level>];

String pesan harus berupa string. Tingkat keparahan memiliki tipe data std. standar.
tingkat keparahan Nilai yang memungkinkan adalah catatan, peringatan, kesalahan,
kegagalan.

For example:

report “this is a message”; — severity note– or:report “this is a serious message”

severity warning;

assert 5 = 2 + 2; assert 5 = 3 + 2 report “Assertion violation.”; assert 5 = 3 + 2

report “Assertion violation.” severity error;

Jenis Waktu VHDL

Coba gunakan Jenis Waktu yang telah ditentukan sebelumnya VHDL. Kita perlu
mendefinisikan waktu dengan memberikan angka dan satuan waktu.

Tabel di bawah ini menunjukkan daftar satuan waktu yang dapat kita gunakan dengan tipe
waktu VHDL.
2.3. Peralatan yang dibutuhkan
• Komputer yang sudah terinstall software XILINX ISE Design Suite 14.7 dan
Adept Digilent
• BASYS 2 FPGA board
2.4. Langkah percobaan

1. Buka software ISE Design Suite 14.7

2. Klik pada tombol “New Project” untuk membuat project baru.

3. Beri nama project dan letakkan project pada folder yang ditentukan serta Top-level
source type adalah HDL
4. Setting jenis FPGA dan konfigurasi lainnya sesuai gambar dibawah, dimana

Family: Spartan-3E

Device: XC3S100E atau XC3S250E, tergantung jenis chip board anda

Package: CP132

Speed: -4

Preferred Language: VHDL

5. Klik Next dan anda akan mendapat konfirmasi konfigurasi yang telah dilakukan.
Selanjutnya klik Finish
6. Selanjutnya buat file VHDL dengan cara klik kanan pada nama project, selanjutnya
pilih New Source
7. Pilih jenis source VHDL Module dan berilah nama, misalnya Counter

8. Selanjutnya langsung klik Next kemudian Finish, karena kita akan membuat port
secara manual dengan text.
9. Maka anda akan mendapatkan file baru (*.vhd), tetapi tanpa deskripsi port yang
akan digunakan.
10. Untuk percobaan ini kita akan mensimulasikan Counter 4-bit.

Counter Test Bench

Counter
11. Edit VHDL code menjadi generic couer seperti berikut:
12. Lakukan pengecekan penulisan,dengan cara RUN Check Syntax sebagaimana
gambar berikut kemudian Synthesize

Lanjutkan ke langkah 13, jika tidak ada error.

Selanjutnya pindahkan VIEW: dari Implementation ke Simulation (Posisi di Pojok Kanan

Atas)
13. Selanjutnya buat file Test Bench VHDL dengan cara klik kanan pada nama project,
selanjutnya pilih New Source, dan pilih jenis source VHDL Test Bench

Maka Secara otomatis anda akan medapatkan file untuk simulas.

14. Edit bagian Stimulus Process pada kode VHDL sebagai berikut: -- Stimulus
process stim_proc: process
begin
reset <= '1';
-- hold reset state for 100 ns.
wait for 100 ns;
reset <= '0';

wait for clock_period*10;

-- insert stimulus here

count_en <= '1';
 wait
;
end process;
15. Run Simulate Behavioral model
16. Anda akan mendapatkan hasil simulasinya.

17. Edit file test bench sebagai berikut.

-----------------------------------------------------------------------
-- Test Bench for counter (ESD figure 2.6)
-- created by Weijun Zhang, 04/2001
-- edite by Arif
-----------------------------------------------------------------------

library ieee;
use ieee.std_logic_1164.all;
use ieee.std_logic_unsigned.all;
use ieee.std_logic_arith.all;

entity counter_TB is
-- entity declaration end counter_TB;

-----------------------------------------------------------------------

architecture TB of counter_TB is

component counter generic(n: natural :=4); port( clock: in std_logic;

reset: in std_logic; count_en: in std_logic;
count_out: out std_logic_vector(n-1 downto 0)
);
end component;

signal T_clock: std_logic;

signal T_clear: std_logic;
signal T_count: std_logic;
signal T_Q: std_logic_vector(3 downto 0);

begin

U_counter: counter port map (clock => T_clock,

 reset => T_clear,
count_en => T_count,
count_out => T_Q);

process
begin
T_clock <= '0'; -- clock cycle is 10 ns
wait for 5 ns; T_clock <= '1';
wait for 5 ns;
end process;

process

variable err_cnt: integer :=0;

begin

T_clear <= '1'; -- start counting

T_count <= '1'; wait for 20 ns;

T_clear <= '0'; -- clear output

-- test case 1
wait for 10 ns;
assert (T_Q=1) report "Failed case 1" severity error;
if (T_Q/=1) then
err_cnt := err_cnt+1;
end if;

-- test case 2 wait for 10 ns;

assert (T_Q=2) report "Failed case 2" severity error;
if (T_Q/=2) then
err_cnt := err_cnt+1;
end if;

-- test case 3
wait for 10 ns;
assert (T_Q=3) report "Failed case 3" severity error;
if (T_Q/=3) then
err_cnt := err_cnt+1;
end if;

-- test case 4
wait for 10 ns;
assert (T_Q=4) report "Failed case 4" severity error;
if (T_Q/=4) then
err_cnt := err_cnt+1;
end if;
 -- test case 5 wait for 200 ns;
T_clear <= '1';

wait for 10 ns;

assert (T_Q=0) report "Failed case 5" severity error;
if (T_Q/=0) then
err_cnt := err_cnt+1;
end if;

-- summary of all the tests

if (err_cnt=0) then
assert false
report "Testbench of Counter completed successfully!" severity note;
else
assert true
report "Something wrong, try again" severity error;
end if;

wait;

end process;

end TB;

----------------------------------------------------------------
configuration CFG_TB of counter_TB is
for TB end for;
end CFG_TB;
----------------------------------------------------------------

18. Tugas: Lakukan cara yang sama untuk percobaan counter dan decoder
seven segemen pada percobaan sebelumnya.
2.5. Data Hasil Percobaan
2.5.1. Percobaan 1

1. Membuka software ISE Design Suite 14.7

2. Meng-klik pada tombol “New Project” untuk membuat project baru.

3. Memberi nama project dan letakkan project pada folder yang ditentukan serta Top-
level source type adalah HDL
4. Setting jenis FPGA dan konfigurasi lainnya sesuai gambar dibawah, dimana

Family: Spartan-3E

Device: XC3S100E atau XC3S250E, tergantung jenis chip board anda

Package: CP132

Speed: -4

Preferred Language: VHDL

5. Meng-klik Next dan anda akan mendapat konfirmasi konfigurasi yang telah
dilakukan. Selanjutnya klik Finish
6. Selanjutnya membuat file VHDL dengan cara klik kanan pada nama project,
selanjutnya pilih New Source

7. Memilih jenis source VHDL Module dan berilah nama, misalnya Counter

8. Selanjutnya langsung meng-klik Next kemudian Finish, karena kita akan membuat
port secara manual dengan text.
9. Maka saya akan mendapatkan file baru (*.vhd), tetapi tanpa deskripsi port yang
akan digunakan.
10. Untuk percobaan ini kita akan mensimulasikan Counter 4-bit.

Counter Test Bench

Counter

11. Edit VHDL code menjadi generic counter seperti berikut:

library IEEE;
use IEEE.STD_LOGIC_1164.ALL;
use IEEE.STD_LOGIC_UNSIGNED.ALL;

entity counter is

generic(n: natural :=4);

port( clock: in std_logic;
reset: in std_logic;
count_en: in std_logic;
count_out: out std_logic_vector(n-1 downto 0)
);
end counter;
----------------------------------------------------------------------------------
architecture Behavioral of counter is

signal sign_counter: std_logic_vector(n-1 downto 0);

begin
-- behavor describe the counter

process(clock, count_en, reset)

begin
if reset = '1' then
sign_counter <= (others=>'0');
elsif (clock='1' and clock'event) then
if count_en = '1' then
sign_counter <= sign_counter + 1;
end if;
end if;
end process;
-- concurrent assignment statement
count_out <= sign_counter;

end Behavioral;
12. Lakukan pengecekan penulisan,dengan cara RUN Check Syntax sebagaimana
gambar berikut kemudian Synthesize

Lanjutkan ke langkah 13, jika tidak ada error.

Pindahkan VIEW: dari Implementation ke Simulation (Posisi di Pojok Kiri Atas)

13. Selanjutnya buat file Test Bench VHDL dengan cara klik kanan pada nama project,
selanjutnya pilih New Source, dan pilih jenis source VHDL Test Bench
 Maka Secara otomatis anda akan medapatkan file untuk simulas.

14. Edit bagian Stimulus Process pada kode VHDL sebagai berikut: -- Stimulus
process stim_proc: process
begin
reset <= '1';
-- hold reset state for 100 ns.
wait for 100 ns;
 reset <= '0';

wait for clock_period*10;

-- insert stimulus here

count_en <= '1';

wait
;
end process;
15. Run Simulate Behavioral Syntax

16. Run Simulate Behavioral Model

17. Maka saya mendapatkan hasil simulasinya.
 2.5.2. Counter Test Bench
1. Pada percobaan Test Bench pada file counter disini yang dilakukan hanya
mengubah program pada file Test Bench menjadi seperti di bawah ini :

-----------------------------------------------------------------------
-- Test Bench for counter (ESD figure 2.6)
-- created by Weijun Zhang, 04/2001
-- edite by Arif
-----------------------------------------------------------------------

library ieee;
use ieee.std_logic_1164.all;
use ieee.std_logic_unsigned.all;
use ieee.std_logic_arith.all;

entity counter_TB is
-- entity declaration end counter_TB;

-----------------------------------------------------------------------

architecture TB of counter_TB is

component counter generic(n: natural :=4); port( clock: in std_logic;

reset: in std_logic; count_en: in std_logic;
count_out: out std_logic_vector(n-1 downto 0)
);
end component;

signal T_clock: std_logic;

signal T_clear: std_logic;
signal T_count: std_logic;
signal T_Q: std_logic_vector(3 downto 0);

begin

U_counter: counter port map (clock => T_clock,

reset => T_clear,
count_en => T_count,
count_out => T_Q);

process
begin
T_clock <= '0'; -- clock cycle is 10 ns
wait for 5 ns; T_clock <= '1';
wait for 5 ns;
end process;
process

variable err_cnt: integer :=0;

begin

T_clear <= '1'; -- start counting

T_count <= '1'; wait for 20 ns;

T_clear <= '0'; -- clear output

-- test case 1
wait for 10 ns;
assert (T_Q=1) report "Failed case 1" severity error;
if (T_Q/=1) then
err_cnt := err_cnt+1;
end if;

-- test case 2 wait for 10 ns;

assert (T_Q=2) report "Failed case 2" severity error;
if (T_Q/=2) then
err_cnt := err_cnt+1;
end if;

-- test case 3
wait for 10 ns;
assert (T_Q=3) report "Failed case 3" severity error;
if (T_Q/=3) then
err_cnt := err_cnt+1;
end if;

-- test case 4
wait for 10 ns;
assert (T_Q=4) report "Failed case 4" severity error;
if (T_Q/=4) then
err_cnt := err_cnt+1;
end if;

-- test case 5 wait for 200 ns;

T_clear <= '1';

wait for 10 ns;

assert (T_Q=0) report "Failed case 5" severity error;
if (T_Q/=0) then
err_cnt := err_cnt+1;
end if;
 -- summary of all the tests
if (err_cnt=0) then
assert false
report "Testbench of Counter completed successfully!" severity note;
else
assert true
report "Something wrong, try again" severity error;
end if;

wait;

end process;

end TB;

----------------------------------------------------------------
configuration CFG_TB of counter_TB is
for TB end for;
end CFG_TB;
----------------------------------------------------------------
2. Kemudian setelah program diubah dengan program diatas, maka selanjutnya
melakukan Behavioral Check Syntax untuk mencari tau apakah Syntax program
sudah benar atau tidak.
3. Kemudian setelah sukses maka selanjutnya melakukan Simulate Behavioral
Model, untuk melihat hasil simulasi dari program Test Bench yang sudah kita buat
apakah cocok dengan hasil keluaran yang kita harapkan.

4. Maka saya akan mendapatkan hasil simulasi seperti dibawah ini.

 2.5.3. Decoder Seven Segment
1. Pada percobaan Test Bench untuk praktikum Decoder Seven Segment disini
menggunakan program inti dari program Decoder Seven Segment pada Tugas Percobaan
1 sebelumnya, dimana disini saya akan menjalankan program Test Bench untuk program
Decoder Seven Segment apakah sudah berjalan seperti yang diharapkan atau masih ada
kesalahan.
2. Membuat file Test Bench seperti langkah ke-13.
3. Setelah mendapat file Test Bench, mengedit file Test Bench dengan program seperti di
bawah ini :

LIBRARY ieee;
USE ieee.std_logic_1164.ALL;

ENTITY tb_seven_seg IS
END tb_seven_seg;

ARCHITECTURE behavior OF tb_seven_seg IS

COMPONENT sev_seg
PORT(
Switch : IN std_logic_vector(3 downto 0);
seg : OUT std_logic_vector(7 downto 0)
);
END COMPONENT;

--Inputs
signal Switch : std_logic_vector(3 downto 0) := (others => '0');
--Outputs
signal seg : std_logic_vector(7 downto 0);

BEGIN
-- Instantiate the Unit Under Test (UUT)
uut: sev_seg PORT MAP (
Switch => Switch,
seg => seg
);

-- Stimulus process
stim_proc: process

begin
Switch <= "0000";
wait for 50 ns;
Switch <= "0001";
 wait for 50 ns;
Switch <= "0010";
wait for 50 ns;
Switch <= "0011";
wait for 50 ns;
Switch <= "0100";
wait for 50 ns;
Switch <= "0101";
wait for 50 ns;
Switch <= "0110";
wait for 50 ns;
Switch <= "0111";
wait for 50 ns;
Switch <= "1000";
wait for 50 ns;
Switch <= "1001";
wait for 50 ns;
Switch <= "1010";
wait for 50 ns;
Switch <= "1011";
wait for 50 ns;
Switch <= "1100";
wait for 50 ns;
Switch <= "1101";
wait for 50 ns;
Switch <= "1110";
wait for 50 ns;
Switch <= "1111";
wait for 50 ns;
end process;
END;
4. Selanjutnya melakukan Behavioral Check Syntax pada program Test Bench untuk
melihat apakah terdapat error atau tidak pada program.

5. Jika tidak ada error maka selanjutnya menjalan simulasi Test Bench dengan cara Run
Simulate Behavioral Model.
6. Kemudian akan didapat tampilan simulasi Test Bench seperti dibawah ini.
2.6. Analisa dan Kesimpulan
2.6.1. Analisa
Pada praktikum piranti terprogram kali ini yaitu Perancangan FPGA dengan
Simulasi (Test Bench) saya melakukan 3 percobaan yaitu pertama melakukan percobaan
Test Bench terhadap program counter dengan program Test Bench yang sederhana, hal
pertama yang dilakukan yaitu membuat file .vhd dari counter yaitu dengan cara membuat
folder New Project kemudian membuat file .vhd dengan settingan seperti yang terlihat
pada modul, setelah mendapat file .vhd yang kosong selanjutnya mengedit file dengan
membuat program counter yang sudah ada pada modul praktikum seperti di bawah ini:

library IEEE;
use IEEE.STD_LOGIC_1164.ALL;
use IEEE.STD_LOGIC_UNSIGNED.ALL;

entity counter is

generic(n: natural :=4);

port( clock: in std_logic;
reset: in std_logic;
count_en: in std_logic;
count_out: out std_logic_vector(n-1 downto 0)
);
end counter;
----------------------------------------------------------------------------------
architecture Behavioral of counter is

signal sign_counter: std_logic_vector(n-1 downto 0);

begin
-- behavor describe the counter

process(clock, count_en, reset)

begin
 if reset = '1' then
sign_counter <= (others=>'0');
elsif (clock='1' and clock'event) then
if count_en = '1' then
sign_counter <= sign_counter + 1;
end if;
end if;
end process;
-- concurrent assignment statement
count_out <= sign_counter;

end Behavioral;

Setelah program counter dibuat, selanjutnya melakukan Check Syntax untuk

memastikan Syntax dari program sudah benar dan siap dijalankan, kemudian setelah
sukses selanjutnya yaitu melakukan Synthesize. Setelah melakukan Synthesize
selanjutnya memindahkan View dari Implementation ke View Simulation, kemudian
membuat file Test Bench dari counter tersebut dengan cara klik kanan pada folder di
pojok kiri atas kemudian klik New Source dan pilih VHDL Test Bench untuk membuat
file Test Bench, jika sudah selesai membuat file Test Bench selanjutnya mengedit file
dengan membuat program Test Bench seperti dibawah ini:

LIBRARY ieee;
USE ieee.std_logic_1164.ALL;

-- Uncomment the following library declaration if using

-- arithmetic functions with Signed or Unsigned values
--USE ieee.numeric_std.ALL;

ENTITY counter_tb1 IS
END counter_tb1;

ARCHITECTURE behavior OF counter_tb1 IS

 -- Component Declaration for the Unit Under Test (UUT)

COMPONENT counter
PORT(
clock : IN std_logic;
reset : IN std_logic;
count_en : IN std_logic;
count_out : OUT std_logic_vector(3 downto 0)
);
END COMPONENT;

--Inputs
signal clock : std_logic := '0';
signal reset : std_logic := '0';
signal count_en : std_logic := '0';

--Outputs
signal count_out : std_logic_vector(3 downto 0);

-- Clock period definitions

constant clock_period : time := 10 ns;

BEGIN

-- Instantiate the Unit Under Test (UUT)

uut: counter PORT MAP (
clock => clock,
reset => reset,
 count_en => count_en,
count_out => count_out
);

-- Clock process definitions

clock_process :process
begin
clock <= '0';
wait for clock_period/2;
clock <= '1';
wait for clock_period/2;
end process;

-- Stimulus process
stim_proc: process
begin
reset <='1';
-- hold reset state for 100 ns.
wait for 100 ns;
reset <='0';
wait for clock_period*10;
count_en <='1';
-- insert stimulus here
wait;
end process;
END;
 Jika file sudah diedit dengan membuat program Test Bench, selanjutnya
melakukan Behavioral Check Syntax dan jika sudah berhasil selanjutnya melakukan
simulasi dengan Run Simulate Behavioral Model dan jika sudah sukses maka tampilan
simulasi akan terlihat seperti dibawah ini :

Pada simulasi terlihat saat pertama proses jalan, reset langsung = 1 kemudian
setelah 100 ns reset menjadi = 0 kemudian 100 ns kemudian count_en menjadi = 1 dan
langsung proses count atau menghitung berlangsung, hal itu sesuai dengan program dari
counter dan Test Bench dari counter seperti dibawah :

begin
reset <='1';
-- hold reset state for 100 ns.
wait for 100 ns;
reset <='0';
wait for clock_period*10;
count_en <='1';
-- insert stimulus here
wait;

Terlihat pada program TB reset awal-awal = 1 kemudian menunggu 100 ns

kemudian menjadi reset = 0 kemudian menunggu lagi pada waktu *10 dimana
sebelumnya waktu diset 10 ns sehingga menunggu 100 ns lagi kemudian count_en =1
kemudian terdapat instruksi wait yang membuat keadaan selanjutnya tetap seperti itu,
hal ini sesuai dengan hasil simulasi pada software.
 Untuk program counter seperti di bawah :

process(clock, count_en, reset)

begin
if reset = '1' then
sign_counter <= (others=>'0');
elsif (clock='1' and clock'event) then
if count_en = '1' then
sign_counter <= sign_counter + 1;
end if;
end if;
end process;
-- concurrent assignment statement
count_out <= sign_counter;

Terlihat disana instruksi jika reset = 1 maka proses count tidak berjalan, kemudian
jika clock dalam logika 1 dan count_en juga dalam keadaan 1 maka proses count
berlangsung, hal itu sama seperti hasil simulasi pada software.
Kemudian percobaan ke-2 yang saya lakukan yaitu masih membuat program Test
Bench terhadap program counter namun program Test Bench yang dibuat berbeda,
Programnya seperti di bawah ini :

LIBRARY ieee;
USE ieee.std_logic_1164.ALL;
use ieee.std_logic_unsigned.all;
use ieee.std_logic_arith.all;

ENTITY tb_counter IS
END tb_counter;
ARCHITECTURE TB OF tb_counter IS
-- Component Declaration for the Unit Under Test (UUT)
COMPONENT counter
generic(n:natural:=4);
 PORT(
clock : IN std_logic;
reset : IN std_logic;
count_en : IN std_logic;
count_out : OUT std_logic_vector(n-1 downto 0)
);
END COMPONENT;
signal T_clock : std_logic;
signal T_clear : std_logic;
signal T_count : std_logic;
signal T_Q : std_logic_vector(3 downto 0);
BEGIN
U_counter: counter port map (
clock => T_clock,
reset => T_clear,
count_en => T_count,
count_out => T_Q
);
process
begin
T_clock <= '0'; -- clock
cycle is 10 ns
wait for 5 ns;
T_clock <= '1';
wait for 5 ns;
end process;
process
variable err_cnt: integer:=0;
begin
T_clear <= '1'; -- start counting
 T_count <= '1';
wait for 20 ns;
T_clear <= '0'; -- clear output
-- test case 1
wait for 10 ns;
assert(T_Q=1)report "Failed case 1" severity error;
if(T_Q/=1)then
err_cnt:=err_cnt+1;
end if;
-- test case 2
wait for 10 ns;
assert(T_Q=2)report "Failed case 2" severity error;
if(T_Q/=2)then
err_cnt:= err_cnt+1;
end if;
-- test case 3
wait for 10 ns;
assert(T_Q=3)report "Failed case 3" severity error;
if(T_Q/=3)then
err_cnt:=err_cnt+1;
end if;
--test case 4
wait for 10 ns;
assert(T_Q=4)report "Failed case 4" severity error;
if(T_Q/=4)then
err_cnt:=err_cnt+1;
end if;
-- test case 5
wait for 200 ns;
T_clear <='1';
 wait for 10 ns;
assert(T_Q=0)report "Failed case5" severity error;
if(T_Q/=0)then
err_cnt:=err_cnt+1;
end if;
--summary of all the test
if(err_cnt=0)then
assert false
report "Testbench of Counter completed succesfully!"
severity note;
else
assert true
report "Something wrong, try again"
severity error;
end if;
wait;
end process;
END TB;
-----------------------------------------------------------------------
configuration CFG_TB of tb_counter is
for TB
end for;
end CFG_TB;
-----------------------------------------------------------------------

Kemudian menjalan Simulate Behavioral Model sehingga didapat hasil simulasi

seperti di bawah ini:
 Dapat dilihat pada hasil simulasi dimana proses counting berjalan saat clock dalam
keadaan 1 dan count_en dalam keadaan 1 sedangkan reset dalam keadaan 0, yang sesuai
dengan program counter seperti penjelasan pada Test Bench sebelumnya.
Pada percobaan ke-3 yaitu merupakan tugas dari praktikum ini yaitu membuat
Test Bench dari program Decoder Seven Segment dari percobaan 1, dimana langkah-
langkah dalam pembuatan file sama seperti pembuatan file Test Bench pada sebelum-
sebelumnya yang berbeda adalah Syntax program, program yang saya gunakan yaitu
seperti di bawah ini :

LIBRARY ieee;
USE ieee.std_logic_1164.ALL;

ENTITY tb_seven_seg IS
END tb_seven_seg;

ARCHITECTURE behavior OF tb_seven_seg IS

COMPONENT sev_seg
PORT(
Switch : IN std_logic_vector(3 downto 0);
seg : OUT std_logic_vector(7 downto 0)
);
 END COMPONENT;
--Inputs
signal Switch : std_logic_vector(3 downto 0) := (others => '0');
--Outputs
signal seg : std_logic_vector(7 downto 0);
BEGIN
-- Instantiate the Unit Under Test (UUT)
uut: sev_seg PORT MAP (
Switch => Switch,
seg => seg
);
-- Stimulus process
stim_proc: process
begin
Switch <= "0000";
wait for 50 ns;
Switch <= "0001";
wait for 50 ns;
Switch <= "0010";
wait for 50 ns;
Switch <= "0011";
wait for 50 ns;
Switch <= "0100";
wait for 50 ns;
Switch <= "0101";
wait for 50 ns;
Switch <= "0110";
wait for 50 ns;
Switch <= "0111";
wait for 50 ns;
 Switch <= "1000";
wait for 50 ns;
Switch <= "1001";
wait for 50 ns;
Switch <= "1010";
wait for 50 ns;
Switch <= "1011";
wait for 50 ns;
Switch <= "1100";
wait for 50 ns;
Switch <= "1101";
wait for 50 ns;
Switch <= "1110";
wait for 50 ns;
Switch <= "1111";
wait for 50 ns;
end process;
END;

Setelah membuat program Test Bench dari Decoder Seven Segment, selanjutnya
menjalankan simulasi Test Bench dengan menjalankan Simulate Behavioral Model, dan
akan didapat hasil simulasi seperti di bawah ini :
 Dari hasil simulasi tersebut terlihat bahwa saat switch membentuk biner 0000
maka output dari segment akan membentuk biner 11000000 dimana ini jika dipasang
pada hardware seven segment akan membentuk angka 0, dan selanjutnya pada switch
0001 maka output segmentnya akan membentuk 11111001 yang jika dilihat pada
hardware seven segment akan membentuk angka 1 dan seterusnya, hal ini berarti program
Decoder Seven Segment yang sudah dibuat berhasil atau sama dengan hasil yang
diinginkan.
2.6.2. Kesimpulan
Pada praktikum 2 ini yaitu Perancanga FPGA dengan Test Bench sudah didapat
data hasil percobaan dan sudah dianalisa, dari kedua hal tersebut dapat diambil
kesimpulan bahwa :
1. Testbench VHDL digunakan untuk simulasi dan verifikasi desain FPGA. Verifikasi
diperlukan untuk memastikan bahwa desain memenuhi persyaratan waktu dan juga
digunakan untuk mensimulasikan fungsionalitas dari spesifikasi desain yang
diperlukan.
2. Program Test Bench akan mentrigger program .vhd untuk mengeluarkan output sesuai
program misal jika dibuat input sekian apakah output dari program akan sama dengan
yang diperkirakan atau tidak, jika tidak maka terdapat program yang kurang tepat dan
harus segera direvisi.
3. Melakukan Test Bench dahulu sebelum mengupload program ke dalam FPGA akan
mengurangi resiko upload ulang program karena pada simulasi Test Bench sudah
terlihat hasil output dari FPGA yang ingin dibuat, jadi jika masih terdapat program
yang kurang tepat masih bisa diperbaiki dengan program ulang atau merevisi program
dan jika hasil simulasi sudah sesuai dapat langsung diupload ke dalam hardware
FPGA.