ALU 16 bit TTL 74....

[kroszkanorber]

Witam. 

ALU 16 bitowa złożona z czterech układów 74181 i 74182. Układ 74181 jest jednostką arytmetyczno logiczną przetwarzającą dane o szerokości 4 bity. Układ 74182 jest używany do przyspieszenia przeniesień w operacji dodawania.

Alu można rozszerzyć do 64 bit przez połączenie 4  komponentów 16 bit z układem 74182.

Układy zaimplementowałem w edytorze i połączyłem komponenty.

Schemat 74181 :

Schemat 74182:

Połączone komponenty:

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

entity ALU16bit is
    Port ( M : in  STD_LOGIC;
           Cn : in  STD_LOGIC;
           S : in  STD_LOGIC_VECTOR (3 downto 0);
           A : in  STD_LOGIC_VECTOR (15 downto 0);
           B : in  STD_LOGIC_VECTOR (15 downto 0);
           AeB : out  STD_LOGIC;
           C : out  STD_LOGIC;
           G : out  STD_LOGIC;
           P : out  STD_LOGIC;
           Y : out  STD_LOGIC_VECTOR (15 downto 0)
			  );
end ALU16bit;

architecture Behavioral of ALU16bit is

   COMPONENT TTL74181
   PORT( Cn	:	IN	STD_LOGIC; 
          M	:	IN	STD_LOGIC; 
          G	:	OUT	STD_LOGIC; 
          P	:	OUT	STD_LOGIC; 
          Cn4	:	OUT	STD_LOGIC; 
          AeB	:	OUT	STD_LOGIC; 
          Y	:	OUT	STD_LOGIC_VECTOR (3 DOWNTO 0); 
          S	:	IN	STD_LOGIC_VECTOR (3 DOWNTO 0); 
          B	:	IN	STD_LOGIC_VECTOR (3 DOWNTO 0); 
          A	:	IN	STD_LOGIC_VECTOR (3 DOWNTO 0));
   END COMPONENT;

   COMPONENT TTL74182
   PORT( G0	:	IN	STD_LOGIC; 
          P0	:	IN	STD_LOGIC; 
          P1	:	IN	STD_LOGIC; 
          P2	:	IN	STD_LOGIC; 
          P3	:	IN	STD_LOGIC; 
          G3	:	IN	STD_LOGIC; 
          G2	:	IN	STD_LOGIC; 
          G1	:	IN	STD_LOGIC; 
          Cn	:	IN	STD_LOGIC; 
          CnX	:	OUT	STD_LOGIC; 
          CnY	:	OUT	STD_LOGIC; 
          CnZ	:	OUT	STD_LOGIC; 
          G	:	OUT	STD_LOGIC; 
          P	:	OUT	STD_LOGIC);
   END COMPONENT;
	
	signal CnX : std_logic;
	signal CnY : std_logic;
	signal CnZ : std_logic;
	signal G0 : std_logic;
	signal P0 : std_logic;
	signal G1 : std_logic;
	signal P1 : std_logic;
	signal G2 : std_logic;
	signal P2 : std_logic;
	signal G3 : std_logic;
	signal P3 : std_logic;
	signal AeB0 : std_logic;
	signal AeB1 : std_logic;
	signal AeB2 : std_logic;
	signal AeB3 : std_logic;

begin
	
	AeB <= AeB0 and AeB1 and AeB2 and AeB3;

   UUT0: TTL74181 PORT MAP(
		Cn => Cn, 
		M => M, 
		G => G0, 
		P => P0, 
		Cn4 => open, 
		AeB => AeB0, 
		Y => Y(3 downto 0), 
		S => S, 
		B => B(3 downto 0), 
		A => A(3 downto 0)
   );

   UUT1: TTL74181 PORT MAP(
		Cn => CnX, 
		M => M, 
		G => G1, 
		P => P1, 
		Cn4 => open, 
		AeB => AeB1, 
		Y => Y(7 downto 4), 
		S => S, 
		B => B(7 downto 4), 
		A => A(7 downto 4)
   );

   UUT2: TTL74181 PORT MAP(
		Cn => CnY, 
		M => M, 
		G => G2, 
		P => P2, 
		Cn4 => open, 
		AeB => AeB2, 
		Y => Y(11 downto 8), 
		S => S, 
		B => B(11 downto 8), 
		A => A(11 downto 8)
   );

   UUT3: TTL74181 PORT MAP(
		Cn => CnZ, 
		M => M, 
		G => G3, 
		P => P3, 
		Cn4 => C, 
		AeB => AeB3, 
		Y => Y(15 downto 12), 
		S => S, 
		B => B(15 downto 12), 
		A => A(15 downto 12)
   );

   UUT: TTL74182 PORT MAP(
		G0 => G0, 
		P0 => P0, 
		P1 => P1, 
		P2 => P2, 
		P3 => P3, 
		G3 => G3, 
		G2 => G2, 
		G1 => G1, 
		Cn => Cn, 
		CnX => CnX, 
		CnY => CnY, 
		CnZ => CnZ, 
		G => G, 
		P => P
   );


end Behavioral;

 

Symulacja układu TB:

--    FUNKCJA        M = 1                         M = 0

--  S3 S2 S1 S0                         Cn = 1                     Cn = 0

--  0  0  0  0     F = -(A)         F = A                      F = A plus 1
--  0  0  0  1     F = -(AorB)      F = A + B                  F = (A + B) plus 1
--  0  0  1  0     F = -(A)andB     F = A + -(B)               F = (A + -(B)) plus 1
--  0  0  1  1     F = 0            F = -1 [U2]                F = 0
--  0  1  0  0     F = -(AandB)     F = A plus A*-(B)          F = A plus A * -(B) plus 1
--  0  1  0  1     F = -(B)         F = (A+B) plus A*-(B)      F = (A + B) plus A * -(B) plus 1
--  0  1  1  0     F = AxorB        F = A minus B mius 1       F = A minus B
--  0  1  1  1     F = Aand-(B)     F = A * -(B) minus 1       F = A * -(B)
--  1  0  0  0     F = -(A)orB      F = A plus A*B             F = A plus A*B plus 1
--  1  0  0  1     F = -(AxorB)     F = A plus B               F = A plus B plus 1
--  1  0  1  0     F = B            F = (A + -(B)) plus A*B    F = (A + -(B)) plus A*B plus 1
--  1  0  1  1     F = AandB        F = A*B minus 1            F = A*B
--  1  1  0  0     F = 1            F = A plus A               F = A plus A plus 1
--  1  1  0  1     F = Aor-(B)      F = (A + B) plus A         F = (A + B) plus A plus 1
--  1  1  1  0     F = AorB         F = (A + -(B)) plus A      F = (A + -(B)) plus A plus 1
--  1  1  1  1     F = A            F = A minus 1              F = A
--------------------------------------------------------------------------------
LIBRARY ieee;
USE ieee.std_logic_1164.ALL;
 
ENTITY ALU16bit_tb IS
END ALU16bit_tb;
 
ARCHITECTURE behavior OF ALU16bit_tb IS 
 
    -- Component Declaration for the Unit Under Test (UUT)
 
    COMPONENT ALU16bit
    PORT(
         M : IN  std_logic;
         Cn : IN  std_logic;
         S : IN  std_logic_vector(3 downto 0);
         A : IN  std_logic_vector(15 downto 0);
         B : IN  std_logic_vector(15 downto 0);
         AeB : OUT  std_logic;
         C : OUT  std_logic;
         G : OUT  std_logic;
         P : OUT  std_logic;
         Y : OUT  std_logic_vector(15 downto 0)
        );
    END COMPONENT;
    

   --Inputs
   signal M : std_logic;
   signal Cn : std_logic;
   signal S : std_logic_vector(3 downto 0);
   signal A : std_logic_vector(15 downto 0);
   signal B : std_logic_vector(15 downto 0);

 	--Outputs
   signal AeB : std_logic;
   signal C : std_logic;
   signal G : std_logic;
   signal P : std_logic;
   signal Y : std_logic_vector(15 downto 0);
   -- No clocks detected in port list. Replace <clock> below with 
   -- appropriate port name 
 
BEGIN
 
	-- Instantiate the Unit Under Test (UUT)
   uut: ALU16bit PORT MAP (
          M => M,
          Cn => Cn,
          S => S,
          A => A,
          B => B,
          AeB => AeB,
          C => C,
          G => G,
          P => P,
          Y => Y
        );

 

   -- Stimulus process
   stim_proc: process
   begin		
      M <= '1';
		Cn <= '0';
		S <= "0110"; -- xor
		A <= "1111101001010000";
		B <= "1111101001011010";
      wait for 10 ns;	
      M <= '1';
		Cn <= '0';
		S <= "1011"; -- and
		A <= "1111101001010000";
		B <= "1111101001011010";
      wait for 10 ns;	
      M <= '1';
		Cn <= '0';
		S <= "1110"; -- or
		A <= "1111101001010000";
		B <= "1111101001011010";
      wait for 10 ns;
      M <= '0';
		Cn <= '1';
		S <= "1001"; -- A plus B
		A <= "1111101001010000";
		B <= "0000000000001111";
      wait for 10 ns;
      M <= '0';
		Cn <= '0';
		S <= "0110"; -- A plus B
		A <= "1111101001010000";
		B <= "0000000000001111";

      wait;
   end process;

END;

Wynik symulacji:

[ReniferRudolf]

@kroszkanorber Z jakiego narzędzia korzystałeś do przeprowadzenia symulacji?

[kroszkanorber]

@ReniferRudolf Hej

Xilinx Ise 14.7

W otwartym programie jest po lewej stronie okienko implementation i obok symulation

Zaznaczasz symulation:

otwierasz New Source Wizard i zaznaczasz VHDL Test bench, a w File Name: wpisujesz swoją nazwę  i klikasz dalej:

Wyskoczy nowe okno:

Wpisujesz na linie wejściowe sygnały używając zegara lub interwałów czasowych lub bez jak uważasz...

Następnie klikasz dwukrotnie na Behavioral check syntax i czekasz aż skończy( jak będą błędy to musisz poprawić i jeszcze raz powtórzyć).

Jak będzie na zielono to klikasz simulate behavioral model i czekasz aż otworzy się nowe okno w którym będą zobrazowane przebiegi sygnałów w zadanym czasie zgodne z tym co podałeś, razem z sygnałami wyjściowymi.

Pozdrawiam