Vibilidad de La Tarjeta Basys2 para Su Implementacion en El Control de Un Proceso

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

Mario Merino Mrquez
Presenta: 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
Menndez Ortiz Mara Alejandra, Arquitectura FPGA para la adquisicin de Datos Trmicos. Universidad del Mar Campus Puerto Escondido Oaxaca Mxico: 2010.
3
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.
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. diseo
En VHDL tambin existen formas metdicas para el de mquinas de estados, filtros digitales, bancos de pruebas etc.
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 Si No Sntesis Si Simulacin Pos-Sintesis Si Ubicacin y Enrrutamiento No No
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. 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. 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.
2)
3)
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
1 2 1
Producto
Basys2 Multimete r-MS821 PMOD-TMP
Descripcin
Basys2 Spartan 3E FPGA Board Autorange Digital Multimeter PMOD-TMP Thermometer
Tabla 3: Gastos en Digilent Inc
Precio Unitario
$ 59.00 USD $ 29.99 USD $ 24.99 USD
Sub Total
$ 59.00 USD $ 59.98 USD $ 24.99 USD
El envi desde USA se hizo a travs del servicio de paquetera Fed-Ex en un lapso de 3 das hbiles.
Cantidad
1 1
Producto
Envo Impuesto
Descripcin
Servicio de Paquetera FedEx Impuesto Aduanal
Tabla 4: Gastos de Envio
Precio Unitario
$ 81.77 USD $ 30.00 USD
Sub Total
$ 81.77 USD $ 30.00 USD
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
2 1 1 30 5 20 10 1 2 3
Producto
Protoboard SN754410 NE555 Resistor Capacitor 2N25 2N2222 Motor Relay Cable Telefnico
Descripcin
Tablilla para Prototipos Quadruple Half-H Driver Multivibrador 555 Resistores de distintos valores Capacitores Electrolticos y Cermicos Optoacoplador MOC NPN Transistor Motro de 5V CD Relays de 5V CD Metros de Cable Telefnico
Tabla 5: Gastos Extras
Precio Unitario
$ 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
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
a
0 1 0 1
s
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.
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.
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
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
a
0 1 0 1
s
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
a
0 1 0 1
s
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
A
0 1 0 1
C
0 0 0 1
S
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
0 0 0 0 1 1 1 1
EntradaB
0 0 1 1 0 0 1 1
EntradaA
0 1 0 1 0 1 0 1
Cout
0 0 0 1 0 1 1 1
Suma
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 bits cin : in STD_LOGIC; reloj_tarjeta : in STD_LOGIC; reset : in STD_LOGIC; -- Carry in de 1 bit STD_LOGIC_VECTOR (2 downto 0); -- dato "b" de 3
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" valor0; when valor1; when valor2; when others => anodos <= "0111"; valor_aux <= valor3; end case; "10" => anodos <= "1011"; valor_aux <= "01" => anodos <= "1101"; valor_aux <=
=>
anodos
<=
"1110";
valor_aux
<=
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" end Behavioral;
Cdigo 6.4 Programa Enciende7Segmentos
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
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 ); end Behavioral;
Cdigo 6.7 Arquitectura Sumador_Arith
unidades decenas centenas millares
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
X
0 0 1 1
Tabla 7.1 Operaciones de la ALU
Y
0 1 0 1
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 --decimal point sseg(7) <= dp; end Behavioral;
Cdigo 7.1 disp_hex_mux (Salida a Displays y Multiplexeo)
"0000", "0001", "0010", "0011", "0100", "0101", "0110", "0111", "1000", "1001", "1010", "1011", "1100", "1101", "1110", others;
--a --b --c --d --P --f
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 unsigned is variable i : integer := 0; variable resultado : unsigned( "0000000000000000"; 15 downto 0 ) := bin_a_bcd( bin : unsigned(15 downto 0)) return
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 = 0
Push = 1
Push = 0
Led0 <= 0
Led_ OFF Push = 1
Led_O N
Led0 <= 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 --=================================== --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; son componente de la
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
4
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 unsigned is variable i : integer := 0; variable resultado : unsigned( "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 -downto 8 ) + "0011"; --end if; end loop; return resultado; resultado( 11 downto 8 ) := resultado( 11 7 downto 0 ) := bin_a_bcd( bin : unsigned(3 downto 0)) return
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" "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" "01100000" "00101101" "00111101" "01011011" "01011101" "01011100" "00111011" "00100111" "00101100" "00101110" "00101111" "00100000" "00001101" "00001000" "00101010"
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 when when when when when when when when when when when when when when when when when when when when when when when
"00011110", "00100110", "00100101", "00101110", "00110110", "00111101", "00111110", "01000110", "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", "00001110", "01001110", "01010101", "01010100", "01011011", "01011101", "01001100", "01010010", "01000001", "01001001", "01001010",
----------------------------------------------
2 3 4 5 6 7 8 9 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 ' = { } \ ; , . /
"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
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

Vibilidad de La Tarjeta Basys2 para Su Implementacion en El Control de Un Proceso

Caricato da

Informazioni sul documento

Titolo originale

Copyright

Formati disponibili

Condividi questo documento

Condividi o incorpora il documento

Opzioni di condivisione

Hai trovato utile questo documento?

Questo contenuto è inappropriato?

Copyright:

Formati disponibili

Vibilidad de La Tarjeta Basys2 para Su Implementacion en El Control de Un Proceso

Caricato da

Copyright:

Formati disponibili

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: Asesor Interno:

Ing. Juan Jos Ortiz Flores

Asesor Externo: Dr. Oscar Leopoldo Prez Castaeda

REA DE PARTICIPACIN ................................................................................. 9 PROBLEMAS A RESOLVER.............................................................................. 10

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

PROCEDIMIENTO Y DESCRIPCIN DE LAS ACTIVIDADES REALIZADAS .. 35

CONCLUSIONES Y RECOMENDACIONES .................................................. 171 REFERENCIAS BIBLIOGRFICAS ................................................................. 172

Figura 1 - Organigrama del Instituto Tecnolgico de Tehuacn

Desarrollo e Implementacin de Mquinas de Estados Finitos (FSM)

Duracin: 3 semanas Objetivo: Disear e implementar circuitos digitales secuenciales avanzados.

Figura 3 Diagramas a bloques de Sistemas de Control a) En Lazo Abierto b) En Lazo Cerrado

Figura 4 Estructura Conceptual FPGA

Figura 5 - LUT (Look-up Table)

Familias comerciales de FPGAs.

Familia Xilinx Spartan-3E FPGA

Tabla 1- Densidades Familia Spartan-3E

Sitio web oficial de Xilinx seccin documentacin de productos. www.xilinx.com/support/documentation/data_sheets/ds312.pdf

Figura 6 Arquitectura Spartan 3-E FPGA

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

Figura 7 Diagrama a bloques Tarjeta Basys2

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

Tendencias Tecnolgicas por Mercado del FPGA

Figura 8 Aplicaciones FPGA a nivel Mundial

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

Red Estrategica de Tecnologia FPGA (AERI FPGA): http://www.conacyt.gob.mx/fondos/institucionales/Tecnologia/Avance/Redes/1-FPGA-FUMEC-AERI.pdf

El flujo de diseo de un sistema es:

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

Diagrama a bloques del sistema

No Compilacin Si Simulacin Funcional Si No Sntesis Si Simulacin Pos-Sintesis Si Ubicacin y Enrrutamiento No No

Programacin del Dispositivo

Figura 9- Diagrama de Flujo Secuencia de Diseo

Ventajas de los lenguajes HDL

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

Figura 11 Arquitectura compuertas NOT, XOR y AND

PROCEDIMIENTO Y DESCRIPCIN DE LAS ACTIVIDADES REALIZADAS

Adquisicin de la Tarjeta Basys2

Por lo tanto el gasto total es de:

Figura 12 Pgina Principal de Xilinx

Figura 13 Seccin de Descargas

Figura 14 Asistente de Creacin de un nuevo Proyecto

Figura 15 Opciones de Configuracin de Tarjeta Basys2

Figura 16 Ventana New Source Wizard

Figura 17 Ventana Define Module

Mas adelante se tiene el siguiente cdigo:

s : out end compuerta_and;

Figura 18 Diagrama esquemtico compuerta_and

-- combinacionales o subprogramas. end NOMBRE_ARQUITECTURA;

Figura 19 Revisin de Sintaxis

Figura 20 Resultado del Chequeo de Sintaxis

Figura 22 Ventana Processes ISim Simulator

Figura 23 Ventana ISim Simulator

Tabla 6 Tabla de verdad compuerta AND

Figura 24 Ventana Force Selected Signal

Figura 25 Resultado Simulacin Valor 1

Figura 26 Resultado Simulacin Valor 2

Figura 27 Resultado Simulacin Valor 3

Figura 28 Resultado Simulacin Valor 4

Figura 29 Resultado de Simulacin Completa

Figura 30 Define Module Compuerta_or

Figura 31 Chequeo de Sintaxis Compuerta_or

Tabla 7 Tabla de verdad compuerta OR