1453 Pub

Diseo sobre FPGA de una Unidad Aritmtica Decimal
TITULACIN: Ingeniera Tcnica Industrial en Electrnica Industrial

AUTOR: Alejandro Baena Alonso

DIRECTOR: Jean-Pierre Deschamps

FECHA: Febrero / 2010


1. NDICE GENERAL

Diseo sobre FPGA de una Unidad Aritmtica Decimal ndice general

- 3 -
2. INTRODUCCIN
2.1 Objetivos del proyecto ............................................................................................................... 7
2.2 Aspectos bsicos ......................................................................................................................... 7
2.2.1 Aritmtica decimal.............................................................................................................. 7
2.2.2 Cdigo decimal codificado en binario (BCD) .................................................................... 8
2.2.3 Dispositivos programables.................................................................................................. 8
2.3 Diseo de Sistemas Electrnicos ............................................................................................... 9
2.3.1 Tendencias generales en Diseo Electrnico...................................................................... 9
2.3.2 Lenguajes de descripcin del hardware.............................................................................. 9
2.3.2.1 Qu son los lenguajes de descripcin del hardware?............................................. 9
2.3.2.2 El lenguaje VHDL................................................................................................... 10
2.3.2.2.1 Introduccin al lenguaje VHDL .................................................................... 10
2.3.2.2.2 Caractersticas............................................................................................... 10
2.3.2.2.3 Niveles de descripcin ................................................................................... 11
2.3.2.2.4 Estructura de una descripcin....................................................................... 11
2.3.2.2.5 Metodologa de diseo................................................................................... 12
2.3.3 Dispositivos lgicos programables ................................................................................... 13
2.3.4 Componentes IP (IP cores)............................................................................................... 15
2.3.5 Prototipado rpido ............................................................................................................ 16
2.4 Spartan-3E Starter Kit Board ................................................................................................... 16

3. MEMORIA DESCRIPTIVA
3.1 La Unidad Aritmtica Decimal ............................................................................................... 20
3.2 Bloques de la unidad................................................................................................................ 21
3.2.1 Sumador/Restador............................................................................................................. 21
3.2.1.1 Sumador .................................................................................................................. 21
3.2.1.1.1 Sumador de 1 dgito BCD (bloque one_digit_adder.vhd)......................... 21
3.2.1.1.2 Sumador de n dgitos decimales .................................................................... 24
3.2.1.2 Restador............................................................................................................... 26
3.2.1.2.1 Clculo del complemento a 9 (bloque nine_complement.vhd).................. 27
3.2.1.2.2 Sumador/Restador en complemento a 10
n
..................................................... 28
3.2.1.3 Sumador/Restador, representacin con signo y magnitud (bloque
n_adder_subs.vhd).......................................................................................................... 29
3.2.2 Multiplicador.. .......................................................................................................... 32
3.2.2.1 Multiplicador de 1x1 dgitos BCD (bloque one_digit_multiplier.vhd)................ 32
3.2.2.2 Multiplicador de Nx1 dgitos BCD (bloquen_by_one_multiplier.vhd)............... 34
3.2.2.3 Multiplicador de NxM dgitos BCD (bloquen_by_m_multiplier.vhd) ................ 37
3.2.3 Divisor .............................................................................................................................. 41
3.2.3.1 Algoritmo de divisin binaria ................................................................................. 41
3.2.3.2 Algoritmo de divisin BCD..................................................................................... 42
3.2.3.3 Error generado........................................................................................................ 42
3.2.3.4 Divisor BCD (bloque divider.vhd)...................................................................... 43
3.3 Diseo de la Unidad Aritmtica Decimal ............................................................................... 48

Diseo sobre FPGA de una Unidad Aritmtica Decimal ndice general

- 4 -
4. MEMORIA EXPERIMENTAL
4.1 Descripcin del proceso ........................................................................................................... 54
4.2 Especificaciones ........................................................................................................................ 54
4.3 Elementos necesarios................................................................................................................ 55
4.4 Arquitectura a desarrollar ...................................................................................................... 55
4.5 Mdulos IP de terceros utilizados........................................................................................... 57
4.5.1 Microcontrolador PicoBlaze (mdulo kcpsm.vhd)........................................................ 57
4.5.2 Interfaz LCD (mdulo lcd_interface.vhd)..................................................................... 58
4.6 Memoria de programa (mdulo program_memory.vhd) ................................................... 60
4.7 Generacin del circuito (mdulo main.vhd) ....................................................................... 62
4.8 Asignacin de pines en la FPGA (archivo pins.ucf) .......................................................... 63
4.9 Implementacin en la FPGA................................................................................................... 65
4.9.1 Generacin del archivo..................................................................................................... 66
4.9.2 Implementacin en la FPGA ............................................................................................ 68

5. ANEXOS
5.1 Modelos VHDL......................................................................................................................... 72
5.1.1 Sumador de 1 dgito BCD (one_digit_adder.vhd)............................................................ 72
5.1.2 Complemento a 9 (nine_complement.vhd) ....................................................................... 73
5.1.3 Sumador/Restador de n dgitos decimales (n_adder_subs.vhd) ....................................... 73
5.1.4 Multiplicador de 1x1 dgitos BCD (one_digit_multiplier.vhd) ........................................ 75
5.1.5 Multiplicador de Nx1 dgitos BCD (n_by_one_multiplier.vhd) ....................................... 76
5.1.6 Multiplicador de NxM dgitos BCD (n_by_m_multiplier.vhd)......................................... 78
5.1.7 Divisor BCD (divider.vhd) ............................................................................................... 80
5.1.8 Unidad Aritmtica Decimal (arithmetic_unit.vhd) ........................................................... 83
5.1.9 Memoria de programa (program_memory.vhd) ............................................................... 86
5.1.10 Circuito completo (main.vhd) ......................................................................................... 89
5.2 Programa en lenguaje ensamblador (decimal_unit.asm) ...................................................... 94
5.3 Asignacin de pines en la Spartan-3E (pins.ucf) .................................................................... 97

6. BIBLIOGRAFA........................................................................................................................ 99


2. INTRODUCCIN

Diseo sobre FPGA de una Unidad Aritmtica Decimal Introduccin

- 6 -
2.1 Objetivos del proyecto ............................................................................................................... 7
2.2 Aspectos bsicos ......................................................................................................................... 7
2.2.1 Aritmtica decimal.............................................................................................................. 7
2.2.2 Cdigo decimal codificado en binario (BCD) .................................................................... 8
2.2.3 Dispositivos programables.................................................................................................. 8
2.3 Diseo de Sistemas Electrnicos ............................................................................................... 9
2.3.1 Tendencias generales en Diseo Electrnico...................................................................... 9
2.3.2 Lenguajes de descripcin del hardware.............................................................................. 9
2.3.2.1 Qu son los lenguajes de descripcin del hardware?............................................. 9
2.3.2.2 El lenguaje VHDL................................................................................................... 10
2.3.2.2.1 Introduccin al lenguaje VHDL .................................................................... 10
2.3.2.2.2 Caractersticas............................................................................................... 10
2.3.2.2.3 Niveles de descripcin ................................................................................... 11
2.3.2.2.4 Estructura de una descripcin....................................................................... 11
2.3.2.2.5 Metodologa de diseo................................................................................... 12
2.3.3 Dispositivos lgicos programables ................................................................................... 13
2.3.4 Componentes IP (IP cores)............................................................................................... 15
2.3.5 Prototipado rpido ............................................................................................................ 16
2.4 Spartan-3E Starter Kit Board ................................................................................................... 16


- 7 -
2.1 Objetivos del proyecto

El objetivo de este proyecto es el diseo del modelo VHDL de una Unidad Aritmtica
Decimal, que pueda funcionar como coprocesador/acelerador dentro de otro sistema ms
complejo. Por tanto, se trata de un componente virtual utilizable en cualquier tipo de
sistemas que requieran operar en decimal.

Dicha unidad permitir realizar las operaciones aritmticas bsicas siempre operando en
decimal como son la suma, resta, multiplicacin y divisin de dos valores decimales.

Posteriormente, y a modo de testeo del modelo resultante, se implementar sobre una
FPGA, la SPARTAN-3E modelo XC3S500E de XILINX.

Para la creacin y simulacin de la unidad aritmtica decimal se ha utilizado el programa
MODELSIM PE en su versin STUDENT EDITION. Para la implementacin en la FPGA,
se ha utilizado el ensamblador PBLAZ IDE para la creacin de la memoria de programa, y
el paquete ISE DESIGN SUITE de XILINX para la sntesis y grabacin del cdigo en la
placa de pruebas.

2.2 Aspectos bsicos

2.2.1 Aritmtica decimal

Los sistemas que operan en decimal son preferibles a los que lo hacen en binario en un
gran nmero de aplicaciones aritmticas informticas. El motivo principal no es la
complejidad de las interfaces de codificacin y decodificacin (que tambin influye), sino
principalmente la falta de precisin y claridad de los resultados.

La aritmtica decimal desempea un papel clave en el procesamiento de datos en diversos
entornos, ya sean comerciales, financieros o de aplicaciones basadas en Internet, entre
otros. Y las prestaciones que estos requieren no quedan satisfechas con las unidades
convencionales que internamente operan en binario. En consecuencia, los procesadores de
propsito general que incluyen la implementacin hardware de aritmtica decimal estn
adquiriendo relevancia

Actualmente, el sistema decimal codificado en binario (BCD) es utilizado en el diseo de
algoritmos de aritmtica decimal; aunque otros sistemas de codificacin podran resultar
interesantes, el sistema BCD parece la mejor opcin por el momento.


- 8 -
2.2.2 Cdigo decimal codificado en binario (BCD)

El cdigo decimal codificado en binario (BCD, Binary Coded Decimal, tambin conocido
como cdigo 8421) codifica los dgitos decimales del 0 al 9 mediante sus representaciones
binarias sin signo de 4 bits, desde 0000 a 1001. Las palabras de cdigo restantes, de 1010 a
1111, no se utilizan. Las conversiones entre las representaciones BCD y decimal son
triviales e implican la sustitucin directa de cuatro bits por cada dgito decimal.

El decimal codificado en binario es un cdigo ponderado, puesto que cada dgito decimal
puede obtenerse a partir de su palabra de cdigo asignando un peso fijo a cada bit de
palabra de cdigo. Los pesos para los bits BCD son 8, 4, 2, 1, y por esta razn el cdigo se
denomina en ocasiones cdigo 8421.

En la siguiente tabla se representa la correspondencia entre los nmeros decimales y las
combinaciones binarias del cdigo BCD:

Decimal BCD
0 0000
1 0001
2 0010
3 0011
4 0100
5 0101
6 0110
7 0111
8 1000
9 1001

Tabla 2.1. Correspondencia entre los dgitos decimales y cdigo BCD

2.2.3 Dispositivos programables

Hoy en da, las FPGA (Field Programmable Gate Arrays, de las que se hablar ms
adelante) son una de las tecnologas disponibles para el desarrollo de sistemas electrnicos.
Representan una atractiva opcin para la produccin de pequeas cantidades ya que sus
costes fijos (coste del prototipo, de la primera unidad) son bastante ms bajos que los
correspondientes en ASIC (Application-Specific Integrated Circuit, circuitos integrados de
aplicacin especfica). Adems, en pos de reducir el tamao y por tanto el coste unitario,
una posibilidad interesante es reconfigurarlas mientras operan de modo que el mismo
dispositivo pueda ejecutar diferentes funciones predefinidas.


- 9 -
2.3 Diseo de Sistemas Electrnicos

2.3.1 Tendencias generales en Diseo Electrnico

Actualmente los sistemas electrnicos estn muy presentes en la mayora de mbitos,
desde la electrnica de consumo a los sistemas de control industrial, pasando por las
aplicaciones para automocin o seguridad, y un largo etctera

El problema principal radica en la complejidad del diseo de muchos de los elementos,
donde se exige, por ejemplo, que sean de fcil utilizacin y adaptables a varias
aplicaciones, que consuman pocos recursos y que puedan estar rpidamente a la venta

La tecnologa actual de circuitos integrados permite realizar e integrar estos complejos
sistemas en muy poco espacio; son los llamados sistemas empotrados (o embebidos) o SoC
(System on Chip). Estos sistemas, como pueden ser los ASIC (Application-Specific
Integrated Circuit) o las FPGA, permiten integrar en el mismo dispositivo uno o ms
microprocesadores o microcontroladores, coprocesadores, diversos bloques de memoria de
diferentes tipos, perifricos de entrada-salida, osciladores, buses para interconectar los
bloques, etc.

Estos sistemas embebidos para aplicaciones especficas incluyen hardware y software
especfico. En el caso de las FPGA, al ser dispositivos reconfigurables, son altamente tiles
para el desarrollo de prototipos o pequeas cantidades, a un precio razonablemente bajo.

2.3.2 Lenguajes de descripcin del hardware

2.3.2.1 Qu son los lenguajes de descripcin del hardware?

Los lenguajes de descripcin hardware (HDL, Hardware Description Language) surgen de
la necesidad de los diseadores de disponer de un conjunto de herramientas que permitan
describir los sistemas digitales de formas diferentes, facilitando el dilogo entre los propios
diseadores, aunque tambin entre las herramientas de diseo asistido por ordenador
(CAD, Computer-Aided Design) y entre diseadores y herramientas.

Los sistemas de desarrollo basados en lenguajes HDL permiten especificar y modelar la
estructura y funcin de un circuito digital; incluyen herramientas para compilar, simular y
sintetizar sistemas digitales. Estas herramientas de programacin se utilizan para
comprobar el funcionamiento del modelo antes de que sea construido.

Actualmente, los lenguajes HDL ms utilizados son VHDL y Verilog, ya que estn
estandarizados por el IEEE (Institute of Electrical and Electronic Engineers). Nosotros nos
centraremos en el primero de ellos.


- 10 -
2.3.2.2 El lenguaje VHDL

2.3.2.2.1 Introduccin al lenguaje VHDL

VHDL proviene de VHSIC (Very High Speed Integrated Circuit) Hardware Description
Language. VHDL es un lenguaje de descripcin del hardware que puede utilizarse para
modelar, documentar, simular, verificar y sintetizar un sistema digital. Por tanto, abarca el
ciclo completo de diseo (salvo el trazado fsico o layout) desde las especificaciones
iniciales hasta la construccin del prototipo hardware. Proporciona el soporte necesario
para especificar su comportamiento o estructura, incluyendo jerarquas. Asimismo, es til
para metodologas de diseo ascendentes (bottom-up) como, sobre todo, descendentes (top-
down).

La semntica y construcciones del lenguaje permiten tambin disear con facilidad bancos
de prueba (test-benches), mediante los que se lleva a cabo la simulacin de los sistemas
modelados.

2.3.2.2.2 Caractersticas

VDHL es un lenguaje de descripcin hardware de mbito general derivado del lenguaje de
alto nivel ADA (que es el lenguaje para programar sistemas en tiempo real por excelencia).
Dispone de tipos abstractos para definir el formato y valores de seales, variables,
constantes, etc., y proporciona amplias facilidades para la realizacin de algoritmos.

Admite casi todos los niveles de descripcin, desde el algortmico (nivel ms alto) hasta el
lgico (nivel ms bajo). Para ello proporciona herramientas semnticas y sintcticas que se
pueden agrupar as:

Aquellas orientadas a las descripciones del comportamiento del circuito.
Aquellas orientas a la descripcin de las relaciones entre los distintos bloques
de un circuito, es decir, su estructura.

Al realizar una descripcin VHDL es importante elegir adecuadamente el nivel de funcin
del objetivo perseguido. Por ejemplo, si se pretende sintetizar la descripcin realizada, es
decir, si el objetivo final es obtener un conjunto de puertas e interconexiones, no se debe
emplear el nivel algortmico, pues en general las herramientas actuales de sntesis no
procesan de forma eficiente estas descripciones. Sin embargo, este nivel s es adecuado
cuando el objetivo es comprobar que un sistema complejo funciona correctamente, pues se
puede describir y simular de una forma rpida y eficaz.


- 11 -
2.3.2.2.3 Niveles de descripcin

El lenguaje VHDL presenta tres mtodos bsicos para describir un circuito digital por
software:

El nivel algortmico es el que presenta un mayor grado de abstraccin (alto nivel).
Aqu el diseador solo describe el comportamiento del sistema, sin preocuparse de
las seales o componentes internos del mismo. Tambin llamado nivel de
comportamiento o behavior.

El nivel RTL (Register-Transfer Level, nivel de transferencia de registros)
proporciona un cierto grado de abstraccin con respecto al hardware, pero el
diseador se ve obligado a describir las distintas seales que interactan en un
circuito y su comportamiento en funcin de las entradas por medio de ecuaciones
lgicas y sentencias de asignacin. Tambin conocido como nivel de flujo de datos.

El nivel lgico describe la estructura interna de un circuito basndose en unos
componentes bsicos definidos previamente (equivaldra a un diagrama lgico).

2.3.2.2.4 Estructura de una descripcin

Toda descripcin en VHDL est constituida al menos por tres tipos de elementos:
bibliotecas (libraries), entidades (entities) y arquitecturas (architectures).

El diseador generalmente realiza la descripcin de las entidades empleando elementos
almacenados en las bibliotecas.

En la declaracin de la entidad se define el diseo como si fuera un producto encapsulado,
indicando el nmero de pines, los puertos de entrada y salida. La entidad puede definir
bien las entradas y salidas de un circuito integrado por disear o puede definir la interfaz
de un mdulo que ser utilizado en un diseo ms grande.

Para que la descripcin de un circuito sea completa se necesita, adems de su declaracin
como entidad, una especificacin de su funcionamiento. La arquitectura es la encargada de
ello. Es posible realizar diversas descripciones del funcionamiento del circuito, por lo que
pueden existir varias arquitecturas para una misma entidad.


- 12 -
2.3.2.2.5 Metodologa de diseo

La Figura 2.1 muestra el flujo de diseo de un circuito en VHDL, desde su concepcin
hasta su fabricacin.

Figura 2.1. Flujo de diseo en VHDL

Una vez finalizada la prueba del concepto, se pasa al diseo detallado. Dependiendo de la
herramienta de sntesis que se utilice y de las especificaciones del circuito, la descripcin
VHDL estar desarrollada en un nivel de abstraccin mayor o menor (desde un nivel
algortmico a uno lgico).

Por ltimo se aborda la sntesis del circuito, es decir, el paso de una descripcin en VHDL
a un circuito real. El proceso de diseo puede terminar antes si el objetivo final no es la
fabricacin sino, por ejemplo, la creacin de componentes de biblioteca para uso posterior.


- 13 -
2.3.3 Dispositivos lgicos programables

Existen dos grandes grupos de dispositivos lgicos programables: PLDs (Programmable
Logic Device, dispositivo lgico programable) y FPGAs (Field Programmable Gate Array,
matriz de puertas configurables).

Figura 2.2. Tipos de lgica programable

Los PLDs estn basados en una matriz AND + OR. Dentro de los PLDs encontramos las
PROM (Programmable Read Only Memory), las PAL (Programmable Logic Array) y las
PAL (Programmable Array Logic).

Figura 2.3. Familia de los PLD

Dentro de las PAL se encuentran los CPLDs (Complex PLD), compuestos por la
integracin de PLDs (PAL/GAL o PLA). Estn formados por bloques lgicos y matrices
de interruptores, donde cada bloque lgico corresponde a un PLD.

Figura 2.4. Ejemplo de arquitectura de CPLD (con 4 elementos lgicos o bloques programables)


- 14 -
Las FPGA estn compuestas por una matriz de elementos lgicos cuya interconexin y
funcionalidad se puede programar. En comparacin con los dispositivos CPLD, difieren en
la arquitectura, no utilizan matrices de tipo PAL/PLA y tienen unas densidades mucho
mayores que los anteriores. Una FPGA tpica tiene un nmero de puertas equivalentes
mucho mayor que un dispositivo CPLD tpico. Los elementos que implementan las
funciones lgicas en las FPGA son, generalmente, mucho ms pequeos que en los CPLD,
por lo que hay muchos ms de esos elementos. Asimismo, en las FPGA, las
interconexiones programables estn organizadas segn una disposicin de filas y
columnas.

Figura 2.5. Arquitectura interna de una FPGA

Los tres elementos bsicos en una FPGA son el bloque configurable (CLB, Configurable
Logic Block), las interconexiones y los bloques de entrada/salida (E/S). Los bloques CLB
de una FPGA son menos complejos que sus homnimos en un CPLD, pero suele haber
muchos ms de ellos. La matriz distribuida de interconexiones programables permite
interconectar los bloques CLB entre s y conectarlos a las entradas y a las salidas. Los
bloques de E/S situados alrededor del permetro de las estructura proporcionan un acceso
de entrada/salida o bidireccional, individualmente seleccionable, hacia el mundo exterior.

Estructura de los bloques lgicos configurables

Cada bloque lgico de la FPGA est formado por mltiples mdulos lgicos ms pequeos
(que son los componentes bsicos) y por una serie de interconexiones programables locales
que se emplean para conectar entre s los mdulos lgicos que componen el CLB.

Mdulo lgico
Mdulo lgico
Mdulo lgico
CLB
Interconexin
local

Figura 2.6. Arquitectura de un CLB

- 15 -
Un mdulo lgico puede configurarse para implementar lgica combinacional, lgica
registrada o una combinacin de ambas. Se emplea un flip-flop que forma parte de la lgica
asociada para implementar lgica registrada. A continuacin se muestra un diagrama de
bloques de un mdulo lgico tpico basado en LUT (Look-Up Table, tipo de memoria
programable que se utiliza para generar funciones booleanas):

LUT
Lgica
asociada
A
0
A
1
A
n-1
Salida suma de
productos
Mdulo lgico
E/S

Figura 2.7. Diagrama de bloques bsico de un mdulo lgico

Los dispositivos FPGA son reprogramables, y los de gran tamao pueden tener decenas de
miles de bloques CLB, adems de memoria y otros recursos. Por todo ello y la gran
flexibilidad que presentan, son ideales para realizar prototipos de manera rpida, en
pequeas cantidades.

2.3.4 Componentes IP (IP cores)

Dentro de una FPGA se puede incluir la funcionalidad de varios circuitos integrados. Esta
funcionalidad puede ser desarrollada uno mismo o adquirida a travs de terceros. Debido a
que estas funcionalidades son como componentes electrnicos, pero sin su parte fsica, se
les suele llamar componentes virtuales. En la industria se les conoce como bloques de
propiedad intelectual o IP cores (Intellectual Property).

Existen tres tipos de IP cores:

Hablamos de soft-core cuando se trata de cdigo sintetizable, similar al cdigo
fuente para software o tambin a descripcin a nivel de puerta (netlist).
Entendemos por hard-core el caso de una descripcin fsica, a nivel fsico (de
transistores); estos mdulos presentan problemas a la hora de asociar diferentes
procesos entre ellos o pasar de una lnea de fabricacin a otra.
Por firm-core nos referimos a un diseo que puede ser modificado en trminos de
placement & routing o en tecnologa de bibliotecas.

Los dispositivos FPGA que contienen procesadores integrados y otras funciones
implementadas en forma de mdulos de hardware (hard-core) y de mdulos de software
(soft-core) se conocen con el nombre de dispositivos FPGA de plataforma, porque
pueden emplearse para implementar un sistema completo sin necesidad de dispositivos
externos de soporte.

El objetivo de este proyecto es el de crear un IP core o componente IP que realice
operaciones en decimal. En este caso se tratar de un soft-core.


- 16 -
2.3.5 Prototipado rpido

Un sistema completo (hardware y software) y su entorno no puede ser validado nicamente
mediante la simulacin. El objetivo es comprobar en la prctica el funcionamiento del
prototipo a un coste asequible.

El prototipado rpido es una posibilidad que facilita enormemente el diseo, mediante la
cual un circuito compuesto por una gran cantidad de puertas lgicas puede ser
implementado en un circuito integrado configurable, como lo puede ser una FPGA, a partir
de una descripcin en HDL mediante un simple ordenador personal (PC), sin la necesidad
de adquirir o disponer de un equipamiento caro. Y la tecnologa que permite dicha tcnica
la forman las tarjetas de prototipado rpido, que permiten reproducir desde funciones
sencillas hasta complejos sistemas en un chip (SoC, System on Chip).

Dichas tarjetas incluyen los componentes necesarios para esta misin: dispositivos
programables (CPLD, FPGA), memoria de datos y de programa, componentes de entrada-
salida y conectores (displays, puertos Ethernet, USB, RS-232, conversores analgico-
digital y viceversa, interruptores, LEDs), osciladores internos (reloj del sistema)

Un ejemplo de este tipo de dispositivos es la Spartan-3E Starter Kit Board, que
utilizaremos para comprobar el funcionamiento de nuestra Unidad Aritmtica Decimal.

2.4 Spartan-3E Starter Kit Board

La unidad Spartan-3E Starter Kit Board nos proporciona las herramientas necesarias para
testear nuestro sistema. Incluye la placa de pruebas con una FPGA Spartan-3E modelo
XC3S500E, fuente de alimentacin, cable USB para programar el dispositivo, software
para sintetizar e implementar nuestro modelo y manuales de referencia.

A continuacin enumeramos algunas caractersticas de la placa:

Dispositivos Xilinx integrados:

- FPGA de la familia Spartan-3E modelo XC3S500E-4FG320C (con 232 pines
de E/S para el usuario, 1164 CLBs o bloque lgicos configurables y 10000
celdas o mdulos lgicos)
- Controlador CPLD CoolRunner-II CPLD (XC2C64A-5VQ44C)
- 4 Mbits de memoria PROM Platform Flash

Reloj: oscilador de 50 MHz

Otra memoria incluida:

- 128 Mbits de memoria Parallel Flash
- 16 Mbits de memoria SPI (Serial Peripheral Interface) Flash
- 64 MBytes de memoria DDR SDRAM


- 17 -
Interfaces y conectores:

- 4 interruptores tipo pulsador
- 4 salidas DAC (Digital-to-Analog Converter)
- 2 entradas ADC (Analog-to-Digital Converter)
- Conexin Ethernet 10/100
- Puerto USB
- 2 puertos serie RS-232
- Puerto PS/2 para ratn o teclado
- 4 interruptores tipo slide
-

Display: Pantalla LCD de 2 lneas de 16 caracteres cada una

Figura 2.8. Vista superior de la Spartan-3E


3. MEMORIA DESCRIPTIVA

Diseo sobre FPGA de una Unidad Aritmtica Decimal Memoria descriptiva

- 19 -
3.1 La Unidad Aritmtica Decimal ............................................................................................... 20
3.2 Bloques de la unidad................................................................................................................ 21
3.2.1 Sumador/Restador............................................................................................................. 21
3.2.1.1 Sumador .................................................................................................................. 21
3.2.1.1.1 Sumador de 1 dgito BCD (bloque one_digit_adder.vhd)......................... 21
3.2.1.1.2 Sumador de n dgitos decimales .................................................................... 24
3.2.1.2 Restador............................................................................................................... 26
3.2.1.2.1 Clculo del complemento a 9 (bloque nine_complement.vhd).................. 27
n
..................................................... 28
n_adder_subs.vhd).......................................................................................................... 29
3.2.2 Multiplicador.. .......................................................................................................... 32
3.2.2.1 Multiplicador de 1x1 dgitos BCD (bloque one_digit_multiplier.vhd)................ 32
3.2.2.2 Multiplicador de Nx1 dgitos BCD (bloquen_by_one_multiplier.vhd)............... 34
3.2.2.3 Multiplicador de NxM dgitos BCD (bloquen_by_m_multiplier.vhd) ................ 37
3.2.3 Divisor .............................................................................................................................. 41
3.2.3.1 Algoritmo de divisin binaria ................................................................................. 41
3.2.3.2 Algoritmo de divisin BCD..................................................................................... 42
3.2.3.3 Error generado........................................................................................................ 42
3.2.3.4 Divisor BCD (bloque divider.vhd)...................................................................... 43
3.3 Diseo de la Unidad Aritmtica Decimal ............................................................................... 48


- 20 -
3.1 La Unidad Aritmtica Decimal

Nuestro objetivo es la creacin del modelo VHDL de una Unidad Aritmtica Decimal, es
decir, una unidad que, operando en sistema BCD, realice las operaciones de suma, resta,
multiplicacin y divisin.

Figura 3.1. Representacin previa de la Unidad Aritmtica Decimal

Necesitaremos un sistema que dados dos valores de entrada de n dgitos BCD cada uno, x e
y, calcule el resultado z (de 2n dgitos BCD) de la operacin que hayamos escogido
previamente mediante la seal de entrada operation. Adems, contaremos con las seales
de entrada start (para iniciar el clculo interno cuando sea necesario), reset (reiniciar el
sistema), clk (seal de reloj) y las de salida carry (acarreo de salida cuando sea necesario)
y done (indicador de resultado disponible).

Para ello, la primera idea es que deberemos crear el modelo necesario para poder ejecutar
cada operacin.

Unidad aritmtica decimal
Sumador Restador Multiplicador Divisor

Figura 3.2. Estructura interna previa de la Unidad Aritmtica Decimal

Por consiguiente, nos centraremos primero en el diseo de los mdulos primarios que
realizarn las diferentes operaciones y despus los integraremos en la unidad principal.


- 21 -
3.2 Bloques de la unidad

3.2.1 Sumador/Restador

3.2.1.1 Sumador

En este apartado nuestro objetivo es la realizacin de un sumador de n dgitos decimales.
Para ello, lo primero que hacemos es crear una estructura bsica, el sumador de 1 dgito
decimal.

3.2.1.1.1 Sumador de 1 dgito BCD (bloque one_digit_adder.vhd)

La idea principal de este bloque es que, dadas dos entradas, a y b, que representan cada una
1 dgito decimal, tenemos una arquitectura cuya misin es realizar la suma de ambos
dgitos y dar como resultado (c) 1 dgito decimal de salida y un acarreo (carry_out) en caso
de ser necesario.

Figura 3.3. Sumador de 1 dgito decimal

La estructura interna del bloque sera la siguiente:

Figura 3.4. Arquitectura del sumador de 1 dgito decimal

- 22 -
Tenemos dos entradas, a y b, que pueden representar cualquier dgito decimal del 0 al 9,
una salida c que tambin ser un dgito BCD, y un acarreo de salida (carry_out). Tambin
hay un acarreo de entrada, carry_in, que nos permitir interconectar diversos bloques.

Funcionamiento

Al realizar la suma binaria se nos pueden presentar dos casos: si el resultado de dicha suma
es igual o menor a 9 (1001), el resultado es directo (es decir, a + b = c). Si la suma es
superior a 9, debemos realizar una correccin al valor obtenido.

El proceso en este segundo caso es el siguiente: realizamos la suma de a y b en binario,
obteniendo el valor intermedio d formado por 5 bits (Figura 3.4). Son 5 bits porque el
mximo nmero en decimal que podemos obtener es que el que se da cuando a y b tienen
sus valores mximos (9) y el acarreo de entrada carry_in es igual a 1; el resultado de la
suma (a + b + carry_in) es 19, y en binario sera 10011 (los cinco bits mencionados).
Para el caso de que la suma de a y b sea mayor que 9, aplicaremos un factor de correccin
que sera restar 10 al valor obtenido y aumentar 1 el dgito de las decenas. Y restar diez
equivale en binario a sumar 6 (0110). Un ejemplo: si a es 5 y b es 7, la suma es 12 y
debemos realizar la correccin.

Empezamos sumando 5 y 7. Sus correspondientes en binario son 0101 para el 5 y 0111
para el nmero 7. El resultado es 12, que en binario se representa como 1100.

1 1 1 decimal
0 1 0 1 5
+ 0 1 1 1 7
1 1 0 0 12

Vemos que este valor es superior a 9, y por tanto no es un valor BCD vlido. Entonces
hemos de aplicar una correccin para obtener el valor correspondiente en BCD, donde el
nmero 12 se representara con dos dgitos de cuatro bits cada uno; un primer grupo para el
1 0001, y otro grupo para el 2 0010. Para pasar de binario a BCD vamos a sumar 6 (en
binario 0110):

1 1
1 1 0 0 12
+ 0 1 1 0 6
1 0 0 1 0

Obtenemos 10010, donde debemos leer los ltimos cuatro bits para el primer dgito
decimal 0010 y que equivalen al nmero 2, y el bit de ms peso, 1, que formara parte
del siguiente dgito decimal, que sera un 1. Por tanto, tendramos como resultado dos
dgitos decimales, un dgito decimal de las decenas igual a 1, y otro para las unidades que
sera un 2. Hemos pasado del valor 12, 10010 en binario, a su equivalente en
nomenclatura BCD, 0001 0010.
Equivale a un dgito BCD de
valor 2 (0010)
Equivale a un dgito BCD
de valor 1 (0001)

- 23 -
Decimal 12
Binario 1100
BCD 0001 0010

En resumen:

Si a + b + cy_in 9, a + b + cy_in = c, acarreo de salida = 0 (3.1)

Si a + b + cy_in > 9, a + b + cy_in = (c + 6) mod 16, acarreo de salida = 1 (3.2)

A continuacin podemos ver una simulacin del funcionamiento de este bloque:

Figura 3.5. Simulacin del sumador de 1 dgito decimal

Podemos observar como se realiza la correccin cuando a + b > 9, obteniendo como
resultado en c el dgito de las unidades, y el dgito 1 (0001) de las decenas en el acarreo
de salida (cy_out).


- 24 -
3.2.1.1.2 Sumador de n dgitos decimales

Para obtener el sumador de n dgitos BCD vamos a interconectar n sumadores de 1 dgito
decimal (el bloque que hemos creado antes). Gracias a la entrada carry_in de cada bloque,
podemos propagar el acarreo de manera que el resultado obtenido sea el correcto.

Figura 3.6. Diagrama de bloques del sumador de n dgitos decimales

La interconexin de los bloques sencillos crear el sumador de n dgitos BCD,

Figura 3.7. Sumador de n dgitos decimales

donde tendremos dos entradas, x e y, de n dgitos BCD (4n bits), y una salida z que ser el
resultado de la operacin. Adems, en el caso de que haya desbordamiento en z, la salida
out_carry se pondr a 1. La entrada ini_carry en este bloque se corresponde con el
acarreo de entrada del primer sumador de 1 dgito BCD.


- 25 -
A continuacin se muestra la simulacin de unos ejemplos para n = 4:

Figura 3.8. Simulacin del sumador de 4 dgitos decimales

Podemos ver como en la tercera operacin (x = 3050, y = 8070), el acarreo de salida est a
nivel alto, lo que indica que el resultado es z = 11120.


- 26 -
3.2.1.2 Restador

El objetivo es crear un bloque que dados dos valores de entrada de n dgitos, x e y, calcule
la diferencia z, e indique mediante una seal de salida denominada carry_out si el
resultado ha sido positivo (carry_out = 0) o negativo (carry_out = 1),

Figura 3.9. Restador de n dgitos decimales

Para ello, nos basaremos en dos operaciones bsicas; una es la suma descrita en el apartado
anterior, por lo que utilizaremos el Sumador de n dgitos decimales, y la otra es la
utilizacin del complemento a 10
n
del valor y de entrada. El complemento a 10
n
de un
nmero se puede obtener a partir de calcular el complemento a 9 de cada dgito (con un
bloque que haga esta funcin) y sumando 1 al resultado.

Un valor decimal x puede expresarse como:

x
n-1
x
n-2
x
1
x
0
= x
n-1
10
n-1
+ x
n-1
10
n-2
+ + x
1
10 + x
0
, (3.3)

y su complemento a 9 equivale a

9 x
n-1
9 x
n-2
9 x
1
9 x
0
= 10
n
1 (x
n-1
x
n-2
x
1
x
0
), (3.4)

por lo que podemos establecer la siguiente igualdad:

10
n
(x
n-1
x
n-2
x
1
x
0
) = (9 x
n-1
9 x
n-2
9 x
1
9 x
0
) + 1 (3.5)

Es decir, el complemento a 10
n
de un valor x equivale a realizar el complemento a 9 de
cada dgito y sumar 1 (lo que ya habamos avanzado anteriormente).

Se puede calcular la resta mediante la expresin x + (10
n
y), que plantea dos casos
posibles:

Si x y: x + (10
n
y) 10
n
, siendo z = x y, con carry_out = 1 (3.6)

Si x < y: x + (10
n
y) < 10
n
, siendo z = 10
n
+ (x y), con carry_out = 0 (3.7)


- 27 -
3.2.1.2.1 Clculo del complemento a 9 (bloque nine_complement.vhd)

Diseamos un bloque que dado un dgito BCD de entrada (e), calcule su complemento a 9
(s). Este bloque estar controlado por una seal de entrada denominada add_sub,
encargada de habilitar o no la operacin. Si su valor es 1, s mostrar el complemento a 9
de e; en caso contrario s tomar el mismo valor que e.

Figura 3.10. Bloque de complemento a 9 de un dgito BCD

Dado un dgito BCD e de cuatro bits (e
3
e
2
e
1
e
0
), su complemento a 9 (s
3
s
2
s
1
s
0
) se
obtiene mediante la operacin 1001 e
3
e
2
e
1
e
0
(o su equivalente, 1001 + e
3
e
2
e
1
e
0

+ 1, es decir, sumando al minuendo el complemento a 2 del sustraendo). Las expresiones
resultantes son las siguientes:

3 2 1 3
2 1 2
1 1
0 0
e e e s
e e s
e s
e s
=
=
=
=
(3.8)

Si aadimos la seal de control add_sub, dichas expresiones quedan modificadas de esta
forma:

( )
3 2 1 3 3
2 1 2 2
1 1
0 0 0
_ _
) ( _ _
_ _
e e e sub add e sub add s
e e sub add e sub add s
e s
e sub add e sub add s
+ =
+ =
=
+ =
(3.9)

Figura 3.11. Ejemplo del funcionamiento del bloque de complemento a 9


- 28 -
n

Para implementar el restador utilizaremos, como hemos explicado antes, el sumador de n
dgitos y el bloque de complemento a 9 (nine_complement.vhd). El diagrama de bloques
resultante sera el mostrado a continuacin:

Figura 3.12. Restador de n dgitos decimales

Si nos fijamos en la Figura 3.12, podemos ver que la seal de control add_sub nos permite
realizar las operaciones de suma y resta:

Si add_sub = 0, la seal y no se modifica y tenemos la operacin suma (z = x + y)

Si add_sub = 1, lo que entra al sumador es el complemento a 9 de y; adems la
seal de entrada del sumador ini_carry (acarreo de entrada) toma el valor de
add_sub, por lo que la operacin que se realiza es la resta (z = x + y + ini_carry).

Debido a que podemos realizar las dos operaciones con un mismo bloque, lo
denominaremos Sumador/Restador de n dgitos.


- 29 -
n_adder_subs.vhd)

Observemos otra vez en el ltimo bloque creado (Figura 3.12). Hemos visto que esta
estructura nos permite realizar las operaciones de suma y resta. Pongamos un par de
ejemplos sobre la resta siendo n = 3:

Si x = 735 e y = 177 (su complemento a 9 es 822), tendremos 735 + 822 + 1 (del
acarreo de entrada, valor de la seal add_sub). El resultado ser positivo e igual a
578, con el acarreo de salida (out_carry) igual a 1.

Si x = 485 e y 823 (su complemento a 9 es 176), tendremos 485 + 176 + 1. El
resultado ser 662 con un acarreo de salida igual a 0 (resultado negativo).

En este ltimo caso, para saber el resultado exacto de la operacin debemos calcular el
complemento a 10
n
del valor z que hemos obtenido; es decir, calcular el complemento a 9
de cada dgito de z y sumar 1 al resultado obtenido. Esto lo hacemos mediante una
modificacin de la arquitectura anterior, por lo que el diagrama de bloques final del
Sumador/Restador de n dgitos BCD ser el siguiente:

Sumador de n
dgitos decimales
ini_carry
carry_out
y(4n-1:0)
4n
x(4n-1:0)
4n
4n
z1
Complemento
a 9
4n
add_sub
Complemento
a 9
4n
1
4n
ini_carry 0
z3
z1
4n
0 1
4n
z(4n-1:0)
add_sub
oc
Sumador de n
dgitos decimales
ini_carry
4n

Figura 3.13. Sumador/Restador de n dgitos decimales


- 30 -
Esta modificacin implica un cambio en el significado del valor del acarreo de salida del
bloque (denominado carry_out), cuando realizamos la operacin resta:

Si carry_out = 0, el resultado de la resta es no negativo (x > y)

Si carry_out = 1, el resultado de la resta es negativo (x < y)

Hemos aadido otro bloque que complementa a 9 el resultado z1 de la primera etapa y
posteriormente suma 1, lo que genera la seal z3. Dependiendo de los valores de add_sub y
oc (acarreo de la primera etapa), el multiplexor seleccionar z1 o z3. Concretamente,
cuando el resultado de la resta sea positivo (carry_out = 0), el multiplexor seleccionar el
canal 0 (z1), y si el resultado es negativo (carry_out = 1) seleccionar el canal 1 (z3).

A modo de resumen, el Sumador/Restador de n dgitos decimales presenta las siguientes
caractersticas:

add_sub Operacin carry_out Resultado
0 Suma 0 Exacto
0 Suma 1 Hay desbordamiento
1 Resta 0 Positivo
1 Resta 1 Negativo

Tabla 3.1. Operaciones del Sumador/Restador

A continuacin mostramos unos ejemplos de la simulacin para n = 4:

En modo resta (add_sub = 1):

Figura 3.14. Simulacin del Sumador/Restador en modo resta


- 31 -
En modo suma (add_sub = 0):

Figura 3.15. Simulacin del Sumador/Restador en modo suma


- 32 -
3.2.2 Multiplicador

En este apartado crearemos un mdulo que multiplique dos valores de entrada, x e y, de n y
m dgitos BCD respectivamente, y muestre el resultado en z, de n + m dgitos BCD.

Figura 3.16. Multiplicador de NxM dgitos BCD

Para ello lo primero que haremos ser definir una estructura bsica que realizar la
multiplicacin de dos dgitos BCD (multiplicador de 1x1 dgitos BCD), despus
realizaremos un bloque que multiplique un nmero de n por 1 dgitos BCD, y finalmente el
multiplicador de NxM dgitos BCD.

3.2.2.1 Multiplicador de 1x1 dgitos BCD (bloque one_digit_multiplier.vhd)

El producto decimal se puede obtener a travs del producto binario y una etapa de
correccin posterior. La etapa bsica sera un multiplicador de 1x1 dgitos BCD, es decir,
dos entradas de 1 dgito BCD cada una. sta se puede implementar a partir de un circuito
combinacional.

Multiplicador de
1 dgito BCD
a(3:0) b(3:0)
4 4
u(3:0)
4
d(3:0)
4

Figura 3.17. Multiplicador de 1x1 dgitos BCD


- 33 -
80 40 20 10 8 4 2 1
p3 p2 p1 p0
p4 p4 p4
+ p5 p5 p5
p6 p6 p6
d3 d2 d1 d0 u3 u2 u1 u0

Tenemos A y B que son dos dgitos BCD (a
3
a
2
a
1
a
0
y b
3
b
2
b
1
b
0
respectivamente). El
producto BCD de ambos dgitos se puede expresar como:

U D B A + = 10 , (3.10)

es decir, la cifra de las decenas multiplicada por 10 ms las unidades.

El producto binario de A y B se puede expresar en un primer paso como un nmero de 7
bits tal que:

0 1 2 3 4 5 6
p p p p p p p P B A = = (3.11)

Son un mximo de 7 bits porque el resultado mximo que podemos tener en esta operacin
es 81 en decimal, que corresponder al caso de que A y B tengan su valor mximo, y este
es 9. La representacin binaria del nmero 81 es 1010001 (7 bits).

Podemos convertir el nmero binario P a cdigo BCD mediante sumas binarias tras
corregir los trminos descritos en la Figura 3.18. La primera fila indica el peso de cada
dgito BCD. Los pesos de p
3
p
2
p
1
p
0
son los mismos que para el valor binario. Pero los
pesos de p
4
p
5
y p
6
se pueden descomponer en los valores BCD de la Figura 3.18.
Concretamente, p
4
(cuyo peso es 16 en binario) se puede descomponer como (10, 4, 2), p
5

(peso binario igual a 32) se puede descomponer en (20, 10, 2) y por ltimo p
6
(peso binario
64) como (40, 20, 4).

Figura 3.18. Reduccin aritmtica de binario a BCD

Sumamos los trminos y obtenemos las expresiones que nos darn el valor de las unidades
(uu) y las decenas (dd):

5 6 4 5 6
5 6 4 4 0 1 2 3
0
0 0 0 0
p p p p p dd
p p p p p p p p uu
+ =
+ + =
(3.12)

Dada esta ltima expresin de uu, podemos ver que su valor estar entre 0 y 27 (segn los
valores de p
0
, p
1
, p
2
, p
3
, p
4
, p
5
y p
6
). Si el valor de uu es superior a 9 (con lo que se
necesitara de ms de 1 dgito BCD para representarse) deberemos realizar una correccin
para obtener un resultado correcto. A continuacin definimos dichos trminos de
correccin:

Si uu 9: no hacemos ninguna correccin, el valor es correcto,
Si 9 < uu 19: sumamos 1 a dd, (aadimos 1 a las decenas y 6 a las unidades; esto
ltimo equivale a restar 10),
Si 19 < uu: sumamos 2 a dd, (aadimos 2 a las decenas y 12 a las unidades; esto
ltimo equivale a restar 20).

- 34 -
Definiremos una variable para cada caso y mediante las siguientes expresiones booleanas
sabremos cual tenemos en cada momento.

Si uu es mayor o igual a 10:

) ( 9
1 2 3 4
uu uu uu uu gt = (3.13)

Si uu es mayor o igual a 20:

) ( 20
2 3 4
uu uu uu gt = (3.14)

Si uu se encuentra entre 10 y 19 (ambos incluidos):

20 9 19 10 gt gt st gt = (3.15)

Por ltimo obtenemos los valores finales para las decenas (d) y las unidades (u) al aadir
las correcciones pertinentes:

u = (uu
3
uu
2
uu
1
uu
0
) + (gt20 gt9 gt10st19 0)
d = (dd
3
dd
2
dd
1
dd
0
) + (0 0 gt20 gt10st19) (3.16)

Simulacin

Figura 3.19. Muestra de la simulacin del multiplicador de 1x1 dgitos BCD

3.2.2.2 Multiplicador de Nx1 dgitos BCD (bloque n_by_one_multiplier.vhd)

Un multiplicador de Nx1 dgitos BCD se puede construir a partir de n multiplicadores de
1x1 dgitos BCD seguido de sumadores BCD. Por tanto, para realizar este bloque
utilizaremos dos que hemos creado anteriormente; uno ser el multiplicador que acabamos
de hacer (multiplicador de 1x1 dgitos BCD, one_digit_multiplier.vhd) y el otro ser el
sumador de 1 dgito BCD (one_digit_adder.vhd).


- 35 -
Pongamos un ejemplo: si n es igual a 3, tendremos la siguiente estructura,

Multipl.
1x1 BCD
4 4
u
0
4
y x
0
d
0
4 Multipl.
1x1 BCD
4 4
u
1
4
y x
1
d
1
4
4 4
u
2
4
y x
2
d
2
4
Multipl.
1x1 BCD

Figura 3.20. Multiplicador de 3x1 dgitos BCD (parte 1)

donde x ser el nmero de 3 dgitos BCD (x
2
x
1
x
0
). Cada multiplicador genera un valor
para las unidades (u
x
) y uno para las decenas (d
x
); este ltimo ser el que deba sumarse a
las unidades del siguiente multiplicador. Esta estructura nos muestra que necesitaremos un
sumador de n + 1 dgitos BCD.

El resultado z (formada por 4 dgitos BCD) ser el siguiente:

z = (0 u
2
u
1
u
0
) + (d
2
d
1
d
0
0) (3.17)

Sumador 1
dgito BCD
z
0
4
4
u
0
4
0
Sumador 1
dgito BCD
z
1
4
4
u
1
4
d
0
Sumador 1
dgito BCD
z
2
4
4
u
2
4
d
1
Sumador 1
dgito BCD
z
3
4
4
0
4
d
2

Figura 3.21. Multiplicador de 3x1 dgitos BCD (parte 2)

Viendo este ejemplo podemos afirmar que, para un multiplicador de Nx1 dgitos BCD,
necesitaremos n multiplicadores 1x1 y n + 1 sumadores de 1 dgito.


- 36 -
Tendremos dos seales de entrada: un valor x de n dgitos (x
n-1
x
n-2
x
2
x
1
x
0
) y un valor y
de 1 dgito, lo que generar una seal de salida z (z
n
z
n-1
z
n-2
z
2
z
1
z
0
).

Figura 3.22. Multiplicador de Nx1 dgitos. Incluye n multiplicadores 1x1 y n + 1 sumadores de 1 dgito

A continuacin se muestra un ejemplo de la simulacin del bloque para n = 5:

Figura 3.23. Simulacin del multiplicador Nx1 dgitos BCD


- 37 -
3.2.2.3 Multiplicador de NxM dgitos BCD (bloque n_by_m_multiplier.vhd)

En este bloque tenemos como datos iniciales dos nmeros decimales, x e y, de n y m
dgitos respectivamente (x
n-1
x
n-2
x
2
x
1
x
0
e y
m-1
y
m-2
y
2
y
1
y
0
). El resultado ser z, un
nmero decimal de n + m dgitos (z
(n+m)-1
z
(n+m)-2
z
2
z
1
z
0
).

Figura 3.24. Multiplicador de NxM dgitos BCD

Tambin tendremos las entradas start (indica inicio de operacin), clk (seal de reloj) y
reset (que inicializa el bloque), y la salida done (que informa de operacin realizada).

Los valores n y m sern los parmetros genricos del circuito.

Para realizar esta operacin vamos a crear un sistema secuencial (a diferencia de los que
habamos hecho hasta ahora, que eran combinacionales) en el que mediante un bucle,
utilizaremos m veces el multiplicador de Nx1 dgitos (n_by_one_multiplier.vhd) y
sumaremos y almacenaremos los resultados parciales (mediante el bloque
n_adder_subs.vhd en modo suma y registros internos).

Que sea un sistema secuencial ayudar a reducir el coste del mismo, ya que utilizaremos un
solo multiplicador en lugar de utilizar m multiplicadores de Nx1.

El algoritmo que utilizaremos ser el siguiente:

z : = 0;
f or i i n 1 . . ml oop
z : = z 10 + x y
m- i
;
end l oop;


- 38 -
El diagrama de bloques del circuito es:

left shift register y
Multiplicador Nx1
dgitos BCD
4 4m
1111 y(4m-1:0)
4n
x(4n-1:0)
load
shift
clk
Sumador n
dgitos BCD
register z
load
shift
clk
4(n+1)
x 10
z(4(n+m)-1:0)
4(n+m)
4
z_by_10
next_z
x_by_yi
int_y(m)

Figura 3.25. Diagrama de bloques del multiplicador NxM

El funcionamiento es el siguiente: se inicializa el registro de desplazamiento (load = 1)
con el valor de y seguido de un dgito no decimal (15 = 1111), que ser el indicador de
que ya hemos multiplicado todos los valores de y. A cada etapa (shift = 1) se desplaza el
valor una posicin (4 bits) a la izquierda. De esta manera entrarn sucesivamente en el
multiplicador Nx1 los dgitos y
m-1
, y
m-2
, y
1
, y
0
; una seal interna detectar el 1111 e
indicar el fin de clculo.

En el multiplicador Nx1 tendremos en una entrada el valor de x, multiplicando cada vez
por el dgito de y correspondiente. Es decir, en un primer paso el multiplicador realizara el
producto de x
n-1
x
n-2
x
1
x
0
e y
m-1
. El valor resultante pasara al sumador, donde no se
modificara ya que el registro z se inicializa con 0, y se almacenara en dicho registro.

En la siguiente etapa, se desplazar el registro de desplazamiento otra posicin; en el
multiplicador ahora tendremos como entradas x
n-1
x
n-2
x
1
x
0
e y
m-2
. En el sumador
tendremos como entradas el ltimo producto generado y el primer valor que se almacen
en el registro z multiplicado por 10.

Este proceso se repite hasta que se detecta el dgito no decimal 1111 en el registro de
desplazamiento que indica que se han ledo todos los valores de y.


- 39 -
En la siguiente figura podemos ver una simulacin del proceso, donde hemos establecido
n = 3 y m = 4:

Figura 3.26. Simulacin del multiplicador NxM dgitos BCD

Para controlar este sistema secuencial necesitaremos una unidad de control. Dicha unidad
recibir como seales de entrada start, clk, reset y end_of_computation, y generar las
seales shift, load y done:

Figura 3.27. Unidad de control

La unidad de control se puede representar con una mquina de 4 estados:

E
0
E
1
E
2
E
3
shift = 0
load = 0
done = 1
start = 1
end_of_ computation = 1
start = 0
start = 1 start = 0
shift = 0
load = 0
done = 1
shift = 0
load = 1
done = 0
shift = 1
load = 0
done = 0
end_of_ computation = 0

Figura 3.28. Mquina de estados de la unidad de control


- 40 -
E
0
es el estado inicial (seal current_state), con un bucle de espera para que la seal start
pase a nivel bajo y avanzar al estado 1 (caso de que start se haya mantenido a 1 como
consecuencia de una operacin anterior).

Aqu se espera a que start sea igual 1 (lo que hemos hecho ha sido detectar la transicin
de 0 a 1 de esta seal). En E
2
se cargan los valores iniciales en los registros (load = 1).
Entonces pasamos a E
3
, donde se ejecutan las etapas de clculo (shift = 1) hasta que la
seal end_of_computation sea igual a 1, lo que significar que el dgito ledo int_y es 15
(1111) y ha finalizado la operacin, volviendo al estado inicial y poniendo la seal done a
1, indicando que el proceso ha terminado.


- 41 -
3.2.3 Divisor

3.2.3.1 Algoritmo de divisin binaria

Dados dos nmeros naturales x e y, siendo x < y, el algoritmo de divisin binaria genera
dos naturales q y r tales que:

, 2 r y q x
p
+ = con r < y (3.18)

As
, 2 2
p p
r y q x

+ = (3.19)

y
, 2 2
p p
y
r
q
y
x

+ = siendo
p p
y
r

< 2 2 (3.20)

El algoritmo se basa en el siguiente conjunto de igualdades:

r
0
= x, de modo que r
0
< y,
2 r
0
= q
p-1
y + r
1
, con r
1
< y,
2 r
1
= q
p-2
y + r
2
, con r
2
< y,
2 r
2
= q
p-3
y + r
3
, con r
3
< y,

2 r
p-1
= q
0
y + r
p
, con r
p
< y, (3.21)

Multiplicando la primera ecuacin por 2
p
, la segunda por 2
p-1
, la tercera por 2
p-2
,, y la
ltima por 2
0
, y sumando las p ecuaciones tenemos que:

x 2p = (q
p-1
2
p-1
+ q
p-2
2
p-2
+ q
p-3
2
p-3
+ + q
0
2
0
) y + r
p
(3.22)

Si comparamos la expresin con (3.18), podemos obtener q y r ya que:

q = 0. q
p-1
q
p-2
q
p-3
q
0
y r = r
p
(3.23)

En cada paso se calculan q
p-i
y r
i
en funcin de r
i-1
e y:

2 r
i-1
= q
p-i
y + r
i
, siendo r
i
< y (3.24)

Se plantean dos opciones:

2 r
i-1
y : entonces

q
p-i
= 1 y r
i
= 2 r
i-1
y (3.25)

2 r
i-1
< y : entonces
q
p-i
= 0 y r
i
= 2 r
i-1
(3.26)


- 42 -
3.2.3.2 Algoritmo de divisin BCD

El algoritmo de divisin binaria se puede utilizar cualquiera que sea el sistema de
numeracin. Si trabajamos en base 10, la nica condicin para poder utilizarlo es que todas
las operaciones se hagan en base 10.

El algoritmo que utilizaremos ser el siguiente:

r : = x; q : = 0; ul p : = 0. 5;
f or i i n 1 . . p l oop
t wo_r : = 2*r ; di f : = t wo_r - y;
i f di f < 0 t hen r : = t wo_r ;
el se r : = di f ; q : = q + ul p;
end i f ;
ul p : = ul p/ 2;
end l oop;

Las operaciones en BCD que utilizaremos sern la multiplicacin por 2, la resta con
generacin de signo y la suma. Adems, la representacin BCD de 1/2, 1/2
2
, ..., 1/2
p
ser
calculada sobre la marcha.

3.2.3.3 Error generado

Si se ejecutan p etapas, el error es menor que 1/2
p
(segn el algoritmo). Supongamos que el
objetivo sea que el resultado se escriba con m dgitos fraccionarios y que el error sea menor
que 1/10
m
(significa que el resultado obtenido es el cociente exacto truncado). Para ello
basta con que se cumpla la siguiente relacin:

m p
<
10
1
2
1
, es decir ) 10 ( log
2
> m p , o sea que m p > 3 . 3 (3.27)


- 43 -
3.2.3.4 Divisor BCD (bloque divider.vhd)

El divisor BCD ser un mdulo que realice la divisin entre dos valores de entrada, x / y,
donde x < y (para que el algoritmo funcione), dando como resultado el cociente q de m
dgitos decimales (q
m-1
q
m-2
q
2
q
1
q
0
).

Tambin tendr como entradas las seales start (inicio de operacin), clk (seal de reloj) y
reset (que inicializa el bloque), y la salida done (que informa de operacin realizada).

Figura 3.29. Divisor BCD

El cociente q es una salida de m dgitos. Internamente, el cociente debe generarse con p
dgitos, donde p es del orden de 3.3m (segn hemos explicado anteriormente). Llmese qq
al cociente interno con p dgitos. El cociente q (el resultado que nosotros veremos) consta
de los m dgitos ms significativos de qq.

Los valores de n (dgitos de los valores de entrada), m (dgitos y por tanto precisin del
resultado, el cociente), p (nmero de iteraciones que se realizarn) y logp (nmero de bits
necesario para representar p) sern los parmetros genricos del modelo.


- 44 -
Basndonos en el algoritmo de ejecucin creamos el siguiente diagrama de bloques:

Sumador/Restador
n dgitos BCD
Multiplicador
Nx1 dgitos BCD
r
4 4n
0010
4n+4
Sumador/Restador
n dgitos BCD
y(4n-1:0)
4n
carry_out add_sub 1
0 1
rr_y(4n-5:0)
rr
load
0 1
ulp
4p
qq
4p
carry_out add_sub 0
4n 4p
ini.: x(4n-1:0)
clk
initially: 0
4n
4p
r
q(4m-1:0)
qq
4p
4p-4(p-m)
4 4p
0101 ulp
load
initially: 0.5
clk
4p
ulp
4p
4p+4
Multiplicador
Nx1 dgitos BCD

Figura 3.30. Diagrama de bloques del divisor BCD

Inicialmente cargamos en el registro r el valor de entrada x.

Para calcular el doble de r utilizamos un multiplicador de Nx1 dgitos BCD
(n_by_one_multiplier.vhd). En una entrada tendremos el valor r y en la otra el dgito 2
(0010 en binario).

La diferencia entre el doble de r (2r, seal rr) y el valor decimal de entrada y, la
calculamos mediante un Sumador/Restador de n dgitos BCD (n_adder_subs.vhd) en
modo resta (seal de entrada add_sub = 1).

Si el resultado de la resta es positivo (rr > y) entonces carry_out = 0 y se almacenarn en
el registro r los n dgitos menos significativos de la diferencia recin calculada (rr - y). Si
por el contrario rr < y, carry_out = 1, se almacenarn en el registro los n dgitos menos
significativos del valor de rr.

- 45 -
El registro qq donde se almacenan los valores intermedios del cociente se inicializa a 0.

La suma de qq y ulp la calculamos mediante un Sumador/Restador de n dgitos BCD
(n_adder_subs.vhd) que opere en modo suma (add_sub = 0). Si el resultado antes
calculado de rr - y es positivo, se almacenar en el registro qq el resultado de qq + ulp; si
es negativo, lo que se almacene ser el valor de qq.

La seal ulp (Unit in the Least significant Position, unidad en la posicin menos
significativa) es un nmero que al final del clculo tendr p dgitos. Su registro
(register_ulp) se inicializa con el valor 0.5 (0000 0101 en cdigo BCD). En cada
iteracin ir tomando los valores 0.5, 0.25, 0.125, 0.0625, y as sucesivamente; es decir,
multiplicando el anterior valor por 5 (mediante el multiplicador de Nx1 dgitos,
n_by_one_multiplier.vhd) y desplazando el resultado 4 bits a la derecha (o lo que es lo
mismo, introduciendo un 0 decimal delante). Al ser la salida del multiplicador por 5 un
nmero de p + 1 dgitos, slo utilizaremos los p dgitos de ms peso (lo que equivale a
dividir por 10).

Al acabar el clculo de la operacin (seal zero = 1), obtendremos el cociente q de
truncar el ltimo valor almacenado en el registro qq, a partir del nmero de dgitos m que
hayamos seleccionado.

Unidad de control

Este sistema que hemos creado tambin es secuencial y necesitar de una unidad de control
que lo gobierne.

Figura 3.31. Unidad de control del divisor

La unidad de control genera las seales load (escritura de los valores iniciales en los
registros), ce (actualizacin de los registros) y done (operacin finalizada).

La seal zero vendr controlada por un contador de p estados (este nmero se representa
con logp bits, como hemos dicho antes). Dicha seal se pondr a 1 cuando se ejecute el
paso p de la iteracin.


- 46 -
La mquina de estados asociada a la unidad de control es la siguiente:

Figura 3.32. Mquina de estados de la unidad de control del divisor

Simulacin

A continuacin mostramos un ejemplo de la simulacin del sistema para los valores
genricos n = 3, m = 8, p = 27 y logp = 5:

Figura 3.33. Simulacin del divisor

La divisin entre x = 335 e y = 927 genera el cociente q = 36138079, que representa
0.36138079 (como x < y, el primer dgito siempre es 0). Al haber definido m = 8, el
cociente est representado por 8 dgitos decimales.


- 47 -
Podemos observar con mayor facilidad en la Figura 3.34 la transicin entre estados, y
vemos como, desde el estado 0 (seal current_state) y dado que la seal start es 0,
pasamos al estado 1 (en caso de que start se hubiera mantenido a 1 como resultado de un
clculo anterior, el sistema esperara a que dicha seal se pusiera a 0).

Figura 3.34. Ampliacin de la Figura 3.33

En el estado 1 y tras detectar un flanco de subida de la seal start, pasamos al estado 2,
donde la unidad de control activa (a 1) la seal load y se escriben los valores iniciales en
los registros. La seal done se pone a 0 indicando que hay una operacin en curso.

Tras un ciclo de reloj pasamos al estado 3 y se inicia el clculo; aqu empieza a funcionar
el contador regresivo (count) de p estados (27 en el ejemplo, de 26 a 0) que determina el
nmero de iteraciones a realizar. Tambin se activa la seal ce que permitir actualizar los
registros. Cuando el contador llegue a 0, dejarn de actualizarse los registros (ce = 0) y se
activar la seal zero informando del fin de clculo (esto se puede ver en la Figura 3.33),
volviendo al estado 0 y ponindose el indicador de operacin realizada done a nivel alto.


- 48 -
3.3 Diseo de la Unidad Aritmtica Decimal (bloque arithmetic_unit.vhd)

El siguiente paso es la definicin de la Unidad Aritmtica Decimal, una estructura que
integre los tres bloques anteriores (Sumador/Restador de n dgitos decimales,
Multiplicador de NxM dgitos BCD y Divisor BCD).

Figura 3.35. Unidad Aritmtica Decimal

Los parmetros genricos del modelo sern:

n: tamao de los operandos (en dgitos decimales) de x e y
p: nmero de etapas de la divisin
logp: nmero de bits necesario para representar p

Este bloque estar controlado por una seal de entrada llamada operation, mediante la cual
se indicar a la unidad la operacin a realizar:

operation Operacin Resultado
00 Suma z = x + y
01 Resta z = x - y
10 Multiplicacin z = x y
11 Divisin z = x / y (con una precisin de 2n dgitos fraccionarios)

Tabla 3.2. Operaciones de la Unidad Aritmtica Decimal

Tanto para la suma como la resta z tendr un tamao de 4n + 1 bits (el bit de mayor peso
corresponde a la seal carry_out del bloque Sumador/Restador), mientras que para la
multiplicacin y divisin el tamao ser de 8n bits.

En la multiplicacin y la divisin el clculo empieza con un flanco de subida de la seal de
entrada start. La bandera done se pone a 0. Una vez disponible el resultado, done tomar
el valor 1.


- 49 -
El diagrama de bloques de la unidad se muestra a continuacin:

8n 8n 4n
z(8n-1:4n) done
done1 done2
1
s1 s2 s3
c_out
Sumador/Restador
n dgitos BCD
Multiplicador de
NxM dgitos BCD
Divisor de n
dgitos BCD
4n
clk
reset
clk
reset
4n 4n 4n 4n 4n
operation
0
operation
1
start
carry_out add_sub
x(4n-1:0)
y(4n-1:0)
start1 start2
00 01 10 11
z(4n-1:0)
operation
4n
MUX-1
00 01 10 11
4n
MUX-2
00 01 10 11
4n
MUX-3

Figura 3.36. Diagrama de bloques de la Unidad Aritmtica Decimal

De cara a la implementacin en la FPGA, el operando y del Multiplicador de NxM dgitos
decimales pasar de estar formado por m dgitos a estarlo por n (podemos decir que ahora
el bloque es un Multiplicador de n dgitos decimales) De esta manera unificamos los
valores de entrada, que siempre estarn formados por n dgitos decimales.

Utilizaremos el bit de menor peso de la seal operation para indicar al Sumador/Restador
la operacin a realizar (entrada add_sub de ste).

Para habilitar el bloque multiplicador utilizaremos la seal start1, que es la salida de una
puerta AND de tres entradas (los dos bits de operation, con el de menor peso negado, y
start). Para el divisor utilizaremos start2, resultado de una puerta AND tambin de tres
entradas, pero esta vez sin negar el bit de menos peso de operation.

Figura 3.37. Circuito generador de las seales start1 y start2

- 50 -
La salida del primer multiplexor (MUX-1) muestra el resultado de las operaciones suma
(operation = 00) o resta (operation = 01), y la parte baja del resultado de las
operaciones multiplicacin (operation = 10) o divisin (operation = 11), que sera
z(4n-1:0).

El segundo multiplexor recibe a travs de sus dos primeros canales el valor de la seal
carry_out del Sumador/Restador (llamada c_out). Como este valor ocupa 1 solo bit, los
otros bits del dgito de menos peso sern 0 (el dgito de menor peso, 4n+3:4n, estar
formado por 0 0 0 c_out); los dems dgitos (8n-1:4n+4) sern 0. Para la multiplicacin y
la divisin mostrar la parte alta del resultado, los dgitos de mayor peso (8n-1:4n).

MUX-3 muestra el valor actual de la seal done, que estar a nivel alto excepto cuando se
realice el clculo de la multiplicacin o de la divisin (periodo en que la seal se pondr a
nivel bajo, debido a que done1 o done2 tomarn este valor).

A continuacin se muestra una simulacin del sistema con los parmetros n = 8 y p = 56
(en consecuencia logp = 6), para las diferentes operaciones:

Figura 3.38. Simulacin de la Unidad Aritmtica Decimal (suma y resta)

En este ejemplo podemos ver las operaciones suma y resta. Los valores de entrada son x =
00867335 e y = 02350927 (ambos de 8 dgitos BCD, ya que habamos establecido n = 8).
Primero se realiza la suma (operation = 00), siendo el resultado z = 03218262; como no
hay desbordamiento en el resultado, c_out (acarreo de salida) es 0. Al cambiar operation a
01 obtenemos la resta, siendo z = 01483592; en este caso el dgito de menor peso de la
parte alta de z es 1 (00000001), lo que indica que el resultado es negativo (z = 1483592).

Seguidamente mostramos la simulacin de la unidad cuando queremos realizar la
multiplicacin de dos valores (seleccionando operation = 10):


- 51 -

Figura 3.39. Simulacin de la Unidad Aritmtica Decimal (multiplicacin)

Al iniciarse el clculo, la seal que lo indica (done1) se pone a 0, lo que provoca que la
salida del sistema done tambin lo haga. Al acabar la ejecucin, done1 vuelve a nivel alto y
done tambin. Vemos como start1 se activa habilitando el multiplicador, en cambio start2
sigue a nivel bajo.

Por ltimo tenemos la simulacin de la unidad cuando ejecutamos la operacin de divisin
(operation = 11).

Figura 3.40. Simulacin de la Unidad Aritmtica Decimal (divisin)

Observamos la influencia de la seal done2 en done (tomando el valor 0 durante la
ejecucin, las p etapas que habamos explicado anteriormente). El resultado z se debe leer
como 0.3689331910348556.


4. MEMORIA EXPERIMENTAL

Diseo sobre FPGA de una Unidad Aritmtica Decimal Memoria experimental

- 53 -
4.1 Descripcin del proceso ........................................................................................................... 54
4.2 Especificaciones ........................................................................................................................ 54
4.3 Elementos necesarios................................................................................................................ 55
4.4 Arquitectura a desarrollar ...................................................................................................... 55
4.5 Mdulos IP de terceros utilizados........................................................................................... 57
4.5.1 Microcontrolador PicoBlaze (mdulo kcpsm.vhd)........................................................ 57
4.5.2 Interfaz LCD (mdulo lcd_interface.vhd)..................................................................... 58
4.6 Memoria de programa (mdulo program_memory.vhd) ................................................... 60
4.7 Generacin del circuito (mdulo main.vhd) ....................................................................... 62
4.8 Asignacin de pines en la FPGA (archivo pins.ucf) .......................................................... 63
4.9 Implementacin en la FPGA................................................................................................... 65
4.9.1 Generacin del archivo..................................................................................................... 66
4.9.2 Implementacin en la FPGA ............................................................................................ 68


- 54 -
4.1 Descripcin del proceso

En este captulo describiremos la implementacin del componente virtual que hemos
creado, la Unidad Aritmtica Decimal, en la plataforma FPGA Spartan-3E Starter Kit, con
el fin de comprobar su correcto funcionamiento.

Para ello debemos estructurar un sistema completo, con una CPU que gobierne el sistema,
una memoria de programa con el juego de instrucciones que se ejecutarn, una interfaz que
visualice los datos en la pantalla de la placa, y nuestra unidad, como principales elementos.

Como CPU utilizaremos un mdulo IP proporcionado por Xilinx, el microcontrolador de 8
bits PicoBlaze (kcpsm.vhd); para la interfaz de visualizacin de datos, el mdulo
lcd_interface.vhd, que es un mdulo previamente generado en proyectos anteriores

El primer paso consistir en la creacin de la memoria de programa que utilizar
PicoBlaze, utilizando la aplicacin pBlaze IDE. Despus crearemos un modelo VHDL que
incluya los mdulos mencionados antes. Por ltimo, implementaremos todo el diseo en la
FPGA mediante el paquete Xilinx ISE Desing Suite.

4.2 Especificaciones

Consideremos las dos lneas de 16 caracteres cada una que posee la placa, y que se
distribuyen de la siguiente manera: en la primera lnea, los 8 primeros dgitos (BCD)
corresponden al operando x, y los 8 ltimos al operando y. La segunda lnea ser el
resultado z.

Figura 4.1. Posicionamiento de los dgitos en el display

Un primer pulso (pulso 0) de synch (seal de sincronizacin) borra el display. Mediante los
interruptores SW3, SW2, SW1 y SW0 (pesos 8, 4, 2, 1 respectivamente) el dgito de
entrada, y con el pulsador synch procedemos a almacenarlo en el registro interno
correspondiente y visualizarlo en pantalla.

Tras haber introducido los 16 dgitos (los 8 primeros para el operando x y los 8 siguientes
para el operando y), un nuevo pulso de synch muestra en el display el resultado de la suma;
en los sucesivos pulsos de synch veremos los resultados de la resta, la multiplicacin y la
divisin. Un ltimo pulso (pulso 21) dar la seal para limpiar el visualizador.


- 55 -
La siguiente figura ilustra el proceso que acabamos de describir:

pulso 2 0 2
pulso 3 0 2 8
pulso 1 0
pulso 0
pulso 16 0 2 8 6 7 3 3 5 5 0 2 9 9 7 2 3
...
pulso 17 0 2 8 6 7 3 3 5 5 0 2 9 9 7 2 3
0 0 0 0 0 0 0 0 5 3 1 6 7 0 5 8
pulso 18 0 2 8 6 7 3 3 5 5 0 2 9 9 7 2 3
0 0 0 0 0 0 0 1 4 7 4 3 2 3 8 8
...
pulso 21

Figura 4.2. Funcionamiento del sistema

4.3 Elementos necesarios

De acuerdo a las especificaciones, precisamos los siguientes elementos de la Spartan-3E
Starter Kit:

Interruptores SW3, SW2, SW1, SW0 para seleccionar el dgito BCD de entrada
data_in.
Pulsadores para las seales synch (de sincronizacin) y reset.
Visualizador LCD de la placa.
Oscilador de 50 MHz.

4.4 Arquitectura a desarrollar

Debemos elaborar una arquitectura capaz de llevar a cabo el proceso descrito
anteriormente. Dicha arquitectura deber disponer (entre otras cosas) de:

Una CPU que controle la entrada de dgitos, la codificacin (a ASCII) de los datos
y la ejecucin de las diferentes operaciones. Las operaciones se definirn mediante
un juego de instrucciones en lenguaje ensamblador, que posteriormente formarn la
memoria de programa.
Una interfaz para el display LCD.
La Unidad Aritmtica Decimal.


- 56 -
Podemos definir la arquitectura del sistema mediante el siguiente diagrama de bloques:

15 . 0
Unidad Aritmtica
Decimal
z (15:0)
start
reset
clk
x (7:0) y (7:0) operation
clk
Registro
8*4 bits
PicoBlaze
(CPU and
program memory)
write_strobe
port_id reset
clk
in_port
out_port
data_in synch
mult_out
done
Registro Registro
clk
d_write i_write
temp_write
lcd_interface
lcd_data lcd_rs lcd_rw lcd_e
Registro
8*4 bits
Registro
2 bits
ready

Figura 4.3. Diagrama de bloques del sistema

Como CPU del sistema utilizaremos el microcontrolador PicoBlaze proporcionado por
Xilinx; emplearemos dos componentes virtuales ms, el modelo VHDL de una interfaz
LCD y nuestra Unidad Aritmtica Decimal, que es el mdulo que queremos testear.


- 57 -
4.5 Mdulos IP de terceros utilizados

En este apartado hablaremos un poco sobre los dos componentes virtuales que utilizaremos
y que son suministrados por terceros.

4.5.1 Microcontrolador PicoBlaze (mdulo kcpsm.vhd)

PicoBlaze es el nombre del modelo VHDL de un microcontrolador de 8 bits (KCPSM
Constant (K) Coded Programmable State Machine) desarrollado por Xilinx y que puede ser
integrado en las FPGA de la familia Spartan-3E, entre otras.

Este mdulo no requiere soporte externo y proporciona un entorno flexible para conectarlo
a otros componentes. Se suministra como descripcin VHDL.

El ensamblador pBlaze IDE permite crear el modelo VHDL de la memoria de programa
que utilizar el microcontrolador.

Algunas caractersticas de PicoBlaze son:

Posee 16 registros de 8 bits de propsito general (s0 a sF).
256 puertos de entrada y 256 de salida.
Rpida respuesta a interrupciones (el peor caso es de 5 ciclos de reloj).
Soporta programas de hasta 256 instrucciones.
El tamao de las instrucciones es de 16 bits.
Todas las instrucciones se ejecutan en 2 ciclos de reloj.

Estructura

A continuacin podemos ver el diagrama de bloques del mdulo PicoBlaze.

Figura 4.4. Diagrama de bloques del mdulo PicoBlaze


- 58 -
Arquitectura

Figura 4.5. Arquitectura interna de PicoBlaze

4.5.2 Interfaz LCD (mdulo lcd_interface.vhd)

Es un mdulo VHDL que aade la funcionalidad necesaria para presentar datos en el
visualizador de la FPGA.

d_write i_write temp_write
lcd_interface
ready
clk
reset

Figura 4.6. Mdulo lcd_interface


- 59 -
La entrada de 8 bits temp_write puede ser un carcter (cdigo ASCII) o un comando. La
entrada de control i_write enva el comando temp_write a la pantalla, y la entrada de
control d_write hace lo mismo pero con un carcter (Figura 4.7). La seal ready se activa
cuando la interfaz est disponible para una nueva operacin.

Figura 4.7. Operaciones

Este componente implementa internamente 4 retardos diferentes mediante un contador
programable, para una correcta visualizacin de los datos en el display:

very long: 3.2
18
clock cycles; at 50 MHz: 786,432 x 20 ns 16 ms;

long: 2
13
clock cycles; at 50 MHz: 8,19 x 20 ns 160 s;

short: 50 clock cycles; at 50 MHz: 50 x 20 ns = 1 s;

very short: 12 clock cycles; at 50 MHz: 12 x 20 ns = 240 ns.

Los comandos que utilizaremos son los siguientes:

comando (hex.) Operacin
01 Limpiar el display
80 Fijar el cursor al inicio de la primera lnea
C0 Fijar el cursor al inicio de la segunda lnea

Tabla 4.1. Comando utilizados


- 60 -
El diagrama de bloques de la interfaz LCD es el siguiente:

0 1 2 3
sel_delay
very_short
short long
very_long
load load
counter
time_out
(to control unit)
status
time_out
nibble
ce_cd
sel_nibble
sel_delay
load
reset
clk
i_write s_write ready
lcd_data lcd_e lcd_rs
lcd_write
(= 0)
ce
temp_write d_write
ce_cd
status
(to control unit)
cd(7..0)
cd(3..0) cd(7..4)
1 0
sel_nibble
nibble
(to control unit)
control unit

Figura 4.8. Circuito de la interfaz LCD

4.6 Memoria de programa (mdulo program_memory.vhd)

El primer paso consiste en realizar la memoria de programa. Para ello, realizaremos un
programa en lenguaje ensamblador (decimal_unit.asm) definiendo las direcciones de
entrada y salida, los registros que se emplearn y las instrucciones que se ejecutarn
(incluyendo un programa principal y diversas subrutinas). Este paso lo llevaremos a cabo
mediante la aplicacin pBlaze IDE, que nos permitir ensamblar y simular nuestro cdigo,
y generar, a partir de un modelo en blanco (my_ROM_blank.vhd) el modelo VHDL de
la memoria de programa (program_memory.vhd).

Definimos las direcciones de entrada segn la siguiente tabla:

seal direccin
z 00 a 0f
synch 10
data_in 11
ready 12
done 13

Tabla 4.2. Direcciones de entrada


- 61 -
Y las de salida:

seal direccin
y 00 a 07
x 08 a 0f
temp_wr 10
id_write 11
start 12
operation 13

Tabla 4.3. Direcciones de salida

El algoritmo utilizado sera el siguiente:

ext er nal l oop ( i nf i ni t e)
send command 01 ( cl ear ) t o di spl ay;
send command 80 ( cur sor addr ess = 00) t o di spl ay;
i nt er nal l oop ( 16 t i mes)
wai t f or a posi t i ve edge on synch;
st or e dat a_i n i n dat a;
wr i t e dat a i nt o x( i ) and y( i ) ;
encode dat a;
di spl ay char act er dat a;
end i nt er nal l oop;
st or e 01 ( addi t i on) i n dat a;
wr i t e dat a i nt o oper at i on;
di spl ay z;
st or e 02 ( subst r act i on) i n dat a;
di spl ay z;
st or e 03 ( mul t i pl i cat i on) i n dat a;
st ar t mul t i pl i er ;
wai t f or done;
di spl ay z;
st or e 04 ( di vi si on) i n dat a;
st ar t di vi der ;
wai t f or done;
di spl ay z;
end ext er nal l oop;

Con el objetivo de reducir el tamao del cdigo, se incluira una subrutina (entre otras) que
mostrara el resultado z en el visualizador despus de cada operacin:

subr out i ne di spl ay z;
send command c0 ( cur sor addr ess = 40) t o di spl ay;
i nt er nal l oop ( 16 t i mes)
st or e z( i ) i n dat a;
encode dat a;
di spl ay char act er dat a;
end i nt er nal l oop;


- 62 -
4.7 Generacin del circuito (mdulo main.vhd)

Con los modelos VHDL disponibles, el microcontrolador PicoBlaze (kcpsm.vhd) y la
memoria de programa (program_memory.vhd), la interfaz LCD (lcd_interface.vhd) y la
Unidad Aritmtica Decimal (arithmetic_unit.vhd), ya podemos disear nuestro circuito
completo. Aadiremos varios registros necesarios para el funcionamiento del sistema.

El diagrama de bloques es el que hemos mostrado antes:

15 . 0
Unidad Aritmtica
Decimal
z (15:0)
start
reset
clk
x (7:0) y (7:0) operation
clk
Registro
8*4 bits
PicoBlaze
(CPU and
program memory)
write_strobe
port_id reset
clk
in_port
out_port
data_in synch
mult_out
done
Registro Registro
clk
d_write i_write temp_write
lcd_interface
Registro
8*4 bits
Registro
2 bits
ready

Figura 4.9. Diagrama de bloques del sistema

Definiremos la Unidad Aritmtica Decimal con los siguientes parmetros:

n = 8, lo que quiere decir que los operandos x e y sern de 8 dgitos BCD cada uno,
p = 56, es el nmero de etapas que se ejecutarn para calcular el resultado cuando
realicemos la divisin,
logp = 6, que son los bits necesarios para representar el valor de p.


- 63 -
Utilizaremos 2 registros de 32 bits (8 dgitos BCD por 4 bits cada uno) para almacenar los
valores que se vayan introduciendo de los operandos x e y; en el caso de la seal operation
tendremos suficiente con un registro de 2 bits.

Otros 2 registros ms sern necesarios para las seales temp_write y i_write/d_write de la
interfaz LCD.

Tambin incluiremos un divisor de frecuencia ya que la proporcionada por el reloj de la
placa es demasiado alta (50 MHz). En el circuito se aaden cuatro divisores de frecuencia
que generan clk_2, clk_4, clk_8 y clk; esta ltima seal es la que se utilizar como seal de
reloj de los diferentes bloques del circuito. Cada divisor reduce la frecuencia anterior a la
mitad, por lo que tras 4 divisores, la frecuencia inicial de 50 MHz se dividir por 16 y
obtendremos una frecuencia de trabajo de 3.125 MHz.

4.8 Asignacin de pines en la FPGA (archivo pins.ucf)

El siguiente paso consiste en crear un archivo UCF (User Constraint File) que asigne las
seales que utilizamos a los pines correspondientes de la Spartan-3E. Las descripciones
necesarias para cada elemento de la placa se pueden encontrar en la Spartan-3E Starter Kit
Board User Guide.

Los interruptores SW3 (mayor peso), SW2, SW1 y SW0 (menor peso) sern asignados a
los siguientes pines (entre parntesis):

data_in<3> SW3 (N17)
data_in<2> SW2 (H18)
data_in<1> SW1 (L14)
data_in<0> SW0 (L13)

Figura 4.10. Distribucin de los interruptores SW


- 64 -
Pulsadores:

synch BTN_WEST (D18)
reset BTN_SOUTH (K17)

Figura 4.11. Pulsadores disponibles en la placa

Seal de reloj:

ext_clk CLK_50MHz (C9)

Figura 4.12. Seales de reloj disponibles

Seales de la interfaz LCD:

Seal Nombre interno PIN asociado
lcd_e LCD_E M18
lcd_rs LCD_RS L18
lcd_rw LCD_RW L17
lcd_data<3> SF_D<11> M15
lcd_data<2> SF_D<10> P17
lcd_data<1> SF_D<9> R16
lcd_data<0> SF_D<8> R15

Tabla 4.4. Asignacin de pines para la interfaz LCD


- 65 -

Figura 4.13. Interfaz LCD

4.9 Implementacin en la FPGA

Ahora que disponemos del modelo VHDL del circuito completo (main.vhd), con los
diferentes componentes virtuales que lo integran (kcpsm.vhd, arithmetic_unit.vhd,
lcd_interface.vhd, program_memory.vhd) y del archivo de asignacin de pines (pins.ucf),
procederemos a sintetizarlo e implementarlo en la FPGA.

Para ello utilizaremos la aplicacin Xilinx ISE Design Suite 11, con dos de sus programas,
ISE Project Navigator para generar el archivo e iMPACT para grabarlo en la placa.

Para mayor comodidad nuestra, uniremos en un solo archivo VHDL todos los
componentes que conforman la Unidad Aritmtica Decimal; este archivo ser el
blocks_uad.vhd. Por tanto, el listado de programas utilizado ser el siguiente:

blocks_uad.vhd
kcpsm.vhd
lcd_interface.vhd
main.vhd
pins.ucf
program_memory.vhd


- 66 -
4.9.1 Generacin del archivo

Abrimos el programa ISE Project Navigator y creamos un nuevo proyecto (New Project) y
escogemos un nombre para l. El siguiente paso es seleccionar las caractersticas del
dispositivo que estamos utilizando, que en nuestro caso sern las siguientes:

Figura 4.14. Caractersticas de la FPGA

Aadimos los modelos VHDL y el archivo pins.ucf:

Figura 4.15. Archivos utilizados en el proyecto


- 67 -
Y vemos el dispositivo y los archivos que dependen de l:

Figura 4.16. Jerarqua del sistema completo

El primer paso consiste en sintetizar el modelo (Synthesize - XST); esto genera un reporte
que indica los recursos necesarios estimados para el dispositivo:

Tabla 4.5. Utilizacin del dispositivo

Ahora realizamos la implementacin (Implement Design), el Placement & Routing, que
nos da una descripcin concreta de los recursos necesarios de la FPGA para grabar nuestro
diseo:

Tabla 4.6. Utilizacin del dispositivo


- 68 -
El siguiente paso consiste en generar el archivo de programacin (Generate Programming
File). Ya tenemos creado nuestro archivo main.bit que ser el que bajemos a la placa.

4.9.2 Implementacin en la FPGA

Grabaremos nuestro diseo (archivo main.bit) a travs del puerto USB de la Spartan-3E.

Desde Configure Target Device, seleccionamos Manage Configuration Project (iMPACT),
los que nos llevar a la aplicacin iMPACT. A travs de Boundary Scan, buscamos el
dispositivo (Initialize Chain) y se muestra en pantalla:

Figura 4.17. Componentes disponibles de la FPGA

El componente xc3s500e corresponde a la FPGA y es donde programaremos nuestro
diseo. Los otros dos componentes pertenecen a la memoria Platform Flash y al CPLD
que hay integrados en la placa.

Asignamos el archivo main.bit a la FPGA y los otros dos componentes los dejamos como
estn (Bypass). Ejecutamos Program en xc3s500e y ya tenemos la unidad operativa (el led
DONE de la placa se enciende indicando que el proceso de implementacin se ha
completado correctamente).

Figura 4.18. FPGA disponible para su utilizacin

- 69 -
A continuacin se muestran unas ilustraciones con ejemplos de las diferentes operaciones,
siendo los operandos x = 2867335 e y = 50299723:

Suma: el resultado es 53167058.

Figura 4.19. Resultado de la suma

Resta: el resultado es 47432388. Es negativo porque el dgito z
8
(segn la Figura
4.1) es 1.

Figura 4.20. Resultado de la resta

Multiplicacin: el resultado es 144226156248205.

Figura 4.21. Resultado de la multiplicacin

Divisin: el resultado se ha de interpretar como 0.0570049858922682.

Figura 4.22. Resultado de la divisin


5. ANEXOS

Diseo sobre FPGA de una Unidad Aritmtica Decimal Anexos

- 71 -
5.1 Modelos VHDL......................................................................................................................... 72
5.1.1 Sumador de 1 dgito BCD (one_digit_adder.vhd)............................................................ 72
5.1.2 Complemento a 9 (nine_complement.vhd) ....................................................................... 73
5.1.3 Sumador/Restador de n dgitos decimales (n_adder_subs.vhd) ....................................... 73
5.1.4 Multiplicador de 1x1 dgitos BCD (one_digit_multiplier.vhd) ........................................ 75
5.1.5 Multiplicador de Nx1 dgitos BCD (n_by_one_multiplier.vhd) ....................................... 76
5.1.6 Multiplicador de NxM dgitos BCD (n_by_m_multiplier.vhd) ........................................ 78
5.1.7 Divisor BCD (divider.vhd) ............................................................................................... 80
5.1.8 Unidad Aritmtica Decimal (arithmetic_unit.vhd) ........................................................... 83
5.1.9 Memoria de programa (program_memory.vhd) ............................................................... 86
5.1.10 Circuito completo (main.vhd) ......................................................................................... 89
5.2 Programa en lenguaje ensamblador (decimal_unit.asm) ...................................................... 94
5.3 Asignacin de pines en la Spartan-3E (pins.ucf) .................................................................... 97


- 72 -
5.1 Modelos VHDL

A continuacin se detallan los diferentes modelos VHDL creados en los apartados
anteriores.

5.1.1 Sumador de 1 dgito BCD (one_digit_adder.vhd)

- - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - -
- - Ent i dad del sumador de 1 d gi t o deci mal
- - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - -
LI BRARY I EEE;
USE I EEE. STD_LOGI C_1164. ALL;
USE I EEE. STD_LOGI C_ARI TH. ALL;
USE I EEE. STD_LOGI C_UNSI GNED. ALL;

ENTI TY one_di gi t _adder I S PORT(
a: I N STD_LOGI C_VECTOR( 3 DOWNTO 0) ;
b: I N STD_LOGI C_VECTOR( 3 DOWNTO 0) ;
c: OUT STD_LOGI C_VECTOR( 3 DOWNTO 0) ;
cy_i n: I N STD_LOGI C; - - car r y de ent r ada al bl oque
cy_out : I NOUT STD_LOGI C) ; - - car r y de sal i da del bl oque
END one_di gi t _adder ;

- - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - -
- - Ar qui t ect ur a del sumador de 1 d gi t o deci mal
- - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - -
LI BRARY I EEE;

ARCHI TECTURE ar chi t ect ur e_oda OF one_di gi t _adder I S

- - Decl ar aci n de seal es
SI GNAL d: STD_LOGI C_VECTOR( 4 DOWNTO 0) ;
SI GNAL cor r ect i on: STD_LOGI C_VECTOR( 3 DOWNTO 0) ;

- - I ni ci o
BEGI N

d <= ' 0' & a + b + cy_i n;

cy_out <= d( 4) OR ( d( 3) AND ( d( 2) OR d( 1) ) ) ; - - cr ea car r y de sal i da
- - si d>9
cor r ect i on <= ' 0' & cy_out & cy_out & ' 0' ; - - se pone a ' 0110' si hay
- - car r y de sal i da
c <= d( 3 DOWNTO 0) + cor r ect i on; - - apl i ca l a cor r ecci n si
- - hay car r y de sal i da

END ar chi t ect ur e_oda;


- 73 -
5.1.2 Complemento a 9 (nine_complement.vhd)

- - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - -
- - Ent i dad del bl oque de compl ement o a 9
- - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - -
LI BRARY I EEE;

ENTI TY ni ne_compl ement I S
PORT(
e: I N STD_LOGI C_VECTOR( 3 DOWNTO 0) ; - - d gi t o de ent r ada
add_sub: I N STD_LOGI C; - - seal de cont r ol del bl oque
s: OUT STD_LOGI C_VECTOR( 3 DOWNTO 0) ) ; - - d gi t o de sal i da
END ni ne_compl ement ;

- - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - -
- - Ar qui t ect ur a del bl oque de compl ement o a 9
- - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - -
LI BRARY I EEE;

ARCHI TECTURE ar chi t ect ur e_nc OF ni ne_compl ement I S

BEGI N

s( 0) <= ( NOT( add_sub) AND e( 0) ) OR ( add_sub AND NOT( e( 0) ) ) ;
s( 1) <= e( 1) ;
s( 2) <= ( NOT( add_sub) AND e( 2) ) OR ( add_sub AND ( e( 1) XOR e( 2) ) ) ;
s( 3) <= ( NOT( add_sub) AND e( 3) ) OR ( add_sub AND ( NOT( e( 1) ) AND
NOT( e( 2) ) AND NOT( e( 3) ) ) ) ;

END ar chi t ect ur e_nc;

5.1.3 Sumador/Restador de n dgitos decimales (n_adder_subs.vhd)

- - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - -
- - Ent i dad del sumador / r est ador de n d gi t os deci mal es
- - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - -
LI BRARY I EEE;

ENTI TY n_adder _subs I S
GENERI C ( n: nat ur al ) ;
PORT(
x: I N STD_LOGI C_VECTOR( 4*n- 1 DOWNTO 0) ; - - ent r ada de n d gi t os BCD
y: I N STD_LOGI C_VECTOR( 4*n- 1 DOWNTO 0) ; - - ent r ada de n d gi t os BCD
add_sub: I N STD_LOGI C; - - oper aci n: ' 0' suma y ' 1' r est a
z: OUT STD_LOGI C_VECTOR( 4*n- 1 DOWNTO 0) ; - - sal i da de n d gi t os BCD
car r y_out : OUT STD_LOGI C) ; - - acar r eo de sal i da
END n_adder _subs;


- 74 -
- - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - -
- - Ar qui t ect ur a del sumador / r est ador de n d gi t os deci mal es
- - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - -
LI BRARY I EEE;

ARCHI TECTURE ar chi t ect ur e_nas OF n_adder _subs I S

- - Decl ar aci n de const ant es
CONSTANT i 1: STD_LOGI C_VECTOR( 4*n- 1 DOWNTO 0) : =
CONV_STD_LOGI C_VECTOR( 1, 4*n) ;

SI GNAL car r i es, car r i es2: STD_LOGI C_VECTOR( n DOWNTO 0) ;
SI GNAL y1: STD_LOGI C_VECTOR( 4*n- 1 DOWNTO 0) ;
SI GNAL z1, z2, z3: STD_LOGI C_VECTOR( 4*n- 1 DOWNTO 0) ;
SI GNAL oc, out put _sel ect i on: STD_LOGI C;

- - Decl ar aci n de component es
COMPONENT one_di gi t _adder I S PORT(
END COMPONENT;

COMPONENT ni ne_compl ement PORT( - - bl oque que compl ement a a 9
e: I N STD_LOGI C_VECTOR( 3 DOWNTO 0) ; - - d gi t o de ent r ada
add_sub: I N STD_LOGI C; - - seal de cont r ol del bl oque
s: OUT STD_LOGI C_VECTOR( 3 DOWNTO 0) ) ; - - d gi t o de sal i da
END COMPONENT;

- - I ni ci o
BEGI N
car r i es( 0) <= add_sub;

a1_i t er at i on: FOR i I N 0 TO n- 1 GENERATE - - Compl ement o a 9 de ' y'
ni ne_compl : ni ne_compl ement PORT MAP( - - en f unci n de ' add_sub'
e => y( 4*i +3 DOWNTO 4*i ) ,
add_sub => add_sub,
s => y1( 4*i +3 DOWNTO 4*i ) ) ;
END GENERATE;

a2_i t er at i on: FOR i I N 0 TO n- 1 GENERATE
addi t i on: one_di gi t _adder PORT MAP(
a => x( 4*i +3 DOWNTO 4*i ) ,
b => y1( 4*i +3 DOWNTO 4*i ) ,
c => z1( 4*i +3 DOWNTO 4*i ) ,
cy_i n => car r i es( i ) ,
cy_out => car r i es( i +1) ) ;
END GENERATE;

oc <= car r i es( n) ; - - seal que ut i l i zamos si el car r y de
- - de sal i da es 0, r esul t ado negat i vo


- 75 -
b1_i t er at i on: FOR i I N 0 TO n- 1 GENERATE - - bl oque que compl ement a a 9
ni ne_compl _2: ni ne_compl ement PORT MAP( - - cuando el r esul t ado
e => z1( 4*i +3 DOWNTO 4*i ) , - - ant er i or sea negat i vo
add_sub => add_sub,
s => z2( 4*i +3 DOWNTO 4*i ) ) ;
END GENERATE;

car r i es2( 0) <= ' 0' ;

b2_i t er at i on: FOR i I N 0 TO n- 1 GENERATE - - bl oque ut i l i zado par a
addi t i on_2: one_di gi t _adder PORT MAP( - - sumar 1 en BCD al
a => z2( 4*i +3 DOWNTO 4*i ) , - - compl ement o a nueve
b => i 1( 4*i +3 DOWNTO 4*i ) , - - gener ado ant es
c => z3( 4*i +3 DOWNTO 4*i ) ,
cy_i n => car r i es2( i ) ,
cy_out => car r i es2( i +1) ) ;
END GENERATE;

out put _sel ect i on <= add_sub AND NOT( oc) ;

WI TH out put _sel ect i on SELECT z <= z3 WHEN ' 1' , z1 WHEN OTHERS;

car r y_out <= oc XOR add_sub;
- - Si l a oper aci n es suma: car r y_out = ' 0' => r esul t ado exact o
- - Si l a oper aci n es suma: car r y_out = ' 1' => hay desbor dami ent o,
- - aadi r un ' 1' a l a i zqui er da
- - Si l a oper aci n es r est a: car r y_out = ' 0' => r esul t ado no negat i vo
- - Si l a oper aci n es r est a: car r y_out = ' 1' => r esul t ado negat i vo

END ar chi t ect ur e_nas;

5.1.4 Multiplicador de 1x1 dgitos BCD (one_digit_multiplier.vhd)

- - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - -
- - Ent i dad del mul t i pl i cador de 1 d gi t o deci mal
- - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - -
LI BRARY I EEE;

ENTI TY one_di gi t _mul t i pl i er I S PORT(
a: I N STD_LOGI C_VECTOR( 3 DOWNTO 0) ; - - ent r ada de 1 d gi t o BCD
b: I N STD_LOGI C_VECTOR( 3 DOWNTO 0) ; - - ent r ada de 1 d gi t o BCD
d: OUT STD_LOGI C_VECTOR( 3 DOWNTO 0) ; - - sal i da de 1 d gi t o BCD
u: OUT STD_LOGI C_VECTOR( 3 DOWNTO 0) ) ; - - sal i da de 1 d gi t o BCD
END one_di gi t _mul t i pl i er ;

- - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - -
- - Ar qui t ect ur a del mul t i pl i cador de 1 d gi t o deci mal
- - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - -
LI BRARY I EEE;

ARCHI TECTURE ar chi t ect ur e_odmOF one_di gi t _mul t i pl i er I S


- 76 -
SI GNAL p: STD_LOGI C_VECTOR( 7 DOWNTO 0) ;
SI GNAL uu: STD_LOGI C_VECTOR( 4 DOWNTO 0) ;
SI GNAL dd: STD_LOGI C_VECTOR( 3 DOWNTO 0) ;
SI GNAL gt 9, gt 20, gt 10st 19: STD_LOGI C;

- - I ni ci o
BEGI N

p <= a*b; - - pr oduct o bi nar i o

uu <= p( 3 DOWNTO 0) + ( " 00" &p( 4) &p( 4) &' 0' ) + ( " 00" &p( 6 DOWNTO 5) &' 0' ) ;
dd <= p( 6 DOWNTO 4) + ( " 00" &p( 6 DOWNTO 5) ) ;

gt 9 <= uu( 4) OR ( uu( 3) AND ( uu( 2) OR uu( 1) ) ) ; - - mayor a 9
gt 20 <= uu( 4) AND ( uu( 3) OR uu( 2) ) ; - - mayor a 19
gt 10st 19 <= gt 9 AND NOT( gt 20) ; - - ent r e 10 y 19

d <= dd + ( ' 0' & ' 0' & gt 20 & gt 10st 19) ;
u <= uu( 3 DOWNTO 0) + ( gt 20 & gt 9 & gt 10st 19 & ' 0' ) ;

END ar chi t ect ur e_odm;

5.1.5 Multiplicador de Nx1 dgitos BCD (n_by_one_multiplier.vhd)

- - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - -
- - Ent i dad del mul t i pl i cador de Nx1 d gi t os deci mal es
- - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - -
LI BRARY I EEE;

ENTI TY n_by_one_mul t i pl i er I S
PORT(
y: I N STD_LOGI C_VECTOR( 3 DOWNTO 0) ; - - ent r ada de 1 d gi t o BCD
z: OUT STD_LOGI C_VECTOR( 4*n+3 DOWNTO 0) ) ; - - sal i da de n d gi t os BCD
END n_by_one_mul t i pl i er ;

- - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - -
- - Ar qui t ect ur a del mul t i pl i cador de Nx1 d gi t os deci mal es
- - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - -
LI BRARY I EEE;

ARCHI TECTURE ar chi t ect ur e_nbomOF n_by_one_mul t i pl i er I S

SI GNAL dd, uu: STD_LOGI C_VECTOR( 4*n- 1 DOWNTO 0) ;
SI GNAL ddc, uuc: STD_LOGI C_VECTOR( 4*n+3 DOWNTO 0) ;
SI GNAL car r i es: STD_LOGI C_VECTOR( n+1 DOWNTO 0) ;


- 77 -
COMPONENT one_di gi t _mul t i pl i er I S PORT(
a: I N STD_LOGI C_VECTOR( 3 DOWNTO 0) ; - - ent r ada de 1 d gi t o BCD
b: I N STD_LOGI C_VECTOR( 3 DOWNTO 0) ; - - ent r ada de 1 d gi t o BCD
d: OUT STD_LOGI C_VECTOR( 3 DOWNTO 0) ; - - sal i da de 1 d gi t o BCD
u: OUT STD_LOGI C_VECTOR( 3 DOWNTO 0) ) ; - - sal i da de 1 d gi t o BCD
END COMPONENT;

COMPONENT one_di gi t _adder I S PORT(
END COMPONENT;

- - I ni ci o
BEGI N
a_i t er at i on: FOR i I N 0 TO n- 1 GENERATE
mul t i pl i er : one_di gi t _mul t i pl i er PORT MAP(
a => x( 4*i +3 DOWNTO 4*i ) ,
b => y,
d => dd( 4*i +3 DOWNTO 4*i ) ,
u => uu( 4*i +3 DOWNTO 4*i ) ) ;
END GENERATE;

ddc <= dd & " 0000" ;
uuc <= " 0000" & uu;

car r i es( 0) <= ' 0' ;

b_i t er at i on: FOR i I N 0 TO n GENERATE
adder : one_di gi t _adder PORT MAP(
a => ddc( 4*i +3 DOWNTO 4*i ) ,
b => uuc( 4*i +3 DOWNTO 4*i ) ,
c => z( 4*i +3 DOWNTO 4*i ) ,
cy_i n => car r i es( i ) ,
cy_out => car r i es( i +1) ) ;
END GENERATE;

END ar chi t ect ur e_nbom;


- 78 -
5.1.6 Multiplicador de NxM dgitos BCD (n_by_m_multiplier.vhd)

- - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - -
- - Ent i dad del mul t i pl i cador de N x M d gi t os deci mal es
- - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - -
LI BRARY I EEE;

ENTI TY n_by_m_mul t i pl i er I S
GENERI C ( n, m: nat ur al ) ;
PORT(
y: I N STD_LOGI C_VECTOR( 4*m- 1 DOWNTO 0) ; - - ent r ada de md gi t os BCD
st ar t : I N STD_LOGI C; - - seal de i ni ci o
cl k: I N STD_LOGI C; - - seal de r el oj
r eset : I N STD_LOGI C; - - i ni ci al i za l a oper aci n
z: I NOUT STD_LOGI C_VECTOR( 4*( n+m) - 1 DOWNTO 0) ; - - sal i da de N+M
- - d gi t os BCD
done: OUT STD_LOGI C) ; - - r esul t ado di sponi bl e
END n_by_m_mul t i pl i er ;

- - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - -
- - Ar qui t ect ur a del mul t i pl i cador de N x M d gi t os deci mal es
- - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - -
LI BRARY I EEE;

ARCHI TECTURE ar chi t ect ur e_nbmmOF n_by_m_mul t i pl i er I S

- - Decl ar aci n de est ados
TYPE st at es I S RANGE 0 TO 3;
SI GNAL cur r ent _st at e: st at es;

CONSTANT i ni t i al _zer oes: STD_LOGI C_VECTOR( 4*m- 5 DOWNTO 0) : = ( OTHERS =>
' 0' ) ;

SI GNAL i nt _y: STD_LOGI C_VECTOR( 4*m+3 DOWNTO 0) ; - - r egi st r o y
- - el r egi st r o z se decl ar a en l a ent i dad
SI GNAL x_by_yi : STD_LOGI C_VECTOR( 4*n+3 DOWNTO 0) ;
SI GNAL next _z: STD_LOGI C_VECTOR( 4*( n+m) - 1 DOWNTO 0) ;
SI GNAL z_by_10, l ong_x_by_yi : STD_LOGI C_VECTOR( 4*( n+m) - 1 DOWNTO 0) ;
SI GNAL l oad, shi f t , end_of _comput at i on: STD_LOGI C;

COMPONENT n_by_one_mul t i pl i er I S - - mul t i pl i cador de Nx1 d gi t os BCD
PORT(
END COMPONENT;


- 79 -
COMPONENT n_adder _subs I S - - Sumador / r est ador ut i l i zado par a sumar
PORT(
END COMPONENT;

- - I ni ci o
BEGI N

mul t i pl i er : n_by_one_mul t i pl i er
GENERI C MAP( n => n)
PORT MAP(
x => x,
y => i nt _y( 4*m+3 DOWNTO 4*m) ,
z => x_by_yi ) ;

l ong_x_by_yi <= i ni t i al _zer oes&x_by_yi ; - - equi par amos l as dos ent r adas
- - del sumador en cuant o a
- - nmer o de d gi t os
adder : n_adder _subs
GENERI C MAP( n => n+m)
PORT MAP(
x => l ong_x_by_yi ,
y => z_by_10,
add_sub => ' 0' , - - oper aci n a r eal i zar : suma
z => next _z) ;

z_by_10 <= z( 4*( n+m) - 5 DOWNTO 0) &" 0000" ; - - mul t i pl i camos z por 10

- - Sent enci as secuenci al es
r egi st er _y: PROCESS( cl k)
BEGI N
I F cl k' EVENT AND cl k = ' 1' THEN
I F l oad = ' 1' THEN i nt _y <= y & " 1111" ;
ELSI F shi f t = ' 1' THEN i nt _y <= i nt _y( 4*m- 1 DOWNTO 0) & " 0000" ;
END I F;
END I F;
END PROCESS;

r egi st er _z: PROCESS( cl k)
BEGI N
I F l oad = ' 1' THEN z <= ( OTHERS => ' 0' ) ;
ELSI F shi f t = ' 1' THEN z <= next _z;
END I F;
END I F;
END PROCESS;

end_of _comput at i on <= i nt _y( 4*m+3) AND i nt _y( 4*m+2) ;


- 80 -
- - Uni dad de cont r ol
cont r ol _uni t _out put : PROCESS( cur r ent _st at e, end_of _comput at i on)
BEGI N
CASE cur r ent _st at e I S
WHEN 0 t o 1 => shi f t <= ' 0' ; l oad <= ' 0' ; done <= ' 1' ;
WHEN 2 => shi f t <= ' 0' ; l oad <= ' 1' ; done <= ' 0' ;
WHEN 3 => I F end_of _comput at i on = ' 0' THEN shi f t <= ' 1' ;
ELSE shi f t <= ' 0' ; END I F; l oad <= ' 0' ; done <= ' 0' ;
END CASE;
END PROCESS;

cont r ol _uni t _next _st at e: PROCESS( cl k, r eset )
BEGI N
I F r eset = ' 1' THEN cur r ent _st at e <= 0;
ELSI F cl k' event AND cl k = ' 1' THEN
WHEN 0 => I F st ar t = ' 0' THEN cur r ent _st at e <= 1; END I F;
WHEN 2 => cur r ent _st at e <= 3;
WHEN 3 => I F end_of _comput at i on = ' 1' THEN
cur r ent _st at e <= 0; END I F;
END CASE;
END I F;
END PROCESS;

END ar chi t ect ur e_nbmm;

5.1.7 Divisor BCD (divider.vhd)

- - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - -
- - Ent i dad del di vi sor de n d gi t os deci mal es
- - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - -
LI BRARY I EEE;

ENTI TY deci mal _di vi der I S
GENERI C ( n, m, p, l ogp: nat ur al ) ;
PORT(
x: I N STD_LOGI C_VECTOR( 4*n- 1 DOWNTO 0) ; - - di vi dendo
y: I N STD_LOGI C_VECTOR( 4*n- 1 DOWNTO 0) ; - - di vi sor
r eset : I N STD_LOGI C; - - i ni ci al i za oper aci n
q: OUT STD_LOGI C_VECTOR( 4*m- 1 DOWNTO 0) ; - - r esul t ado ( coci ent e)
done: OUT STD_LOGI C) ; - - oper aci n r eal i zada
END deci mal _di vi der ;


- 81 -
- - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - -
- - Ar qui t ect ur a del di vi sor de n d gi t os deci mal es
- - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - -
LI BRARY I EEE;

ARCHI TECTURE ar chi t ect ur e_di vi der OF deci mal _di vi der I S

- - Decl ar aci n de est ados
TYPE st at es I S RANGE 0 TO 3;
SI GNAL cur r ent _st at e: st at es;

CONSTANT i ni t i al _zer oes: STD_LOGI C_VECTOR( 4*p- 9 DOWNTO 0) : = (
OTHERS => ' 0' ) ;
CONSTANT i ni t i al _zer oes_2: STD_LOGI C_VECTOR( 4*p- 5 DOWNTO 0) : = (
OTHERS => ' 0' ) ;

SI GNAL r , s1: STD_LOGI C_VECTOR( 4*n- 1 DOWNTO 0) ;
SI GNAL r r , r r _y, yy: STD_LOGI C_VECTOR( 4*n+3 DOWNTO 0) ;
SI GNAL qq, ul p, qq_ul p, s2: STD_LOGI C_VECTOR( 4*p- 1 DOWNTO 0) ;
SI GNAL c_out : STD_LOGI C;
SI GNAL l oad, ce, zer o: STD_LOGI C;
SI GNAL ul p_by_5: STD_LOGI C_VECTOR( 4*p+3 DOWNTO 0) ;
SI GNAL count : STD_LOGI C_VECTOR( l ogp- 1 DOWNTO 0) ;

COMPONENT n_by_one_mul t i pl i er I S - - mul t i pl i cador de Nx1 d gi t os BCD
PORT(
END COMPONENT;

COMPONENT n_adder _subs I S - - Sumador / r est ador ut i l i zado par a sumar
PORT(
END COMPONENT;

- - I ni ci o
BEGI N

yy <= " 0000" & y; - - Aadi mos un 0 deci mal a ' y' par a i gual ar l a
- - en nmer o de d gi t os a r r ( 2r )

mul t i pl i er _r _by_2: n_by_one_mul t i pl i er - - Mul t i pl i cador de r x 2
PORT MAP(
x => r ,
y => " 0010" , - - 2 en deci mal
z => r r ) ; - - r esul t ado 2r


- 82 -
subt r act i on: n_adder _subs - - Rest ador par a r eal i zar 2r - y
GENERI C MAP( n => n+1)
PORT MAP(
x => r r , - - 2r
y => yy,
add_sub => ' 1' , - - Rest a como oper aci n a r eal i zar
z => r r _y, - - r esul t ado de 2r - y
car r y_out => c_out ) ;

WI TH NOT( c_out ) SELECT s1 <= r r ( 4*n- 1 DOWNTO 0) WHEN ' 0' , r r _y( 4*n- 1
DOWNTO 0) WHEN OTHERS;

addi t i on: n_adder _subs - - Sumador par a r eal i zar qq + ul p
GENERI C MAP( n => p)
PORT MAP(
x => qq,
y => ul p,
add_sub => ' 0' , - - Suma como oper aci n a r eal i zar
z => qq_ul p) ;

WI TH NOT( c_out ) SELECT s2 <= qq WHEN ' 0' , qq_ul p WHEN OTHERS;

mul t i pl i er _ul p_by_5: n_by_one_mul t i pl i er - - Mul t i pl i cador de ul p x 5
GENERI C MAP( n => p)
PORT MAP(
x => ul p,
y => " 0101" , - - 5 en BCD
z => ul p_by_5) ; - - r esul t ado 5*ul p

q <= qq( 4*p- 1 DOWNTO 4*( p- m) ) ; - - Los md gi t os ms si gni f i cat i vos
- - de qq
- - Sent enci as secuenci al es
r egi st er _r : PROCESS( cl k)
BEGI N
I F l oad = ' 1' THEN r <= x; - - El val or i ni ci al de r es x
ELSI F ce = ' 1' THEN r <= s1; - - Act ual i za el val or de r
END I F;
END I F;
END PROCESS;

r egi st er _qq: PROCESS( cl k)
BEGI N
I F l oad = ' 1' THEN qq <= ( OTHERS => ' 0' ) ; - - Val or i ni ci al de qq es 0
ELSI F ce = ' 1' THEN qq <= s2; - - Act ual i za el val or de qq
END I F;
END I F;
END PROCESS;

r egi st er _ul p: PROCESS( cl k)
BEGI N
I F l oad = ' 1' THEN ul p <= " 0101" & i ni t i al _zer oes_2;
- - El val or i ni ci al es 5, que r epr esent a 0. 5
ELSI F ce = ' 1' THEN ul p <= ul p_by_5( 4*p+3 DOWNTO 4) ; - - Act ual i za ul p
END I F;
END I F;
END PROCESS;


- 83 -
- - Cont ador de p est ados
count er _st ages: PROCESS( cl k)
BEGI N
I F l oad = ' 1' THEN count <= CONV_STD_LOGI C_VECTOR( p- 1, l ogp) ;
ELSI F ce = ' 1' THEN count <= count - 1;
END I F;
END I F;
END PROCESS;

zer o <= ' 1' WHEN count = " 0" ELSE ' 0' ;

- - Uni dad de cont r ol
cont r ol _uni t : PROCESS( cl k, r eset , cur r ent _st at e, zer o)
BEGI N
WHEN 0 t o 1 => l oad <= ' 0' ; ce <= ' 0' ; done <= ' 1' ;
WHEN 2 => l oad <= ' 1' ; ce <= ' 0' ; done <= ' 0' ;
WHEN 3 => l oad <= ' 0' ; ce <= ' 1' ; done <= ' 0' ;
END CASE;
I F r eset = ' 1' THEN cur r ent _st at e <= 0;
ELSI F cl k' EVENT AND cl k = ' 1' THEN
WHEN 2 => cur r ent _st at e <= 3;
WHEN 3 => I F zer o = ' 1' THEN cur r ent _st at e <= 0; END I F;
END CASE;
END I F;
END PROCESS;

END ar chi t ect ur e_di vi der ;

5.1.8 Unidad Aritmtica Decimal (arithmetic_unit.vhd)

- - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - -
- - Ent i dad de l a uni dad ar i t mt i ca deci mal
- - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - -
LI BRARY I EEE;

ENTI TY ar i t hmet i c_uni t I S
GENERI C ( n, p, l ogp: NATURAL) ;
PORT(
x: I N STD_LOGI C_VECTOR( 4*n- 1 DOWNTO 0) ; - - oper ando x
y: I N STD_LOGI C_VECTOR( 4*n- 1 DOWNTO 0) ; - - oper ando y
oper at i on: I N STD_LOGI C_VECTOR( 1 DOWNTO 0) ; - - oper aci n
r eset : I N STD_LOGI C; - - i ni ci al i za
z: OUT STD_LOGI C_VECTOR( 8*n- 1 DOWNTO 0) ; - - r esul t ado
done: OUT STD_LOGI C) ; - - oper aci n l i st a
END ar i t hmet i c_uni t ;


- 84 -
- - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - -
- - Ar qui t ect ur a de l a uni dad ar i t mt i ca deci mal
- - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - -
LI BRARY I EEE;

ARCHI TECTURE ar chi t ect ur e_au OF ar i t hmet i c_uni t I S

SI GNAL s1: STD_LOGI C_VECTOR( 4*n- 1 DOWNTO 0) ;
SI GNAL s2, s3: STD_LOGI C_VECTOR( 8*n- 1 DOWNTO 0) ;
SI GNAL c_out , done1, done2: STD_LOGI C;
SI GNAL st ar t 1, st ar t 2: STD_LOGI C;

COMPONENT n_adder _subs I S
PORT(
END COMPONENT;

COMPONENT n_by_m_mul t i pl i er I S
GENERI C ( n, m: nat ur al ) ;
PORT(
y: I N STD_LOGI C_VECTOR( 4*m- 1 DOWNTO 0) ; - - ent r ada de md gi t os BCD
r eset : I N STD_LOGI C; - - i ni ci al i za l a oper aci n
z: I NOUT STD_LOGI C_VECTOR( 4*( n+m) - 1 DOWNTO 0) ; - - sal i da de N+M
- - d gi t os BCD
done: OUT STD_LOGI C) ; - - r esul t ado di sponi bl e
END COMPONENT;

COMPONENT deci mal _di vi der I S
GENERI C ( n, m, p, l ogp: nat ur al ) ;
PORT(
x: I N STD_LOGI C_VECTOR( 4*n- 1 DOWNTO 0) ; - - di vi dendo
y: I N STD_LOGI C_VECTOR( 4*n- 1 DOWNTO 0) ; - - di vi sor
r eset : I N STD_LOGI C; - - i ni ci al i za oper aci n
q: OUT STD_LOGI C_VECTOR( 4*m- 1 DOWNTO 0) ; - - r esul t ado ( coci ent e)
done: OUT STD_LOGI C) ; - - oper aci n r eal i zada
END COMPONENT;

- - I ni ci o
BEGI N

st ar t 1 <= st ar t AND NOT( oper at i on( 0) ) AND oper at i on( 1) ;
st ar t 2 <= st ar t AND oper at i on( 0) AND oper at i on( 1) ;


- 85 -
addi t i on_subst r act i on: n_adder _subs
PORT MAP(
x => x,
y => y,
add_sub => oper at i on( 0) ,
z => s1,
car r y_out => c_out ) ;

mul t i pl i er : n_by_m_mul t i pl i er
GENERI C MAP( n => n, m=> n)
PORT MAP(
x => x,
y => y,
st ar t => st ar t 1,
cl k => cl k,
r eset => r eset ,
z => s2,
done => done1) ;

di vi der : deci mal _di vi der
GENERI C MAP( n => n, m=> 2*n, p => p, l ogp => l ogp)
PORT MAP(
x => x,
y => y,
st ar t => st ar t 2,
cl k => cl k,
r eset => r eset ,
q => s3,
done => done2) ;

WI TH oper at i on SELECT z( 4*n- 1 DOWNTO 0) <=
s1 WHEN " 00" ,
s1 WHEN " 01" ,
s2( 4*n- 1 DOWNTO 0) WHEN " 10" ,
s3( 4*n- 1 DOWNTO 0) WHEN OTHERS;

WI TH oper at i on SELECT z( 8*n- 1 DOWNTO 4*n) <=
x" 0000000" & " 000" & c_out WHEN " 00" ,
x" 0000000" & " 000" & c_out WHEN " 01" ,
s2( 8*n- 1 DOWNTO 4*n) WHEN " 10" ,
s3( 8*n- 1 DOWNTO 4*n) WHEN OTHERS;

WI TH oper at i on SELECT done <=
' 1' WHEN " 00" ,
' 1' WHEN " 01" ,
done1 WHEN " 10" ,
done2 WHEN OTHERS;

END ar chi t ect ur e_au;


- 86 -
5.1.9 Memoria de programa (program_memory.vhd)

l i br ar y I EEE ;
use I EEE. STD_LOGI C_1164. al l ;
use I EEE. STD_LOGI C_ARI TH. al l ;
use I EEE. STD_LOGI C_UNSI GNED. al l ;
l i br ar y uni si m;
use uni si m. vcomponent s. al l ;
ent i t y pr ogr am_memor y i s
por t (
cl k : i n st d_l ogi c ;
r eset : out st d_l ogi c ;
addr ess : i n st d_l ogi c_vect or ( 7 downt o 0 ) ;
i nst r uct i on : out st d_l ogi c_vect or ( 15 downt o 0 )
) ;
end ent i t y pr ogr am_memor y ;

ar chi t ect ur e mi x of pr ogr am_memor y i s
component j t ag_shi f t er i s
por t (
cl k : i n st d_l ogi c ;
user 1 : out st d_l ogi c ;
wr i t e : out st d_l ogi c ;
addr : out st d_l ogi c_vect or ( 8 downt o 0 ) ;
dat a : out st d_l ogi c_vect or ( 7 downt o 0 )
) ;
end component ;

si gnal j addr : st d_l ogi c_vect or ( 8 downt o 0 ) ;
si gnal j dat a : st d_l ogi c_vect or ( 7 downt o 0 ) ;
si gnal j user 1 : st d_l ogi c ;
si gnal j wr i t e : st d_l ogi c ;

at t r i but e I NI T_00 : st r i ng ;
at t r i but e I NI T_0A : st r i ng ;
at t r i but e I NI T_0B : st r i ng ;
at t r i but e I NI T_0C : st r i ng ;
at t r i but e I NI T_0D : st r i ng ;
at t r i but e I NI T_0E : st r i ng ;
at t r i but e I NI T_0F : st r i ng ;

- 87 -
at t r i but e I NI TP_00 : st r i ng ;

at t r i but e I NI T_00 of br am: l abel i s
" 8322E2130200832B9D0561018339834BF210A211832B010F8340038083400301" ;
" 83228347E212E2130203832B83228347E212E2130202832B8322E2130201832B" ;
" 6000A010952B6000A01080809D2561018339834BB210010F834003C08100832B" ;
" 8080E0110000E0110002E2108335808091356000A01280809532640104FF912E" ;
" 808042309D50600AC020808091476000A0138080E0110000E0110001E3108335" ;
" 0000000000000000000000000000000000000000000000000000808042406209" ;
" 0000000000000000000000000000000000000000000000000000000000000000" ;
" 0000000000000000000000000000000000000000000000000000000000000000" ;

- 88 -
" 0000000000000000000000000000000000000000000000000000000000000000" ;
" 0000000000000000000000000000000000000000000000000000000000000000" ;
at t r i but e I NI T_0A of br am: l abel i s
" 0000000000000000000000000000000000000000000000000000000000000000" ;
at t r i but e I NI T_0B of br am: l abel i s
" 0000000000000000000000000000000000000000000000000000000000000000" ;
at t r i but e I NI T_0C of br am: l abel i s
" 0000000000000000000000000000000000000000000000000000000000000000" ;
at t r i but e I NI T_0D of br am: l abel i s
" 0000000000000000000000000000000000000000000000000000000000000000" ;
at t r i but e I NI T_0E of br am: l abel i s
" 0000000000000000000000000000000000000000000000000000000000000000" ;
at t r i but e I NI T_0F of br am: l abel i s
" 0000000000000000000000000000000000000000000000000000000000000000" ;

begi n
br am: component RAMB4_S8_S16
gener i c map (
I NI T_00 =>
X" 8322E2130200832B9D0561018339834BF210A211832B010F8340038083400301" ,
I NI T_01 =>
X" 83228347E212E2130203832B83228347E212E2130202832B8322E2130201832B" ,
I NI T_02 =>
X" 6000A010952B6000A01080809D2561018339834BB210010F834003C08100832B" ,
I NI T_03 =>
X" 8080E0110000E0110002E2108335808091356000A01280809532640104FF912E" ,
I NI T_04 =>
X" 808042309D50600AC020808091476000A0138080E0110000E0110001E3108335" ,
I NI T_05 =>
X" 0000000000000000000000000000000000000000000000000000808042406209" ,
I NI T_06 =>
X" 0000000000000000000000000000000000000000000000000000000000000000" ,
I NI T_07 =>
X" 0000000000000000000000000000000000000000000000000000000000000000" ,
I NI T_08 =>
X" 0000000000000000000000000000000000000000000000000000000000000000" ,
I NI T_09 =>
X" 0000000000000000000000000000000000000000000000000000000000000000" ,
I NI T_0A =>
X" 0000000000000000000000000000000000000000000000000000000000000000" ,
I NI T_0B =>
X" 0000000000000000000000000000000000000000000000000000000000000000" ,
I NI T_0C =>
X" 0000000000000000000000000000000000000000000000000000000000000000" ,
I NI T_0D =>
X" 0000000000000000000000000000000000000000000000000000000000000000" ,
I NI T_0E =>
X" 0000000000000000000000000000000000000000000000000000000000000000" ,
I NI T_0F =>
X" 0000000000000000000000000000000000000000000000000000000000000000"
)
por t map (
DI B => " 0000000000000000" ,
ENB => ' 1' ,
WEB => ' 0' ,
RSTB => ' 0' ,
CLKB => cl k,
ADDRB => addr ess,
DOB => i nst r uct i on( 15 downt o 0 ) ,

- 89 -
DI A => j dat a( 7 downt o 0 ) ,
ENA => j user 1,
WEA => j wr i t e,
RSTA => ' 0' ,
CLKA => cl k,
ADDRA => j addr ,
DOA => open
) ;

j dat a <= ( ot her s => ' 0' ) ;
j addr <= ( ot her s => ' 0' ) ;
j user 1 <= ' 0' ;
j wr i t e <= ' 0' ;
end ar chi t ect ur e mi x ;

5.1.10 Circuito completo (main.vhd)

- - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - -
- - Ent i dad del ci r cui t o compl et o
- - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - -
LI BRARY I EEE;

ENTI TY mai n I S PORT(
dat a_i n: I N STD_LOGI C_VECTOR( 3 DOWNTO 0) ;
ext _cl k: I N STD_LOGI C;
r eset : I N STD_LOGI C;
synch: I N STD_LOGI C;
l cd_dat a: OUT STD_LOGI C_VECTOR( 3 DOWNTO 0) ;
l cd_e: OUT STD_LOGI C;
l cd_r s: OUT STD_LOGI C;
l cd_r w: OUT STD_LOGI C) ;
END mai n;

- - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - -
- - Ar qui t ect ur a del ci r cui t o compl et o
- - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - -
LI BRARY I EEE;

ARCHI TECTURE ar chi t ect ur e_mai n OF mai n I S

COMPONENT kcpsmI S PORT( - - Pr ocesador
i nst r uct i on: I N STD_LOGI C_VECTOR( 15 DOWNTO 0) ;
i n_por t : I N STD_LOGI C_VECTOR( 7 DOWNTO 0) ;
i nt er r upt : I N STD_LOGI C;
cl k: I N STD_LOGI C;
addr ess: OUT STD_LOGI C_VECTOR( 7 DOWNTO 0) ;
por t _i d: OUT STD_LOGI C_VECTOR( 7 DOWNTO 0) ;
out _por t : OUT STD_LOGI C_VECTOR( 7 DOWNTO 0) ;
wr i t e_st r obe: OUT STD_LOGI C;
r ead_st r obe: OUT STD_LOGI C) ;
END COMPONENT;

- 90 -
COMPONENT pr ogr am_memor y I S PORT( - - Memor i a de pr ogr ama
addr ess: I N STD_LOGI C_VECTOR( 7 DOWNTO 0) ;
i nst r uct i on: OUT STD_LOGI C_VECTOR( 15 DOWNTO 0) ;
r eset : OUT STD_LOGI C) ;
END COMPONENT;

COMPONENT l cd_i nt er f ace I S PORT( - - I nt er f az LCD
t emp_wr : I N STD_LOGI C_VECTOR( 7 DOWNTO 0) ;
i _wr i t e: I N STD_LOGI C;
d_wr i t e: I N STD_LOGI C;
l cd_dat a: OUT STD_LOGI C_VECTOR( 3 DOWNTO 0) ;
l cd_e: OUT STD_LOGI C;
l cd_r s: OUT STD_LOGI C;
l cd_r w: OUT STD_LOGI C;
r eady: OUT STD_LOGI C) ;
END COMPONENT;

COMPONENT ar i t hmet i c_uni t I S - - Uni dad ar i t mt i ca deci mal
GENERI C ( n, p, l ogp: NATURAL) ;
PORT(
x: I N STD_LOGI C_VECTOR( 4*n- 1 DOWNTO 0) ; - - oper ando x
y: I N STD_LOGI C_VECTOR( 4*n- 1 DOWNTO 0) ; - - oper ando y
oper at i on: I N STD_LOGI C_VECTOR( 1 DOWNTO 0) ; - - oper aci n
r eset : I N STD_LOGI C; - - i ni ci al i za
z: OUT STD_LOGI C_VECTOR( 8*n- 1 DOWNTO 0) ; - - r esul t ado
done: OUT STD_LOGI C) ; - - oper aci n l i st a
END COMPONENT;

SI GNAL por t _i d, i n_por t : STD_LOGI C_VECTOR( 7 DOWNTO 0) ;
SI GNAL mul t _out : STD_LOGI C_VECTOR( 3 DOWNTO 0) ;
SI GNAL r eady, done: STD_LOGI C;

SI GNAL i nst r uct i on: STD_LOGI C_VECTOR( 15 DOWNTO 0) ;
SI GNAL addr ess, out _por t : STD_LOGI C_VECTOR( 7 DOWNTO 0) ;
SI GNAL i nt er r upt , wr i t e_st r obe, r ead_st r obe: STD_LOGI C;

SI GNAL t emp_wr : STD_LOGI C_VECTOR( 7 DOWNTO 0) ;
SI GNAL i _wr i t e, d_wr i t e: STD_LOGI C;

SI GNAL i d_wr i t e: STD_LOGI C_VECTOR( 1 DOWNTO 0) ;
SI GNAL x, y: STD_LOGI C_VECTOR( 31 DOWNTO 0) ;
SI GNAL oper at i on: STD_LOGI C_VECTOR( 1 DOWNTO 0) ;

SI GNAL z: STD_LOGI C_VECTOR( 63 DOWNTO 0) ;
SI GNAL st ar t _op: STD_LOGI C;

SI GNAL cl k_2, cl k_4, cl k_8, cl k: STD_LOGI C;


- 91 -
- - I ni ci o
BEGI N

WI TH por t _i d SELECT i n_por t <=
( " 0000000" &synch) when " 00010000" ,
( " 0000" &dat a_i n) when " 00010001" ,
( " 0000000" &r eady) when " 00010010" ,
( " 0000000" &done) when " 00010011" ,
( " 0000" &mul t _out ) when ot her s;

pr ocessor : kcpsmPORT MAP(
i nst r uct i on, i n_por t , i nt er r upt , r eset , cl k, addr ess, por t _i d,
out _por t , wr i t e_st r obe, r ead_st r obe) ;

memor y: pr ogr am_memor y PORT MAP(
addr ess => addr ess,
cl k => cl k,
i nst r uct i on => i nst r uct i on) ;

out put _i nt er f ace: l cd_i nt er f ace PORT MAP(
t emp_wr , r eset , cl k, i _wr i t e, d_wr i t e, l cd_dat a, l cd_e, l cd_r s,
l cd_r w, r eady) ;

- - Di vi sor de f r ecuenci a
PROCESS( ext _cl k)
BEGI N
I F r eset = ' 1' THEN cl k_2 <= ' 0' ;
ELSI F ext _cl k' EVENT AND ext _cl k = ' 1' THEN cl k_2 <= NOT( cl k_2) ;
END I F;
END PROCESS;

PROCESS( cl k_2)
BEGI N
I F r eset = ' 1' THEN cl k_4 <= ' 0' ;
ELSI F cl k_2' EVENT AND cl k_2 = ' 1' THEN cl k_4 <= NOT( cl k_4) ;
END I F;
END PROCESS;

PROCESS( cl k_4)
BEGI N
I F r eset = ' 1' THEN cl k_8 <= ' 0' ;
ELSI F cl k_4' EVENT AND cl k_4 = ' 1' THEN cl k_8 <= NOT( cl k_8) ;
END I F;
END PROCESS;

PROCESS( cl k_8)
BEGI N
I F r eset = ' 1' THEN cl k <= ' 0' ;
ELSI F cl k_8' EVENT AND cl k_8 = ' 1' THEN cl k <= NOT( cl k) ;
END I F;
END PROCESS;

- - Regi st r os
r egi st er _t emp_wr : PROCESS( cl k)
BEGI N
I F cl k' event AND cl k = ' 0' THEN
I F por t _i d = " 00010000" AND wr i t e_st r obe = ' 1' THEN t emp_wr <=
out _por t ;
END I F;
END I F;
END PROCESS;

- 92 -
r egi st er _i d_wr i t e: PROCESS( cl k)
BEGI N
I F r eset = ' 1' THEN i d_wr i t e <= " 00" ;
ELSI F por t _i d = " 00010001" AND wr i t e_st r obe = ' 1' THEN
i d_wr i t e <= out _por t ( 1 DOWNTO 0) ;
END I F;
END I F;
END PROCESS;

i _wr i t e <= i d_wr i t e( 0) ;
d_wr i t e <= i d_wr i t e( 1) ;

r egi st er _x: PROCESS( cl k)
BEGI N
I F por t _i d = " 00001000" AND wr i t e_st r obe = ' 1' THEN
x( 3 DOWNTO 0) <= out _por t ( 3 DOWNTO 0) ;
END I F;
END I F;
END PROCESS;

r egi st er _y: PROCESS( cl k)
BEGI N
y( 3 DOWNTO 0) <= out _por t ( 3 DOWNTO 0) ;
END I F;
END I F;
END PROCESS;


- 93 -
r egi st er _oper at i on: PROCESS( cl k)
BEGI N
oper at i on( 1 DOWNTO 0) <= out _por t ( 1 DOWNTO 0) ;
END I F;
END I F;
END PROCESS;

st ar t _op <= ' 1' WHEN por t _i d = " 00010010" AND wr i t e_st r obe = ' 1'
ELSE ' 0' ;

mai n_component : ar i t hmet i c_uni t
GENERI C MAP( n => 8, p => 56, l ogp => 6)
PORT MAP(
x => x,
y => y,
oper at i on => oper at i on,
st ar t => st ar t _op,
cl k => cl k,
r eset => r eset ,
z => z,
done => done) ;

WI TH por t _i d SELECT mul t _out <=
z( 3 DOWNTO 0) WHEN " 00000000" ,
z( 7 DOWNTO 4) WHEN " 00000001" ,
z( 11 DOWNTO 8) WHEN " 00000010" ,
z( 15 DOWNTO 12) WHEN " 00000011" ,
z( 19 DOWNTO 16) WHEN " 00000100" ,
z( 23 DOWNTO 20) WHEN " 00000101" ,
z( 27 DOWNTO 24) WHEN " 00000110" ,
z( 31 DOWNTO 28) WHEN " 00000111" ,
z( 35 DOWNTO 32) WHEN " 00001000" ,
z( 39 DOWNTO 36) WHEN " 00001001" ,
z( 43 DOWNTO 40) WHEN " 00001010" ,
z( 47 DOWNTO 44) WHEN " 00001011" ,
z( 51 DOWNTO 48) WHEN " 00001100" ,
z( 55 DOWNTO 52) WHEN " 00001101" ,
z( 59 DOWNTO 56) WHEN " 00001110" ,
z( 63 DOWNTO 60) WHEN OTHERS;

i nt er r upt <= ' 0' ;

END ar chi t ect ur e_mai n;


- 94 -
5.2 Programa en lenguaje ensamblador (decimal_unit.asm)

VHDL " my_ROM_bl ank. vhd" , " pr ogr am_memor y. vhd" , " pr ogr am_memor y"

; di r ecci ones de ent r ada
z0 DSI N $00
z1 DSI N $01
z2 DSI N $02
z3 DSI N $03
z4 DSI N $04
z5 DSI N $05
z6 DSI N $06
z7 DSI N $07
z8 DSI N $08
z9 DSI N $09
z10 DSI N $0a
z11 DSI N $0b
z12 DSI N $0c
z13 DSI N $0d
z14 DSI N $0e
z15 DSI N $0f
synch DSI N $10
dat a_i n DSI N $11
r eady DSI N $12
done DSI N $13

; di r ecci ones de sal i da
y0 DSOUT $00
y1 DSOUT $01
y2 DSOUT $02
y3 DSOUT $03
y4 DSOUT $04
y5 DSOUT $05
y6 DSOUT $06
y7 DSOUT $07
x0 DSOUT $08
x1 DSOUT $09
x2 DSOUT $0a
x3 DSOUT $0b
x4 DSOUT $0c
x5 DSOUT $0d
x6 DSOUT $0e
x7 DSOUT $0f
t emp_wr DSOUT $10
i d_wr i t e DSOUT $11
st ar t DSOUT $12
oper at i on DSOUT $13

; r egi st r os i nt er nos
acc EQU s0
addr ess EQU s1
dat a EQU s2
command EQU s3
count er EQU s4


- 95 -
; mai n pr ogr am
begi n:
l oad command, $01
cal l l cd_cont r ol ; send command 01 ( cl ear ) t o di spl ay,
; bor r amos el di spl ay
l oad command, $80
cal l l cd_cont r ol ; send command 80 ( cur sor addr ess = 00) t o
; di spl ay, si t uamos el cur sor al i ni ci o de
; l a pr i mer a f i l a
l oad addr ess, $0f ; i ni t i al addr ess = 15

f i r st : ; escr i bi mos l os 16 d gi t os de ent r ada, 8
; par a ' x' y 8 par a ' y'
cal l wai t _f or _synch ; wai t f or a posi t i ve edge on synch
i n dat a, dat a_i n ; st or e dat a_i n i n dat a
out dat a, addr ess ; wr i t e dat a i nt o x( addr ess)
cal l encode_dat a ; dat a = ASCI I code
cal l l cd_dat a ; di spl ay char act er dat a
sub addr ess, $01 ; updat e addr ess
j ump NC, f i r st ; check whet her addr ess < 0

; addi t i on
l oad dat a, $00
out dat a, oper at i on ; oper at i on = 00
cal l di spl ay_z ; di spl ay x+y
; end of addi t i on

; subst r act i on
l oad dat a, $01
cal l di spl ay_z ; di spl ay x- y
; end of subst r act i on

; mul t i pl i cat i on
l oad dat a, $02
out dat a, st ar t ; st ar t comput at i on
cal l wai t _f or _done
cal l di spl ay_z ; di spl ay x*y
; end of mul t i pl i cat i on

; di vi si on
l oad dat a, $03
out dat a, st ar t ; st ar t comput at i on
cal l wai t _f or _done
cal l di spl ay_z ; di spl ay x/ y
; end of di vi si on

j ump begi n
; end of mai n pr ogr am


- 96 -
; subr out i nes:

; di spl ay t he r esul t of t he oper at i on
di spl ay_z:
l oad command, $c0
cal l l cd_cont r ol ; send command c0 ( cur sor addr ess = 40) t o
; di spl ay
l oad addr ess, $0f ; i ni t i al addr ess = 15

f i r st _bi s:
i n dat a, addr ess ; r ead z( addr ess)
cal l encode_dat a ; dat a = ASCI I code
cal l l cd_dat a ; di spl ay char act er dat a
sub addr ess, $01 ; updat e addr ess
j ump NC, f i r st _bi s ; check whet her addr ess < 0
r et

; wai t f or a posi t i ve edge on synch; acc i s modi f i ed
wai t _f or _synch:
i n acc, synch
sub acc, $00
j ump NZ, wai t _f or _synch

wai t _f or _1:
i n acc, synch
sub acc, $00
j ump Z, wai t _f or _1
l oad count er , $f f

updat e_count er :
sub count er , $01
j ump NZ, updat e_count er
r et

; wai t unt i l r eady i s set ; acc i s modi f i ed
wai t _f or _r eady:
i n acc, r eady
sub acc, $00
j ump Z, wai t _f or _r eady
r et

; l cd_dat a sends t he char act er " dat a" t o t emp_wr and gener at es a
; t wo- cycl e pul se on d_wr i t e; i t cl ear s " acc"
l cd_dat a:
cal l wai t _f or _r eady ; wai t f ot l cd_i nt er f ace r eady
out dat a, t emp_wr ; send char act er t o l cd
l oad acc, $02 ; set d_wr i t e
out acc, i d_wr i t e
l oad acc, $00 ; cl ear d_wr i t e
r et


- 97 -
; l cd_cont r ol s sends t he i nst r uct i on " command" t o t emp_wr and gener at es a
; t wo- cycl e pul se on i _wr i t e; i t cl ear s " acc"
l cd_cont r ol :
cal l wai t _f or _r eady ; wai t f ot l cd_i nt er f ace r eady
out command, t emp_wr ; send i nst r uct i on t o l cd
l oad acc, $01 ; set i _wr i t e
l oad acc, $00 ; cl ear i _wr i t e
r et

; wai t unt i l done i s set ; acc i s modi f i ed
wai t _f or _done:
i n acc, done
sub acc, $00
j ump Z, wai t _f or _done
r et

; dat a = ASCI I ( dat a)
encode_dat a:
l oad acc, dat a
sub acc, $0a
j ump NC, g_t _9
add dat a, $30
r et

g_t _9:
sub dat a, $09
add dat a, $40
r et

5.3 Asignacin de pines en la Spartan-3E (pins.ucf)

NET " ext _cl k" LOC = " C9" | I OSTANDARD = LVCMOS33 ;
NET " r eset " LOC = " K17" | I OSTANDARD = LVTTL | PULLDOWN ;
NET " dat a_i n<3>" LOC = " N17" | I OSTANDARD = LVTTL | PULLUP ;
NET " dat a_i n<2>" LOC = " H18" | I OSTANDARD = LVTTL | PULLUP ;
NET " dat a_i n<1>" LOC = " L14" | I OSTANDARD = LVTTL | PULLUP ;
NET " dat a_i n<0>" LOC = " L13" | I OSTANDARD = LVTTL | PULLUP ;

NET " synch" LOC = " D18" | I OSTANDARD = LVTTL | PULLDOWN ;

NET " l cd_e" LOC = " M18" | I OSTANDARD = LVCMOS33 | DRI VE = 4 | SLEW= SLOW
;
NET " l cd_r s" LOC = " L18" | I OSTANDARD = LVCMOS33 | DRI VE = 4 | SLEW=
SLOW;
NET " l cd_r w" LOC = " L17" | I OSTANDARD = LVCMOS33 | DRI VE = 4 | SLEW=
SLOW;
NET " l cd_dat a<3>" LOC = " M15" | I OSTANDARD = LVCMOS33 | DRI VE = 4 | SLEW
= SLOW;
NET " l cd_dat a<2>" LOC = " P17" | I OSTANDARD = LVCMOS33 | DRI VE = 4 | SLEW
= SLOW;
NET " l cd_dat a<1>" LOC = " R16" | I OSTANDARD = LVCMOS33 | DRI VE = 4 | SLEW
= SLOW;
NET " l cd_dat a<0>" LOC = " R15" | I OSTANDARD = LVCMOS33 | DRI VE = 4 | SLEW
= SLOW;


6. BIBLIOGRAFA

Diseo sobre FPGA de una Unidad Aritmtica Decimal Bibliografa

- 99 -
6. Bibliografa

[1] Serafn Alfonso Prez, Enrique Soto, Santiago Fernndez, Diseo de Sistemas Digitales con VDHL,
Editorial Thomson, 2002.
[2] Fernando Pardo Carpio, Jos A. Boluda Grau, VHDL: Lenguaje para sntesis y modelado de
circuitos, Editorial Ra-Ma, 1999.
[3] John F. Wakerly, Diseo digital. Principios y prcticas, Tercera edicin, Editorial Prentice Hall,
2001.
[4] Thomas L. Floyd, Fundamentos de sistemas digitales, Novena edicin, Editorial Prentice Hall,
2006.
[5] M. Vazquez, G. Sutter, G. Bioul, J.-P. Deschamps, Decimal adders/substractors in FPGA: Efficient
6-input LUT implementations.
[6] J.-P. Deschamps, G. Sutter, G. Bioul, M. Vazquez, Decimal division: algorithms and FPGA
implementations.
[7] G. Sutter, E. Todorovich, G. Bioul, M. Vazquez, J.-P. Deschamps, FPGA Implementations of BCD
Multipliers.
[8] Electrnica Digital I, apuntes de la asignatura.
[9] ModelSim Users Manual Software Version 6.5, Mentor Graphics, 2009.
[10] Spartan-3E FPGA Starter Kit Board User Guide, UG230 (v1.1), Xilinx, 2008.
[11] Spartan-3E FPGA Family: Functional Description, DS312-2 (v1.0), Xilinx, 2005.
[12] PicoBlaze 8-Bit Microcontroller for Virtex-E and Spartan-II/IIE Devices, XAPP213 (v2.1), Xilinx,
2003.
[13] http://www.model.com/
[14] http://www.xilinx.com/

1453 Pub

Încărcat de

Informații document

Drepturi de autor

Formate disponibile

Partajați acest document

Partajați sau inserați document

Opțiuni de partajare

Vi se pare util acest document?

Este necorespunzător acest conținut?

Drepturi de autor:

Formate disponibile

1453 Pub

Încărcat de

Drepturi de autor:

Formate disponibile

Diseo sobre FPGA de una Unidad Aritmtica Decimal

TITULACIN: Ingeniera Tcnica Industrial en Electrnica Industrial

S-ar putea să vă placă și