FPGA实验代码注释随笔

---

一、存储器实验

1.CALC1_PAK.vhd

--IEEE库
library IEEE;

--使用该库下的STD_LOGIC_1164
use IEEE.STD_LOGIC_1164.all;

--对CALC1_PAK的定义
package CALC1_PAK is

	--自定义记录类型。注意，其中的元素A_IN、B_IN……必须保持现在的顺序，因为后续的testbench中会按此顺序分别赋值
	type MY_RECORD is record
		--A_IN:长度4的逻辑矢量，第一个输入
		A_IN : std_logic_vector ( 3 downto 0 ); 
		
		--B_IN:长度4的逻辑矢量，第二个输入
		B_IN : std_logic_vector ( 3 downto 0 );
		
		--OP_CODE:长度4的逻辑矢量，操作码
		OP_CODE : std_logic_vector ( 3 downto 0 );
		
		--C_IN:设置为std_logic类型，第三格输入
		C_IN : std_logic;
		
		--EXP_OUT:长度4的逻辑矢量，输出
		EXP_OUT : std_logic_vector ( 3 downto 0 );
	end record MY_RECORD;
 
end package CALC1_PAK;

2.MEM.vhd

--IEEE库
library IEEE;

--使用该库下的STD_LOGIC_1164
use IEEE.STD_LOGIC_1164.all;

--使用该库下的STD_LOGIC_ARITH
use IEEE.STD_LOGIC_ARITH.ALL;

--使用该库下的STD_LOGIC_UNSIGNED
use IEEE.STD_LOGIC_UNSIGNED.ALL;

--使用自定义的包集合
use work.CALC1_PAK.ALL;

--创建MEM的entity
entity MEM is
    Port ( 
		--长度3，初始化为000
		ADDR : in  STD_LOGIC_VECTOR(2 downto 0):= "000";
		--CLK，EN端口设置为std_logic类型
		CLK,EN : in  STD_LOGIC;
		--输出，类型为MY_RECORD
		DATA_FRAME : out  MY_RECORD
	);
end MEM;

architecture RTL of MEM is
	--长度6的ROM数组，每个元素类型是MY_RECORD
	type ROM_ARRAY is array ( 0 to 5 ) of MY_RECORD;
	
	--存储器内部ROM_ARRAY数组的所有元素全部初始化为0
	constant MY_ROM : ROM_ARRAY :=       
	  ( 0 => ( A_IN => "0000", B_IN => "0000", OP_CODE => "0000", C_IN => '0', EXP_OUT => "0000" ),
	    1 => ( A_IN => "0001", B_IN => "0000", OP_CODE => "0000", C_IN => '0', EXP_OUT => "0000" ),
	    2 => ( A_IN => "0010", B_IN => "0000", OP_CODE => "0000", C_IN => '0', EXP_OUT => "0000" ),
	    3 => ( A_IN => "0011", B_IN => "0000", OP_CODE => "0000", C_IN => '0', EXP_OUT => "0000" ),
	    4 => ( A_IN => "0100", B_IN => "0000", OP_CODE => "0000", C_IN => '0', EXP_OUT => "0000" ),
	    5 => ( A_IN => "0101", B_IN => "0000", OP_CODE => "0000", C_IN => '0', EXP_OUT => "0000" ));
	
	begin									 	 
		    
	process ( CLK )
	    begin
	        --遇到上升沿触发
	        if rising_edge ( CLK) then
	            --EN使能端输入为1		 
	            if ( EN = '1') then
	                --强制转换为整型赋值给，对应数组的索引，将对应的A_IN,B_IN,OP_CODE,C_IN,EXP_OUT赋值给DATA_FRAME
	                DATA_FRAME <= MY_ROM(conv_integer(ADDR)) ;   
	            end if;
	        end if;
	end process ;	  
	  	
end RTL;

3.testbench.vhd

--IEEE库
library IEEE;

--使用该库下的STD_LOGIC_1164
use IEEE.STD_LOGIC_1164.all;

--使用自定义的包集合
use work.CALC1_PAK.ALL;   

 
ENTITY testbench IS
END testbench;
 
ARCHITECTURE behavior OF testbench IS 
 
    -- component：就是将Design Entity中的port内容写一遍
	COMPONENT MEM
	Port ( 
		--长度3
		ADDR : in  STD_LOGIC_VECTOR(2 downto 0);
		--CLK，EN端口设置为std_logic类型
		CLK,EN : in  STD_LOGIC;
		--输出到记录MY_RECORD中
		DATA_FRAME : out  MY_RECORD
	);
	END COMPONENT;
    

	--Inputs
	signal ADDR : std_logic_vector(2 downto 0) := (others => '0');
	signal CLK : std_logic := '0';
	signal EN : std_logic := '0';
	
	--Outputs
	signal DATA_FRAME : MY_RECORD;
	
	-- Clock period definitions
	constant CLK_period : time := 10 ns;
 
BEGIN
 
	-- Unit Under Test (UUT):将(Component)MEM的端口Port映射到信号signal上
	uut: MEM PORT MAP (
		ADDR => ADDR,
		CLK => CLK,
		EN => EN,
		DATA_FRAME => DATA_FRAME
	);
	
	-- Clock process definitions
	CLK_process :process
		begin
		CLK <= '0';
		wait for CLK_period/2;
		CLK <= '1';
		wait for CLK_period/2;
	end process;
	
	
	-- Stimulus process
	stim_proc: process
	begin		
		-- hold reset state for 100 ns.
		wait for 100 ns;	
		
		wait for CLK_period*10;
		
		-- insert stimulus here 
		EN <= '1';
		ADDR <= "000";
		wait for 100 ns;
		ADDR <= "001";
		wait for 100 ns;
		ADDR <= "010";
		wait for 100 ns;
		ADDR <= "011";
		wait for 100 ns;
		ADDR <= "100";
		wait for 100 ns;
		ADDR <= "101";
		wait;
	end process;

END;

二、比较器实验

1.COMP.vhd

--IEEE库
library IEEE;

--使用该库下的STD_LOGIC_1164
use IEEE.STD_LOGIC_1164.all;

--使用该库下的STD_LOGIC_ARITH
use IEEE.STD_LOGIC_ARITH.ALL;

--使用该库下的STD_LOGIC_UNSIGNED
use IEEE.STD_LOGIC_UNSIGNED.ALL;


--创建COMP的entity
entity COMP is
	Port ( 
		--CLK:设置为std_logic类型，时钟
		CLK: in std_logic;
		--EN：设置为std_logic类型，由FSM输出的使能信号
		EN: in std_logic;
		--EXPECTED：长度4的逻辑矢量，由ROM模块输出的数据，数据的期望值
		EXPECTED: in std_logic_vector(3 downto 0);
		--ALU_OUT：长度4的逻辑矢量，由ALU模块输出的数据，数据的实际值
		ALU_OUT: in std_logic_vector(3 downto 0);
		--RESULT：设置为std_logic类型，比较结果
		RESULT: out std_logic
	);
end COMP;


--创建COMP的architecture
architecture behavioral of COMP is
begin
	--过程
	process(CLK)
	begin
		--遇到上升沿触发
		if rising_edge(CLK) then
			--如果使能激发
			if (EN = '1') then
				--结果数据的期望值EXPECTED和数据的实际值EXPECTED比较相等
				if (EXPECTED = ALU_OUT )then
					--结果RESULT输出为1
					RESULT <= '1';
				else
					--不等时结果RESULT输出为1
					RESULT <= '0' ;
				end if;
	
				--当EXPECTED = ALU_OUT时，跳过；不等时跳过
				assert (EXPECTED = ALU_OUT )
					--输出信息
					report " Warning, simulation mismatch has occurred "
					--级别
					severity warning ;
			end if;
		end if ;
	end process;
end behavioral;

2.testbench.vhd

--IEEE库
library IEEE;

--使用该库下的STD_LOGIC_1164
use IEEE.STD_LOGIC_1164.all;

--使用该库下的STD_LOGIC_UNSIGNED
use IEEE.STD_LOGIC_UNSIGNED. all;

--使用该库下的NUMERIC_STD
use IEEE.NUMERIC_STD.all;

--创建testbench的entity
entity COMP_TB_VHD is
end COMP_TB_VHD;

--创建testbench的architecture
architecture BEHAVIOR of COMP_TB_VHD is
	component COMP
		Port ( 
			--CLK:设置为std_logic类型，时钟
			CLK: in std_logic;
			--EN：设置为std_logic类型，由FSM输出的使能信号
			EN: in std_logic;
			--EXPECTED：长度4的逻辑矢量，由ROM模块输出的数据，数据的期望值
			EXPECTED: in std_logic_vector(3 downto 0);
			--ALU_OUT：长度4的逻辑矢量，由ALU模块输出的数据，数据的实际值
			ALU_OUT: in std_logic_vector(3 downto 0);
			--RESULT：设置为std_logic类型，比较结果
			RESULT: out std_logic
		);
	end component;
	
	--信号signal初始化
	--初始化为0
	signal EXPECTED:STD_LOGIC_VECTOR(3 downto 0) := (others=>'0');
	--初始化为0
	signal ALU_OUT: STD_LOGIC_VECTOR(3 downto 0) := (others=>'0');
	--初始化为1，表示激活
	signal EN: STD_LOGIC := '1';
	--初始化为0
	signal CLK: STD_LOGIC := '0' ;
	signal RESULT: STD_LOGIC;
	

begin
	-- Unit Under Test (UUT):将Component的端口Port映射到信号signal上
	UUT: COMP port map(
		EXPECTED => EXPECTED,
		ALU_OUT => ALU_OUT,
		RESULT => RESULT,
		EN => EN,
		CLK => CLK);
	
	--每20ns翻转
	CLK <= not CLK after 20 ns;
	
	-- Stimulus process
	TB: process
	begin
		--数据期望设为X"A",即1010
		EXPECTED <= X"A" ;
		--数据实际值设为X"A",即1010
		ALU_OUT <= X"A" ;
		
		--等待200ns
		wait for 200 ns;
		--数据期望设为X"A",即1010
		EXPECTED <= X"A" ;
		--数据实际值设为X"B",即1011
		ALU_OUT <= X"B" ;
		
		--等待200ns
		wait for 200 ns;
		--数据期望设为X"1",即0001
		EXPECTED <= X"1" ;
		--数据实际值设为X"1",即0001
		ALU_OUT <= X"1" ;
		
		--等待200ns
		wait for 200 ns;
		--数据期望设为X"1",即0001
		EXPECTED <= X"1" ;
		--数据实际值设为X"2",即0010
		ALU_OUT <= X"2" ;
		wait;
	end process;
end;

三、算术逻辑单元实验

1.1.ALU.vhd

--IEEE库
library IEEE;

--使用该库下的STD_LOGIC_1164
use IEEE.STD_LOGIC_1164.all;

--使用该库下的STD_LOGIC_ARITH
use IEEE.STD_LOGIC_ARITH.ALL;

--使用该库下的STD_LOGIC_UNSIGNED
use IEEE.STD_LOGIC_UNSIGNED.ALL;

--创建ALU的entity
entity ALU is
	port(
		--CLK:设置为std_logic类型，时钟
		CLK:in std_logic ;
		--EN：设置为std_logic类型，由FSM输出的使能信号
		EN:in std_logic ; 
		--OP_CODE：长度4的逻辑矢量
		OP_CODE:in std_logic_vector ( 3 downto 0 ) ;
		--A：长度4的逻辑矢量
		A:in std_logic_vector ( 3 downto 0 ) ;
		--B：长度4的逻辑矢量
		B:in std_logic_vector ( 3 downto 0 ) ;
		--C：设置为std_logic类型
		C_IN:in std_logic ;
		--Y：长度4的逻辑矢量，输出结果
		Y:out std_logic_vector (3 downto 0) 
	);		
end entity ALU;

--创建ALU的architecture
architecture behavioral of ALU is

	--信号OP_CODE_CI是长度5的逻辑矢量
	signal OP_CODE_CI : std_logic_vector ( 4 downto 0 );
    

begin
	--信号OP_CODE_CI是OP_CODE和C_IN的拼凑
	OP_CODE_CI <= OP_CODE & C_IN ;
	
	--过程
	process ( CLK )
	begin
		--遇到上升沿触发
		if rising_edge ( CLK ) then
			--如果使能激发
			if (EN = '1') then
				--匹配OP_CODE_CI对应的情况
				case OP_CODE_CI is
					--对应功能：传输A
					when "00000" => Y <= A;
					--对应功能：递增A
					when "00001" => Y <= A + 1 ; 
					--对应功能：加和
					when "00010" => Y <= A + B ; 
					--对应功能：带进位的加和
					when "00011" => Y <= A + B + 1; 
					--对应功能：与补码相加
					when "00100" => Y <= A + not B ; 
					--对应功能：减
					when "00101" => Y <= A + not B + 1; 
					--对应功能：递减
					when "00110" => Y <= A - 1 ; 
					--对应功能：传输A
					when "00111" => Y <= A ;
					--对应功能：与
					when "01000" => Y <= A and B ;
					--对应功能：或
					when "01010" => Y <= A or B ;
					--对应功能：异或
					when "01100" => Y <= A xor B ;
					--对应功能：反码
					when "01110" => Y <= not A ;
					--对应功能：传输0
					when "10000" => Y <= (others => '0') ;
					--匹配不上的其他情况
					when others  => Y <= (others => 'X' );
				end case;
			end if;
		end if ;
	end process;
end architecture behavioral;

2.testbench.vhd

--IEEE库
library IEEE;

--使用该库下的STD_LOGIC_1164
USE ieee.std_logic_1164.ALL;
 
--创建testbench的entity
ENTITY ALU_TB_vhd IS
END ALU_TB_vhd;

--创建testbench的architecture
ARCHITECTURE test OF ALU_TB_vhd IS
	--component：就是将Design Entity中的port内容写一遍
	COMPONENT alu
		port(
			--CLK:设置为std_logic类型，时钟
			CLK:in std_logic ;
			--EN：设置为std_logic类型，由FSM输出的使能信号
			EN:in std_logic ; 
			--OP_CODE：长度4的逻辑矢量，操作码
			OP_CODE	:in std_logic_vector ( 3 downto 0 ) ;
			--A：长度4的逻辑矢量，数据A
			A:in std_logic_vector ( 3 downto 0 ) ;
			--B：长度4的逻辑矢量，数据B
			B:in std_logic_vector ( 3 downto 0 ) ;
			--C：设置为std_logic类型，carry_in借位输入
			C_IN:in std_logic ;
			--Y：长度4的逻辑矢量，输出结果
			Y:out std_logic_vector (3 downto 0) 
		);
	END COMPONENT;

	--信号signal初始化
	--操作码初始化为0
	SIGNAL OP_CODE_SIG :  std_logic_vector(3 downto 0):= (others => '0');
	--数据A初始化为0111
	SIGNAL A_SIG :  std_logic_vector(3 downto 0):= "0111" ;
	--数据B初始化为0011
	SIGNAL B_SIG :  std_logic_vector(3 downto 0):= "0011" ;
	--carry_in借位输入初始化为0
	SIGNAL C_IN_SIG :  std_logic := '0';
	--使能初始化为0
	SIGNAL EN_SIG : std_logic := '1';
	--时钟初始化为0
	SIGNAL CLK :  std_logic := '0' ;
	--输出结果声明
	SIGNAL Y_SIG :  std_logic_vector(3 downto 0);
	--信号OP_CODE_CI(OP_CODE和C_IN的拼凑)初始化为0
	SIGNAL OP_CODE_CI_SIG : std_logic_vector ( 4 downto 0 ) := (others => '0') ;

begin
	--OP_CODE_SIG取OP_CODE_CI_SIG的对应的前4个
	OP_CODE_SIG <= OP_CODE_CI_SIG(4 downto 1);
	--C_IN_SIG取OP_CODE_CI_SIG的对应的最后的一个
	C_IN_SIG <= OP_CODE_CI_SIG(0);

	-- Unit Under Test (UUT):将Component的端口Port映射到信号signal上
	uut: alu PORT MAP(
		OP_CODE => OP_CODE_SIG,
		A => A_SIG,
		B => B_SIG,
		C_IN => C_IN_SIG,
		Y => Y_SIG,
		EN => EN_SIG,
		CLK => CLK 
	);

	--每10ns翻转
	clk <= not clk after 10 ns; 

	process
	begin
		--对应功能：传输A
		OP_CODE_CI_SIG <= "00000";   wait for 100 ns;
		--对应功能：递增A
		OP_CODE_CI_SIG <= "00001";   wait for 100 ns;
		--对应功能：加和
		OP_CODE_CI_SIG <= "00010";   wait for 100 ns;
		--对应功能：带进位的加和
		OP_CODE_CI_SIG <= "00011";   wait for 100 ns;
		--对应功能：与补码相加
		OP_CODE_CI_SIG <= "00100";   wait for 100 ns;
		--对应功能：减
		OP_CODE_CI_SIG <= "00101";   wait for 100 ns;
		--对应功能：递减
		OP_CODE_CI_SIG <= "00110";   wait for 100 ns;
		--对应功能：传输A
		OP_CODE_CI_SIG <= "00111";   wait for 100 ns;
		--对应功能：与
		OP_CODE_CI_SIG <= "01000";   wait for 100 ns;
		--对应功能：或
		OP_CODE_CI_SIG <= "01010";   wait for 100 ns;
		--对应功能：异或
		OP_CODE_CI_SIG <= "01100";   wait for 100 ns;
		--对应功能：反码
		OP_CODE_CI_SIG <= "01110";   wait for 100 ns;
		--对应功能：传输0
		OP_CODE_CI_SIG <= "10000";   wait;
	end process; 
END architecture test;

N、模板

1.module.vhd

--IEEE库
library IEEE;

--使用该库下的STD_LOGIC_1164
use IEEE.STD_LOGIC_1164.all;

--使用该库下的STD_LOGIC_ARITH
use IEEE.STD_LOGIC_ARITH.ALL;

--使用该库下的STD_LOGIC_UNSIGNED
use IEEE.STD_LOGIC_UNSIGNED.ALL;

--使用自定义的包集合
use work.CALC1_PAK.ALL;

--创建ALU的entity
entity ALU is
	--端口设置
	port(
		--CLK:设置为std_logic类型，时钟
		CLK:in std_logic ;
		
		--EN：设置为std_logic类型，由FSM输出的使能信号
		EN:in std_logic ; 
		
		--OP_CODE：长度4的逻辑矢量，操作码
		OP_CODE:in std_logic_vector ( 3 downto 0 ) ;
		
		--A：长度4的逻辑矢量，第一个输入
		A:in std_logic_vector ( 3 downto 0 ) ;
		
		--B：长度4的逻辑矢量，第二个输入
		B:in std_logic_vector ( 3 downto 0 ) ;
		
		--C：设置为std_logic类型，第三个输入
		C_IN:in std_logic ;
		
		--Y：长度4的逻辑矢量，输出结果
		Y:out std_logic_vector (3 downto 0) 
	);		
end entity ALU;

--创建ALU的architecture
architecture behavioral of ALU is

	--信号OP_CODE_CI是长度5的逻辑矢量
	signal OP_CODE_CI : std_logic_vector ( 4 downto 0 );
    

begin
	--信号OP_CODE_CI是OP_CODE和C_IN的拼凑
	OP_CODE_CI <= OP_CODE & C_IN ;
	
	--过程
	process ( CLK )
	begin
		--遇到上升沿触发
		if rising_edge ( CLK ) then
			--如果使能激发
			if (EN = '1') then
				--匹配OP_CODE_CI对应的情况
				case OP_CODE_CI is
					--对应功能：传输A
					when "00000" => Y <= A;
					--对应功能：递增A
					when "00001" => Y <= A + 1 ; 
					--对应功能：加和
					when "00010" => Y <= A + B ; 
					--对应功能：带进位的加和
					when "00011" => Y <= A + B + 1; 
					--对应功能：与补码相加
					when "00100" => Y <= A + not B ; 
					--对应功能：减
					when "00101" => Y <= A + not B + 1; 
					--对应功能：递减
					when "00110" => Y <= A - 1 ; 
					--对应功能：传输A
					when "00111" => Y <= A ;
					--对应功能：与
					when "01000" => Y <= A and B ;
					--对应功能：或
					when "01010" => Y <= A or B ;
					--对应功能：异或
					when "01100" => Y <= A xor B ;
					--对应功能：反码
					when "01110" => Y <= not A ;
					--对应功能：传输0
					when "10000" => Y <= (others => '0') ;
					--匹配不上的其他情况
					when others  => Y <= (others => 'X' );
				end case;
			end if;
		end if ;
	end process;
end architecture behavioral;

2.testbench.vhd

--IEEE库
library IEEE;

--使用该库下的STD_LOGIC_1164
USE ieee.std_logic_1164.ALL;
 
--创建testbench的entity
ENTITY ALU_TB_vhd IS
END ALU_TB_vhd;

--创建testbench的architecture
ARCHITECTURE test OF ALU_TB_vhd IS
	--component：就是将Design Entity中的port内容写一遍
	COMPONENT alu
		port(
		);
	END COMPONENT;

	--信号signal初始化
	--操作码初始化为0
	SIGNAL OP_CODE_SIG :  std_logic_vector(3 downto 0):= (others => '0');
	--数据A初始化为0111
	SIGNAL A_SIG :  std_logic_vector(3 downto 0):= "0111" ;
	--数据B初始化为0011
	SIGNAL B_SIG :  std_logic_vector(3 downto 0):= "0011" ;
	--carry_in借位输入初始化为0
	SIGNAL C_IN_SIG :  std_logic := '0';
	--使能初始化为0
	SIGNAL EN_SIG : std_logic := '1';
	--时钟初始化为0
	SIGNAL CLK :  std_logic := '0' ;
	--输出结果声明
	SIGNAL Y_SIG :  std_logic_vector(3 downto 0);
	--信号OP_CODE_CI(OP_CODE和C_IN的拼凑)初始化为0
	SIGNAL OP_CODE_CI_SIG : std_logic_vector ( 4 downto 0 ) := (others => '0') ;

begin
	--OP_CODE_SIG取OP_CODE_CI_SIG的对应的前4个
	OP_CODE_SIG <= OP_CODE_CI_SIG(4 downto 1);
	--C_IN_SIG取OP_CODE_CI_SIG的对应的最后的一个
	C_IN_SIG <= OP_CODE_CI_SIG(0);

	-- Unit Under Test (UUT):将Component的端口Port映射到信号signal上
	uut: alu PORT MAP(
	);

	--每10ns翻转
	clk <= not clk after 10 ns; 

	process
	begin
		--对应功能：传输A
		OP_CODE_CI_SIG <= "00000";   wait for 100 ns;
		--对应功能：递增A
		OP_CODE_CI_SIG <= "00001";   wait for 100 ns;
		--对应功能：加和
		OP_CODE_CI_SIG <= "00010";   wait for 100 ns;
		--对应功能：带进位的加和
		OP_CODE_CI_SIG <= "00011";   wait for 100 ns;
		--对应功能：与补码相加
		OP_CODE_CI_SIG <= "00100";   wait for 100 ns;
		--对应功能：减
		OP_CODE_CI_SIG <= "00101";   wait for 100 ns;
		--对应功能：递减
		OP_CODE_CI_SIG <= "00110";   wait for 100 ns;
		--对应功能：传输A
		OP_CODE_CI_SIG <= "00111";   wait for 100 ns;
		--对应功能：与
		OP_CODE_CI_SIG <= "01000";   wait for 100 ns;
		--对应功能：或
		OP_CODE_CI_SIG <= "01010";   wait for 100 ns;
		--对应功能：异或
		OP_CODE_CI_SIG <= "01100";   wait for 100 ns;
		--对应功能：反码
		OP_CODE_CI_SIG <= "01110";   wait for 100 ns;
		--对应功能：传输0
		OP_CODE_CI_SIG <= "10000";   wait;
	end process; 
END architecture test;