Implementacin de una ALU de 8 bits en lenguaje

VHDL

AUTORS: Jordi Pons Albalat.

DIRECTORS: Enric Cant Navarro.

DATA: Febrer / 2002.

1. Introduccin ........................................................................................ 4
2. El lenguaje VHDL .............................................................................. 5
2.1 VHDL describe estructura y comportamiento ............................................. 6
2.1.1 Ejemplo bsico y estilos de descripcin VHDL .................................... 7
2.1.2 Descripcin algortmica ........................................................................ 7
2.1.3 Descripcin flujo de datos .................................................................... 9
2.1.4 Descripcin estructural ......................................................................... 10
2.2 Unidades bsicas de diseo ........................................................................ 14
2.2.1 Como se declara una entidad ................................................................ 14
2.2.2 Como se declara una arquitectura ......................................................... 19
2.3 VHDL para sntesis ..................................................................................... 22
2.4 Construcciones bsicas ............................................................................... 23
2.5 Objetos ........................................................................................................ 24
2.6 Identificadores ............................................................................................ 24
2.7 Palabras reservadas ..................................................................................... 25
2.8 Smbolos especiales .................................................................................... 26

3. Explicacin ALU de 8 bits.................................................................. 27

3.1 Explicacin paso a paso .............................................................................. 27
3.2 Esquema interno bloque AND/OR ............................................................. 30
3.3 Esquema interno bloque suma_resta .......................................................... 32
3.4 Esquema interno bloque multiplexor .......................................................... 34
3.5 Tabla y simplificaciones ............................................................................. 35
3.5.1 Karnaught CLRA .................................................................................. 35
3.5.2 Karnaught INVB .................................................................................. 36
3.5.3 Karnaught MUX ................................................................................... 37
3.5.4 Karnaught CIN ..................................................................................... 38
3.5.5 Karnaught Funcio ................................................................................. 39

4. Guia del programa eProduct Designer ........................................... 41

4.1 Funcionamiento del programa paso a paso ................................................. 41
2

4.1.1 Compilar ............................................................................................... 41

4.1.2 Simulacin ............................................................................................ 53
4.1.3 Sintetizar .............................................................................................. 63

5. Conclusiones ..................................................................................... 72
Anexos .................................................................................................... 73
Anexo 1. Programa ALU ................................................................................ 73
Anexo 2. Programa de simulacin ................................................................... 80
Anexo 3. Fichero de retardos despus de la sntesis ...................................... 82
Anexo 4. Disposicin de las patas de la FPGA .............................................. 83
Anexo 5. Grficas de salida ........................................................................... 84

Bibliografa ........................................................................................... 88

Introduccin

En este proyecto lo que se trata es de hacer una unidad aritmtico lgica de 8 bits, es
decir lo que solemos conocer con el nombre de ALU, y la implementaremos a partir del
lenguaje VHDL, es decir disearemos un algoritmo que implemente una ALU. En el
algoritmo se ha hecho de forma que todo se tiene que hacer a travs de puetas lgicas es
decir un lenguaje puramente sintetizable ya que slo utilizaremos puertas. Esta ALU tiene
que hacer las siguientes operaciones o funciones:

Inversin del registro B

Suma

Resta

AND

OR

Cuando tengamos el cdigo VHDL hecho tendremos que compilarlo, simularlo, y

posteriormente tendremos que sintetizarlo. Para hacer todo esto que he comentado
anteriormente utilizaremos el programa eProduct Designer y con l lo haremos todo.
Este programa se ha hecho con un lenguaje RTL es decir transferencia de registros.
En el captulo 2 se explicar como hacer un programa mediante RTL, y aparte tambin se
explicar de forma introductoria como se pueden hacer programas en VHDL mediante otro
tipo de descripciones.
En el captulo 3 explicaremos los pasos que he seguido para hacer la ALU, primero
mostrar los esquemas de como se ha hecho paso a paso, y en el apartado de anexos se
mostrar el cdigo.
En el captulo 4 se explicar como hacer funcionar el programa eProduct Designer
mediante un tutorial que te ir diciendo como compilar, simular y sintetizar un programa
VHDL.
En el captulo 5 explicaremos las conclusiones a que hemos llegado despus de hacer
el proyecto, y las cosas que podramos mejorar.
Por ltimo al final pondremos los anexos, all pondremos los programas VHDL que
hemos hecho para hacer la ALU. En definitiva pondremos dos programas VHDL, uno que
ser la ALU y el otro que ser el fichero de simulacin con el cual verificamos que el
programa de la ALU funciona bien. A parte tambin pondremos ah los ficheros que
encontremos interesantes poner en el apartado de anexos, como el fichero de retardos que
se obtiene despus de realizar la sntesis del programa de VHDL.
Este proyecto ser una prctica para los alumnos de sistemas digitales para que vean
como se programa en VHDL y tambin para que vean como funciona este programa nuevo
el eProduct Designer. Antes se hacan las prcticas con el programa SYNARIO y ahora
se pasar a utilizar este nuevo programa y a utilizar el lenguaje VHDL que como se ver es
un lenguaje bastante sencillo de hacer.
Ahora pasaremos a explicar como se hace un programa VHDL y como usar el
programa para poder hacer nuestras pruebas.
4

2. El lenguaje VHDL
El significado de las siglas VHDL es VHSIC(Very High Speed Integrated Circuit)
Hardware Description Language, es decir, lenguaje de descripcin hardware de circuitos
integrados de muy alta velocidad. VHDL es un lenguaje de descripcin y modelado
diseado para describir, en una forma en que los humanos y las mquinas puedan leer y
entender la funcionalidad y la organizacin de sistemas hardware digitales, placas de
circuitos y componentes.
VHDL fue desarrollado como un lenguaje para el modelado y simulacin lgica
dirigida por eventos de sistemas digitales, y actualmente se utiliza tambin para la sntesis
automtica de circuitos. El VHDL fue desarrollado de forma muy parecida al ADA debido
a que el ADA fue tambin propuesto como un lenguaje que tuviera estructuras y elementos
sintcticos que permitieran la programacin de cualquier sistema hardware sin limitacin
de la arquitectura. El ADA tena una orientacin hacia sistemas en tiempo real y al
hardware en general, por lo que se lo escogi como modelo para desarrollar el VHDL.
VHDL es un lenguaje con una sintaxis amplia y flexible que permite el modelado
estructural, en flujo de datos y de comportamiento hardware. VHDL permite el modelado
preciso, en distintos estilos, del comportamiento de un sistema digital conocido y el
desarrollo de modelos de simulacin.
Uno de los objetivos del lenguaje VHDL es el modelado. Modelado es el desarrollo
de un modelo para simulacin de un circuito o sistema previamente implementado cuyo
comportamiento, por tanto, se conoce. El objetivo del modelado es la simulacin.
Otro de los usos de este lenguaje es la sntesis automtica de circuitos. En el
proceso de sntesis se parte de una especificacin de entrada con un determinado nivel de
abstraccin y se llega a una implementacin ms detallada, menos abstracta. Por tanto, la
sntesis es una tarea vertical entre niveles de abstraccin, del nivel mas alto en la jerarqua
de diseo hacia el ms bajo nivel de la jerarqua.
El VHDL es un lenguaje que fue diseado inicialmente para ser usado en el
modelado de sistemas digitales. Es por esta razn que su utilizacin en sntesis no es
inmediata, aunque lo cierto es que la sofisticacin de las actuales herramientas de sntesis
es tal que permiten implementar diseos especificados en un alto nivel de abstraccin.
La sntesis a partir de VHDL constituye hoy en da una de las principales
aplicaciones del lenguaje con una gran demanda de uso. Las herramientas de sntesis
basadas en el lenguaje permiten en la actualidad ganancias importantes en la productividad
de diseo.
Algunas ventajas del uso de VHDL para la descripcin hardware son:

VHDL permite disear, modelar y comprobar un sistema desde un alto

nivel de abstraccin bajando hasta el nivel de definicin estructural de
puertas.

Circuitos descritos utilizando VHDL, siguiendo unas guas para

sntesis, pueden ser utilizados por diversas herramientas de sntesis para
crear e implementar circuitos.
Los mdulos creados en VHDL pueden utilizarse en diferentes diseos,
lo que permite la reutilizacin del cdigo. Adems, la misma
descripcin puede utilizarse para diferentes tecnologas sin tener que
redisear todo el circuitos.
Al estar basado en un estndar(IEEE Std 1076-1987, IEEE Std 10761993) los ingenieros de toda la industria e diseo pueden usar este
lenguaje para minimizar errores de comunicacin y problemas de
compatibilidad.
VHDL permite diseo Top-Down, esto es, describir(modelar) el
comportamiento de los bloques de alto nivel, analizarlos(simularlos) y
refinar la funcionalidad en alto nivel requerida antes de llegar a niveles
ms bajos de abstraccin de la implementacin del diseo.
Modularidad: VHDL permite dividir o descomponer un diseo
hardware y su descripcin VHDL en unidades ms pequeas.

2.1 VHDL describe estructura y comportamiento

Existen dos formas de describir un circuito. Por un lado se puede describir un
circuito indicando los diferentes componentes que lo forman y su interconexin, de esta
manera se tiene especificado un circuito y se sabe cmo funciona. Esta es la forma habitual
en que se han venido describiendo circuitos, siendo las herramientas utilizadas para ello las
de captura de esquemas y las de descripcin netlist.
La segunda forma consiste en describir un circuito indicando lo que hace o cmo
funciona, es decir, describiendo su comportamiento. Naturalmente esta forma de describir
un circuito es mucho mejor para un diseador puesto que lo que realmente le interesa es el
funcionamiento del circuito ms que sus componentes. Por otro lado, al encontrarse lejos
de lo que es realmente un circuito, se pueden plantear algunos problemas a la hora de
implementarlo a partir de la descripcin de su comportamiento.
El VHDL va a ser interesante puesto que va
descripciones:

permitir los dos tipos de

Estructura: VHDL puede ser usado como un lenguaje de Netlist normal y corriente
donde se especifican por un lado los componentes del sistema y por otro
sus interconexiones.
Comportamiento: VHDL tambin se puede utilizar para la descripcin comportamental
o funcional de un circuito. Esto es lo que lo distingue de un lenguaje de
Netlist. Sin necesidad de conocer la estructura interna de un circuito es
posible describirlo explicando su funcionalidad. Esto es especialmente til
en simulacin, ya que permite simular un sistema sin conocer su estructura
interna. As, este tipo de descripcin se est volviendo cada da ms
importante porque las actuales herramientas de sntesis permiten la
creacin automtica de circuitos a partir de una descripcin de su
funcionamiento.
6

Muchas veces la descripcin comportamental se divide a su vez en dos,

dependiendo del nivel de abstraccin y del modo en que se ejecutan las
instrucciones. Estas dos formas comportamentales de describir circuitos
son la de flujo de datos y la algortmica.
2.1.1 Ejemplo bsico y estilos de descripcin en VHDL
VHDL presenta tres estilos de descripcin de circuitos dependiendo del nivel de
abstraccin. El menos abstracto es una descripcin puramente estructural. Los otros dos
estilos representan un descripcin comportamental o funcional, y la diferencia viene de la
utilizacin o no de la ejecucin serie.
Ahora mediante un ejemplo de un multiplexor explicar la forma en que se escriben
descripciones en VHDL, se van a mostrar tres estilos de descripcin.
Ejemplo. Describir en VHDL un circuito que multiplexe dos lneas de entrada
como el de la siguiente figura. Figura 1

Figura 1. Multiplexor

2.1.2 Descripcin algortmica

Lo se va a realizar a continuacin es la descripcin comportamental algortmica del
circuito de la figura anterior, despus se realizar la transferencia entre registros, que sigue
siendo comportamental, y por ltimo se ver la descripcin estructural mostrando as las
diferencia.
La sintaxis del VHDL no es sensible a maysculas o minsculas, por lo que se
puede escribir como se prefiera. A lo largo de las explicaciones se pondrn siempre las
palabras clave del lenguaje en maysculas para distinguirlas de las variables y otros
elementos. Esto no significa que durante la descripcin de diseos se tenga que hacer as,
7

de hecho resulta ms rpido escribir siempre en minsculas. Se ha hecho as en todos los

ejemplos para mayor claridad del cdigo.
En primer lugar, sea el tipo de descripcin que sea, hay que definir el smbolo o
ENTIDAD del circuito. En efecto, lo primero es definir las entradas y salidas del circuito,
es decir, la caja negra que lo define. Se llama entidad porque en la sintaxis de VHDL esta
parte se declara con la palabra clave ENTITY. Esta definicin de entidad, que suele ser la
primera parte de toda descripcin VHDL, se expone a continuacin. En esta parte
pondremos un ejemplo de lo que es una
entidad para poder hacer una descripcin de cada tipo especificado, despus en temas
posteriores definiremos con claridad que es una ENTIDAD y tambin una arquitectura, y
para que sirven.
Primero antes de pasar a la declaracin pondremos un dibujo de lo que es la caja
negra es decir la ENTIDAD de este multiplexor, que ser la siguiente. Figura 2

Entr_a

Mux

Entr_b

Multiplexor

Sortida
Figura 2. Bloque multiplexor

Ahora declararemos la ENTIDAD con lenguaje VHDL es decir las entradas y salidas que
tenemos.
ENTITY multiplexor IS --Bloque multiplexor
Port( entr_a:in std_logic --Entrada a
entr_b:in std_logic --Entrada b
mux :in std_logic; --Seleccionamos la entrada
sortida: out std_logic --Salida
END multiplexor;
8

Esta porcin del lenguaje indica que la entidad multiplexor (que es el nombre que
se le ha dado al circuito) tiene tres entradas de tipo bit y una salida tambin del tipo bit.
Los tipos de las entradas y salidas se vern ms adelante. El tipo bit simplemente indica
una lnea que puede tomar valores 0 o 1.
Ahora en lo que llamamos ARQUITECTURA definiremos lo que hace esta caja
negra que llamamos ENTIDAD es decir definiremos la funcin que hace, diremos que
hacen estas entradas y salidas que hemos definido antes. En la ARQUITECTURA
pondremos como se hace el multiplexor. Se muestra a continuacin la descripcin
comportamental del multiplexor:
ARCHITECTURE comportamental OF muxltiplexor IS
BEGIN
IF (mux=0) THEN
Sortida<=entr_a;
ELSE
Sortida<=entr_b;
END IF;
END comportamental

Esta descripcin comportamental es muy sencilla de entender, ya que sigue una

estructura parecida a los lenguajes de programacin convencionales. Es por lo que se dice
que se trata de una descripcin comportamental algortmica. Lo que se est indicando es
simplemente que si la seal mux es cero, entonces la entrada es entr_a, y si mux es uno,
entonces la salida es la entrada entr_b. Eta forma tan sencilla de describir el circuito
permite a ciertas herramientas sintetizar el diseo a partir de una descripcin
comportamental como la que se acaba de mostrar. La diferencia con un Netlist es directa:
en una descripcin comportamental no se estn indicando ni los componentes ni sus
interconexiones, sino simplemente lo que hace, es decir, su comportamiento o
funcionamiento.

2.1.3 Descripcin flujo de datos

La descripcin anterior era puramente comportamental, de manera que con una
secuencia sencilla de instrucciones se podra describir el circuito. Naturalmente, a veces
resulta ms interesante describir el circuito de forma que est ms cercano a una posible
realizacin fsica del mismo. En este sentido VHDL posee una forma de describir circuitos
que adems permite la paralelizacin de instrucciones, y que se encuentra ms cercana a
una descripcin estructural del mismo, siendo todava una descripcin funcional. A
continuacin se muestra una descripcin de flujo de datos o de transferencia entre
registros (RTL).

ARCHITECTURE flujo OF multiplexor IS

SIGNAL nmux: std_logic;
SIGNAL sor0: std_logic;
SIGNAL sor1: std_logic;
BEGIN
nmux<=not mux;
sor0<=nmux and entr_a;
sor1<=mux and entr_b;
sortida<= sor0 or sor1;
END multiplexor;
2.1.4 Descripcin estructural
Aunque no es la caracterstica ms interesante del VHDL, tambin permite ser
usando como Netlist o lenguaje de descripcin de estructura. En este caso esta estructura
tambin estara indicada dentro de un bloque de arquitectura, aunque la sintaxis interna es
completamente diferente.
Ahora pondremos un ejemplo para que se vea ms claro lo que es una descripcin
estructural, definiremos una ALU. Esto lo interpretaremos como una caja donde dentro
habr un bloque que sume y reste, otro bloque que haga las operaciones and y or, y por
ltimo otro bloque que sea un multiplexor que nos escoja la salida que queremos en
funcin de si en las operaciones Op0, Op1, Op2 le hemos dicho que funcin nos tiene que
hacer si suma o resta, o and o or. Para este ejemplo tendremos dos registros de entrada que
sern el registro a y el registro b que sern con los que haremos las operaciones, tendremos
una salida del carry llamada Cout y otra salida que ser el resultado de la operacin
hecha. Aparte como se ver en la unin de todos los bloques crearemos unas seales para
unir las diferentes entradas y salidas que sern x e y.
Cada uno de los tres bloques, haremos una descripcin por componentes, es decir
tendremos tres componentes, que sern:
1. Componente Suma/Resta
2. Componente And/Or
3. Componente Multiplexor

10

1. Primero definiremos los bloques por separado, y luego los uniremos, empezaremos
por el bloque de sumar y restar. Figura 3

aa

bb
COMPONENT suma_resta

Sum/Res

operacio0
operacio1
operacio2

Port ( aa: in std_logic;

bb: in std_logic;
operacio0 in std_logic;
operacio1:in std_logic;
operacio2: in std_logic;
cout:out std_logic;
sor_sum_res:out std_logic;
END COMPONENT;

Sor_sum_res
Figura 3. Componente suma_resta

2. Ahora haremos el bloque que nos har la funcin AND y la funcin OR. Figura 4

aa

bb
COMPONENT and_or

And/Or

operacio0
operacio1
operacio2

Port ( aa: in std_logic ;

bb: in std_logic;
operacio0: in std_logic;
operacio1: in std_logic;
operacio2: in std_logic;
sor_and_or: out std_logic;
END COMPONENT;

Sor_and_or
Figura 4. Componente AND/OR

11

3. Por ltimo haremos el bloque multiplexor que ser el siguiente. Figura 5

Entr_a Entr_b

COMPONENT multiplexor

operacio0
operacio1
operacio2

Multiplexor

Port ( entr_a: in std_logic;

entr_b: in std_logic;
operacio0: in std_logic;
operacio1: in std_logic;
operacio2: in std_logic;
sortida: out std_logic
END COMPONENT

Sortida
Figura 5. Componente multiplexor

4. Ahora uniremos todos los bloques y nos quedar la ALU tal y como se puede ver
en la figura. Figura 6

aa
Cout

bb

aa

bb

Cout
Sum/Res

And/Or

U1

Op0

U2
Op1

Sor_sum_res

Entr_a

Entr_b

Multiplexor
U3
Sortida
resultat
Figura 6. ALU

12

Sor_and_or

Op2

Seguidamente haremos el programa para unir los diferentes componentes y as se

ver como se ha hecho para hacer una descripcin estructural.
Primero mediante una entidad general tal y como habamos definido en el
enunciado pondremos las diferentes entradas y salidas de las que est compuesta nuestra
ALU, que sern, las siguientes.
ENTITY alu IS
Port ( a: in std_logic
b: in std_logic
resultat: out std_logic
op0: in std_logic;
op1: in std_logic;
op2: in std_logic;
cout: out std_logic);
END alu;

--Entrada de 1 bit
--Entrada de 1 bit
--Resultado de la operacin
--Op0,Op1,Op2 sirven
--para seleccionar la operacin
--que tiene que realitzar la ALU
--Carry de salida

Ahora en el siguiente trozo de programa haremos las uniones de los diferentes

bloques mediante una arquitectura como la siguiente
ARCHITECTURE estructura OF alu IS
COMPONENT and_or

--Bloque AND y OR

Port ( aa: in std_logic ;

bb: in std_logic;
operacio0: in std_logic;
operacio1: in std_logic;
operacio2: in std_logic;
sor_and_or: out std_logic;

--Entrada del bloque

--Entrada del bloque
--operacin a realizar
--salida

END COMPONENT;
COMPONENT suma_resta

--Bloque suma y resta

Port ( aa: in std_logic;

bb: in std_logic;
operacio0 in std_logic;
operacio1:in std_logic;
operacio2: in std_logic;
cout:out std_logic;
sor_sum_res:out std_logic

--Entrada del bloque

--Seleccin de operacin
--Carry de salida
--Salida

END COMPONENT;
COMPONENT multiplexor

--Bloque multiplexor

Port ( entr_a: in std_logic;

entr_b: in std_logic;
operacio0: in std_logic;

--Entrada del bloque

13

operacio1: in std_logic;
operacio2: in std_logic;
sortida: out std_logic;

--Seleccin de operacin
--Salida

END COMPONENT;
SIGNAL x: std_logic;
SIGNAL y: std_logic;
BEGIN

--Variables intermedias para unir

--los 3 bloques anteriores

U1 :and_or port map (a,b,op0,op1,y);

U2: suma_resta port map (a,b,op0,op1,op2,cout,x);
U3: multiplexor port map (x,y,op0,op1,op2,resultat);

--Paso de parmetros
--Paso de parmetros
--Paso de parmetros

END estructura;
Como se puede ver en el ejemplo anterior en las ltimas lineas hacemos el paso de
parmetros de los componentes a las variables de la ENTIDAD principal que es la entidad
ALU, lo nico que se tiene que tener en cuenta es que al hacer el paso de parmetros lo
hagamos en igual orden con el que hemos definido las variables, ya que si no al compilar
nos dar error si asignamos variables de tipo in a tipo out, o igual no nos da error pero si
invertimos variables el programa no nos va a funcionar i ser un autntico desastre.
2.2 Unidades bsicas de diseo
2.2.1 Cmo se declara una entidad
En la declaracin de entidades, se definen las entradas y salidas de nuestro chip,
diciendo cuntas son, de qu tamao (de 0 a n bits), modo (entrada, salida, ...) y tipo
(integer, bit,...) . Las entidades pueden definir bien las entradas y salidas de un diseo ms
grande o las entradas y salidas de un chip directamente. La declaracin de entidades es
anloga al smbolo esquemtico de lo que queremos implementar, el cual describe las
conexiones de un componente al resto del proyecto, es decir, si hay una entrada o puerto de
8 bits, o dos salidas o puertos de 4 bits, etc. La declaracin de entidades tiene la siguiente
forma:
ENTITY programa IS

Cabecera del programa

port(

Se indica que a continuacin viene los

puertos (o grupos seales) de entrada y/o salida

-- puertos de entradas
-- puertos de salidas
-- puertos de I/O
-- puertos de buffers

Aqu se declaran las entradas y/o salidas

con la sintaxis que se ver a continuacin. Las
lneas empezadas por dos guiones son ignoradas
por el compilador. As mismo, recordamos que el
compilador no distingue las maysculas de las
minsculas

14

);
END programa;

Se indica que se ha acabado la declaracin

de puertos de entrada y/o salida, y que se ha
acabado la entidad

Como hemos dicho, cada seal en una declaracin de entidad est referida a un
puerto (o grupo de seales), el cual es anlogo a un(os) pin(es) del smbolo esquemtico.
Un puerto es un objeto de informacin, el cual, puede ser usado en expresiones y al cual se
le pueden asignar valores. A cada puerto se le debe asignar un nombre vlido, Un ejemplo
de declarar los puertos es el siguiente:
nombre_variable: modo tipo;

Forma genrica de designar un puerto

puertoa: in bit;

El primer puerto es un bit de entrada,

y su nombre es "puertoa"

puertob: in bit_vector(0 to 7);

El segundo puerto es un vector de 8 bits de

entrada siendo el MSB el puertob(0) y el
LSB el puertob(7)

puertoc: out bit_vector(3 downto 0);

El tercer puerto es un vector de 4 bits

de salida siendo el MSB el puertoc(3) y el
LSB el puertoc(0)

puertod: buffer bit;

El cuarto puerto es un buffer de un

solo bit, cuyo nombre es "puertod"

puertoe: inout std_logic;

El quinto puerto es una entrada/salida

del tipo estndar logic de un solo bit

Seguido del nombre del puerto y separado de ste por dos puntos, viene el tipo de
puerto que va a ser. El modo describe la direccin en la cual la informacin es transmitida
a travs del puerto. stos slo pueden tener cuatro valores: in, out, buffer e inout. Si no se
especifica nada, se asume que el puerto es del modo in.

Modo in: Un puerto es de modo in si la informacin del mismo, solamente

debe entrar a la entidad, soliendo ser usado para relojes, entradas de control
(como las tpicas load, reset y enable), y para datos de entrada unidireccionales.

Modo out: Un puerto es de modo out si la informacin fluye hacia fuera de la

entidad. Este modo no permite realimentacin, ya que al declarar un puerto
como out, estamos indicando al compilador que el estado lgico en el que se
encuentra no es leble. Esto le da una cierta desventaja, pero a cambio consume
menos recursos de nuestros dispositivos lgicos programables.

Modo buffer: Es usado para una realimentacin interna (es decir, para usar
este puerto como un driver dentro de la entidad). Este modo es similar al modo
out, pero adems, permite la realimentacin. Este puerto no es bidireccional, y
solo puede ser conectado directamente a una seal interna, o a un puerto de
modo buffer de otra entidad. Una aplicacin muy comn de este modo es la de
15

salida de un contador, ya que debemos saber la salida en el momento actual

para determinar a salida en el momento siguiente.

Modo inout: Es usado para seales bidireccionales, es decir, si necesitamos

que por el mismo puerto fluya informacin tanto hacia dentro como hacia
afuera de la entidad. Este modo permite la realimentacin interna. Este modo
puede reemplazar a cualquiera de los modos anteriores, pudindose usar este
modo para todos los puertos, pero reduciremos la lectura posterior del cdigo
por otra persona, y reduciendo los recursos disponibles de la cpsula.

Como se ha comentado arriba, VHDL slo admite cuatro modos para los puertos,
pero puede haber tantos tipos de seales como queramos, ya que las podemos crear
nosotros mismos. VHDL incorpora varios tipos de forma estndar (por haber sido creado
as), pudiendo usar otros mediante libreras normalizadas, y los creados por nosotros. La
norma internacional IEEE 1076/93 define cuatro tipos que son nativos para VHDL como
son:

Tipo boolean: puede tomar dos valores: verdadero/true o falso/false. Un

ejemplo tpico es la salida de un comparador que da verdadero si los nmeros
comparados son iguales y falso si no lo son:

equal:out boolean;

Slo puede tomar dos valores: verdadero o falso, y es

de salida (darle mas operatividad a la salida de un
comparador sera superfluo)

Tipo bit: Puede tomar dos valores: 0 1 ( o tambin "low" o "high", segn se
prefiera). Es el tipo ms usado de los nativos.

Tipo bit_vector: Es un vector de bits. Debemos tener cuidado al definir el peso

de los bits que lo integran, ya que segn pongamos la palabra reservada
downto o to estaremos diciendo que el bit ms significativo es el nmero ms
alto o el ms bajo del vector, respectivamente.

numero : bit_vector (0 to 7);

En este caso el MSB es numero(0) y

numero(7) el LSB

numero : bit_vector (7 downto En este caso el MSB es numero(7) y

0);
numero(0) el LSB

Tipo integer: Para manejar nmeros enteros. Hay que advertir que el uso de
enteros consume muchos recursos de cpsula, siempre y cuando sea
sintetizable, ya que est prcticamente creado para la simulacin.

Pero ante la necesidad de ampliar la operatividad del tipo bit, la norma IEEE 1164,
defini un nuevo tipo llamado std_logic, y sus derivados tales como std_logic_vector y

16

std_logic_vector. Como su nombre pretende indicar, es el tipo de tipo lgico estndar, que
es el ms usado en la actualidad.
Primero pondremos un ejemplo sencillo de una entidad que consiste en un bloque
que nos haga la funcin AND de dos entradas a y b. Figura 7

AND

resultado
Figura 7. Bloque AND

ENTITY and IS port (

Cabecera de la entidad, cuyo nombre es and

a,b: in std_logic;
resultado: out bit;
);
END and;

a y b son las entradas de 1 bit

resultado es la salida de un slo bit

Se finaliza la entidad con la palabra clave end y el

nombre de la misma and).

Como ejemplo, a continuacin se incluye la declaracin de entidades de un

multiplexor de 2x1 de cuatro bits, con entrada de habilitacin o enable. El multiplexor
necesita las entradas de informacin, la seal de seleccin, la de enable y las salidas de
informacin. Figura 8

in1

in2

4 bits

4 bits

Multiplexor

4 bits
out1
Figura 8. Multiplexor

17

selec

Cabecera ya estudiada arriba, en la que multi es el

nombre de la entidad

ENTITY multi IS port (

selec: in bit;
in1: in std_logic_vector(3 downto 0);
in2: in std_logic_vector(3 downto 0);
out1:out std_logic_vector(3 downto 0));

selec es otro bit de entrada, que selecciona

la entrada in1 o in2, ambas de 4 bits

out1 es de salida, que lgicamente, debe

ser de la misma longitud que in1 e in2

END multi;

Otro ejemplo se muestra a continuacin como es la entidad para un comparador.

Figura 9

4 bits

4 bits

Comparador

4 bits
igual
Figura 9. Comparador

ENTITY compa IS port (

a,b: in std_logic_vector(3 downto 0);
igual: out bit;
);
END compa;

Cabecera de la entidad, cuyo nombre es compa

a y b son las entradas de cuatro bits

igual es la salida de un slo bit

Se finaliza la entidad con la palabra clave end y el

nombre de la misma (compa).

Debemos recordar dos puntos ms a la hora de dar el nombre a algn puerto, que se
tratarn ms adelante en el apartado de objetos:

VHDL no distingue las letras maysculas de las minsculas, por lo que un

puerto llamado por nosotros "EnTraDA" ser equivalente a otro que se llame
"ENTRADA" o "entrada".

18

El primer carcter de un puerto slo puede ser una letra, nunca un nmero. As
mismo, no pueden contener caracteres especiales como $, %, ^, @, ... y dos
caracteres de subrayado seguidos.

Estos dos detalles a tener en cuenta surgieron del comit que cre este lenguaje, por
lo que no se debe considerar como un fallo de nuestra herramienta, sino como una
caracterstica ms del lenguaje.

2.2.2 Cmo se declara una arquitectura

La arquitectura es lo que nos dice que debemos hacer con los puertos 8o grupos de
seales de entrada, declarados previamente en la entidad) para llegar a tener los puertos de
salida (tambin declarados en la entidad). En la declaracin de entidades es donde reside
todo el funcionamiento de un programa, ya que es ah donde se indica que hacer con cada
entrada, para obtener la salida. Si la entidad es vista como una "caja negra", para la cual lo
nico importante son las entradas y las salidas, entonces, la arquitectura es el conjunto de
detalles interiores de la caja negra.
La declaracin de arquitecturas debe constar de las siguientes partes como mnimo,
aunque suelen ser ms:
Cabecera de la arquitectura. En sta, archpro
es un nombre cualquiera (suele empezar por
ARCHITECTURE archpro OF programa IS "arch", aunque no es necesario) y programa
es el nombre de una entidad existente en el
mismo fichero
-- declaracin de seales y otros accesorios

Declaraciones de apoyo, que se vern en la

pgina siguiente

BEGIN

Se da comienzo al programa

-- ncleo del programa

Conjunto de sentencias, bucles, procesos,

funciones,... que dan operatividad al
programa.

END archpro;

Fin del programa

Como podemos apreciar, es una estructura muy sencilla, y que guarda alguna
relacin con Turbo Pascal. Las sentencias entre begin y end son las que realmente "hacen
algo". A continuacin, pondremos primero la arquitectura de la AND la cual debe ir unido
a la entidad expuesta en el apartado de la declaracin de entidades, ya que una parte sin la
otra carecen de sentido. Figura 10

19

resultado
Figura 10. AND

ARCHITECTURE archiand OF and IS

Cabecera de la arquitectura. En esta ocasin

el nombre de la arquitectura es archiand, y el
de la entidad es and, la cual est definida
anteriormente.

-- seales

En este programa no vamos a necesitar

seales

BEGIN

Se da comienzo al programa

resultado<=a and b;

ENDarchiand;

Asignacin para hacer la funcin AND

Fin del programa

Despus del anterior ejemplo que muy sencillo pasaremos hacer el ejemplo del
multiplexor, que tambin en el apartado anterior especificamos su identidad, ahora
definiremos su funcin mediante la arquitectura siguiente, primero haremos el dibujo del
multiplexor con su puertas lgicas, y despus pasaremos a implementarlo. Figura 11

20

In1

In2

Selec

Sor1

Sor2

Out1
Figura 11. Multiplexor

Ahora haremos el programa con VHDL, que ser el siguiente:

Cabecera de la arquitectura. En esta
ocasin el nombre de la arquitectura es
archimulti, y el de la entidad es multi,
la cual est definida anteriormente.

ARCHITECTURE archimulti OF multi IS

SIGNAL sor1 : std_logic_vector (3 downto 0);

Seales necesarias tal como se puede
observar en el dibujo anterior

SIGNAL sor2 : std_logic_vector (3 downto 0);

SIGNAL selecnot : std_logic;

Se da comienzo al programa

BEGIN
Selecnot<= not selec;

Operaciones con cada uno de los 4 bits.

Para cada bit se tiene que implementar
el circuito del dibujo anterior.

Sor1(0)<=selecnot and in1(0);

Sor2(0)<=selec and in2(0);

21

Out(0)<=sor1(0) or sor2(0);
Sor1(1)<=selecnot and in1(1);
Sor2(1)<=selec and in2(1);
Out(1)<=sor1(1) or sor2(1);
Sor1(2)<=selecnot and in1(2);
Sor2(2)<=selec and in2(2);
Out(2)<=sor1(2) or sor2(2);
Sor1(3)<=selecnot and in1(3);
Sor2(3)<=selec and in2(3);
Out(3)<=sor1(3) or sor2(3);

END multi;

Fin del programa

2.3 VHDL para sntesis

La sntesis de un circuito, a partir de una descripcin VHDL, consiste en reducir el
nivel de abstraccin de la descripcin del circuito hasta convertirlo en una definicin
puramente estructural cuyos componentes son elementos de una determinada biblioteca.
Esta biblioteca depender del circuito que se quiera realizar, la herramienta de sntesis, etc.
Al final del proceso de sntesis se debe obtener un circuito que funcionalmente se comporte
igual que la descripcin que de l se ha hecho.
En un principio cualquier descripcin en VHDL es sintetizable, no importa el nivel
de abstraccin que la descripcin pueda tener. Esto, que en principio puede parecer
sorprendente no lo es en absoluto, ya que cualquier descripcin en VHDL se puede
simular, y si se puede simular, el propio simulador(en general un ordenador jecutando un
programa) es un circuito que funcionalmente se comporta tal y como se ha descrito, por lo
tanto, desde este punto de vista es una sntesis del circuito que se ha diseado. Es evidente
que no ser el circuito ms optimizado para realizar la tarea que se pretende, ni lo har a la
velocidad que se requiere, pero seguro que funcionalmente se comporta tal y como se ha
descrito.
La complejidad del circuito resultante y tambin incluso la posibilidad o no de
realizar el circuito, va a depender sobre todo del nivel de abstraccin inicial que tenga la
descripcin. Como primera solucin se puede utilizar un ordenador que ejecute la
22

simulacin y ya se tiene la sntesis. A partir de este primer intento, hay que ir optimizando
el circuito. En realidad las herramientas de sntesis siguen una aproximacin distinta, ya
que de otra manera el circuito acabara siendo algo parecido a un microprocesador cuando
quiz en realidad slo se pretende, eventualmente, implementar una puerta lgica.
La aproximacin de las herramientas de sntesis consiste en, partiendo de la
descripcin original, reducir el nivel de abstraccin hasta llegar a un nivel de descripcin
estructural. La sntesis es por tanto una tarea vertical entre los niveles de abstraccin de un
circuito. As, una herramienta de sntesis comenzara por la descripcin comportamental
abstracta algortmica e intentara traducirla a un nivel de transferencia entre registros
descrita con ecuaciones de conmutacin. A partir de esta descripcin se intenta
transformarla a una descripcin estructural donde se realiza, adems, lo que se llama el
mapeado tecnolgico, es decir, la descripcin del circuito utilizando los componentes de
una biblioteca concreta que depende de la tecnologa con la cual se quiera implementar el
diseo.
Las herramientas de sntesis actuales cubren a la perfeccin la sntesis a partir de
descripciones RTL y estruturales, pero no estn tan avanzadas en el manejo de diseos
descritos en un nivel de abstraccin ms alto. No es que no se pueda sintetizar a partir de
un nivel alto de abstraccin, lo que ocurre es que la sntesis obtenida no es quiz la ms
ptima para el circuito que se pretende realizar.

2.4 Construcciones bsicas

El primer paso es ver si un circuito describe lgica combinacional o secuencial. Un

circuito describe lgica combinacional si la salida depende nicamente de la entrada en ese
instante, y no de la entrada que hubiera tenido en un pasado, es decir, ante una entrada
dada la salida es siempre la misma. Un circuito describe lgica secuencial cuando la salida
depende de la entrada actual y de las entradas anteriores, o dicho de otra forma, la salida
depende de la entrada y del estado del sistema. Esto introduce un nuevo elemento dentro
del sistema que ser la memoria. Normalmente el elemento de memoria ser una seal que
frente a unos estmulos captura otra seal y en caso contrario permanece igual. Esto nos da
una pista de si un circuito es secuencial y si se realizar por tanto a partir de elementos de
memoria como pueden ser cerrojos o registros.
En este proyecto solo estudiaremos la lgica combinacional ya que solo interviene este
tipo, la idea bsica es que si en la estructura del lenguaje no se introducen elementos de
memoria entonces se est delante de una descripcin combinacional. Se va a mostrar
entonces cmo evitar que aparezcan elementos de memoria para que el circuito se realice
slo con puertas lgicas.

23

2.5 Objetos
En un lenguaje de descripcin de software (SDL) una variable contiene un valor y
puede aceptar un nuevo valor a travs de una asignacin secuencial. Por otro lado, las
constantes tienen valores prefijados a lo largo de toda la ejecucin del programa. Sin
embargo, en VHDL se hace necesaria la utilizacin de un nuevo tipo de objeto que puede
emular las asignaciones concurrentes propias de los circuitos elctricos reales; este nuevo
tipo de objeto son las seales.
Un objeto en VHDL es un elemento que tiene asignado un valor de un tipo determinado.
Segn sea el tipo de dato, el objeto poseer un conjunto de operaciones que se le podrn
aplicar. En general, no ser posible realizar operaciones entre dos objetos de distinto tipo, a
menos que definamos previamente un programa de conversin de tipos.
2.6 Identificadores

Los identificadores son un conjunto de caracteres dispuestos de una forma

adecuada y siguiendo unas normas propias del lenguaje, para dar un nombre a los
elementos en VHDL, por lo que es aconsejable elegir un nombre que sea representativo y
que facilite la comprensin del cdigo.
Las reglas a tener en cuenta a la hora de elegir un identificador son:

Los identificadores deben empezar con un carcter alfabtico, no pudiendo

terminar con un carcter subrayado, ni tener dos o ms de estos caracteres
subrayados seguidos.

VHDL identifica indistintamente tanto las maysculas como las minculas,

pudindose emplear por igual el identificador "sumador" o "SUMADOR".

El tamao o extensin del identificador no est fijado por VHDL, siendo

recomendable que el usuario elija un tamao que confiera sentido y significado
al identificador, sin llegar a alcanzar longitudes excesivamente largas.

Los identificadores pueden contener caracteres numricos del '0' al '9', sin que
stos puedan aparecer al principio.

No puede usarse como identificador una palabra reservada por VHDL.

24

2.7 Palabras reservadas

Las palabras reservadas son un conjunto de identificadores que tienen un

significado especfico en VHDL. Estas palabras son empleadas dentro del lenguaje a la
hora de realizar un diseo. Por esta razn y buscando obtener claridad en el lenguaje, las
palabras reservadas no pueden ser empleadas como identificadores definidos por el
usuario.
Las palabras reservadas por VHDL son:

abs

else

nand

return

access

elsif

new

select

after

end

next

severity

alias

entity

nor

signal

all

exit

not

subtype

and

file

null

then

architecture

for

of

to

array

function

on

transoprt

asser

generate

open

type

attribute

generic

or

units

begin

guarded

others

until

block

if

out

use

body

in

package

variable

buffer

inout

port

wait

bus

is

procedure

when

case

label

process

while

component

library

range

with

configuration

linkage

record

xor

constant

loop

register

disconnect

map

rem

downto

mod

report

25

2.8 Smbolos especiales

Adems de las palabras reservadas empleadas como identificadores predefinidos,

VHDL utiliza algunos smbolos especiales con funciones diferentes y especficas, tales
como el smbolo "+" se utiliza para representar la operacin suma y, en este caso, es un
operador. El smbolo "--" es empleado para los comentarios realizados por el usuario, de
tal forma que el programa al encontrar una instruccin precedida por "--" la saltar
ignorando su contenido. De esta forma, el programador puede hacer ms comprensible el
cdigo del programa.
Los smbolos especiales en VHDL son:

( ) . , : ; & ' < > = | # <= => := --

Para finalizar, recordar el smbolo ms empleado por un programador que es el ";",

smbolo que debe finalizar todas y cada una de las lneas del cdigo dando por terminada
dicha sentencia en el programa.

26

Explicacin de la ALU de 8 bits

3.1 Explicacin paso a paso
En este captulo explicaremos paso a paso como se ha hecho la ALU de 8 bits,
mediante los esquemas. Cuando tenemos todos los esquemas hechos, entonces haremos el
programa en VHDL que est expuesto en el anexo 1.
Una vez se tienen claros todos los esquemas, es bastante sencillo programar en
VHDL.
Primero ahora definiremos los diferentes bloques que tendr la ALU, que sern
tres:
Bloque que ara la suma y la resta y tambin el inverso del registro B
Bloque que ara las operaciones AND i OR
Bloque multiplexor

Todos estos bloques estarn dentro de nuestra ALU Ahora definiremos por pasos
todos los bloques y el ltimo ser hacer un esquema general de todo unido. Primero

aa

bb

Cout
Sum/Res

operacio0
operacio1
operacio2

Sor_sum_res
empezaremos por el bloque suma_resta que ser el siguiente tal y como se puede observar.
en la figura siguiente. Figura 12.
Figura 12. Esquema general bloque suma_resta

En la figura 12 hemos definido el bloque las entradas y salidas que tendr,

posteriormente cuando hagamos definido todos los bloques y tambin los hagamos
interconexionado todos, haremos los esquemas interiores de cada bloque por separado.

27

Ahora pasaremos a hacer el esquema del bloque AND/OR tal y como se muestra en

aa

bb
operacio0
operacio1
operacio2

And/Or

Sor_and_or
la siguiente figura. Figura 13.
Figura 13. Esquema general bloque AND/OR

En este bloque de la figura 13 anterior tambin podemos observar las entradas y

salidas que tendremos.
Ahora haremos el bloque multiplexor que lo que nos har este bloque es escoger si
tenemos que coger el resultado del bloque suma_resta o del bloque AND/OR, y ponerlo a
la salida, dependiendo de que hagamos puesto en las opereaciones escogeremos un

Entr_a Entr_b
operacio0
operacio1
operacio2

Multiplex

Sortida
resultado, u otro. Seguidamente pasaremos a ver la figura del multiplexor. Figura 14
28

Figura 14. Esquema general bloque multiplexor

Ahora lo que haremos es unir todos los bloques anteriores, y entonces ya tendremos

aa
Cout

bb

aa

bb

Cout
Sum/Res
U1
Sor_sum_res

And/Or
U2
Sor_and_or
y
Entr_b

x
Entr_a

Op0
Op1
Op2

Multiplex
U3
Sortida
resultat
definida nuestra ALU, en la siguiente figura. Figura 15 pondremos el esquema general de
la ALU con todas sus entradas y salidas.
Figura 15. ALU

Como se puede observar en la figura anterior. Figura 15 tendremos nuestras entradas

y salidas generales que sern, las que estn en azul que estn fuera del cuadrado son las
entradas y salidas generales, mientras que las que estn dentro del cuadrado, que estn en
negro sern variables internas que he creado para despus poder disear el programa,
despus aparte de estas entradas y salidas que tenemos internamente como ya se ver
posteriormente ir creando nuevas variables y seales para que todo quede ms claro.
Variables generales de entrada y salida de la ALU:
1. A) Entrada de 8 bits
2. B) Entrada de 8 bits
3. Cout) Salida de 1 bit
4. Resultat) Salida de 8 bits
5. Op0) Entrada de 1 bit
6. Op1) Entrada de 1 bit

29

7. Op2) Entrada de 1 bit

Como se puede observar tendremos dos entradas de 8 bits que sern con las que
haremos las operaciones, y despus tres bits Op0, Op1, Op2, que nos diran que operaciones
queremos hacer: suma, resta, inversa de b, AND, OR. Por ltimo tendremos el resultado de
8 bits, y tambin tendremos el carry de salida en caso de que hagamos una suma o una
resta, en el caso de que hagamos otras operaciones no lo tendremos en cuenta.
3.2 Esquema Interno Bloque AND/OR
Ahora primero haremos la tabla de la verdad. Figura 16

AA

BB

Funcin

SALIDA

Figura 16. Tabla 1

La variable funcin sirve para decidir si queremos hacer una AND o una OR. Como
se puede observar si ponemos un 0 en funcin haremos la funcin AND, y si por el
contrario ponemos un 1 en funcin haremos la funcin OR Ahora pasaremos hacer la
simplificacin por Karnaught. Figura 17

aa
bb
Funcin

0
0

0
1

1
1

1
1

0
1

1
0
aa*bb

aa*funcin

bb*funcin

Salida = aa*bb + aa*funcin + bb*funcin

Figura 17. Simplificacin AND/OR

30

(1)

Entonces como las funcines yo las elegir con Operacion0, Operacion1,

Operacion2, esto tengo que adaptar la variable funcin a estas operaciones, y entonces nos
quedar ya la figura del bloque interno AND/OR que ser el siguiente. Figura 18.

Figura 18. Esquema interno AND/OR

Las variables intermedias que he puesto y que no he comentado, son variables que
necesitar para hacer el programa en VHDL, si se quieren ver para que sirven estas
variables consultar el cdigo del programa VHDL en el anexo 1, y mirar en el apartado del
bloque AND/OR donde se vern estas seales.
Para sacar la variable funcio de las operacio0,operacio1, operacio2, mas adelante
pondr una tabla y todas las simplificaciones donde se podr apreciar como se han
obtenido, mirar figura 23.

31

3.3 Esquema interno bloque suma_resta

Ahora en este apartado pondremos los dibujos necesarios para que se entienda el
bloque que nos har la suma y la resta, y tambin la inversin de la seal B. Figura 19
aa(7) bb(7)
Clra

aa(4) bb(4)
Clra

aa(0) bb(0)
Clra
Invb

a_entr_sum(4)

a_entr_sum(7)

b_entr_sum(4)

b_entr_sum(7)

a_entr_sum(0)
b_entr_sum(0)

Cout

Cin

Sumador de 8 Bits

Sor_sum_res(7)

Sor_sum_res(4)

Sor_sum_res(0)

Figura 19. Sumador

En la figura 19 podemos ver que solo hemos implemntado el bit 0, el bit 4 y el bit
7, pero para hacer los otros que faltan en medio es lo mismo. Tambin podemos observar
que ponemos unas seales que aqu no nos interesan, pero veremos que para hacer el
programa en VHDL sern necesarias, mirar anexo 1 en el bloque suma_resta y las veremos
identificadas.

32

En la figura 19 Dentro del bloque de color verde que pone sumador de 8 bits dentro
habr ocho sumadores como los que se muestran en la siguiente figura. Figura 20.

a_entr_sum (0)
b_entr_sum(0)
Sor_sum_res(0)
Cin (0)

Bit0(0)
Bit1(0)

Cin(1)

Bit2(0)
Figura 20. Sumador interno

Ahora con las dos figuras anteriores pondremos como quedara el dibujo final en la
siguiente figura. Figura 21.
aa(7) bb(7)
Clra

aa(4) bb(4)

aa(0) bb(0)

Clra

Clra
Invb

a_entr_sum(4)

a_entr_sum(7)

b_entr_sum(4)

b_entr_sum(7)

a_entr_sum(0)
b_entr_sum(0)

Cout

Cin

Sumador de 8 Bits
Cin(1)

Sor_sum_res(7)

Sor_sum_res(4)

Figura 21. Sumador completo

33

Sor_sum_res(0)

En la figura 21, se puede observar como quedara el sumador con las figuras 19 y 20
juntas. Para cada bit se tendr que poner un sumador total igual que el de la figura 20.
Ahora despus de estas especificaciones anteriores ya tenemos el bloque que suma,
resta, y invierte b. Mas adelante pondremos una tabla, figura 23, donde especificaremos
como se hacen cada una de las operaciones, dependiendo de que valor pongamos en CLRA
o en INVB haremos la suma la resta o la inversin, esto ya lo observaremos ms adelante.
Despus de la figura 23 pondremos las simplificaciones de CLRA, INVB, CIN, para
ponerlas en funcion de operacio0, operacion1, operacio2, que son las que nos tienen que
decir que operacin tenemos que hacer.
3.4 Bloque multiplexor
En este apartado pondremos como hemos hecho el bloque multiplexor,
seguidamente pondremos un esquema de un multiplexor de 1 bit, y lo que se tendr que
hacer es lo mismo pero para ocho bits, por lo tanto explicaremos uno y entonces solo ser
questin de poner 7 ms. En la siguiente figura pondremos un multiplexor. Figura 22

Figura 22. Multiplexor

En la figura 22 se observa un multiplexor, las seales que de ms las necesitaremos

para hacer el programa como se puede observar en el anexo 1.
La entrada mux es la que nos decide que salida tenemos que poner en sortida. Esta
entrada mux nos depender de operacio0, operacio1, operacio2, que ms adelante en la
figura 23 pondremos como se llega a mux y sus simplificaciones.

34

3.5 Tabla y simplificaciones

Una vez tenemos claro todos los dibujos anteriores tendremos que dibujar una tabla
con las operaciones que tenemos que hacer, y segn las entradas Op que pongamos
tenemos que definir que salida queremos. Esta tabla tambin nos servir para simplicar
como veremos prximamente. Figura 23

Op2

Op1

Op0

Operacin

CLRA

INVB

MUX

CIN

Funcio

Inversion B

Suma

Resta

AND

OR

Figura 23. Tabla 2

Aqu ahora pondremos todas las tablas de Karnaught de cada variable.

3.5.1. Karnaught de CLRA. Figura 24

Op1
Op2Op0

0
0

0
1

1
1

1
0

Op0 * Op1

CLRA = Op0 * Op1

Figura 24. Simplificacin CLRA

35

(2)

Con la funcin anterior entonces tendremos el siguiente esquema, Figura 25.

Figura 25. Esquema CLRA

3.5.2. Karnaught de INVB que ser. Figura 26

0
1

0
0
11

Op1
Op2Op0

1
1
X

1
0
1

Op0 * Op2
INVB = Op0 * Op2

Figura 26. Simplificacin INVB

36

(3)

Seguidamente pondremos el esquema. Figura 27

Figura 27. Esquema INVB

3.5.3. Simplificacin de Mux. Figura 28

Op1
Op2Op0

0
0

1
1

1
0

0
1

0
1

1
Op0 * Op1 * Op2
Op0 * Op1 * Op2

MUX = Op0 * Op1 * Op2 + Op0 * Op1 * Op2

MUX = Op0 * Op1 * Op2 + Op0 * Op1 * Op2

Figura 28. Simplificacin Mux

37

(4)

Ahora pondremos el esquema de la funcin mux, que ser el de la siguiente figura.

Figura 29.

Figura 29. Esquema Multiplexor

3.5.4. Simplificacin de Cin.Figura 30

Op1
Op2Op0

0
0

0
1

0
1

1
1
X

1
0
1

Op1 * Op2
CIN = Op1 * Op2

Figura 30. Simplificacin Cin

38

(5)

Aqu pondremos su esquema que ser el de la figura siguiente. Figura 31

Figura 31. Esquema Cin

3.5.5. Simplificacin de
funcin. Figura 32

0
0

0
1

Op1
Op2Op0

1
1

1
0
X

FUNCIO = Op1 * Op0

FUNCIO = Op1 * Op0

Figura 32. Simplificacin funcin

39

(6)

Aqu pondremos el dibujo de la funcio. Figura 33

Figura 33. Esquema Funcio

Cuando tengo todos los esquemas hechos lo que tendr que hacer es
implementarlos en cdigo VHDL, y ponerlos en su lugar adecuado, para que quede ms
claro, mirar el anexo 1 donde aparece el cdigo del programa y se podr ver en los
diferentes apartados todas las variables que hemos visto en las simplificaciones.
Como se puede observar en el anexo 1, el cdigo una vez tienes hecho todos los
esquemas, y lo tienes todo claro resulta bastante evidente como se hace, cuando tienes
claro como se programa en VHDL.

40

Guia del programa eProduct Designer

El programa que utilizaremos para compilar el cdigo VHDL, para probar que
funciona, para sintetizar, para sacar el pin-out de la ALU y para todo ser el eProduct
Designer tambin dicho Dashboard.

4.1 Funcionamiento paso a paso del programa

4.1.1 Como hacer para compilar
Aqu pondremos los pasos a seguir para comenzar a utilizar el programa, lo haremos
de la siguiente manera:
1) Abrir en programas eProduct Designer.
2) Programable Design.
3) Escogemos el icono siguiente

y nos aparecer la siguinte figura 34.

Figura 34. Men 1

41

4) Abrimos File > Analyze VHDL Design

, y entonces podremos ver la figura

35.

Figura 35. Men 2

5) En el submen de la figura anterior, figura 35 tenemos que elegir la opcin

Cancelar.
6) Ahora tendremos que crear un VHDL Workspace para incluir los archivos que
nosotros queramos compilar, con las libreras que necesitemos en cada caso.
7) Seleccionar File > New.
8) Seleccionar File > Save as. Le ponemos un nombre y lo guardamos dentro del
directorio que nosotros tenemos los archivos VHDL que queremos compilar. Podemos
obsevarlo en la figura 36.

42

Figura 36. Men 3

9) En el submen de la figura anterior, figura 36 poner un nombre donde pone

nombre de archivo y despus seleccionar Guardar.
10) Ahora lo que tenemos que hacer es seleccionar las libreras que necesitamos para
compilar nuestro programa.
11) Para seleccionar una determinada librera lo que tenemos que hacer es lo
siguiente, ponernos encima de la que queramos y pulsar el botn derecho del ratn y
entonces nos aparecer el siguiente men, figura 37

43

Figura 37. Men 4

12) Seleccionamos del submen de la figura anterior, figura 37 Include System

Library. Entonces nos aparecer de la siguiente manera, como se puede observar en la
figura 38.
En cada una de las libreras que nosotros necesitemos para nuestro programa
tendremos que apretar el botn derecho del ratn y entonces seleccionaremos el Include
system library.
Si por ejemplo queremos utilizar todas las libreras para nuestro programa no har
falta ir una por una seleccionandolas, sin que donde pone VHDL system Libraries, que
es de donde cuelgan todas las libreras, le daremos ah con el botn derecho, y entonces
nos seleccionar todas las libreras.

44

Figura 38. Men 5

Como podemos apreciar en la figura 38 en la librera ieee.lib, vemos que nos aparece un
seal, esto quiere decir que nosotros la hemos incluido, en caso de que no aparezca esta
seal querr decir que no tenemos la librera seleccionada.
13) Cuando tengamos la librera seleccionada tendremos que guardar los cambios.
Tendremos que ir a File > Save. Se pueden seleccionar tantas libreras como necesitemos
en nuestro programa.
14) Ahora tendremos que crear un nuevo usuario de librera, y lo haremos de la
siguiente manera.
15) Seleccionamos Library >Create, nos aparecer el siguiente men. Figura 39.

45

Figura 39. Men 6

Tenemos que tener cuidado, en el submen de la figura anterior, figura 39 donde

nos aparece Symbolic Name pondremos el nombre que nosotros queramos. En Library
Path tenemos que estar en el directorio donde nosotros tengamos los archivos VHDL que
queremos simular. Esto de estar en el directorio donde tengamos los archivos VHDL es
importamte de lo contrario si ponemos otro directorio el programa nos dar error y no nos
funcionar.
16) Cuando tengamos los nombres correctos hacemos click en OK, y entonces nos
aparecer la siguiente figura. Figura 40.

46

Figura 40. Men 7

17) Ahora el siguiente paso ser incluir los ficheros que nosotros queremos
compilar.
18) Lo haremos de la siguiente manera, iremos a la barra de mens y
seleccionaremos Library > Add source files, como aparece en la siguiente figura. Figura
41.

47

Figura 41. Men 8

Al hacer click nos aparecer la siguiente figura. Figura 42

Figura 42. Men 9

48

19) En la figura anterior Figura 42 seleccionamos los ficheros VHDL que

queremos compilar, en mi caso pondr dos uno el programa en s de la ALU, y el otro que
ser el fichero de simulacin. En la prxima figura , figura 43 podremos observar que he
seleccionado los ficheros.

Figura 43. Men 10

En la figura anterior, figura 43 cuando vemos que tenemos seleccionados los

archivos, y se observa porque los tenemos de color azul, haremos un click en el botn OK,
y entonces nos aparecer la siguiente figura. Figura 44.

49

Figura 44. Men 11

Como se puede observar en la figura anterior figura 44, en la parte izquierda hay
un caseta dibujada llamada ejemplo y de ella cuelgan dos archivos con un punto rojo y
tachados. Estos dos archivos, son los que he seleccionado anteriormente para despus
compilarlos. La seal x tachada de color rojo antes de los nombres de los archivos,
significa que an no los hemos compilado.

20) El siguiente paso ser guardar los cambios File > Save.
21) Ahora compilaremos los ficheros de la siguiente manera. Nos ponemos encima
de ejemplo en nuestro caso. Si hubiramos puesto otro nombre nos aparecera el que
hubiramos puesto. Hacemos un click encima y entonces nos aparecer de color azul tal y
como se puede observar en la siguiente figura. Figura 45

50

Figura 45. Men 12

22) Entonces ahora tendremos que ir a Analyze > Analyze User Library. Figura 46

Figura 46. Men 13

51

Con el paso anterior lo que hemos hecho es compilar los ficheros, si vemos como
en este caso que no nos da error enntonces, pasaremos al siguiente paso. Si por el contrario
nos diera algn tipo de error tendramos que coregirlo, y despus volver a compilar.
23) Ahora una vez compilados los ficheros nos aparecer como sigue. Figura 47

Figura 47. Men 14

24) Una vez esto tenemos que guardar File > Save.
25) El siguiente paso ser salir de este programa File > Exit.
Una vez hecho esto ya tenemos los ficheros compilados, ahora tenemos que pasar al
siguiente paso que ser la simulacin de nuestro cdigo VHDL. Ahora con el programa
siguiente lo que haremos es sacar las grficas de nuestro programa.

52

4.1.2. Simulacin de ficheros

Cuando hayamos cerrado el programa anterior, nos quedaremos en la ventana de
Fusion, si no la tenemos abierta, la tendremos que volver a abrir, tal y como lo hemos
hecho antes.
1) Abrir en programas eProduct Designer.
2) Programable Design.
3) Escogemos el icono siguiente
Al pulsar en este icono entonces nos aparecer la siguiente figura. Figura 48

Figura 48. Menu 15

4) Ahora haremos File > Load Design, y nos aparecer la siguiente figura. Figura
49.

53

7
Figura 49. Men 15

5) Como nosotros queremos simular un fichero VHDL pondremos un ralla donde la

vemos en la figura anterior, entonces nosotros haremos click en Browse y seleccionaremos
el directorio donde nosotros tenemos los archivos que deseamos compilar, como se puede
observar en la figura siguiente. Figura 50
Si en vez de querer simular un fichero VHDL, quisiramos simular un fichero en
formato schematico o un fichero Verilog entonces tendramos que poner un cruz donde sea
necesario.
Como nuestro caso es VHDL la pondremos ah y entonces nos aparecer la siguiente
figura. Figura 50.

54

Figura 50. Men 16

6) Ahora tendremos que escoger la entidad de nuestro programa, que en este caso
estar dentro de Library ejemplo.lib. haremos click, y se nos abrir la carpeta, dentro de
esta carpeta, estarn todas las entidades, seleccionaremos la de mayor jerarqua. Como se
puede apreciar en la figura siguiente. Figura 51

55

Figura 51. Men 17

7) Aqu ahora una vez seleccionada le daremos a Aceptar, nos volveremos a la

figura 48 , pero entonces ya tendremos seleccionada nuestra carpeta y tambin el nombre
de la entidad que en este caso la de mayor jerarqua es sim que es la entidad de
simulacin. Como volvemos a la figura 48 no la volveremos a poner ahora, lo que
tendremos que hacer cuando volvamos a estar en la figura 48, es ponerle OK y entonces
nos aparecer la siguiente figura. Figura 52.

56

Figura 52. Men 18

8) Una vez aqu nos ponemos en la ventana Hierachy Viewer, y le damos con el
botn derecho del ratn click a el cuadrado que aparece con un signo +, y entonces nos
aparecer la siguiente figura. Figura 53

Figura 53. Men 19

57

9) Seleccionaremos la que hemos visto seleccionada en la figura 53. Display This

Scope in Vwave, y nos aparecer la siguiente figura. Figura 54

Figura 54. Men 20

10) Le daremos click al OK, y entonces el programa nos abrir automticamente el

Vwaves. Tendremos la siguiente figura. Figura 55

58

Figura 55. Men 21

11) Ahora como podemos observar en la izquierda tenemos el nombre de nuestras

seales. Ahora lo que tenemos que hacer es que nos salgan las seales dibujadas, y lo
haremos de la siguiente manera.
12) Nos iremos al programa Fusion que tenemos abierto y seleccionaremos
Simulate > Run como podemos observar en la siguiente figura. Figura 56

59

Figura 56. Men 22

Entonces nos aparecer la siguiente figura. Figura 57

Figura 57. Men 23

60

13) En la figura anterior figura 57 nos pone el tiempo que queremos simular nuestro
cdigo, en este caso pondremos 100ns y le daremos al botn Run
14) Cuando ya hemos dado al botn Run nos tenemos que ir al programa que
tenemos abierto Vwaves, y all observaremos que ya tenemos las seales, como se muestra
en la siguiente figura. Figura 58.

Figura 58. Men 24

En la izquiera que aparecen las seales, hay unas que aparecen con un signo +, esto
quiere decir que son vectores de bits, si queremos ver cada uno de los bits por separado
haremos click encima, entonces todas las seales y nos quedar el dibujo como el de la
figura siguiente. Figura 59.

61

Figura 59. Men 25

Ahora ya hemos podido observar como simular con este programa. Ahora solo nos
quedar hacer la sntesis, que se ver a continuacin.

62

4.1.3. Sintetizar archivos

Par sintetizar archivos seguiremos los siguientes pasos:
1) Abriremos eProduct Designer.
2) Seguidamente Programable Design.
3) Ahora Intelliflow

4) Ahora se nos abrir la siguiente ventana. Figura 60

Figura 60. Men 26

63

5) Seleccionaremos Set Up New Project Using The Wizard de la figura 60

anterior.
6) Le daremos al botn siguiente. Nos saldr el siguiente men. Figura 61.

Figura 61. Men 27

7) Ahora seleccionaremos VHDL de la figura 61 y tambin le daremos al botn

siguiente.
8) Ahora nos aparecer otro men dnde tendremos que escoger el tipo de chip que
tenemos que utilizar, le pondremos el que nosotros tengamos que utilizar.En este caso es
para el fabricante LATTICE. Entonces nos aparecer la siguiente figura. Figura 62.

64

Figura 62. Men 28

9) En la figura 62 donde pone select device haremos click y entonces entraremos en

un men y seleccionaremos el dispositvo que queremos, en nuestro caso el 1024 Ahora
seguidamente haremos click en Siguiente, nos aparecer la siguiente figura. Figura 63

Figura 63. Men 29

65

10) Seleccionaremos Gates en la figura 63 que quiere decir puertas y le daremos al

botn Finalizar
11) Ahora en el siguiente men tendremos que ponernos en el directorio donde
tenemos los archivos VHDL, y seleccionar el archivo que tengamos que sintetizar. Ser la
figura siguiente. Figura 64.

Figura 64. Men 30

12) Lo que tendremos que hacer en la figura 64 es poner el fichero que queremos
sintetizar. Solo se tiene que sintetizar el fichero de la ALU, y no el de simulacin, lo que
tenemos que hacer es ir a nuestro directorio, elegir el fichero y cuando lo tengamos
elegido, le damos al botn OK. Entonces nos aparecer la siguiente figura. Figura 65.

66

Figura 65. Menu 31

13) Ahora tenemos que seleccionar la entidad de mayor nivel que en nuestro caso
ser alu WORK y le daremos al botn OK, con lo cual nos quedar la siguiente figura.
Figura 66.

Figura 66. Men 32

67

14) Ahora lo que tendremos que hacer es ir haciendo los clicks a cada una de las
opciones como iremos viendo a continuacin hasta que terminemos. En la siguiente le
daremos a Perform Functional Simulation, y si todo va bien nos tienen que salir como
arriba el smbolo este verde que quiere decir que la cosa est bien, y si no tendramos que
arreglar lo que nos dijera. Ahora al hacer nos quedar la siguiente figura. Figura 67.

Figura 67. Men 33

El programa lo que nos ha hecho es abrirnos una serie de ventanas, ya que este
programa puede hacer muchas cosas, el te las abre por si quieres utilizar las distintas
opciones que tiene.
Lo que tendremos que hacer es cerrar todas las ventanas estas que nos aparecen
encima de la ventana principal, y solo quedarnos con la principal donde podremos observar
que nos a puesto el smbolo de correcto, esto nos dice que podremos pasar a la siguiente.
Tal y como se puede observar en la siguiente figura. Figura 68.

68

Figura 68. Men 34

15) Seguidamente haremos Implement and Perform Timing Simulation.

Tendremos lo siguiente. Figura 69

Figura 69. Men 35

69

16) Ahora haremos Implement and Perform Static Timing Analysis. Tendremos la
siguiente figura. Figura 70.

Figura 70. Men 36

Cuando esto nos lo haya hecho tambin nos abrir un fichero que son los retardos
que tiene el programa despus de sintetizarlo. Es un fichero como el de la siguiente figura.
Figura 71.

Figura 71. Menu 38

70

17) Por ltimo haremos el Implement and Create Board Level Symbol, y nos
aparecer la siguiente pantalla .Figura 72

Figura 72. Men 39

Cuando hayamos hecho esto tambin nos abrir un fichero donde nos pondr la
disposicin de las patas de la FPGA, es decir donde estn nuestras entradas y salidas. Ser
un fichero como el de la figura siguiente. Figura 73

Figura 73. Men 40

71

Conclusiones

Las conclusiones que se pueden sacar despus de haber hecho proyecto son, la
primera y ms importante que he aprendido un nuevo lenguaje de programacin, que es
muy interesante y por lo que he ledo se utiliza mucho para programar circuitos digitales.
En mi proyecto he encontrado muy interesante sobretodo programar en RTL,
transferencia entre registros, una vez tienes claros todos los esquemas combinacionales, es
relativamente sencillo programar en VHDL cuando lo tienes claro.
Por lo que hace referencia al programa eProduct Designer ha sido un poco difcil de
hacer funcionar, todo y que es un programa muy completo donde se pueden hacer multitud
de cosas como por ejemplo puedes ponerle la disposicin de patas que ms te interesa y el
te disea el circuito para que tengas aquella disposicin. Le puedes poner que te diga la
mxima frecuencia a que funciona tu circuito etc. Todo esto antes citado no lo he hecho
porque no era el objetivo de mi proyecto pero he visto que se puede hacer a parte de otras
cosas que no he tenido ni tiempo de mirarlo pero que seguro que son muy interesantes.
En el circuito puedes simular antes de sintetizar, y despus de sintetizar el circuito te
genera otro fichero VHDL que puedes volver a simular y aqu observas los retardos
obtenidos como consecuencia de la implementacin en puertas, que es donde aparecen los
retardos.
Lo que se tendra que hacer ahora es grabarlo a un micro y mirar si realmente
funciona, pero esto no se ha podido realizar ya que la aplicacin no funciona. Supongo que
sera muy interesante poderlo hacer.
En definitiva ha sido una experiencia muy interesante desde los dos puntos de vista
primero porque he aprendido a programar con un lenguaje distinto, y segunda porque he
hecho funcionar un programa bastante completo aunque no he podido mirar todas las
opciones que tiene, aunque puedo decir que tiene muchas.
Espero que haya sido un proyecto probechoso para la Universidad y para todas las
personas que estn interesadas en este lenguaje y en este programa.

72

Anexos
Anexo 1. Programa VHDL de la ALU
Library ieee;
Use ieee.std_logic_1164.ALL;
Library work;
Use work.ALL;
ENTITY alu IS
Port( a: in std_logic_vector(7 downto 0);
--Entrada de 8 bits
b: in std_logic_vector(7 downto 0);
--Entrada de 8 bits
resultat: out std_logic_vector(7 downto 0); --Resultado de
--la operacin
op0: in std_logic;
--Op0,Op1,Op2 sirven
op1: in std_logic;
--para seleccionar la operacin
op2: in std_logic
--que queremos realizar a la ALU
cout: out std_logic);
--Carry de salida
END alu;
ARCHITECTURE estructura OF alu IS
COMPONENT and_or

--Bloque AND/OR

Port(aa,bb: in std_logic_vector(7 downto 0); --Entradas del bloque

operacio0,operacio1: in std_logic;
--operacin a realizar
sor_and_or: out std_logic_vector(7 downto 0)); --salida
END COMPONENT;
COMPONENT suma_resta

--Bloque suma y resta

Port(aa,bb:in std_logic_vector(7 downto 0); --Entradas del bloque

operacio0,operacio1,operacio2: in std_logic; --Selecciona
--la operacin
cout:out std_logic;
--Carry de salida
sor_sum_res:out std_logic_vector(7 downto 0)); --Salida
END COMPONENT;
COMPONENT multiplexor

--Bloque multiplexor

Port(entr_a,entr_b:in std_logic_vector(7 downto 0); --Entradas del

bloque
operacio0,operacio1,operacio2:in std_logic;
--Selecciona la
operacin
sortida:out std_logic_vector(7 downto 0));
--Salida
END COMPONENT;
SIGNAL x,y:std_logic_vector (7 DOWNTO 0);

--Variables intermedias
--para unir
--los 3 bloques anteriores

BEGIN
U1:and_or port map(a,b,op0,op1,y);
--Paso de parmetros
U2:suma_resta port map(a,b,op0,op1,op2,cout,x);--Paso de parmetros
U3:multiplexor port map(x,y,op0,op1,op2,resultat); --Paso de
parmetros

73

END estructura;

Library ieee;
Use ieee.std_logic_1164.ALL;
Library work;
Use work.ALL;

ENTITY and_or IS

--Bloque que define las entradas salidas de la AND y la

OR

Port( aa:in std_logic_vector(7 downto 0); --Vector de 8 bits de entrada

bb:in std_logic_vector(7 downto 0); --Vector de 8 bits de entrada
operacio0:in std_logic;
--Seleccionamos si queremos hacer
la operacin AND
operacio1:in std_logic;
--la OR o ninguna de las dos.
sor_and_or: out std_logic_vector(7 downto 0));--Salida del bloque
END and_or;

Library ieee;
Use ieee.std_logic_1164.ALL;
Library work;
Use work.ALL;

ENTITY suma_resta IS

--Bloque que define las entradas y salidas de la

suma y la resta

Port( aa:in std_logic_vector(7 downto 0); --Vector de entrada de 8 bits

bb:in std_logic_vector(7 downto 0); --Vector de entrada de 8 bits
operacio0:in std_logic
--En estas tres variables seleccionamos
operacio1:in std_logic;
--la operacin que tenemos que realizar
operacio2:in std_logic;
cout:out std_logic;
--Carry de salida
sor_sum_res: out std_logic_vector(7 downto 0));--Salida del bloque
END suma_resta;

Library ieee;
Use ieee.std_logic_1164.ALL;
Library work;
Use work.ALL;
ENTITY multiplexor IS

--Bloque multiplexor

Port( entr_a:in std_logic_vector(7 downto 0);

--Vector de entrada de 8
bits
entr_b:in std_logic_vector(7 downto 0); --Vector de entrada de 8
bits
operacio0:in std_logic;
--Seleccionamos la
operacin que queremos
realizar

74

operacio1:in std_logic;
operacio2:in std_logic;
sortida: out std_logic_vector(7 downto 0)); --Salida
END multiplexor;

ARCHITECTURE andor OF and_or IS

--Definicin de la funcin del bloque

SIGNAL inter_op_0:std_logic; --Guarda el valor de la operacio0 negada

SIGNAL inter_op_1:std_logic; --Guarda el valor de la operacio1 negada
SIGNAL funcio:std_logic;
--Le decimos si tiene que hacer la AND o
--la OR
BEGIN
inter_op_0<=not operacio0;
inter_op_1<=not operacio1;
funcio<=inter_op_0 and inter_op_1;
reg1(0)<=aa(0) and bb(0);
--Realizamos la AND y la OR del bit 0
reg2(0)<=aa(0) and funcio;
reg3(0)<=bb(0) and funcio;
sor_and_or(0)<=reg1(0) or reg2(0) or reg3(0);
reg1(1)<=aa(1) and bb(1);
--Realizamos la AND y la OR del bit 1
reg2(1)<=aa(1) and funcio;
reg3(1)<=bb(1) and funcio;
sor_and_or(1)<=reg1(1) or reg2(1) or reg3(1);
reg1(2)<=aa(2) and bb(2);
--Realizamos la AND y la OR del bit 2
reg2(2)<=aa(2) and funcio;
reg3(2)<=bb(2) and funcio;
sor_and_or(2)<=reg1(2) or reg2(2) or reg3(2);
reg1(3)<=aa(3) and bb(3);
--Realizamos la AND y la OR del bit 3
reg2(3)<=aa(3) and funcio;
reg3(3)<=bb(3) and funcio;
sor_and_or(3)<=reg1(3) or reg2(3) or reg3(3);
reg1(4)<=aa(4) and bb(4);
--Realizamos la AND y la OR del bit 4
reg2(4)<=aa(4) and funcio;
reg3(4)<=bb(4) and funcio;
sor_and_or(4)<=reg1(4) or reg2(4) or reg3(4);
reg1(5)<=aa(5) and bb(5);
--Realizamos la AND y la OR del bit 5
reg2(5)<=aa(5) and funcio;
reg3(5)<=bb(5) and funcio;
sor_and_or(5)<=reg1(5) or reg2(5) or reg3(5);
reg1(6)<=aa(6) and bb(6);
--Realizamos la AND y la OR del bit 6
reg2(6)<=aa(6) and funcio;
reg3(6)<=bb(6) and funcio;
sor_and_or(6)<=reg1(6) or reg2(6) or reg3(6);
reg1(7)<=aa(7) and bb(7);
--Realizamos la AND y la OR del bit 7
reg2(7)<=aa(7) and funcio;
reg3(7)<=bb(7) and funcio;
sor_and_or(7)<=reg1(7) or reg2(7) or reg3(7);

75

END andor;

ARCHITECTURE sum_rest OF suma_resta IS

SIGNAL
SIGNAL
SIGNAL
SIGNAL

opera0:std_logic; --Guardamos el valor de la operacio0 negada

opera1:std_logic; --Guardamos el valor de la operacio1 negada
opera2:std_logic; --Guardamos el valor de la operacio2 negada
invb:std_logic; --Bit para saber si tenemos que hacer la
inversa de B
SIGNAL clra:std_logic;
--Bit para poner el vector A a 0
SIGNAL clranot:std_logic; --Guardamos el valor del clra negado
SIGNAL cin:std_logic_vector(7 downto 0); --Carry de entrada a cada
uno de los 7 sumadores
SIGNAL a_entr_sum:std_logic_vector(7 downto 0);
SIGNAL
SIGNAL

SIGNAL
SIGNAL

--Entrada del vector

A al sumador
b_entr_sum:std_logic_vector(7 downto 0); --Entrada del vector
B al sumador
bit0:std_logic_vector(7 downto 0);
--Bits para realizar
una NAND de tres
entradas
bit1:std_logic_vector(7 downto 0);
bit2:std_logic_vector(7 downto 0);

BEGIN
opera0<=not operacio0;
opera1<=not operacio1;
opera2<=not operacio2;
clra<=opera0 and opera1;
clranot<=not clra;
invb<=opera0 and opera2;
cin(0)<=opera2 and operacio1;
--OPERACIONES ANTES DE ENTRAR LOS DATOS AL SUMADOR
a_entr_sum(0)<=clranot and aa(0);
b_entr_sum(0)<=invb xor bb(0);
a_entr_sum(1)<=clranot and aa(1);
b_entr_sum(1)<=invb xor bb(1);
a_entr_sum(2)<=clranot and aa(2);
b_entr_sum(2)<=invb xor bb(2);
a_entr_sum(3)<=clranot and aa(3);
b_entr_sum(3)<=invb xor bb(3);
a_entr_sum(4)<=clranot and aa(4);
b_entr_sum(4)<=invb xor bb(4);
a_entr_sum(5)<=clranot and aa(5);
b_entr_sum(5)<=invb xor bb(5);
a_entr_sum(6)<=clranot and aa(6);
b_entr_sum(6)<=invb xor bb(6);
a_entr_sum(7)<=clranot and aa(7);
b_entr_sum(7)<=invb xor bb(7);

76

--OPERACIONES DENTRO DEL SUMADOR

sor_sum_res(0)<=cin(0) xor (a_entr_sum(0) xor b_entr_sum(0));
bit0(0)<=a_entr_sum(0) nand b_entr_sum(0);
bit1(0)<=b_entr_sum(0) nand cin(0);
bit2(0)<=a_entr_sum(0) nand cin(0);
cin(1)<=not(bit0(0) and bit1(0) and bit2(0));
sor_sum_res(1)<=cin(1) xor (a_entr_sum(1) xor b_entr_sum(1));
bit0(1)<=a_entr_sum(1) nand b_entr_sum(0);
bit1(1)<=b_entr_sum(1) nand cin(1);
bit2(1)<=a_entr_sum(1) nand cin(1);
cin(2)<= not(bit0(1) and bit1(1) and bit2(1));

sor_sum_res(2)<=cin(2) xor (a_entr_sum(2) xor b_entr_sum(2));

bit0(2)<=a_entr_sum(2) nand b_entr_sum(2);
bit1(2)<=b_entr_sum(2) nand cin(2);
bit2(2)<=a_entr_sum(2) nand cin(2);
cin(3)<= not(bit0(2) and bit1(2) and bit2(2));

sor_sum_res(3)<=cin(3) xor (a_entr_sum(3) xor b_entr_sum(3));

bit0(3)<=a_entr_sum(3) nand b_entr_sum(3);
bit1(3)<=b_entr_sum(3) nand cin(3);
bit2(3)<=a_entr_sum(3) nand cin(3);
cin(4)<= not(bit0(3) and bit1(3) and bit2(3));

sor_sum_res(4)<=cin(4) xor (a_entr_sum(4) xor b_entr_sum(4));

bit0(4)<=a_entr_sum(4) nand b_entr_sum(4);
bit1(4)<=b_entr_sum(4) nand cin(4);
bit2(4)<=a_entr_sum(4) nand cin(4);
cin(5)<= not(bit0(4) and bit1(4) and bit2(4));

sor_sum_res(5)<=cin(5) xor (a_entr_sum(5) xor b_entr_sum(5));

bit0(5)<=a_entr_sum(5) nand b_entr_sum(5);
bit1(5)<=b_entr_sum(5) nand cin(5);
bit2(5)<=a_entr_sum(5) nand cin(5);
cin(6)<= not(bit0(5) and bit1(5) and bit2(5));

sor_sum_res(6)<=cin(6) xor (a_entr_sum(6) xor b_entr_sum(6));

bit0(6)<=a_entr_sum(6) nand b_entr_sum(6);
bit1(6)<=b_entr_sum(6) nand cin(6);
bit2(6)<=a_entr_sum(6) nand cin(6);
cin(7)<= not(bit0(6) and bit1(6) and bit2(6));

sor_sum_res(7)<=cin(7)
bit0(7)<=a_entr_sum(7)
bit1(7)<=b_entr_sum(7)
bit2(7)<=a_entr_sum(7)
cout<= not(bit0(7) and

xor (a_entr_sum(7) xor b_entr_sum(7));

nand b_entr_sum(7);
nand cin(7);
nand cin(7);
bit1(7) and bit2(7));

END sum_rest;

ARCHITECTURE multi OF multiplexor IS

77

SIGNAL regi1:std_logic;

SIGNAL

SIGNAL
SIGNAL
SIGNAL
SIGNAL
SIGNAL

SIGNAL
SIGNAL

--Guardamos el valor de una AND de tres

entrades correspondiente a la operacin a
realizar
regi2:std_logic; --Guardamos el valor de una AND de tres
entradas correspondiente a la operacin a
realizar
mux:std_logic;
--Bit que dice que entrada tieneque coger el
multiplexor
nmux:std_logic;
--Negacin de la variable mux
sor0:std_logic_vector(7 downto 0); --Canal 0 del multiplexor
sor1:std_logic_vector(7 downto 0); --Canal 1 del multiplexor
opera0:std_logic; --Canal que tiene que coger el multiplexor
dependiendo de la operacin que se tenga
que realizar
opera1:std_logic;
opera2:std_logic;

BEGIN
opera0<=not operacio0;
opera1<=not operacio1;
opera2<=not operacio2;
regi1<=operacio0 and operacio1 and opera2;
regi2<=opera0 and opera1 and operacio2;
mux<=regi1 or regi2;
nmux<=not mux;
sor0(0)<=nmux and entr_a(0);
sor1(0)<=mux and entr_b(0);
sortida(0)<=sor0(0) or sor1(0);

sor0(1)<=nmux and entr_a(1);

sor1(1)<=mux and entr_b(1);
sortida(1)<=sor0(1) or sor1(1);

sor0(2)<=nmux and entr_a(2);

sor1(2)<=mux and entr_b(2);
sortida(2)<=sor0(2) or sor1(2);

sor0(3)<=nmux and entr_a(3);

sor1(3)<=mux and entr_b(3);
sortida(3)<=sor0(3) or sor1(3);

sor0(4)<=nmux and entr_a(4);

sor1(4)<=mux and entr_b(4);
sortida(4)<=sor0(4) or sor1(4);

sor0(5)<=nmux and entr_a(5);

sor1(5)<=mux and entr_b(5);
sortida(5)<=sor0(5) or sor1(5);

--Salida del multiplexor

correspondiente al bit 0

--Salida del multiplexor

correspondiente al bit 1

--Salida del multiplexor

correspondiente al bit 2

--Salida del multiplexor

correspondiente al bit 3

--Salida del multiplexor

correspondiente al bit 4

--Salida del multiplexor

correspondiente al bit 5

78

sor0(6)<=nmux and entr_a(6);

sor1(6)<=mux and entr_b(6);
sortida(6)<=sor0(6) or sor1(6);

sor0(7)<=nmux and entr_a(7);

sor1(7)<=mux and entr_b(7);
sortida(7)<=sor0(7) or sor1(7);

--Salida del multiplexor

correspondiente al bit 6

--Salida del multiplexor

correspondiente al bit 7

END multi;

79

Anexo 2. Programa de simulacin de la ALU

library IEEE;
use IEEE.STD_LOGIC_1164.all;
library work;
use work.all;
ENTITY sim IS
END sim;

--Entidad simulacin

ARCHITECTURE proves OF sim IS

SIGNAL
SIGNAL
SIGNAL
SIGNAL
SIGNAL
SIGNAL
SIGNAL

a: std_logic_vector (7 downto 0);

b: std_logic_vector (7 downto 0);
resultat: std_logic_vector (7 downto 0);
op0: std_logic;
op1: std_logic;
op2: std_logic;
cout: std_logic;

COMPONENT alu
Port (a: in std_logic_vector(7 downto 0);
b: in std_logic_vector(7 downto 0);
resultat: out std_logic_vector(7 downto 0);
op0: in std_logic;
op1: in std_logic;
op2: in std_logic;
cout: out std_logic);

--Entradas y salidas de la ALU

END COMPONENT;
SIGNAL variable end_test: boolean:=false;
constant T:time:=10ns; --Freq=(1/T)=100Mhz
BEGIN
U4: alu port map(a,b,resultat,op0,op1,op2,cout); --Paso de parmetros al Bloque
ALU
proceso: process BEGIN
a<="00000000";
b<="00000000";
op0<='0';
op1<='0';
op2<='0';

--Sucesin de pruebas para mirar la salida final

wait for T;
a<="11111111";
b<="00000000";
op0<='1';
op1<='0';
op2<='0';

wait for T;
a<="11111111";

80

b<="11111111";
op0<='0';
op1<='1';
op2<='0';
wait for T;
a<="11111111";
b<="00011100";
op0<='1';
op1<='1';
op2<='0';
wait for T;
a<="11111111";
b<="11111111";
op0<='0';
op1<='0';
op2<='1';
wait for T;
a<="00001101";
b<="00110011";
op0<='0';
op1<='0';
op2<='0';
wait for T;
a<="01010101";
b<="10101010";
op0<='1';
op1<='0';
op2<='0';
wait for T;
a<="01010101";
b<="10101010";
op0<='1';
op1<='1';
op2<='0';
wait for T;
end_test:=true;
wait;
END process;
END proves;

81

Anexo 3. Fichero de retardos despus de la sntesis

En este fichero podemos observar los retardos que obtendr dependiendo de las
entradas que yo le ponga

82

Anexo 4. Disposicin de las patas de la FPGA

De esta forma es tal y como ha quedado nuestra ALU. La disposicin de las patas es
la que se indica en la figura.
Con este programa tambin podemos poner con unas opciones si nos interesa por
algn motivo la disposicin de las patas segn nos convenga, pero en nuestro caso como
no lo necesitamos, lo hemos puesto tal y como nos lo ha dado el programa.

83

Anexo 5. Grficas de Salida

84

85

86

Como se puede observar en las grficas, el resultado es correcto de acuerdo con las
entrada a y b junto con las operaciones que queremos que haga dependiendo de lo que
ponemos en las variables Op.
Tambin se puede observar que cambiamos de valor cada 10 ns.

87

Bibliografa

1.

Lenguaje para la sntesis y modelado de circuitos VHDL. Autores : Fernando

Pardo y Jose A. Boluda. Editorial RA-MA.

2.

Pgina Web de la Universidad de Guadalajara

3.

Pgina Web de la Universidad Politcnica de Valencia

4.

Tutoriales y ayudas del programa eProduct Designer

88