INSTITUTO TECNOLGICO DE TEHUACN

Departamento de Ingeniera Elctrica-Electrnica

Reporte de Residencia Profesional
Proyecto:

VIABILIDAD DE LA TARJETA BASYS2

PARA SU IMPLEMENTACIN EN EL
CONTROL DE UN PROCESO

Presenta:
Mario Merino Mrquez
Asesor Interno:

Ing. Juan Jos Ortiz Flores

Asesor Externo:
Dr. Oscar Leopoldo Prez Castaeda
Tehuacn, Puebla; a 24 Mayo de 2012

pg. 1

NDICE
NDICE .................................................................................................................... 2
INTRODUCCIN ................................................................................................... 4
JUSTIFICACIN .................................................................................................... 6
OBJETIVOS............................................................................................................ 8
OBJETIVO GENERAL .................................................................................... 8
OBJETIVOS ESPECFICOS ............................................................................. 8

REA DE PARTICIPACIN ................................................................................. 9

PROBLEMAS A RESOLVER.............................................................................. 10
CRONOGRAMA DE ACTIVIDADES ................................................................. 10
Bsqueda y Compra de Tarjeta basada en FPGA XILINX Spartan 3E 100K ... 10
Instalacin y Manejo del Software ISE Design Suite 13.4 y Digilent Adept ....... 10
Investigacin de la Arquitectura de la Tarjeta basada en FPGA ....................... 10
Manejo del Lenguaje de Programacin VHDL ................................................... 11
Desarrollo e Implementacin de Prcticas de Circuitos Digitales bsicos con
VHDL y la Tarjeta basada en FPGA ............................................................................... 11
Desarrollo e Implementacin de Mquinas de Estados Finitos (FSM) .............. 11
Acondicionamiento de Entradas y Salidas de la Tarjeta basada en FPGA para
adquisicin de datos y activacin de actuadores............................................................ 12
Desarrollo e Implementacin del Control de un Proceso por medio de la Tarjeta
basada en FPGA ............................................................................................................. 12

ALCANCES Y LIMITACIONES........................................................................... 13
ALCANCES ................................................................................................ 13
LIMITACIONES............................................................................................ 13

MARCO TERICO .............................................................................................. 15

SISTEMAS DE CONTROL Y SISTEMAS DIGITALES .......................................... 15
DISPOSITIVOS FPGA ................................................................................. 17
FAMILIAS COMERCIALES DE FPGAS. ........................................................... 19
FPGAs de Xilinx. ............................................................................................... 19
FPGAs de Altera. ............................................................................................... 19
FPGAs de Actel ................................................................................................. 20
FAMILIA XILINX SPARTAN-3E FPGA............................................................ 21
TARJETA BASYS2 ...................................................................................... 22
Caractersticas Generales: ................................................................................. 23
TENDENCIAS TECNOLGICAS POR MERCADO DEL FPGA ............................. 25
Comunicaciones ................................................................................................. 25
Aeroespacial y Militar ......................................................................................... 26
Automotriz .......................................................................................................... 26
Industrial ............................................................................................................. 26
Electrnica de Consumo .................................................................................... 27
Procesamiento de Datos .................................................................................... 27
LENGUAJE VHDL ...................................................................................... 27

pg. 2

Formas de describir un circuito .......................................................................... 27

Secuencia de diseo .......................................................................................... 28
Ventajas de los lenguajes HDL .......................................................................... 31
Entity................................................................................................................... 31
Architecture ........................................................................................................ 33
Bibliotecas .......................................................................................................... 34
Paquetes ............................................................................................................ 34

PROCEDIMIENTO Y DESCRIPCIN DE LAS ACTIVIDADES REALIZADAS .. 35

ADQUISICIN DE LA TARJETA BASYS2 ......................................................... 35
DESCARGA E INSTALACIN DE SOFTWARE ISE DESIGN SUITE 13.4 Y ADEPT
2.6.1 SYSTEM ....................................................................................................... 36
USO DEL SOFTWARE ISE DESIGN SUITE 13.4, ADEPT 2.6.1 SYSTEM Y
CONFIGURACIN DE LA TARJETA BASYS2 ............................................................... 38
Entidad y Arquitectura .......................................................................... 43
Simulacin............................................................................................ 47
Diseo Estructural en VHDL ................................................................. 56
Configuracin de la Tarjeta Basys2 ...................................................... 66

RESULTADOS ..................................................................................................... 74
DESARROLLO DE PRCTICAS UTILIZANDO LA TARJETA BASYS2 .................... 74
Practica 1 Decoder Display ............................................................................. 74
Practica 2 - Contador Ascendente ..................................................................... 77
Practica 3 - Contador con salida a Display ........................................................ 81
Practica 4 - Encendido de un motor de CD....................................................... 83
Prctica 5 - Motor Reversible ............................................................................. 85
Practica 6 Sumador Aritmtico con Salida a Display ...................................... 88
Practica 7 Unidad Aritmtica Lgica (ALU) ..................................................... 97
Practica 8 Elementos de Memoria (Flip-Flops) Pulsador .............................105
Practica 9 Maquinas de Estados Finitos (FSM) ............................................108
Prctica 10 Circuito Anti rebotes (Debounce Circuit) ...................................120
Practica 11 - Generacin de una seal PWM .................................................125
Practica 12 - PWM con salida a display. ..........................................................129
Practica 13 Seal PWM con Potencimetro. ...............................................135
Practica 14 - Control de un motor debido a la seal de un sensor. .................140
Prctica 15 - Seal PWM controlada con Pushbuttons ...................................152
Prctica 16 - Contador Parametrizable (Mod_m_Counter) ..............................157
Prctica 17 - FIFO Buffer .................................................................................159
Prctica 18 Comunicacin Serial Puerto PS2 Teclado ..............................162

CONCLUSIONES Y RECOMENDACIONES .................................................. 171

REFERENCIAS BIBLIOGRFICAS ................................................................. 172

pg. 3

INTRODUCCIN
Viabilidad de la Tarjeta Basys2 para su Implementacin en el
Control de un Proceso

Ante las diferentes aplicaciones a realizar dentro del campo de los

Sistemas Digitales, nuevas tecnologas han emergido como herramientas a
las mismas. La adquisicin de datos es una de estas aplicaciones, para la
cual se han utilizado diferentes herramientas como son sistemas basados en
microprocesadores, microcontroladores, CPLD, entre otros.
Con la aparicin de los dispositivos FPGAs (Fiel Programmable Gate
Array), se dispone de una nueva herramienta para los sistemas digitales. Su
alta disponibilidad de recursos lgicos, bloques de memoria SRAM, bloques
MAC, aumento de las entradas y salidas y sobre todo su reprogramacin,
han colocado a estos dispositivos como una de las herramientas ms
verstiles en estos momentos.
La opcin de generar maquinas de estados finitos FSM (Finite State
Machines) de forma rpida y sencilla gracias a los lenguajes HDL (Lenguajes
de Descripcin de Hardware), colocan a los dispositivos FPGAs como una
solucin eficaz ante el diseo de sistemas digitales.
La combinacin del lenguaje HDL y los dispositivos FPGAs permiten a
los diseadores simular, probar e implementar fsicamente circuitos digitales
sofisticados, reduciendo el tiempo que existe desde el diseo hasta la
produccin final.
En este documento se propone analizar la viabilidad de la tarjeta
Basys2, basada en tecnologa FPGA para su aplicacin en el Control de un
Proceso.
Para demostrar la viabilidad y poner a prueba la Tarjeta Basys2 se
proponen una serie de prcticas que servirn como gua de aprendizaje de
las bases del Lenguaje de Programacin VHDL (Very High Speed Hardware
Description Language), la instalacin y uso del software XILINX ISE13.4, la
traduccin por medio del software Digilent Adept y el manejo de la Tarjeta
Basys2.

pg. 4

Se recomienda al lector tener conocimientos de Electrnica Digital y

Electrnica Analgica Bsica para la total comprensin de los temas
expuestos.
El FPGA utilizado es el XILINX Spartan 3E-100K por lo cual este
documento puede servir de referencia para el manejo de otras Tarjetas tales
como la Spartan-3 Starterboard, Spartan-3E Starterboard, Nexys-2 board,
Pegasus, Basys o de arquitecturas semejantes.

pg. 5

JUSTIFICACIN
Velocidad, Reprogramacin, Mltiples I/0, Rendimiento, Costo

Los Dispositivos Lgicos Programables ofrecen mltiples ventajas en

el diseo de sistemas digitales; son una alternativa viable ante
microprocesadores, microcontroladores y ASICs (Circuitos Integrados de
Aplicacin Especfica) debido a su naturaleza reprogramable, alto
rendimiento y facilidad de uso; todo esto a un costo accesible.
Diseadores de Sistemas Digitales pueden desarrollar prototipos para
el control de procesos de forma rpida y sencilla, evitando retrasos en la
adecuada eleccin de un microprocesador o microcontrolador. Con un FPGA
de gama baja se cuenta con los suficientes recursos para disear, probar e
implementar el control de mltiples procesos.
La Tarjeta Basys2 basada en el FPGA XILINX Spartan 3E-100K es un
laboratorio completo para el diseo de circuitos digitales ya que cuenta con
Memoria Flash, Interfaz programable USB2, push buttons, switches, leds,
puerto PS2, puerto VGA y 4 mdulos de expansin. Al tener todo lo
necesario en una sola placa se reduce el tiempo de salida del prototipo, ya
que se evita el tener que disear un PCB (Printed Circuit Board) o utilizar
protoboards que por lo general ocasionan fallos en las seales elctricas.
El Lenguaje de Descripcin de Hardware VHDL representa una
ventaja debido a lo sencilla e intuitiva que es su programacin y su sntesis
que no ocupa demasiados recursos; en comparacin al Lenguaje
Ensamblador que es ms complejo y poco entendible, o el uso de Lenguajes
de alto nivel como lo son C, Basic, Java para microcontroladores y
microprocesadores que gastan recursos excesivamente.
El uso de mltiples microprocesadores embebidos en un FPGA
significa una de las mayores ventajas de estos dispositivos lgicos
programables, la creacin de un microprocesador a la medida proporciona un
diseo flexible y escalable que satisface las necesidades del productor y
evita el hecho de que el microprocesador, microcontrolador o ASIC elegido
para el control del proceso quede obsoleto.
El mercado de los FPGAs ha ido en aumento y XILINX, la empresa
creadora de estos dispositivos lgicos programables se coloca como lder
mundial con el 56% de las ventas de FPGAs, seguido por Altera, Lattice y
pg. 6

Actel. Las aplicaciones finales que se le dan a estos dispositivos suelen ser
diversas y se presentan en campos tales como telecomunicaciones, industria
automotriz, industria de consumo, entre otros.
Este documento busca adems de demostrar la viabilidad de la
Tarjeta Basys2 para ser utilizada en el control de un proceso, beneficiar y
orientar a todos aquellos que se comienzan a sumergir dentro del campo de
los dispositivos lgicos programables para el diseo de sistemas digitales a
travs de FPGAs, de modo que puedan hacer consideraciones para la
eleccin de la arquitectura que controle sus procesos.

pg. 7

OBJETIVOS

Objetivo General
-

Determinar la Viabilidad de la Tarjeta Basys2 para Implementar el

Control de un Proceso

Objetivos Especficos
-

Manejar VHDL (Very High Speed Integrated Circuit Hardware

Description Language) para la Descripcin de circuitos Digitales en
un FPGA Spartan 3E

Manejar la Tarjeta Basys2 basada en el FPGA XILINX Spartan 3E

100K y sus Similares

Manejar el Software compilador y traductor necesario para utilizar

el FPGA XILINX Spartan 3E 100K

Determinar e Implementar el control de un proceso

pg. 8

REA DE PARTICIPACIN
Ingeniera Electrnica Ciencia Aplicada para Crear e Innovar

El desarrollo de este documento as como las prcticas propuestas se

han llevado a cabo en el Instituto Tecnolgico de Tehuacn en el rea de
Ingeniera Elctrica-Electrnica por parte del equipo de Residentes
investigadores del rea.
En la Figura1 se muestra el organigrama del Instituto Tecnolgico de
Tehuacn, siendo el rea de Ingeniera Electrnica dentro del departamento
de investigacin el lugar donde se ha desarrollado este proyecto.

Figura 1 - Organigrama del Instituto Tecnolgico de Tehuacn

pg. 9

PROBLEMAS A RESOLVER
Cronograma de Actividades
A continuacin se exponen los problemas a resolver para el desarrollo
del proyecto, asi como una breve descripcin de los mismos.
Bsqueda y Compra de Tarjeta basada en FPGA XILINX Spartan 3E
100K
-

Duracin: 2 semanas

Objetivo: Buscar y Comprar una Tarjeta de prototipos basada en

un FPGA

Descripcin: Durante el tiempo propuesto se buscar en internet y

proveedores locales una Tarjeta de Prototipos basada en un FPGA
sencillo.

Instalacin y Manejo del Software ISE Design Suite 13.4 y Digilent Adept
-

Duracin: 1 semana

Objetivo: Descargar e instalar el software necesario para el manejo

de la Tarjeta basada en el FPGA de eleccin

Descripcin: Durante el tiempo propuesto se descargarn e

instalarn los programas necesarios para el manejo de la Tarjeta
adquirida, as como el acondicionamiento del equipo de cmputo
necesario.

Investigacin de la Arquitectura de la Tarjeta basada en FPGA

-

Duracin: 1 semana

Objetivo: Investigar y analizar la arquitectura de la Tarjeta basada

en FPGA

pg. 10

Descripcin: Durante el tiempo propuesto se buscarn y analizarn

las hojas de datos de la Tarjeta adquirida as como del FPGA que
contenga.

Manejo del Lenguaje de Programacin VHDL

-

Duracin: 3 semanas

Objetivo: Conocer y manejar el lenguaje de Descripcin de

Hardware VHDL

Descripcin: Durante el tiempo propuesto se buscar informacin

acerca del lenguaje VHDL en biblioteca e internet y se aprendern
las bases del mismo para la programacin de la Tarjeta basada en
FPGA.

Desarrollo e Implementacin de Prcticas de Circuitos Digitales bsicos

con VHDL y la Tarjeta basada en FPGA
-

Duracin: 3 semanas

Objetivo: Disear e Implementar en la Tarjeta basada en FPGA

circuitos digitales combinacionales y secuenciales bsicos.

Descripcin: Durante el tiempo propuesto se disearan e

implementarn prcticas de circuitos combinacionales y
secuenciales bsicos programados en lenguaje VHDL y
compilados a travs del software necesario para la descarga hacia
la Tarjeta basada en FPGA.

Desarrollo e Implementacin de Mquinas de Estados Finitos (FSM)

-

Duracin: 3 semanas

Objetivo: Disear e implementar circuitos digitales secuenciales

avanzados.

pg. 11

Descripcin: Durante el tiempo propuesto se disearan e

implementarn prcticas de circuitos combinacionales avanzados
utilizando para ello Maquinas de Estados Finitos (FSM). Se
analizarn las diversas opciones con las que se cuenta para
disearlas y se elegir la ms viable.

Acondicionamiento de Entradas y Salidas de la Tarjeta basada en FPGA

para adquisicin de datos y activacin de actuadores.
-

Duracin: 2 semanas

Objetivo: Acondicionar las seales elctricas para hacer interfaces

humano-sensores-actuadores-CI-tarjeta

Descripcin: Durante el tiempo propuesto se investigar acerca de

los dispositivos analgicos necesarios para hacer la interconexin
de actuadores, sensores, circuitos integrados y dems dispositivos
que interacten con la tarjeta basada en FPGA para su correcto
funcionamiento sin daarla; as como las etapas de potencia
necesarias.

Desarrollo e Implementacin del Control de un Proceso por medio de la

Tarjeta basada en FPGA
-

Duracin: 3 semanas

Objetivo: Controlar un Proceso a travs de la Tarjeta basada en

FPGA seleccionada

Descripcin: Durante el tiempo propuesto se buscar una

aplicacin de control utilizando la tarjeta basada en FPGA
seleccionada, se disear, implementar y se determinar la
viabilidad de su uso.

pg. 12

ALCANCES Y LIMITACIONES
Alcances
Las prcticas expuestas en este documento pretenden demostrar la
viabilidad del uso de una tarjeta de desarrollo basada en FPGA para su
implementacin en el control de un proceso, adems servirn de gua para
todos aquellos que busquen disear sistemas digitales con dispositivos
lgicos programables.
El impacto de este proyecto beneficia a la carrera de Ingeniera
Electrnica en sus cursos de Electrnica Digital y Diseo Digital con VHDL.
La tarjeta Basys 2 cuenta con 4 mdulos de expansin PMOD los
cuales cuentan con 4 entradas y salidas externas cada uno que nos permiten
ingresar seales elctricas de sensores u otros dispositivos, o enviar seales
elctricas para activar actuadores o establecer comunicacin entre el FPGA y
un ordenador.
La Tarjeta Basys2 nos permite trabajar a velocidades de 50Mhz y
controlar mltiples procesos de forma paralela, lo cual es su principal ventaja
en comparacin a un microcontrolador.

Limitaciones
La adquisicin de la Tarjeta Basys2 en el territorio nacional es
complicada; los distribuidores autorizados de la empresa Digilent se
encuentran fuera del estado de Puebla. Es ms sencillo pedirla directamente
al proveedor en USA pero se debe pagar un impuesto aduanal.
Se debe analizar el proceso a controlar para determinar si las entradas
y salidas con las que cuenta la Tarjeta Basys2 son suficientes para su
implementacin.
Los componentes electrnicos con los que se cuenta dentro del rea
de Ingeniera Electrnica son insuficientes, por lo cual se opta por adquirirlos
en distribuidores locales generando gastos adicionales.
El voltaje de las entradas y salidas de la Tarjeta Basys2 utiliza
tecnologa LVTTL de 3.3V por lo tanto se requiere acondicionar

pg. 13

correctamente las seales elctricas. Adems, no cuenta con puerto serial,

LCD (Liquid Crystal Display), ni convertidor analgico-digital integrados en la
tarjeta, por lo que hay que comprarlos y disear su interfaz.
La licencia del software ISE Design Suite 13.4 utilizada es de versin
gratuita, por lo tanto para proyectos de mayor volumen o que utilicen FPGAs
mas avanzados se debe comprar la licencia completa.
El control de procesos ms sofisticados est sujeto a la disposicin de
recursos econmicos, equipo de laboratorio disponible en el rea de
Ingeniera Electrnica y componentes electrnicos extras.

pg. 14

MARCO TERICO
Sistemas de Control y Sistemas Digitales
El control de procesos a travs de tecnologas reprogramables es un
rea en constante crecimiento con dispositivos lgicos programables
evolucionando rpidamente.
Un proceso es un conjunto de actividades o eventos que se realizan
o suceden (alternativa o simultneamente) bajo ciertas circunstancias con un
fin determinado.
Los sistemas de control son parte integrante de la sociedad moderna y
sus numerosas aplicaciones estn alrededor de nosotros: Un sistema de
control esta formado por subsistemas y procesos unidos con el fin de
controlar las salidad de los procesos. En su forma ms sencilla, un sistema
de control produce una salida o respuesta para una entrada o estmulo dado.
En la Figura 2 se muestra un sistema de control simple.
Entrada; Estimulo

Salida; Respuesta

Sistema de Control
Respuesta Deseada

Respuesta Real
Figura 2 Diagrama Sistema de Control

Los sistemas de control se dividen en sistemas en lazo abierto y en

lazo cerrado. Un sistema genrico en lazo abierto se ilustra en la Figura 3 (a),
formado por un subsistema llamado transductor de entrada, que convierte la
forma de la entrada a la empleada por el controlador. El controlador maneja
un proceso o planta. A veces, la entrada se denomina referencia, mientras
que la salida se puede llamar variable controlada. Otras seales, por ejemplo
las perturbaciones se muestran agregadas al controlador y a las salidas del
proceso por medio de puntos de suma que dan la suma algebraica de sus
seales de salida por medio de signos asociados. La caracterstica distintiva
de un sistema en lazo abierto es que no puede compensar ninguna
perturbacin que se sume a la seal de actuacin del controlador;
simplemente se comandan por la entrada.

pg. 15

Figura 3 Diagramas a bloques de Sistemas de Control

a) En Lazo Abierto b) En Lazo Cerrado

La estructura genrica de un sistema en lazo cerrado se ilustra en la

Figura 3(b). En diferencia a los sitemas en lazo abierto estos compensan
perturbaciones al medir la respuesta de salida, alimentando esa medida a
una trayectoria de realimentacin comparando esa respuesta con la entrada
en el punto de suma. Si hay alguna diferencia entre las dos respuestas, el
sistema acciona el proceso, por medio de una seal de actuacin, para hacer
la correccin. 1
El controlador (o compensador) puede ser un dispositivo lgico
programable o un microcontrolador que ejecute las acciones de control.
Un sistema digital es un conjunto de dispositivos destinados a la
generacin,
transmisin,
procesamiento
o
almacenamiento
de
seales digitales. Tambin un sistema digital es una combinacin de
dispositivos diseados para manipular cantidades fsicas o informacin que
estn representadas en forma digital; es decir, que slo puedan tomar
valores discretos.
Para el anlisis y la sntesis de sistemas digitales binarios se utiliza
como herramienta el lgebra de Boole.
1

Norman S. Nise, Sistemas de Control para Ingeniera. (1a Edicin), Compaa Editorial Continental, Mexico: 2004

pg. 16

Sistemas digitales combinacionales: Aquellos en los que sus

salidas slo depende del estado de sus entradas en un momento
dado. Por lo tanto, no necesita mdulos de memoria, ya que las
salidas no dependen de los estados previos de las entradas.

Sistemas digitales secuenciales: Aquellos en los que sus salidas

dependen adems del estado de sus entradas en un momento dado,
de estados previos. Esta clase de sistemas necesitan elementos
de memoria que recojan la informacin de la historia pasada del
sistema.

Dispositivos FPGA
Un FPGA (Field programable gate array) es un dispositivo lgico que
contiene una matriz de celdas lgicas idnticas, con interconexiones
programables (switches programables). La estructura conceptual de un
dispositivo FPGA se muestra en la Figura 4. Una celda lgica puede ser
configurada (programada) para realizar una funcin simple, y un switch
programable puede ser configurado para proveer interconexin a travs de
las celdas lgicas. Un diseo puede ser implementado en un FPGA
especificando la funcin de cada celda lgica y estableciendo selectivamente
la conexin de cada switch programable. Una vez que el diseo y la sntesis
son completados, podemos utilizar un simple cable adaptador para descargar
la celda lgica deseada y la configuracin del switch programable al
dispositivo FPGA, para obtener el circuito digital diseado.

Figura 4 Estructura Conceptual FPGA

pg. 17

Las celdas lgicas usualmente contienen un pequeo circuito

combinacional y un flip-flop D (DFF). El mtodo mas comn para
implementar un circuito combinacional configurable es a travs de una tabla
de bsqueda (look-up table LUT). Una LUT de n entradas puede ser
considerada como una pequea memoria de 2 n-por-1. Escribiendo
adecuadamente el contenido de la memoria, podemos utilizar una LUT para
implementar cualquier funcin combinacional de n entradas. El diagrama
conceptual de una celda lgica basada en una LUT de 3 entradas es
mostrado en la Figura 5 (a). La funcin abc implementada en una LUT
de 3 entradas es mostrada en la Figura 5(b). Ntese que la salida de la LUT
puede ser utilizada directamente o puede ser almacenada en el Flip-Flop D.

Figura 5 - LUT (Look-up Table)

Macro Celda (Macro cell). La mayora de los dispositivos FPGA

cuentan con macro celdas o macro bloques embebidos. Estos son diseados
y fabricados a nivel de transistores, y sus funcionalidades complementan a
las celdas lgicas. Comnmente las macro celdas usadas incluyen bloques
de memoria, multiplicadores combinacionales, circuitos de manejo de reloj y
circuitos de interface entre entradas y salidas. Dispositivos FPGA mas
sofisticados suelen contener uno o ms ncleos de procesador
prefabricados.2

Pong P. Chu, FPGA Prototyping by VHDL Examples XILINX Spartan-3 Version. (1a Edicin), John Wiley
& Sons Inc, Hoboken, New Jersey: 2008

pg. 18

Familias comerciales de FPGAs.

Existen tres fabricantes mayoritarios en la distribucin de FPGAs y
software de soporte, estos son Xilinx, Altera y Actel. Sin embargo, en el
mercado mundial tambin existen otros como Lucent, Texas Instruments,
Philips, QuickLogic, Cypress, Atmel, entre otros. No obstante, por la
importancia de las tres primeras compaas se mencionaran algunas de las
familias lgicas que ofrecen.
FPGAs de Xilinx.
Son uno de los fabricantes ms fuertes en el nivel mundial. Sus
FPGAs estn basados en la tecnologa SRAM, son dispositivos
reprogramables (Many-Times Programable, MTP) y programables en
sistema (ISP).
Sus principales familias son: XC3000, XC4000, XC Virtex y XC
Spartan. Dichos dispositivos estn compuestos por mdulos lgicos CLBs,
basados en tablas de bsqueda. Cada CLB contiene circuitos que permiten
realizar operaciones aritmticas eficientes. Los usuarios tambin pueden
configurar las tablas de bsqueda como celdas lectura/escritura (read/write)
de RAM. Asimismo, a partir de la seria XC 4000 se incluye un generador
interno de seal de reloj, con 5 diferentes frecuencia.
Adems de los CLBs, los FPGAs de este fabricante incluyen otros
bloques complejos que configuran la entrada de los pines fsicos, estos a si
ves conectan el interior del dispositivo con el exterior y los bloques son
llamados bloques de Entrada/Salida (Input/Output Blocks, IOBs). Cada
IOB contiene una lgica compleja que permite que un pin actu como
entrada, salida o triestado (el triestado puede tomar valores de 0, 1 o de alta
impedancia).
FPGAs de Altera.
Altera ofrece dos familias de FPGAs con caractersticas diferentes,
pero conservando algunas bsicas que representan las ventajas originales
de las primeras familias estndar: FLEX 6000, 8000 y 10K; as como la ms
novedosa, APEX 20K. Las primeras familias estndar, la FLEX 6000 y la
8000 an se utilizan ampliamente. La serie FLEX (Matriz Flexible de
Elementos Lgicos, Flexible Logic Element Matrix) estndar contiene un
numero considerando de compuertas en tecnologa SRAM con tablas de
bsqueda, agregando mayor flexibilidad a los diseos.

pg. 19

La serie estndar FLEX combina la arquitectura de los CPLD con los

FPGAs. El dispositivo consiste de una arquitectura muy parecida a la de un
CPLD; en su nivel ms bajo de la jerarqua tiene un conjunto de tablas de
bsqueda, en lugar de un bloque muy similar a un SPLD, por ello se
considera un FPGA. El modulo lgico bsico, nombrado por Altera, elemento
lgico (Logic Element), contiene una LUT de 4 entradas, un flip-flop y un
elemento de acarreo (carry) de propsito especial para circuito aritmticos. El
elemento lgico tambin incluye circuitos en cascada, que permiten una
implementacin eficiente de funciones AND amplias.
Esta arquitectura agrupa elementos lgicos en grupos de 8, y los llama
bloques de arreglos lgicos (Arrays Logic Blocks, ALBs). Cada ALB,
contiene una interconexin local que le permite conectarse con otro ALB y a
la vez, la misma interconexin sirve para conectarse a la interconexin global
de la crossbar (matriz de interconexiones), nombrada por Altera como
FastTrack. As, las interconexiones se hacen al estilo de los CPLDs, pero la
configuracin de los bloques de arreglos lgicos utiliza tecnologa SRAM
propia de los FPGAs.
FPGAs de Actel
Actel ofrece una seria de familias OTP que resultan ampliamente
utilizadas despus de haber probado satisfactoriamente un diseo (emigrar a
otro FPGA). Las principales son: la serie estndar ACT, y las ms nuevas por
orden cronolgico de aparicin, sX, sX-A, mX y eX. Todas las anteriores son
programables fuera del sistema (OPS). Tambin ofrece una familia
reprogramable a la llamada Pro ASIC (por ser de alta densidad de
componentes, Actel no la considera parte de los FPGAs), basada en una
tecnologa Flash EEPROM programable en sistema (ISP).
Los FPGAs de Actel, emplean como modulo o elemento bsico una
estructura tipo arreglo fijo de compuertas. La lgica del arreglo est
dispuesta en renglones de mdulos lgicos interconectables, rodeados hacia
afuera por mdulos de E/S. la estructura de interconexiones consiste en
pistas o lneas fijas de interconexin, horizontales y verticales, con
segmentos de alambrado. Hay muchas pistas en cada canal entre los
renglones de la lgica. Las pistas verticales son menos y pasan sobre los
canales horizontales y los mdulos lgicos.
El FPGA de Actel utiliza tecnologa antifusible que proporciona una
programacin permanente y no voltil. El dispositivo tiene muchos
antifusibles para conectar las entradas y salidas de los mdulos de lgica y
E/S, a los segmentos de alambrado de los canales. Tambin tiene antifusible
pg. 20

que interconectan los segmentos de alambrado entre las pistas para ofrecer
conexiones de diferentes longitudes.
Una de las principales caractersticas de los mdulos lgicos de los
FPGAs de Actel, es que los mdulos no se programan para que efecten una
operacin, sino que toda la programacin se hace mediante antifusibles en
las pistas de alambrado.3

Familia Xilinx Spartan-3E FPGA

El FPGA utilizado en este proyecto es el Spartan-3E 100K de la marca
Xilinx.
Las caractersticas y capacidades de la familia Spartan-3E se han
optimizado para un alto volumen y aplicaciones de bajo costo. Debido a su
excepcional bajo costo, los FPGA de la familia Spartan-3E son viables para
un extenso mercado de aplicaciones electrnicas, incluyendo accesos de
banda ancha, redes locales, control de procesos y equipos de televisin
digital.
Celdas Lgicas, Slice, y Bloques Lgicos Configurables (CLB). El
elemento mas bsico de un dispositivo Spartan-3 es una celda lgica (Logic
Cell LC), el cual contiene LUTs de 4 entradas y un Flip-Flop D similar al de la
figura 3. Adems, una celda lgica contiene un circuito de acarreo (carry), el
cual es usado para implementar funciones aritmticas, y un circuito
multiplexor. Las LUT pueden ser configuradas como memorias estticas de
acceso aleatorio (Static Random Access Memory SRAM) de 16-por-1 o como
registros de corrimiento (Shift Register) de 16-bit.
Para incrementar la flexibilidad y mejorar el rendimiento, 8 celdas
lgicas son combinadas con una estructura especial en el ruteo interno. En
trminos del fabricante Xilinx, 2 celdas lgicas son agrupadas para formar un
Slice, y 4 slices son agrupado para formar un bloque lgico configurable
(Configurable Logic Block (CLB)).
Macro Celdas del Spartan-3. El dispositivo Spartan-3 cuenta con 4
tipos de macro bloques: multiplicador combinacional, bloque RAM, digital
clock manager (DCM) y bloque de entrada/salida (IOB). El bloque
multiplicador combinacional acepta dos nmeros de 18-bits como entrada y
calcula el producto. El bloque RAM es una SRAM de 18K-bit sncrona que
3

Menndez Ortiz Mara Alejandra, Arquitectura FPGA para la adquisicin de Datos Trmicos. Universidad
del Mar Campus Puerto Escondido Oaxaca Mxico: 2010.

pg. 21

puede ser configurada de distintas formas. El DCM usa un ciclo digitaldelayed para reducir los problemas con los tiempos y controlar la frecuencia
y fase de las seales de reloj. Las IOB controlan el flujo de datos entre los
pines de E/S y la lgica interna.4 La arquitectura del Spartan-3E es mostrada
en la Figura 6.
La Familia Spartan-3E cuenta con 5 miembros que ofrecen distintas
densidades, las cuales van desde los 100,000 hasta los 1.6 millones de
compuertas, tal y como se muestra en la Tabla 1.

Tabla 1- Densidades Familia Spartan-3E

Las caractersticas generales del Spartan 3-E se pueden encontrar en

su datasheet a travs del siguiente enlace 5
www.xilinx.com/support/documentation/data_sheets/ds312.pdf

Tarjeta Basys2
La tarjeta Basys2 es una plataforma para el diseo e implementacin
de circuitos digitales. La tarjeta esta construida en base a un FPGA Spartan3E de Xilinx y un controlador USB Atmel AT90USB2. La tarjeta Basys2
provee el hardware necesario listo para usarse capaz de soportar circuitos
que van desde el rango de lo bsico hasta el control complejo de procesos.
Una amplia gama de dispositivos de E/S y todas las conexiones del FPGA
son incluidas, por lo que incontables diseos pueden ser creados sin la
necesidad de componentes adicionales.

Pong P. Chu, FPGA Prototyping by VHDL Examples XILINX Spartan-3 Version. (1a Edicin), John Wiley
& Sons Inc, Hoboken, New Jersey: 2008
5

Sitio web oficial de Xilinx seccin documentacin de productos.

www.xilinx.com/support/documentation/data_sheets/ds312.pdf

pg. 22

Figura 6 Arquitectura Spartan 3-E FPGA

Cuatro conectores de expansin estndar permiten a la tarjeta Basys2

crecer utilizando circuitos diseados por el usuario o PMods. (Los PMods son
mdulos de E/S analgicos y digitales de bajo costo que ofrecen conversin
A/D y D/A, drivers para motor, entradas de sensor y muchas otras
caractersticas). Las seales en los conectores de 6 pines estn protegidas
contra corto circuito, garantizando una larga vida de funcionamiento en
cualquier ambiente. La tarjeta Basys2 trabaja en cualquier versin del
compilador Xilinx ISE tools, incluyendo la licencia gratuita WebPack.
Contiene un cable USB que le proporciona energa y es utilizado como
interfaz de programacin, por lo que ninguna otra fuente de poder o cable de
programacin es requerido. 6 En la Figura 7 se muestra el diagrama a
bloques de la tarjeta Basys2.
Caractersticas Generales:
-

Xilinx Spartan 3-E FPGA, 100K or 250K gate

6

Manual de Referencia Tarjeta Basys2:http://www.digilentinc.com/Data/Products/BASYS2/Basys2_rm.pdf

pg. 23

FPGA con multiplicadores de 18-bit, 72Kbits de bloque RAM dual-port,

y 500MHz+ velocidad de operacin
Puerto USB2 full-speed para la configuracin y transferencia de datos
hacia el FPGA (utilizando el software Adept 2.0 disponible en
descarga gratuita)
XCF02 Platform Flash ROM que almacena las configuraciones del
FPGA
Frecuencia de oscilacin ajustable (25, 50, and 100 MHz), adems
cuenta con socket para un oscilador extra
3 reguladores de voltaje incluidos (1.2V, 2.5V, and 3.3V) que permiten
el uso de fuentes externas de 3.5V a 5.5V.

Figura 7 Diagrama a bloques Tarjeta Basys2

8 LEDs, 4 displays de siete segmentos, 4 pushbuttons, 8 slide

switches, Puerto PS/2, y un puerto VGA de 8-bit
Cuatro conectores de 6-pines para E/S del usuario, y compatibles con
los circuitos Digilent PMOD.

La compra, asi como la documentacin completa y ejemplos acerca de

la tarjeta Basys2 se encuentran en el siguiente enlace7.

Documentacin Completa, Compra y ejemplos de la Tarjeta Basys2 de Digilent INC.

http://www.digilentinc.com/Products/Detail.cfm?NavPath=2,400,790&Prod=BASYS2

pg. 24

Tendencias Tecnolgicas por Mercado del FPGA

Las tendencias de Aplicaciones FPGA a nivel Mundial se muestran en
la Figura 8.

Figura 8 Aplicaciones FPGA a nivel Mundial

Comunicaciones
De acuerdo a la empresa de consultora industrial Gartner, durante el
ciclo fiscal 2008-2009, el mercado de la tecnologa FPGAs para
Comunicaciones gener aproximadamente USD $ 1,45 millones de dlares,
mientras que las proyecciones para el 2012 ascienden a unos USD $ 2,096
millones de dlares.
En cuanto a la cantidad de patentes registradas con esta tecnologa
para Comunicaciones, indica que a la fecha se tiene un total de 2,527
documentos y solicitudes a nivel internacional. Los campos en donde se ha
generado mayor propiedad intelectual son: Comunicaciones pticas,
Comunicaciones Inalmbricas/Almbricas, Antenas, Moduladores y
Codificadores y Redes.

pg. 25

Aeroespacial y Militar
El mercado de la tecnologa FPGA en el 2008 fue de
aproximadamente USD$447 millones y se estima que para el 2012 sea de
USD$717 millones.
Aplicaciones:
-

Sistemas de radar
Enlaces de comunicaciones de alta velocidad
Misiles
Aplicaciones de alta confiablidad en el espacio
Procesamiento digital de seales robusto y de alta seguridad

Automotriz
El mercado de la tecnologa FPGA en el 2008 fue de
aproximadamente USD$83 millones y se estima que para el 2012 sea de
USD$358 millones.

Aplicaciones:
GPS
Infoentretenimiento
Control de frenos
Control de luces
Sistemas de seguridad

Industrial
Los sectores industriales que mayor consumo de FPGAs registran son
para aplicaciones de Sistemas de Manufactura, Equipo Mdico y Monitoreo
de Pacientes, Seguridad, Administracin de Energa, Pruebas y Mediciones,
Redes y Domtica. En el 2008 el sector industrial recaud 852 millones de
dlares (mdd) y se estima que para el 2012 ascienda a unos 1,406 mdd. La
cantidad de patentes internacionales en el sector Industrial con tecnologa
FPGAs llega a 524 documentos y solicitudes.

pg. 26

Electrnica de Consumo
En el rea de electrnica de consumo, los FPGAs generaron en el
2008 un total de 469 mdd por ingresos y se estima que para el ao 2012 se
eleve a 672 mdd. En cuanto a propiedad intelectual a nivel internacional se
han registrado 102 documentos y solicitudes. Las aplicaciones ms comunes
en las que son utilizados son: Audio, Video y Equipo de Oficina.
Procesamiento de Datos
El mercado de FPGAs en el 2008 para este campo sum 312 mdd y
se tiene proyectado que para el ao 2012 alcance los 335 mdd. Sus
principales aplicaciones han sido para el desarrollo de Sper computadoras,
Tarjetas Inteligentes, Servidores, Procesadores y Computadoras Personales
(PCs). 8

Lenguaje VHDL
VHDL es el acrnimo que representa la combinacin
de VHSIC y HDL, donde VHSIC es el acrnimo de Very High Speed
Integrated Circuit y HDL es a su vez el acrnimo de Hardware Description
Language.
Es un lenguaje definido por el IEEE (Institute of Electrical and
Electronics Engineers) (ANSI/IEEE 1076-1993) usado por ingenieros para
describir circuitos digitales.
Aunque puede ser usado de forma general para describir cualquier
circuito se usa principalmente para programar PLD (Programable Logic
Device - Dispositivo Lgico Programable), FPGA (Field Programmable Gate
Array), ASIC y similares.
Formas de describir un circuito

Dentro del VHDL hay varias formas con las que podemos disear el
mismo circuito y es tarea del diseador elegir la ms apropiada.
8

Red Estrategica de Tecnologia FPGA (AERI FPGA):

http://www.conacyt.gob.mx/fondos/institucionales/Tecnologia/Avance/Redes/1-FPGA-FUMEC-AERI.pdf

pg. 27

Funcional: Describimos la forma en que se comporta el circuito. Esta

es la forma que ms se parece a los lenguajes de software ya que la
descripcin es secuencial. Estas sentencias secuenciales se
encuentran dentro de los llamados procesos en VHDL. Los procesos
son ejecutados en paralelo entre s, y en paralelo con asignaciones
concurrentes de seales y con las instancias a otros componentes.

Flujo de datos: describe asignaciones concurrentes (en paralelo) de

seales.

Estructural: se describe el circuito con instancias de componentes.

Estas instancias forman un diseo de jerarqua superior, al conectar
los puertos de estas instancias con las seales internas del circuito, o
con puertos del circuito de jerarqua superior.

Mixta: combinacin de todas o algunas de las anteriores.

En VHDL tambin existen formas metdicas para el

de mquinas de estados, filtros digitales, bancos de pruebas etc.

diseo

Secuencia de diseo

El flujo de diseo de un sistema es:

Construccin del diagrama en bloque del sistema.

Elaboracin del cdigo en VHDL para cada modulo, para sus
interfaces y sus detalles internos. Como el VHDL es un lenguaje
basado en texto, se puede utilizar cualquier editor para esta tarea,
aunque el entorno de los programas de VHDL incluye su propio editor
de texto.
Compilacin. El compilador de VHDL analiza el cdigo y determina
los errores de sintaxis y chequea la compatibilidad entre mdulos.
Crea toda la informacin necesaria para la simulacin.
Simulacin funcional. En este tipo de simulacin se comprueba que
el cdigo VHDL ejecuta correctamente lo que se pretende.
Sntesis. En este paso se adapta el diseo anterior a un hardware en
concreto, ya sea una FPGA o un ASIC. Hay sentencias del lenguaje
que no son sintetizables, como por ejemplo divisiones o
exponenciaciones con nmeros no constantes. El hecho de que no
todas las expresiones en VHDL sean sintetizables es que el VHDL es
un lenguaje genrico para modelado de sistemas (no slo para diseo
pg. 28

de circuitos digitales), por lo que hay expresiones que no pueden ser

transformadas a circuitos digitales. Durante la sntesis se tiene en
cuenta la estructura interna del dispositivo, y se definen restricciones,
como la asignacin de pines. El sintetizador optimiza las expresiones
lgicas con objeto de que ocupen menor rea, o bien son eliminadas
las expresiones lgicas que no son usadas por el circuito.
Simulacin post-sntesis. En este tipo de simulacin se comprueba
que el sintetizador ha realizado correctamente la sntesis del circuito,
al transformar el cdigo HDL en bloques lgicos conectados entre s.
Este paso es necesario ya que, a veces, los sintetizadores producen
resultados de sntesis incorrectos, o bien realiza simplificaciones del
circuito al optimizarlo.
Ubicacin y enrutamiento. El proceso de ubicacin consiste en situar
los bloques digitales obtenidos en la sntesis de forma ptima, de
forma que aquellos bloques que se encuentran muy interconectados
entre s se siten prximamente. El proceso de enrutamiento consiste
en interconectar adecuadamente los bloques entre s, intentando
minimizar retardos de propagacin para maximizar la frecuencia
mxima de funcionamiento del dispositivo.
Anotacin final. Una vez ha sido completado el proceso de ubicacin
y enrutamiento, se extraen los retardos de los bloques y sus
interconexiones, con objeto de poder realizar una simulacin temporal
(tambin llamada simulacin post-layout). Estos retardos son anotados
en un fichero SDF (Standard Delay Format) que asocia a cada bloque
o interconexin un retardo mnimo/tpico/mximo.
Simulacin temporal. A pesar de la simulacin anterior puede que el
diseo no funcione cuando se programa, una de las causas puede ser
por los retardos internos del chip. Con esta simulacin se puede
comprobar, y si hay errores se tiene que volver a uno de los pasos
anteriores.
Programacin en el dispositivo. Se implementa el diseo en el
dispositivo final y se comprueba el resultado.

En la Figura 9 se muestra el diagrama de flujo con la secuencia de

diseo necesaria.

pg. 29

Inicio

Diagrama a bloques del

sistema

Cdigo en VHDL

No
Compilacin
Si
Simulacin
Funcional

No

Si
No
Sntesis
Si
Simulacin
Pos-Sintesis

No

Si
Ubicacin y
Enrrutamiento

Fichero SDF

Anotacin Final

Simulacin
Temporal

No

Programacin del
Dispositivo

Fin

Figura 9- Diagrama de Flujo Secuencia de Diseo

pg. 30

Ventajas de los lenguajes HDL

El empleo de HDL presenta ventajas respecto al empleo de

descripciones basadas en esquemticos. Algunas de ellas son las siguientes:
1)

Puesto que una descripcin HDL es simplemente un fichero de

texto, es mucho ms portable que un diseo esquemtico, que
debe ser visualizado y editado empleando la herramienta grfica
especfica del entorno de CAD (Computer-Aided Design - Diseo
asistido por ordenador) con el que se ha creado.

2)

Una descripcin esquemtica nicamente describe el diseo de

manera estructural, mostrando los mdulos y la conexin entre
ellos. Por el contrario, la descripcin del circuito usando un HDL
puede realizarse bien mostrando la estructura, o bien describiendo
el comportamiento. Es decir, los HDL permiten describir el
comportamiento que se desea que tenga el circuito, sin hacer
ninguna referencia a su estructura. Las herramientas de sntesis
permiten generar automticamente la estructura del circuito lgico a
partir de la descripcin de su comportamiento.

3)

El mismo HDL que se ha usado para la descripcin del circuito,

puede emplearse para describir los vectores de test y los resultados
esperados del test. Los vectores de test son los valores de las
seales aplicadas a los pines de entrada del circuito con la finalidad
de probar si el funcionamiento del circuito es correcto. As pues,
pueden realizarse los programas de test (vectores de test e
instantes en los cuales son aplicados) del circuito a medida que se
disea el propio circuito, pudindose con ello ir realizando
diferentes pruebas a medida que se avanza en el diseo. Como
ventajas aadidas, la descripcin de los programas de test usando
HDL es altamente portable y repetible.

Entity

La entity define la interfaz externa de la entidad de diseo. Incluye:

El nombre de la entidad de diseo.
La lista de las seales de salida y de entrada que componen la
interfaz (normalmente se aplica el convenio de escribir primero las salidas y a
continuacin las entradas). A cada una de estas seales se le denomina

pg. 31

puerto (port). Existen tres tipos de puertos: in (entrada), out (salida) e inout
(bidireccional).
La palabra reservada entity, seguida del nombre de la interfaz y de las
palabras reservadas is port, indica el comienzo de la definicin de la interfaz.
A continuacin, se especifica el nombre de cada uno de los puertos, su
direccin (in, out o inout) y su tipo. En el ejemplo mostrado en la Figura 10,
todos los puertos son seales del tipo std_logic.
Finalmente, las palabras reservadas end entity, seguidas del nombre
de la interfaz, indican el final de la definicin.

Figura 10 Definicin de Entidad de compuertas NOT, XOR y AND

Los nombres definidos por el usuario deben comenzar por una letra,
seguida opcionalmente por cualquier secuencia de letras, nmeros y
caracteres guion bajo, con la limitacin de que ni pueden aparecer dos
guiones bajos seguidos, ni el guion bajo puede ser el ultimo caracter del
nombre. En VHDL no se diferencia entre los caracteres en mayscula y en
minscula.
Los tipos de seales utilizados en el lenguaje VHDL se muestran en la
Tabla 2.

TIPO

Caractersticas

BIT

En este tipo las seales solo toman los valores de "1" y

"0"

Booleana

En este tipo las seales solo toman los valores de True y

False

pg. 32

Std_logic

En este tipo las seales toman 9 valores, entre ellos

tenemos: "1", "0", "Z" (para el 3er estado), "-" (para
los opcionales).

Integer

En este tipo las seales toman valores enteros. Los 1 y

los 0 se escriben sin

Bit_Vector

En este tipo los valores de las seales son una cadena de

unos y ceros. Ejemplo: 1000

Std_Logic_Vector

En este tipo los valores de las seales son una cadena de

los nueve valores permisibles para el tipo std_logic.

Character

Contiene todos los caracteres ISO de 8 bits, donde los

primeros 128 son los caracteres ASCII.
Tabla 2 Tipos de Datos VHDL

Architecture
La architecture describe el comportamiento o la estructura de la
entidad de diseo. En la Figura 11 se muestra la arquitectura de las
compuertas NOT, XOR y AND.9

Figura 11 Arquitectura compuertas NOT, XOR y AND

Urqua Alfonso, Martn Villalba Carla, Casos prcticos de diseo de circuitos digitales con VHDL,
Universidad Nacional de Educacin a Distancia (UNED) Departamento de Informtica y Automtica, Madrid,
Espaa: 2008

pg. 33

Bibliotecas

Una biblioteca en VHDL es un lugar en donde se guarda la

informacin relacionada con un diseo determinado. Al comienzo de cada
diseo el compilador crea automticamente una biblioteca llamada WORK
con este objetivo. Adems de esta biblioteca particular existen otras
bibliotecas de tipo general que contienen un conjunto de definiciones que
pueden utilizarse en cualquier diseo. Un ejemplo de biblioteca general es la
llamada Library IEEE, que contiene definiciones estndar para VHDL. Para
utilizar una biblioteca general es necesario escribir su nombre al inicio del
programa, por eso es muy comn que en la primera lnea de un diseo en
VHDL aparezca escrito "Library IEEE", de sta forma dicha biblioteca se
hace visible para el diseo.
Paquetes
En los paquetes se guardan definiciones de tipos y objetos que
pueden ser utilizados en los diferentes diseos que invoquen su utilizacin.
Un
paquete
muy
utilizado
es
el
paquete
estndar
IEEE_STD_LOGIC_1164.ALL; La utilizacin de un paquete en un diseo se
realiza invocando su empleo mediante la clusula USE y el nombre del
paquete. Por ejemplo USE IEEE_STD_LOGIC_1164.ALL;
La terminacin ALL, permite utilizar todas las definiciones y objetos
que contiene dicho paquete. Adems del estndar, existen otros paquetes de
utilizacin general y tambin los diseadores que trabajan con VHDL pueden
definir sus propios paquetes, lo que les permite reutilizar diseos realizados
anteriormente como parte de nuevos diseos.

pg. 34

PROCEDIMIENTO Y DESCRIPCIN DE LAS

ACTIVIDADES REALIZADAS

Adquisicin de la Tarjeta Basys2

La Tarjeta Basys2 y otros instrumentos fueron solicitados a la empresa
Digilent a travs de su sitio web oficial www.digilentinc.com.
El catlogo completo de las tarjetas basadas en FPGAs y CPLDs se
encuentra en el siguiente vnculo:
http://www.digilentinc.com/Products/Catalog.cfm?NavPath=2,400&Cat=10&F
PGA

Cantidad

Producto

Basys2

Basys2 Spartan 3E FPGA Board

Multimete
r-MS821
PMOD-TMP

Autorange Digital Multimeter

Descripcin

PMOD-TMP Thermometer

Precio
Unitario
$ 59.00
USD
$ 29.99
USD
$ 24.99
USD

Sub
Total
$ 59.00
USD
$ 59.98
USD
$ 24.99
USD

Tabla 3: Gastos en Digilent Inc

El envi desde USA se hizo a travs del servicio de paquetera Fed-Ex

en un lapso de 3 das hbiles.

Cantidad

Producto

Envo

Impuesto

Descripcin
Servicio de Paquetera FedEx
Impuesto Aduanal

Precio
Unitario
$ 81.77
USD
$ 30.00
USD

Sub
Total
$ 81.77
USD
$ 30.00
USD

Tabla 4: Gastos de Envio

Adems se utilizaron componentes electrnicos pasivos y activos para

la implementacin de las prcticas que implicaron un gasto extra en el
desarrollo del proyecto. Estos componentes fueron adquiridos en
distribuidores locales.

pg. 35

Cantidad

Producto

Descripcin

Precio
Unitario

Protoboard

Tablilla para Prototipos

SN754410

Quadruple Half-H Driver

NE555

Multivibrador 555

30

Resistor

Capacitor

20

2N25

Resistores de distintos
valores
Capacitores Electrolticos
y Cermicos
Optoacoplador MOC

10

2N2222

NPN Transistor

Motor

Motro de 5V CD

Relay

Relays de 5V CD

Cable
Telefnico

Metros de Cable Telefnico

$ 9.00
USD
$ 2.99
USD
$ 0.95
USD
$ 0.10
USD
$ 0.30
USD
$ 0.80
USD
$ 0.23
USD
$ 1.00
USD
$ 1.00
USD
$ 0.88
USD

Sub
Total
$ 18.00
USD
$ 2.99
USD
$ 0.95
USD
$ 3.00
USD
$ 1.50
USD
$ 16.00
USD
$ 2.30
USD
$ 1.00
USD
$ 2.00
USD
$ 2.64
USD

Tabla 5: Gastos Extras

Por lo tanto el gasto total es de:

306.12 USD

Convertido a moneda nacional a una tasa de cambio de $ 13.43 MN el

gasto total es de:
$ 4111.18 MN

Descarga e Instalacin de Software ISE Design Suite 13.4 y Adept

2.6.1 System
Xilinx ofrece una licencia gratuita de su entorno de desarrollo y diseo
para sus dispositivos reconfigurables, la versin gratuita se conoce como
Webpack, en ltimas versiones no se trata de un software separado del
principal sino de una licencia de uso especial para el mismo, a continuacin
se muestran los pasos necesarios para descargar el software y obtener la
licencia gratuita.
1- Ingresar y registrarse en el sitio web de Xilinx: www.xilinx.com. Al
ingresar al sitio, en el men de la parte superior se tiene la opcin
Sign In, que permite ingresar con una cuenta creada con
anterioridad o registrarse con una nueva mediante el enlace
Create Account.

pg. 36

Figura 12 Pgina Principal de Xilinx

Para el registro se deben proporcionar algunos datos personales tales

como nombre, direccin y correo electrnico.
2- Una vez registrados en el sitio, se puede acceder a la seccin de
descargas, puede hacerse desde el enlace Downloads en la
parte superior del sitio. El software que nos interesa se llama ISE
Design Suite, en la pgina se puede seleccionar la versin a
descargar as como el sistema operativo con el cual trabajaremos:
hay tres opciones de descarga, instalador para Windows,
instalador para Linux o los binarios. La versin ms reciente del
software y la utilizada en este documento es la 13.4.
3- La descarga no es directa, sino que al hacer clic en alguno de los
enlaces se instala el administrador de descargas de Xilinx, es
necesario permitir la ejecucin del mismo, el cual permitir pausar
y continuar la descarga de los archivos, algo bastante til ya que el
software pesa 5.67 GB.
4- Una vez descargado el software, es necesario obtener una licencia
de uso, se utilizar la licencia Webpack que es gratuita, como se
ha expuesto anteriormente la principal diferencia con la versin de
pago es que soporta menos dispositivos, por lo tanto para el
desarrollo de proyectos de mayor volumen no ser de utilidad. En
la misma pgina de descargas, a la derecha de los enlaces para
descargar ISE Design Suite se encuentra el enlace License
Solution Center

pg. 37

Figura 13 Seccin de Descargas

5- Una vez adquirido el software ISE Design Suite y la Licencia,

procedemos a instalarlo; basta con seguir los sencillos pasos y
ubicar el directorio de la licencia. Para el uso de las tarjetas de
Digilent que cuentan con conector Mini-USB como lo son la Basys2
y Nexys2 se requiere un software extra para poder realizar la
comunicacin: Adept de Digilent; El software puede descargarse
de manera gratuita en el sitio web de Digilent www.digilentinc.com ,
en la seccin Software: Digilent Adept, el paquete a descargar
para Windows es Adept 2.6.1 System, 32/64-bit. Su instalacin es
muy sencilla, basta con hacer doble clic en el icono del software
descargado y seguir las instrucciones.
Con esto se tiene instalado el software necesario para el uso de la
Tarjeta Basys2.

Uso del Software ISE Design Suite 13.4, Adept 2.6.1 System y
configuracin de la Tarjeta Basys2
Para explicar el uso del software ISE Design Suite 13.4, Adept 2.6.1
System, la descarga y configuracin de los programas hacia la Tarjeta
Basys2 as como las bases del lenguaje de programacin VHDL, se
desarrollar una prctica sencilla que servir de gua a travs de la creacin,
simulacin y descarga del proyecto. Iniciaremos por compuertas lgicas

pg. 38

AND, OR y XOR, y estas mismas sern utilizadas para hacer un medio

sumador y a su vez un sumador completo. A continuacin se muestran todos
los pasos que se realizarn:
Se inicia por abrir ISE Project Navigator. Al iniciar el programa, carga
automticamente el ltimo proyecto con el cual se trabaj. Se crea un nuevo
proyecto, para ello se selecciona el men File y despus New Project, con
esto se iniciar el asistente de creacin de nuevo proyecto, en la primera
ventana que se muestra habr que indicar el nombre del proyecto, la carpeta
de trabajo del proyecto (al introducir el nombre del proyecto se indicar
automticamente una carpeta con el mismo nombre), una descripcin del
proyecto (opcional) y en la parte inferior se tiene que indicar el tipo de archivo
fuente que ser el mdulo principal del proyecto, se deja en HDL.

Figura 14 Asistente de Creacin de un nuevo Proyecto

A continuacin se da clic en el botn Next, lo cual mostrar la ventana

Project Settings, donde se indica el modelo del dispositivo utilizado en el
proyecto, adems de las herramientas a utilizar para las diferentes etapas del
diseo. Para el uso de la Tarjeta Basys2, las opciones necesarias son las
mostradas en la Figura 15.

pg. 39

Figura 15 Opciones de Configuracin de Tarjeta Basys2

Una vez indicadas las opciones adecuadas, se hace clic en el botn

Next, se mostrar un resumen del proyecto, finalmente se da clic en el botn
Finish y se crear el proyecto nuevo, todava sin ningn archivo fuente
agregado, solamente se ver el nombre del archivo de proyecto en la parte
superior y en la ventana Hierarchy dentro del panel Design el dispositivo
seleccionado.
Ahora se procede a agregar un nuevo archivo fuente al proyecto, esto
se realizar utilizando el men Project => New Source, con lo que
aparecer una ventana donde se debe indicar el tipo de mdulo que se
desea agregar al proyecto, se selecciona VHDL Module y como nombre del
programa compuerta_and. Es importante que est seleccionada la opcin
Add to Project. Observe la Figura 16.

pg. 40

Figura 16 Ventana New Source Wizard

Despus se da clic en el botn Next lo cual mostrar la ventana

Define Module, aqu se deben indicar las caractersticas del mdulo; el
nombre de la entidad, el nombre de la arquitectura y las entradas y salidas
con las que contar. Se debe tener algo como lo mostrado en la Figura 17.

Figura 17 Ventana Define Module

pg. 41

A continuacin se da clic en el botn Next, con lo que se mostrar un

resumen del nuevo archivo fuente que se ha agregado al proyecto. Por
ltimo se da clic en el botn Finish para que se agregue la nueva fuente al
proyecto, se abrir la ventana del editor donde se cargar el contenido del
nuevo archivo compuerta_and.vhd (el nombre indicado para el nuevo
archivo fuente con la extensin .vhd que corresponde a un mdulo VHDL)
Analice el cdigo que se presenta al terminar de crear la nueva fuente
del proyecto; la primera seccin que se aprecia con dos guiones al inicio, es
cdigo predefinido que ISE Project Navigator inserta al inicio de cada mdulo
que se agrega a un proyecto, se puede notar que todas las lneas en esta
primera seccin inician con un par de guiones : al igual que en los
lenguajes de programacin de software, VHDL permite insertar comentarios
en el cdigo, los cuales se indican mediante esos dos guiones, todo el texto
que siga a estos guiones se toma como un comentario.
---------------------------------------------------------------------------------- Company:
-- Engineer:
--- Create Date:
15:11:22 05/10/2012
-- Design Name:
-- Module Name:
compuerta_and - Behavioral
-- Project Name:
-- Target Devices:
-- Tool versions:
-- Description:
--- Dependencies:
--- Revision:
-- Revision 0.01 - File Created
-- Additional Comments:
---------------------------------------------------------------------------------Cdigo 1 Cdigo Predefinido por ISE Project Navigator

Mas adelante se tiene el siguiente cdigo:

library IEEE;
use IEEE.STD_LOGIC_1164.ALL;
Cdigo 2 Libreras utilizadas en el programa

La instruccin library permite indicar una biblioteca externa de la cual

se desee utilizar sus tipos de datos, operadores y algunas otras
declaraciones; sera equiparable a la instruccin #include de los lenguajes C

pg. 42

y C++. De manera similar a estos lenguajes, VHDL termina cada instruccin

con punto y coma: ;.
Despus se tiene una instruccin use, que permite indicar qu
paquete se va a utilizar de la biblioteca que antes se haba declarado con
library. En este caso, se indica que se va a hacer uso de la biblioteca IEEE,
que es una biblioteca estndar definida por el Institute of Electrical and
Electronics Engineers, seguido de use se tiene STD_LOGIC_1164 lo cual
hace referencia al paquete de la biblioteca que se utilizar y por ultimo se
indica que de ese paquete se utilizaran todas sus declaraciones por medio
de la instruccin ALL.
Cabe mencionar que VHDL es un lenguaje que no distingue
minsculas de maysculas.
Entidad y Arquitectura
En VHDL, cada mdulo est compuesto por dos partes: la entidad y la
arquitectura. La entidad es la seccin donde se indican las conexiones
(seales) del mdulo con el resto de componentes, se indican el nmero de
entradas y salidas, adems del tipo de cada una de ellas. La sintaxis de
declaracin de entidad y de sus conexiones es la siguiente:
entity NOMBRE_ENTIDAD is
port (
NOMBRE_SEAL1 : MODO TIPO;
NOMBRE_SEAL2 : MODO TIPO
);
end NOMBRE_ENTIDAD;
Cdigo 3 Sintaxis de la Entidad

En primer lugar se indica el nombre de la entidad, utilizando la palabra

reservada entity, y despus de la instruccin is se inicia la descripcin de la
entidad, en este caso de las seales o puertos mediante los cuales se
comunicar con el exterior; para cada seal se indica su nombre, el modo
(entrada, salida o ambos) y el tipo. Notese que las declaraciones de puertos
finalizan con punto y coma, excepto la ltima antes del parntesis que
culmina la instruccin port.
Por lo tanto, continuando con el mdulo, ISE Project Navigator ha
insertado el cdigo mostrado en el recuadro de cdigo 4:
entity compuerta_and is
Port ( a : in STD_LOGIC;
b : in STD_LOGIC;

pg. 43

s : out
end compuerta_and;

STD_LOGIC);
Cdigo 4 Entidad Compuerta_and

La entidad cuyo nombre es compuerta_and, tiene tres puertos, todos

de tipo std_logic, los dos primeros denominados a y b, son entradas (in),
mientras que el tercero, denominado s, es una salida (out), el diagrama
esquemtico de la entidad creada se puede representar de la siguiente
manera:

Figura 18 Diagrama esquemtico compuerta_and

De cierta forma, se considera la declaracin de la entidad como una

caja negra, para la cual se conocen sus entradas y salidas, pero no su
funcionamiento interno, el cual se describe en la arquitectura.
La arquitectura es la seccin de un mdulo VHDL en la que se
describe el funcionamiento de la entidad, y puede hacerse de dos maneras
diferentes: describiendo su estructura interna mediante interconexiones entre
compuertas y componentes que constituyen al mdulo, lo que se denomina
una descripcin estructural, o con una descripcin de lo que hace el mdulo,
ya sea mediante funciones booleanas o mediante una descripcin
algortmica, lo que se conoce como una descripcin de comportamiento. La
sintaxis para declarar una arquitectura es mostrada en el recuadro de cdigo
5.
architecture NOMBRE_ARQUITECTURA of NOMBRE_ENTIDAD is
-- Aqu se declaran elementos auxiliares para usar en la descripcin
begin
-- Aqu se realiza la descripcin de la arquitectura,
-- mediante la utilizacin de sentencias secuenciales,

pg. 44

-- combinacionales o subprogramas.
end NOMBRE_ARQUITECTURA;
Cdigo 5 Sintaxis de la Arquitectura

Como se puede observar se utiliza la instruccin architecture para

iniciar la declaracin de la arquitectura, despus se indica su nombre y el
nombre de la entidad a la cual corresponde la descripcin que se realizar,
se continua con la instruccin begin para indicar el inicio del cdigo que
describe el funcionamiento de la arquitectura, y finaliza con la instruccin end
seguido del nombre de la arquitectura. Entre las instrucciones is y begin, es
posible declarar seales, componentes o elementos auxiliares para la
descripcin de la arquitectura, algunos de estos elementos se vern ms
adelante.
ISE Project Navigator nos crea la plantilla de la arquitectura, para que
el programa compuerta_and funcione se debe describir su comportamiento;
para lo cual se agrega despus de la instruccin begin lo que se desea que
haga el programa. El resultado se muestra en el recuadro de cdigo 6.
architecture behavioral of compuerta_and is
begin
s <= a and b;
end behavioral;
Cdigo 6 Arquitectura compuerta_and

Con esto, se asigna el resultado de la operacin and entre las seales

de entrada a y b a la seal de salida s. Como se observa, la pareja de
caracteres <=" son el operador de asignacin de seales en VHDL, tambin,
se hace uso del operador and, que realiza la operacin lgica AND entre sus
dos operandos. Adems del operador and, en VHDL se tienen definidos los
siguientes operadores lgicos: or, nand, nor, xor y xnor. Finalmente, se
termina la instruccin con un punto y coma.
Una vez que se ha adicionado este cdigo al mdulo, se procede a
guardar los cambios realizados usando el comando Save dentro del men
File o pulsando en el botn con icono de un disco flexible en la barra de
herramientas. Para comprobar que no se han cometido errores en el cdigo
del mdulo, se debe realizar una revisin de sintaxis, para ello, en la ventana
Hierarchy, se da clic en el nombre del mdulo (compuerta_and), despus,
en la ventana Processes, se expande la seccin Synthesize XST, de
manera que se pueda ver el proceso Check Syntax tal y como se muestra
en la figura 19.

pg. 45

Figura 19 Revisin de Sintaxis

Para iniciar la revisin de sitanxis del cdigo, se hace doble clic sobre
el nombre del proceso o con un clic derecho y luego seleccionando el
comando Run del men contextual. Se puede observar el resultado del
proceso de revisin de sintaxis en la parte inferior del programa en la
ventana de resultados.

Figura 20 Resultado del Chequeo de Sintaxis

Al terminar el proceso, un icono con una palomita blanca indica que la

revisin de sintaxis ha concluido exitosamente pues no se encontraron
errores en el cdigo.

pg. 46

Con esto se ha revisado el cdigo del mdulo, resta comprobar que

funcione correctamente, para ello se puede realizar una simulacin antes de
proceder a la implementacin en un dispositivo reconfigurable.

Simulacin
Analicemos cmo realizar una simulacin del componente
compuerta_and. En primer lugar, dentro de Project Navigator, en la seccin
Design, en la opcin View, se selecciona Simulation:

Figura 21 Simulacin

A continuacin, dentro de la ventana Hierarchy, se selecciona el

componente que se desea simular, al hacerlo cambiarn las opciones
disponibles en la ventana Processes, en este caso se muestra ISim
Simulator, se da clic en el signo + a la izquierda de ISim Simulator con lo
que se mostrarn dos procesos: Behavioral Check Syntax y Simulate
Behavioral Model

pg. 47

Figura 22 Ventana Processes ISim Simulator

Este ltimo proceso es el que permitir realizar la simulacin, se hace

doble clic en Simulate Behavioral Model y se espera a que inicie ISim.

Figura 23 Ventana ISim Simulator

ISim muestra por defecto cuatro ventanas o secciones, una en la parte

inferior y tres en el medio: Instances and Processes, muestra las entidades,
bibliotecas y procesos existentes en el mdulo; Objects, despliega una lista
de los puertos que forman parte del mdulo, indicando con un pequeo icono
con la letra I aquellos que son entradas y con la letra O los que son salidas; y
la ventana de simulacin, donde se despliegan nuevamente los puertos del

pg. 48

mdulo con lneas de tiempo que permitirn visualizar el comportamiento de

cada uno de dichos puertos para cada instante de la simulacin.
La tabla de verdad de una compuerta AND de dos entradas se
muestra en la Tabla 6.
b

0
0
1
1

0
1
0
1

0
0
0
1

Tabla 6 Tabla de verdad compuerta AND

Se tienen cuatro combinaciones posibles de valores para las entradas

a y b, para comprobar el funcionamiento del mdulo es conveniente simular
estos cuatro casos; para ello, se asignan valores a las entradas de manera
que se tengan las cuatro combinaciones posibles y se pueda evaluar el valor
que toma la salida para cada una de ellas.
Se inicia por la primera combinacin, cuando ambas entradas valen 0,
para indicar que una entrada tendr el valor 0 en el simulador, se da clic con
el botn derecho del ratn sobre dicha entrada en la ventana de simulacin,
del men que se despliega se selecciona la opcin Force Constant
Aparecer la ventana Force Selected Signal; en la opcin Force to
Value: escribiremos un 0 como se muestra en la Figura 24. Se hace clic en el
botn OK.
Se repiten estos pasos para la seal de entrada b: se hace clic con el
botn derecho sobre el nombre de la entrada en la ventana de simulacin, se
selecciona la opcin Force Constant, y se establece a 0 la opcin Force
to Valu: se da clic en el botn OK.
Al hacer esto no se nota ningn cambio en la ventana de simulacin
una vez que se han indicado los valores de 0 para las dos seales, estos se
notarn hasta que se ejecute la simulacin. Para ello se har uso de la barra
de herramientas de ISim.

pg. 49

Figura 24 Ventana Force Selected Signal

Se da clic en el botn que tiene como icono una punta de flecha y un

reloj de arena, esto ejecuta la simulacin por un tiempo determinado, el cual
se indica a la derecha del botn; en este caso, 1 us, la ventana de simulacin
ahora muestra lo que se observa en la figura 25.

Figura 25 Resultado Simulacin Valor 1

Como se puede observar, los valores en la columna Value han

cambiado de U a 0, la U indica valor desconocido, que era el caso antes de
iniciar la simulacin, ahora que se ha simulado por un tiempo de 1us, las
entradas se encuentran en valores de 0, que fue como se forz, adems la
seal de salida s tambin tiene el valor de 0, esta no se forz, sino que toma
el valor especificado en el mdulo: la operacin AND entre las
entradas a y b, que en este caso es 0.
Ahora, cambie el valor de la entrada a por 1, para evaluar el segundo
caso de la tabla de verdad de la operacin AND de dos entradas, se hace
clic con el botn derecho sobre el nombre de la seal y se selecciona el
comando Force Constant nuevamente; en esta ocasin se establecer un 1
en la opcin Force to value. Se hace clic en el botn para ejecutar la
pg. 50

simulacin por cierto tiempo, lo que nos mostrar algo como lo que se tiene
en la Figura 26.

Figura 26 Resultado Simulacin Valor 2

La columna Value ha cambiado a 1 para el caso de la seal a,

adems, en la ventana de tiempo la lnea verde a la derecha de la misma
seal se encuentra ms arriba y ahora con una zona sombreada debajo, esto
indica que durante ese tiempo la seal se encuentra en un estado alto (1). La
seal de salida s se mantiene en 0, que es correcto debido a que solamente
cambiar de estado cuando ambas entradas sean 1. Ahora simule el tercer
caso de la tabla de verdad, cuando a vale 0 y b vale 1.

Figura 27 Resultado Simulacin Valor 3

Como se puede observar en la figura 27 la seal se mantiene en alto

durante el tiempo de la simulacin, pero la salida s se mantiene en 0. Por
ltimo simule el caso cuando ambas entradas valen 1.

pg. 51

Figura 28 Resultado Simulacin Valor 4

Observe en la figura 28 como finalmente la salida s ha cambiado a 1,

lo cual corresponde con la tabla de verdad de la operacin AND, de esta
forma se ha comprobado que el componente funciona correctamente.
Cabe mencionar que en cada paso, en la ventana de simulacin
apareci a la derecha un valor con letras amarillas que cambi de 1,000,000
ns a 2,000,000 ns en el primer tiempo de simulacin, y as hasta llegar a
5,000,000 ns. Esto indica que entre cada paso se avanz 1 us, que es el
tiempo que se configur en la barra de herramientas.
Para poder visualizar la simulacin completa se hace clic en el
botn Zoom to Full View; la simulacin completa se observa en la figura 29
donde se pueden ver los cuatro pasos de simulacin ejecutados, los cuales
corresponden a la tabla de verdad de la compuerta AND.

Figura 29 Resultado de Simulacin Completa

A continuacin, se agregarn un par de componentes ms: una

compuerta OR y otra XOR. Cierre ISim y vuelva a ISE Project Navigator.
Desde el men Project seleccie New Source, o tambin puede hacer
clic con el botn derecho sobre el nombre del proyecto o del dispositivo para
el cual est destinado, donde de igual manera aparece la opcin New
Source.
Agrege
un
mdulo
VHDL
y
como
nombre
de
archivo compuerta_or, enseguida haga clic en el botn Next.
La ventana Define module debe quedar como se muestra en la figura
30.

pg. 52

Figura 30 Define Module Compuerta_or

Haga clic en el botn Next y despus en Finish, con lo cual se

obtendr el nuevo mdulo compuerta_or en la ventana Hierarchy, en el
editor se mostrar el cdigo generado por Project Navigator.
El cdigo de la arquitectura deber ser el mostrado en el recuadro de
cdigo siguiente:
architecture Behavioral of compuerta_or is
begin
s <= a or b;
end Behavioral;
Cdigo 7 Arquitectura compuerta_or

El siguiente paso es revisar la sintaxis del mdulo creado, se debe

seleccionar la opcin Implementation en la ventana Design, despus
seleccionar el mdulo compuerta_or y en la ventana de procesos hacer
doble clic en Check Syntax, si hubo algn problema se indicar en la
consola ubicada en la parte inferior.

pg. 53

Figura 31 Chequeo de Sintaxis Compuerta_or

Como se puede observar en la figura 31 no se tiene ningn error de

sintaxis, por lo que ahora se prosigue a hacer la simulacin del mdulo.
En Project Navigator, seccin Design, pase View a Simulation,
enseguida se selecciona el componente compuerta_or y por ltimo en la
ventana Processes haga doble clic en Simulate Behavioral Model.
Nuevamente se abre ISim Simulator, y de manera similar a la
simulacin del mdulo compuerta_and, se evaluarn las cuatro
combinaciones posibles segn la tabla de verdad de la operacin OR para
dos entrada:
b

0
0
1
1

0
1
0
1

0
1
1
1

Tabla 7 Tabla de verdad compuerta OR

Haga clic con el botn derecho sobre la entrada a en la ventana de

simulacin, pero en esta ocasin no se utilizar el comando Force Constant,
sino el comando Force Clock, lo cual desplegar una ventana como la
mostrada en la figura 32.

pg. 54

Figura 32 Ventana Define Clock

El comando Force Clock permite indicar que una entrada tendr

valores alternados entre 0 y 1 durante la simulacin, es decir, como una
seal de reloj. En la ventana Define Clock se defininen algunas opciones
como el periodo, ciclo de trabajo y el valor del primer pulso, para el caso de
esta simulacin, se configura Leading Edge Value a 0 y Trailing Edge
Value a 1, mientras que Period ser de 100 ns, tal y como se muestra en la
figura 33.

Figura 33 Configuracin Define Clock

pg. 55

Haga clic en OK y configure de manera similar la entrada b, pero

variando el periodo a 200 ns
Hecho esto se ejecuta la simulacin por un tiempo determinado; por
defecto 1 us, se da clic en el botn Run for the time specified on the
toolbar y despus en el botn Zoom to Full View, el resultado es mostrado
en la siguiente figura.

Figura 34 Resultado Simulacin compuerta_or

En la figura 34 se observan algunos cambios de valor entre 0 y 1 de

las seales de entrada a y b, los suficientes para evaluar las cuatro
combinaciones diferentes de la tabla de verdad de la compuerta OR. Estas
transiciones se consiguen al usar la opcin Force Clock para las
seales a y b, adems, notese que al configurar el periodo de la seal b
como el doble con respecto al periodo de la seal a, las transiciones
corresponden de manera exacta con las de la tabla de verdad.
Por ltimo practique creando el mdulo de la compuerta XOR. Para
agregar el mdulo, siga los mismos pasos que con los mdulos anteriores.
Despus de haber creado el modulo, chequee la sintaxis, y prosiga a la
simulacin; para comprobar la simulacin obsrvese la tabla de verdad de la
compuerta XOR.
b

0
0
1
1

0
1
0
1

0
1
1
0

Tabla 8 Tabla de Verdad Compuerta XOR

Diseo Estructural en VHDL

Una de las caractersticas ms potentes del lenguaje VHDL, es la
posibilidad de utilizar los mdulos que se han desarrollado para construir
mdulos ms grandes, es decir, un mdulo VHDL puede convertirse
en componente de otro mdulo, de esta forma se reutilizan o aprovechan

pg. 56

mdulos ya diseados con anterioridad, o se puede dividir un diseo

complejo en varios diseos ms simples.
Utilizar mdulos VHDL para construir otros mdulos se
denomina diseo estructural, que difiere del diseo por comportamiento
que se ha utilizado en la creacin de las compuertas AND, OR y XOR.
Se aprovecharn dos de los componentes que se han creado hasta
este momento para crear un componente nuevo: Un Medio Sumador.
Como primer paso observe la tabla de verdad de un medio sumador el
cual cuenta con un par de entradas (A y B) y un par de salidas: suma (S) y
acarreo (C):
B

0
0
1
1

0
1
0
1

0
0
0
1

0
1
1
0

Tabla 9: Tabla de Verdad Medio Sumador

Expresado en ecuaciones booleanas:

C= AB
S= AB
Se utilzarn como componentes los mdulos compuerta_and y
compuerta_xor para crear un nuevo mdulo llamado medio_sumador. Por
lo tanto agrege un nuevo mdulo llamado medio_sumador, en el asistente
indique cuatro seales, dos entradas (A y B) y dos salidas (C y S) como se
muestra en la figura 35.
Se finaliza con el asistente y para obtener el cdigo creado
por Project Navigator.
Antes de utilizar un componente, es necesario declararlo, esta
declaracin se realiza en el cdigo de la arquitectura, entre la declaracin del
nombre de arquitectura y la instruccin begin, se incluye el nombre de la
entidad que se utilizar como componente, adems de la declaracin de sus
seales (mediante la instruccin port), la sintaxis es la mostrada en el
recuadro de Cdigo 8.

pg. 57

Figura 35 Modulo Medio Sumador

architecture NOMBRE_ARQUITECTURA of NOMBRE_ENTIDAD is

component NOMBRE_ENTIDAD_COMPONENTE
port(
NOMBRE_SEAL1: DIRECCIN TIPO;
NOMBRE_SEAL2: DIRECCIN TIPO
);
end component;
begin
end NOMBRE_ARQUITECTURA;
Cdigo 8 Sintaxis declaracin de componente.

La instruccin port dentro de la declaracin del componente es

prcticamente una copia de las seales que se declaran en el cdigo de
entidad del mdulo que se usa como componente. Por ejemplo, la
declaracin de componente del mdulo compuerta_and sera la siguiente:
component compuerta_and is
port(
a : in std_logic;
b : in std_logic;
s : out std_logic
);
end component;
Cdigo 9 Declaracin component compuerta_and

pg. 58

Con este ejemplo ya se pueden agregar las declaraciones de los

componentes
compuerta_and y compuerta_xor en
el
mdulo medio_sumador.
architecture behavioral of medio_sumador is
component compuerta_and is
port(
a : in std_logic;
b : in std_logic;
s : out std_logic
);
end component;
component compuerta_xor is
port(
a : in std_logic;
b : in std_logic;
s : out std_logic
);
end component;
begin
end behavioral;
Cdigo 10 Declaracin de componentes para medio_sumador

Ya se han declarado los componentes, ahora se debe hacer uso de

ellos, esto se hace mediante una instanciacin de componente, en la que
se indica el componente del cual se crea una instancia y las conexiones de
sus seales, esta es la sintaxis:
ETIQUETA: NOMBRE_COMPONENTE port map( CONEXION1, CONEXION2 );
Cdigo 11 Sintaxis Instanciacin de componentes

La etiqueta es obligatoria, permite identificar entre diferentes

instanciaciones del mismo componente. La etiqueta va seguida del nombre
del componente y despus se indican las conexiones de las seales del
componente, es decir, se indica con qu entradas, salidas o seales
auxiliares se conectarn las seales que forman parte de la interfaz del
componente. Para el caso del medio sumador, las entradas A y B se
conectarn con las entradas a y b de ambas compuertas, mientras que la
salida del mdulo compuerta_and se conectar con la seal de salida C y la
salida del mdulo compuerta_xor con la seal de salida S.

pg. 59

ACARREO: compuerta_and port map( A, B, C );

SUMA: compuerta_xor port map( A, B, S );
Cdigo 12 Instanciacin compuerta_and y compuerta_xor

De esta forma, el cdigo final del mdulo medio_sumador es el

siguiente:
library IEEE;
use IEEE.STD_LOGIC_1164.ALL;
entity medio_sumador is
port(
A : in STD_LOGIC;
B : in STD_LOGIC;
C : out STD_LOGIC;
S : out STD_LOGIC
);
end medio_sumador;
architecture behavioral of medio_sumador is
component compuerta_and is
port(
a : in std_logic;
b : in std_logic;
s : out std_logic
);
end component;
component compuerta_xor is
port(
a : in std_logic;
b : in std_logic;
s : out std_logic
);
end component;
begin
ACARREO: compuerta_and port map( A, B, C );
SUMA: compuerta_xor port map( A, B, S );
end behavioral;
Cdigo 13 Programa completo Medio_sumador

Al guardar el cdigo del mdulo medio_sumador, la jerarqua de

archivos del proyecto cambia.

pg. 60

Los mdulos compuerta_and y compuerta_xor aparecen anidados

dentro del mdulo medio_sumador, indicando que se estn utilizando como
componentes de este, adems, se muestran las etiquetas que se han
utilizado para instanciar los componentes.
Crrase la sintaxis para observar que este bien estructurado el mdulo
de medio_sumador.

Figura 36 Chequeo de Sintaxis medio_sumador

El resultado de la simulacin se muestra en la figura 37.

Figura 37 Simulacin medio_sumador

pg. 61

De manera similar a la creacin del medio_sumador, elabore un

sumador_completo para demostrar las ventajas del diseo estructural y
como teniendo los mdulos hechos se pueden realizar diseos de mayor
tamao muy fcilmente.
La construccin de un sumador_completo de un bit a partir de dos
medios sumadores y una compuerta OR se muestra en la figura 38.

Figura 38 Diagrama esquemtico sumador completo

Agregue un nuevo mdulo VHDL al proyecto, el cual se llamar

sumador_completo,
tendr
tres
entradas:
EntradaA, EntradaB y Cin (acarreo de entrada), y dos salidas: Suma
y Cout (Acarreo de salida).
Agregue la declaracin de los componentes que sern utilizados:
medio_sumador y compuerta_or, de manera que quede algo como lo
expuesto en el recuadro de cdigo 14.
architecture behavioral of sumador_completo is
component medio_sumador
port(
A : in STD_LOGIC;
B : in STD_LOGIC;
C : out STD_LOGIC;
S : out STD_LOGIC
);
end component;
component compuerta_or
port (
a : in std_logic;
b : in std_logic;
s : out std_logic

pg. 62

);
end component;
begin

end behavioral;
Cdigo 14 Declaracin medio_sumador y compuerta_or

Hecho esto toca realizar la instanciacin de los componentes e indicar

sus conexiones, no debe haber ningn problema para la conexin de las
seales del mdulo sumador_completo (EntradaA, EntradaB, Cin, Suma y
Cout), pero seguro habr duda sobre cmo realizar las conexiones entre los
componentes, por ejemplo, cmo indicamos que la salida S del primer
medio sumador debe conectarse a la entrada A del segundo? La respuesta
es: mediante seales auxiliares. Las seales auxiliares podran ser algo afn
a variables temporales en otros lenguajes de programacin (como las usadas
en los ciclos, o las usadas para permitir una mayor claridad de cdigo), en
VHDL permiten realizar la conexin entre seales de varios componentes. En
la siguiente figura se muestran en rojo las seales auxiliares de las que se
haran uso para realizar las interconexiones de los componentes del
mdulo sumador_completo.

Figura 39 Interconexin de seales auxiliares

De manera similar a los componentes, las seales deben ser

declaradas antes de poder utilizarse, y tambin como el caso de los
componentes, las seales auxiliares se declaran despus de la lnea que
indica el nombre de la arquitectura y antes de la instruccin begin. La
sintaxis para declarar una seal es la siguiente (cdigo 15):

pg. 63

signal NOMBRE_SEAL : tipo;

Cdigo 15 Sintaxis declaracin de seal auxiliar

El cdigo para agregar las seales s1, c1 y c2 al mdulo es el

mostrado en el recuadro de cdigo 16.
Signal s1 : std_logic;
signal c1, c2 : std_logic;
Cdigo 16 Seales auxiliaries para sumador_completo

Ntese que el tipo de las seales auxiliares debe coincidir con el tipo
de las seales de los componentes con los que se desea realizar la
conexin.
A continuacin se crean dos instancias del mdulo medio_sumador y
una del mdulo compuerta_or, y se utilizarn las seales s1, c1 y c2 para
interconectar dichas instancias.
MS0: medio_sumador port map( EntradaA, EntradaB, c1, s1 );
MS1: medio_sumador port map( s1, Cin, c2, Suma );
COR: compuerta_or port map( c1, c2, Cout );
Cdigo 17 Instanciacin sumador_completo

El cdigo completo del mdulo sumador_completo se muestra en el

recuadro de cdigo 18.
library IEEE;
use IEEE.STD_LOGIC_1164.ALL;
entity sumador_completo is
Port (
EntradaA : in STD_LOGIC;
EntradaB : in STD_LOGIC;
Cin : in STD_LOGIC;
Suma : out STD_LOGIC;
Cout : out STD_LOGIC
);
end sumador_completo;
architecture behavioral of sumador_completo is
component medio_sumador
port(
A : in STD_LOGIC;
B : in STD_LOGIC;
C : out STD_LOGIC;
S : out STD_LOGIC

pg. 64

);
end component;
component compuerta_or
port (
a : in std_logic;
b : in std_logic;
s : out std_logic
);
end component;
signal s1 : std_logic;
signal c1, c2 : std_logic;
begin
MS0: medio_sumador port map( EntradaA, EntradaB, c1, s1 );
MS1: medio_sumador port map( s1, Cin, c2, Suma );
COR: compuerta_or port map( c1, c2, Cout );
end behavioral;
Cdigo 18 Mdulo sumado_completo

En cuanto se guarda el cdigo, la jerarqua del proyecto se modifica

como antes ocurri con el mdulo medio_sumador.

Figura 40 Jerarqua sumador_completo

pg. 65

Ntese que todos los mdulos anteriores se han anidado dentro del
mdulo sumador_completo, adems de que hay dos apariciones del
mdulo medio_sumador, correspondiendo con las instancias que se han
creado del mismo. A continuacin se realiza una revisin de sintaxis, si no
hay problemas proceda con la simulacin. Para comprobar la simulacin
observe la tabla de verdad para el sumador completo de 1 bit:
Cin

EntradaB

EntradaA

Cout

Suma

0
0
0
0
1
1
1
1

0
0
1
1
0
0
1
1

0
1
0
1
0
1
0
1

0
0
0
1
0
1
1
1

0
1
1
0
1
0
0
1

Tabla 10 Tabla de Verdad sumador_completo

Para facilitar la simulacin, utilize la opcin Force Clock, colocando

una frecuencia de 100 ns para EntradaA, 200 ns para EntradaB y 400 ns
para Cin. El resultado se muestra en la figura 41.

Figura 41 Simulacin Sumador_completo

La figura 41 engloba todas las combinaciones de la tabla de verdad,

con lo que podemos observar que el mdulo funciona correctamente.
Adems, en la simulacin es posible ver los valores que toman las seales
auxiliares, de forma que sea ms fcil depurar y encontrar posibles errores
lgicos en el mdulo.
Configuracin de la Tarjeta Basys2
Despus de haber revisado que el cdigo sea el correcto y que los
mdulos funcionen como se desea mediante la simulacin, el siguiente paso

pg. 66

es indicar a qu pines del dispositivo lgico programable correspondern las

entradas y salidas del mdulo que se ha desarrollado.
Estas entradas y salidas deben ser asociadas con pines o puertos del
dispositivo en el que se desee implementar el diseo, de manera que se
pueda conectar el mdulo con el resto del circuito que se a diseando.
Para este diseo, se debern conectar las tres entradas con tres
interruptores (switches), mientras que las dos salidas sern conectadas a dos
leds de la tarjeta de desarrollo, la siguiente figura indicamos a qu elemento
de la tarjeta se conectar cada puerto del mdulo sumador_completo.

Cout
(M11)

Suma
(M5)

Cin
(K3)

EntradaA
(L3)

EntradaB
(P11)

Figura 42 Asignacin de switches y leds sumador_completo

Como se puede observar, debajo de cada seal a conectar se

encuentra entre parntesis una letra y un nmero, as es como se indican los
pines del encapsulado del dispositivo que se este configurando, en este caso
una Basys2. Una vez que se sabe a qu pin del FGPA se asociarn los
puertos del mdulo, se debe indicarlo en el proyecto, para ello en primera
instancia se hace uso de la aplicacin PlanAhead: se selecciona el

pg. 67

mdulo sumador_completo en la ventana Design, se debe asegurar de que

est
seleccionada
la
opcin Implementation,
despus,
en
la
ventana Processes, se expande la categora User Constraints, y se hace
doble clic en el proceso I/O Pin Plannig (Plan Ahead) Post-Synthesis.

Figura 43 I/O Pin Planning

Espere unos instantes y se abrir el programa PlanAhead,

probablemente antes de cargar PlanAhead se muestre un mensaje que
indica que se agregar un archivo de restricciones de usuario (UCF), a lo que
se indica que si (Yes).

pg. 68

Figura 44 Indicacin para agregar archivo UCF

Si todo ha salido correctamente se debe tener en pantalla la ventana

PlanAhead. En la parte superior se muestran dos pestaas en las cuales se
pueden ver los grficos que representan el dispositivo que se esta por
configurar: la pestaa de la izquierda despliega los pines del FPGA en un
arreglo matricial (Package), mientras que la de la derecha representa el
dispositivo en su totalidad (Device).
Debajo de esas imgenes, se encuentra una seccin con dos
pestaas: I/O Ports y Package Pins, si se selecciona I/O Ports y se
expanden las opciones All ports y Scalar ports se mostrarn los puertos
que forman parte del mdulo sumador_completo, haciendo clic en uno de
ellos se pueden arrastrar hacia la imagen que representa los puertos del
dispositivo donde deberemos soltarlo estando ubicados en el pin al que se
desea asociar el puerto o tambin se puede hacer mediante la columna site
en la cual solo se escribe la letra y el nmero del pin deseado. (Figura 45)

Figura 45 Ventana PlanAhead

pg. 69

Una vez que se han asociado todos los puertos del

mdulo sumador_completo con pines del FPGA. Haga clic en el botn para
guardar el diseo de Plan Ahead y cierre para continuar en ISE Project
Navigator. Ntese que un nuevo archivo se ha agregado al proyecto, el
nombre de este archivo corresponde con el mdulo que se va a enviar al
dispositivo reconfigurable y tendr como extensin .ucf.
Una
vez
realizado
lo
anterior,
se
selecciona
el
mdulo sumador_completo en la ventana Hierarchy, despus, en la
ventana Processes haga clic con el botn derecho en Generate
Programming File, se selecciona la opcin Process Properties lo cual
abrir un dilogo en el que se deber asegurar de 2 cosas: que en la
categora General Options (figura 46) est habilitada la opcin Create Bit
File, y que en la categora Startup Options (figura 47), la propiedad FPGA
Start-Up Clock est configurada a JTAG Clock.

Figura 46 General Options

Haga clic en el botn OK para cerrar el dilogo y enseguida doble clic

en el proceso Generate Programming File (Figura 48), iniciar la creacin
del archivo de configuracin .bit que se descargar al FPGA. Si el proceso
termina con xito, se habr creado el archivo sumador_completo.bit dentro
de la carpeta del proyecto.

pg. 70

Figura 47 Startup Options

Figura 48 Generate Programming File

Ahora se procede a enviar este archivo al FPGA, para ello se utilizar

el software Adept 2.6.1 System de Digilent. Conecte la tarjeta Basys2 a un
puerto USB disponible de una computadora, Windows reconocer que se ha
conectado un nuevo dispositivo y proceder a asociarlo con el controlador

pg. 71

adecuado. Abra el software Adept, y si la tarjeta se encuentra conectada

adecuadamente, se debe tener algo como lo que se muestra en la figura 49.

Figura 49 Software Adept 2.6.1 System

Una vez detectada la tarjeta toca configurar el FPGA: haga clic en el

botn Browse (Figura 50) a la derecha de donde aparece el dispositivo
FPGA, se abre un dilogo de Windows en el que se debe indicar el archivo
de configuracin sumador_completo.bit que se gener antes en Project
Navigator.
Por ltimo haga clic en el botn Program a la derecha del
botn Browse e inicie el proceso de carga del archivo de configuracin al
FPGA. Durante la programacin, un led de color rojo, que se encuentra a un
lado de los pines de alimentacin externa de la tarjeta se enciende, una vez
terminado el proceso se indica si ha sido exitoso en la ventana de mensajes
de Adept, si no ha habido problemas, el FPGA ha sido configurado y se
puede probar si funciona.
Con esto se termina la explicacin del desarrollo de un nuevo proyecto
y su descarga hacia la tarjeta Basys2.

pg. 72

Figura 50 Bsqueda de archivo .bit

Teniendo las bases del manejo de la tarjeta se procedi al desarrollo

de nuevas prcticas las cuales son expuestas en los resultados. El diseo de
las prcticas involucra adquisicin de datos y control de procesos.

pg. 73

RESULTADOS
Desarrollo de Prcticas utilizando la Tarjeta Basys2
Las prcticas expuestas a continuacin se desarrollaron con la Tarjeta
Basys2 basada en el Xilinx Spartan 3E, estas prcticas tienen como objetivo
demostrar la viabilidad del uso de la tarjeta Basys2 como arquitectura base
en el control de un proceso.
El diseo estructural con VHDL permite agregar mdulos y crear
prcticas cada vez ms complejas. El diseo estructural, la asignacin de
pines y la descarga hacia la tarjeta se explica de forma breve en este
documento y para no extender de ms las prcticas se omiten dentro del
desarrollo de las mismas.
Se recomienda tener bases del lenguaje VHDL y de electrnica digital
para comprender en su totalidad las practicas expuestas.

Practica 1 Decoder Display

En la siguiente prctica se disear un Decoder para el Display de 7
segmentos de la Tarjeta Basys2. Con los switches de la tarjeta se pretende
ingresar un nmero binario el cual ser desplegado en los leds y en el
display de 7 segmentos. El diagrama esquemtico se muestra en la figura
1.1

Figura 1.1 Esquemtico Decoder_Display

En base al diagrama esquemtico se declara la entidad la cual se

muestra en la figura 1.2. Notese el bus de datos utilizado en cada entrada y
salida.

pg. 74

Figura 1.2 Asignacin de Entidad

A continuacin se muestra el cdigo de la entidad creado por el ISE

Project Navigator:
library IEEE;
use IEEE.STD_LOGIC_1164.ALL;
-- Uncomment the following library declaration if using
-- arithmetic functions with Signed or Unsigned values
--use IEEE.NUMERIC_STD.ALL;
-- Uncomment the following library declaration if instantiating
-- any Xilinx primitives in this code.
--library UNISIM;
--use UNISIM.VComponents.all;
entity Display is
Port ( a : in

STD_LOGIC_VECTOR (3 downto 0);

Led : out STD_LOGIC_VECTOR (3 downto 0);
Sel_Disp: out STD_LOGIC_VECTOR (3 downto 0);
d : out STD_LOGIC_VECTOR (6 downto 0));
end Display;
Cdigo 1.1 - Entidad con sus respectivas seales

Enseguida agregue el cdigo mostrado en el recuadro de cdigo 1.2 a

la arquitectura para que el mdulo funcione correctamente.

pg. 75

architecture Behavioral of Display is

begin
-- Los Leds del Display se activan con 0
process (a) begin
case a is
when "0000" => d <= "0000001"; -- 0
when "0001" => d <= "1001111"; -- 1
when "0010" => d <= "0010010"; -- 2
when "0011" => d <= "0000110"; -- 3
when "0100" => d <= "1001100"; -- 4
when "0101" => d <= "0100100"; -- 5
when "0110" => d <= "0100000"; -- 6
when "0111" => d <= "0001111"; -- 7
when "1000" => d <= "0000000"; -- 8
when "1001" => d <= "0001100"; -- 9
when "1010" => d <= "0001000"; -- a
when "1011" => d <= "1100000"; -- b
when "1100" => d <= "1110010"; -- c
when "1101" => d <= "1000010"; -- d
when "1110" => d <= "0110000"; -- e
when "1111" => d <= "0111000"; -- f
when others => d <= "0000000";
end case;
end process;
Led <= a;
-- ANO = F12, AN1 = J12, AN2 = M13, AN3 = K14
-- El display seleccionado se enciende con valor en bajo 0
Sel_Disp <= "1010";
end Behavioral;
Cdigo 3.2 Arquitectura terminada

El cdigo inicia con el nombre de la arquitectura, en este caso se le

dejo el nombre que automticamente le da el programa (Behavioral),
despus de ello se inicia con un proceso con la entrada (a), y dentro del
proceso la condicin case donde se incluyen los valores que la salida (d)
puede tomar, dependiendo del valor que se le asigne a la entrada (a). Al
finalizar el proceso, se agrega una lnea (Led <= a;) en la cual solo se le
asigna el valor que tiene la entrada (a) a la salida (Led), esta ltima
corresponde a los 4 leds de la tarjeta.
Cabe mencionar que los leds de los displays se encienden con un
valor en bajo.
La ltima lnea antes de terminar la arquitectura (Sel_Disp <= "1010";)
es para la seleccin del display a utilizar.

pg. 76

Para finalizar se comprueba el correcto funcionamiento del modulo

Display_7seg a travs de la siguiente tabla se verdad:

a(entrada)
0000
0001
0010
0011
0100
0101
0110
0111
1000
1001
1010
1011
1100
1101
1110
1111

Leds
0000
0001
0010
0011
0100
0101
0110
0111
1000
1001
1010
1011
1100
1101
1110
1111

Display
0
1
2
3
4
5
6
7
8
9
a
b
c
d
e
f

Tabla 1.1 Tabla de verdad Display_7seg

Compile y Pruebe el funcionamiento del Programa con la Tarjeta

Basys2.

Practica 2 - Contador Ascendente

En esta prctica se disear un contador ascendente. Para que un
contador funcione se necesita un generador de pulsos (reloj), y en este caso
ser utilizado el reloj de la tarjeta Basys2, recuerde que el reloj de la tarjeta
es de 50 Mhz lo que significa un problema ya que el ojo humano es incapaz
de ver pulsos a esa velocidad, es por ello que dentro del proyecto ser
necesario hacer un reloj ms lento que el de la tarjeta; a continuacin se
describe paso a paso el desarrollo del proyecto.
Se inicia creando un nuevo proyecto, con el nombre de
contador_ascendente y la entidad contadorAD que cuenta con las
entradas clk y reset y la salida Q de 4 bits.
El cdigo de la entidad se muestra en el recuadro de cdigo 2.1

pg. 77

library IEEE;
use IEEE.STD_LOGIC_1164.ALL;
use ieee.std_logic_unsigned.all;
entity contadorAD is
Port ( clk : in STD_LOGIC;
reset:in std_logic;
Q : out STD_LOGIC_VECTOR (3 downto 0));
end contadorAD;
Cdigo 2.1 - Entidad contadorAD

Se declara una seal auxiliar auxiliar en la arquitectura:

signal aux : std_logic_vector( 3 downto 0 );
Esta seal aux sustituye a la seal Q dentro de la arquitectura debido
a que la seal Q es una salida (out), y no se puede leer una salida.
Se utilizarn otras dos seales auxiliares para el diseo del reloj a baja
frecuencia.
signal divisor : std_logic_vector( 24 downto 0 );
signal reloj_lento : std_logic;
Cdigo 2.2 - Declaracin de seales auxiliares

La primera seal como se puede observar en el recuadro de cdigo

2.2 es un vector de 24 bits que permite dividir la frecuencia de 50MHZ del
reloj de la tarjeta Basys2; la segunda seal ser el reloj a baja frecuencia que
se utilizar para el contador.
Despus de haber declarado las seales auxiliares, se iniciar un
proceso con las seales de reloj_lento y reset, este proceso ser el que
realizar el conteo ascendente, el cdigo del proceso se muestra a
continuacin:

pg. 78

begin
-- Proceso que lleva la cuenta de 4 bits
process( reloj_lento, reset )
begin
if reset = '1' then
aux <= "0000";
elsif reloj_lento'event and reloj_lento = '1' then
aux <= aux + 1;
end if;
end process;
Q <= aux;
Cdigo 2.3 - Proceso contador ascendente

Como se observa en el cdigo 2.3 se inicia con un begin despus de

haber declarado las seales auxiliares, este begin indica el inicio de la
arquitectura; despus de eso sigue la declaracin de un proceso con las
seales: reloj_lento y reset, a continuacin se encuentra un nuevo begin el
cual indica el inicio del proceso, enseguida se tiene una sentencia if para el
reset, con la cual cada que reset tome el valor de 1 la seal aux toma el
valor de 0000, despus continua con la sentencia elsif, en la cual se indica
que cada vez que reloj_lento tenga un flanco de subida la seal aux se
incrementar en 1.
Enseguida se le asigna el valor de la seal aux a la seal Q la cual es
la salida que se mostrar en los leds.
Ahora lo nico que falta es el proceso para el reloj_lento, el cual es
mostrado continuacin:
-- Contador auxiliar que corre con el cristal de la tarjeta (50 MHz)
-- permite reducir la frecuencia
process( clk, reset )
begin
if ( reset = '1' ) then
divisor <= ( others => '0' );
elsif clk'event and clk = '1' then
divisor <= divisor + 1;
end if;
end process;
-- Tomamos el bit ms significativo del contador auxiliar para
-- dividir la frecuencia de operacin
reloj_lento <= divisor( 24 );
Cdigo 2.4 - Proceso para crear un reloj lento

pg. 79

Para el reloj lento se dise un contador ascendente, solo que esta

vez se utiliz el reloj de la tarjeta y se increment en 1 el valor de la seal
divisor en cada flanco de subida de clk, por lo tanto contar hasta llegar al
valor mximo el cual es 2^ 24, debido a que la seal es de 24 bits. Teniendo
este contador solo basta con asignar el bit ms significativo de la seal
divisor a la seal reloj_lento, esto se observa en la ltima lnea del cdigo
anterior (reloj_lento <= divisor( 24 );). El cdigo completo se muestra en el
recuadro de cdigo 2.5.
library IEEE;
use IEEE.STD_LOGIC_1164.ALL;
use ieee.std_logic_unsigned.all;
entity contadorAD is
Port ( clk : in STD_LOGIC;
reset:in std_logic;
Q : out STD_LOGIC_VECTOR (3 downto 0));
end contadorAD;
architecture Behavioral of contadorAD is
signal aux : std_logic_vector( 3 downto 0 );
signal divisor : std_logic_vector( 24 downto 0 );
signal reloj_lento : std_logic;
begin
-- Proceso que lleva la cuenta de 4 bits
process( reloj_lento, reset )
begin
if reset = '1' then
aux <= "0000";
elsif reloj_lento'event and reloj_lento = '1' then
aux <= aux + 1;
end if;
end process;
Q <= aux;
-- Contador auxiliar que corre con el cristal de la tarjeta (50 MHz)
-- permite reducir la frecuencia
process( clk, reset )
begin
if ( reset = '1' ) then
divisor <= ( others => '0' );
elsif clk'event and clk = '1' then
divisor <= divisor + 1;
end if;
end process;
-- Tomamos el bit ms significativo del contador auxiliar para
-- dividir la frecuencia de operacion
reloj_lento <= divisor( 24 );

pg. 80

end Behavioral;
Cdigo 2.5 - Mdulo contadorAD

Finalmente se hace un chequeo de sintaxis, si no hay algn error, se

asignan lo pines, se crea el archivo .bit y se descarga a la tarjeta Basys2 por
medio del software Adept para probar el programa.
Cabe mencionar que la velocidad del reloj_lento depende del nmero
de bits que se le asignen a la seal auxiliar divisor.

Practica 3 - Contador con salida a Display

A continuacin se disear un contador ascendente como el de la
Practica 2 y se desplegar el resultado de la cuenta en los Displays de 7
segmentos de la tarjeta Basys2.
Se crea un nuevo proyecto y un mdulo VHDL con el nombre
cont_display.
entity cont_display is
Port ( clk : in STD_LOGIC;
reset:in std_logic;
sal : out STD_LOGIC_VECTOR (6 downto 0));
end cont_display;
Cdigo 3.1 Entidad cont_display

Como se puede observar en el recuadro de cdigo 3.1 la entidad es

similar a la de la prctica 2 con la diferencia que la salida es de 7 bits, esto
es debido a que se enviar el resultado de la cuenta a los displays.
Enseguida se muestra el cdigo correspondiente a la arquitectura el
cual cuenta con un reloj a baja frecuencia y un proceso que despliega el
resultado en el display.
architecture Behavioral of cont_display is
signal divisor : std_logic_vector( 24 downto 0 );
signal reloj_lento : std_logic;
signal cuenta:integer;
begin
process (reloj_lento,reset)
begin

pg. 81

if (reset='1') then
cuenta<=0;
elsif (reloj_lento'event and reloj_lento = '1') then
cuenta<= cuenta + 1
end if;
end process;

-- Contador auxiliar que corre con el cristal de la tarjeta (50 MHz)

-- permite reducir la frecuencia
process( clk,reset )
begin
if ( reset = '1' ) then
divisor <= ( others => '0' );
elsif clk'event and clk = '1' then
divisor <= divisor + 1;
end if;
end process;
-- Tomamos el bit ms significativo del contador auxiliar para
-- dividir la frecuencia de operacion
reloj_lento <= divisor( 24 );
--asiganamos las salidas al display de 7 segmentos
sal<= "0000001" when cuenta=0 else
"1001111" when cuenta=1 else
"0010010" when cuenta=2 else
"0000110" when cuenta=3 else
"1001100" when cuenta=4 else
"0100100" when cuenta=5 else
"0100000" when cuenta=6 else
"0001111" when cuenta=7 else
"0000000" when cuenta=8 else
"0001100" when cuenta=9 else
"0001000" when cuenta=10 else
"1100000" when cuenta=11 else
"0110001" when cuenta=12 else
"1000010" when cuenta=13 else
"0110000" when cuenta=14 else
"0111000";
end Behavioral;
Cdigo 3.2 - Arquitectura cont_display

Como se observa en el recuadro de cdigo 3.2 se utiliza una condicin

when para hacer la traduccin entre el valor de cuenta y el valor asignado a
la salida sal que despliega el resultado en el display.
Para probar el programa cont_display se asignan los pines a la
Tarjeta Basys2 con PlanAhead, compile y baje el programa al FPGA para
verificar su funcionamiento.

pg. 82

Practica 4 - Encendido de un motor de CD

Materiales:
-

1 Optoacoplador 2N25
1 Transistor NPN 2N2222
1 Protoboard
1 Resistor 330
1 Resistor 10K
1 Relevador de 5V
Alambre telefnico
1 Motor de CD @ 5V

La tarjeta Basys2 cuenta con 4 mdulos de expansin PMOD con 4

entradas/salidas cada uno. Utilizando una de estas salidas se encender un
motor de CD de 5V por medio de uno de los switches de la tarjeta.
Se crea un nuevo proyecto y mdulo VHDL llamado encender_motor.
La entidad es mostrada en el recuadro de cdigo 4.1
entity encender_motor is
Port ( start_stop : in STD_LOGIC;
motor : out STD_LOGIC);
end encender_motor;
Cdigo 4.1 - Entidad encender_motor

El funcionamiento de la arquitectura es simple y es idntico al de un

interruptor, solo se debe enviar el valor de la entrada start_stop a la salida
motor.

architecture Behavioral of encender_motor is

begin
motor <= start_stop;
end Behavioral;
Cdigo 4.2 Arquitectura encender_motor

Como se puede observar el mdulo es bastante sencillo. Compile y

descargue el programa hacia la tarjeta Basys2 para comprobar el
funcionamiento.
pg. 83

Una vez teniendo el programa se debe hacer un acondicionamiento de

la seal de salida de la tarjeta Basys2 para que esta pueda encender el
motor. La principal dificultad radica en el hecho de que la tarjeta tiene una
salida de 3.3 V y se necesitan 5V para que el motor funcione.
Cabe mencionar que los motores de CD consumen bastante corriente
elctrica y si se le exigue corriente de ms a la Tarjeta Basys2 se puede
daarla por siempre. Es por ello que se utiliza un opto-acoplador 2N25 el
cual es un dispositivo que asla a la tarjeta del circuito de potencia del motor.
Adems se necesita un Transistor 2N2222 en su configuracin de
amplificador para activar un relevador el cual funcionar como un interruptor
para encender o detener el motor segn la accin de control enviada desde
el switch de la tarjeta Basys2. Por medio de una fuente externa de 5V se
obtiene la potencia elctrica necesaria para que el motor y el circuito externo
funcionen sin problemas.
El diagrama elctrico del acondicionamiento de seal es mostrado en
la figura 4.1
Se arma el circuito externo en un protoboard y para probar su
funcionamiento.
Nota importante: Las tierras GND de la tarjeta Basys y del circuito
externo de acondicionamiento de seal deben estar acopladas.

Figura 4.1 Acondicionamiento de Seal

pg. 84

Prctica 5 - Motor Reversible

Materiales:
-

3 Opto-Acoplador 2N25
1 Protoboard
3 Resistor 330
3 Resistor 1K
1 Puente H SN754410
Alambre telefnico
1 Motor de CD @ 5V

Teniendo la experiencia de la prctica 4 para hacer el

acondicionamiento de seal necesario para utilizar las salidas de la Tarjeta
Basys2, se pretende en esta prctica que el Motor de CD encienda y cambie
su sentido de rotacin al enviar la accin de control desde los switches de la
tarjeta.
Se inicia la prctica creando un nuevo proyecto y mdulo VHDL
llamado puente_h. La entidad se muestra en el recuadro de cdigo 5.1
entity puente_h is
Port ( start : in STD_LOGIC;
sentido : in STD_LOGIC;
s1 : out STD_LOGIC;
led_start: out std_logic;
led_sent: out std_logic;
s2 : out STD_LOGIC;
enable: out std_logic);
end puente_h;
Cdigo 5.1 - Entidad puente_h

Como se puede apreciar en el cdigo 5.1 se cuenta con una entrada

start, para encender o apagar el motor, una entrada sentido, para cambiar
el sentido de rotacin del motor, dos salidas s1 y s2, las cuales enviarn un
pulso dependiendo del valor de la entrada sentido y otras dos salidas
led_start y led_sent para indicar que el motor est en marcha y para indicar
el sentido de rotacin respectivamente, estos dos leds sern de la tarjeta.

pg. 85

Figura 5.1 Configuracin y conexin CI SN754410

Para poder controlar el sentido de rotacin del motor se necesita un

puente H, en este caso como es un motor pequeo de 5 volts, se utilizar el
integrado SN754410. Este Circuito integrado es capaz de controlar el sentido
de rotacin de 2 motores de CD, a la vez. El diagrama del circuito integrado
se muestra en la figura 5.1, adems de los pines en los cuales debe ser
conectado el motor:
Como se puede observar en la figura 5.1 el integrado tiene dos pines
de alimentacin debido a que puede controlar 2 motores, dos pines de
enable, cuatro entradas (1A, 2A, 3A y 4A) y cuatro salidas (1Y, 2Y, 3Y y 4Y),
en esta prctica se utilizarn 2 entradas y dos salidas (vase la conexin del
motor izquierdo figura 5.1).
Para disear el cdigo de la arquitectura se debe saber que para que
sean activadas las salidas 1Y y 2Y, necesitamos un pulso de enable en el
pin 1, y a su vez para ser activadas estas salidas, necesitan un pulso en 1A
para activar 1Y, y un pulso en 2A para activar 2Y.
El cdigo de la arquitectura del modulo puente_h se muestra en el
recuadro de cdigo 5.2
architecture Behavioral of puente_h is
begin
enable<= not start;
led_start<= start;

pg. 86

process (sentido)
begin
if sentido='0' then
--SENTIDO DEL MOTOR HACIA LA IZQUIERDA
s1<= '1';
s2<='0';
led_sent <= '0';
else
--SENTIDO DEL MOTOR HACIA LA DERECHA
s1<='0';
s2<='1';
led_sent <= '1';
end if;
end process;
end Behavioral;
Cdigo 5.2 - Arquitectura puente_h

Como se puede observar en la arquitectura el sentido de rotacin del

motor se controla a travs de la sentencia if que manda un pulso en alto o
bajo a las salidas s1 y s2 las cuales se conectarn al puente H en las
entradas 1A y 2A. El enable controla el encendido y apagado del motor
habilitando el chip.
Como se utilizan 3 salidas que son conectadas a un circuito externo,
son necesarios 3 opto-acopladores. El acondicionamiento de seal propuesto
se muestra en la figura 5.2.
Finalmente cheque la sintaxis, asigne pines, arme en el protoboard el
circuito externo y descargue el programa hacia la tarjeta Basys2 para
comprobar el funcionamiento.
En el siguiente enlace se muestra un video del programa funcionando
sobre la tarjeta Basys2: http://youtu.be/gWH4DcUR6oQ

pg. 87

Figura 5.2 Acondicionamiento de seal

Practica 6 Sumador Aritmtico con Salida a Display

A continuacin se disear un Sumador de 3 bits con carry de
entrada; la salida del sumador ser desplegada en los Leds de la Tarjeta
Basys2 en cdigo binario y a su vez en los Displays de 7 Segmentos.
Para comprender mejor el diseo del programa observe el diagrama a
bloques de la figura 6.1; como se puede observar este es un diseo de tipo
estructural donde se mapea el programa de Encidende7Segmentos hacia
el Top Module (Programa Maestro) Sumador_Arith.

pg. 88

Figura 6.1 Diagrama a Bloques Sumador Aritmtico

La entidad del Sumador Aritmtico se muestra en el cdigo 6.1; cabe

mencionar que dentro de la entidad se agregan las salidas de nodos y
segmentos para realizar posteriormente el mapeo por software.
library IEEE;
use IEEE.STD_LOGIC_1164.ALL;
use IEEE.STD_LOGIC_UNSIGNED.ALL;
entity Sumador_Arith is
Port ( a : in STD_LOGIC_VECTOR (2 downto 0); -- dato "a" de 3
bits
b : in

STD_LOGIC_VECTOR (2 downto 0); -- dato "b" de 3

bits
cin : in STD_LOGIC;
reloj_tarjeta : in STD_LOGIC;
reset : in STD_LOGIC;

-- Carry in de 1 bit

segmentos : out std_logic_vector( 6 downto 0 );

-- encender display
anodos : out
std_logic_vector( 3 downto 0 );
-- multiplexar display
suma : inout STD_LOGIC_VECTOR (5 downto 0));
-- Salida
de a + b + cin
end Sumador_Arith;
Cdigo 6.1 Entidad Sumador Aritmtico

Como
se
observa
se
agreg
la
librera
IEEE.STD_LOGIC_UNSIGNED.ALL para poder realizar operaciones con
operadores aritmticos (+, - , *, /) esta es una gran ventaja ya que ahorra
cdigo
y
facilita
la
programacin.
(La
librera

pg. 89

IEEE.STD_LOGIC_UNISGNED.ALL ya no es soportada por la IEEE por lo

que se utiliza en su lugar la IEEE.NUMERIC_STD.ALL; en esta prctica se
utiliza la librera IEEE.STD_LOGIC_UNISGNED.ALL por la sencillez en el
manejo de los operadores aritmticos sin necesidad de castear el tipo de
variable.
En
practicas
posteriores
se
analizar
la
librera
IEEE.NUMERIC_STD.ALL y como castear correctamente).
Para agregar un mdulo previamente hecho y mapearlo al diseo se
necesita Inicializar el componente antes del inicio de la arquitectura (cdigo
6.2) y despus mapearlo dentro de la arquitectura (cdigo 6.3). En esta
prctica se utiliza el cdigo Enciende7Segmentos.vhd mostrado en el
recuadro de cdigo 6.4:

COMPONENT Enciende7Segmentos
PORT(
valor0 : IN std_logic_vector(3 downto 0);
valor1 : IN std_logic_vector(3 downto 0);
valor2 : IN std_logic_vector(3 downto 0);
valor3 : IN std_logic_vector(3 downto 0);
reloj_50MHz : IN std_logic;
reset : IN std_logic;
segmentos : OUT std_logic_vector(6 downto 0);
anodos : OUT std_logic_vector(3 downto 0)
);
END COMPONENT;
Cdigo 6.2 Inicializacin del Componente

ETI: Enciende7Segmentos PORT MAP(

valor0 =>numerobcd (3 downto 0) ,
valor1 => numerobcd (7 downto 4),
valor2 => numerobcd(11 downto 8),
valor3 => numerobcd(15 downto 12),
segmentos =>segmentos ,
reloj_50MHz => reloj_tarjeta,
reset => reset,
anodos => anodos
);
Cdigo 6.3 Mapeo del Componente

entity Enciende7Segmentos is
Port (
valor0 : in STD_LOGIC_VECTOR (3 downto 0);
valor1 : in STD_LOGIC_VECTOR (3 downto 0);
valor2 : in STD_LOGIC_VECTOR (3 downto 0);
valor3 : in STD_LOGIC_VECTOR (3 downto 0);
segmentos : out STD_LOGIC_VECTOR (6 downto 0);
reloj_50MHz : in std_logic;
reset : in std_logic;

pg. 90

anodos : out std_logic_vector( 3 downto 0 )

);
end Enciende7Segmentos;
architecture Behavioral of Enciende7Segmentos is
signal activo : std_logic_vector( 1 downto 0 );
signal divisor : std_logic_vector( 15 downto 0 );
signal reloj_1KHz : std_logic;
signal valor_aux : std_logic_vector( 3 downto 0 );
begin
-- Proceso que genera una seal de 1 KHz a partir del cristal
-- de 50 MHz de la tarjeta de desarrollo.
process(reloj_50MHz,reset)
begin
if reset = '1' then
divisor <= (others => '0');
reloj_1KHz <= '0';
elsif reloj_50MHz'event and reloj_50MHz = '1' then
divisor <= divisor + 1;
if ( divisor = 25000 ) then
reloj_1KHz <= not reloj_1KHz;
divisor <= ( others => '0' );
end if;
end if;
end process;
-- Proceso que multiplexa los displays
process( reloj_1KHz, reset)
begin
if reset = '1' then
activo <= "00";
anodos <= "1111";
elsif rising_edge(reloj_1KHz) then
activo <= activo + 1;
case activo is
when "00"

=>

anodos

<=

"1110";

valor_aux

<=

when

"01"

=>

anodos

<=

"1101";

valor_aux

<=

when

"10"

=>

anodos

<=

"1011";

valor_aux

<=

valor0;
valor1;
valor2;
when others => anodos <= "0111"; valor_aux <=
valor3;
end case;

pg. 91

end if;
end process;

-a
----- f| g | b
----- e|
| c
----d
-- Activa los segmentos adecuados
-- Por hacer: manejar el punto decimal y ampliar a ms caracteres.
with valor_aux select
segmentos <=
-- abcdefg
"1001111"
"0010010"
"0000110"
"1001100"
"0100100"
"0100000"
"0001111"
"0000000"
"0000100"
"0001000"
"1100000"
"0110001"
"1000010"
"0110000"
"0111000"
"0000001"

when
when
when
when
when
when
when
when
when
when
when
when
when
when
when
when

"0001",
"0010",
"0011",
"0100",
"0101",
"0110",
"0111",
"1000",
"1001",
"1010",
"1011",
"1100",
"1101",
"1110",
"1111",
others;

--1
--2
--3
--4
--5
--6
--7
--8
--9
--A
--b
--C
--d
--E
--F
--0

end Behavioral;
Cdigo 6.4 Programa Enciende7Segmentos

Como se puede observar el Programa Enciende7Segmentos se

encarga del multiplexado de los displays para ello genera un reloj que
proporciona una seal de 1khz a partir de la seal de reloj de la tarjeta
Basys2 de 50Mhz, con esto inicia un proceso que lleva una cuenta a
velocidad de 1khz la cual se guarda en la seal activo de 2 bits cuyo
resultado multiplexea los displays de manera automtica con una tasa de
refresco de 1khz/4_displays = 250Hz (T=4ms).

pg. 92

Figura 6.2 Diagrama esquemtico de los displays de 7 Segmentos de la Tarjeta Basys2

Como se puede observar en el cdigo 6.2 para inicializar un

componente se utiliza la entidad del cdigo VHDL previamente diseado. La
forma general de inicializar cualquier componente se muestra en el cdigo
6.5.

COMPONENT Nombre_del_programa
GENERIC( Variables_genericas: natural;
N : integer
);
PORT(
Entradas : IN std_logic;
Bus_Entradas : IN std_logic_vector(N downto 0);
Salidas : OUT std_logic;
Bus_Salidas : OUT std_logic_vector(N downto 0);
);
END COMPONENT;
Cdigo 6.5 Inicializacin de componentes (Forma General)

La forma general de mapear un componente hacia otro programa se

muestra en el cdigo 6.6
Nombre_del mapeo: Nombre_del_programa
GENERIC MAP (
Variables_genericas => ,
N => )
PORT MAP(
Entradas => ,
Bus_Entradas => , -- Despus del => se ingresa el
puerto,
Salidas => ,
-- seal, constante o variable a
mapear

pg. 93

Bus_Salidas => ,
);
Cdigo 6.6 Mapeo de componentes (Forma General)

A continuacin se muestra el cdigo de la arquitectura del sumador

aritmtico (Cdigo 6.7) en donde se observa la inicializacin del componente
Enciende7Segmentos y el Mapeo del mismo llamado ETI
architecture Behavioral of Sumador_Arith is
-- Declaracin de Seales Auxiliares
signal A_aux, B_aux : STD_LOGIC_VECTOR (5 downto 0); -- Largo del
vector de 6 bits para porder hacer la suma
signal Suma_aux: STD_LOGIC_VECTOR ( 15 downto 0 ); -- Seal auxiliar
para hacer el resize
signal numerobcd : std_logic_vector( 15 downto 0 ); -- 16 bits para
encender los 4 displays

-- Llamada al archivo componente "Enciende7Segmentos"

component Enciende7Segmentos
Port (
valor0 : in STD_LOGIC_VECTOR (3 downto 0);
valor1 : in STD_LOGIC_VECTOR (3 downto 0);
valor2 : in STD_LOGIC_VECTOR (3 downto 0);
valor3 : in STD_LOGIC_VECTOR (3 downto 0);
segmentos : out STD_LOGIC_VECTOR (6 downto 0);
reloj_50MHz : in std_logic;
reset : in std_logic;
anodos : out std_logic_vector( 3 downto 0 )
);
end component;
-- Funcin que recibe un valor binario de 16 bits y devuelve su
representacin
-- BCD de cuatro dgitos (16 bits).
-- Usa el algoritmo de corrimiento y suma 3.
function bin_a_bcd( bin : std_logic_vector(15 downto 0))
return std_logic_vector is
variable i : integer := 0;
variable resultado : std_logic_vector( 15 downto 0 ) :=
"0000000000000000";
variable copiabin : std_logic_vector( 15 downto 0 ) :=
bin;
begin
-- Aqu va el cdigo de la funcin
for i in 0 to 15 loop
resultado( 15 downto 1 ) := resultado( 14 downto
0 );
resultado( 0 ) := copiabin( 15 );
copiabin( 15 downto 1 ) := copiabin( 14 downto 0

pg. 94

);
copiabin( 0 ) := '0';
-- unidades
if i < 15 and resultado( 3 downto 0 ) > "0100"
then
resultado( 3 downto 0 ) := resultado( 3
downto 0 ) + "0011";
end if;
-- decenas
if i < 15 and resultado( 7 downto 4 ) > "0100"
then
resultado( 7 downto 4 ) := resultado( 7
downto 4 ) + "0011";
end if;
-- centenas
if i < 15 and resultado( 11 downto 8 ) > "0100"
then
resultado( 11 downto 8 ) := resultado( 11
downto 8 ) + "0011";
end if;
-- millares
if i < 15 and resultado (15 downto 12) > "0100"
then
resultado ( 15 downto 12 ) := resultado ( 15
downto 12 ) + "0011";
end if;
end loop;
return resultado;
end bin_a_bcd;
-- Inicio de la Arquitectura
begin
-- Utilizacin de los 3 LSB de "a" y "b" para hacer una Suma con
vectores de 6 bits
A_aux (2 downto 0) <= a;
B_aux (2 downto 0) <= b;
--process (A_aux, B_aux, cin, reloj_tarjeta)
--begin
--if reloj_tarjeta'event and reloj_tarjeta = '1' then
suma <= A_aux + B_aux + cin;
--end if;
--end process;
suma_aux (5 downto 0) <= suma;
numerobcd <= bin_a_bcd(Suma_aux);

pg. 95

-- Mapeo del controlador de displays

ETI: Enciende7Segmentos port map(
valor0 =>numerobcd (3 downto 0) , -valor1 => numerobcd (7 downto 4), -valor2 => numerobcd(11 downto 8), -valor3 => numerobcd(15 downto 12),-segmentos =>segmentos ,
reloj_50MHz => reloj_tarjeta,
reset => reset,
anodos => anodos
);

unidades
decenas
centenas
millares

end Behavioral;
Cdigo 6.7 Arquitectura Sumador_Arith

Dentro del cdigo de la arquitectura se puede observar la funcin

bin_a_bcd la cual recibe un valor binario de 16 bits y devuelve su
representacin BCD de cuatro dgitos (16 bits) usando un algoritmo de
corrimiento y sumando 011.
Recordemos que las seales auxiliares, la inicializacin de los
componentes y las funciones (function nombre_de_la_funcin) se declaran
antes del inicio (begin) de la arquitectura.
El Sumador Aritmtico se resume en suma <= A_aux + B_aux +
cin; donde se suma el dato A, el dato b y el Cin de manera mas simple.
La salida suma es enviada a una seal auxiliar suma_aux de 16 bits
asignndole a los 6 bits menos significativos de suma_aux los 6 bits de suma
(suma_aux (5 downto 0) <= suma); esto debido a que la funcin bin_a_bcd
requiere un ancho de bus de 16 bits. El resultado de la funcin bin_a_bcd es
asignado a la seal numerobcd de 16 bit, quedando de la siguiente manera
el casteo de la funcin (numerobcd <= bin_a_bcd(Suma_aux);)
Al final se mapean las seales al componente Enciende7Segmentos
utilizando los 4 bits del bus de 16 bit de la seal numerobcd necesarios de
cada display para representar las unidades, decenas, centenas y millares.
Este cdigo ser de bastante utilidad para prcticas posteriores donde se
necesite mostrar en valor BCD nmeros binarios.

pg. 96

Practica 7 Unidad Aritmtica Lgica (ALU)

Una Unidad Aritmtica Lgica es un circuito digital que calcula
operaciones aritmticas (como suma, resta, multiplicacin, etc.) y
operaciones lgicas (and, or, not, sll, slr, etc), entre dos nmeros.
A continuacin se disear una ALU con 2 entradas de 3 bits y 2
lneas de seleccin que permitirn elegir entre las siguientes opciones (Tabla
7.1).
Sel
Suma (a+b)
Multiplicacin (a-b)
Corrimiento a la Izq de a
Corrimiento a la Der de a

0
0
1
1

0
1
0
1

Tabla 7.1 Operaciones de la ALU

Se utilizar la funcin bin_a_bcd de la prctica anterior para mandar el

resultado de la operacin hacia los displays de 7 segmentos y se utilizar el
diseo estructural para mapear el programa de Salida y multiplexeo de
displays (Disp_hex_mux.vhd) el cual es una versin mejorada del programa
Enciende7Segmentos.vhd que incluye punto decimal (DP).
Esta vez se utilizar la librera IEEE.NUMERIC_STD.ALL y se
explicar como hacer conversin entre los tipos de datos y los casteos de
salida.
El diagrama a bloques de la ALU se muestra en la figura 7.1

Figura 7.1 Diagrama Esquemtico de la ALU

pg. 97

El cdigo del programa disp_hex_mux.vhd que ser mapeado hacia el

top module ALU es mostrado en el recuadro de cdigo 7.1
entity disp_hex_mux is
port(
clk, reset: in std_logic;
hex3, hex2, hex1, hex0: in std_logic_vector (3 downto
0);
dp_in: in std_logic_vector (3 downto 0);
an: out std_logic_vector (3 downto 0);
sseg: out std_logic_vector (7 downto 0)
);
end disp_hex_mux;
architecture Behavioral of disp_hex_mux is
constant N : integer :=18;
signal q_reg , q_next : unsigned (N-1 downto 0) ;
signal sel: std_logic_vector (1 downto 0 ) ;
signal hex: std_logic_vector (3 downto 0 );
signal dp: std_logic;
begin
-- register
process (clk, reset)
begin
if reset = '1' then
q_reg <= ( others => '0' ) ;
elsif (clk'event and clk='1') then
q_reg <= q_next;
end if;
end process;
-- next-state logic for the counter
q_next <= q_reg + 1;
-- 2 MSBs of counter to control 4-to-1 multiplexing
-- and to generate active-low enable signal
sel <= std_logic_vector (q_reg(N-1 downto N-2));
process (sel, hex0, hex1, hex2, hex3, dp_in)
begin
case sel is
when "00" =>
an <= "1110";
hex <= hex0;
dp <= dp_in(0);
when "01" =>
an <= "1101";
hex <= hex1;

pg. 98

dp <= dp_in(1);
when "10" =>
an <= "1011";
hex <= hex2;
dp <= dp_in(2);
when others =>
an <= "0111";
hex <= hex3;
dp <= dp_in(3);
end case;
end process;
-- hex-to-7- segment led decoding
with hex select
sseg (6 downto 0) <=
"0000001" when
"1001111" when
"0010010" when
"0000110" when
"1001100" when
"0100100" when
"0100000" when
"0001111" when
"0000000" when
"0001100" when
"0001000" when
"1100000" when
"1110010" when
"1000010" when
"0011000" when
"0111000" when

"0000",
"0001",
"0010",
"0011",
"0100",
"0101",
"0110",
"0111",
"1000",
"1001",
"1010",
"1011",
"1100",
"1101",
"1110",
others;

--a
--b
--c
--d
--P
--f

--decimal point
sseg(7) <= dp;
end Behavioral;
Cdigo 7.1 disp_hex_mux (Salida a Displays y Multiplexeo)

El cdigo completo de la ALU se muestra en el recuadro de cdigo

7.2; tmese en cuenta el uso de la librera IEEE.NUMERIC_STD.ALL, la
inicializacin del componente disp_hex_mux y el mapeo del mismo, as como
el uso de la funcin bin_a_bcd.
library IEEE;
use IEEE.STD_LOGIC_1164.ALL;
use IEEE.NUMERIC_STD.ALL;
entity ALU is
Port ( Dato_A : in STD_LOGIC_VECTOR (2 downto 0);
Dato_B : in STD_LOGIC_VECTOR (2 downto 0);

pg. 99

Sel
: in STD_LOGIC_VECTOR (1 downto 0);
clk : in STD_LOGIC;
reset : in STD_LOGIC;
segmentos : out std_logic_vector( 7 downto 0 );
Componente para encender display
anodos : out std_logic_vector( 3 downto 0 ); -Componente para multiplexar display
Salida : out STD_LOGIC_VECTOR (5 downto 0));

--

end ALU;
architecture Behavioral of ALU is
-- Declaracin de Seales Auxiliares
signal a: unsigned (Dato_A'range);
signal b: unsigned (Dato_B'range);
signal Salida_aux: unsigned (Salida'range);
signal numerobcd : unsigned( 15 downto 0 );
encender los 4 displays

-- 16 bits para

--===========================================================
-- Llamada al archivo componente "disp_hex_mux"
--===========================================================
COMPONENT disp_hex_mux
PORT(
clk : IN std_logic;
reset : IN std_logic;
hex3 : IN std_logic_vector(3 downto 0);
hex2 : IN std_logic_vector(3 downto 0);
hex1 : IN std_logic_vector(3 downto 0);
hex0 : IN std_logic_vector(3 downto 0);
dp_in : IN std_logic_vector(3 downto 0);
an : OUT std_logic_vector(3 downto 0);
sseg : OUT std_logic_vector(7 downto 0)
);
END COMPONENT;
-===========================================================================
=======
-- Funcin que recibe un valor binario de 16 bits y devuelve su
representacin
-- BCD de cuatro dgitos (16 bits).
-- Usa el algoritmo de corrimiento y suma 3.
function

bin_a_bcd(

bin

unsigned(15

downto

0))

return

unsigned is
variable i : integer := 0;
variable resultado : unsigned(

15

downto

:=

"0000000000000000";

pg. 100

variable copiabin : unsigned( 15 downto 0 ) := bin;

begin
-- Cdigo de la funcin
for i in 0 to 15 loop
resultado( 15 downto 1 ) := resultado( 14 downto
0 );
resultado( 0 ) := copiabin( 15 );
copiabin( 15 downto 1 ) := copiabin( 14 downto 0
);
copiabin( 0 ) := '0';
-- unidades
if i < 15 and resultado( 3 downto 0 ) > "0100"
then
resultado( 3 downto 0 ) := resultado( 3
downto 0 ) + "0011";
end if;
-- decenas
if i < 15 and resultado( 7 downto 4 ) > "0100"
then
resultado( 7 downto 4 ) := resultado( 7
downto 4 ) + "0011";
end if;
-- centenas
if i < 15 and resultado( 11 downto 8 ) > "0100"
then
resultado( 11 downto 8 ) := resultado( 11
downto 8 ) + "0011";
end if;
-- millares
if i < 15 and resultado (15 downto 12) > "0100"
then
resultado ( 15 downto 12 ) := resultado ( 15
downto 12 ) + "0011";
end if;
end loop;
return resultado;
end bin_a_bcd;
-- Inicio de la Arquitectura
begin

-- Proceso de la ALU
PROCESS (a, b, Sel)
BEGIN

pg. 101

CASE Sel IS
WHEN "00" => Salida_aux <= RESIZE(a,Salida_aux'length) +
RESIZE(b,Salida_aux'length);
WHEN
"01"
=>
Salida_aux
<=
RESIZE((a
*
b),Salida_aux'length);
WHEN "10" => Salida_aux <= RESIZE((a(1 downto 0) &
a(2)),Salida_aux'length); -- Rot izq
WHEN "11" => Salida_aux <= RESIZE((a(0) & a(2 downto
1)),Salida_aux'length); -- Rot derecha
WHEN OTHERS => null;
END CASE;
END PROCESS;
--Conversin de entradas Dato_A y Dato_B a unsigned y asignacin a
seales auxiliares
a <= UNSIGNED(Dato_A);
b <= UNSIGNED(Dato_B);
--Salida a Leds
Salida <= std_logic_vector (Salida_aux);

-- Conversin a BCD llamada a Funcin

numerobcd <= bin_a_bcd (RESIZE (Salida_aux,numerobcd'length));
--=====================================================
-- Mapeo del controlador de displays
--=====================================================
Inst_disp_hex_mux: disp_hex_mux PORT MAP(
clk => clk,
reset => reset,
hex3 => std_logic_vector (numerobcd(15 downto 12)),
hex2 => std_logic_vector (numerobcd(11 downto 8)),
hex1 => std_logic_vector (numerobcd(7 downto 4)),
hex0 => std_logic_vector (numerobcd(3 downto 0)),
dp_in => "1111",
an => anodos,
sseg => segmentos
);

end Behavioral;
Cdigo 7.2 ALU

Como podemos observar en el cdigo 7.2, la seleccin de las

operaciones se hace con un CASE donde la entrada Sel es la referencia y

pg. 102

dependiendo del valor asignado a Sel desde los switches de la tarjeta

Basys2 se realiza la operacin mostrada en la tabla 7.1.
La muestra del poder y versatilidad de VHDL se observa en la
multiplicacin. Al multiplicar 2 nmeros de 3 bits se necesita una salida de 6
bits para representar el nmero mximo que sera 7*7 = 49. Esto ocasiona
una discrepancia en el ancho de los vectores; para ello se llama a la funcin
RESIZE.
RESIZE (a, Salida_auxlenght)
Esto quiere decir que se redimensiona a de 3 bits al ancho de la seal
auxiliar salida_aux de 6 bits; de igual forma se utiliza el RESIZE para hacer
el llamado de la funcin bin_a_bcd de un ancho de 6 bits a 16 bits sin
necesidad de mandar la salida_aux a otra seal auxiliar de 16 bits y
recortarla como en la prctica 6.
numerobcd <= bin_a_bcd
(RESIZE(Salida_aux,numerobcd'length));

Observe la declaracin de las seales de tipo unsigned a y b; esto es

debido a que con la librera IEEE.NUMERIC_STD.ALL no se pueden hacer
implcitamente operaciones aritmticas entre vectores (std_logic_vector) de
las 2 entradas Dato_A y Dato_B.
signal a: unsigned (Dato_A'range);
signal b: unsigned (Dato_B'range);
Se asigna el contenido de Dato_A y Dato_B a las seales auxiliaries
de tipo unsigned a y b con las siguientes lneas; ntese la palabra
UNSIGNED antes de la asignacin que convierte de tipo std_logic_vector a
Unsigned.
a <= UNSIGNED(Dato_A);
b <= UNSIGNED(Dato_B);
Por ltimo analice el casteo de Salida que convierte la Salida_aux de
tipo unsigned a std_logic_vector la cual encender los leds de la Tarjeta
Basys2. De igual forma se hace la misma conversin en las entradas hex del
componente disp_hex_mux.vhd para encender los displays.
Salida <= std_logic_vector (Salida_aux);

pg. 103

De esta forma se hace el manejo entre entradas o salidas de tipo

std_logic_vector a seales de tipo signed o unsigned.
Para probar la ALU asigne los pines a la Tarjeta Basys2, compile y
verifique su funcionamiento. La asignacin de pines se muestra en el
recuadro de cdigo 7.3
# PlanAhead Generated physical constraints
NET
NET
NET
NET
NET
NET
NET
NET
NET
NET
NET
NET
NET
NET
NET
NET
NET
NET
NET
NET
NET
NET
NET
NET
NET
NET
NET
NET

"Dato_A[0]" LOC = P11;

"Dato_A[1]" LOC = L3;
"Dato_A[2]" LOC = K3;
"Dato_B[0]" LOC = B4;
"Dato_B[1]" LOC = G3;
"Dato_B[2]" LOC = F3;
"Salida[0]" LOC = M5;
"Salida[1]" LOC = M11;
"Salida[2]" LOC = P7;
"Salida[3]" LOC = P6;
"Salida[4]" LOC = N5;
"Salida[5]" LOC = N4;
"Sel[0]" LOC = E2;
"Sel[1]" LOC = N3;
"anodos[0]" LOC = F12;
"anodos[1]" LOC = J12;
"anodos[2]" LOC = M13;
"anodos[3]" LOC = K14;
"reloj_tarjeta" LOC = B8;
"reset" LOC = G12;
"segmentos[0]" LOC = M12;
"segmentos[1]" LOC = L13;
"segmentos[2]" LOC = P12;
"segmentos[3]" LOC = N11;
"segmentos[4]" LOC = N14;
"segmentos[5]" LOC = H12;
"segmentos[6]" LOC = L14;
"segmentos[7]" LOC = N13;
Cdigo 7.3 Asignacin de pines ALU

Nota: En algunos casos con la utilizacin de la librera

IEEE.NUMERIC_STD.ALL se requiere convertir variables, seales o
constantes de tipo integer, real, natural, etc a unsiged o signed e incluso a
std_logic_vector.
Para realizar estas conversiones tomese como referencia el siguiente
ejemplo: Se requiere desplegar en los leds de la Tarjeta Basys2 una seal de
tipo natural la cual se sumar con una seal de tipo unsigned.
Leds : out std_logic_vector (7 downto 0);

pg. 104

Signal a : natural;
Signal a_aux : unsigned (7 downto 0);
Signal b : unsigned (7 downto 0);
Primero se convierte de natural a unsigned y se asigna a una seal
auxiliar a_aux
a_aux <= to_unsigned (a, 8);
seal_destino <= to_unsigned (seal_natural, #
nmero_bits_destino)
Despus se puede hacer la suma entre 2 seales de tipo unsigned y
despus convertirla a std_logic_vector para desplegarla en la salida Leds.
Leds <= std_logic_vector (a_aux + b);

Practica 8 Elementos de Memoria (Flip-Flops) Pulsador

Un elemento de memoria es un componente que es capaz de
memorizar (guardar) un valor. Un biestable (flip-flop o latch), es un
multivibrador capaz de permanecer en uno de dos estados posibles durante
un tiempo indefinido en ausencia de perturbaciones.
El paso de un estado a otro se realiza variando sus entradas.
Dependiendo del tipo de dichas entradas los biestables se dividen en:
-Asncronos: slo tienen entradas de control. El ms empleado es el
biestable RS.
-Sncronos: adems de las entradas de control posee una entrada de
sincronismo o de reloj. Por lo general, las entradas de control asncronas
prevalecen sobre las sncronas.
En la siguiente prctica se encender un Led de la Tarjeta Basys2 con
un solo Push Button; por lo tanto cuando el Led se encuentre apagado y se
pulse el Push Button este se encender y por el contrario cuando el Led se
encuentre encendido este se apagar.
Para hacer esto se utilizar un Biestable T (Toggle) el cual cambia de
estado cada vez que la entrada de sincronismo de reloj se dispara mientras
la entrada T est a nivel alto. Si la entrada T est a nivel bajo, el biestable
retiene el nivel previo. El smbolo del Biestable T se muestra en la figura 8.1

pg. 105

Figura 8.1 Flip-Flop T

Con un biestable T es suficiente para esta aplicacin, pero el dedo

humano no es tan rpido como la frecuencia de reloj de la Tarjeta Basys2 de
50Mhz, por lo tanto al presionar el Push Button el tiempo de pulsacin durar
muchos ciclos de reloj, y por lo tanto, el estado del biestable (Q) cambiar en
todos los ciclos de reloj que se deje presionado el botn; al soltar el Push
Button el estado final del biestable ser aleatorio segn se haya mantenido
pulsado el botn durante un nmero par o impar de ciclos de reloj.
Para solucionar este problema se debe implementar un Circuito
Detector de Flancos el cual ser til cada vez que se necesite hacer
interfaces humanas con diseos sncronos. En una seal digital, se
denomina flanco a la transicin del nivel bajo al alto (flanco de subida) o de
nivel alto al bajo (flanco de bajada).
El circuito Detector de Flancos se puede realizar mediante 2 registros
de desplazamiento (Biestables D). Cuando se pulse el Push Button de la
Tarjeta Basys2 la seal ser almacenada por el primer Biestable D (Reg1) y
su salida pasa al segundo Biestable D (Reg2) cuya salida es negada e
ingresada junto con la salida del Primer Biestable D (Reg1) a una compuerta
AND. Como resultado se obtendr una salida que durar un ciclo de reloj que
servir como entrada al Biestable T (Figura 8.2) que en vez de recibir el pulso
directamente de los Push Buttons de la Tarjeta Basys2 obtendr una seal
filtrada de 1 ciclo de reloj que encender o apagar el Led segn sea el caso.

Figura 8.2 Detector de Flancos conectado a Biestable T

pg. 106

Observe la simulacin del circuito Detector de flancos. Cuando la

entrada btn0 pasa de bajo a alto btn0_reg1 y btn0_reg2 lo hacen tambin.
Recuerde que estas 2 seales ingresan a una compuerta AND por lo tanto se
tiene una salida pulso_btn0 de 1 ciclo de reloj (Figura 8.3)

Figura 8.3 Simulacin Detector de Flancos

El cdigo VHDL del circuito es mostrado en el recuadro de cdigo 8.1

donde se puede observar la implementacin del circuito detector de flancos
basado en Biestables tipo D y la memoria Biestable tipo T.
entity Pulsador_Memoria is
Port ( BTN0 : in STD_LOGIC;
Clk : in STD_LOGIC;
Reset : in STD_LOGIC;
LD0 : out STD_LOGIC);
end Pulsador_Memoria;
architecture Behavioral of Pulsador_Memoria is
signal BTN0_REG1, BTN0_REG2, PULSO_BTN0, Q_T : std_logic;
begin
--==================================================================
-- Detector de Flancos
--==================================================================
Process (Reset, Clk)
begin
if Reset = '1' then

pg. 107

BTN0_REG1
BTN0_REG2
elsif Clk'event
BTN0_REG1
BTN0_REG2
end if;
end process;

<= '0';
<= '0';
and Clk='1' then
<= BTN0;
<= BTN0_REG1;

PULSO_BTN0 <= '1' when (BTN0_REG1 = '1' and (not BTN0_REG2='1'))

else '0';
--==================================================================
-- Biestable T
--==================================================================
biest_T: Process (Reset, Clk)
begin
if Reset = '1' then
Q_T <= '0';
elsif Clk'event and Clk='1' then
if PULSO_BTN0 = '1' then - Si el pulso del boton = 1
Q_T <= NOT Q_T;
-- Enciende o Apaga.
End if;
end if;
end process;
LD0 <= Q_T;
end Behavioral;
Cdigo 8.1 Pulsador_Memoria

Para probar el programa Pulsador_Memoria asigne los pines a la

Tarjeta Basys2 con Plan Ahead, compile y baje el programa al FPGA para
verificar su funcionamiento.

Practica 9 Maquinas de Estados Finitos (FSM)

Se denomina mquina de estados a un modelo de comportamiento de
un sistema con entradas y salidas, en donde las salidas dependen no solo de
las seales de entrada actuales sino tambin de las anteriores. Una maquina
de estados Finitos es usada para modelar sistemas que transitan a travs de
un numero finito de estados internos.
El diagrama a bloques bsico de una FMS (Figura 9.1) consiste de un
Registro de estado, Lgica de Estado Siguiente y Lgica de Salida. Una FSM
pg. 108

es conocida como Maquina de Moore si su salida esta en funcin solo del

Estado actual, y es conocida como Maquina de Mealy si su salida esta en
funcin del Estado Actual y una Entrada externa.

Figura 9.1 - Diagrama a Bloques de FSM

De ahora en adelante para la comprensin de los programas que

utilicen Mquinas de estados, Registros de Estado y lgica de Estado
Siguiente se utilizar:
Estado Actual => State_reg
Estado Siguiente => State_next
Para representar una FSM generalmente se utiliza un Diagrama de
Estados (State diagram) o una Tabla ASM (ASM chart Algorithmic State
Machine chart). Ambos capturan las entradas, salidas, estados y transiciones
de la FSM en una representacin grfica.

Practica 9.1 Encendido de Led Basado en FSM con Pulsador

En esta prctica se encender un Led de la Tarjeta Basys2 por medio

de un PushButton de igual forma que en la prctica 10 pero esta vez
utilizando Maquinas de Estados Finitos (FSM)
Para comprender mejor el funcionamiento observe el Diagrama de
Estados del FSM_Led

pg. 109

Push = 1

Push = 0

Led0 <= 0

Push = 0

Led_O
N

Led_
OFF

Led0 <= 1

Push = 1
Figura 9.2 Diagrama de Estados FSM_Led

Como claramente se observa en el Diagrama de Estados, al

encontrarse en el Estado LED_OFF (state_reg) y obtener un 1 desde el
PushButton de la Tarjeta Basys2 se pasa al siguiente estado (state_next)
LED_ON encendiendo el Led, por el contrario si se encuentra en el estado
LED_OFF y se obtiene un 0 desde el PushButton, se permanece en el
mismo estado y el Led no se enciende. Al encontrarse en el estado LED_ON
y obtener un 0 desde el PushButton, el Estado siguiente permanece en
LED_ON; por el contrario, si el PushButton enva un 1 se cambia al estado
LED_OFF apagando el Led.
En otras palabras el Led enciende con un pulso del botn y se apaga
con otro pulso del mismo botn.
El diagrama a bloques del circuito se muestra en la Figura 9.3

Figura 9.3 Diagrama a bloques FSM_Led

Por lo tanto basado en la figura 9.3 la entidad del programa quedara

de la siguiente manera:

pg. 110

entity FSM_Led is
Port ( Push: in STD_LOGIC;
Clk : in STD_LOGIC;
Reset : in STD_LOGIC;
Led0 : out STD_LOGIC);
end FSM_Led;
Cdigo 9.1 Entidad FSM_Led

Para representar los estados de la FSM se utiliza una enumeracin de

Tipo de Datos TYPE, en donde se asigna un nombre a la enumeracin
seguido de los estados que se utilizarn.
TYPE nombre_de_la_enumeracin is (Estado1, Estado2, EstadoN);
TYPE estados_led is (LED_OFF, LED_ON);
De este modo se crean 2 estados LED_OFF y LED_ON mostrados en
el Diagrama de la Figura 9.2
Teniendo la enumeracin se crean las seales del registro de Estados
las cuales sern un componente de la enumeracin creada.
Signal state_reg, state_next : estados_led;
Para que la FSM funcione se necesitan de dos procesos, un proceso
que actualice y guarde el Estado del Registro cada pulso de Reloj de la
Tarjeta Basys2 (Cdigo 9.2 State Register) y un proceso que obtenga el
estado siguiente y mande la accin de control hacia las salidas (Cdigo 9.3
Next-State logic and output logic).
--==========================================================
-- Proceso que actualiza y guarda el estado del registro
--==========================================================
P_SEQ_FSM: Process (Reset, Clk)
begin
if Reset = '1' then
state_reg <= LED_OFF;
elsif Clk'event and Clk='1' then
state_reg <= state_next;
end if;
end process;
Cdigo 9.2 - State Register

-=====================================================================
--Proceso que obtiene el estado siguiente y salidas (next-state
logic)
-=====================================================================

pg. 111

P_COMB_ESTADO: Process (state_reg, Push_tick)

begin
state_next <= state_reg; -- condicion de inicio y regreso a
estado actual
Led0 <= '0';
case state_reg is
when LED_OFF =>
if Push_tick = '1' then
state_next <= LED_ON;
Led0 <= '1';
else
state_next <= LED_OFF;
Led0 <= '0';
end if;
when LED_ON =>
if Push_tick = '1' then
state_next <= LED_OFF;
Led0 <= '0';
else
state_next <= LED_ON;
Led0 <= '1';
end if;
end case;
end process;
Cdigo 9.3 Next-State Logic and Output Logic

Las condiciones del cambio de estado se implementan por medio de

un CASE que depende del estado actual del Registro (State_reg). Es una
buena prctica de programacin inicializar los estados y mandar a su
condicin predeterminada las salidas (en este caso el Led apagado) dentro
del proceso de cambio de Estados.

state_next <= state_reg;

Led0 <= '0';
No olvide el circuito Detector de Flancos necesario para las interfaces
humanas el cual solo entregar un pulso cada que se presione el botn.
El cdigo completo de la arquitectura es mostrado en el recuadro de
cdigo 9.4. (Observe el circuito detector de flancos y la creacin de las
seales auxiliares). Compile y pruebe su funcionamiento.

architecture Behavioral of FSM_Led is

-- Enumeracin Type para la FSM ... (Enumeracion de los Estados)
-- El tipo enumerado siguiente nos permite asignar los valores

pg. 112

LED_OFF y LED_ON a
-- las seales que se declaren del tipo estados_led.
type estados_led is (LED_OFF, LED_ON);
-- Seales para el programa (ojo que
enumeracin XD)
signal state_reg, state_next : estados_led;
signal btn_reg : std_logic;
signal Push_tick : std_logic;
begin

son

componente

de

la

--===================================
--Detector de Flancos
--===================================
process(clk)
begin
if (clk'event and clk='1') then
btn_reg <= Push;
end if;
end process;
Push_tick <= (not btn_reg) and Push;
--==========================================================
-- Proceso que actualiza y guarda el estado del registro
--==========================================================
P_SEQ_FSM: Process (Reset, Clk)
begin
if Reset = '1' then
state_reg <= LED_OFF;
elsif Clk'event and Clk='1' then
state_reg <= state_next;
end if;
end process;
-=====================================================================
--Proceso que obtiene el estado siguiente y salidas (next-state
logic)
-=====================================================================
P_COMB_ESTADO: Process (state_reg, Push_tick)
begin
state_next <= state_reg; -- condicion de inicio y regreso a
estado actual
Led0 <= '0';
case state_reg is
when LED_OFF =>
if Push_tick = '1' then
state_next <= LED_ON;

pg. 113

Led0 <= '1';

else
state_next <= LED_OFF;
Led0 <= '0';
end if;
when LED_ON =>
if Push_tick = '1' then
state_next <= LED_OFF;
Led0 <= '0';
else
state_next <= LED_ON;
Led0 <= '1';
end if;
end case;
end process;

end Behavioral;
Cdigo 9.4 Arquitectura FSM_Led

Practica 9.2 Rotacin de Leds Basado en FSM con Pulsador

En esta prctica se pretende que los Leds de la tarjeta Basys2 se
enciendan 1 tras otro y roten en ambos sentidos (Izquierda o Derecha).
Con un pulso de un PushButton de la tarjeta se cambiar el sentido de
rotacin de Izquierda a Derecha y al presionar de nuevo se cambiar el
sentido de Derecha a Izquierda. Adems con otro PushButton se podr
Pausar o Continuar la rotacin.
Para hacer esto hay que basarse en el Programa anterior de la
Prctica 9.1 donde los PushButtons dejan Memorizado su pulso, esto
significa que con un pulso se obtiene un 1 y al volver a presionar un 0.
Nuevamente es necesario el diseo estructural para poder Mapear y Castear
los mdulos. El Diagrama a bloques del circuito es mostrado en la figura 9.4

pg. 114

Figura 9.4 Diagrama a Bloques Esquemtico FSM_Rot_Led

Para comprender el funcionamiento de la FSM observe el Diagrama

de estados de la figura 9.5

Pause

Dir
Figura 9.5 Diagrama de estados FSM_Rot_Led

Dependiendo del valor de Dir los Leds rotarn hacia la Izquierda o

hacia la Derecha. Dependiendo del valor de Pause el Led permanecer
quieto en el estado en el que se encuentre. El estado en donde se encuentre
ser el Led que encender de la tarjeta Basys2.
Cabe mencionar que los Leds rotarn a la velocidad del Reloj de la
tarjeta Basys2, por lo cual todos los Leds se vern encendidos al mismo
tiempo. Esto es debido a que corrern a una frecuencia de 50Mhz (50
millones de pulsos por segundo) la cual no es visible al ojo humano.
Para solucionar este problema es necesario un divisor de frecuencia
el cual genera un Tick con un periodo de 20 ns (F = 50 Mhz) cada 0.33
segundos. (*ESTO ES MUY IMPORTANTE PARA NO GENERAR
PROBLEMAS CON LOS TIEMPOS YA QUE NO SE PUEDE UTILIZAR LA
FUNCION clkevent and clk=1 CON UNA SEAL DIFERENTE QUE NO
SEA LA DEL RELOJ DE LA TARJETA BASYS)
Para calcular la divisin de la Frecuencia utilise la siguiente ecuacin:

pg. 115

Donde:
N = Constante de tipo Integer
T = Tiempo Deseado
De este modo se crea una Constante con un valor de 24 para obtener
un Tiempo de 0.33 segundos lo cual equivale a F = 1/T = 3 Hz. (3 Pulsos por
segundo).
El cdigo para lograr esta Divisin de Frecuencia queda como se
muestra en el Recuadro de Cdigo 9.5
constant N: integer:=24; -- 2^N * 20ns = reloj
signal q_reg, q_next: unsigned (N-1 downto 0);
signal Tick : std_logic;
begin
--===================================
--Contador que genera ticks de 0.3 seg
--===================================
process (clk)
begin
if (Clk'event and Clk='1') then
q_reg <= q_next;
end if;
end process;
-- next-state logic
q_next <= q_reg + 1;
-- tick de salida
Tick <= '1' when q_reg=0 else '0';
Cdigo 9.5 Divisor de Frecuencia

Como se puede apreciar, el divisor de Frecuencia no es ms que un

Contador que incrementa en 1 un registro hasta el nmero 16777216 = 2 24.
Cuando el registro vuelve a ser 0 genera un Tick que vale 1 durante 20 ns.
El cdigo que muestra el programa completo (FSM_Rot_Led) se
muestra en el recuadro de Cdigo 9.6. Ntese el uso del diseo estructural
para el Casteo del programa FSM_Led.
entity FSM_Rot_Led is
Port ( Clk : in STD_LOGIC;
Reset : in STD_LOGIC;
Dir_ent : in STD_LOGIC;

pg. 116

Led : out
end FSM_Rot_Led;

Pause_ent: in STD_LOGIC;
STD_LOGIC_VECTOR (7 downto 0));

architecture Behavioral of FSM_Rot_Led is

signal Led_aux : unsigned (7 downto 0);

constant N: integer:=24; -- 2^N * 20ns = reloj
signal q_reg, q_next: unsigned (N-1 downto 0);
signal Tick : std_logic;
signal Dir, Pause : std_logic;
type estados_led is (s0,s1,s2,s3,s4,s5,s6,s7);
signal state_reg, state_next : estados_led;
COMPONENT FSM_Led
PORT(
Push : IN std_logic;
Clk : IN std_logic;
Reset : IN std_logic;
Led0 : OUT std_logic
);
END COMPONENT;
begin
--==================================
--Mapeo para Pause y Direccion
--==================================
Inst_FSM_Led_Dir: FSM_Led PORT MAP(
Push => Dir_ent,
Clk => Clk,
Reset => Reset,
Led0 => Dir
);
Inst_FSM_Led_Pause: FSM_Led PORT MAP(
Push => Pause_ent,
Clk => Clk,
Reset => Reset,
Led0 => Pause
);

--===================================
--Contador que genera ticks de 0.3 seg
--===================================
process (clk)
begin
if (Clk'event and Clk='1') then

pg. 117

q_reg <= q_next;

end if;
end process;
-- next-state logic
q_next <= q_reg + 1;
-- tick de salida
Tick <= '1' when q_reg=0 else '0';
--==========================================================
-- Proceso que actualiza y guarda el estado del registro
--==========================================================
P_SEQ_FSM: Process (Reset, Clk, Pause)
begin
if Reset = '1' then
state_reg <= s0;
elsif Pause = '1' then
state_reg <= state_reg;
elsif Clk'event and Clk='1' then
state_reg <= state_next;
end if;
end process;

-=====================================================================
--Proceso que obtiene el estado siguiente y salidas (next-state
logic)
-=====================================================================
P_COMB_ESTADO: Process (state_reg, Tick, Dir, Pause)
begin
state_next <= state_reg; -- 118 ondicin de inicio y regreso a
estado actual
case state_reg is
when s0 =>
Led_aux <= 00000001;
if Tick = 1 then
if Dir = 1 then
state_next <= s1;
else
state_next <= s7;
end if;
end if;
when s1 =>
Led_aux <= 00000010;
if Tick = 1 then
if Dir = 1 then
state_next <= s2;
else

pg. 118

state_next <= s0;

end if;
end if;
when s2 =>
Led_aux <= 00000100;
if Tick = 1 then
if Dir = 1 then
state_next <= s3;
else
state_next <= s1;
end if;
end if;
when s3 =>
Led_aux <= 00001000;
if Tick = 1 then
if Dir = 1 then
state_next <= s4;
else
state_next <= s2;
end if;
end if;
when s4 =>
Led_aux <= 00010000;
if Tick = 1 then
If Dir = 1 then
state_next <= s5;
else
state_next <= s3;
end if;
end if;
when s5 =>
Led_aux <= 00100000;
if Tick = 1 then
if Dir = 1 then
state_next <= s6;
else
state_next <= s4;
end if;
end if;
when s6 =>
Led_aux <= 01000000;
if Tick = 1 then
if Dir = 1 then
state_next <= s7;
else
state_next <= s5;
end if;
end if;
when s7 =>
Led_aux <= 10000000;
if Tick = 1 then
if Dir = 1 then
state_next <= s0;

pg. 119

else
state_next <= s6;
end if;
end if;
end case;
end process;
Led <= std_logic_vector (Led_aux);
end Behavioral;
Cdigo 9.6 FSM_Rot_Led

Para lograr que la rotacin se Detenga hay que hacer que

permanezca en el mismo estado cuando Pause tenga un valor de 1. Dentro
del Proceso que controla la actualizacin del Registro de estado se puede
agregar esta condicin.
elsif Pause = '1' then
state_reg <= state_reg;
Compile y Pruebe el funcionamiento del Programa con la Tarjeta
Basys2.

Prctica 10 Circuito Anti rebotes (Debounce Circuit)

Existe un problema con los switches mecnicos de la Tarjeta Basys2 y
sensores diseados por uno mismo, al ser activados presentan ms de un
pulso en su seal. Esto se debe a que rebota de arriba hacia abajo la seal
hasta que se estabiliza en un pulso positivo o negativo. En algunos casos
estos rebotes duran hasta 20 ms y tomando en cuenta que la Tarjeta
Basys2 tiene una velocidad de reloj de 20 ns ocasiona comportamientos no
deseados en los diseos como saltos de cuentas, cambio a estados
indeterminados o activacin de actuadores en momentos errneos.
Un circuito detector de flancos no siempre es suficiente as que al
combinarlo con un circuito anti rebotes se obtiene una seal limpia (filtrada)
que elimina esos rebotes innecesarios en las transiciones de los switches o
sensores.
En la figura 10.1 se representa lo que pasa al accionar un switch
mecnico, observe las pequeas variaciones que se eliminarn antes de
estabilizarse.

pg. 120

Figura 10.1 Toma de osciloscopio de un Switch

Se basar el circuito anti rebotes en una Maquina de Estados la cual

tendr un generador de ticks de 10 ms para los estados de espera y dos
estados principales (Zero y One); de esta forma se tendr un valor de 0 o 1
respectivamente.
Asumiendo que la FSM esta inicialmente en el estado Zero, esta se
mueve al primer estado de espera Wait1_1 cuando el switch cambia a 1. En
el estado Wait1_1 la FSM espera recibir un Tick de 10 ms para pasar al
siguiente estado, si dentro de este tiempo el Switch toma un valor de 0,
implica que la duracin del 1 no tard lo demasiado y regresa al estado Zero
(Hubo un rebote). La accin se repite 2 veces mas para los estados Wait1_2
y Wait1_3. La operacin desde el estado One es similar excepto que la seal
del switch debe ser 0.
El diagrama a bloques esquemtico del circuito anti rebotes se
observa en la Figura 10.2

Figura 10.2 Diagrama Esquemtico Debounce_FSM

Para entender mejor el funcionamiento observe el diagrama de

estados Debounce_FSM de la Figura 10.3.

pg. 121

Figura 10.3 Diagrama de Estados Debounce_FSM

El cdigo VHDL que implementa el Debounce_FSM (Cdigo 10.1) es

similar a las maquinas de estados creadas en la prctica 9, observe la
implementacin del generador de ticks de 10ms y la salida filtrada db que se
utilizar en prcticas posteriores.
entity Debounce_fsm is
Port ( clk : in STD_LOGIC;
reset : in STD_LOGIC;
sw : in STD_LOGIC;
db : out STD_LOGIC);
end Debounce_fsm;
architecture Behavioral of Debounce_fsm is
constant N: integer:=19; -- 2^N * 20ns = 10 ms reloj
signal q_reg, q_next: unsigned (N-1 downto 0);
signal m_tick: std_logic;
--enumeracin estados
type eg_state_type is (zero, wait1_1, wait1_2, wait1_3,
one, wait0_1, wait0_2, wait0_3);
signal state_reg, state_next: eg_state_type;
begin
--===================================

pg. 122

--Contador que genera ticks de 10 ms

--===================================
process (clk,reset)
begin
if (clk'event and clk='1') then
q_reg <= q_next;
end if;
end process;
-- next-state logic
q_next <= q_reg + 1;
-- tick de salida
m_tick <= '1' when q_reg=0 else '0';
--===================================
-- Debounce FMS
--===================================
-- Registro de Estado
process (clk, reset)
begin
if (reset = '1') then
state_reg <= zero;
elsif (clk'event and clk='1') then
state_reg <= state_next;
end if;
end process;
-- logica de estados y salidas
process (state_reg, sw, m_tick)
begin
state_next <= state_reg; -- parametro default
db <= '0'; -- default 0
case state_reg is
when zero =>
if sw = '1' then
state_next <= wait1_1;
end if;
when wait1_1 =>
if sw = '0' then
state_next <= zero;
else
if m_tick = '1' then
state_next <= wait1_2;
end if;
end if;
when wait1_2 =>
if sw = '0' then
state_next <= zero;
else

pg. 123

if m_tick = '1' then

state_next <= wait1_3;
end if;
end if;
when wait1_3 =>
if sw = '0' then
state_next <= zero;
else
if m_tick = '1' then
state_next <= one;
end if;
end if;
when one =>
db <= '1';
if sw = '0' then
state_next <= wait0_1;
end if;
when wait0_1 =>
db <= '1';
if sw = '1' then
state_next <= one;
else
if m_tick = '1' then
state_next <= wait0_2;
end if;
end if;
when wait0_2 =>
db <= '1';
if sw = '1' then
state_next <= one;
else
if m_tick = '1' then
state_next <= wait0_3;
end if;
end if;
when wait0_3 =>
db <= '1';
if sw = '1' then
state_next <= one;
else
if m_tick = '1' then
state_next <= zero;
end if;
end if;
end case;
end process;
end Behavioral;
Cdigo 10.1 Debounce_FSM

pg. 124

Practica 11 - Generacin de una seal PWM

En la siguiente practica se realizar un cdigo en VHDL con el que la
tarjeta Basys2 proporcionar una seal PWM, la cual como se sabe es til en
el control de motores de CD.
La modulacin por ancho de pulso (Pulse Width Modulation PWM) de
una seal o fuente de energa es una tcnica en la que se modifica el ciclo
de trabajo de una seal peridica (una senoidal o una cuadrada, por
ejemplo), ya sea para transmitir informacin a travs de un canal de
comunicaciones o para controlar la cantidad de energa que se enva a una
carga.
El ciclo de trabajo de una seal peridica es el ancho relativo de su
parte positiva en relacin con el perodo. Expresado matemticamente:

Donde:
D es el ciclo de trabajo
es el tiempo en que la funcin es positiva (ancho del pulso)
T es el perodo de la funcin

Figura 11.1 Ciclo de Trabajo

La construccin tpica de un circuito PWM se lleva a cabo mediante un

comparador con dos entradas y una salida.
Algunos parmetros importantes de un PWM son:

La relacin de amplitudes entre la seal portadora y la moduladora,

siendo recomendable que la ltima no supere el valor pico de la
portadora y est centrada en el valor medio de sta.
La relacin de frecuencias, donde en general se recomienda que la
relacin entre la frecuencia de la portadora y la de seal sea de 10 a
1.

pg. 125

En la figura 11.2 se muestra un primer esquema para la generacin de

la seal PWM. El diseo es muy simple, mediante el mdulo interfaz, el
software enva la posicin deseada que es almacenada en un registro, que
se denominar registro de posicin. El reloj del sistema incrementa un
contador, de manera que se lleva la cuenta de cuntos tics de reloj han
transcurrido desde que inicialmente se encontraba a cero.
Mediante un comparador se comprueba si el nmero de tics recibidos
es menor que la posicin especificada. Esta posicin, que es en realidad el
ancho del pulso de la seal PWM, se expresa tambin en tics de reloj, por lo
que mientras los tics contados sean menores que los tics del ancho del
pulso, la seal de salida del comparador, L, permanecer a nivel alto. En
cuanto los tics superen este valor, la seal L se pone a cero.

F
Posicin
I

Figura 11.2 Diagrama a bloques generacin de una seal PWM en VHDL

Como se puede observar en el diagrama a bloques, se necesitan dos

mdulos: un contador y un comparador, los cuales posteriormente sern
mapeados para as crear un solo modulo que contendr los dos mdulos
anteriores y la seal PWM de salida.
El mdulo del contador es mostrado en el recuadro de cdigo 11.1
notese la creacin de la variable cuenta y su uso.

entity Contador is
port (

clk : in std_logic; -- Reloj

reset : in std_logic;
q : out std_logic_vector (7 downto 0)); --Salida

pg. 126

end Contador;
architecture Behavioral of Contador is
begin
output: process(clk,reset)
variable cuenta : std_logic_vector(7 downto 0);
begin
-- Actualizar la cuenta
if (reset='1') then -- Reset asncrono
cuenta:=(others=>'0'); -- Inicializar contador
q<=cuenta;
elsif (clk'event and clk='1') then -- Flanco de subida en reloj
cuenta:=(cuenta+1); -- Incrementar contador
q<=cuenta;
end if;
end process;
end Behavioral;
Cdigo 11.1 Mdulo contador

Es recomendado utilizar la librera unsigned para poder utilizar el

signo de (+) en el cdigo, sin esta librera marcar un error al momento de
checar la sintaxis del cdigo.
Lo siguiente es disear un mdulo de Comparacin de 2 entradas de 8
bits. El cdigo es mostrado en el recuadro de cdigo 11.2
entity Comparador is
port (opa : in std_logic_vector(7 downto 0); -- Operador A
opb : in std_logic_vector(7 downto 0); -- Operador B
G : out std_logic);
end Comparador;
architecture Behavioral of Comparador is
begin
process (opa, opb)
begin
if (opa<opb) then
G <= '1';
else
G <= '0';
end if;
end process;
end Behavioral;
Codigo 11.2 Mdulo comparador

pg. 127

Como se observa se tiene dos entradas de 8 bits de las cuales la

primera ser la salida del mdulo contador y la segunda ser la posicin
deseada por el usuario. Para hacer esta comparacin solo se necesita un
proceso el cual depender de las entradas opa y opb; cuando opa sea
menor que opb entonces la seal de salida G, tomar el valor de 1, por el
contrario tomar el valor de 0.
Por ltimo se crea el Top Module en el cual se agregan los dos
modulos anteriores (comparador y contador) y asi se obtiene la seal PWM.
A este nuevo mdulo se le asignar el nombre de PWM_OUT, a continuacin
se muestra el cdigo del mdulo PWM_OUT (cdigo 11.3).
entity PWM_OUT is
port (pwm_pos : in std_logic_vector (7 downto 0); -- Posicion
pwm_clk : in std_logic; -- Reloj
pwm_reset: in std_logic; -- Reset.
pwm_o : out std_logic); -- Seal PWM
end PWM_OUT;
architecture Behavioral of PWM_OUT is
component contador is
port (
clk : in std_logic; -- Reloj
reset : in std_logic;
q : out std_logic_vector (7 downto 0)); --Salida
end component;
component comparador is
port (
opa : in std_logic_vector(7 downto 0); -- Operador A
opb : in std_logic_vector(7 downto 0); -- Operador B
G : out std_logic);
end component;
signal ntic : std_logic_vector (7 downto 0); -- Numero de tics de
reloj
signal sg : std_logic; -- Seal G
begin
CONT1: contador port map (clk=>pwm_clk, q=>ntic, reset=>pwm_reset);
COMP1: comparador port map (opa=>ntic, opb=>pwm_pos, G=>sg);
-- Seal PWM de salida
pwm_o<= sg;

end Behavioral;
Cdigo 11.3 - Mdulo PWM_OUT.

pg. 128

Observe que en el mdulo PWM_OUT se cuenta con una seal de

posicin (pwm_pos), la cual es una de las entradas del comparador (Ciclo de
Trabajo que el usuario desea para la seal PWM), tiene una seal de reloj
(pwm_clk) con la misma frecuencia de reloj que el contador, un reset
(pwm_reset) que ser el mismo que el del contador y una salida (pwm_o) la
cual es la salida del comparador, y en su defecto ser la seal PWM
deseada.
Asigne la entrada pwm_pos a los switches de la tarjeta Basys2 y la
salida pwm_o a un led. Se debe notar la variacin de intensidad luminosa en
el led de la tarjeta.
Envie la salida de la seal PWM a un motor haciendo las
consideraciones de acondicionamiento de seal necesarias. El resultado se
observa en el siguiente video a travs del enlace:
http://youtu.be/Y4YPefPjxqY

Practica 12 - PWM con salida a display.

En esta prctica se generar una seal PWM como en el proyecto
anterior, pero ahora el porcentaje al que se encuentra el ancho de pulso de la
seal (duty cycle) ser mostrado en los displays de la tarjeta, dicho ancho de
pulso ser manipulado por medio del usuario a travs de los bits de posicin.
Observese el diagrama a bloques del proyecto (figura 12.1) para
comprender mejor su funcionamiento.

Figura 12.1 Diagrama a bloques de PWM con display

Como se puede observar se necesita un mdulo PWM, para ello se

reutilizar el de la prctica anterior (Cdigo 11.1, 11.2, 11.3); adems, se
pg. 129

necesita un mdulo que se encarge de multiplexear y sacar el resultado

hacia los displays, para ello se reutilizar el modulo diseado en la prctica
de la ALU (Cdigo 7.1 disp_hex_mux)
Con la ayuda del diseo estructural se facilita el trabajo reutilizando
pedazos de cdigo prefabricados, cree un mdulo que se encarge de la
conversin de cdigo binario de la entrada a un porcentaje proporcional que
ser desplegado en la salida del display. Emplee la funcin bin-a-bcd
utilizada anteriormente para este paso. Observese el cdigo del mdulo
Porcentaje
library IEEE;
use IEEE.STD_LOGIC_1164.ALL;
use IEEE.NUMERIC_STD.ALL;
entity Porcentaje is
Port ( Entrada : in STD_LOGIC_VECTOR (5 downto 0);
clk : in STD_LOGIC;
an: out std_logic_vector (3 downto 0);
sseg: out std_logic_vector (7 downto 0));
end Porcentaje;
architecture Behavioral of Porcentaje is
--=======================
--sEALES
--=======================
Signal Porcentaje_aux : unsigned (15 downto 0);
Signal Porcentaje : unsigned (6 downto 0);
Signal hex : unsigned(15 downto 0);
-===========================================================================
========
-- Funcin que recibe un valor binario de 16 bits y devuelve
su representacin
-- BCD de cuatro dgitos (16 bits).
-- Usa el algoritmo de corrimiento y suma 3.
-===========================================================================
========
function bin_a_bcd( bin : unsigned(15 downto 0)) return unsigned is
variable i : integer := 0;
variable
resultado
:
unsigned(
15
downto
0
)
:=
"0000000000000000";
variable copiabin : unsigned( 15 downto 0 ) := bin;
begin
-- Aqu va el cdigo de la funcin
for i in 0 to 15 loop

pg. 130

resultado( 15 downto 1 ) := resultado( 14 downto 0 );

resultado( 0 ) := copiabin( 15 );
copiabin( 15 downto 1 ) := copiabin( 14 downto 0 );
copiabin( 0 ) := '0';
-- unidades
if i < 15 and resultado( 3 downto 0 ) > "0100" then
resultado( 3 downto 0 ) := resultado( 3 downto 0
) + "0011";
end if;
-- decenas
if i < 15 and resultado( 7 downto 4 ) > "0100" then
resultado( 7 downto 4 ) := resultado( 7 downto 4
) + "0011";
end if;
-- centenas
if i < 15 and resultado( 11 downto 8 ) > "0100" then
resultado( 11 downto 8 ) := resultado( 11 downto
8 ) + "0011";
end if;
-- millares
if i < 15 and resultado (15 downto 12) > "0100" then
resultado ( 15 downto 12 ) := resultado ( 15
downto 12 ) + "0011";
end if;
end loop;
return resultado;
end bin_a_bcd;
--============================================
--Instantiation Display_Mux
--============================================
COMPONENT Dis_hex_mux
PORT(
clk : IN std_logic;
reset : IN std_logic;
hex3 : IN std_logic_vector(3 downto 0);
hex2 : IN std_logic_vector(3 downto 0);
hex1 : IN std_logic_vector(3 downto 0);
hex0 : IN std_logic_vector(3 downto 0);
dp_in : IN std_logic_vector(3 downto 0);
an : OUT std_logic_vector(3 downto 0);
sseg : OUT std_logic_vector(7 downto 0)
);
END COMPONENT;
--==================================
--Inicio de Arquitectura
--==================================

pg. 131

begin
--=============================================================
-- Conversin de los Porcentajes de la Entrada de los Switches
--=============================================================
process (Entrada) begin
case Entrada is
when "000000" => Porcentaje
when "000001" => Porcentaje
when "000010" => Porcentaje
when "000011" => Porcentaje
when "000100" => Porcentaje
when "000101" => Porcentaje
when "000110" => Porcentaje
when "000111" => Porcentaje
when "001000" => Porcentaje
when "001001" => Porcentaje
when "001010" => Porcentaje
when "001011" => Porcentaje
when "001100" => Porcentaje
when "001101" => Porcentaje
when "001110" => Porcentaje
when "001111" => Porcentaje
when "010000" => Porcentaje
when "010001" => Porcentaje
when "010010" => Porcentaje
when "010011" => Porcentaje
when "010100" => Porcentaje
when "010101" => Porcentaje
when "010110" => Porcentaje
when "010111" => Porcentaje
when "011000" => Porcentaje
when "011001" => Porcentaje
when "011010" => Porcentaje
when "011011" => Porcentaje
when "011100" => Porcentaje
when "011101" => Porcentaje
when "011110" => Porcentaje
when "011111" => Porcentaje
when "100000" => Porcentaje
when "100001" => Porcentaje
when "100010" => Porcentaje
when "100011" => Porcentaje
when "100100" => Porcentaje
when "100101" => Porcentaje
when "100110" => Porcentaje
when "100111" => Porcentaje
when "101000" => Porcentaje
when "101001" => Porcentaje
when "101010" => Porcentaje

<=
<=
<=
<=
<=
<=
<=
<=
<=
<=
<=
<=
<=
<=
<=
<=
<=
<=
<=
<=
<=
<=
<=
<=
<=
<=
<=
<=
<=
<=
<=
<=
<=
<=
<=
<=
<=
<=
<=
<=
<=
<=
<=

"0000000" ; -- 0 0%
"0000001" ; -- 1 1%
"0000011" ; -- 2 3%
"0000100" ; -- 3 4%
"0000101"
; -- 4 6%
"0000111"
; -- 5 7%
"0001001"
; -- 6 9%
"0001011"; -- 7 11%
"0001100"
; -- 8 12%
"0001110"
; -- 9 14%
"0001111"
; -- 10 15%
"0010001"
; -- 11 17%
"0010011"
; -- 12 19%
"0010100"
; -- 13 20%
"0010110"
; -- 14 22%
"0010111"
; -- 15 23%
"0011001"
; -- 16 25%
"0011010"
; -- 17 26%
"0011100"
; -- 18 28%
"0011110"
; -- 19 30%
"0011111"
; -- 20 31%
"0100001"
; -- 21 33%
"0100010"
; -- 22 34%
"0100100"
; -- 23 36%
"0100110"
; -- 24 38%
"0100111"
; -- 25 39%
"0101001"
; -- 26 41%
"0101010"
; -- 27 42%
"0101100"
; -- 28 44%
"0101110"
; -- 29 46%
"0101111"
; -- 30 47%
"0110001"
; -- 31 49%
"0110010"
; -- 32 50%
"0110100"
; -- 33 52%
"0110101"
; -- 34 53%
"0110111"
; -- 35 55%
"0111001"
; -- 36 57%
"0111011"
; -- 37 58%
"0111100"
; -- 38 60%
"0111101"
; -- 39 61%
"0111111"
; -- 40 63%
"1000001"
; -- 41 65%
"1000010"
; -- 42 66%

pg. 132

when "101011" => Porcentaje <= "1000100"

; -- 43 68%
when "101100" => Porcentaje <= "1000110"
; -- 44 69%
when "101101" => Porcentaje <= "1000111"; -- 45 71%
when "101110" => Porcentaje <= "1001001"
; -- 46 73%
when "101111" => Porcentaje <= "1001010"
; -- 47 74%
when "110000" => Porcentaje <= "1001100"
; -- 48 76%
when "110001" => Porcentaje <= "1001101"
; -- 49 77%
when "110010" => Porcentaje <= "1001111"
; -- 50 79%
when "110011" => Porcentaje <= "1010000"
; -- 51 80%
when "110100" => Porcentaje <= "1010010" ; -- 52 82%
when "110101" => Porcentaje <= "1010100"
; -- 53 84%
when "110110" => Porcentaje <= "1010101"
; -- 54 85%
when "110111" => Porcentaje <= "1010111"
; -- 55 87%
when "111000" => Porcentaje <= "1011000"
; -- 56 88%
when "111001" => Porcentaje <= "1011010"
; -- 57 90%
when "111010" => Porcentaje <= "1011100"
; -- 58 92%
when "111011" => Porcentaje <= "1011101"
; -- 59 93%
when "111100" => Porcentaje <= "1011111"
; -- 60 95%
when "111101" => Porcentaje <= "1100000"
; -- 61 96%
when "111110" => Porcentaje <= "1100010"
; -- 62 98%
when "111111" => Porcentaje <= "1100100"
; -- 63 100%
when others => Porcentaje <= "0000000"
; -- 64
end case;
end process;
--============================================
-- Mapeo Display_Mux
--============================================
Inst_disp_hex_mux: Dis_hex_mux
clk => clk,
reset => '0',
hex3 => std_logic_vector
hex2 => std_logic_vector
hex1 => std_logic_vector
hex0 => "1110",
dp_in => "1111",
an => an,
sseg => sseg
);

PORT MAP(

(hex (11 downto 8)),

(hex (7 downto 4)),
(hex (3 downto 0)),

--================================
-- Salida a Display
--================================
Porcentaje_aux (6 downto 0) <= Porcentaje;
hex <= bin_a_bcd(Porcentaje_aux);
end Behavioral;
Cdigo 12.1 - Mdulo Porcentaje.

Como se observa el cdigo anterior es til para mostrar el porcentaje

de ancho de pulso de la seal PWM, dicho porcentaje es introducido por el

pg. 133

usuario por medio de los 6 bits de la seal entrada (El clculo se realiz por
simple regla de tres).
Ahora solo queda mapear este componente dentro del mdulo PWM
para que el proyecto quede terminado, el cdigo del proyecto ya terminado
se muestra en el recuadro de cdigo 12.2.
library IEEE;
use IEEE.STD_LOGIC_1164.ALL;
use IEEE.NUMERIC_STD.ALL;
entity PWM is
port (pwm_pos : in std_logic_vector (5 downto 0); -- Posicion
pwm_clk : in std_logic; -- Reloj
pwm_reset: in std_logic; -- Reset.
pwm_o : out std_logic; -- Seal PWM
an: out std_logic_vector (3 downto 0);
sseg: out std_logic_vector (7 downto 0));
end PWM;
architecture Behavioral of PWM is
--==================================
-- Instalacion de Contador
--==================================
component contador is
port (clk : in std_logic; -- Reloj
reset : in std_logic;
q : out std_logic_vector (5 downto 0)); --Salida
end component;
--==================================
-- Instalacion de Comparador
--==================================
component comparador is
port (opa : in std_logic_vector(5 downto 0); -- Operador A
opb : in std_logic_vector(5 downto 0); -- Operador B
G : out std_logic);
end component;
--==================================
-- Instalacion Displays a porcentaje
--================================== o algo asi?
COMPONENT Porcentaje
PORT(
Entrada : IN std_logic_vector(5 downto 0);
clk : IN std_logic;
an : OUT std_logic_vector(3 downto 0);
sseg : OUT std_logic_vector(7 downto 0)
);
END COMPONENT;

pg. 134

signal ntic : std_logic_vector (5 downto 0); -- Numero de tics de

reloj
signal sg : std_logic; -- Seal G
begin
--=================================================
--Mapeo del contador y comparador
--=================================================
CONT1: contador port map (clk=>pwm_clk, q=>ntic, reset=>pwm_reset);
COMP1: comparador port map (opa=>ntic, opb=>pwm_pos, G=>sg);
-- Seal PWM de salida
pwm_o<= sg;
--===================================================
--Mapeo salida a display porcentaje PWM
--===================================================
Inst_Porcentaje: Porcentaje PORT MAP(
Entrada => pwm_pos,
clk => pwm_clk,
an => an,
sseg => sseg
);
end Behavioral;
Cdigo 12.2 Mdulo PWM

Como se observa solo fue mapeado el mdulo de Porcentaje dentro

del mdulo PWM para que este pueda mostrar el porcentaje del ancho de
pulso en el display.
Finalmente Compile y Pruebe el funcionamiento del Programa con la
Tarjeta Basys2.

Practica 13 Seal PWM con Potencimetro.

En esta prctica se generar una seal PWM la cal ser variada a
travs de un potencimetro y se mostrar el porcentaje del ciclo de trabajo
en los displays.
La seal elctrica analgica proporcional proveniente del
potencimetro, necesita ser previamente convertida a una seal digital que
sea entendible para la tarjeta Basys2. Para ello se utilizar un convertidor
analgico digital (ADC0820) de 8 bits; aunque solo se utilizarn los 6 bits

pg. 135

ms significativos por cuestiones de comodidad. En la figura 13.1 se muestra

el diagrama del convertidor ADC0820 y en la figura 13.2 su conexin hacia la
Tarjeta Basys2

Figura 13.1 Diagrama convertidor ADC0820

El funcionamiento es sencillo; se hace variar el potencimetro con lo

cual varia su resistencia y a su vez por ley de ohm obtenemos una variacin
de voltaje de 0 a 5 V. El ADC0820 se encarga de transformar ese voltaje a
un valor binario (0 o 1) el cual es ledo por la tarjeta Basys2. Dependiendo
del valor binario obtenido hacemos la comparacin para sacar el valor PWM
deseado y el porcentaje del ciclo de trabajo que se mostrar en los displays.

Cabe mencionar que para que el ADC0820 funcione correctamente

necesita una seal de reloj. La seal de reloj de la tarjeta Basys2 es
demasiado rpida para el convertidor por lo que crearemos pulsos de menor
frecuencia a travs de la tarjeta.
El procedimiento del generador de pulsos se muestra en el recuadro
de cdigo 13.1. Notes el uso de un generador de ticks de 10ms basado en
el reloj de 50Mhz de la tarjeta y una FSM que manda la salida a 0 o 1
dependiendo del tick generado. Por lo tanto se tendrn pulsos de una
duracin de 100hz.

pg. 136

Figura 13.2 Conversin y Acondicionamiento de Seal

library IEEE;
use IEEE.STD_LOGIC_1164.ALL;
use IEEE.NUMERIC_STD.ALL;
entity Contador_Ticks_10ms is
Port ( clk : in STD_LOGIC;
Pulso : out STD_LOGIC);
end Contador_Ticks_10ms;
architecture Behavioral of Contador_Ticks_10ms is
constant N: integer:=19; -- 2^N * 20ns = 10 ms reloj
signal q_reg, q_next: unsigned (N-1 downto 0);
signal Tick : std_logic;
type Sreg0_type is (Pulso_OFF, Pulso_ON);
signal state_reg, state_next: Sreg0_type;
begin
--===================================
--Contador que genera ticks de 10 ms
--===================================
process (clk)
begin

pg. 137

if (clk'event and clk='1') then

q_reg <= q_next;
state_reg <= state_next;
end if;
end process;
-- next-state logic
q_next <= q_reg + 1;
-- tick de salida
Tick <= '1' when q_reg=0 else '0';

Sreg0_machine: process (state_reg, Tick)

begin
state_next <= state_reg; -- Estado Inicial
Pulso <= '0'; -- Seal Default
case state_reg is
when Pulso_OFF =>
if Tick = '1' then
state_next <=
Pulso <= '1';
else
state_next <=
Pulso <= '0';
end if;
when Pulso_ON =>
if Tick = '1' then
state_next <=
Pulso <= '0';
else
state_next <=
Pulso <= '1';
end if;
end case;
end process;

Pulso_ON;

Pulso_OFF;

Pulso_OFF;

Pulso_ON;

end Behavioral;
Cdigo 13.1 Generador de pulsos

Reutilizando todos los mdulos de la prctica 12 se mapea el

generador de pulsos como se muestra en el recuadro de cdigo 13.2.
entity PWM is
port (pwm_pos : in std_logic_vector (5 downto 0); -- Posicion
pwm_clk : in std_logic; -- Reloj

pg. 138

pwm_reset: in std_logic; -- Reset.

pwm_o : out std_logic; -- Seal PWM
an: out std_logic_vector (3 downto 0);
sseg: out std_logic_vector (7 downto 0));
end PWM;
architecture Behavioral of PWM is
--==================================
-- Instalacion de Contador
--==================================
component contador is
port (clk : in std_logic; -- Reloj
reset : in std_logic;
q : out std_logic_vector (5 downto 0)); --Salida
end component;
--==================================
-- Instalacion de Comparador
--==================================
component comparador is
port (opa : in std_logic_vector(5 downto 0); -- Operador A
opb : in std_logic_vector(5 downto 0); -- Operador B
G : out std_logic);
end component;
--==================================
-- Instalacion Displays a porcentaje
--================================== o algo asi?
COMPONENT Porcentaje
PORT(
Entrada : IN std_logic_vector(5 downto 0);
clk : IN std_logic;
an : OUT std_logic_vector(3 downto 0);
sseg : OUT std_logic_vector(7 downto 0)
);
END COMPONENT;
signal ntic : std_logic_vector (5 downto 0); -- Numero de tics de
reloj
signal sg : std_logic; -- Seal G
begin
--=================================================
--Mapeo del contador y comparador
--=================================================
CONT1: contador port map (clk=>pwm_clk, q=>ntic, reset=>pwm_reset);
COMP1: comparador port map (opa=>ntic, opb=>pwm_pos, G=>sg);
-- Seal PWM de salida
pwm_o<= sg;
--===================================================

pg. 139

--Mapeo salida a display porcentaje PWM

--===================================================
Inst_Porcentaje: Porcentaje PORT MAP(
Entrada => pwm_pos,
clk => pwm_clk,
an => an,
sseg => sseg
);
--===================================================
--Mapeo Generador 10 ms
--===================================================
Inst_Contador_Ticks_10ms: Contador_Ticks_10ms PORT MAP(
clk => pwm_clk,
Pulso => Pulso
);

end Behavioral;
Cdigo 13.2 Seal PWM con Generador de Pulsos de 10ms

Finalmente cheque sintaxis, compile y asigne los pines necesarios

tomando en cuenta que esta vez se utilizan 6 entradas de los conectores
PMod que representan los 6 bits anteriormente utilizados por los switches.
Adems de una salida que ser utilizada por el ADC0820, la cual debe ser
debidamente acondicionada.
El resultado de la prctica es mostrado en el siguiente enlace:

Practica 14 - Control de un motor debido a la seal de un sensor.

En la siguiente prctica se simular el Control de una banda
transportadora la cual detendr o activar el motor que la hace girar una vez
que el sensor que cuenta las piezas llegue a 15. Adems se integra un botn
de reset que regresa a 0 la cuenta y un Stop de Emergencia que detiene el
proceso en cualquier momento. El nmero de piezas contadas se muestra en
los displays de la tarjeta Basys2
Como sensor de presencia se utilizar un fotorresistor, el cual es un
componente electrnico cuya resistencia disminuye con el aumento de
intensidad de luz incidente. Sus siglas son: LDR y se originan de su nombre
en ingls light-dependent resistor. Su cuerpo est formado por una clula o
celda y dos patillas (figura 14.1).
pg. 140

Figura 14.1 - Fotorresistor

A travs de un CI LM555 conectado al fotorresistor se obtendrn

seales de 0 o 1 cuando haya o no incidencia de luz. Esto ser til al pasar
un objeto el cul evitar el paso de luz hacia el sensor lo que indicar
presencia de pieza que ser contada por la tarjeta Basys2.
El diseo del sensor de presencia es mostrado en la figura 14.2
notese el uso de resistores y capacitores extras. El potencimetro utilizado
en el sensor de presencia sirve para variar la sensibilidad.

Figura 14.2 Sensor de presencia

La seal proporcionada por el sensor debe ser acondicionada por lo

que se agrega un optoacoplador para proteger a la Tarjeta Basys2 y unos

pg. 141

resistores de 1K para disminuir el voltaje a 3.3V. El circuito se muestra en

la figura 14.3.

Figura 14.3 Circuito para el acondicionamiento de seal, con salida hacia el FPGA.

Para comprender el cdigo utilizado en el proyecto observe el

diagrama a bloques que se muestra en la figura 14.4

Figura 14.4 Diagrama a bloques del Proyecto

pg. 142

Existe un problema con el sensor de presencia, el cual envia pulsos

parasitos que afectan la cuenta. Ser necesario implementar un circuito
antirrebotes (debounce) como el del mdulo debounce_fsm del recuadro de
cdigo 10.1 de la Prctica 10. Observe la diferencia en el recuadro de cdigo
14.1 donde se ha agregado un detector de flancos extra llamado
Flanco_Enable que ser de utilidad en el siguiente mdulo.
library IEEE;
use IEEE.STD_LOGIC_1164.ALL;
use IEEE.NUMERIC_STD.ALL;
entity Debounce_fsm is
Port ( clk : in STD_LOGIC;
reset : in STD_LOGIC;
sw : in STD_LOGIC;
Flanco_Enable : out STD_LOGIC);
end Debounce_fsm;
architecture Behavioral of Debounce_fsm is
constant N: integer:=19; -- 2^N * 20ns = 10 ms reloj
signal q_reg, q_next: unsigned (N-1 downto 0);
signal m_tick: std_logic;
signal db, db_reg: std_logic;
--enumeracin estados
type eg_state_type is (zero, wait1_1, wait1_2, wait1_3,
one, wait0_1, wait0_2, wait0_3);
signal state_reg, state_next: eg_state_type;
begin
--===================================
--Contador que genera ticks de 10 ms
--===================================
process (clk,reset)
begin
if (clk'event and clk='1') then
q_reg <= q_next;
end if;
end process;
-- next-state logic
q_next <= q_reg + 1;
-- tick de salida
m_tick <= '1' when q_reg=0 else '0';
--===================================
-- Debounce FMS
--===================================

pg. 143

-- Registro de Estado
process (clk, reset)
begin
if (reset = '1') then
state_reg <= zero;
elsif (clk'event and clk='1') then
state_reg <= state_next;
end if;
end process;
-- logica de estados y salidas
process (state_reg, sw, m_tick)
begin
state_next <= state_reg; -- parametro default
db <= '0'; -- default 0
case state_reg is
when zero =>
if sw = '1' then
state_next <= wait1_1;
end if;
when wait1_1 =>
if sw = '0' then
state_next <= zero;
else
if m_tick = '1' then
state_next <= wait1_2;
end if;
end if;
when wait1_2 =>
if sw = '0' then
state_next <= zero;
else
if m_tick = '1' then
state_next <= wait1_3;
end if;
end if;
when wait1_3 =>
if sw = '0' then
state_next <= zero;
else
if m_tick = '1' then
state_next <= one;
end if;
end if;
when one =>
db <= '1';
if sw = '0' then
state_next <= wait0_1;
end if;
when wait0_1 =>
db <= '1';

pg. 144

if sw = '1' then
state_next <= one;
else
if m_tick = '1' then
state_next <= wait0_2;
end if;
end if;
when wait0_2 =>
db <= '1';
if sw = '1' then
state_next <= one;
else
if m_tick = '1' then
state_next <= wait0_3;
end if;
end if;
when wait0_3 =>
db <= '1';
if sw = '1' then
state_next <= one;
else
if m_tick = '1' then
state_next <= zero;
end if;
end if;
end case;
end process;
--====================================
--Detector de Flancos
--====================================
process(clk)
begin
if (clk'event and clk='1') then
db_reg <= db;
end if;
end process;
--db_reg <= db when m_tick = '1' else db_reg;
Flanco_Enable <= ((not db_reg) and db);

end Behavioral;
Cdigo 14.1 Modulo debounce_FSM con Flanco_Enable.

Se reutilizar el mdulo disp_hex_mux (Cdigo 7.1) utilizado en la

ALU y prcticas anteriores, el cual se encarga de multiplexear y mandar la
salida a los displays.

pg. 145

A continuacin se mapean los mdulos debounce_FSM y

disp_hex_mux al mdulo Sensor_Prox el cual generar un pulso cada que
el sensor de presencia detecte 15 piezas. Observe el uso de la funcin
bin_a_bcd y el diseo de un contador de 4 bits necesario para la cuenta de
las piezas.
library IEEE;
use IEEE.STD_LOGIC_1164.ALL;
--use IEEE.STD_LOGIC_UNSIGNED.ALL;
use IEEE.NUMERIC_STD.ALL;
entity Sensor_Prox is
Port ( Sensor : in STD_LOGIC;
reset: in STD_LOGIC;
clk : in STD_LOGIC;
Cuenta : out STD_LOGIC_VECTOR (3 downto 0);
an : out STD_LOGIC_VECTOR (3 downto 0);
cuenta_max: out STD_LOGIC;
sseg : out STD_LOGIC_VECTOR (7 downto 0)
);
end Sensor_Prox;

architecture Behavioral of Sensor_Prox is

--============================================
--Instantiation Antirrebotes
--============================================
COMPONENT Debounce_fsm
PORT(
clk : IN std_logic;
reset : IN std_logic;
sw : IN std_logic;
Flanco_Enable : OUT std_logic
);
END COMPONENT;
--============================================
--Instantiation Display_Mux
--============================================
COMPONENT disp_hex_mux
PORT(
clk : IN std_logic;
reset : IN std_logic;
hex3 : IN std_logic_vector(3 downto 0);
hex2 : IN std_logic_vector(3 downto 0);
hex1 : IN std_logic_vector(3 downto 0);
hex0 : IN std_logic_vector(3 downto 0);
dp_in : IN std_logic_vector(3 downto 0);
an : OUT std_logic_vector(3 downto 0);
sseg : OUT std_logic_vector(7 downto 0)

pg. 146

);
END COMPONENT;
-===========================================================================
========
-- Funcin que recibe un valor binario de 4 bits y devuelve su
representacin
-- BCD de tres dgitos (8 bits).
-- Usa el algoritmo de corrimiento y suma 3.
-===========================================================================
========
function

bin_a_bcd(

bin

unsigned(3

downto

0))

return

unsigned is
variable i : integer := 0;
variable resultado : unsigned(

downto

:=

"00000000";
variable copiabin : unsigned( 3 downto 0 ) := bin;
begin
-- Aqu va el cdigo de la funcin
for i in 0 to 3 loop
resultado( 7 downto 1 ) := resultado( 6 downto 0
);
resultado( 0 ) := copiabin( 3 );
copiabin( 3 downto 1 ) := copiabin( 2 downto 0 );
copiabin( 0 ) := '0';
-- unidades
if i < 3 and resultado( 3 downto 0 ) > "0100"
then
resultado( 3 downto 0 ) := resultado( 3
downto 0 ) + "0011";
end if;
-- decenas
if i < 3 and resultado( 7 downto 4 ) > "0100"
then
resultado( 7 downto 4 ) := resultado( 7
downto 4 ) + "0011";
end if;
-- centenas
--if i < 7 and resultado( 11 downto 8 ) > "0100"
then
--

resultado( 11 downto 8 ) := resultado( 11

downto 8 ) + "0011";
--end if;
end loop;
return resultado;

pg. 147

end bin_a_bcd;
--============================================
--Seales Auxiliares (Reg Reloj y cuenta)
--============================================
constant N: integer:=4; -- 2^N * 20ns = 10 ms reloj
signal q_reg, q_next: unsigned (N-1 downto 0);
signal sensor_enable : STD_LOGIC;
-- Seales Display
signal hex0: unsigned (7 downto 0);
begin
--============================================
--Mapeo Antirrebotes
--============================================
Inst_Debounce_fsm: Debounce_fsm PORT MAP(
clk => clk ,
reset => reset,
sw => Sensor,
Flanco_Enable => sensor_enable
);
--============================================
-- Mapeo Display_Mux
--============================================
Inst_disp_hex_mux: disp_hex_mux PORT MAP(
clk => clk,
reset => reset,
hex3 => "0000",
hex2 => "0000",
hex1 => std_logic_vector (hex0 (7 downto 4)),
hex0 => std_logic_vector (hex0 (3 downto 0)),
dp_in => "1111",
an => an,
sseg => sseg
);

--===================================
--Contador que genera ticks de 10 ms
--===================================
process (clk,reset)
begin
if reset = '1' then
q_reg <= (others => '0');
elsif(clk'event and clk='1') then
q_reg <= q_next;
end if;
end process;

pg. 148

-- next-state logic
q_next <= q_reg + 1 when (sensor_enable = '1') else
q_reg;

--================
--Cast de salida
--================
Cuenta <= std_logic_vector (q_reg);
Cuenta_max <= '1' when q_reg = 15 else '0';
--====================================
-- Salida a Displays y conversin
--====================================
hex0 <= bin_a_bcd(q_reg);
end Behavioral;
Cdigo 14.2 Mdulo Sensor_Prox.

Finalmente cree un mdulo llamado Motor_Sensor en el cual se

agregarn el mdulo Sensor_Prox. Una vez mas el diseo estructural con
VHDL demuestra ser un arma escencial para el desarrollo de este proyecto y
de igual forma viable para el diseo del control de procesos complejos.
El mdulo Motor_Sensor se encargar por medio de una FSM de
encender y apagar el motor dependiendo de la cuenta proporcionada por el
mdulo Sensor_Prox; a su vez controla el stop de emergencia que detendr
el proceso cuando sea activado. Observe el cuadro de cdigo 14.3

library IEEE;
use IEEE.STD_LOGIC_1164.ALL;
use IEEE.NUMERIC_STD.ALL;
entity Motor_Sensor is
port (
CLK: in STD_LOGIC;
Sensor: in STD_LOGIC;
reset: in STD_Logic;
Cuenta: out std_logic_vector (3 downto 0);
an: out std_logic_vector (3 downto 0);
sseg: out std_logic_vector (7 downto 0);
Stop_emerg: in STD_LOGIC;
Motor: out STD_LOGIC);
end;
architecture motor_on_arch of Motor_Sensor is

-- SYMBOLIC ENCODED state machine: Sreg0

pg. 149

type Sreg0_type is (Motor_OFF, Motor_ON);

signal state_reg, state_next: Sreg0_type;
signal cuenta_reg: std_logic;
signal cuenta_flanco: std_logic;
signal cuenta_max: std_logic;
--==========================================
--Inst Sensor_Prox
--==========================================
COMPONENT Sensor_Prox
PORT(
Sensor : IN std_logic;
reset : IN std_logic;
clk : IN std_logic;
Cuenta : OUT std_logic_vector(3 downto 0);
an : OUT std_logic_vector(3 downto 0);
cuenta_max : OUT std_logic;
sseg : OUT std_logic_vector(7 downto 0)
);
END COMPONENT;

begin
--========================================
-- Mapeo Sensor_Prox
--========================================
Inst_Sensor_Prox: Sensor_Prox PORT MAP(
Sensor => Sensor,
reset => reset,
clk => CLK,
Cuenta => Cuenta,
an => an,
cuenta_max => cuenta_max,
sseg => sseg
);
--=========================================
--Detector de Flancos
--=========================================
process(CLK)
begin
if (CLK'event and CLK='1') then
cuenta_reg <= cuenta_max;
end if;
end process;
--db_reg <= db when m_tick = '1' else db_reg;
cuenta_flanco <= ((not cuenta_reg) and cuenta_max);
--==========================================

pg. 150

-- Estado del Registro

--==========================================
Process (CLK, Stop_emerg)
begin
if (Stop_emerg = '1') then
state_reg <= Motor_OFF;
elsif CLK'event and CLK = '1' then
state_reg <= state_next;
end if;
end process;
--==========================================
-- Lgica de Estado Siguiente y Salidas
--==========================================

Sreg0_machine: process (state_reg, cuenta_flanco)

begin
state_next <= state_reg; -- Estado Inicial
Motor <= '0'; -- Seal Default
case state_reg is
when Motor_OFF =>
if cuenta_flanco = '1' then
state_next <= Motor_ON;
Motor <= '1';
else
state_next <= Motor_OFF;
Motor <= '0';
end if;
when Motor_ON =>
if cuenta_flanco = '1' then
state_next <= Motor_OFF;
Motor <= '0';
else
state_next <= Motor_ON;
Motor <= '1';
end if;
end case;
end process;

end motor_on_arch;
Cdigo 14.3 Mdulo Motor_Sensor.

Por ltimo haga un chequeo de sintaxis, compile y asigne los pines

necesarios. Recuerde hacer el acondicionamiento de seal necesario para la
entrada del sensor de presencia y la salida que controla el motor (Figura 4.1)

pg. 151

Prctica 15 - Seal PWM controlada con Pushbuttons

Seal PWM que vara su ciclo de trabajo pulsando los pushbuttons de
la tarjeta basys2.

Mdulos Necesarios:
Contador Cdigo 11.1
Comparador Cdigo 11.2
Disp_hex_mux Cdigo 7.1
Contador_UP_DOWN Cdigo 15.2

entity pwm_unit is
Port ( --pwm_pos : in
STD_LOGIC_VECTOR (5 downto 0); -- BITS DE
ENTRADA SWITCHES
pwm_clk : in STD_LOGIC;
P_up : in STD_LOGIC;
P_down : in STD_LOGIC;
--sal: out std_logic;
--Pulso: out std_logic;
--led_enable: out std_logic;
--start: in std_logic;
pwm_motor: out std_logic;
pwm_led:out std_logic;
an: out std_logic_vector (3 downto 0);
sseg: out std_logic_vector (7 downto 0));
end pwm_unit;
architecture Behavioral of pwm_unit is
COMPONENT Contador_UP_DOWN
PORT(
P_up1 : IN std_logic;
P_down1 : IN std_logic;
clk : IN std_logic;
reset : IN std_logic;
cuenta : OUT std_logic_vector(7 downto 0);
an : OUT std_logic_vector(3 downto 0);
sseg : OUT std_logic_vector(7 downto 0)
);
END COMPONENT;
COMPONENT contador
PORT(
clk : IN std_logic;
reset : IN std_logic;
q : OUT std_logic_vector(7 downto 0)
);
END COMPONENT;
component comparador is

pg. 152

port (opa : in std_logic_vector(7 downto 0);

opb : in std_logic_vector(7 downto 0);
G
: out std_logic);
end component;

-- Operador A
-- Operador B

signal ntic
: std_logic_vector (7 downto 0); -- Numero de tics de
reloj
--signal ntic_ms: std_logic_vector (3 downto 0); -- 8 bits menos peso
de ntic
--signal sg
: std_logic; -- Seal G
signal pwm_o : std_logic;
signal pwm_pos : std_logic_vector (7 downto 0);

--Inicio de Arquitectura
begin
--enable<= not start;
--led_enable<= start;
CONT1: contador
port map (clk=>pwm_clk, q=>ntic, reset=> '0');
COMP1: comparador port map (opa=>ntic, opb=>pwm_pos, G=> pwm_o);
Inst_Contador_UP_DOWN: Contador_UP_DOWN PORT MAP(
P_up1 => P_up,
P_down1 => P_down,
clk => pwm_clk,
reset => '0',
cuenta => pwm_pos,
an => an,
sseg => sseg
);

-- Obtener los 8 bits menos significativos del contador

-- Seal PWM de salida
--pwm_o <= sg; --(not ntic(8)) and (not ntic(9)) and (not ntic(10))
--and (not sg);
--sal <= pwm_o;
pwm_led <= pwm_o;
pwm_motor <= pwm_o;

end Behavioral;
Cdigo 15.1 Pwm_unit

pg. 153

El cdigo 15.2 es mapeado hacia el top module Pwm_unit. El

contador_UP_DOWN se encarga de incrementar o disminuir una cuenta
cada que obtengamos un tick de reloj y un pulso filtrado a travs de un
detector de flancos de los push buttons. Observe el mapeo de los dems
mdulos para mostrar la cuenta de 0 a 100 equivalente al porcentaje de la
seal PWM en los displays y el uso de la funcin bin_a_bcd.
entity Contador_UP_DOWN is
Port ( P_up1 : in STD_LOGIC;
P_down1 : in STD_LOGIC;
clk : in STD_LOGIC;
reset : in STD_LOGIC;
cuenta: out std_logic_vector (7 downto 0);
an: out std_logic_vector (3 downto 0);
sseg: out std_logic_vector (7 downto 0));
end Contador_UP_DOWN;
architecture Behavioral of Contador_UP_DOWN is
--signal db_reg_up1, db_reg_down1 : std_logic;
--signal db_up1, db_down1 : std_logic;
signal conta : natural;
signal hex : unsigned (11 downto 0);
constant N: integer:=22; -- 2^N * 20ns = 0.6 s reloj
signal q_reg, q_next: unsigned (N-1 downto 0);
signal Tick : std_logic;
-===========================================================================
========
-- Funcin que recibe un valor binario de 12 bits y devuelve su
representacin
-- BCD de tres dgitos (12 bits).
-- Usa el algoritmo de corrimiento y suma 3.
-===========================================================================
========
function bin_a_bcd( bin : unsigned(11 downto 0)) return unsigned is
variable i : integer := 0;
variable resultado : unsigned( 11 downto 0 ) := "000000000000";
variable copiabin : unsigned( 11 downto 0 ) := bin;
begin
-- Aqu va el cdigo de la funcin
for i in 0 to 11 loop
resultado( 11 downto 1 ) := resultado( 10 downto 0 );
resultado( 0 ) := copiabin( 11 );
copiabin( 11 downto 1 ) := copiabin( 10 downto 0 );

pg. 154

copiabin( 0 ) := '0';
-- unidades
if i < 11 and resultado( 3 downto 0 ) > "0100" then
resultado( 3 downto 0 ) := resultado( 3 downto 0 ) +
"0011";
end if;
-- decenas
if i < 11 and resultado( 7 downto 4 ) > "0100" then
resultado( 7 downto 4 ) := resultado( 7 downto 4 ) +
"0011";
end if;
-- centenas
if i < 11 and resultado( 11 downto 8 ) > "0100" then
resultado( 11 downto 8 ) := resultado( 11 downto 8 ) +
"0011";
end if;
-- millares
--if i < 15 and resultado (15 downto 12) > "0100" then
-resultado ( 15 downto 12 ) := resultado ( 15 downto 12
) + "0011";
--end if;
end loop;
return resultado;
end bin_a_bcd;

--==============================================
--Display instansiacin
--==============================================
COMPONENT disp_hex_mux
PORT(
clk : IN std_logic;
reset : IN std_logic;
hex3 : IN std_logic_vector(3 downto 0);
hex2 : IN std_logic_vector(3 downto 0);
hex1 : IN std_logic_vector(3 downto 0);
hex0 : IN std_logic_vector(3 downto 0);
dp_in : IN std_logic_vector(3 downto 0);
an : OUT std_logic_vector(3 downto 0);
sseg : OUT std_logic_vector(7 downto 0)
);
END COMPONENT;
begin
--====================================
--Detector de Flancos

pg. 155

--====================================
--process(clk)
--begin
-if (clk'event and clk='1') then
-db_reg_up1 <= P_up1;
-db_reg_down1 <= P_down1;
-end if;
--end process;

--db_up1 <= ((not db_reg_up1) and P_up1);

--db_down1 <= ((not db_reg_down1) and P_down1);

--=============================================
-- Generador de Ticks de 0.6 s
--=============================================

process (clk)
begin
if (clk'event and clk='1') then
q_reg <= q_next;
end if;
end process;
-- next-state logic
q_next <= q_reg + 1;
-- tick de salida
Tick <= '1' when q_reg=0 else '0';

--=============================================
-- Contador Up / Down
--=============================================
P_conta: Process (reset, clk)
begin
if reset = '1' then
conta <= 0;
elsif clk'event and clk='1' then
if Tick = '1' and P_up1 = '1' then
if conta /= 100 then
conta <= conta + 1;
end if;
elsif Tick = '1' and P_down1 = '1' then
if conta /= 0 then
conta <= conta - 1;
end if;
end if;
end if;
end process;

pg. 156

hex <= bin_a_bcd(to_unsigned (conta,12));

cuenta <= std_logic_vector ( to_unsigned (conta, 8));
--==============================================
-- Mapeo Display
--==============================================
Inst_disp_hex_mux: disp_hex_mux PORT MAP(
clk => clk,
reset => reset,
hex3 => std_logic_vector (hex (11 downto 8)),
hex2 => std_logic_vector (hex (7 downto 4)),
hex1 => std_logic_vector (hex (3 downto 0)),
hex0 => "1110",
dp_in => "1101",
an => an ,
sseg => sseg
);

end Behavioral;
Cdigo 15.2 Contador_UP_DOWN

Compile y Pruebe el funcionamiento del Programa con la Tarjeta

Basys2.

Prctica 16 - Contador Parametrizable (Mod_m_Counter)

En la siguiente prctica se disear un contador parametrizable que
cuenta desde 0 a m-1 y vuelve a iniciar.
El cdigo VHDL necesario es mostrado en el recuadro de cdigo 16.1.
Observe el uso de los parmetros genricos los cuales pueden ser
modificados en futuras instanciaciones al determinar un valor en la
inicializacin de componentes.
Library IEEE;
use IEEE.STD_LOGIC_1164.ALL;
use IEEE.NUMERIC_STD.ALL;
-- A mod-m counter counts from 0 to m 1 and wraps around.
-- One is M, which specifies the limit, m, and the other is N, which
specifies the
-- number of bits needed and should be equal to (log2*M) .

pg. 157

-===========================================================================
=======
entity mod_m_counter is
generic (
N: integer := 6; -- numero de bits
M: integer := 40 MOD-M
);
Port ( clk : in STD_LOGIC;
reset : in STD_LOGIC;
max_tick : out STD_LOGIC);
--q : out STD_LOGIC_VECTOR (N-1 downto 0));
end mod_m_counter;
architecture Behavioral of mod_m_counter is
signal r_reg: unsigned (N-1 downto 0);
signal r_next: unsigned (N-1 downto 0);

begin
-===========================================================================
=======
--Registro cambio de estado
-===========================================================================
=======
process (clk, reset)
begin
if (reset = 1) then
r_reg <= (others => 0);
elsif (clkevent and clk = 1) then
r_reg <= r_next;
end if;
end process;
-===========================================================================
========
--Logica de cambio de estado
-===========================================================================
========
r_next <= (others => 0) when r_reg = (M-1) else
r_reg + 1;
-===========================================================================

pg. 158

========
--Salida
-===========================================================================
========
--q <= std_logic_vector (r_reg);
max_tick <= 1 when r_reg = (M-1) else 0;
end Behavioral;
Cdigo 16.1 Mdulo mod_m_counter

Prctica 17 - FIFO Buffer

Un FIFO (first-in-first-out) buffer es un almacen elastico entre dos
subsitemas, como se muestra en el diagrama conceptual de la figura 17.1.
Cuenta con dos seales de control wr y rd, para escribir y leer
respectivamente. Cuando wr se encuentra en alto, la entrada de datos es
escrita en el buffer. La cabeza del FIFO buffer esta siempre disponible y
puede ser leida en cualquier momento. La seal de rd funciona como una
seal de borrado. Cuando la seal de rd se encuentra en alto, el primer
dato (la cabeza) del FIFO buffer es removida y el siguiente dato se queda
disponible.
La descripcin del FIFO Buffer que ser utilizado en prcticas
siguientes se muestra en el recuadro de cdigo 17.1.

Figura 17.1 Diagrama Conceptual FIFO Buffer

entity fifo is
generic (
B: natural :=8 ; -- 8 Numero de Bits
W: natural :=4 -- 4 Number of Address Bits
);
Port ( clk : in STD_LOGIC;
reset : in STD_LOGIC;

pg. 159

rd : in STD_LOGIC;
wr : in STD_LOGIC;
w_data : in STD_LOGIC_VECTOR (B-1 downto 0);
empty : out STD_LOGIC;
full : out STD_LOGIC;
r_data : out STD_LOGIC_VECTOR (B-1 downto 0));
end fifo;
architecture Behavioral of fifo is
type reg_file_type is array (2**W-1 downto 0) of
std_logic_vector (B-1 downto 0);
signal array_reg: reg_file_type;
signal w_ptr_reg, w_ptr_next, w_ptr_succ:
std_logic_vector (W-1 downto 0);
signal r_ptr_reg, r_ptr_next, r_ptr_succ:
std_logic_vector (W-1 downto 0);
signal full_reg, empty_reg, full_next, empty_next: std_logic;
signal wr_op: std_logic_vector (1 downto 0);
signal wr_en: std_logic;
begin
--=================================================================
--registro
--=================================================================
process (clk, reset)
begin
if (reset = '1') then
array_reg <= (others =>(others => '0'));
elsif (clk'event and clk='1') then
if wr_en='1' then
array_reg(to_integer(unsigned(w_ptr_reg)))
<= w_data;
end if;
end if;
end process;
-- Lectura del puerta
r_data <= array_reg(to_integer(unsigned(r_ptr_reg)));
-- Write Enabled solo cuando FIFO no esta lleno
wr_en <= wr and (not full_reg);
--==================================================================
-- FIFO control logic
--==================================================================
-- registro para leer y escribir punteros (pointers)
process(clk, reset)
begin
if (reset = '1') then
w_ptr_reg <= (others => '0');

pg. 160

r_ptr_reg <= (others => '0');

full_reg <= '0';
empty_reg <= '1';
elsif (clk'event and clk='1') then
w_ptr_reg <= w_ptr_next;
r_ptr_reg <= r_ptr_next;
full_reg <= full_next;
empty_reg <= empty_next;
end if;
end process;
-- successive pointer values
w_ptr_succ <= std_logic_vector(unsigned(w_ptr_reg)+1);
r_ptr_succ <= std_logic_vector(unsigned(r_ptr_reg)+1);
--===================================================================
--Logica de estado siguiente
--===================================================================
wr_op <= wr & rd;
process (w_ptr_reg, w_ptr_succ, r_ptr_reg, r_ptr_succ, wr_op,
empty_reg, full_reg)
begin
w_ptr_next <= w_ptr_reg;
r_ptr_next <= r_ptr_reg;
full_next <= full_reg;
empty_next <= empty_reg;
case wr_op is
when "00" => -- no op
when "01" => -- read
if (empty_reg /= '1') then -- not empty
r_ptr_next <= r_ptr_succ;
full_next <= '0';
if (r_ptr_succ = w_ptr_reg) then
empty_next <= '1';
end if;
end if;
when "10" => -- write
if (full_reg /= '1') then -- not full
w_ptr_next <= w_ptr_succ;
empty_next <= '0';
if (w_ptr_succ = r_ptr_reg) then
full_next <= '1';
end if;
end if;
when others => -- write /read
w_ptr_next <= w_ptr_succ;
r_ptr_next <= r_ptr_succ;
end case;
end process;

pg. 161

--salidas
full <= full_reg;
empty <= empty_reg;
end Behavioral;
Cdigo 17.1 Mdulo FIFO

Prctica 18 Comunicacin Serial Puerto PS2 Teclado

A travs de los siguientes mdulos se logra la comunicacin del puerto
PS2 de la tarjeta Basys2; se conecta un teclado para probarlo. El cdigo
enviado por el teclado es mostrado en los leds de la tarjeta.

Mdulos:
FIFO Cdigo 17.1
Mod_m_couter Cdigo 16.1
Kb_code Cdigo 18.1
Kb_monitor Cdigo 18.2
Key2ascii Cdigo 18.3
PS2_RX Cdigo 18.4
Kb_led Cdigo 18.5

El diagrama del conector PS2 y su conexin hacia la tarjeta Basys2 se

muestra en la figura 18.1.

Figura 18.1 Conector PS2 Tarjeta Basys2

-===========================================================================
==
-- PS2 keyboard last-releases key circuit
-===========================================================================
==
entity kb_code is

pg. 162

generic (W_SIZE: integer := 2); -- 2^W_SIZE words in FIFO

Port ( clk : in STD_LOGIC;
reset : in STD_LOGIC;
ps2d : in STD_LOGIC;
ps2c : in STD_LOGIC;
rd_key_code : in STD_LOGIC;
key_code : out STD_LOGIC_VECTOR (7 downto 0);
kb_buf_empty : out STD_LOGIC);
end kb_code;
architecture Behavioral of kb_code is
constant BRK: std_logic_vector (7 downto 0):= "11110000";
-- F0 (Break Code)
type statetype is (wait_brk, get_code);
signal state_reg, state_next: statetype;
signal scan_out, w_data: std_logic_vector (7 downto 0);
signal scan_done_tick, got_code_tick: std_logic;
begin
-===========================================================================
===
-- Instantiation PS2_RX_unit
-===========================================================================
===
PS2_RX_unit: entity work.PS2_RX (Behavioral)
port map ( clk => clk, reset => reset, rx_en => '1',
ps2d => ps2d, ps2c => ps2c,
rx_done_tick => scan_done_tick,
dout => scan_out);
--=================================================================
-- Instantiation FIFO Buffer
--=================================================================
fifo_key_unit: entity work.fifo (Behavioral)
generic map (B => 8, W => W_SIZE)
PORT MAP (clk => clk, reset => reset, rd => rd_key_code,
wr => got_code_tick, w_data => scan_out,
empty => kb_buf_empty, full => open,
r_data => key_code);
--=====================================================================
-- FSM to get the scan code after F0 received
--=====================================================================
process (clk, reset)
begin
if reset = '1' then

pg. 163

state_reg <= wait_brk;

elsif (clk'event and clk='1') then
state_reg <= state_next;
end if;
end process;
process (state_reg, scan_done_tick, scan_out)
begin
got_code_tick <= '0';
state_next <= state_reg;
case state_reg is
when wait_brk => -- wait for F0 of Break Code
if scan_done_tick = '1' and scan_out = BRK then
state_next <= get_code;
end if;
when get_code => -- get the following scan code
if scan_done_tick = '1' then
got_code_tick <= '1';
state_next <= wait_brk;
end if;
end case;
end process;
end Behavioral;
Cdigo 18.1 Mdulo kb_code

entity kb_monitor is
Port ( clk : in STD_LOGIC;
reset : in STD_LOGIC;
ps2d : in STD_LOGIC;
ps2c : in STD_LOGIC;
tx : out STD_LOGIC);
end kb_monitor;
architecture Behavioral of kb_monitor is
constant SP: std_logic_vector (7 downto 0) := "00100000";
-- blank space in ASCII
type statetype is (idle, send1, send0, sendb);
signal state_reg, state_next: statetype;
signal scan_data, w_data: std_logic_vector (7 downto 0);
signal scan_done_tick, wr_uart: std_logic;
signal ascii_code: std_logic_vector (7 downto 0);
signal hex_in: std_logic_vector (3 downto 0);
begin
--====================================================================
-- Inicializacion PS2 RECEIVER
--====================================================================
PS2_RX_unit: entity work.PS2_RX (Behavioral)

pg. 164

port map (clk => clk, reset => reset, rx_en => '1',
ps2d => ps2d, ps2c => ps2c,
rx_done_tick => scan_done_tick,
dout => scan_data);
--====================================================================
-- Inicializacion UART
--====================================================================
UART_unit: entity work.UART (Behavioral)
port map (clk => clk, reset => reset, rd_uart => '0',
wr_uart => wr_uart, rx => '1', w_data =>
w_data,
tx_full => open, rx_empty => open, r_data =>
open,
tx => tx);
--====================================================================
-- FSM para enviar 3 Caracteres ASCII
--====================================================================
-- REGISTROS DE ESTADO
process (clk, reset)
begin
if reset = '1' then
state_reg <= idle;
elsif (clk'event and clk = '1') then
state_reg <= state_next;
end if;
end process;
-- next state logic
process (state_reg, scan_done_tick, ascii_code)
begin
wr_uart <= '0';
w_data <= SP;
state_next <= state_reg;
case state_reg is
when idle => -- start when a scan code received
if scan_done_tick = '1' then
state_next <= send1;
end if;
when send1 => -- send higher hex char
w_data <= ascii_code;
wr_uart <= '1';
state_next <= send0;
when send0 => -- send lower hex char
w_data <= ascii_code;
wr_uart <= '1';
state_next <= sendb;
when sendb => -- send blank space char

pg. 165

w_data <= SP;

wr_uart <= '1';
state_next <= idle;
end case;
end process;
--========================================================================
-- Scan code to ASCII display
--========================================================================
-- se parte el codigo escaneado en 2 4-bit hex
hex_in <= scan_data (7 downto 4) when state_reg = send1 else
scan_data (3 downto 0);
-- hex digit a Codigo ASCII
with hex_in select
ascii_code <=
"00110000"
"00110001"
"00110010"
"00110011"
"00110100"
"00110101"
"00110110"
"00110111"
"00111000"
"00111001"
"01000001"
"01000010"
"01000011"
"01000100"
"01000101"
"01000110"

when
when
when
when
when
when
when
when
when
when
when
when
when
when
when
when

"0000",
"0001",
"0010",
"0011",
"0100",
"0101",
"0110",
"0111",
"1000",
"1001",
"1010",
"1011",
"1100",
"1101",
"1110",
others;

-----------------

0
1
2
3
4
5
6
7
8
9
A
B
C
D
E
F

end Behavioral;
Cdigo A.9 Mdulo Kb_monitor

entity key2ascii is
Port ( key_code : in STD_LOGIC_VECTOR (7 downto 0);
ascii_code : out STD_LOGIC_VECTOR (7 downto 0));
end key2ascii;
architecture Behavioral of key2ascii is
begin
with key_code select
ascii_code <=
"00110000" when "01000101", -- 0
"00110001" when "00010110", -- 1

pg. 166

"00110010"
"00110011"
"00110100"
"00110101"
"00110110"
"00110111"
"00111000"
"00111001"

when
when
when
when
when
when
when
when

"00011110",
"00100110",
"00100101",
"00101110",
"00110110",
"00111101",
"00111110",
"01000110",

---------

2
3
4
5
6
7
8
9

"01000001"
"01000010"
"01000011"
"01000100"
"01000101"
"01000110"
"01000111"
"01001000"
"01001001"
"01001010"
"01001011"
"01001100"
"01001101"
"01001110"
"01001111"
"01010000"
"01010001"
"01010010"
"01010011"
"01010100"
"01010101"
"01010110"
"01010111"
"01011000"
"01011001"
"01011010"

when
when
when
when
when
when
when
when
when
when
when
when
when
when
when
when
when
when
when
when
when
when
when
when
when
when

"00011100",
"00110010",
"00100001",
"00100011",
"00100100",
"00101011",
"00110100",
"00110011",
"01000011",
"00111011",
"01000010",
"01001011",
"00111010",
"00110001",
"01000100",
"01001101",
"00010101",
"00101101",
"00011011",
"00101100",
"00111100",
"00101010",
"00011101",
"00100010",
"00110101",
"00011010",

---------------------------

A
B
C
D
E
F
G
H
I
J
K
L
M
N
O
P
Q
R
S
T
U
V
W
X
Y
Z

"01100000"
"00101101"
"00111101"
"01011011"
"01011101"
"01011100"
"00111011"
"00100111"
"00101100"
"00101110"
"00101111"

when
when
when
when
when
when
when
when
when
when
when

"00001110",
"01001110",
"01010101",
"01010100",
"01011011",
"01011101",
"01001100",
"01010010",
"01000001",
"01001001",
"01001010",

------------

'
=
{
}
\
;

,
.
/

"00100000"
"00001101"
"00001000"
"00101010"

when
when
when
when

"00101001", -- (space)
"01011010", -- (enter, cr)
"01100110", -- (backspace)
others; -- *

pg. 167

end Behavioral;
Cdigo 18.2 Mdulo key2ascii

entity PS2_RX is
Port ( clk : in STD_LOGIC;
reset : in STD_LOGIC;
ps2d : in STD_LOGIC; -- key data
ps2c : in STD_LOGIC; -- key clock
rx_en : in STD_LOGIC;
rx_done_tick : out STD_LOGIC;
dout : out STD_LOGIC_VECTOR (7 downto 0));
end PS2_RX;
architecture Behavioral of PS2_RX is
type statetype is (idle, dps, load);
signal state_reg, state_next: statetype;
signal filter_reg, filter_next: std_logic_vector(7 downto 0);
signal f_ps2c_reg, f_ps2c_next: std_logic;
signal b_reg, b_next: std_logic_vector (10 downto 0);
signal n_reg, n_next: unsigned (3 downto 0);
signal fall_edge: std_logic;
begin
-=========================================================================
-- Filtro y detector de flancos --- ticks generados para ps2c
-=========================================================================
process(clk, reset)
begin
if reset = '1' then
filter_reg <= (others => '0');
f_ps2c_reg <= '0';
elsif (clk'event and clk = '1') then
filter_reg <= filter_next;
f_ps2c_reg <= f_ps2c_next;
end if;
end process;
filter_next <= ps2c & filter_reg(7 downto 1);
f_ps2c_next <= '1' when filter_reg = "11111111" else
'0' when filter_reg = "00000000" else
f_ps2c_reg;
fall_edge <= f_ps2c_reg and (not f_ps2c_next);
-=========================================================================
-- FSMD to extract the 8 - bit data
--

pg. 168

=========================================================================
process (clk, reset)
begin
if reset = '1' then
state_reg <= idle;
n_reg <= (others => '0');
b_reg <= (others => '0');
elsif (clk'event and clk = '1') then
state_reg <= state_next;
n_reg <= n_next;
b_reg <= b_next;
end if;
end process;
-- next state logic
process (state_reg, n_reg, b_reg, fall_edge, rx_en, ps2d)
begin
rx_done_tick <= '0';
state_next <= state_reg;
n_next <= n_reg;
b_next <= b_reg;
case state_reg is
when idle =>
if fall_edge = '1' and rx_en = '1' then
-- shift in start bit
b_next <= ps2d & b_reg (10 downto 1);
n_next <= "1001";
state_next <= dps;
end if;
when dps => -- 8 data + 1 parity + 1 stop
if fall_edge = '1' then
b_next <= ps2d & b_reg (10 downto 1);
if n_reg = 0 then
state_next <= load;
else
n_next <= n_reg - 1;
end if;
end if;
when load =>
-- 1 extra clock to complete the last shift
state_next <= idle;
rx_done_tick <= '1';
end case;
end process;
-- salidas
dout <= b_reg (8 downto 1); -- data bits
end Behavioral;
Cdigo 18.3 Mdulo PS2_RX

pg. 169

El teclado manda un cdigo a travs de los canales de datos del

puerto PS2. Los cdigos hexadecimales de cada tecla son mostrados en la
figura 18.2.

Figura 18.2 Cdigos enviados por el teclado

Mapeamos el mdulo PS2_RX (Cdigo 18.3) hacia el top module

KB_Led el cual se encargar de enviar hacia los leds de la tarjeta Basys2 el
cdigo hexadecimal de la tecla del teclado pulsada. Sern necesarios los 8
leds de la tarjeta.
entity KB_Led is
Port ( clk : in STD_LOGIC;
reset : in STD_LOGIC;
ps2d : in STD_LOGIC;
ps2c : in STD_LOGIC;
leds : out STD_LOGIC_VECTOR (7 downto 0));
end KB_Led;
architecture Behavioral of KB_Led is
signal kb_not_empty, kb_buf_empty : std_logic;
signal key_code : std_logic_vector(7 downto 0);
begin
kb_code_unit : entity work.kb_code(Behavioral)
port map (clk => clk, reset => reset, ps2d => ps2d, ps2c => ps2c,
rd_key_code => kb_not_empty, key_code =>
key_code,
kb_buf_empty => kb_buf_empty );
kb_not_empty <= not kb_buf_empty;
leds <= key_code;
end Behavioral;
Cdigo 18.4 Mdulo KB_Led

pg. 170

CONCLUSIONES Y RECOMENDACIONES
Tarjeta Basys2 Viable en el control de Procesos.

Gracias al diseo e implementacin de las prcticas expuestas en este

documento qued demostrado que la Tarjeta Basys2 basada en el FPGA
Spartan-3E 100 K de la marca Xilinx es un opcin viable para controlar
procesos.
Cabe destacar que la Tarjeta Basys2 cuenta con entradas y salidas
limitadas y el proceso a implementar debe estar pensado en las capacidades
de la tarjeta. Para proyectos de un volumen alto se recomienda utilizar una
tarjeta de desarrollo con mayor capacidad y basada en una arquitectura
FPGA superior. De igual manera se puede optar por comprar nicamente el
dispositivo FPGA y hacer el PCB necesario para la produccin en masa.
El diseo estructural con VHDL permite conectar mdulos
prefabricados. Los alcances del FPGA Spartan-3E aun no han llegado al
lmite con estas prcticas y el uso de procesadores embebidos diseados por
el fabricante Xilinx como los son PicoBlaze de 8 bits y MicroBlaze de 32 bits
abren un avanico de posibilidades para el manejo de datos de forma paralela
y aplicaciones innovadoras de adquisicin y procesamiento a gran velocidad.
El tiempo de diseo de un prototipo con la Tarjeta Basys2 es reducido
y ofrece ventajas tales como la reprogramacin y reasignacin de pines para
hacer pruebas que permitan llegar al producto final.
Se recomienda ampliamente a los diseadores tomar las precauciones
pertinentes respecto al acondicionamiento de las seales para no daar la
tarjeta; recuerde que los puertos PMod de E/S estn protegidos contra corto
circuito, pero al trabajar con valores altos de voltaje y corriente se corren
riesgos importantes y no hay garanta de que no sufra daos.
La tendencia actual demuestra que el uso de FPGAs se ha ido
incrementando con el paso de los aos y las capacidades de estos aumentan
de manera exponencial. A la fecha de este documento se ha roto la barrera
de los 2 Tb/s de ancho de banda con un transmisor basado en los modernos
Virtex-7 X690T FPGAs. Imaginemos las posibilidades.

pg. 171

REFERENCIAS BIBLIOGRFICAS
1

Norman S. Nise, Sistemas de Control para Ingeniera. (1a Edicin),

Compaa Editorial Continental, Mexico: 2004
2

Pong P. Chu, FPGA Prototyping by VHDL Examples XILINX Spartan-3

Version. (1a Edicin), John Wiley & Sons Inc, Hoboken, New Jersey: 2008
3

Menndez Ortiz Mara Alejandra, Arquitectura FPGA para la adquisicin de

Datos Trmicos. Universidad del Mar Campus Puerto Escondido Oaxaca
Mxico: 2010.
4

www.xilinx.com/support/documentation/data_sheets/ds312.pdf

http://www.digilentinc.com/Products/Detail.cfm?NavPath=2,400,790&Prod=B
ASYS2
6

Urqua Alfonso, Martn Villalba Carla, Casos prcticos de diseo de circuitos

digitales con VHDL, Universidad Nacional de Educacin a Distancia (UNED)
Departamento de Informtica y Automtica, Madrid, Espaa: 2008
7

Machado Snchez Felipe, Borromeo Lpez Susana, Diseo de circuitos

digitales con VHDL, (Version 1.01) Departamento de Tecnologa Electrnica
Universidad Rey Juan Carlos; Madrid, Espaa: 2010
8

http://www.mexchip.com/categor%C3%ADas/tutoriales/vhdl/

pg. 172