Está en la página 1de 10

INSTITUTO TECNOLÓGICO DE NOGALES

Practicas:
-Diseño de una ALU de 1 bit con acarreo.
-Programación del comportamiento de una ALU de 4
bits.

Nombre del Alumno | No. De control:


Graciano Plata Ángel Regino | 12340151
Jaramillo Álvarez Omar Sarid | 10340186

Ingeniería en Electrónica
Materia: Diseño digital con VHDL
Profesora: Ing. Silvia Karina Reyes Lio
H. Nogales, Sonora

Contenido
INTRODUCCIÓN.......................................................................................................3
Signed vs. Unsigned en VHDL.............................................................................3
PROCEDIMIENTO.....................................................................................................4
CONCLUSIÓN.........................................................................................................10
BIBLIOGRAFIA........................................................................................................10

6
INTRODUCCIÓN
En computación, la unidad aritmética lógica, también conocida como ALU
(siglas en inglés de arithmetic logic unit), es un circuito digital que calcula
operaciones aritméticas (como suma, resta, multiplicación, etc.) y operaciones
lógicas (And, Or, Not), entre dos números.

Muchos tipos de circuitos electrónicos necesitan realizar algún tipo de


operación aritmética, así que incluso el circuito dentro de un reloj digital tendrá una
ALU minúscula que se mantiene sumando 1 al tiempo actual, y se mantiene
comprobando si debe activar el sonido de la alarma, etc.

Por mucho, los más complejos circuitos electrónicos son los que están
construidos dentro de los chips de microprocesadores modernos. Por lo tanto,
estos procesadores tienen dentro de ellos un ALU muy complejo y potente. De
hecho, un microprocesador moderno (y los mainframes) puede tener múltiples
núcleos, cada núcleo con múltiples unidades de ejecución, cada una de ellas con
múltiples ALU.

Muchos otros circuitos pueden contener en el interior una unidad aritmética


lógica: unidades de procesamiento gráfico como las que están en las GPU
modernas, FPU como el viejo coprocesador matemático 80387, y procesadores
digitales de señales como los que se encuentran en tarjetas de sonido, lectoras de
CD y los televisores de alta definición. Todos éstos tienen en su interior varias
ALU potentes y complejas.

Signed vs. Unsigned en VHDL

Todos los diseñadores digitales deben entender cómo funciona la


matemática dentro de un FPGA o ASIC. El primer paso para ello es entender
como las señales “signed” o “unsigned” funcionan. Los tipos de señales Signed y
Unsigned existen en el paquete numeric_std, el cual es parte de la librería ieee.
Debemos notar que hay otro archivo de paquete que es usado frecuentemente
para efectuar operaciones aritméticas: std_logic_arith. Como sea, std_logic_arith
no es un paquete oficialmente respaldado por ieee y no está recomendado su uso
en diseños digitales.

Una señal que está definida como tipo Signed, significa que las
herramientas interpretan esta señal como que podrá ser positiva o negativa. Una
señal definida como Unsigned significa que será solo positiva. Internamente, el
FPGA utilizará representación complemento a 2. Por ejemplo, una señal de 3 bits
puede ser interpretada de acuerdo a la tabla siguiente:

6
Bits      Unsigned Value Signed Value
011 3 3
010 2 2
001 1 1
000 0 0
111 7 -1
110 6 -2
101 5 -3
100 4 -4

PROCEDIMIENTO

1.- Programar mediante VHDL el comportamiento de una ALU de 4 bits que


efectúe las siguientes operaciones:
Select: 000 , A+B
Select: 001 , A-B
Select: 010 , A+1
Select: 011 , A-1
Select: 100 , A and B
Select: 101 , A or B
Select: 110 , Not (A)
Select: 111 , A xor B

Código:

library IEEE;
use IEEE.STD_LOGIC_1164.ALL;
use IEEE.NUMERIC_STD.ALL;

entity program is

6
port
(
A, B : in std_logic_vector(3 downto 0);
selec : in std_logic_vector(2 downto 0);

Carry_Out : out std_logic;


Flag : out std_logic; --Para números negativos
S : out std_logic_vector(3 downto 0)
);
end entity program;

architecture Behavioral of program is

signal Temp: std_logic_vector(4 downto 0);

begin

process(A, B, selec, temp) is


begin
Flag <= '0';
case selec is
when "000" => --S = A + B, carry = overflow
Temp <= std_logic_vector((unsigned("0" & A) + unsigned(B)));
--El vector completo
S <= temp(3 downto 0); --Los primeros 4 bits del vector
Carry_Out <= temp(4); --El bit más significativo
Flag <= '-';
when "001" => -- S = |A - B|, flag = 1 si B > A
if (A >= B) then

6
S <= std_logic_vector(unsigned(A) - unsigned(B));
Flag <= '0';
else
S <= std_logic_vector(unsigned(B) - unsigned(A));
Flag <= '1';
end if;
Carry_Out <= '0';
Temp <= "-----";
when "010" =>
Temp <= std_logic_vector((unsigned("0" & A) + 1));
S <= temp(3 downto 0);
Carry_Out <= temp(4);
Flag <= '-';

when "011" =>


if (A = "0000") then
S <= std_logic_vector(unsigned(A) + 1);
Flag <= '1';
else
S <= std_logic_vector(unsigned(A) - 1);
Flag <= '0';
end if;
Carry_Out <= '0';
Temp <= "-----";

when "100" =>


S <= A and B;
Temp <= "-----";
Flag <= '-';
Carry_Out <= '-';

6
when "101" =>
S <= A or B;
Temp <= "-----";
Flag <= '-';
Carry_Out <= '-';
when "110" =>
S <= not A;
Temp <= "-----";
Flag <= '-';
Carry_Out <= '-';
when others =>
S <= A xor B;
Temp <= "-----";
Flag <= '-';
Carry_Out <= '-';
end case;
end process;

end architecture Behavioral;

6
Simulación:

2.- Diseñe el circuito para una ALU de 1 bit que efectúe las mismas operaciones y
en el mismo orden que el ejercicio anterior (procedimientos hechos en clase).

6
Circuito con IC’s

6
CONCLUSIÓN
Se llega a la conclusión de que con el lenguaje VHDL es mucho más fácil
crear circuitos digitales, además de que se ahorra espacio, de otro modo se
tendrían que usar muchas compuertas, es un gran ahorro de tiempo, recursos y
esfuerzo.

BIBLIOGRAFIA
http://www.nandland.com/vhdl/examples/example-signed-unsigned.html