Thiết kế logic số bằng ngôn ngữ vhdl

BỘ THÔNG TIN VÀ TRUYỀN THÔNG
HỌC VIỆN CÔNG NGHỆ BƯU CHÍNH VIỄN THƠNG

BÁO CÁO BÀI TẬP LỚN MƠN THIẾT KẾ
LOGIC SỐ
Giảng viên : Trần Thị Thúy Hà
Nhóm : 20
Sinh viên : Nguyễn Đức Thắng – B20DCDT205
Nguyễn Tiến Dũng – B20DCDT032

Hà Nội -2023


LỜI NÓI ĐẦU
Ngày nay, với sự phát triển vượt bậc của các ngành khoa học đều nhằm mục đích
phục vụ lợi ích cho con người. Kĩ thuật điện tử là một trong những lĩnh vực có đóng góp
rất lớn trong việc nâng cao và cải thiện đời sống của con người cùng với đó là các phương
pháp thiết kế mạch điện tử được sáng tạo và sử dụng rộng rãi. Trong kì học này, bộ mơn
Thiết kế Logic số mà học viện lựa chọn giúp chúng em được tiếp xúc với ngôn ngữ
VHDL do hãng Xilinx – một trong những hãng sản xuất chip bán dẫn hàng đầu thế giới
sáng tạo ra.
Sau khoảng thời gian học tập, trau dồi và tích lũy kiến thức tại học viện thì bài tập
lớn lần này cơ hội cho chúng em được vận dụng những lí thuyết được học vào thực hiện
thiết kế mạch logic mô phỏng.
Cảm ơn cô Trần Thị Thúy Hà đã đồng hành cùng với chúng em trong khoảng thời
gian qua. Nếu báo cáo có bất kì thiếu xót hay chưa đúng mong cơ hướng dẫn cũng như
góp ý để bọn em có thể khắc phục cho tương lai.

1

MỤC LỤC

LỜI NÓI ĐẦU...........................................................................................1
MỤC LỤC.................................................................................................2
Bài 1:.........................................................................................................2
1. Cơ sở lý thuyết......................................................................................2
2.Dưới đây là vhdl và mã testbench tương ứng của mạch tạo mã
hamming (7,4):..........................................................................................3
...................................................................................................................3
3.Dưới đây là mã vhdl và testbench tương ứng mạch giải mã haming:....6
Bài 2:.......................................................................................................22
1. Cơ sở lí thuyết......................................................................................22
2. Áp dụng cho code VHDL......................................................................23
2.1. Code chương trình............................................................................23
2.2. Code testbench.................................................................................25
Bài 3:........................................................................................................31
1.Cơ sở lí thuyết......................................................................................31
2.Áp dụng cho code VHDL.......................................................................31
2.1.Code chương trình............................................................................31
2.2.Code testbench.................................................................................36
Bài 4:........................................................................................................39
1. Cơ sở lí thuyết......................................................................................39
2.Áp dụng code VHDL..............................................................................40
2


2.1.Code chương trình............................................................................41
2.2.Code testbench..................................................................................45
Bài 5 :......................................................................................................50
1. Cơ sở lí thuyết......................................................................................50

2.Áp dụng code VHDL...........................................................................51
2.1.

Code chương trình ....................................................................51

2.2.

Code cho Trigger JK....................................................................52

2.3.Code testbench.................................................................................54

3


Bài 1:
Viết chương trình mơ tả mạch tạo mã và giải mã Hamming. Viết testbench để
kiểm tra hoạt động của mạch.
1. Cơ sở lý thuyết
Ở đây ,em tạo mã và giải mã hamming chẵn (7,4) như sau :
Đầu tiên , với mạch tạo mã từ 4 bit D1,D2,D3,D4 , sẽ tạo ra mã hamming chẵn hamming
7 bit D4D3D2P2D1P1P0 thỏa mãn :P0=D1 XOR D2 XOR D4, P1=P1 XOR D1 XOR D3
XOR D4 ,P2 =P2 XOR D2 XOR D3 XOR D4
Thứ hai, với mạch giải mã : em xét lỗi bit đầu vào 7bit s2s1s0 nếu s2s1s0 =000 thì mã
khơng có lỗi s2s1s0 =001 thì mã có lỗi ở bit ở vị trí thứ 1 , s2s1s0 =010 khi đó mã có lỗi
ở vị trí thứ 2 , s2s1s0 =011 khi đó lỗi ở vị trí thứ 3 , s2s1s0 =100 thì mã có lỗi ở vị trí thứ
4 , s2s1s0 =101 thì mã có lỗi ở vi trí thứ 5 , s2s1s0 =110 => mã có lỗi ở vị trí thứ 6 ,
s2s1s0 =111, mã có lỗi ở vị trí thứ 7

2.Dưới đây là vhdl và mã testbench tương ứng của mạch tạo mã hamming
(7,4):

library IEEE;
use IEEE.STD_LOGIC_1164.ALL;
use IEEE.STD_LOGIC_ARITH.ALL;
use IEEE.STD_LOGIC_UNSIGNED.ALL;
entity Hamming is
Port ( D : in STD_LOGIC_VECTOR(4 downto 1);
H : out STD_LOGIC_VECTOR(7 downto 1));
end Hamming;

4


architecture Behavioral of Hamming is
begin
-- Mã hóa Hamming (7,4)
process(D)
variable p0, p1, p2: STD_LOGIC;
begin
p0 := D(1) XOR D(2) XOR D(4);
p1 := D(1) XOR D(3) XOR D(4);
p2 := D(2) XOR D(3) XOR D(4);
H<=D(4) & D(3) & D(2)& p2 & D(1)& p1& p0;

end process;
end Behavioral;

5


library IEEE;

use IEEE.STD_LOGIC_1164.ALL;
use IEEE.STD_LOGIC_ARITH.ALL;
use IEEE.STD_LOGIC_UNSIGNED.ALL;
entity Testbench is
end Testbench;
architecture behavior of Testbench is
signal D : std_logic_vector(4 downto 1);
signal H : std_logic_vector(7 downto 1);
-- T?o tín hi?u vào D ra H cho ma chan
begin
uut_encode : entity work.Hamming port map (D => D, H => H);-- N?i chân
process
begin
for i in 0 to 15 loop-- t?O vịng lap cho tín hi?u vào d
case i is
when 0 =>
D <= "0000";
when 1 =>
D <= "0001";
when 2 =>
D <= "0010";
when 3 =>
D <= "0011";
when 4 =>
D <= "0100";
when 5 =>
D <= "0101";
when 6 =>
D <= "0110";
when 7 =>

D <= "0111";

6


3.Dưới đây là mã vhdl và testbench tương ứng mạch giải mã haming:
library IEEE;
use IEEE.STD_LOGIC_1164.ALL;
use IEEE.STD_LOGIC_ARITH.ALL;
use IEEE.STD_LOGIC_UNSIGNED.ALL;
entity HammingDecoder is
Port ( H : in STD_LOGIC_VECTOR(7 downto 1 );
K : out STD_LOGIC_VECTOR( 7 downto 1 )
);
end HammingDecoder;
architecture Behavioral of HammingDecoder is
begin
process(H)
variable S0 , S1, S2: STD_LOGIC;
variable Syndrome: STD_LOGIC_VECTOR(2 downto 0);
begin
S0 := H(1) XOR H(3) XOR H(5)XOR H(7);
S1 := H(2) XOR H(3) XOR H(6)XOR H(7);
S2 := H(4) XOR H(5) XOR H(6)XOR H(7);
Syndrome := S2 & S1 & S0;
if Syndrome = "000" then
K <= H(7)& H(6)& H(5)& H(4)& H(3)& H(2)& H(1);
else
case Syndrome is
when "001" =>

K <= H(7) & H(6) & H(5) & H(4)& H(3)&H(2)& not H(1);
when "010" =>
7


K <= H(7) & H(6) & H(5) & H(4)& H(3)& not H(2)& H(1);
when "011" =>
K <= H(7) & H(6) & H(5) & H(4)& not H(3)& H(2)& H(1);
when "100"=>
K <= H(7)& H(6)&H(5)& not H(4)&H(3)&H(2)&H(1);
when"101"=>
K <=H(7)& H(6)& not H(5)& H(4)&H(3)&H(2)&H(1);
when "110"=>
K <=H(7)& not H(6)& H(5)& H(4)& H(3)& H(2)& H(1);
when others =>
K <= not H(7)& H(6)& H(5)& H(4)& H(3)& H(2)& H(1);
end case;
end if;
end process;
end behavioral;
library IEEE;
use IEEE.STD_LOGIC_1164.ALL;
use IEEE.STD_LOGIC_ARITH.ALL;
use IEEE.STD_LOGIC_UNSIGNED.ALL;
entity Testbench is
end Testbench;
architecture behavior of Testbench is
signal M : std_logic_vector(7 downto 1 );
signal K : std_logic_vector( 7 downto 1 );
-- Tao tin hieu vào ra giai hamming ch?n

8


begin
uut_decode : entity work.HammingDecoder port map (H => M , K => K );
process
begin
for i in 0 to 127 loop
case i is
when 0=>
M <= "0000000";
when 1=>
M <= "0000001";
when 2=>
M <="0000010";
when 3=>
M <="0000011";
when 4=>
M <="0000100";
when 5=>
M <="0000101";
when 6=>
M <="0000110";
when 7=>
M <="0000111";
when 8 =>
M <="0001000";
when 9=>
M <="0001001";
when 10=>

9


M <="0001010";
when 11 =>
M <="0001011";
when 12=>
M <="0001100";
when 13=>
M <="0001101";
when 14=>
M <="0001110";
when 15=>
M <="0001111";
when 16=>
M <="0010000";
when 17=>
M <="0010001";
when 18=>
M <="0010010";
when 19=>
M <="0010011";
when 20 =>
M <="0010100";
when 21 =>
M<="0010101";
when 22 =>
M<="0010110";
when 23 =>
M<="0010111";

when 24 =>
10


M<="0011000";
when 25 =>
M<="0011001";
when 26 =>
M<="0011010";
when 27 =>
M<="0011011";
when 28 =>
M<="0011100";
when 29 =>
M<="0011101";
when 30 =>
M<="0011110";
when 31 =>
M<="0011111";
when 32 =>
M<="0100000";
when 33 =>
M<="0100001";
when 34 =>
M<="0100010";
when 35 =>
M<="0100011";
when 36 =>
M<="0100100";
when 37 =>

M<="0100101";
when 38 =>
11


M<="0100110";
when 39 =>
M<="0100111";
when 40 =>
M<="0101000";
when 41 =>
M<="0101001";
when 42 =>
M<="0101010";
when 43 =>
M<="0101011";
when 44 =>
M<="0101100";
when 45 =>
M<="0101101";
when 46 =>
M<="0101110";
when 47 =>
M<="0101111";
when 48 =>
M<="0110000";
when 49 =>
M<="0110001";
when 50 =>
M<="0110010";

when 51 =>
M<="0110011";
when 52 =>
12


M<="0110100";
when 53 =>
M<="0110101";
when 54 =>
M<="0110110";
when 55 =>
M<="0110111";
when 56 =>
M<="0111000";
when 57 =>
M<="0111001";
when 58 =>
M<="0111010";
when 59 =>
M<="0111011";
when 60 =>
M<="0111100";
when 61 =>
M<="0111101";
when 62 =>
M<="0111110";
when 63 =>
M<="0111111";
when 64 =>

M<="1000000";
when 65 =>
M<="1000001";
when 66 =>
13


M<="1000010";
when 67 =>
M<="1000011";
when 68 =>
M<="1000100";
when 69 =>
M<="1000101";
when 70 =>
M<="1000110";
when 71 =>
M<="1000111";
when 72 =>
M<="1001000";
when 73 =>
M<="1001001";
when 74 =>
M<="1001010";
when 75 =>
M<="1001011";
when 76 =>
M<="1001100";
when 77 =>
M<="1001101";

when 78 =>
M<="1001110";
when 79 =>
M<="1001111";
when 80 =>
14


M<="1010000";
when 81 =>
M<="1010001";
when 82 =>
M<="1010010";
when 83 =>
M<="1010011";
when 84 =>
M<="1010100";
when 85 =>
M<="1010101";
when 86 =>
M<="1010110";
when 87 =>
M<="1010111";
when 88 =>
M<="1011000";
when 89 =>
M<="1011001";
when 90 =>
M<="1011010";
when 91 =>

M<="1011011";
when 92 =>
M<="1011100";
when 93 =>
M<="1011101";
when 94 =>
15


M<="1011110";
when 95 =>
M<="1011111";
when 96 =>
M<="1100000";
when 97 =>
M<="1100001";
when 98 =>
M<="1100010";
when 99 =>
M<="1100011";
when 100 =>
M<="1100100";
when 101 =>
M<="1100101";
when 102 =>
M<="1100110";
when 103 =>
M<="1100111";
when 104 =>
M<="1101000";

when 105 =>
M<="1101001";
when 106 =>
M<="1101010";
when 107 =>
M<="1101011";
when 108 =>
16


M<="1101100";
when 109 =>
M<="1101101";
when 110 =>
M<="1101110";
when 111 =>
M<="1101111";
when 112 =>
M<="1110000";
when 113 =>
M<="1110001";
when 114 =>
M<="1110010";
when 115 =>
M<="1110011";
when 116 =>
M<="1110100";
when 117 =>
M<="1110101";
when 118 =>

M<="1110110";
when 119 =>
M<="1110111";
when 120 =>
M<="1111000";
when 121 =>
M<="1111001";
when 122 =>
17


M<="1111010";
when 123 =>
M<="1111011";
when 124 =>
M<="1111100";
when 125 =>
M<="1111101";
when 126 =>
M<="1111110";
when others =>
M<="1111111";
end case;
wait for 10 ns;
end loop;
end process;
end Behavior;

Bài 2:
Viết chương trình mơ tả mạch điều khiển bơm nước vào một tháp nước nhờ 2

bơm P1 và P2 .Cả hai bơm P1 và P2 được mở (bơm nước) khi nước ở dưới mức 1
và vẫn mở cho đến khi nước chưa đạt tới mức 2. Khi nước vừa đạt tới mức 2 thì
bơm P1 ngắt (khơng bơm nước), chỉ cịn P2 vẫn bơm. P1 vẫn ngắt cho tới khi nước
lại ở dưới mức 1. P2 vẫn mở, chỉ khi nào nước đạt tới mức 3 thi P2 mới ngắt. P2

18


vẫn ngắt, chỉ mở khi nước lại xuống dưới mức 1.Viết testbench để kiểm tra hoạt
động của mạch.
1. Cơ sở lí thuyết
- Em chia mức nước trong bể với 4 mức với mức 0 tương ứng với đáy bể. Mức
1,2,3 được chia dựa theo yêu cầu đề bài tương ứng với trạng thái 1,2,3.
- Quá trình nước lên được miêu tả bằng như một xung clock đầu vào liên tục.
- Hai máy bơm được mô tả qua bit nhị phân : ‘1’ tương ứng với bơm bật,’0’
tương ứng với bơm tắt .
- Khi nước chạm mức 3 thì hai máy bơm tắt cho đến khi nước xuống lại mức
1, vì thế em coi trạng thái kế tiếp của trạng thái 3 là trạng thái 1.

2. Áp dụng cho code VHDL
2.1.

Code chương trình
library IEEE;
use IEEE.STD_LOGIC_1164.ALL;

entity baikiemtra2 is
Port ( water : in STD_LOGIC;
bom : out STD_LOGIC_VECTOR(1 downto 0));
end baikiemtra2;

architecture Behavioral of baikiemtra2 is
signal pr, nx: integer := 0;
begin
19