PREINFORME N4

IMPLEMENTACIN DE ALU EN FPGA

1.- OBJETIVOS

Aplicar los conocimientos adquiridos para disear, comprender y operar un ALU en FPGA
Disear los mdulos que complementan a la ALU
Disear mdulos opcionales de funciones de un microprocesador.

2.- DISEO DEL PROGRAMA DE LA ALU IMPLEMENTADA EN LABORATORIO

Para el diseo de la ALU implementado en la FPGA usaremos el diagrama que se tena en el

laboratorio 1

AND
MUX
OR
4x1
XOR 8bits

UBC

De acuerdo con lo anterior mostrado se puede observar que el cdigo podemos dividirlo en 5
partes y crearnos componentes para asi llamarlos en un cdigo TOP-LEVEL integrando de esta
manera la entidad de la ALU

Analizaremos el comportamiento de cada bloque para crear un componente de cada una de ellas.
Modulo lgico AND (mod_and)

A_and (8 bits)

B_and (8 bits)
AND R_and (8 bits)

Como podemos observar requerimos de 2 variables de entrada y una de salida, todas sern
vectores de 8 bits.

library ieee;
use ieee.std_logic_1164.all;
entity mod_and is port(
A_and:in std_logic_vector (7 downto 0);
B_and:in std_logic_vector (7 downto 0);
R_and:out std_logic_vector (7 downto 0));
end mod_and;
architecture arq_mod_and of mod_and is
begin
R_and <= A_and and B_and;
end arq_mod_and;

Modulo lgico OR (mod_or)

A_or (8 bits)

B_or (8 bits)
OR R_or (8 bits)

Como podemos observar requerimos de 2 variables de entrada y una de salida, todas sern
vectores de 8 bits.

library ieee;
use ieee.std_logic_1164.all;
entity mod_or is port(
A_or:in std_logic_vector (7 downto 0);
B_or:in std_logic_vector (7 downto 0);
R_or:out std_logic_vector (7 downto 0));
end mod_or;
architecture arq_mod_or of mod_or is
begin
R_or <= A_or or B_or;
end arq_mod_or;
Modulo lgico XOR (mod_or)

A_xor (8 bits)

B_xor (8 bits)
XOR R_xor (8 bits)

Como podemos observar requerimos de 2 variables de entrada y una de salida, todas sern
vectores de 8 bits.

library ieee;
use ieee.std_logic_1164.all;
entity mod_xor is port(
A_xor:in std_logic_vector (7 downto 0);--entrada
B_xor:in std_logic_vector (7 downto 0);--entrada
R_xor:out std_logic_vector (7 downto 0));--salida
end mod_xor;
architecture arq_mod_xor of mod_xor is
begin
R_xor <= A_xor xor B_xor;-- xor de las dos variables
end arq_mod_xor;

Modulo lgico UBC (ubc)

A_ubc(8 bits) Cout(1 bit)

B_ubc (8 bits)
UBC R_ubc (8 bits)

CX1 CY1 CX2 CY2 CE

La ubc adems de tener la entrada de 8 bits de cada variable de entrada cuenta con variables de
control para generar las funciones con que cuenta el ALU estas son CX1 CY1 CX2 CY2 y CE en
nuestra entidad se vern reflejados estas variables y debemos reslizar el cdigo en dos partes la
del sumador y la de control (de paso y de inversin).

Las funciones de paso y de inversion ya se haban visto en el laboratorio 1 estas se hacen bit a bit
de cada variable con el respectivo bit de control por ejemplo para A_ubc(0) se tendra que
almacenar en una variable diferente el resultado

X0 <= (A_ubc(0) AND CX1) XOR CX2

A esta le llamaremos X(0) y esta ser la que entrara al sumador de 8 bits.

Para la suma de 8 bits lo realizaremos de acuerdo a un sumador bsico con acarreo inicial esta
funcin representara al sumador bsico de 1 bit el cual se implementara hasta terminar con los 8
bits que se deben sumar; notese que para el control de paso e inversion la salida ser X(i )para los
datos de A_ubc(i) y ser y(i) para los datos de B_ubc(i).
R_ubc(0) <= X0 XOR Y0 XOR CE
C0 <= (X0 AND Y0)OR((X0 XOR Y0)AND CE);

Entonces el cdigo en vhdl quedara como:

LIBRARY IEEE;
USE IEEE.STD_LOGIC_1164.ALL;
ENTITY ubc IS
PORT(
A_ubc:IN STD_LOGIC_VECTOR (7 DOWNTO 0);
B_ubc:IN STD_LOGIC_vector (7 DOWNTO 0);
CX1,CY1,CX2,CY2,CE:IN STD_LOGIC;
COUT: OUT STD_LOGIC;
R_ubc:OUT STD_LOGIC_vector (7 DOWNTO 0));
END ubc;
ARCHITECTURE arq_ubc OF ubc IS
SIGNAL X0,X1,X2,X3,X4,X5,X6,X7: STD_LOGIC;
SIGNAL Y0,Y1,Y2,Y3,Y4,Y5,Y6,Y7: STD_LOGIC;
SIGNAL C0,C1,C2,C3,C4,C5,C6,C7: STD_LOGIC;
BEGIN
-- CONTROL DE PASO Y CONTROL DE INVERSION
X0 <= (A_ubc(0) AND CX1) XOR CX2; X1 <= (A_ubc(1) AND CX1) XOR CX2;
X2 <= (A_ubc(2) AND CX1) XOR CX2; X3 <= (A_ubc(3) AND CX1) XOR CX2;
X4 <= (A_ubc(4) AND CX1) XOR CX2; X5 <= (A_ubc(5) AND CX1) XOR CX2;
X6 <= (A_ubc(6) AND CX1) XOR CX2; X7 <= (A_ubc(7) AND CX1) XOR CX2;
Y0 <= (B_ubc(0) AND CY1) XOR CY2; Y1 <= (B_ubc(1) AND CY1) XOR CY2;
Y2 <= (B_ubc(2) AND CY1) XOR CY2; Y3 <= (B_ubc(3) AND CY1) XOR CY2;
Y4 <= (B_ubc(4) AND CY1) XOR CY2; Y5 <= (B_ubc(5) AND CY1) XOR CY2;
Y6 <= (B_ubc(6) AND CY1) XOR CY2; Y7 <= (B_ubc(7) AND CY1) XOR CY2;
-- SUMADOR Y CARRY
R_ubc(0) <= X0 XOR Y0 XOR CE; C0 <= (X0 AND Y0)OR((X0 XOR Y0)AND CE);
R_ubc(1) <= X1 XOR Y1 XOR C0; C1 <= (X1 AND Y1)OR((X1 XOR Y1)AND C0);
R_ubc(2) <= X2 XOR Y2 XOR C1; C2 <= (X3 AND Y2)OR((X2 XOR Y2)AND C1);
R_ubc(3) <= X3 XOR Y3 XOR C2; C3 <= (X3 AND Y3)OR((X3 XOR Y3)AND C2);
R_ubc(4) <= X4 XOR Y4 XOR C3; C4 <= (X4 AND Y4)OR((X4 XOR Y4)AND C3);
R_ubc(5) <= X5 XOR Y5 XOR C4; C5 <= (X5 AND Y5)OR((X5 XOR Y5)AND C4);
R_ubc(6) <= X6 XOR Y6 XOR C5; C6 <= (X6 AND Y6)OR((X6 XOR Y6)AND C5);
R_ubc(7) <= X7 XOR Y7 XOR C6;

COUT <=(X7 AND Y7)OR((X7 XOR Y7)AND C6);

END arq_ubc;
Modulo lgico MUX (mod_or)

E_1mux (8 bits)

MUX R_mux (8 bits)

E_2mux (8 bits)

E_3mux (8 bits)
4x1
E_4mux (8 bits)
8bits

a b

En el mux deben ingresar todas las seales que tengamos de los otros componentes creados
(modulo and, or, xor y del ubc). En nuestra entidad por el momento colocaremos solo E_imux para
las 4 entradas y la salida nica de R_mux. Que deber mostrarse en el final del ALU.
library ieee;
use ieee.std_logic_1164.all;
entity mod_mux is port(
E_1mux:in std_logic_vector (7 downto 0);
E_2mux:in std_logic_vector (7 downto 0);
E_3mux:in std_logic_vector (7 downto 0);
E_4mux:in std_logic_vector (7 downto 0);
a: in std_logic;
b: in std_logic;
R_mux:out std_logic_vector (7 downto 0));
end mod_mux;
architecture arq_mod_mux of mod_mux is
signal G: std_logic_vector (1 downto 0);
begin
G(0)<=a;
G(1)<=b;
with G select
R_mux <= E_1mux when "00",
E_2mux when "01",
E_3mux when "10",
E_4mux when others;
end arq_mod_mux;
 Entonces la ALU integrada quedara siendo:

A (8 bits) AND
MUX R (8 bits)
OR
4x1
B (8 bits)
XOR 8bits
C (1bit)
UBC

S4 S3 S2 S1 S0 S6 S5
Cdigo del alu integrado

library ieee;
use ieee.std_logic_1164.all;
ENTITY alu IS
PORT(
A: IN STD_LOGIC_VECTOR (7 DOWNTO 0);
B: IN STD_LOGIC_VECTOR (7 DOWNTO 0);
S0,S1,S2,S3,S4,S5,S6: IN STD_LOGIC;
R: OUT STD_LOGIC_VECTOR (7 DOWNTO 0);
C: OUT STD_LOGIC);
END alu;
ARCHITECTURE estructura OF alu IS

-- COMPONENTE DEL MODULO AND

COMPONENT mod_and port(
A_and:in std_logic_vector (7 downto 0);
B_and:in std_logic_vector (7 downto 0);
R_and:out std_logic_vector (7 downto 0));
end COMPONENT;
-- COMPONENTE DEL MODULO OR
COMPONENT mod_or port(
A_or:in std_logic_vector (7 downto 0);
B_or:in std_logic_vector (7 downto 0);
R_or:out std_logic_vector (7 downto 0));
end COMPONENT;
-- COMPONENTE DEL MODULO XOR
COMPONENT mod_xor port(
A_xor:in std_logic_vector (7 downto 0);
B_xor:in std_logic_vector (7 downto 0);
R_xor:out std_logic_vector (7 downto 0));
end COMPONENT;
-- COMPONENTE DEL MODULO UBC
COMPONENT ubc PORT(
A_ubc:IN STD_LOGIC_VECTOR (7 DOWNTO 0);
B_ubc:IN STD_LOGIC_vector (7 DOWNTO 0);
CX1,CY1,CX2,CY2,CE:IN STD_LOGIC;
COUT: OUT STD_LOGIC;
R_ubc:OUT STD_LOGIC_vector (7 DOWNTO 0));
END component;
-- COMPONENTES DEL MUX 4X1 8 BITS
COMPONENT mod_mux port(
E_1mux:in std_logic_vector (7 downto 0);
E_2mux:in std_logic_vector (7 downto 0);
E_3mux:in std_logic_vector (7 downto 0);
E_4mux:in std_logic_vector (7 downto 0);
a: in std_logic;
b: in std_logic;
R_mux:out std_logic_vector (7 downto 0));
end COMPONENT;
-- UNION DE LOS MODULOS
SIGNAL T: std_logic_vector(7 downto 0);
SIGNAL V: std_logic_vector(7 downto 0);
SIGNAL W: std_logic_vector(7 downto 0);
SIGNAL H: std_logic_vector(7 downto 0);
BEGIN

u1: mod_and port map(A,B,T);

u2: mod_or port map(A,B,V);
u3: mod_xor port map(A,B,W);
u4: ubc port map(A,B,S4,S3,S2,S1,S0,C,H);
u5: mod_mux port map(T,V,W,H,S6,S5,R);

END estructura;
3.- Disee instrucciones de salto con banderas C,Z,V, y N.

Para este diseo es necesario tener las banderas calculadas en nuestro circuito o cdigo entonces
se diseara tomando en cuenta esta consideracin tomando como un bloque aparte las banderas
de nuestro circuito suponemos que C,Z,V y N ya estn calculadas.
Analizando las banderas el circuito debe ser capaz de entregarnos un argumento que nos lleve a
otra direccin de memoria para realizar una operacin determinada, siguiendo esta lgica
tenemos como entrada las Banderas C,Z,V y N y como salida el puntero que nos llevara a otra
direccin de memoria a este le llamaremos PS (puntero de salto) el esquema del bloque ser:

C
PS (8 bits)
Z

V
HTL
C,Z,V y N load(1bit)
N

El puntero de salto debe ser conectado a un contador que tenga carga en paralelo de esta manera
se direccionara a otra direccin de memoria para realizar la operacin del salto

Los saltos pueden realizarse de dos maneras:

1. Utilizando 4 registros que se habiliten de acuerdo a las necesidades del salto para cada
bandera habilitando un buffer de alta impedancia para cada registro de las banderas.

2. Utilizando una memoria que nos entregue las direcciones a las que se debe saltar si una
bandera esta activa y un registro que transfiera esta informacin cuando tengamos una
bandera activa. Como tenemos 4 variables podemos realizar saltos diferentes aplicando
dos condiciones unidas a la vez lo que nos da un mayor desarrollo de saltos con facilidad y
menor consumo de energa ya que podemos realizarlo con dos integrados; no obstante
perdemos las siguientes direcciones de la memoria y la hacemos intil desperdiciando el
espacio disponible de esta. Adems para este diseo podramos obtener los datos de salto
pregrabado en la memoria de salto las direcciones a las que se quiera saltar.

En cdigo VHDL para aplicarlo en FPGA sera ms fcil tener una memoria de salto para poder
direccionar directamente la direccin de la memoria que corresponde a la condicin. Adems que
el desarrollo del cdigo sera mucho ms rpido
En cdigo se veria lo siguiente:
LIBRARY IEEE;
USE IEEE.STD_LOGIC_1164.ALL;
ENTITY salto_banderas IS
PORT(
PS: OUT STD_LOGIC_VECTOR (7 DOWNTO 0);
LOAD: IN STD_LOGIC;
DIR_SALTO_C:IN STD_LOGIC_VECTOR(7 DOWNTO 0); -- se debe grabar previamente
DIR_SALTO_Z:IN STD_LOGIC_VECTOR(7 DOWNTO 0); -- estas direcciones de salto
DIR_SALTO_V:IN STD_LOGIC_VECTOR(7 DOWNTO 0); -- para las banderas que tengamos
DIR_SALTO_N:IN STD_LOGIC_VECTOR(7 DOWNTO 0); -- en una memoria o si se conoce el
C: IN STD_LOGIC; -- programa podemos apuntar y
Z: IN STD_LOGIC; -- copiar directamente en el codigo **
V: IN STD_LOGIC;
N: IN STD_LOGIC);
END salto_banderas;

ARCHITECTURE arq_salto_banderas OF salto_banderas IS

SIGNAL M:STD_LOGIC_VECTOR(3 DOWNTO 0);
BEGIN
M(0)<=C;
M(1)<=Z;
M(2)<=V;
M(3)<=N;

WITH M SELECT
PS <= DIR_SALTO_C WHEN "0001", ---- **
DIR_SALTO_Z WHEN "0010", ---- apuntar directamente
DIR_SALTO_V WHEN "0011",
DIR_SALTO_N WHEN OTHERS;
with M select
LOAD <= '0' WHEN "0000", --- PARA CARGAR LOS DATOS
'1' WHEN OTHERS; --- EN EL PUNTERO DE INSTRUCCIONES

END arq_salto_banderas;
 4.- Disee instrucciones para tambor de desplazamiento con 4 opciones
Desplazamiento aritmtico a la derecha
Desplazamiento aritmtico a la izquierda
Rotacin lgica a la derecha
Rotacin lgica a la izquierda

Para el diseo requerimos de 4 instrucciones que nos reproduzcan el desplazamiento estas sern
seleccionadas de acuerdo a la siguiente tabla que debe ser aadida al circuito del computador.

N tipo Cdigo
1 Desp. Arit derecha 00
2 Desp. Arit izquierda 01
3 Rot. Log derecha 10
4 Rot. Log izquierda 11

Estos desplazamiento se pueden realizar con mux de 4 a1 para cada desplazamiento la variable de
seleccin se actualiza y nos muestra el desplazamiento o la rotacin dependiendo lo que queramos
mostrar.
Para cada vez que se realice el desplazamiento la variable que se est desplazando debe actualizarse
y cambiar el valor de esta todo esto se realizara con un registro de 8 bits para luego devolver a la
entrada el valor que se desplaz posteriormente se debe cambiar el valor direccionando con un
buffer de alta impedancia de la siguiente manera:

Entonces la ALU integrada quedara siendo:

direc
A (8 bits)
ciona MUX REG
mien 4x1 8 bits
to 8bits

R (8 bits)
Cdigo en vhdl para el desplazamiento

library ieee;
use ieee.std_logic_1164.all;

entity mod_tambor_desplazamiento is port(

A:inout std_logic_vector (7 downto 0);
R:inout std_logic_vector (7 downto 0);
clk : in std_logic;
c,b: in std_logic);
end mod_tambor_desplazamiento;

architecture arq_mod_tambor_desplazamiento of mod_tambor_desplazamiento is

begin

process(clk,c,b)
begin
if(clk'event and clk = '1')then

if(c='0' and b='0')then -- desplazamiento aritmetico a la derecha

R(0) <= A(1);
R(1) <= A(2);
R(2) <= A(3);
R(3) <= A(4);
R(4) <= A(5);
R(5) <= A(6);
R(6) <= A(7);
R(7) <= '0';
A<=R;

elsif (c='0' and b='1') then-- desplazamiento aritmetico a la izquierda

R(0) <= '0';
R(1) <= A(0);
R(2) <= A(1);
R(3) <= A(2);
R(4) <= A(3);
R(5) <= A(4);
R(6) <= A(5);
R(7) <= A(6);

A<=R;

elsif (c='1' and b='0') then-- desplazamiento logico a la derecha

R(0) <= A(1);
R(1) <= A(2);
R(2) <= A(3);
 R(3) <= A(4);
R(4) <= A(5);
R(5) <= A(6);
R(6) <= A(7);
R(7) <= A(0);

A<=R;

else -- desplazamiento logico a la izquierda

R(0) <= A(7);
R(1) <= A(0);
R(2) <= A(1);
R(3) <= A(2);
R(4) <= A(3);
R(5) <= A(4);
R(6) <= A(5);
R(7) <= A(6);

A<=R;
end if;
end if;
end process;
end arq_mod_tambor_desplazamiento;

5.- Disee instrucciones para suma BCD

Para el diseo del sumador BCD se tom las siguientes consideraciones

En la suma de las unidades si el resultado en binario es mayor que 9 que no se pueda expresar en
bcd necesitaba una correccin en este caso se suma un 6 a las unidades y si genera un acarreo se
suma a las decenas, y si este es mayor que 9 o genera un acarreo igual se corrige con 6
Por ejemplo la suma mas grande que podemos hacer es de 99 +99

Cen Dc Un
1 1
9 9
9 9
1 9 8

Como las unidades y las decenas generan acarreo ambos bloques necesitan correccin sumar 66

Cen Dc Un
1 1
1001 1001
1001 1001
1 0011 0010
Sumamos 6 a cada bloque

Cen Dc Un
0001 0001
1001 1001
1001 1001
0001 0011 0010
0110 0110
0001 1001 1000
1 9 8

A continuacin el cdigo VHDL DEL SUMADOR BCD PARA 8 BITS

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

entity sumabcd is
port (au,ad: in std_logic_vector(3 downto 0);
bu,bd: in std_logic_vector(3 downto 0);
ru: inout std_logic_vector(3 downto 0);
rd: inout std_logic_vector(3 downto 0);
rc: inout std_logic);
end sumabcd;

architecture fun of sumabcd is

signal s,mc : std_logic;

begin
process(au,bu,ad,bd)
begin
ru <= au + bu;
rd <= ad + bd;
--condicion para la correccion
if ru> "1001" then
--condicion para la correccion y acarreo
if ru>"1111" then
s <= '1';
rd <= rd + s;
ru <= ru + "0110";
if rd > "1001" then
if rd>"1111" then
rc <='1';
rd <= rd + "0110";
else
rd <= rd + "0110";
 if rd >"1111" then
rc <= '1';
else
rc <= '0';
end if;
end if;
else
rd <= rd;
end if;

else
ru <= ru +"0110";
if ru>"1111" then
s<='1';
rd <= rd + s;
if rd >"1001" then
if rd > "1111" then
rc <='1';
rd <= rd + "0110";
else
rd <= rd + "0110";
if rd > "1111" then
rc <='1';
else
rc <='0';
end if;
end if;
else
rd <= rd;
rc<='0';
end if;
else
ru<=ru;
if rd >"1001" then
if rd > "1111" then
rc <='1';
rd <= rd + "0110";
else
rd <= rd + "0110";
if rd > "1111" then
rc <='1';
else
rc <='0';
end if;
end if;
else
 rd <= rd;
rc<='0';
end if;
end if;
end if;

else
ru <= ru;
if rd >"1001" then
if rd > "1111" then
rc <='1';
rd <= rd + "0110";
else
rd <= rd + "0110";
if rd > "1111" then
rc <='1';
else
rc <='0';
end if;
end if;
else
rd <= rd;
rc<='0';
end if;
end if;
end process;
end fun;
 Universidad Mayor De San Andrs
Facultad de Ingeniera

INGENIERIA
ELECTRONICA

Laboratorio de
MICROPROCESADORES
ETN 801

PRE - INFORME N4
IMPLEMENTACION DE ALU EN
FPGA

INTEGRANTES
Univ. lbarez Flores Juan Pablo
Univ. Catari Condorino Miguel Edgar
Univ. Choque Quispe Cristian Flix

La Paz- Bolivia