UAM-I Rafael Sánchez García148.206.53.84/tesiuami/UAMI17155.pdf · 2013-07-12 · Se desea diseñar e implementar un comparador de 4 bits: ... se abre la ventana de la figura 9,

UAM-I Rafael Sánchez García Julio 2013

Proyecto de ingeniería electrónica

“Diseño de un conjunto de apoyos didácticos de Teoría y Laboratorio para las temáticas de Diseño Lógico y Filtros Pasivos y Activos de la

carrera de Ingeniería Electrónica”.

Asesor:

Ing. Miguel Ángel Gutiérrez Galindo.

Elaboro:

Sánchez García Rafael.


Índice Introducción ------------------------------------------------------------------ 3 Objetivo ------------------------------------------------------------------------ 4 VHDL ---------------------------------------------------------------------------- 5

Planteamiento del problema --------------------------------------- 5 Diseño con VHDL ----------------------------------------------------- 5 Síntesis ----------------------------------------------------------------- 14 Simulación en el ISE de Xilinx -------------------------------------- 22 Modelos de Hardware -------------------------------------------------- 27 Acondicionamiento para la implementación ------------------ 30 Implementación ------------------------------------------------------ 35 Generación del archivo de configuración --------------------- 37 Programación del dispositivo ------------------------------------ 38 Ejercicio de repaso ----------------------------------------------------- 40

PIC´s --------------------------------------------------------------------------- 41 Estructura ------------------------------------------------------------- 41 Resumen de instrucciones ---------------------------------------- 42 Programa de ejemplo ----------------------------------------------- 43 Simulación ------------------------------------------------------------- 44 Aplicación -------------------------------------------------------------- 47

Filtros -------------------------------------------------------------------------- 49 Filtros FIR -------------------------------------------------------------- 50

Conclusión -------------------------------------------------------------------- 57 Bibliografía y Referencias ------------------------------------------------ 58

UAM-I Rafael Sánchez García

Julio 2013

3

Introducción El aprendizaje del lenguaje VHDL en la Ingeniería Electrónica necesita de una constante realización práctica de ejercicios, tanto de simulación como de implementación. Por ello, este documento describe la metodología llevada a cabo para conseguir que el aprendizaje de este lenguaje de descripción hardware sea efectivo y rápido, especialmente en lo referido al VHDL orientado a síntesis hardware. Se ha empleado dispositivo FPGA de Xilinx. VHDL es un lenguaje no necesariamente conectado con síntesis hardware, pero viene asociado a la implementación de sistemas digitales, por lo que trataremos únicamente todo lo relacionado con el aprendizaje VHDL orientado a síntesis. Por ello, resulta imprescindible que el estudiante conozca las diferencias de estilo de una descripción para simulación y una descripción donde se debe considerar que el sistema a obtener se implementará en hardware (en nuestro caso, FPGA). En este documento se presentan de manera detallada los pasos a seguir para implementar un sistema digital en la tarjeta de desarrollo Nexys 2 de Digilent, desde el planteamiento del problema hasta su puesta en marcha y verificación en la tarjeta, la cual contiene un FPGA Spartan- 3E XC3S500E de Xilinx. El ejemplo que se desarrolla es bastante simple, porque el objetivo del tutorial no es resolver un problema complejo, sino ilustrar el proceso de desarrollo. Para el desarrollo del tutorial se requiere de las siguientes herramientas de Software:

• Active-HDL versión 6.2: Herramienta desarrollada por Aldec, es empleada para la captura y simulación de las descripciones en VHDL.

• ISE 12.1i de Xilinx: Es un ambiente integrado de desarrollo desde el que

se invocan diferentes herramientas, conforme se van requiriendo. Se utiliza para la síntesis, implementación y creación del archivo de descarga. También puede utilizarse para programar al FPGA si se emplea una interfaz conocida como JTAG.

• Para el Active-HDL y el ISE actualmente existen versiones más recientes,

se ocuparán las que se han citado porque emplean menos recursos en su instalación y son suficientes para las aplicaciones a desarrollar.


4

Objetivo El presente proyecto tiene como objetivo generar un conjunto de apuntes para las temáticas de Diseño Lógico y Filtros en las que se tome en cuenta las últimas tecnologías disponibles tales como FPGA, PIC’s y VHDL. Así mismo reforzar el uso de técnicas como Cartas ASM, Transformada de Laplace y Software de Simulación. La justificación principal de este proyecto deriva del hecho de ampliar los recursos de enseñanza acorde a los nuevos contenidos de las ueas correspondientes para la Licenciatura en Ingeniería Electrónica como:

- Fundamentos de Lógica Digital - Sistemas Digitales de Propósito Específico - Temas Selectos de Sistemas Digitales - Circuitos Eléctricos III - Laboratorio de Comunicaciones - Comunicaciones Digitales


5

VHDL Planteamiento del problema Se desea diseñar e implementar un comparador de 4 bits: Un circuito que como entradas reciba dos números A y B de 4 bits y como salidas indique si A > B, A < B o A = B, esto se muestra en la figura 1.

Figura 1. Circuito a implementar

Diseño con VHDL Para el diseño y simulación se utilizará la herramienta Active-HDL versión 6.2, desarrollada por Aldec, cuyo Icono de acceso directo se muestra en la figura 2.

Figura 2. Acceso directo para el programa Active-HDL 6.2

Este programa organiza los diseños en espacios de trabajo (workspace) si es la primera vez que se ejecuta, deberá crearse un nuevo espacio de trabajo, en caso contrario podrá usarse un espacio de trabajo existente. En la figura 3 se observa cómo, aunque existan algunos espacios de trabajo, siempre es posible iniciar con uno nuevo.


6

Figura 3. Iniciando con el programa Active -HDL

Un espacio de trabajo puede contener diversos diseños independientes. Si es la primera vez que trabaja con esta herramienta, es conveniente iniciar con un nuevo espacio de trabajo propio. Al cual deberá asignársele un nombre, en este caso se le puso “tutorial” (figura 4).

Figura 4. Iniciando con un nuevo espacio de trabajo

Si se abre un espacio de trabajo existente, automáticamente se abre el último diseño elaborado. Para los espacios de trabajo nuevos, se presenta el asistente para iniciar con nuevos diseños, el asistente inicia con la ventana mostrada en la figura 5.


7

Figura 5. Creando un diseño en el espacio de trabajo La primera opción se usa cuando ya se cuenta con módulos que se agregarán al diseño. La segunda es para importar un diseño completo. La última opción es necesaria para nuevos diseños, ésta es la opción que debe seleccionarse y después continuar con el paso siguiente. Posteriormente se deben definir algunas características del diseño relacionadas con las herramientas que se cuenten para síntesis e implementación, y al tipo de FPGA sobre el cual se realizará la descarga. Pero como esta versión de Active -HDL es muy previa a las nuevas herramientas de Xilinx, no es posible relacionarlas, por ello, el Active-HDL sólo será utilizado para describir y simular al circuito, no se seleccionan herramientas como se muestra en la figura 6.


8

Figura 6. Diseño sin herramientas de síntesis.

Finalmente deberá escribirse el nombre del diseño, en este caso es “comparador” (figura 7).

Figura 7. Nombrando al diseño.

A continuación se tiene disponible al ambiente de trabajo completo de la herramienta, el cual tiene un aspecto como el que se muestra en la figura 8.


9

Figura 8. Entorno de trabajo en la herramienta Active -HDL 6.2.

En (1) se tiene un navegador en el que se puede seleccionar una de las 3 opciones siguientes (con sus cejas inferiores):

• Archivos (Files) – Se muestran los archivos del diseño, organizados bajo un esquema: Espacio de Trabajo (Workspace)-> Diseños -> Archivo. Un espacio de trabajo puede contener varios diseños y un diseño a la vez puede contener varios archivos (módulos descritos en VHDL).

• Estructura (Structure) – Tiene sentido una vez que los módulos han sido

compilados, muestra la organización del diseño, así como las señales internas, externas y variables de cada uno de sus módulos, esta opción es útil para simulación.

• Recursos (Recursos) – Muestra la organización en directorios de todos los elementos que se agreguen al diseño activo.

En (2) se tiene una consola en la que aparecerán mensajes de acuerdo con las actividades realizadas por el usuario. Es solo con carácter informativo, no es posible introducir información a través de esta consola. El espacio en (3) es el área de trabajo, aquí se va a mostrar el contenido de cada uno de los módulos que integren a un diseño. Archivos con código VHDL, ventanas de simulación, diagramas de bloques, etc. Basta dar doble clic dentro del navegador para observar el contenido de un archivo y poder modificarlo.


10

Para agregar un nuevo archivo al diseño activo, en el navegador se debe dar doble clic en la opción Add New File ( ), se abre la ventana de la figura 9, para permitir insertar archivos vacíos, archivos existentes o usar uno de los asistentes (Wizards) para crear uno nuevo.

Figura 9. Ventana para insertar un nuevo archivo.

Lo más simple es emplear uno de los asistentes, específicamente se debe seleccionar al que apoya para crear un nuevo archivo empleando código VHDL, como se muestra en la figura 10. Los otros asistentes son para crear diagramas a Bloques (para módulos con mayor jerarquía), diagramas de estado o archivos en Verilog.

Figura 10. Agregando un nuevo archivo VHDL con ayuda del asistente.

Después de aceptar, se va a iniciar con el nuevo módulo, se deja activa la opción de que el código generado se integre al proyecto y se avanza (figura 11).


11

Figura 11. Creación de un nuevo archivo VHDL con ayuda del asistente.

A continuación se debe escribir el nombre del archivo a crear y de manera opcional el nombre de la entidad y de la arquitectura, si estos se omiten, todos los campos tomarán el mismo nombre, que se decidió fuera “comp4b” (figura 12).

Figura 12. Personalizando al nuevo archivo VHDL.

Luego se deben insertar una a una las señales que formarán parte de la entidad (interfaz), la inserción de una señal comienza con un clic en el botón new, luego se le pone un nombre, si es un vector su tamaño se determina con los índices y debe definirse su modo (entrada o salida). El proceso debe repetirse con cada una de las señales, de acuerdo a las especificaciones del diseño. En la figura 13 se muestra el entorno mediante el cual se definen los puertos que forman parte de la entidad, desde que se inserta la primera, hasta que todas han sido incluidas.


12

Figura 13. Ventana para definir los puertos que forman parte de la entidad.

Al concluir con la inserción de señales se presiona el botón finalizar, con lo que se creará la plantilla del módulo en el archivo comp4b, el cual es automáticamente abierto en el área de trabajo, como se puede ver en la figura 14.

Figura 14. Plantilla creada a partir del asistente.

Los comentarios de la plantilla pueden completarse para una adecuada documentación. En este momento ya se tiene descrita la entidad (la interfaz del módulo) y falta por describir su arquitectura para determinar su comportamiento. El tipo de dato generado por default es STD_LOGIC, el cual es una ampliación del tipo Bit con la característica de que maneja otros niveles lógicos, además de falso y verdadero, como desconocido, alta impedancia, no importa, etc.


13

Nota: Si se quiere modificar la entidad, para agregar una nueva señal, eliminar una existente o modificar algún parámetro, debe hacerse manualmente, respetando la sintaxis de VHDL, no es posible regresar al asistente anterior. El módulo a desarrollar es un comparador de 4 bits, de manera que su comportamiento puede determinarse por el proceso siguiente:

process( A, B ) begin

mayor <= ‘0’; menor <= ‘0’; igual <= ‘0’; if A > B then

mayor <= ‘1’; elsif A < B then

menor <= ‘1’; else

igual <= ‘1’; end if;

end process; Existen otras alternativas, sin embargo la descripción funcional es más entendible porque refleja directamente la solución del problema. Nota: Después de la palabra process se coloca la lista de sensitividad, son señales que activarán la ejecución del proceso, cuando ocurra un cambio en cualquiera de ellas. En el caso del comparador, será activado con cualquier cambio en las señales A y B. Este código debe insertarse en la arquitectura, sustituyendo al comentario: -- enter your statements here --, como se muestra en la figura 15.


14

Figura 15. Inserción de un proceso en la arquitectura.

Una vez insertado el código, se verifica su sintaxis realizando su compilación. Para ello se selecciona al archivo y se presiona al botón compilar

. Otra alternativa consiste en obtener un menú contextual dando un clic derecho en el archivo y seleccionar la opción de compilación (compile). Si no hay errores de sintaxis, el archivo tendrá otro marcador indicando su estado

y la consola reflejará el éxito de la compilación. En caso de que hubiera errores, el archivo en el navegador quedará marcado de manera diferente y los errores se mostrarán en la consola:

Los errores deben resolverse considerando la sintaxis del lenguaje. Síntesis La síntesis se va a realizar con las herramientas de Xilinx desde un Ambiente Integrado de Software (Integrated Software Environment – ISE) el cual se inicia con un doble clic en el ícono mostrado en la figura 16.


15

Figura 16. Acceso directo para el Ambiente Integrado de Software (ISE) de Xilinx.

Al iniciar este programa se mostrará el Tip del Día y luego se abrirá el último proyecto en el que se ha trabajado (excepto cuando es la primera vez que se ejecuta al software). Para este tutorial se iniciará con un nuevo proyecto, dando un clic al botón New Project, en los comandos para proyectos ubicados a la izquierda de la ventana, mostrados en la figura 17. Con ello se obtendrá el cuadro de diálogo mostrado en la figura 18.

Figura 17. Comandos para los proyectos en el ISE de Xilinx.

Figura 18. Cuadro de diálogo para crear un nuevo proyecto.

Primero se debe seleccionar la ubicación y el directorio de trabajo del nuevo proyecto y luego se le debe asignar un nombre. El proyecto queda ubicado en una carpeta con el mismo nombre.


16

En este caso, los proyectos se ubican en la carpeta C:\Practicas y el nuevo proyecto llevará por nombre comparador. Para el tipo de módulo superior (Top-level source type) se mantiene HDL porque el comparador ya fue descrito en VHDL. En la figura 19 se ha personalizado el cuadro de diálogo de la figura 18.

Figura 19. Definición del nombre y ubicación del nuevo proyecto.

Una vez que se introduzcan estos datos se debe proceder con el paso siguiente. En el cual se definen las propiedades del proyecto relacionadas con el FPGA en el que se va a realizar la descarga, por lo que es necesario seleccionar los valores correctos, incluyendo el lenguaje preferido. En la figura 20 se muestran los valores que corresponden con el FPGA que está integrado en las tarjetas de desarrollo Nexys 2.


17

Figura 20. Información relacionada con el FPGA a utilizar.

Con un clic en Next se obtiene el resumen del proyecto mostrado en la figura 21, si los datos con correctos, con el botón Finish se finaliza con la creación del proyecto.


18

Figura 21. Resumen del proyecto.

Una vez que se cierra el cuadro de diálogo inicial se podrá ver el entorno de desarrollo de Xilinx, el cual se muestra en la figura 22.


19

Figura 22. Entorno de desarrollo de Xilinx.

En la figura 22 se distinguen cuatro áreas principales:

1. Área de archivos. Se muestran los diferentes archivos fuente que integran al proyecto, a manera de un árbol. Si un proyecto está formado por varios módulos, en este árbol los módulos se ubicarán de acuerdo con sus niveles jerárquicos.

2. Espacio de trabajo. Acá serán abiertos los diferentes archivos fuente, reportes o información de internet, inicialmente se muestra un resumen de la versión 12 del ISE con ligas para mostrar sus diferentes características. Para abrir un archivo en el espacio de trabajo, basta con dar doble clic a su nombre en el área de archivos.

3. Área de procesos. Los procesos que se pueden aplicar a un archivo dependen de su tipo. Una vez que se selecciona un archivo en el área 1, en esta área se mostrará una lista con los procesos aplicables, por ello, la lista puede cambiar en función del tipo de archivo.


20

4. Área de mensajes. Muestra una consola con mensajes indicando las diferentes actividades que se están realizando. Además, existen otras cejas para mostrar errores o precauciones.

Hasta el momento se tiene un diseño vacío, para agregar un archivo nuevo o copiar uno existente se debe dar un clic derecho en el área de archivos para obtener el menú contextual que permitirá hacerlo, en la figura 23 se muestra el citado menú.

Figura 23. Menú contextual para agregar archivos nuevos o existentes.

Puesto que el archivo en VHDL del comparador ya fue realizado, se debe seleccionar la opción Add Copy of Source, para copiar el archivo en la carpeta del proyecto. Con un clic en esta opción se abre una ventana de navegación en la que se debe buscar al archivo comp4b.vhd, el cual se encuentra en la ruta: my_designs -> tutorial -> comparador -> src, esto porque el Active-HDL trabaja en la carpeta denominada my_designs, el espacio de trabajo se denominó tutorial, en el cual se inició con un diseño denominado comparador, y todos los diseños dejan los archivos del código fuente en una carpeta denominada src. En la figura 24 se muestra el cuadro de diálogo resultante de agregar al archivo, en la columna Association se debe dejar la opción All, lo que significa que el archivo podrá ser empleado para síntesis y simulación.


21

Figura 24. Archivo agregado al proyecto.

Al presionar OK en la figura 24 se tendrá al archivo comp4b.vhd en el área de archivos y en el espacio de trabajo se mostrará un resumen del proyecto. Puesto que el archivo comp4b.vhd está seleccionado, en el área de procesos se muestran los procesos que son aplicables a un archivo de este tipo, esto se observa en la figura 25.

Figura 25. Archivo comp4b.vhd agregado al proyecto.

Con el archivo comp4b.vhd seleccionado se realiza su síntesis. Para ello, en el área de procesos se da un doble clic al proceso de síntesis, si no hay errores de sintaxis, en el proceso de síntesis aparecerá la indicación de que se realizó con éxito y la consola reflejará el mismo hecho. Ambas indicaciones se pueden ver en la figura 26.


22

Figura 26. Proceso de síntesis realizado con éxito.

En caso de que hubiera errores, el proceso de síntesis no sería superado y el error se mostraría en el espacio de la consola, en la ceja de errores también se mostraría la posición del error. Se esperaría que no ocurrieran errores, dado que el módulo cont4b.vhd ya fue evaluado con el Active-HDL, sin embargo, si se realiza algún ajuste en el código VHDL que genere algún error, éste debe resolverse considerando la sintaxis del lenguaje, en la figura 27 se muestra un error al quitar un ; en el archivo cont4b.vhd.

Figura 27. Errores durante el proceso de síntesis.

Simulación en el ISE de Xilinx El entorno de Xilinx también permite realizar simulaciones, este paso puede omitirse porque ya se realizó una simulación previa en el Active -HDL, sin embargo, el paso se describe para que se observen las diferencias que existen entre ambas herramientas.


23

Para la simulación en el ISE de Xilinx debe agregarse un nuevo archivo, conocido como un banco de pruebas, con un clic derecho en cualquier parte del área de archivos se obtiene un menú contextual en el que se debe seleccionar New Source, como se muestra en la figura 28.

Figura 28. Opciones para agregar un nuevo archivo al proyecto.

Con ello se muestran los diferentes tipos de archivo que pueden agregarse (figura 29), se selecciona Test Bench WaveForm (banco de pruebas) y se le agrega un nombre.

Figura 29. Se agrega un banco de pruebas al proyecto.

Un banco de pruebas es un archivo que se asocia con el módulo a simular, proporcionándole estímulos para sus entradas y el entorno de desarrollo permitirá


24

observar las señales de salida, el banco de pruebas no forma parte de la implementación final en la tarjeta. La relación entre el banco de pruebas y el comparador se muestra en la figura 30.

Figura 30. Relación del comparador con el banco de pruebas.

Por lo tanto, al presionar el botón de siguiente, se asocia al banco de pruebas con el comparador.

Figura 31. Asociación del banco de pruebas con el módulo a simular.

Al presionar siguiente se muestra un resumen en el cual se debe presionar finalizar, con lo que se crea un archivo en VHDL en el que aparece el módulo a simular como un componente. La Entidad en este archivo es nula, dado que sólo


25

sirve para simulación, con código VHDL deben definirse los estímulos para las señales de entrada. Los estímulos son señales que cambian a lo largo del tiempo, por lo que se debe definir su estado a lo largo del tiempo de prueba. Para este ejemplo, básicamente se utilizan contadores, la señal A va aumentando y la señal B disminuyendo. Si el circuito fuera secuencial, también se debe definir el comportamiento de la señal de reloj. Por lo tanto, es necesario modificar al archivo test_comp4b.vhd para que quede de la siguiente manera: -------------------------------------------------------------------------------- LIBRARY ieee; USE ieee.std_logic_1164.ALL; USE ieee.std_logic_unsigned.ALL; -- Se agrega para operaciones aritméticas ENTITY test_comp4b IS END test_comp4b; ARCHITECTURE behavior OF test_comp4b IS

-- Declaración del Componente para la Unidad Bajo Prueba COMPONENT comp4b PORT(

A : IN std_logic_vector(3 downto 0); B : IN std_logic_vector(3 downto 0); mayor : OUT std_logic; menor : OUT std_logic; igual : OUT std_logic );

END COMPONENT; -- Entradas signal A : std_logic_vector(3 downto 0) := (others => '0'); signal B : std_logic_vector(3 downto 0) := (others => '0'); -- Salidas signal mayor : std_logic; signal menor : std_logic; signal igual : std_logic;

BEGIN

-- Instancia la Unidad Bajo Prueba (Unit Under Test) uut: comp4b PORT MAP (

A => A, B => B, mayor => mayor, menor => menor, igual => igual

); -- Proceso para los estímulos stim_proc: process begin

-- Estado inicial, por 100 ns A <= "0000"; B <= "0000";


26

wait for 100 ns; for i in 0 to 15 loop A <= A + 1; -- Estímulos para los datos de entrada B <= B - 1; wait for 100ns; end loop; wait; -- Se mantiene inactivo

end process;

END; El banco de pruebas debe seleccionarse en el área de archivos para verificar su sintaxis y proceder con la simulación. Si no aparece debe cambiarse a la vista de simulación en la parte superior de la misma área:

Con el archivo seleccionado, se verifica su sintaxis en el área de procesos y si no hay errores, se puede iniciar con la simulación. En la figura 32 se muestran ambos procesos.

Figura 32. Procesos para un banco de pruebas.

Si la sintaxis correcta, se procede con la simulación del comportamiento del módulo VHDL, al dar un clic en la opción Simulate Behavioral Model se abrirá la aplicación ISim, el simulador incluido en el ISE. En la figura 33 se muestra la simulación del Comparador, sin embargo, para ese resultado se han avanzado otros ciclos de simulación y se han realizado los ajustes necesarios en el diagrama de tiempos para visualizar diferentes combinaciones.


27

Figura 33. Simulación del comparador.

Para concluir con la simulación y cerrar la aplicación ISim, se teclea el comando exit en la consola del programa (parte inferior de la ventana), con lo cual se regresa al entorno del ISE. El banco de pruebas queda disponible para cuando se requiera regenerar la simulación. Modelos de Hardware Con la herramienta de trabajo, después de haber realizado la síntesis, se pueden observar los componentes de hardware a los cuales se ha sintetizado el módulo en una lógica de transferencia de registros (RTL), para ello, primeramente se debe regresar a visualizar para una implementación, en la parte superior del área de archivos se debe seleccionar:

Seleccionando al archivo comp4b, en el área de procesos se hace una expansión de la opción síntesis, como se muestra en la figura 34, para posteriormente dar doble clic al proceso View RTL Shematic.


28

Figura 34. Obtención del esquemático.

La primera vez que se ejecute este proceso se presentará una ventana con 2 opciones, la primera es un asistente, por lo que debe seleccionarse la segunda (Start with a schematic of the top-level block) para obtener el bloque de mayor jerarquía del comparador, el cual se muestra en la figura 35.

Figura 35. Bloque de mayor jerarquía del comparador.

El diagrama de la figura 35 es el bloque de mayor jerarquía, con un doble clic en el

bloque o con el botón es posible explorar hacia los niveles inferiores en los que se pueden observar más detalles, lo cual es bastante útil en diseños complejos. En la figura 36 se puede ver el siguiente nivel del comparador.


29

Figura 36. Segundo nivel jerárquico del comparador.

Estos diagramas permiten evaluar la relación que se da entre el software y

hardware, y son útiles para documentación, con el botón se puede regresar al nivel jerárquico anterior. En este ejemplo ya no se tienen niveles inferiores, por su simpleza, los componentes del segundo nivel pueden implementarse directamente en los bloques lógicos del dispositivo seleccionado. Al cerrar la ventana del área de trabajo se concluye el proceso de visualización del hardware.


30

Acondicionamiento para la implementación. Como pudo observarse en las figuras 35 y 36, el código VHDL ha sido sintetizado satisfactoriamente en hardware, ahora se deben tomar en cuenta algunas consideraciones para poder llevar a cabo su implementación en el dispositivo. El comparador será descargado en un FPGA XC3S500 de Xilinx, el cual está en una tarjeta Nexys 2 de Digilent, cuya imagen se muestra en la figura 37. Digilent es la empresa que manufactura estas tarjetas de desarrollo y su manual de referencia puede obtenerse de su sitio web: www.digilentinc.com. Se observa que la tarjeta tiene diferentes elementos para entrada/salida o almacenamiento de datos.

Figura 37. Tarjeta Nexys 2, incluye un FPGA Spartan-3E de Xilinx.

Para la implementación del comparador, es de esperarse que las entradas A y B se obtengan de los interruptores, y las salidas: Mayor, Menor e Igual, se muestren en los LEDs. Por lo tanto, se requiere conocer a que terminales del FPGA están conectados estos elementos. En la figura 38 se muestra la organización de las terminales en el FPGA, se observa una disposición matricial organizada en 4 bancos. Para referirse a una terminal, debe indicarse el renglón (A-V) y la columna (1-18).


31

Figura 51. Terminales del FPGA Spartan-3E de Xilinx incluido en la tarjeta Nexys 2.

En la figura 39 se muestra a que terminales del FPGA están conectados los dispositivos básicos de entrada/salida. Sería necesario revisar el manual de la tarjeta si se va a emplear alguna interfaz especializada, como RS-232, PS/2 o VGA; o bien, si se va a manejar alguna de las memorias incluidas en la misma Nexys 2.


32

Figura 39. Conexión del FPGA con los dispositivos básicos de entrada/salida, en la tarjeta Nexys 2.

Para la asignación de terminales, es necesario agregar un archivo de restricciones (archivo con extensión UCF), para ello, en cualquier parte del área de archivos se debe dar un clic derecho y en el menú contextual seleccionar la opción New Source, como se muestra en la figura 40.

Figura 40. Opciones para agregar un nuevo archivo al proyecto.

Dentro de los diferentes tipos de archivo que se pueden insertar, se debe seleccionar la opción Implementation Constraints File, como se muestra en la figura 41, y se le asigna un nombre al archivo, en este caso se le denominó terminales.


33

Figura 41. Se inserta un archivo de restricciones al proyecto.

El archivo con las restricciones automáticamente se asocia con el archivo del diseño, si hubiera más módulos se debería seleccionar al de mayor jerarquía. Luego, se muestra la información sobre este nuevo archivo (figura 42) y se finaliza.

Figura 42. Resumen del archivo de restricciones a insertar en el proyecto.


34

Con esto, el archivo de restricciones es ubicado en el área de archivos, en la figura 43 se puede ver que el archivo está asociado con el comparador. Para modificarlo, el archivo debe seleccionarse para que en el área de proceso se muestre la opción Edit Constrains (Text), que es un proceso asociado a los archivos de restricciones. Al ejecutarlo, se abre el archivo vacío en el espacio de trabajo (también se muestra en la figura 43).

Figura 43. Archivo de restricciones dentro del proyecto.

La sintaxis para definir la asociación de las señales con las terminales del FPGA es la siguiente :

NET “nombre de la señal” LOC = “terminal”; Donde con NET se hace referencia a la señal y con LOC se refiere a su ubicación. Por lo tanto, en el archivo de restricciones debe insertarse:

# Entradas para el dato A NET "A<0>" LOC = "G18" ; NET "A<1>" LOC = "H18" ; NET "A<2>" LOC = "K18" ; NET "A<3>" LOC = "K17" ; # Entradas para el dato B NET "B<0>" LOC = "L14" ; NET "B<1>" LOC = "L13" ; NET "B<2>" LOC = "N17" ; NET "B<3>" LOC = "R17" ; # Salidas


35

NET "igual" LOC = "J14" ; NET "mayor" LOC = "J15" ; NET "menor" LOC = "K15" ;

El signo # indica que el resto del renglón es un comentario. En la figura 44 se muestra al archivo de restricciones modificado.

Figura 44. Archivo de restricciones editado.

Es necesario realizar una asociación correcta de los pines del módulo VHDL con las terminales del FPGA, dado que si se comete un error, por ejemplo, conectando una salida del FPGA con una terminal que genera voltaje, se podría dañar a la tarjeta. Implementación. La implementación es un proceso que involucra varios pasos: Trasladar el diseño (Traslate), mapearlo (Map) y realizar su colocación y ruteo (Place & Route). Sin embargo, estos procesos los realiza la herramienta de manera automática. Para ello, es necesario seleccionar el archivo comp4b en el área de archivos, con lo que se abrirán los procesos aplicables al archivo, entre los cuales se debe buscar la lista de procesos Implement Design y darle un doble clic para ejecutarlos, en la figura 45 se muestra la realización con éxito de la Implementación, con todas sus etapas.


36

Figura 45. Implementación del diseño.

En el resumen del proyecto (que se muestra en el área de trabajo) se pueden ver los recursos que está usando el diseño dentro del FPGA, estos se observan en la figura 46.

Figura 46. Resumen de recursos utilizados en el diseño.


37

Generación del archivo de configuración Dentro de los procesos asociados al diseño (los cuales se obtienen al seleccionarlo), se encuentra el proceso Generate Programming File, ubicado después de los procesos de implementación. Con este proceso se crea el archivo para descargar en el FPGA, sin embargo, antes de ejecutarlo es necesario definir uno de sus parámetros, para ello habrá que dar un clic derecho al proceso y seleccionar la opción propiedades en el menú contextual, como se muestra en la figura 47.

Figura 47. Opción para el ajuste de las propiedades del proceso para generar el archivo de programación.

Con ello se abrirá la ventana mostrada en la figura 48, en donde se debe seleccionar la categoría Startup Options y cambiar el valor de la propiedad FPGA Start-Up Clock para que tenga JTAG Clock, este ajuste también se muestra en la figura 48.

Figura 48. Ajuste de las propiedades del proceso para generar el archivo de programación.


38

Después del cambio debe presionarse el botón Aplicar (Apply) y cerrar la ventana presionando OK. Este cambio es necesario porque la programación del FPGA se hará a través de su interfaz JTAG y por lo tanto, se requiere que en la misma interfaz se tenga la señal de reloj. Una vez hecho esto es posible ejecutar al proceso Generate Programming File aplicándole un doble clic. Si el proceso se realiza con éxito, se obtendrá un estado de éxito, como se muestra en la figura 49.

Figura 49. La generación del archivo de programación se realizó con éxito.

En este momento ha sido creado al archivo con extensión BIT que será descargado en el FPGA, por lo tanto, para descargas en la tarjeta Nexys 2 empleando la interfaz USB ya es posible cerrar al ISE de Xilinx. Programación del dispositivo La tarjeta puede programarse desde dos diferentes puertos, el puerto JTAG o un puerto mini-USB, el programa puede enviarse directamente al FPGA o a una FLASH, para que el FPGA cargue el programa automáticamente, después de que es alimentada la tarjeta. En la figura 50 se observa cómo en realidad es sólo por el puerto JTAG por el que se tiene acceso al FPGA y a la Flash. La salida del controlador USB va dirigida hacia el puerto JTAG.


39

Figura 50. Interfaz para programar al FPGA.

El cable JTAG es similar al de la figura 51, si se utiliza este medio, debe ejecutarse el proceso Manage Configuratio Project (iMPACT), visible al expandir la opción Configure Target Device, ubicado por debajo del proceso Generate Programming File.

Figura 51. Cable JTAG, también empleado para programar al FPGA.

Cabe aclarar que los recursos programables en el FPGA están basados en tecnología RAM, por lo que si se retira la alimentación, el programa se perderá. Para evitar esto, el programa podría almacenarse en la memoria FLASH, lo cual se evitará para mantener el programa de demostración. Sin embargo, es conveniente aclarar que en la PROM no se puede programar un archivo con extensión BIT, primero debería generarse el archivo para la PROM desde el ISE de Xilinx.


40

Ejercicio de repaso Para repasar el tutorial e iniciarse con la programación en VHDL, diseñar e implementar el circuito decodificador de 3 a 8 mostrado en la figura 52.

Figura 74. Circuito para repetir el tutorial.

Las entradas deberán tomarse de los interruptores y las salidas enviarse a los LEDs. Realizar un reporte con los siguientes puntos:

a. Descripción del problema. b. Código VHDL. c. Resumen de los recursos empleados. d. Modelos de Hardware (diagramas RTL) del nivel superior y siguiente. e. Restricciones (Archivo UCF). f. Conclusiones.


41

PIC´s. Los microcontroladores están conquistando el mundo. Están presentes en nuestro trabajo, en nuestra casa y en nuestra vida, en general. Se pueden encontrar controlando el funcionamiento de los ratones y teclados de los computadores, en los teléfonos, en los hornos microondas y los televisores de nuestro hogar. Pero la invasión acaba de comenzar y el nacimiento del siglo XXI será testigo de la conquista masiva de estos diminutos computadores, que gobernarán la mayor parte de los aparatos que fabricaremos y usamos los humanos. El PIC16F84 es un microcontrolador de la familia PIC, fabricada por la empresa Microchip.

En el aspecto software, para el 16F84 y demás PICs, Microchipdispone de un software gratuito llamado MPLAB , el cual es un entorno de desarrollo para estos microcontroladores.

Dicho entorno de desarrollo incluye un compilador que convierte el código fuente del programa (.asm) en un fichero .hex, listo para pasar al microcontrolador.

De esta labor se encarga el software programador, que junto con el circuito de mismo nombre graban el circuito en el micro para que éste funcione según lo que hayamos programado.

Estructura

Se trata de un microcontrolador de 8 bits y 18 pines, que a demás consta internamente de:

• Memoria Flash de programa (1K x 14). • Memoria EEPROM de datos (64 x 8). • Memoria RAM (67 registros x 8). • Un temporizador/contador (timer de 8 bits). • Un divisor de frecuencia. • Varios puertos de entrada-salida (13 pines en dos puertos, 5 pines el puerto

A y 8 pines el puerto B). Otras características son:

• Manejo de interrupciones (de 4 fuentes). • Perro guardián (watchdog).


42

• Bajo consumo. • Frecuencia de reloj externa máxima 10MHz. (Hasta 20MHz en nuevas

versiones). La frecuencia de reloj interna es un cuarto de la externa, lo que significa que con un reloj de 20Mhz, el reloj interno sería de 5Mhz y así pues se ejecutan 5 Millones de Instrucciones por Segundo (5 MIPS).

• No posee conversores analógicos-digital ni digital-analógicos. • Pipe-line de 2 etapas, 1 para búsqueda de instrucción y otra para la

ejecución de la instrucción (los saltos ocupan un ciclo más). • Repertorio de instrucciones reducido (RISC), con tan solo 30 instrucciones

distintas. • 4 tipos distintos de instrucciones, orientadas a byte, orientadas a bit,

operación entre registros, de salto. Resumen de instrucciones (clasificación según el fabricante en tres grupos): Instrucciones orientadas a byte:

Instrucciones orientadas a bit:


43

Instrucciones orientadas a literal y control:

Programa de ejemplo A continuación hay un pequeño programa en ensamblador (MPASM) que pone a 0 las posiciones de memoria 20 y 21 (en hexadecimal) usando un direccionamiento indirecto:

MOVLW 20h MOVWF FSR CLRF INDF INCF FSR CLRF INDF

MOVLW k: (Move Literal to W) Es una instrucción que carga en el registro de trabajo W, un literal (constante) k, que en este caso es 20h. MOVWF f: (Move W to File), Copia el contenido del registro W a la posición de memoria f. En este caso, FSR representa una dirección de memoria. FSR es el registro usado para direccionamiento indirecto. En FSR se carga la dirección de memoria que se va a direccionar con INDF (otro registro). CLRF f: (Clear File), Pone en 0 el registro en la posición de memoria f. INCF f: (Increment File), Incrementa en uno el valor almacenado en la posición de memoria f.


44

Simulación. A continuación se muestran de forma sencilla los pasos en la compilación de un programa, al generar un proyecto. Iniciando el software dando clic en el icono que se muestra a continuación (figura 75) se visualiza la pantalla de la figura 76. Para abrir un archivo a compilar en modo de proyecto, se siguen los pasos que a continuación se describen.

Figura 75. Icono de acceso directo a MPLAB

Figura 76. Ventana de Inicio de MPLAB

En la barra de herramientas abrir Project/ New, enseguida se desplegara una nueva ventana en donde le daremos el nombre del proyecto y la ruta en donde se crearan las nuevas carpetas de nuestro proyecto con la selección del botón


45

browse, oprimir OK para continua r. Como lo muestran las figuras 77 y 78 posicionando el clic derecho del mouse en la etiqueta de SourceFile abrir el archivo a compilar.

Figura 77. Selección de Add File.

Figura 78. Se adjunta el archivo ensamblador.


46

Se observa que aparece el archivo ensamblador debajo de SourceFile, nuevamente con clic derecho en el archivo *.asm se selecciona (Edit) editar el archivo para realizar la compilación. Cuando el archivo fuente este abierto se procede a configurar el ambiente del MPLAB para realizar la compilación del archivo cargado haciendo clic Configure/Select Device de la barra de herramientas y seleccionar el PIC utilizado como muestra la figura 79.

Figura 79. Configuración de parámetros del PIC.

Finalmente solo se hará clic en Built All de la barra de herramientas para construir nuestra aplicación y generar el archivo *.HEX, que es el que se usa en la programación de los PIC´s. El icono para compilar se muestra a continuación.


47

Aplicación. Para la prueba de nuestro integrado se utilizó el software IC-PROG para programar. Al abrir el programa se procede a configurar el ambiente para realizar la programación del PIC seleccionando el tipo de dispositivo y abriendo nuestro archivo HEX que fue creado por el MPLAB. Este paso se muestra en la figura 80.

Figura 80. Búsqueda del archivo HEX

Cuando el archivo este cargado se configura el tipo de oscilador, en este caso se esta utilizando uno de tipo XT. Ademas, se deshabilita el watchdog WDT y el de protección de código CP; mientras que se habilita la terminal del reset (Power Reset) PWR, como se muestra en la figura 81.


48

Figura 81. Se carga el archivo HEX en el IC-PROG

Por último se realiza la programación del PIC al pulsar el botón hasta que IC-PROG nos indique que se ejecuto correctamente.


49

Filtros Un filtro es un sistema que, dependiendo de algunos parámetros, realiza un proceso de discriminación de una señal de entrada obteniendo variaciones en su salida. Los filtros digitales tienen como entrada una señal analógica o digital y a su salida tienen otra señal analógica o digital, pudiendo haber cambiado en amplitud, frecuencia o fase dependiendo de las características del filtro. El filtrado digital es parte del procesado de señal digital. Se le da la denominación de digital más por su funcionamiento interno que por su dependencia del tipo de señal a filtrar, así podríamos llamar filtro digital tanto a un filtro que realiza el procesado de señales digitales como a otro que lo haga de señales analógicas. El filtrado digital consiste en la realización interna de un procesado de datos de entrada. El valor de la muestra de la entrada actual y algunas muestras anteriores (que previamente habían sido almacenadas) son multiplicadas por unos coeficientes definidos. También podría tomar valores de la salida en instantes pasados y multiplicarlos por otros coeficientes. Finalmente todos los resultados de todas estas multiplicaciones son sumados, dando una salida para el instante actual. Esto implica que internamente tanto la salida como la entrada del filtro serán digitales, por lo que puede ser necesario una conversión analógico-digital o digital-analógico para uso de filtros digitales en señales analógicas. Un elemento de prueba de estos circuitos típicamente es el ruido blanco (figura 82).

Figura. 82. Gráfica de ruido blanco


50

Filtros FIR Los filtros digitales se usan frecuentemente para tratamiento digital de la imagen o para tratamiento del sonido digital. FIR es un acrónimo en inglés para Finite Impulse Response o Respuesta finita al impulso. Se trata de un tipo de filtros digitales en el que, como su nombre indica, si la entrada es una señal impulso, la salida tendrá un número finito de términos no nulos. Para obtener la salida sólo se basan en entradas actuales y anteriores. Su expresión en el dominio n es:

En la expresión anterior N es el orden del filtro, que también coincide con el número de términos no nulos y con el número de coeficientes del filtro. Los coeficientes son bk. La salida también puede expresarse como la convolución de la señal de entrada x(n) con la respuesta impulso h(n):

La Transformada Zeta (Z) es un modelo matemático que se emplea entre otras aplicaciones en el estudio del Procesamiento de Señales Digitales, como son el análisis y proyecto de Circuitos Digitales, los Sistemas de Radar o Telecomunicaciones y especialmente los Sistemas de Control de Procesos por computadoras. La Transformada Z es un ejemplo más de Transformada, como lo son la Transformada de Fourier para el caso de tiempo discreto y las Transformadas de Fourier y Laplace para el caso del tiempo continúo. La importancia del modelo de la Transformada Z radica en que permite reducir Ecuaciones en Diferencias o ecuaciones recursivas con coeficientes constantes a Ecuaciones Algebraicas lineales. Aplicando la T ransformada Z a la expresión anterior:


51

La estructura básica de un FIR se presenta en la figura 83.

Figura 83. Estructura básica de un FIR

En la figura 2 los términos ß son los coeficientes y los T son retardos. Pueden hacerse multitud de variaciones de esta estructura. Hacerlo como varios filtros en serie, en cascada, etc. Hay tres métodos básicos para diseñar este tipo de filtros:

• Método de las ventanas. Las más habituales son: § Ventana rectangular § Ventana de Barlett § Ventana de Hanning § Ventana de Hamming § Ventana de Blackman § Ventana de Kaiser

• Muestreo en frecuencia. • Rizado constante.

El FPGA es un dispositivo lógico programable , que posee la cualidad de la re-configuración, lo que permite realizar cambios en la arquitectura sin necesidad de producir variaciones en el montaje o en el software que se está operando. La implementación de estos filtros está determinada por algunos factores que ayudan a la calificación de dichos sistemas, tales como:


52

- La Complejidad computacional: está determinada por el número de operaciones aritméticas necesarias para el cálculo de la salida, como sumas, multiplicaciones y divisiones.

- Requisitos de memoria: hacen referencia a la cantidad de posiciones de memoria que son necesarias para almacenar elementos, tales como los coeficientes del sistema, entradas retrasadas, salidas retrasadas y algunos valores internos necesarios para el cálculo de la salida.

- Longitud de palabra: se refiere a un efecto de precisión que se encuentra dado por la cuantificación, tanto de los coeficientes del filtro como de la señal de entrada. Este elemento se hace presente en filtros implementados en hardware y en software.

Existen dos tipos básicos de filtros digitales:

• no recursivos • recursivos.

Para los filtros no recursivos la función de transferencia contiene un número finito de elementos, cuya ecuación en diferencias es:

Y su equivalente en función de transferencia es:

Esta clase de sistemas se caracteriza por no poseer realimentaciones, de lo cual se observa que la salida se encuentra dada en función de la entrada y de sus respectivos retrasos. Para los filtros recursivos la ecuación en diferencias se encuentra expresada en función de dos formas polinomiales:


53

Esta ecuación nos lleva a encontrar una función de transferencia de la forma:

A los primeros pertenecen los filtros tipo FIR, caracterizados por no poseer realimentación, y a los segundos los filtros tipo IIR, en donde la salida se encuentra dada en función de la entrada y de las salidas en instantes previos. Se creó una herramienta en hardware como filtro tipo FIR, esta fue probada en una tarjeta XILINX SPARTAN 3E. La entidad fue definida de la siguiente forma:

ENTITY FIR IS GENERIC (N : natural := 16 ); PORT ( SIGNAL CLK : IN std_logic; SIGNAL RES_n : IN std_logic; SIGNAL X : IN std_logic_vector( N-1 DOWNTO 0 ); SIGNAL Y : OUT std_logic_vector( N-1 DOWNTO 0 ) ); END ENTITY FIR ;

Como es posible observar se mantiene la señal de reloj CLK como entrada, dos valores de ingreso donde X es dato de 2 bits y RES_n es un reset activado por pulso. La salida se encuentra definida por un valor de dato de 2 bits. Tal como se muestra en la figura 84.

Figura 84. Entidad de un filtro Fi r en FPGA XILINX


54

La arquitectura se define de la siguiente manera: ARCHITECTURE RTL OF FIR IS TYPE t_operacion IS ARRAY (7 DOWNTO 1) OF std_logic_vector(N-1 DOWNTO 0);

SIGNAL operacion : t_operacion; SIGNAL add_01 : std_logic_vector(N DOWNTO 0); SIGNAL add_23 : std_logic_vector(N DOWNTO 0); SIGNAL add_45 : std_logic_vector(N DOWNTO 0); SIGNAL add_67 : std_logic_vector(N DOWNTO 0); SIGNAL add_0123 : std_logic_vector(N+1 DOWNTO 0); SIGNAL add_4567 : std_logic_vector(N+1 DOWNTO 0); SIGNAL add_all : std_logic_vector(N+2 DOWNTO 0); SIGNAL vystup : std_logic_vector(N+2 DOWNTO 0); SIGNAL pom : std_logic_vector(N+2 DOWNTO 0); SIGNAL pipe_0123 : std_logic_vector(N+1 DOWNTO 0); SIGNAL pipe_4567: std_logic_vector(N+1 DOWNTO 0);

Como es posible observar las señales de operación son diversas, la idea principal es mostrar el manejo del pipeline, el circuito presentará el esquema de la figura 85.

Figura 85. Esquema RTL


55

El pipeline característico se codifico de la siguiente manera: Si es presionado el reset RES_n el pipeline inicia su operación, si existe el evento del reloj y es un pulso positivo, entonces realiza las operaciones retardas y secuenciales.

pipeline: PROCESS (CLK, RES_n) BEGIN IF RES_n='0' THEN

pipe_0123 <= (OTHERS => '0'); pipe_4567 <= (OTHERS => '0');

ELSIF CLK='1' AND CLK'EVENT THEN pipe_0123 <= add_0123; pipe_4567 <= add_4567;

END IF; END PROCESS pipeline;

Las siguientes instrucciones muestran el bloque de cada procedimiento u operación del pipeline, cabe resaltar el manejo de los índices en el filtro. add_01 <= (X(N-1) & X) + (operacion(1)(N-1) & operacion(1)); add_23 <= (operacion(2)(N-1) & operacion(2)) + (operacion(3)(N-1) & operacion(3)); add_45 <= (operacion(4)(N-1) & operacion(4)) + (operacion(5)(N-1) & operacion(5)); add_67 <= (operacion(6)(N-1) & operacion(6)) + (operacion(7)(N-1) & operacion(7)); add_0123 <= (add_01(N) & add_01) + (add_23(N) & add_23); add_4567 <= (add_45(N) & add_45) + (add_67(N) & add_67); add_all <= (pipe_0123(N+1) & pipe_0123) + (pipe_4567(N+1) & pipe_4567); pom(3 DOWNTO 0) <= "0100"; pom(N+2 DOWNTO 4) <= (OTHERS => '0'); vystup <= add_all WHEN add_all(3 DOWNTO 0) = "0100" else add_all + pom; Se creó una herramienta de software que se encarga de brindar una conexión sencilla y amable entre e l usuario del filtro y el hardware. La interfase se encuentra desarrollada sobre Matlab y al inicio presenta 3 posibilidades de filtros tipo FIR para escoger con cuál se desea trabajar:


56

• Filtro con coeficientes estáticos. • Filtro con coeficientes dinámicos. • Filtro adaptativo.

Para efectos de este documento sólo se trabaja con la opción de filtro con coeficientes dinámicos. Esta sección escogida presenta dos bloques principales así: Diseño del filtro: esta es la primera sección, le permite al usuario manejar las especificaciones del filtro tales como:

• Cantidad de coeficientes. • Ancho de banda. • Atenuación y ganancia del filtro para diferentes frecuencias.

Una vez se han escogido los diferentes parámetros del filtro, tanto para su arquitectura como para su funcionamiento, se procede a diseñar dicho filtro. Proceso que se lleva a cabo mediante la utilización del algoritmo FIR. La verificación e implementación: se realizan una vez que se han determinado las especificaciones del filtro y se ha diseñado.


57

Conclusión Se ha revisado de manera detallada el proceso a seguir para implementar sistemas digitales en FPGAs con ayuda de VHDL, para otro tipo de tarjetas u otro tipo de FPGAs sólo debe hacerse la selección adecuada del dispositivo y la ubicación correcta de las terminales de entrada y salida. Si no se tiene éxito en la programación, las causas pueden ser diversas:

• La tarjeta puede estar desconectada. • Se seleccionó un FPGA que no corresponde con el de la tarjeta. • El empaque seleccionado no es el empaque del FPGA. • El puerto o el cable USB no funcionan correctamente. • El FPGA no funciona correctamente.

Otra paquetería de software utilizada fue la correspondiente al uso del microcontrolador (PIC’s) las cuales fueron MPLAB y IC -PROG. El objetivo final de este proyecto (documento) fue la construcción de un tutorial como apoyo didáctico a las asignaturas de la carrera de Ingeniería Electrónica. El propósito de este documento de proyecto terminal es también el de brindar a cualquier persona o usuario la facilidad de comprensión y de manejo de las herramientas que aquí se describen, cubriendo los aspectos más generales y mas importantes que se deben tomar en cuenta para su funcionamiento. El reporte contiene la información didáctica de cada punto, es decir, su correspondiente información teórica, definiciones, estructura, etc .; de los dispositivos; pero también un pequeño manual práctico en el que se enuncian sucesiva y ordenadamente parte de la secuencia de pasos para poder llevar a cabo un correcto flujo de diseño para que al final se pueda se pueda comprobar con alguna aplicación. Sin embargo se recomienda que no se tome este reporte como única fuente información es por eso que al final se incluye la bibliografía para otras fuentes de consulta. Se puede notar que para los filtros tenemos un diseño en forma jerárquica, de tal manera que se dividió en diferentes etapas. Antes de iniciar el estudio de cada una de estas entidades deberá de ser necesario tener en cuenta algunos aspectos del funcionamiento que presenta este diseño: El ancho de palabra es de 8 bits, para el reloj del sistema se utilizó el oscilador interno del FPGA, que es de 50 Mhz y la arquitectura presenta una etapa que se encarga de comunicarse con el software y, de esta forma, mediante una interfase de puerto paralelo a la PC.


58

Bibliografía y Referencias. [1] “Microcontroladores PIC diseño practico de aplicaciones” Angulo Usategui, José; Angulo Martínez, Ignacio. Editorial Mc Graw Hill, Segunda Edición, 1999 [2] “Electrónica Digital Introducción a la Lógica Digital, Teoría, problemas y simulación” Acha, Santiago; Castro, Manuel A.; Pérez, Julio; Rioseras, Miguel A. Editorial Alfaomega-Rama, 2003 [3] “VHDL Lenguaje para Síntesis y Modelado de Circuitos” Pardo, Fernando; Boluda, José. Editorial Alfaomega-Rama, 2003

[4] “VHDL El arte de programar sistemas digitales” David G.Maxinez; Jessica Alcalá Grupo Editorial Patria, 2010 [5] “Tratamiento digital de señales” J. G., Proakis, Dimitris G. Manolakis. Prentice Hall, 1997 [6] “Signal procesing algoritms” Samuel Stearms, Ruth A. David. Prentice Hall, 1997 [7] “Digital filters” R. W. Hamming. Prentice Hall, 1989

[8]http://www.xilinx.com/

[9]http://www.microchip.com/

Documents

UAM-I Rafael Sánchez García148.206.53.84/tesiuami/UAMI17155.pdf · 2013-07-12 · Se desea diseñar e implementar un comparador de 4 bits: ... se abre la ventana de la figura 9,