• Author / Uploaded
• whendy

Citation preview

Departamento de Tecnología Electrónica

Diseño digital con esquemáticos y FPGA. v1.8

Felipe Machado Sánchez Norberto Malpica González de Vega Susana Borromeo López

Departamento de Tecnología Electrónica

Índice Índice .................................................................................................................................................................................. 1 1. Introducción..................................................................................................................................................................... 3 2. Encender un LED............................................................................................................................................................ 4 2.1. Diseño del circuito ............................................................................................................................................................................ 5 2.2. Síntesis e implementación del circuito............................................................................................................................................ 10 2.3. Programación de la FPGA.............................................................................................................................................................. 11

3. Puertas lógicas, interruptores y pulsadores .................................................................................................................. 15 3.1. Diseño del circuito .......................................................................................................................................................................... 15 3.2. Simulación del circuito .................................................................................................................................................................... 17 3.3. Síntesis e implementación del circuito............................................................................................................................................ 20

4. Decodificador de 2 a 4 .................................................................................................................................................. 21 4.1. Diseño del decodificador ................................................................................................................................................................ 21 4.2. Comprobación del diseño ............................................................................................................................................................... 23 4.3. Implementación del diseño ............................................................................................................................................................. 24 4.4. Creación de un bloque.................................................................................................................................................................... 24

5. Decodificador de 3 a 8 .................................................................................................................................................. 27 5.1. Diseño del decodificador con bloques ............................................................................................................................................ 28

6. Decodificador de 4 a 16 ................................................................................................................................................ 30 6.1. Diseño del decodificador con bloques prediseñados ..................................................................................................................... 31 6.2. Comprobación del diseño ............................................................................................................................................................... 33

7. Convertidor de hexadecimal a 7 segmentos ................................................................................................................. 35 7.1. Diseño del convertidor de hexadecimal a 7 segmentos ................................................................................................................ 35 7.2. Implementación .............................................................................................................................................................................. 39

8. Codificadores ................................................................................................................................................................ 42 8.1. Codificador de 4 a 2 sin prioridad ................................................................................................................................................... 42 8.2. Codificador de 4 a 2 con prioridad, línea activa y habilitación........................................................................................................ 42 8.3. Codificador de 4 a 2 con conversión a 7 segmentos...................................................................................................................... 44

9. Extensión de la capacidad de un codificador ................................................................................................................ 46 9.1. Codificador de 8 a 3 a partir de codificadores de 4 a 2 .................................................................................................................. 46 9.2. Inclusión del convertidor a siete segmentos................................................................................................................................... 47 9.3. Codificador mayores....................................................................................................................................................................... 47

10. Comparadores ............................................................................................................................................................ 48 10.1. Comparador de un bit ................................................................................................................................................................... 48 10.2. Comparador de dos bits ............................................................................................................................................................... 48 10.2.1. Diseño del comparador ....................................................................................................................................................... 50

11. Comparadores en cascada ......................................................................................................................................... 51 12. El multiplexor............................................................................................................................................................... 55 12.1. Especificaciones ........................................................................................................................................................................... 55 12.2. Diagrama de bloques del circuito ................................................................................................................................................. 55 12.3. Diseño........................................................................................................................................................................................... 57

13. El sumador .................................................................................................................................................................. 60 13.1. Especificaciones ........................................................................................................................................................................... 60 13.2. Diseño........................................................................................................................................................................................... 60

14. Sumador/restador ....................................................................................................................................................... 63 14.1. Especificaciones ........................................................................................................................................................................... 63 14.2. Diagrama de bloques.................................................................................................................................................................... 63 14.2.1. Bloque sumador/restador .................................................................................................................................................... 64 14.2.2. Bloque de visualización....................................................................................................................................................... 66 14.3. Diseño........................................................................................................................................................................................... 68 14.4. Comprobación del diseño ............................................................................................................................................................. 69

15. Unidad aritmético lógica .............................................................................................................................................. 71 15.1. Especificaciones ........................................................................................................................................................................... 71 15.2. Diagrama de bloques.................................................................................................................................................................... 71 15.3. Diseño........................................................................................................................................................................................... 74 15.3.1. Multiplicador por 2 ............................................................................................................................................................... 74 15.3.2. Circuito comparador, "mayor" ............................................................................................................................................. 75 15.3.3. Circuito operación lógica AND ............................................................................................................................................ 75 15.3.4. Multiplexor de 4 entradas datos con habilitación ................................................................................................................ 76 15.3.5. Codificador con prioridad de 4 entradas ............................................................................................................................. 77 15.3.6. Componente de mayor jerarquía......................................................................................................................................... 78 15.4. Implementación y comprobación .................................................................................................................................................. 78

16. Elementos de memoria ............................................................................................................................................... 79 16.1. Especificaciones ........................................................................................................................................................................... 79 16.2. Diseño........................................................................................................................................................................................... 79 16.3. Implementación ............................................................................................................................................................................ 79

17. Interruptor con pulsador .............................................................................................................................................. 81 17.1. Ideas ............................................................................................................................................................................................. 81 Diseño digital con esquemáticos y FPGA. v1.8 - - 04/06/2008

1

Departamento de Tecnología Electrónica

Índice

17.1.1. Conectando el pulsador a la entrada del biestable T .......................................................................................................... 81 17.1.2. Conectando el pulsador al reloj del biestable T .................................................................................................................. 81 17.2. Circuito detector de flanco ............................................................................................................................................................ 82 17.3. Solución al cronograma ................................................................................................................................................................ 83

18. Parpadeo de un LED................................................................................................................................................... 84 18.1. Especificaciones ........................................................................................................................................................................... 84 18.2. Diseño........................................................................................................................................................................................... 84

19. Reloj digital.................................................................................................................................................................. 87 19.1. Especificaciones ........................................................................................................................................................................... 87 19.2. Contador de 10 segundos ............................................................................................................................................................ 87 19.2.1. Bloque segundero ............................................................................................................................................................... 87 19.2.2. Bloque de mayor jerarquía .................................................................................................................................................. 89 19.3. Reloj digital con segundos y minutos ........................................................................................................................................... 89 19.3.1. Implementación ................................................................................................................................................................... 90 19.3.2. Solución............................................................................................................................................................................... 91

Diseño digital con esquemáticos y FPGA. v1.8 - 04/06/2008

2

Departamento de Tecnología Electrónica

1. Introducción

1. Introducción El objetivo de esta prácticas guiadas es introducir al alumno en el diseño con esquemáticos mediante el uso de herramientas CAD (computer aided design). Estas prácticas parten de un nivel elemental y se pretende que puedan ser seguidas como complemento en un curso básico de electrónica digital. Estas prácticas se han desarrollado en el departamento de Tecnología Electrónica 1 de la Universidad Rey Juan Carlos. Estas prácticas consistirán en un grupo de ejercicios con los que aprenderemos a programar una FPGA utilizando la herramienta gratuita de diseño electrónico digital ISE-WebPACK de Xilinx 2. En las prácticas de este curso realizaremos diseños con esquemáticos: puertas lógicas, bloques combinacionales y secuenciales. Una vez que hayamos realizado el diseño en la herramienta, lo sintetizaremos y lo implementaremos en la FPGA. La síntesis es la tarea que transforma un diseño desde un nivel de descripción a otro nivel de descripción más bajo. En nuestro caso, el diseño lo tendremos en esquemáticos y la herramienta lo transformará en una descripción que indica las conexiones internas y configuración de la FPGA para que funcione de la misma manera a como funcionaría nuestro diseño original en esquemáticos. Por suerte, la síntesis la realiza la herramienta automáticamente, durante la síntesis nosotros nos ocuparemos de supervisar el proceso, analizando los errores y advertencias (warnings) que aparezcan. Antes de implementar el diseño en la FPGA es recomendable simular el diseño para comprobar que funciona correctamente. Es más fácil detectar errores de diseño mediante simulación, que en la placa. Imagina que has implementado el diseño en la FPGA y que ésta no hace nada. Para descubrir el fallo tendrías que usar un polímetro o un osciloscopio y comprobar los niveles de tensión de los pines. Además con el inconveniente de que sólo tienes accesibles los puertos de entrada y salida, y no las señales internas del diseño. Mediante la simulación puedes comprobar todas las señales (internas y externas) y directamente de un vistazo, sin recurrir a medidas eléctricas. Una vez que tenemos el diseño verificado por simulación, lo implementaremos en la FPGA. La herramienta de diseño creará un fichero de configuración (con extensión .bit). Este fichero contiene la información de la implementación de nuestro diseño en la FPGA. Para programar la FPGA, en nuestro caso, utilizaremos un cable JTAG, que es un cable que cumple un protocolo de depuración y programación: Boundary Scan.. Este cable se conecta al puerto paralelo de nuestro ordenador. Una vez programada la FPGA, nuestro diseño estará implementado en la FPGA y por lo tanto estará funcionando. Dependiendo del diseño implementado, interactuará con el exterior de distinta manera y podremos comprobar su correcto funcionamiento. Para las prácticas utilizaremos la placa Pegasus de Digilent 3, que contiene una FPGA de Xilinx de modelo Spartan-II XC2S200 con encapsulado PQ208. Esta FPGA tiene 200000 puertas lógicas equivalentes y 140 pines disponibles para el usuario. Con esta capacidad podemos hacer diseños digitales bastante grandes. La placa Pegasus contiene distintos periféricos que nos facilitarán la tarea del diseño, como por ejemplo: 8 LED, 4 displays de 7 segmentos, 4 botones, 8 interruptores, un puerto PS/2 (para ratón o teclado), y puerto VGA (para conectar un monitor), y varios puertos de expansión. En la figura 1.1 se muestra la placa Pegasus, y en la que se señalan varios de sus componentes. La foto de la placa no coincide exactamente con la versión de la placa que tenemos en el laboratorio y hay algunos componentes que no están en el mismo lugar, aunque sí todos los que se han señalado.

http://gtebim.es Herramienta gratuita que se puede descargar en http://www.xilinx.com 3 http://www.digilentinc.com 1 2

Diseño digital con esquemáticos y FPGA. v1.8 - 04/06/2008

3

Departamento de Tecnología Electrónica Conector de expansión

Conector JTAG

FPGA

2. Encender un LED Memoria Flash

VGA

Alimentación Jumpers de configuración PS/2 Display 7 segmentos

LED

Pulsadores

Interruptores

Figura 1.1: Placa Pegasus de Digilent A medida que vayamos avanzando con la práctica iremos aprendiendo la funcionalidad de la placa. Aún así se puede consultar en la página web de la asignatura (http://gtebim.es/docencia/EDI) el manual de la placa (en inglés), y una versión resumida de dicho manual en español. Bueno, es hora ya de empezar con las practicas ...

2. Encender un LED Cuando nos enfrentamos por primera vez a diseñar mediante una metodología y herramientas nuevas, lo más aconsejable es empezar con ejemplos lo más sencillos posibles. Y a partir de éstos se irá aumentando la complejidad del diseño. Son muchas cosas las que pueden fallar, tanto en el uso de las herramientas de diseño como en la placa de la FPGA. Por consiguiente, si de primeras probamos con un diseño complejo, en caso de que no funcione correctamente no sabremos si es el diseño que está mal o es algún paso que no hemos realizado bien. De manera similar, los informáticos realizan un programa llamado "Hello world" (hola mundo), que es un programa muy sencillo que simplemente saca por pantalla dicho texto. Nosotros, como no tenemos pantalla, encenderemos un LED. También podríamos usar el display de 7 segmentos, pero su uso es algo más complicado y lo que queremos es la mayor sencillez. Ya hemos visto que la placa Pegasus tiene 8 LED disponibles para utilizar, cada uno de estos LED van conectados a distintos pines de la FPGA, de los 140 pines que hay disponibles. La conexión de los LED se muestra en la figura 2.1. En ella se indican qué pines de la FPGA están conectados a los LED. Por ejemplo el LED número 0, está conectado al pin 46. Para facilitar esta identificación, la placa lleva impresos la identificación del LED y el pin asociado de la FPGA. Así, podemos ver cómo al lado del LED 0 (LD0) de la placa está el número 46 entre paréntesis. Podemos apreciar que esto se cumple para casi todos los componentes: pulsadores, interruptores, ... '1' → Encendido '0' → Apagado 390Ω

Spartan-II PIN 46 45 44 43 42 41 37 36

LED LD0 LD1 LD2 LD3 LD4 LD5 LD6 LD7

Figura 2.1: Conexión de los LED de la placa Pegasus Viendo el esquema eléctrico de la figura 2.1 podemos deducir que si ponemos un '1' lógico en el pin 46 de la FPGA encenderemos el LED, ya que con un '1' lógico la FPGA pondrá 3,3 voltios en ese pin (que es el nivel Diseño digital con esquemáticos y FPGA. v1.8 - 04/06/2008

4

Departamento de Tecnología Electrónica

2. Encender un LED

de tensión de ese pin de la FPGA). Por el contrario, si ponemos un '0' lógico en el pin 45, mantendremos apagado el LED 1 (LD1), puesto que no circulará corriente por él. Así pues, éste será el objetivo del primer ejercicio, poner un '1' en el pin 46 y un '0' en el pin 45. Si después de programar la FPGA el LED 0 se enciende y el LED 1 se apaga habremos cumplido el objetivo. Con el resto de pines que van a los otros LED no haremos nada, en teoría, haciéndolo así no deberían lucir, ya que por defecto la FPGA pone resistencias de pull-down en los pines no configurados, y una resistencia de pull-down pone la salida a tierra.

2.1. Diseño del circuito El diseño del circuito lo haremos con la herramienta ISE-Foundation o con ISE-WebPack de Xilinx, esta última es la versión gratuita que se puede descargar en la página web de Xilinx. Esta práctica está referida a la versión 9.2, debido a que existen nuevas versiones, puedes descargar esta versión en: http://www.xilinx.com/ise/logic_design_prod/classics.htm

Para arrancar el programa pincharemos en el icono de Xilinx o bien, desde: Inicio→Todos los programas→Xilinx ISE 9.2i→Project Navigator

Nos puede aparecer una ventana con el Tip of the day que son indicaciones que hace la herramientas cada vez que la arrancamos. Si las leemos habitualmente podemos ir aprendiendo poco a poco. Pinchamos en Ok, con lo que se cierra dicha ventana. Normalmente la herramienta abre el último proyecto que se ha realizado. Así que lo cerramos pinchando en: File→Close Project.

Para empezar a crear nuestro nuevo proyecto, pinchamos en File→New Project... y nos saldrá la ventana New Project Wizard – Create New Project como la mostrada en la figura 2.2. En ella pondremos el nombre del proyecto, que lo llamaremos led0, indicamos la ruta donde guardaremos el proyecto (C:/practica/edi/tunombre). Respecto al nombre y a la ruta, no es conveniente trabajar desde un dispositivo de memoria USB, ni tampoco incluir en la ruta o el nombre ni acentos ni eñes, ni caracteres extraños, lo más conveniente es limitarse a caracteres alfanuméricos, y usar el guión bajo en vez del espacio. Para el último recuadro de la ventana, donde pone Top-Level Source Type seleccionaremos Schematic, ya que nuestro diseño lo haremos mediante esquemáticos.

Figura 2.2: Ventana para la creación de nuevo proyecto Una vez que hemos rellenado los tres recuadros pinchamos en Next. Ahora nos aparece la ventana de selección del dispositivo (figura 2.4). En Product Category ponemos All. En la familia ponemos Spartan2, que es, como ya hemos dicho, la FPGA que tenemos en la placa de Pegasus. Los siguientes datos los podemos obtener a partir de la observación del texto del encapsulado de la FPGA, que se muestran en la figura 2.3. Hay que observar los valores que tiene la FPGA de nuestra placa, ya que en algunas el tipo es XC2S200 y en otras es XC2S50. Lo mismo sucede con la velocidad, en algunas es 5 y otras 6.

Diseño digital con esquemáticos y FPGA. v1.8 - 04/06/2008

5

Departamento de Tecnología Electrónica

tipo de dispositivo encapsulado

XC2S200

2. Encender un LED

código de fecha

PQ208 código de lote

velocidad

5C

rango de operación C: comercial

Figura 2.3: Interpretación del texto del encapsulado de la FPGA Para la selección de la herramienta de síntesis no tenemos alternativa, y para el simulador en esta práctica no es importante y lo dejamos en ISE Simulator (VHDL/Verilog). En el lenguaje de descripción de hardware preferido (Preferred Language) se deja el VHDL. Al terminar pinchamos en Next.

Mirar en la FPGA Mirar en la FPGA

Figura 2.4: Ventana para la selección del dispositivo del nuevo proyecto En las dos siguientes ventanas pinchamos en Next sin rellenar nada y en la última pinchamos en Finish. Ya tenemos el proyecto creado y ahora nos disponemos a crear nuestro diseño. Para ello creamos una nueva fuente pinchando en Project→New Source. Esto hará saltar a una nueva ventana que nos pedirá que seleccionemos el tipo de fuente que queremos crear. Como estamos trabajando en esquemáticos, seleccionamos Schematic, y nombramos al fichero led0. Este paso se muestra en la figura 2.5. Posteriormente pinchamos en Next y en la siguiente ventana en Finish.

Diseño digital con esquemáticos y FPGA. v1.8 - 04/06/2008

6

Departamento de Tecnología Electrónica

2. Encender un LED

Figura 2.5: Selección del tipo de nueva fuente Si al terminar el proceso la herramienta nos muestra la siguiente imagen, debemos seleccionar el fichero que hemos creado (led0.sch) como se muestra en la figura 2.6. También se puede pinchando en Window→led0.sch

Seleccionar led0.sch

Figura 2.6: Selección de la ventana del fichero led0.sch Ahora veremos el plano donde podremos dibujar el esquemático. En la figura 2.7 se muestra la apariencia de la herramienta. En ella se han movido las subventanas para tener una disposición más cómoda. Muévelas de manera que queden de una forma similar a la figura 2.7. Esta operación no siempre es fácil de realizar y a veces las subventanas se resisten a ser movidas. Otra opción es pinchar en Window→Tile Vertically. Luego, para dejarlo como muestra la figura 2.7, habría que maximizar la subventana del plano donde se dibuja el circuito, y seleccionar la pestaña de opciones y la pestaña de símbolos.

Diseño digital con esquemáticos y FPGA. v1.8 - 04/06/2008

7

Departamento de Tecnología Electrónica

2. Encender un LED

Plano donde dibujaremos el circuito

Opciones

Fuentes

Símbolos

Procesos

Figura 2.7: Apariencia de la herramienta para empezar a realizar el esquema del circuito En la figura 2.7 se han señalado algunas pestañas que utilizaremos durante el proceso de diseño y a las que se hará referencia durante el ejercicio. Así que familiarízate con sus nombres y vuelve a esta figura si durante la práctica no sabes a qué pestaña nos estamos refiriendo. Si quieres, pincha en ellas para ver el aspecto que tienen. La ventana de opciones permite cambiar el comportamiento de la herramienta al dibujar el esquemático. La ventana de símbolos nos permite dibujar las puertas lógicas y los distintos componentes de nuestro diseño. En la ventana de fuentes se muestran los ficheros de nuestro diseño (en este caso sólo hay uno: led0.sch). Y por último, en la ventana de procesos se indica a la herramienta los comandos que se quieren ejecutar. Para empezar a diseñar volvemos a la ventana de símbolos. En ella, seleccionamos la categoría General y tomamos el símbolo vcc. Una vez que los hemos seleccionado podemos apreciar que el puntero del ratón cambia de forma cuando lo situamos en el plano del circuito. Si pinchamos en cualquier parte del plano se situará el símbolo correspondiente a Vcc, que es la fuente de alimentación, y por tanto, en electrónica digital es un '1' lógico (ver la figura 2.8). A veces la herramienta tarda un poco en situarlo, así que no desesperes y no pinches varias veces con el ratón, pues colocarías varias Vcc por tu circuito. Cuando hayas colocado tu fuente de alimentación, seguramente la veas un poco pequeña. Para ampliar la zona puedes pinchar en View→Zoom→Zoom In (o bien pulsar F8). Siempre que se haya seleccionado un símbolo, al pinchar con el ratón en el mapa del circuito se añade dicho símbolo. Esto puede resultar incómodo ya que podemos estar añadiendo componentes sin querer. Para quitar esta opción y tener en cursor del ratón en modo de selección (con su flechita habitual) basta con pulsar la tecla de escape (Esc) o bien pulsar el icono de la flechita que está en la barra de herramientas

.

Si por error hemos incluido un símbolo más de una vez, para borrarlo vamos al modo selección (tecla Esc) y pinchamos encima del símbolo que queramos eliminar. Éste cambiará a color rojo, y entonces o bien lo borramos con la tecla Supr, o bien pinchamos con el botón derecho del ratón y del menú seleccionamos Delete. Como podrás apreciar viendo dicho menú, también puedes copiar y cortar de la misma manera que se hace en Windows.

Diseño digital con esquemáticos y FPGA. v1.8 - 04/06/2008

8

Departamento de Tecnología Electrónica

2. Encender un LED

Figura 2.8: Creación de un nivel lógico alto: '1' Ahora conectaremos dicho '1' lógico a un puerto de salida, para ello pincha en Add→I/O Marker, o bien pincha de la barra de herramientas. Verás que la ventana de opciones cambia, en ella puedes en el icono determinar el tipo de puerto y cambiar la orientación del símbolo dibujado. Esto lo puedes cambiar posteriormente seleccionando el símbolo y pinchando con el botón derecho del ratón. Ahora, con el ratón te pones encima del final del cable del símbolo de la fuente (VCC) y encima de él pinchas con el ratón. Aparecerá el símbolo del puerto, con un nombre similar a XLXN_1. Seguramente esté vertical, para ponerlo horizontal, selecciónalo (habiendo pulsado antes la tecla Esc) y pulsa CTRL+R para rotarlo y CTRL+M para voltearlo, también lo puedes hacer pinchando con el botón derecho del ratón. Como el nombre dado por la herramienta nos dice poco del puerto, le pondremos un nuevo nombre que nos ayude a identificar el puerto. Para ello, seleccionamos el puerto y pinchando con el botón derecho del ratón, seleccionamos la opción Rename Port. En el cuadro de diálogo escribiremos LD0, que hace referencia al LED 0 de la placa. Hasta ahora, el aspecto de nuestro circuito debería ser el siguiente:

Figura 2.9: El 1-lógico conectado al puerto LD0 Ahora realizaremos el mismo proceso para conectar el puerto LD1 a un 0-lógico. Para ello, primero situamos el símbolo de tierra en el mapa del circuito. En la ventana superior de símbolos mantenemos la selección General y en la ventana inferior seleccionamos gnd (del inglés ground : tierra). Situamos la tierra en el mapa del circuito y posteriormente, de la misma manera que hicimos anteriormente, la conectamos a otro puerto de salida. Este puerto de salida lo llamaremos LD1, haciendo referencia al LED número 1 de la placa.

Figura 2.10: Esquema final de nuestro circuito Diseño digital con esquemáticos y FPGA. v1.8 - 04/06/2008

9

Departamento de Tecnología Electrónica

2. Encender un LED

Ya tenemos nuestro primer diseño hecho. Le damos a guardar (es algo que deberías hacer de vez en cuando), y procederemos a implementarlo en la FPGA. Fíjate que cuando no has guardado, el nombre del circuito que está en la pestaña del esquemático tiene un asterisco.

2.2. Síntesis e implementación del circuito Ahora selecciona la ventana de procesos y la ventana de fuentes (Sources). En la ventana de fuentes verifica que el componente y el fichero que hemos creado está seleccionado: led0(led0.sch). Pincha en él una vez si no estuviese seleccionado. Aunque a los puertos de salida les hayamos dado unos nombres referidos a los LED que vamos a utilizar, la herramienta no sabe qué pines queremos utilizar. Para indicarle a la FPGA qué pines vamos a utilizar y con qué puertos de nuestro diseño los vamos a conectar deberemos lanzar la herramienta PACE. Esto lo hacemos desde la ventana de procesos, en ella despliega la sección que dice User Constraints, pincha dos veces en Assign Package Pins (figura 2.11). Posteriormente nos saldrá una ventana de aviso que nos indica que para este proceso se requiere añadir al proyecto un fichero del tipo UCF. Este tipo de ficheros son los que se usan para definir las conexiones de los pines de la FPGA con los puertos de nuestro diseño, y por tanto pinchamos en Yes.

Figura 2.11: Selección para la asignación de pines Ahora nos aparecerá la herramienta Xilinx PACE. En ella podemos distinguir tres subventanas, la de la derecha, tiene 2 pestañas en su parte inferior, en una se muestra la arquitectura de la FPGA y en la otra la asignación de los pines (ver figura 2.12). En la subventana de la parte inferior izquierda hay una tabla con los nombres de nuestros puertos: LD0 y LD1. En una columna se indica la dirección de los puertos (ambos de salida: output). Y en la siguiente columna (Loc) debemos indicar el pin de la FPGA con el que queremos unir nuestros puertos. Ten cuidado porque aquí hay un fallo de la herramienta, ya que si pinchas en las celdas de dicha columna aparece un menú desplegable con los bancos de la FPGA (los pines se organizan en bancos), pero en estas celdas hay que indicar los pines y no los bancos. Así que pinchamos en dichas celdas y ponemos nosotros mismos el pin que queremos conectar. Así, para el puerto LD0 conectamos el pin 46, para ello escribimos P46 (el mismo número que indica la placa añadiéndole una P). Para el puerto LD1 le asignamos el pin P45.

Diseño digital con esquemáticos y FPGA. v1.8 - 04/06/2008

10

Departamento de Tecnología Electrónica

2. Encender un LED

Figura 2.12: Herramienta PACE para la asignación de pines Le damos a guardar y nos saldrá una ventana que nos pregunta por el formato del fichero que guardará esta información. Aunque nos es indiferente, seleccionamos la primera opción "XST Default ", pinchamos en OK, cerramos la herramienta PACE y volvemos al ISE. En la ventana de procesos, tenemos ordenados los pasos que debemos tomar: "Synthesize-XST" , "Implement Design" y "Generate Programming File". Así que con este orden, vamos a ir pinchando dos veces en cada uno de ellos hasta que veamos que se pone una signo verde de correcto en ellos. Cuando se ponga en verde, pinchamos en el siguiente (puede salir en amarillo si indicando que hay advertencias -warnings- que muchas veces no son importantes). En realidad, si se ejecuta el último paso sin haber ejecutado los anteriores, la herramienta realiza todo el proceso. Cuando tengamos todos los pasos correctamente ejecutados, la subventana de procesos debería mostrar el aspecto de la figura 2.13. Si es así, ya estamos en disposición de programar la FPGA. Puede ser que aparezca algún warning y que el proceso de síntesis tenga un símbolo amarillo triangular. Los warnings se pueden ver en la ventana de design summary. De todos modos, en muchas ocasiones estas advertencias no son relevantes.

Figura 2.13: Aspecto de la subventana de procesos una vez que se ha sintetizado e implementado el diseño correctamente. En la ventana de la derecha, en el proceso de síntesis ha habido advertencias (warnings) que no siempre son importantes, y por eso tiene un símbolo triangular de color amarillo

2.3. Programación de la FPGA Si hemos llegado hasta aquí, ya habremos generado el fichero de programación de la FPGA (que tiene extensión .bit). Ahora veremos los pasos que hay que dar para programarla. Lo primero que tenemos que hacer es quitar los tres jumpers de configuración: M0, M1 y M2 del conector J4, (ver situación en la figura 1.1). Para no perder las caperuzas conéctalos a un sólo conector dejando el otro al aire como se muestra a la derecha de la figura 2.14.

Diseño digital con esquemáticos y FPGA. v1.8 - 04/06/2008

11

Departamento de Tecnología Electrónica jumper conectado

2. Encender un LED jumper desconectado sin perder su caperuza

jumper desconectado su caperuza está perdida y pisoteada por el suelo del labo

Representación:

Figura 2.14: Jumpers y su conexión Cuando estos jumpers están conectados, la FPGA se programa desde la memoria flash de la placa, en la que se guarda un fichero de configuración para la FPGA. La Spartan-II es un tipo de FPGA volátil, esto es, requiere estar alimentada para mantener su configuración. Por tanto, cuando la apagamos se borra lo que hayamos programado. Para evitar tener que programar la FPGA desde el ordenador cada vez que encendamos nuestro sistema electrónico, se pone una memoria flash que la programa automáticamente. Si esto no fuese posible, este tipo de FPGA perdería casi toda su utilidad, ya que no serían autónomas y prácticamente sólo valdrían para hacer pruebas en el laboratorio. Como nosotros estamos haciendo pruebas, queremos programar la FPGA desde el ordenador y no desde la memoria flash, así que desconectamos los tres jumpers. Ahora hay que conectar el cable JTAG al puerto paralelo del ordenador y conectar el otro extremo del cable al conector JTAG de la placa (conector J2, ver figura 1.1). No debes conectarlo de cualquier manera, de las dos posibilidades que hay, hazlo de forma que los nombres de las señales de la placa coincidan con los nombres de las señales del cable. Esto es: TMS con TMS, TDI con TDI, ... , y VDD con VDD o con VCC (éste es el único caso en que pueden no coincidir exactamente, depende del conector). A continuación conectamos el cable de alimentación de la placa y lo enchufamos a la red eléctrica (y cuando lo desenchufes fíjate en que no se quede enchufado el adaptador de la clavija plana americana a clavija redonda europea). Al enchufar la placa verás que se enciende el LED LD8. Ya tenemos todo preparado para programar la FPGA y probar nuestro diseño. Volvemos al ordenador, al programa ISE. Dentro de "Generate Programming File" desplegamos el menú pinchando el cuadradito con el signo + dentro: + . Y pinchamos dos veces en "Configure Device (iMPACT)". Esto arrancará la herramienta iMPACT, que nos mostrará un ventana en la que se ofrecen varias opciones, dejamos la opción que hay por defecto "configure devices using Boundary-Scan (JTAG)" y "Automatically connect to a cable and identify Boudary-Scan chain". Aceptamos pinchando en Finish. Lo que hemos hecho es decirle a la herramienta que identifique los componentes que hay en la placa por medio del protocolo Boundary-Scan (JTAG). Después de esto la herramienta procede a identificar a la placa y debería encontrar dos componentes: la FPGA y la memoria flash. La FPGA la identifica como xc2s200 y la memoria como xcf02s. A continuación nos pedirá los ficheros de programación para cada uno de los componentes (figura 2.15).

Diseño digital con esquemáticos y FPGA. v1.8 - 04/06/2008

12

Departamento de Tecnología Electrónica

2. Encender un LED

Figura 2.15: iMPACT: componentes detectados y asignación de un fichero de configuración Para la FPGA hay que asignar el fichero led0.bit, sabremos que está asignando el fichero a la FPGA porque ésta tendrá color verde y además la extensión del fichero es .bit (para las memorias es otro). Seleccionamos el fichero y pinchamos en Open. Inmediatamente nos saldrá una advertencia (Warning) que habla sobre el Startup Clock, esto no nos afecta y pulsamos en Ok. Ahora nos pide el fichero de configuración de la memoria. Como no vamos a programarla, pulsamos en Cancel.

En la ventana central del iMPACT tenemos los dos componentes. Pinchando en cualquiera de ellos, los seleccionamos y se pondrán de color verde. Si pinchamos en la FPGA (xc2s200 ó xc2s50) con el botón derecho del ratón, nos saldrá un menú. Puede pasar que al pinchar no salga y que aparezca de nuevo la ventana de la figura 2.15, eso es que se ha quedado el puntero del ratón enganchado; para evitarlo, pincha con el botón izquierdo en cualquier parte de la ventana fuera de los símbolos de los chips y vuelve a intentarlo. Ahora, en el menú que aparece podemos asignar un fichero de configuración diferente o programar la FPGA (figura 2.16). Y esto es lo que vamos hacer, pinchamos en Program, y le damos a Ok a la siguiente ventana sin cambiar nada (si diésemos a Verify daría un error de programación).

Figura 2.16: Orden para programar la FPGA Diseño digital con esquemáticos y FPGA. v1.8 - 04/06/2008

13

Departamento de Tecnología Electrónica

2. Encender un LED

Después de la orden de programar la FPGA, aparece un cuadro que muestra la evolución y, si todo ha salido bien, la herramienta nos avisará de que hemos tenido éxito en la programación mostrando un aviso como el de la figura

Figura 2.17: Programación realizada con éxito Ahora miramos la placa y debería haber tres LED encendidos: • LD8: que indica que la placa está encendida • LD9: que indica que se ha programado la FPGA • LD0: que es el LED que hacemos encender nosotros con el diseño de la FPGA

El LED LD1 deberá estar apagado, pues lo hemos puesto a un '0' lógico. Y el resto de LED también estarán apagados debido a las resistencias de pull-down que la FPGA pone en los puertos sin conectar. Con esto hemos terminado el primer ejercicio. Hemos comprobado que la placa y la herramienta funcionan, y ya podemos probar otros diseños más complejos.

Diseño digital con esquemáticos y FPGA. v1.8 - 04/06/2008

14

3. Puertas lógicas, interruptores y pulsadores

Departamento de Tecnología Electrónica

3. Puertas lógicas, interruptores y pulsadores En este ejercicio vamos diseñar un circuito sencillo con el que podamos interactuar. Para ello usaremos como entradas del circuito los interruptores y pulsadores de la placa. Además incluiremos alguna lógica interna. A partir de ahora no se va a realizar una explicación tan detallada como la del primer ejercicio, si durante la ejecución de este ejercicio has olvidado algún paso, repasa lo explicado en el ejercicio anterior. Analizando las conexiones de los interruptores (figura 3.1) vemos que cuando el interruptor está hacia arriba transmite un 1-lógico a la entrada de la FPGA. En la placa, a la derecha del interruptor SW0 se indica que hacia arriba son 3,3V y hacia abajo son 0V. PIN 89 88 87 86 84 83 82 81

4,7kΩ

Spartan-II

3,3V

Spartan-II

3,3V

interruptor SW0 SW1 SW2 SW3 SW4 SW5 SW6 SW7

4,7kΩ

4,7kΩ

0,1μF

PIN pulsador 59 BTN0 58 BTN1 57 BTN2 154 BTN3

Figura 3.1: Esquema eléctrico de las conexiones de los interruptores y pulsadores en la placa Pegasus Para los pulsadores, cuando están pulsados transmiten un 1-lógico a la entrada y cuando no están pulsados ponen 0 voltios a la entrada. Observa que los pulsadores tienen un pequeño circuito con resistencias y un condensador, esto es para eliminar los rebotes que se producen al pulsar y así enviar una señal sin ruido.

3.1. Diseño del circuito Creamos un nuevo proyecto (File→New Proyect...) llamado swt0 con las mismas características que el anterior. Creamos una nueva fuente de tipo esquemático llamada swt0.sch. Y tendremos una pantalla similar a la de la figura 2.7. Como vamos a realizar el circuito con puertas lógicas, en la subventana de categorías (Categories) dentro de la ventana de símbolos, seleccionamos el elemento Logic. Veremos como en la subventana de símbolos (Symbols) aparecen nombres relativos a puertas lógicas (and12, and16, and2, or2, ...) el número indica el número de entradas de la puerta y si hay alguna b indica que tiene una entrada negada. La figura 3.2 muestra ejemplos de esta nomenclatura. and2

AND de 2 entradas

and2b1

AND de 2 entradas con una de ellas negada

and3b2

AND de 3 entradas con dos de ellas negadas

Figura 3.2: Ejemplos de la nomenclatura de las puerta lógicas Lo primero que haremos es añadir una puerta AND (and2) en el mapa y conectamos sus entradas y salidas con puertos (Add→I/O Marker). Los puertos de entrada los llamaremos SW0 y SW1, que se corresponderán con los interruptores 0 y 1. Y el puerto de salida lo renombraremos como LD0, que será el LED número cero. Quedando como muestra la figura 3.3.

Figura 3.3: Implementación de la puerta AND De manera similar conectaremos los interruptores SW2 y SW3 con la entrada de una puerta conectaremos a LD1, obteniendo algo similar a la figura 3.4.

Diseño digital con esquemáticos y FPGA. v1.8 - 04/06/2008

OR,

y su salida la

15

3. Puertas lógicas, interruptores y pulsadores

Departamento de Tecnología Electrónica

Figura 3.4: Implementación de la puerta OR Ahora conectaremos un inversor al pulsador BTN0 y su salida la conectaremos a LD2:

Figura 3.5: Implementación de un inversor Además queremos conectar la entrada del pulsador BTN0 a LD3. Como no podemos conectar directamente el puerto de entrada BTN0 al puerto de salida LD3, los conectamos mediante un buffer. Para ello, en la subventana de categorías (Categories) seleccionamos Buffer. Para el símbolo seleccionamos buf y lo situamos encima del inversor (fíjate que el símbolo es el mismo pero sin la bolita a la salida, por eso no invierte). Conectamos la salida del buffer al LED LD3.

Figura 3.6: Buffer que queremos conectar a la misma entrada (BTN0) que la del inversor Para conectar la entrada del buffer al puerto de entrada

BTN0

necesitamos un cable. Los cables los

, o bien tecleando CTRL+W. Una vez que hemos implementan pinchando en Add→Wire, o bien con el icono seleccionado este comando, veremos que en la ventana de opciones aparecen las opciones para situar los cables. En ella seleccionamos la primera opción: Use the Autorouter to add one o more line segments between the points you indicate. Y posteriormente pinchamos al cable que está entre la salida del puerto BTN0 y la entrada del inversor; sin soltar el botón del ratón, nos dirigimos a la entrada del buffer. Puede pasar que la herramienta dé un mensaje que diga: The pin 'I' is already connected to a net. Only one net is allowed to connect to a pin. Con esto quiere decir que sólo se puede conectar un cable a un pin. Pero lo que sí se puede hacer es conectarlo al cable que une el pin con la entrada del inversor. Puede ser que tengas poco espacio entre el pin y la entrada del inversor. Para alargar ese cable, puedes seleccionar y arrastrar el pin de entrada a la izquierda. Ahora será más fácil conectar la entrada del buffer con el cable.

Figura 3.7: Conexión final del buffer e inversor Nuestro diseño final tiene 3 entradas (SW0, siguiente aspecto:

SW1

y

BRN0)

y 4 salidas (LD0,

LD1, LD2

y

LD3).

Y deberá tener el

Figura 3.8: Diseño final del ejercicio

Diseño digital con esquemáticos y FPGA. v1.8 - 04/06/2008

16

Departamento de Tecnología Electrónica

3. Puertas lógicas, interruptores y pulsadores

Para comprobar que hemos hecho la conexión bien podemos pinchar en Tools→Check Schematic, y revisamos la ventana inferior (Console) para ver si ha detectado algún error o advertencia. Grabamos el esquemático: File→Save (esto deberías hacerlo regularmente). Debido a que es un diseño pequeño podríamos probar el circuito directamente en la placa, sin embargo vamos a simularlo antes para aprender el proceso.

3.2. Simulación del circuito Una vez que hemos terminado el esquemático y lo hemos grabado, seleccionamos la ventana de fuentes (Sources) y la ventana de procesos (Processes).

En la parte superior de la ventana de fuentes, vemos que indica Sources for: "Synthesis/Implementation" (ver figura 3.9). El menú desplegable permite seleccionar el tipo de ficheros fuente con los que se quiere trabajar: para simulación o para síntesis. Es importante conocer esta opción, debido a que nos puede ocurrir que no veamos un fichero que hemos creado a causa de tener seleccionada una opción que no lo muestra. Por ejemplo, los ficheros para simulación no se verán en caso de tener seleccionada la opción de síntesis. Selección de fuentes para: - Síntesis/Implementación - Simulación comportamental - Simulación post-rutado

Figura 3.9: Selección de los ficheros fuente según el tipo de actividad que se vaya a realizar Como ahora queremos simular el circuito para comprobar su funcionamiento, seleccionamos Sources for: "Behavioural Simulation" . Como resultado de esta selección, la ventana de procesos cambia. Por lo tanto, si en cualquier momento ves que la ventana de procesos no está como piensas que debería estar, comprueba que has seleccionado el menú de fuentes adecuado. Por ejemplo, puede pasar que quieras sintetizar el diseño y no aparezca el comando, entonces mira qué opción tienes seleccionada. Ahora crearemos un nuevo fichero para simular nuestro diseño. Mediante un cronograma, este fichero indicará al simulador qué valores toman las entradas en función del tiempo. En la ventana de procesos pinchamos dos veces en Create New Source. Y nos saldrá una ventana como la de la figura 3.10, que es similar a la que ya vimos en la figura 2.5.

Figura 3.10: Creación de una fuente para la simulación Tal como se muestra en la figura 3.10, seleccionamos el tipo de fichero como Test Bench Waveform. Lo nombramos tb_swt0 y pinchamos en Next. Test Bench significa "banco de pruebas", y eso es lo que queremos hacer, un banco de pruebas que demuestre que el diseño funciona como queremos. Waveform significa

Diseño digital con esquemáticos y FPGA. v1.8 - 04/06/2008

17

Departamento de Tecnología Electrónica

3. Puertas lógicas, interruptores y pulsadores

"forma de onda", así que nuestro banco de pruebas lo definiremos con las formas de onda de los puertos de entrada (ahora veremos cómo y por qué). La siguiente ventana nos pide que seleccionemos el diseño que vamos a probar con el banco de pruebas. En nuestro caso solo hay uno: swt0. Y así que pinchamos en Next y en la siguiente ventana en Finish. Surgirá una ventana que nos pide mucha información (figura 3.11). Como nuestro circuito no tiene reloj ni elementos de memoria (ya los estudiaremos en el tema 7) es un circuito combinacional, y por tanto, en el apartado de Clock Information, seleccionamos Combinatorial (or internal clock). Además, deseleccionamos la casilla GSR (FPGA) y el resto de opciones las dejamos como están y pinchamos en Finish.

Figura 3.11: Opciones de la temporización de la simulación Y así llegamos a una ventana como la de la figura 3.12 en la que en la vertical se muestran los puertos de entrada y salida, y en la horizontal un eje de tiempos. En medio de estos dos ejes tendremos los valores de las señales según el tiempo en que estemos.

Puertos Puertos de de entrada entrada

Eje Eje temporal temporal

Puertos Puertos de de salida salida

Valores Valores de de las las señales señales en en el el tiempo tiempo

Figura 3.12: Ventana de los cronogramas de las señales de simulación

Diseño digital con esquemáticos y FPGA. v1.8 - 04/06/2008

18

3. Puertas lógicas, interruptores y pulsadores

Departamento de Tecnología Electrónica

Ahora nosotros tenemos que asignar los valores de los puertos de entrada, para que a partir de ellos el simulador calcule los de salida. Inicialmente, la ventana asigna a todos los puertos de entrada el valor '0'. Nosotros vamos a asignar diversos valores para comprobar el funcionalidad de nuestro circuito en distintos casos. Antes de asignar los valores, vamos a agrupar las señales entre sí, para comprobar de manera más fácil los resultados de la simulación. SW0 y SW1 van a las entradas de una puerta AND cuya salida es LD0. Así que las vamos a poner juntas. Esto se hace pinchando en el nombre del puerto y arrastrándolo hasta donde queramos. Hacemos lo mismo con el resto: SW2, SW3 y LD1 juntas; y por último BTN0 junto con LD2 y LD3. Pinchando en los recuadros azules del cronograma de los puertos de entrada modificamos su valor. El ancho de estos cuadrados se define en la ventana de la figura 3.11, nosotros los dejaremos con su valor por defecto. Como tenemos un diseño pequeño, los valores de las entradas que vamos a asignar cubrirán todas las posibilidades para cada puerta. Así, haremos que las entradas SW0 y SW1, de la puerta AND, tomen todos los valores de la tabla de verdad. En la figura 3.13 se muestran los valores que se quieren asignar a los puertos de entrada y los intervalos de tiempo en que se asignarán. También se muestra los valores que deben salir (los valores de los LED) y que más adelante comprobaremos si coinciden con los de la simulación. LD1: OR

LD0: AND tiempo 0-100ns 100-200 200-300 300-400

SW0 SW1 LD0 0 0 0 0 1 0 1 0 0 1 1 1

tiempo 0-100ns 100-200 200-300 300-400

LD2: NOT SW2 SW3 LD1 0 0 0 0 1 1 1 0 1 1 1 1

tiempo 0-200ns 200-400

BTN0 LD2 LD3 0 1 0 1 0 1

Figura 3.13: Asignación de valores a los puertos de entrada de modo que cubran todas las posibilidades de la tabla de verdad Asignando los valores de la figura 3.13 obtendremos un cronograma como el mostrado en la figura 3.14. Cuando lo tengamos hecho lo grabamos y comprobaremos cómo aparece en la ventana de fuentes: tb_swt0.tbw, y cómo dentro de él está nuestro diseño 4: UUT – swt0(swt0.sch).

Figura 3.14: Valores en los puertos de entrada para la simulación Para simularlo, en la ventana de fuentes (Sources) el fichero tb_swt0.tbw debe estar seleccionado, y en la ventana de Procesos, dentro de Xilinx ISE Simulator, pincharemos dos veces en Simulate Behavioral Model. Esto dará la orden para llevar a cabo la simulación, y finalmente obtendremos los resultados de la simulación en el cronograma (figura 3.15). Las señales se pueden haber descolocado y las volvemos a colocar en el mismo orden. Ahora debemos comprobar que los valores a las salidas se corresponden con los valores que esperamos (los de la figura 3.13). Para comprobar el buen funcionamiento de LD0 vemos que está a '1' sólo cuando SW0 y SW1 están a '1'. Esto es así porque es una AND. Para la LD1, como es una OR, valdrá '1' cuando SW2 o SW3 sean '1'. Y por último, vemos que LD2 y LD3 tienen valores complementarios, ya que LD2 invierte el valor de BTN0 y LD1 lo asigna directamente. Así pues, se cumple lo que habíamos esperado en la figura 3.13.

4

UUT indica el componente que se está comprobando, es el acrónimo del inglés: Unit Under Test

Diseño digital con esquemáticos y FPGA. v1.8 - 04/06/2008

19

Departamento de Tecnología Electrónica

3. Puertas lógicas, interruptores y pulsadores

Figura 3.15: Resultados de la simulación Después de haber comprobado la funcionalidad del circuito, nos disponemos a implementarlo en la FPGA

3.3. Síntesis e implementación del circuito Los pasos que debemos tomar son casi los mismos que los que tomamos en el ejemplo anterior. Aunque ahora, como venimos de la simulación, lo primero que tienes que hacer es seleccionar en la ventana de fuentes las fuentes para síntesis: Sources for: "Synthesis/Implementation" (ver figura 3.9). Debemos también activar la ventana de procesos, que es donde le indicaremos a la herramienta que comandos de síntesis debe ejecutar (recuerda la figura 2.7). Antes de dar la orden de sintetizar debes asignar los pines de la FPGA. Ahora tenemos más pines que asignar. Repite el mismo proceso y asigna los pines conforme a la numeración de la placa (si se te ha olvidado, vuelve a mirarte el ejercicio anterior). Ya podemos sintetizar e implementar el circuito y pasarlo a la placa. Si todo ha salido bien, podrás comprobar que los LED de la placa se enciende en función del estado de los interruptores y el pulsador 0.

Diseño digital con esquemáticos y FPGA. v1.8 - 04/06/2008

20

Departamento de Tecnología Electrónica

4. Decodificador de 2 a 4

4. Decodificador de 2 a 4 En este ejercicio implementaremos un decodificador de 2 a 4 como los que hemos visto en clase. Un decodificador de 2 a 4 recibe dos entradas que están codificadas en binario y según que número esté codificado activa la salida correspondiente a ese número. Por ejemplo, si el número de la entrada es 102, activará la salida 2, ya que 102 es dos en binario. Además, los decodificadores suelen tener una señal de habilitación (enable) que en caso de no estar activa, todas las salidas estarán también inactivas independientemente del valor del resto de entradas. Por tanto, nuestro decodificador será un bloque como el mostrado en la figura 4.1, cuya tabla de verdad también se muestra. DECOD 2a4 A0

S0 S1

A1

S2 S3

E

E 0 1 1 1 1

A1 X 0 0 1 1

A0 X 0 1 0 1

S3 0 0 0 0 1

S2 0 0 0 1 0

S1 0 0 1 0 0

S0 0 1 0 0 0

Figura 4.1: Decodificador de 2 a 4 y su tabla de verdad

4.1. Diseño del decodificador Si nos fijamos en la tabla de verdad del decodificador (figura 4.1), considerando que E=1, podemos ver que cada una de las salidas S0, S1, S2 y S3, se corresponde con un término mínimo de A1 y A0. Por ejemplo, la ⎯⎯ · A0 ⎯⎯ ); la salida S1 es el término mínimo 1 (m1= A1 ⎯⎯ ·A0), y de manera salida S0 es el término mínimo 0 (m0= A1 similar para el resto. Luego sólo tendremos que añadir la habilitación y obtendremos las salidas. Empecemos a diseñar: primero creamos un nuevo proyecto llamado decod2a4 en el directorio Recuerda no poner tildes ni eñes, y mejor si no pones espacios. El proyecto debe tener las mismas características de los proyectos anteriores. Creamos también una nueva fuente con el mismo nombre y de tipo esquemático (Schematic). Ya tendremos que tener el plano vacío de nuestro circuito.

C:/practica/edi/tunombre.

Ya que el decodificador implementa todos los términos mínimos, necesitaremos todas las entradas negadas y afirmadas (no negadas). Como los puertos no se pueden colocar solos (se deben conectar a las patas de algún componente), empezamos colocando los dos inversores de las entradas A1 y A0. Y posteriormente les conectamos los puertos de entrada (figura 4.2).

Figura 4.2: Inversores colocados a las entradas para formar los términos mínimos ). El otro lado del cable lo Ahora conectamos un cable a la salida de cada inversor (mediante el icono dejamos al aire: pinchamos en un punto más alejado a la derecha y pulsamos la tecla ESC. El extremo del cable tendrá un cuadradito rojo que indica que sin conectar (al aire). Vamos a nombrar los terminales de cada cable que hemos dejado al aire. Seleccionamos Add→Net Name (también hay un icono ). Y en la ventana de opciones, en el apartado Name ponemos el nombre del cable. Para el negado de A1 lo llamamos N_A1, y el negado de A0 lo llamamos N_A0. Para colocarlo nos ponemos al final del cable y pinchamos encima. Para colocar el segundo, cambiamos el nombre y repetimos la operación. Llegados a este punto, deberíamos tener:

Figura 4.3: Inversores con nombre a la salida

Diseño digital con esquemáticos y FPGA. v1.8 - 04/06/2008

21

Departamento de Tecnología Electrónica

4. Decodificador de 2 a 4

A continuación incluiremos 4 puertas AND de dos entradas que se encargarán de crear los 4 términos mínimos. Por ahora simplemente las creamos una debajo de la otra, y conectamos un cable a la salida de cada una de ellas.

Figura 4.4: Inversores y las cuatro puertas AND para formar los términos mínimos Ahora vamos a conectar las entradas de cada una de las puertas. La puerta de arriba será la del término mínimo cero (m0) y la de abajo m3. Para unir los cables de los puertos de entrada (negados o no) con las entradas de las puertas usamos el comando Add→Net¸ y dejamos la opción por defecto: Use the Autorouter to add one or more line segments between the points you indicate. Al unir los cables veremos que en las uniones se forma un cuadradito que indica la conexión entre cable. Al terminar de unir los cables tendremos un circuito como el siguiente. Si te equivocas, usa CTRL+Z para deshacer la última unión.

Figura 4.5: Términos mínimos del decodificador Añade también los nombres de cada uno de los términos mínimos (como se ve en la figura 4.5). Para facilitar la tarea, puedes empezar por m0, y si seleccionas dentro de la ventana de opciones, en el apartado que indica After naming the branch or net marcas la opción: Increase the name; el índice de término mínimo se incrementará por sí solo. Ahora sólo nos queda incluir la señal de habilitación. Cuando ésta es cero, las salidas son cero, por tanto se puede añadir al final de cada término mínimo mediante una puerta AND. Recuerda que la puerta AND Diseño digital con esquemáticos y FPGA. v1.8 - 04/06/2008

22

Departamento de Tecnología Electrónica

4. Decodificador de 2 a 4

actúa como una compuerta en el sentido que si E='0' la salida vale '0' (inhabilitada) y si E='1' la salida vale lo que la otra entrada (ver figura 4.6). E → Habilitación m0 E

S0

E='0' → Salida inhabilitada m0 E='0'

S0='0'

E='1' → Salida habilitada m0 E='1'

S0=m0

Figura 4.6: Puerta AND como habilitación Añadimos las puertas y las conectamos con la señal de habilitación. El circuito debería quedarnos como la siguiente figura

Figura 4.7: Esquema de puertas del decodificador Antes de seguir, debemos guardar el fichero (CRTL+S) y comprobar si todas las conexiones están bien hechas: Tools→Check Schematic. Debemos ver los errores o advertencias que puedan aparecer en la consola (ventana de abajo). Si hubiese algún error, debemos comprobar qué cable o componente se trata, moverlo para ver si realmente está conectado y conectarlo bien. Vuelve a comprobar el esquemático (Tools→Check Schematic) cuantas veces haga falta hasta que no tengas errores, y el final guarda el fichero.

4.2. Comprobación del diseño Antes de implementarlo en la placa vamos a ver si está bien diseñado. Para ello seguimos los mismos pasos que en el apartado 3.2: • • • • • • •

Seleccionamos en la ventana de fuentes (Sources) la opción de Behavioural Simulation En la ventana de procesos pinchamos en Create New Source Seleccionamos el tipo: Test Bench Waveform, y nombramos el fichero tb_decod2a4 En la ventana de las opciones del cronograma (figura 3.11) indicamos que es un diseño combinacional y deseleccionamos GSR (FPGA), que está dentro Global Signals. Para terminar pinchamos en Finish. Introducimos en el cronograma los valores de las entradas y guardamos el fichero del banco de pruebas Damos la orden de simular Simulate Behavioral Model. Comprobamos si los valores a las salidas son correctos.

Como sólo tenemos 3 entradas, introduciremos las 8 combinaciones posibles. Éstas se muestran en la figura 4.8.

Diseño digital con esquemáticos y FPGA. v1.8 - 04/06/2008

23

Departamento de Tecnología Electrónica

4. Decodificador de 2 a 4

Figura 4.8: Valores introducidos en el cronograma para la simulación del decodificador Después de la simulación, los resultados de las salidas son:

Figura 4.9: Cronograma de la simulación Podemos ver que los resultados de la simulación son correctos. Cuando E='0' no hay ninguna salida activa, y cuando E='1' se van activando las distintas salidas según cambian las entradas.

4.3. Implementación del diseño Ahora pasamos a implementarlo en el FPGA, si no te acuerdas, repasa lo visto en el apartado 2.2. Aquí te recordamos los pasos principales: • • • • •

Como venimos de la simulación, lo primero que tienes que hacer es seleccionar en la ventana de fuentes las fuentes para síntesis: Sources for: "Synthesis/Implementation" (ver figura 3.9). Activa la ventana de procesos, que es donde le indicaremos a la herramienta que comandos de síntesis debe ejecutar (recuerda la figura 2.7). Asigna los pines de la FPGA. Asigna el puerto A0 al interruptor SW0, el puerto A1 al interruptor SW1, y la habilitación a el interruptor SW7. Los 4 LED de salida asígnalos consecutivamente. Sintetiza e implementa el diseño Comprueba que funciona como debe funcionar

4.4. Creación de un bloque Si hemos llegado hasta aquí significa que nuestro diseño funciona bien, tanto en simulación como físicamente en la placa, ahora vamos a crear un módulo que integre este codificador para que cada vez que lo necesitemos implementar en diseños más grandes, no tengamos que crear todo el esquema de puertas sino que conectaremos un bloque como el de la figura 4.1. Sería similar a un componente MSI (Medium Scale Integration) como los chips disponibles para diseño con componentes discretos. Por ejemplo los decodificadores 74LS138 y 74LS139. Esto nos permitirá subir el nivel de abstracción y diseñar con bloques lógicos en vez de con puertas, lo que hará que podamos diseñar de manera más rápida y con menos probabilidad de equivocarnos, ya que cada uno de los bloques están probados y sabemos que funcionan correctamente. Volvemos a la vista del mapa del circuito: dentro de la ventana de fuentes pinchamos dos veces en el decodificador (decod2a4) o bien seleccionándolo directamente en la pestaña de la ventana grande. Para crear el módulo (Xilinx lo llama símbolo) pinchamos en Tools→Symbol Wizard, lo que hará que aparezca una ventana (figura 4.10) que nos preguntará para qué componente vamos a crear un símbolo. En la opción Pin Name Source, seleccionamos Using Schematic, y aparecerá el único esquemático que hemos creado en este proyecto: decod2a4.

Diseño digital con esquemáticos y FPGA. v1.8 - 04/06/2008

24

Departamento de Tecnología Electrónica

4. Decodificador de 2 a 4

Figura 4.10: Selección del componente para el que vamos a crear un símbolo Pinchamos en Next y aparecerá una ventana con las entradas y salidas del módulo. En ella podemos cambiar el lugar donde aparecerán (derecha o izquierda) y el orden. Ponemos el mismo orden de la figura 4.11.

Figura 4.11: Determinación de la posición de los pines del símbolo Pinchando en Next la siguiente ventana nos preguntan por las distancias y los tamaños del símbolo. Lo dejamos como está, o bien, si lo prefieres de otra manera, puedes modificarlo a tu gusto. Volvemos a pinchar en Next, y tendremos una ventana con el símbolo de nuestro decodificador (figura 4.12). Si nos gusta pinchamos en Finish.

Diseño digital con esquemáticos y FPGA. v1.8 - 04/06/2008

25

Departamento de Tecnología Electrónica

4. Decodificador de 2 a 4

Figura 4.12: Aspecto final del símbolo de nuestro decodificador Por último tendremos el decodificador en el editor de esquemáticos (figura 4.13), en donde hay una pestaña para acceder al esquema en puertas.

Esquema Esquema en en puertas puertas

Símbolo Símbolo

Figura 4.13: Símbolo del decodificador en el editor de esquemáticos Ahora podremos utilizar este símbolo en otros diseños. En esto va a consistir el próximo ejercicio.

Diseño digital con esquemáticos y FPGA. v1.8 - 04/06/2008

26

Departamento de Tecnología Electrónica

5. Decodificador de 3 a 8

5. Decodificador de 3 a 8 Hemos realizado el decodificador de 2 a 4, utilizando dos interruptores encendíamos uno de los cuatro primeros LED. Ahora vamos a construir un decodificador que encienda uno de los 8 LED, utilizaremos para ello los tres primeros interruptores. Aunque este ejercicio ya se ha explicado en clase, vamos a repasarlo un poco. En la figura 5.1 se muestra el bloque final que queremos obtener y la tabla de verdad. La tabla de verdad es muy similar a la del codificador de 2 a 4 (figura 4.1). Podríamos hacer el ejercicio de la misma manera que el decodificador de 2 a 4, sin embargo, si lo hacemos uniendo dos decodificadores de 2 a 4 lograremos diseñarlo de manera mucho más rápida y entendible. Es difícil de entender el funcionamiento de un diseño grande en puertas, mientras que si lo hacemos con bloques es más claro. S0

A0

S1 DECOD 3a8

A1 A2

E 0 1 1 1 1 1 1 1 1

S2 S3 S4 S5 S6

E

S7

A2 X 0 0 0 0 1 1 1 1

A1 X 0 0 1 1 0 0 1 1

A0 X 0 1 0 1 0 1 0 1

S7 0 0 0 0 0 0 0 0 1

S6 0 0 0 0 0 0 0 1 0

S5 0 0 0 0 0 0 1 0 0

S4 0 0 0 0 0 1 0 0 0

S3 0 0 0 0 1 0 0 0 0

S2 0 0 0 1 0 0 0 0 0

S1 0 0 1 0 0 0 0 0 0

S0 0 1 0 0 0 0 0 0 0

Figura 5.1: Esquema del decodificador de 3 a 8 y su tabla de verdad Si analizamos la tabla de verdad y la dividimos en tres partes según los valores de podemos ver que: • • •

Cuando E=0, el circuito está inactivo Cuando E=1, y A2=0, las señales S7 a decodificador de 2 a 4. Cuando E=1, y A2=1, las señales S3 a decodificador de 2 a 4. E 0

E

y

A2

(figura 5.2),

S4

están inactivas, y las señales

S3

a

S0

se comportan igual que el

S0

están inactivas, y las señales

S7

a

S4

se comportan igual que el

A2 A1 A0 X X X

S7 S6 S5 S4 S3 S2 S1 S0 0 0 0 0 0 0 0 0 todas '0'

E 1 1 1 1

A2 0 0 0 0

A1 0 0 1 1

A0 0 1 0 1

S7 0 0 0 0

S6 0 0 0 0

S5 0 0 0 0

S4 0 0 0 0

todas '0'

misma secuencia E 1 1 1 1

A2 1 1 1 1

A1 0 0 1 1

A0 0 1 0 1

S7 0 0 0 1

S6 0 0 1 0

S5 0 1 0 0

S3 0 0 0 1

S2 0 0 1 0

S1 0 1 0 0

S0 1 0 0 0

A2 = '0'

igual que decod2a4 S4 1 0 0 0

S3 0 0 0 0

igual que decod2a4

S2 0 0 0 0

S1 0 0 0 0

S0 0 0 0 0

A2 = '1'

todas '0'

Figura 5.2: Tabla de verdad del decodificador de 3 a 8 dividida según el valor de E y A2 Por tanto, podemos usar dos decodificadores de 2 a 4, uno para las señales S3 a S0, que se activará cuando ⎯⎯ ; y otro decodificador para las señales S7 a S4, que se activará cuando E=1 y A2=1 E=1 y A2=0 ; esto es E· A2 (E·A2). La salida S0 de este último decodificador de 2 a 4 irá a la salida S4 del decodificador de 3 a 8, y así sucesivamente con el resto de señales. Diseño digital con esquemáticos y FPGA. v1.8 - 04/06/2008

27

Departamento de Tecnología Electrónica

5. Decodificador de 3 a 8

Intenta realizarlo tú mismo, y si no te sale puedes ver la solución en la figura 5.5. A continuación vamos a diseñarlo.

5.1. Diseño del decodificador con bloques Aunque lo podríamos crear en el mismo proyecto que el anterior, vamos a crear un nuevo proyecto. Ya sabes como se hace. Lo nombraremos decod3a8. Una vez que hemos indicado las características del proyecto estaremos en la ventana principal, y pincharemos en Proyect→Add Copy of Source.... Con ello vamos a añadir una copia del decodificador que ya hemos hecho a este nuevo proyecto. Vamos a hacer una copia para evitar estropear el diseño original. Después de ejecutar el comando aparecerá una ventana que nos pedirá el nombre del fichero que queremos añadir. Vamos al directorio del anterior proyecto y señalamos el fichero ..\decod2a4\decod2a4.sch y pinchamos en Abrir. Nos surgirá una ventana como la de la figura 5.3.

Figura 5.3: Fichero fuente que vamos a añadir Después de esto tendremos en nuestra ventana de fuentes (Sources) el componente decod2a4. Al importar decod2a4.sch se ha importado su esquemático, pero no el símbolo que habíamos creado para él. Así que volvemos a crear el símbolo repitiendo los pasos del apartado 4.4. Ahora crearemos una nueva fuente: pincha dos veces en el comando "Create New Source" de la ventana de procesos. Seleccionamos que es de tipo Schematic y la llamamos decod3a8. Como resultado tendremos el editor de esquemáticos vacío (el plano de nuestro nuevo diseño), y veremos que en la ventan de fuentes tenemos dos diseños: el decod2a4 que acabamos de añadir y el nuevo decod3a8 que vamos a diseñar. Seleccionamos la pestaña de la ventana de símbolos, y vemos que en la sección de categorías (Categories), la primera de ellas corresponde a nuestro proyecto, y si la seleccionamos aparece el símbolo que hemos creado: decod2a4. Esto se muestra en la figura 5.4.

Símbolos Símbolos del del proyecto proyecto

Símbolo Símbolo del del decodificador decodificador de de 22 aa 44

Decodificador Decodificador de de 22 aa 44

Figura 5.4: Implementación del decodificador de 2 a 4 en el nuevo decodificador

Diseño digital con esquemáticos y FPGA. v1.8 - 04/06/2008

28

Departamento de Tecnología Electrónica

5. Decodificador de 3 a 8

En el mapa del circuito añadimos dos referencias a decod2a4, que como ya hemos dicho, un decodificador es para las 4 primeras salidas y el otro para el resto. Ahora realizamos las conexiones entre los decodificadores decod2a4 y las entradas y salidas del nuevo decodificador decod3a8. Incluyendo también las señales de habilitación de cada uno de ellos, usando para ello puertas AND. Nota que para la habilitación del decodificador superior, la puerta AND debe tener la entrada de A2 negada. El circuito final se muestra en la figura 5.5.

Figura 5.5: Esquema final del decodificador de 3 a 8 Fíjate en lo rápido que lo has podido diseñar y lo simple del circuito, y compáralo con lo que te hubiese supuesto haberlo hecho todo en puertas lógicas. Antes de pasar al siguiente paso, guarda el diseño (CTRL+S) y comprueba que el diseño es correcto (Tools→Check Schematic). Si quieres puedes simularlo, siguiendo los pasos descritos en los apartados 3.2 y 4.2. Ahora asigna los pines de la FPGA de manera similar al ejemplo anterior

Figura 5.6: Conexión de los puertos del diseño con los pines de la FPGA Una vez implementado, comprueba que funciona correctamente y compáralo con los valores de la tabla de verdad y la simulación.

Diseño digital con esquemáticos y FPGA. v1.8 - 04/06/2008

29

Departamento de Tecnología Electrónica

6. Decodificador de 4 a 16

6. Decodificador de 4 a 16 ¿Y cómo haríamos un decodificador de 4 a 16 con decodificadores de 2 a 4? el proceso es muy similar al anterior. La figura 6.1 muestra este decodificador y su tabla de verdad. Ésta se puede dividir en 4 partes, una por decodificador.

A1

A1 X 0 0 1 1 0 0 1 1 0 0 1 1 0 0 1 1

A0 S15 S14 S13 S12 S11 S10 S9 X 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 1 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 1 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 1 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 1 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 1 0 0 0 0 0 0 1 0 0 0 0 0 0 1 0 1 0 0 0 0 1 0 0 0 0 0 0 1 0 0 0 1 0 0 1 0 0 0 0 0 0 1 0 0 0 0 0 0 1 0 0 0 0 0 0

S8 0 0 0 0 0 0 0 0 0 1 0 0 0 0 0 0 0

S7 0 0 0 0 0 0 0 0 1 0 0 0 0 0 0 0 0

S6 0 0 0 0 0 0 0 1 0 0 0 0 0 0 0 0 0

S5 0 0 0 0 0 0 1 0 0 0 0 0 0 0 0 0 0

S4 0 0 0 0 0 1 0 0 0 0 0 0 0 0 0 0 0

S3 0 0 0 0 1 0 0 0 0 0 0 0 0 0 0 0 0

S2 0 0 0 1 0 0 0 0 0 0 0 0 0 0 0 0 0

S1 0 0 1 0 0 0 0 0 0 0 0 0 0 0 0 0 0

S0 0 1 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0

decod 4

A2 X 0 0 0 0 1 1 1 1 0 0 0 0 1 1 1 1

decod 3

E

A3 X 0 0 0 0 0 0 0 0 1 1 1 1 1 1 1 1

decod 2

A3

DECOD4a16

A2

E 0 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1

decod 1

S0 S1 S2 S3 S4 S5 S6 S7 S8 S9 S10 S11 S12 S13 S14 S15

A0

Figura 6.1: Bloque del decodificador de 4 a 16, y su tabla de verdad En la tabla de verdad de la figura 6.1 vemos que las señales de salida se han agrupado de cuatro en cuatro. En la figura 6.2 se han separado estos grupos, más el caso en que E='0'. Podemos ver que para cada grupo se puede utilizar un decodificador de 2 a 4 como el que ya hemos diseñado. Todos los decodificadores tendrán las mismas entradas A1 y A0. La única diferencia está en las salidas a las que se conecta cada decodificador y la habilitación. Por ejemplo, el primer decodificador tendrá como salidas S0, S1, S2 y S3 y sólo estará habilitado cuando A3='0' y A2='0'; el segundo decodificador estará habilitado cuando A3='0' y A2='1'. Y de manera similar para el tercer y cuarto decodificador (como lo muestra la figura). E 0

A3 A2 A1 A0 S15 S14 S13 S12 S11 S10 S9 S8 S7 S6 S5 S4 S3 S2 S1 S0 X X X X 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0

E = '0': Inhabilitado

todas '0' E 1 1 1 1

A3 0 0 0 0

A2 0 0 0 0

A1 0 0 1 1

A0 S15 S14 S13 S12 S11 S10 S9 0 0 0 0 0 0 0 0 1 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 1 0 0 0 0 0 0 0

A3 0 0 0 0

A2 1 1 1 1

A1 0 0 1 1

A0 S15 S14 S13 S12 S11 S10 S9 0 0 0 0 0 0 0 0 1 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 1 0 0 0 0 0 0 0

A3 1 1 1 1

A2 0 0 0 0

A1 0 0 1 1

A3 = '1' A2 = '0' E 1 1 1 1

A3 1 1 1 1

A2 1 1 1 1

A3 = '1'

misma A2 = '1' secuencia

S6 0 0 0 0

S5 0 0 0 0

A1 0 0 1 1

S8 0 0 0 0

S7 0 0 0 1

S6 0 0 1 0

S5 0 1 0 0

S8 1 0 0 0

S7 0 0 0 0

S6 0 0 0 0

S5 0 0 0 0

S2 0 0 1 0

S1 0 1 0 0

S0 1 0 0 0

decod 0 activo cuando A3 = '0' A2 = '0'

S4 1 0 0 0

S3 0 0 0 0

S2 0 0 0 0

S1 0 0 0 0

S0 0 0 0 0

decod 1 activo cuando A3 = '0' A2 = '1'

todas '0' S4 0 0 0 0

S3 0 0 0 0

S2 0 0 0 0

S1 0 0 0 0

S0 0 0 0 0

S1 0 0 0 0

S0 0 0 0 0

decod 2 activo cuando A3 = '1' A2 = '0'

todas '0'

igual que decod2a4

A0 S15 S14 S13 S12 S11 S10 S9 0 0 0 0 1 0 0 0 1 0 0 1 0 0 0 0 0 0 1 0 0 0 0 0 0 1 0 0 0 0 0 0

igual que decod2a4

S3 0 0 0 1

igual que decod2a4

A0 S15 S14 S13 S12 S11 S10 S9 0 0 0 0 0 0 0 0 1 0 0 0 0 0 0 1 0 0 0 0 0 0 1 0 1 0 0 0 0 1 0 0

todas '0'

S4 0 0 0 0

igual que decod2a4 para las entradas A1 y A0

todas '0'

A3 = '0' A2 = '1' E 1 1 1 1

S7 0 0 0 0

todas '0'

A3 = '0' A2 = '0' E 1 1 1 1

S8 0 0 0 0

S8 0 0 0 0

S7 0 0 0 0

S6 0 0 0 0

S5 0 0 0 0

S4 0 0 0 0

S3 0 0 0 0

S2 0 0 0 0

decod 3 activo cuando A3 = '1' A2 = '1'

todas '0'

Figura 6.2: Tabla de verdad del decodificador de 4 a 16 dividida según el valor de E y de A3 y A2 Diseño digital con esquemáticos y FPGA. v1.8 - 04/06/2008

30

Departamento de Tecnología Electrónica

6. Decodificador de 4 a 16

Así que usaremos cuatro decodificadores de 2 a 4 para las 16 salidas. Además necesitaremos crear la lógica que se encargue de habilitar cada decodificador. Si nos fijamos en las señales A3 y A2 de la tabla de verdad, y de cómo habilitan a cada decodificador, podemos extraer la tabla de verdad de la figura 6.3. En ella se ponen las señales de habilitación de cada decodificador (E3, E2, E1, E0) en función de la habilitación general (E) y las entradas A3 y A2. Podemos ver que la tabla de verdad se corresponde con la tabla de verdad de un decodificador de 2 a 4 (figura 4.1), así que para las señales de habilitación de los cuatro decodificadores usaremos otro decodificador de 2 a 4. Señales de habilitación de los 4 decodificadores E 0 1 1 1 1

A3 X 0 0 1 1

A2 X 0 1 0 1

E3 0 0 0 0 1

E2 0 0 0 1 0

E1 0 0 1 0 0

E0 0 1 0 0 0

Ningún decodificador habilitado decodificador 0 habilitado decodificador 1 habilitado decodificador 2 habilitado decodificador 3 habilitado

Figura 6.3: Tabla de verdad de las señales de habilitación de los 4 decodificadores Con estas indicaciones (además de lo visto en clase) ya podemos diseñar el decodificador de 4 a 16.

6.1. Diseño del decodificador con bloques prediseñados Vamos a crear un nuevo proyecto en C:/practicas/edi/tunombre llamado sieteseg. Quizás te preguntes por qué no lo llamamos decod4a16, esto es porque aunque en este ejercicio vamos a hacer el decodificador de 4 a 16, en el siguiente ejercicio y trabajando en el mismo proyecto vamos a usar el visualizador (display) de siete segmentos. Creamos una nueva fuente (Project→New Source) de tipo esquemático (Schematic) llamada decod4a16. Para crear el decodificador de 4 a 16 vamos a emplear decodificadores de 2 a 4, igual que hicimos en el ejercicio 5. Sin embargo para este ejercicio, en vez de utilizar el decodificador que diseñamos en el ejercicio 4 utilizaremos un decodificador disponible en la biblioteca de símbolos de Xilinx. Si no tenemos en pantalla el plano para dibujar el circuito (el editor de esquemáticos) pinchamos dos veces en decod4a16.sch en la ventana de fuentes (Sources). Seleccionamos la ventana de símbolos y la de opciones (recuerda la figura 2.7). Ahora seleccionamos el decodificador de 2 a 4 disponible en la herramienta: en la ventana de símbolos en la subventana de categorías (Categories) seleccionamos Decoder. Y en la subventana de abajo llamada Symbols seleccionamos d2_4e. Este componente es un decodificador de 2 a 4 con una funcionalidad exactamente igual a la del que ya realizamos en el ejercicio 4. Las características del componente seleccionado, incluyendo su tabla de verdad, se pueden consultar pinchando el botón que dice Symbol Info. Si te fijas, hay más componentes, incluso hay un decodificador de 4 a 16, pero no lo usaremos, ya que en tal caso, este ejercicio ya estaría hecho. Como vamos a necesitar 5 decodificadores, cuatro para las salidas y uno para la habilitación, colocamos 4 componentes alineados verticalmente y el que decodifica las habilitaciones a la izquierda de ellos (figura 6.4).

Diseño digital con esquemáticos y FPGA. v1.8 - 04/06/2008

31

Departamento de Tecnología Electrónica

6. Decodificador de 4 a 16

Figura 6.4: Selección de los decodificadores de 2 a 4 disponibles en el ISE Realizamos la conexiones entre ellos, como vimos en la figura 6.2, las entradas de los decodificadores de la derecha son las mismas (A0 y A1) y a éstos conectamos las salidas. Las entradas del decodificador que se encarga de las habilitaciones son A2 y A3. El diseño final se muestra en la figura 6.5. Observa la señal de habilitación E, si ésta es 0¸ hace que todas las salidas del decodificador de la izquierda valgan 0, y por tanto inhabilita los 4 decodificadores de la derecha, haciendo que todas las salidas valgan 0. Si E='1' se habilitará un único decodificador dependiendo del valor de A2 y A3.

Figura 6.5: Diseño final del decodificador de 4 a 16 Una vez que lo hayas realizado, grábalo y comprueba que todo esté bien conectado (Tools→Check Schematic). Date cuenta de lo rápido que se puede diseñar usando bloques y lo tedioso que hubiese sido realizar este decodificador enteramente con puertas lógicas.

Diseño digital con esquemáticos y FPGA. v1.8 - 04/06/2008

32

Departamento de Tecnología Electrónica

6. Decodificador de 4 a 16

Ahora crearemos el símbolo de este decodificador para poder utilizarlo en el ejercicio siguiente. Recuerda el apartado 4.4, en donde se explicaba la creación de un símbolo (o bloque): • •

•

•

Pinchar en Tools→Symbol Wizard Aparecerá una ventana (figura 4.10) que nos preguntará para qué componente vamos a crear un símbolo: seleccionamos Using Schematic y quedará seleccionado el único que hay decod4a16. La ventana de los pines la dejamos como está, ya que aunque la disposición de los pines parece desordenada, en la columna Order están bien, pinchamos en Next. Y terminamos pinchando en Finish.

El resultado debe ser similar al de la figura 6.6.

Figura 6.6: Símbolo del decodificador de 4 a 16

6.2. Comprobación del diseño En la placa sólo tenemos 8 LED disponibles para usar, y sin embargo nuestro decodificador tiene 16 salidas. Así que no lo podemos probar fácilmente. En el siguiente ejercicio lo podremos probar, pero antes podemos simularlo. Procedemos como en el apartado 3.2, que lo recordaremos esquemáticamente: • • • •

Seleccionamos en la ventana de fuentes (Sources) la opción de Behavioural Simulation En la ventana de procesos pinchamos en Create New Source Seleccionamos el tipo: Test Bench Waveform, y nombramos el fichero tb_decod4a16 En la ventana de las opciones del cronograma (figura 3.11) indicamos que es un diseño combinacional y deseleccionamos GSR (FPGA), que está dentro Global Signals. Para terminar pinchamos en Finish.

Cuando tengamos la ventana para incluir los cronogramas de las entradas, pinchamos en "Test Bench→Set End of Test Bench" y ponemos 3000 ns. Esto lo hacemos para realizar un banco de pruebas más largo (verás que se amplía el tiempo del banco de pruebas). Ahora introducimos las 16 posibles combinaciones para las entradas A0, A2, A2 y A3, e incluimos unas cuantas más para probar que la habilitación E funciona bien. En la figura 6.7 se muestra los valores a las entradas. Con líneas discontinuas se han señalado el intervalo de tiempo en el cual una de las señales de salida se deben activar. En la parte inferior de la figura, entre las líneas discontinuas, se muestra cuál de las señales de salida es la que se debe activar. Observa también que al principio y al final de la simulación se ha puesto la señal de habilitación a cero para ver si funciona bien. Intenta entender el cronograma para que en ejercicios posteriores puedas hacerlo tú solo.

inhabilitado

0 1

2 3 4 5

6 7 8 9 10 11 12 13 14 15 0 1

inhabilitado →

Figura 6.7: Valores introducidos en el cronograma para la simulación del decodificador de 4 a 16 Una vez introducidos los valores en el cronograma: • • •

•

Guardamos el fichero del banco de pruebas Habiendo seleccionando el fichero tb_decod4a16 en la ventana de fuentes, desde la ventana de procesos damos la orden de simular: Simulate Behavioral Model (dentro de Xilinx ISE Simulator) El resultado de la simulación saldrá sólo para 1000 ns, como nuestro banco de pruebas lo queremos para 3000 ns, le indicaremos que simule el tiempo restante. Para ello ejecutamos dos veces el comando "Simulation→Run For Specified Time". El tiempo especificado por defecto para la simulación son 1000 ns. Este tiempo se puede modificar (figura 6.8) y además, como se muestra en la figura, existe un botón para ejecutar la simulación. Finalmente comprobamos si los valores a las salidas son correctos.

Diseño digital con esquemáticos y FPGA. v1.8 - 04/06/2008

33

Departamento de Tecnología Electrónica

6. Decodificador de 4 a 16

Tiempo de simulación Simular por el tiempo especificado

Figura 6.8: Comando para simular por un tiempo especificado En la figura 6.9 se muestran los resultados de la simulación, se puede observar cómo se van activando las salidas consecutivamente mientras la señal de habilitación (E) esté a uno. Cuando ésta vale 0, no hay ninguna salida activa.

Figura 6.9: Resultado de la simulación En el siguiente ejercicio usaremos el decodificador para un diseño que implementaremos en la placa.

Diseño digital con esquemáticos y FPGA. v1.8 - 04/06/2008

34

7. Convertidor de hexadecimal a 7 segmentos

Departamento de Tecnología Electrónica

7. Convertidor de hexadecimal a 7 segmentos En los ejercicios de los decodificadores teníamos un número codificado en los interruptores de la placa y lo decodificábamos mostrándolo en los LED. Ahora queremos mostrar un número hexadecimal (4 bits) en un visualizador o display de siete segmentos. Antes de empezar a diseñar el circuito veamos cómo funcionan los displays de siete segmentos. Un display de siete segmentos permite iluminar 7 segmentos (y a veces también el punto decimal) de manera independiente, de forma que se pueden representar todos los números y algunas letras y símbolos.

A F

Los segmentos del display se nombran como muestra la figura 7.1. Según qué segmentos estén encendidos, se mostrarán diferentes números. Por ejemplo, para el número 1 deberán estar encendidos los segmentos B y C. Para el número 8 todos los segmentos deberán estar encendidos.

B

G

E

C

D

DP

Figura 7.1: Display de 7 segmentos

A continuación se muestra la codificación de los 16 números hexadecimales (figura 7.2), como podrás apreciar, algunos números admiten más de una representación, por ejemplo, el 6 podría no tener el segmento A iluminado (pero se confundiría con la B). El 9 podría tener el segmento D iluminado. La A, la C y la E se podrían representar en minúsculas. Puedes ver muchas otras representaciones en http://en.wikipedia.org/wiki/Seven-segment_display. Nosotros, usaremos la de la figura 7.2.

0

A F E

8

G D

B C

A F

G

E

D

1

B C

A F E

9

G D

B C

A F

G

E

D

2

B C

A F E

A

G D

B C

A F

G

E

D

3

B

A F E

B

C

G D

B C

A F

G

E

D

4

B C

A F E

C

G D

B C

A F

G

E

D

5

B C

A F E

D

G D

B C

A F

G

E

D

6

B

A F E

E

C

G D

B C

A F

G

E

D

7

B

A F E

F

C

G D

B C

A F

G

E

D

B C

Figura 7.2: Codificación de los segmentos para mostrar los 16 números hexadecimales Existen también otros visualizadores de 14 ó 16 segmentos, para poder representar todos los caracteres alfanuméricos. También se usan las matrices de puntos que tienen distintas resoluciones. En nuestra placa, para activar el display de la derecha, debemos poner la señal AN_0='0'. El pin correspondiente de la FPGA es el P60, como puedes ver en la placa encima de donde están los displays. En la placa también se muestran los pines correspondientes a cada segmento, para encender un segmento tenemos que poner su pin correspondiente a cero. Funcionan por tanto con lógica negada. Cuando no quieres que se encienda un display tendrás que poner un uno, por ejemplo en los pines de las señales AN_1, AN_2 y AN_3, correspondientes a los otros tres displays. Así, para representar el uno, tendrías que poner los segmentos B y C a cero y el resto a uno, poniendo también la señal AN_0=0. Con esta información ya podemos hacer el diseño, más adelante, en otros ejercicios, veremos las conexiones eléctricas y cómo encender varios displays.

7.1. Diseño del convertidor de hexadecimal a 7 segmentos El objetivo es mostrar en un display el número hexadecimal codificado en los cuatro interruptores de la derecha (SW0, SW1, SW2 y SW3), ya que con cuatro bits podemos formar 16 números. Las entradas y salidas del circuito que queremos diseñar están representadas en la figura 7.3.

Diseño digital con esquemáticos y FPGA. v1.8 - 04/06/2008

35

7. Convertidor de hexadecimal a 7 segmentos

Departamento de Tecnología Electrónica

HEX7SEG SEG_A SEG_B SEG_C SEG_D SEG_E SEG_F SEG_G SEG_DT AN_0 AN_1 AN_2 AN_3

I0 Número codificado:

I1

A los interruptores: SW0, SW1, SW2, SW3

I2 I3

Habilitación:

E

Salida a los 7 segmentos

Punto decimal del display Encendido de los displays AN0: display de la derecha

Figura 7.3: Diagrama de entradas y salidas del convertidor hexadecimal a 7segmentos Ya hemos visto en clase cómo se diseña el circuito que convierte de BCD a 7 segmentos. Ahora tenemos que modificar la tabla de verdad para que incluya las salidas de los números del 10 (A16) al 15 (F16), ya que en BCD para ellos poníamos X (condiciones indiferentes o "no importa"). En la figura 7.4 se ha puesto la parte de la tabla de verdad, nota que las salidas van a nivel bajo y por esto, los ceros indican que se enciende el segmento. No te confundas con la nomenclatura de los segmentos (columnas de la A a la G) con los números en hexadecimal (filas de la A a la F). En dicha tabla de verdad se han dejado en blanco los segmentos E, F y G para que los deduzcas y evitar que simplemente copies todo lo que aquí se dice y no estés entendiendo nada. Para implementar el circuito podríamos realizar el mapa de Karnaugh para cada uno de los 7 segmentos y obtener la función lógica. Este método es perfectamente válido y es necesario conocerlo, aunque es verdad que puede darnos un poco de pereza apartar el ordenador y ponernos con boli y papel a realizar 7 mapas de Karnaugh (uno para cada segmento). segmentos

ojo esto son números en hex, no son los segmentos

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

I3 0 0 0 0 0 0 0 0 1 1 1 1 1 1 1 1

I2 0 0 0 0 1 1 1 1 0 0 0 0 1 1 1 1

I1 0 0 1 1 0 0 1 1 0 0 1 1 0 0 1 1

I0 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 0

A 0 1 0 0 1 0 0 0 0 0 0 1 0 1 0 0

B 0 0 0 0 0 1 1 0 0 0 0 1 1 0 1 1

C 0 0 1 0 0 0 0 0 0 0 0 0 1 0 1 1

D 0 1 0 0 1 0 0 1 0 1 1 0 0 0 0 1

E

F

G

Figura 7.4: Tabla de verdad del convertidor hexadecimal a 7 segmentos (salidas a nivel bajo) Así que vamos a realizarlo por otro método. Hemos visto en clase que mediante decodificadores se pueden implementar funciones lógicas. Normalmente no es un método muy eficiente en puertas, es decir, si realizamos la función lógica a partir del mapa de Karnaugh suelen salir muchas menos puertas que haciéndolo con decodificadores. Esto se debe a que el decodificador obtiene todos los términos mínimos, sean o no necesarios para la ecuación, y además, al hacerlo con los términos mínimos, se implementa la ecuación en la primera forma normal (1FN), ésta suele ser de bastante mayor tamaño que la ecuación obtenida por Karnaugh. Esto último lo has podido comprobar si hiciste el primer ejercicio propuesto del tema 3 5. Sin embargo, cuando necesitamos obtener varias funciones lógicas a partir de un mismo grupo de entradas (como es el caso) el uso de decodificadores no es tan descabellado, ya que un término mínimo puede ser utilizado en varias salidas. Es decir, en nuestro caso necesitamos siete funciones lógicas, una para cada segmento, y por tanto un término mínimo puede ser usado en varias funciones. Además, ya tenemos el decodificador implementado y encima disponemos de una FPGA con 50000 ó 200000 puertas equivalentes, por lo que excedernos en el número de puertas para un diseño pequeño como el nuestro no es problemático. 5

Disponible en http://laimbio08.escet.urjc.es/assets/files/docencia/EDI/pbs3_02.pdf

Diseño digital con esquemáticos y FPGA. v1.8 - 04/06/2008

36

7. Convertidor de hexadecimal a 7 segmentos

Departamento de Tecnología Electrónica

Quizás ahora estés intentando recordar de clase cómo se diseñaban funciones lógicas con decodificadores. Bueno, es muy fácil, simplemente tenemos que unir con una puerta OR todos los términos mínimos de la función. Por ejemplo, la salida A del display es la OR de los términos mínimos 1, 4, 11 y 13 (m1, m4, m11, m13). Mira la figura 7.5, en ella se han tomado estas salidas para crear la función que implementa el segmento A. Para la A tomamos las salidas 1, 4, 11 y 13 I3 0 0 0 0 0 0 0 0 1 1 1 1 1 1 1 1

I2 0 0 0 0 1 1 1 1 0 0 0 0 1 1 1 1

I1 0 0 1 1 0 0 1 1 0 0 1 1 0 0 1 1

I0 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 0

A 0 1 0 0 1 0 0 0 0 0 0 1 0 1 0 0

I0 I1

m1

I2 I3 E

m4

A0 A1 A2 A3 E

S0 S1 S2 S3 S4 S5 S6 S7 S8 S9 S10 S11 S12 S13 S14 S15

m11 m13

SEG_A

Figura 7.5: Implementación de la función para activar el segmento A Esto además se puede entender de otra manera, cada salida del decodificador indica qué numero tenemos codificado con los interruptores. El segmento A no lucirá cuando tengamos un 1, un 4, un 11 (B16) ó un 13 (D16). De la figura 7.2 puedes ver que para estos números el segmento A no luce, para el resto sí. Consecuentemente si la salida del decodificador S1 es igual a '1' (S1=1), ó S4=1 ó S11=1 ó S13=1, entonces el segmento A no lucirá. Dicho en álgebra de Boole: A=(S1 + S4 + S11 + S13). Ten en cuenta que el decodificador de 7 segmentos luce con lógica negada, y por eso decimos "no lucirá". Otra alternativa sería haberlo hecho con lógica afirmada (sin negar). Entonces cada uno de los 7 segmentos estarían complementados. Para obtener la salida negada se tomarían los términos mínimos complementarios, y habría que negar la OR (sería una NOR). La figura 7.6 muestra las dos formas equivalentes de realizar el circuito para el segmento A. Lógica afirmada:

Lógica negada:

números que hacen "lucir" el segmento A

números que hacen "No lucir" el segmento A I3 0 0 0 0 0 0 0 0 1 1 1 1 1 1 1 1

I2 0 0 0 0 1 1 1 1 0 0 0 0 1 1 1 1

I1 0 0 1 1 0 0 1 1 0 0 1 1 0 0 1 1

I0 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 0

A 0 1 0 0 1 0 0 0 0 0 0 1 0 1 0 0

m1 m4

SEGA

m1

m11 m13

m4

Los números 1, 4, B y D pondrán un 1 en la salida, y por tanto, no lucirá el segmento A. El resto pondrá un 0 y lucirá

1 m11 m13

B 11

A F

G

E

D

C

A F E

G D

4

B

B C

D 13

A F

G

E

D

B C

A F E

G D

B C

I3 0 0 0 0 0 0 0 0 1 1 1 1 1 1 1 1

I2 0 0 0 0 1 1 1 1 0 0 0 0 1 1 1 1

I1 0 0 1 1 0 0 1 1 0 0 1 1 0 0 1 1

I0 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 0

A 1 0 1 1 0 1 1 1 1 1 1 0 1 0 1 1

m0 m2 m3 m5 m6 m7 m8 m9 m10 m12 m14 m15

m0 m2 m3 m5 m7 m8 m9 m10 m12 m14 m15

SEGA

Negar la salida para que los números que hacen lucir el segmeno A pongan un cero

Figura 7.6: Formas equivalentes de realizar el circuito: a la izquierda con lógica negada. A la derecha, con lógica afirmada y negando la salida pues el segmento luce cuando hay un cero Para el resto de segmentos haremos lo mismo: uniremos mediante una puerta OR todos sus términos mínimos (también lo podríamos hacer de la manera en que muestra en la derecha de la figura 7.6). Empecemos a diseñarlo, nos mantenemos en el mismo proyecto que en el anterior. Primero, como venimos de la simulación, seleccionamos en la ventana de fuentes (Sources) la opción de Synthesis Implementation. Ahora creamos una nueva fuente de tipo esquemático llamada hex7seg. Tenemos la ventana de opciones y de símbolos activas. Diseño digital con esquemáticos y FPGA. v1.8 - 04/06/2008

37

Departamento de Tecnología Electrónica

7. Convertidor de hexadecimal a 7 segmentos

En la ventana de símbolos, en la subventana de categorías (Categories) escogemos la primera de ellas que hace referencia a nuestro proyecto (C:/practicas/edi/...). Y en la ventana de símbolos estará el decodificador de 4 a 16 que creamos en el ejercicio anterior. Incluimos una referencia a este símbolo en nuestro nuevo diseño, y realizamos las conexiones del decodificador con las salidas al display según la tabla de verdad de la figura 7.4 y el ejemplo de la figura 7.5. Conecta también las 4 entradas del decodificador, llámalas I0, I1, I2, I3. Y la habilitación E. Quizás veas que si sigues conectando cables a las siete puertas OR que tienes que incluir, se va enmarañar todo el circuito. Para evitar esto, una mejor opción es nombrar los cables, ya que si dos cables tienen el mismo nombre, aunque no estén unidos se consideran como el mismo cable. Veámoslo para el segmento B. Según la tabla de verdad de la figura 7.4, el segmento B no luce para los números 5, 6, B, C, E y F (m5, m6, m11, m12, m14 y m15), por tanto necesitamos una puerta OR de 6 entradas. La situamos en el plano y le conectamos ya la salida SEG_B (para no olvidarnos luego de qué salida se trata). Ver figura 7.7. Ahora, a la primera entrada de la puerta OR le conectamos un cable corto. Esto es necesario porque los cables son los que reciben el nombre y no las entradas de las puertas o componentes. Y por el mismo motivo, a la salida S5 del decodificador le conectamos otro cable corto (ver figura 7.8). Verás que el final de ambos cables están en rojo, esto es porque están desconectados. S0 S1 S2 S3 S4 S5 S6 S7 S8

SEG_B

S9 S10 S11 S12 S13 S14 S15

Figura 7.7: Paso 1, ponemos la puerta OR de 6 entradas

Figura 7.8: Paso 2, conectamos un cable pequeño a la salida S5 del decodificador y a una entrada de la puerta OR

Ahora pinchamos en "Add→Net Name" y en la ventana de opciones rellenamos en el apartado Name el nombre m5, ya que vamos a poner el término mínimo m5. A continuación pinchamos en el esquemático cerca de los cables que hemos puesto (figura 7.9). Por último, repetimos la operación con el resto de las entradas de la puerta OR (figura 7.10). Al poner un nombre a un cable que ya existe. Por ejemplo, en la figura 7.9, si nombramos a una pata de la OR como m5, estamos conectando esa pata al cable m5 que ya existe y que es una salida del decodificador. En caso de que nos hayamos equivocado de término mínimo, y nombramos una pata de la OR con un término mínimo equivocado, tendremos que borrar el cable y volverle a conectar uno nuevo, porque si renombramos, estaremos renombrando tanto ese cable que está en la pata de la OR como el cable de la salida del decodificador. De todos modos, si intentásemos renombrar el cable sin borrarlo, seguramente aparecerá una advertencia que indica que ese otro nombre ya existe, pues corresponde a otra salida del decodificador.

Diseño digital con esquemáticos y FPGA. v1.8 - 04/06/2008

38

Departamento de Tecnología Electrónica

7. Convertidor de hexadecimal a 7 segmentos

Figura 7.9: Paso 3, nombramos ambos cables con el mismo nombre Figura 7.10: Paso 4, repetimos la operación con el resto de entradas Así que tienes dos métodos para realizar las conexiones del circuito: unir cables o nombrarlos, puedes combinarlos o usar el que más te guste, aunque para este ejemplo, si conectas todos los cables va a resultar un circuito muy poco claro, y difícil para hacer modificaciones. El resto de las salidas de los segmentos debes realizarlo tú solo. Una vez que tengas todas las salidas de los segmentos conectadas, debes conectar la señal AN_0¸ recuerda que esta señal es un pin que va al display de la derecha. Cuando AN_0=0 el display lucirá (si tiene algún segmento encendido) cuando AN0=1 el display estará apagado independientemente de que tengas los segmentos encendidos. Lo que vamos a hacer es encender el display cuando el circuito esté habilitado (E). Como la señal de habilitación es a nivel alto y la señal AN_0 es a nivel bajo, tendrás que conectarlas con un inversor. Es fácil, pero si no se te ocurre cómo hacerlo observa la figura 7.11. Por último conectarás el resto de encendidos de displays a 1 (AN_1=AN_2=AN_3=1), para que no luzcan. Recuerda del ejercicio 2 (encender un LED) cómo se conectaba una salida a un uno lógico. Si no se te ocurre cómo hacerlo puedes mirar la figura 7.11. También deberás incluir el puerto del punto decimal, que hemos llamado SEG_DT (figura 7.3). El punto decimal funciona igual que el resto de los segmentos, y como no lo queremos encender lo conectaremos a alimentación (Vcc), exactamente igual que el las señales (AN_1, AN_2, AN_3) En este punto deberías tener todo el circuito diseñado. Grábalo y comprueba que el esquemático está bien conectado (Tools→Check Schematic). Si el diseño está bien pasaremos a implementarlo en la FPGA.

Figura 7.11: Detalle de la conexión de las señales AN_0 y AN_1

7.2. Implementación Esta vez, en vez de simular el circuito vamos a implementarlo directamente, ya que la funcionalidad del circuito es muy fácilmente comprobable en la placa, pues sólo tenemos que ver si el display luce bien o no. Lo primero que haremos es seleccionar la ventana de procesos y la de fuentes. En la ventana de fuentes verás una imagen similar a la de la figura 7.12. En ella puedes apreciar que de los dos esquemáticos que tenemos, el convertidor de hexadecimal a 7 segmentos está por encima del decodificador. El convertidor debe de tener el símbolo , que significa que es el diseño de más alta jerarquía. Si no estuviese tendrías que pinchar con el botón derecho del ratón encima de él y seleccionar "Set as Top Module". Diseño digital con esquemáticos y FPGA. v1.8 - 04/06/2008

39

Departamento de Tecnología Electrónica

Convertidor HEX a 7SEG diseño de mayor jerarquía

7. Convertidor de hexadecimal a 7 segmentos

El decodificador es un componente del convertidor

: Símbolo que indica el componente de mayor jerarquía

Figura 7.12: Representación de la jerarquía en la ventana de fuentes Ahora vamos a asignar los pines del circuito, en los ejercicios anteriores lo hemos hecho mediante la herramienta PACE (figura 2.11 del apartado 2.2). Dentro de la ventanas de procesos seleccionábamos el comando "User Constraints→Assign Package Pins". Sin embargo a veces hay un error y salen unos puertos que no son los que tienes en tu diseño. En la figura 7.13 se muestran los pines que salían al hacer este ejercicio (probado incluso desde dos ordenadores distintos), sin embargo, si hemos hecho el diseño bien, nos deberían de salir los pines de la figura 7.3.

Figura 7.13: Ventana de puertos errónea de la herramienta PACE Si te salen los pines correctamente, puedes seguir usando la herramienta PACE, si no, y te sale algo parecido a la figura 7.13, entonces cierra la herramienta PACE y lo haremos por otra alternativa. Esta alternativa es editar directamente el fichero de restricciones. Este fichero tiene la extensión .UCF. Y lo puedes editar con cualquier editor de texto o desde la propia herramienta ISE. En la ventana de procesos, dentro de "User Constraints", dos comandos por debajo del que acabamos de usar para arrancar el PACE está el comando: "Edit Constraints (Text)", pincha dos veces en él y te saldrá un editor de texto en la ventana grande de la derecha (ver figura 7.14).

Aquí se escriben las restricciones

Edit Constraints (Text) Fichero Fichero de de restricciones restricciones .ucf .ucf Figura 7.14: Edición de las restricciones en texto Diseño digital con esquemáticos y FPGA. v1.8 - 04/06/2008

40

Departamento de Tecnología Electrónica

7. Convertidor de hexadecimal a 7 segmentos

Ahora tenemos que escribir los puertos en el fichero UCF, que en realidad es lo que hace la herramienta PACE. El texto que tenemos que escribir se muestra en el código 7.1. El formato de estos ficheros es muy sencillo: • •

Los comentarios se consideran a partir del signo # Cada puerto de nuestro diseño se conecta con la línea: NET "Nombre_del_Puerto" LOC = "Nombre_del_Pin"

Con estas indicaciones, y tras identificar los pines en la placa, ya la podrías hacer tú solo. Sin embargo, por ser la primera vez, a continuación se muestra el contenido del fichero. Aún así, intenta entender el significado, ya que para las siguientes ocasiones tendrás que escribirlo tú solo. #Numero codificado en los interruptores SW0, SW1, SW2, SW3 NET "I0" LOC = "P89" ; NET "I1" LOC = "P88" ; NET "I2" LOC = "P87" ; NET "I3" LOC = "P86" ; #Enable en el SW7 NET "E" LOC = "P81" #Encendido de los NET "AN_0" LOC = NET "AN_1" LOC = NET "AN_2" LOC = NET "AN_3" LOC = #7 segmentos NET "SEG_A" NET "SEG_B" NET "SEG_C" NET "SEG_D" NET "SEG_E" NET "SEG_F" NET "SEG_G"

LOC LOC LOC LOC LOC LOC LOC

;

displays "P60" ; "P69" ; "P71" ; "P75" ; = = = = = = =

"P74" "P70" "P67" "P62" "P61" "P73" "P68"

#Punto decimal NET "SEG_DT" LOC = "P63"

; ; ; ; ; ; ; ;

Código 7.1: Conexión de los puertos del diseño con los pines de la FPGA Debes estar atento a que los nombres que hemos puesto en el fichero UCF coincidan con los nombres de los puertos de tu diseño. El código 7.1 está hecho para los nombres de la figura 7.3. Si por descuido has puesto otros nombres en el diseño, o bien cambias los nombres del diseño, o cambias el UCF. Guarda el fichero UCF una vez que lo hayas terminado. Sintetiza el diseño, y posteriormente impleméntalo. Esto ese hacía desde la ventana de procesos, "SynthesizeXST", "Implement Design". Observa si hay algún error, sobre todo después de la implementación. Si te has equivocado al nombrar los puertos te saldrá un mensaje diciendo qué puerto falta, si es así, corrige el UCF o el esquemático y repite el proceso. Finalmente pincha dos veces en "Generate Programming File" y luego en "Configure Device (iMPACT)" para programar la FPGA, si no te acuerdas de estos pasos repasa el apartado 2.3. Ahora comprueba que se visualizan correctamente los números según estén los interruptores del cero al tres. Si ves que algún número no se visualiza correctamente, identifica qué segmento está mal y revisa el esquemático. Comprueba también que la habilitación funciona. Quizás crea que no funciona nada, y lo que sucede es que tienes el circuito deshabilitado (SW7='0').

Diseño digital con esquemáticos y FPGA. v1.8 - 04/06/2008

41

Departamento de Tecnología Electrónica

8. Codificadores

8. Codificadores En esta práctica realizaremos varios codificadores. Primero haremos un codificador de 4 a 2. En un principio lo haremos sin prioridad y luego incluiremos un módulo que establezca las prioridades. Posteriormente, en el capítulo 9 utilizaremos varios codificadores para realizar uno de 8 a 3.

8.1. Codificador de 4 a 2 sin prioridad Un codificador devuelve en forma codificada la entrada que tiene activa. En esta práctica el codificador tendrá 4 entradas y devolverá en formato binario la entrada que está activa. En un principio realizaremos la versión más sencilla. Utilizaremos los cuatro pulsadores como entradas y los dos primeros LED para mostrar la salida codificada en binario. El esquema del circuito que queremos realizar se muestra en la figura 8.1. En la tabla se indica qué salidas se activa. Por ejemplo, cuando la entrada activa es la I0 los dos LED permanecerán apagados, ya que mostrarán un cero en binario (002). Cuando está la entrada I1 activa, se encenderá el LED0¸ mostrando un uno en binario (012). De análoga sucede con los dos casos restantes. CODIF BTN0 BTN1 BTN2 BTN3

I0 I1 I2 I3

S0 S1

entrada activa I0 I1 I2 I3

LED0 LED1

salidas S1 S0 0 0 0 1 1 0 1 1

S0 se enciende cuando I1 está activa o (OR) cuando I3 está activa

I1

S0

I2 I3

S1 se enciende cuando I2 está activa o (OR) cuando I3 está activa

S1

Figura 8.1: Entradas y salidas del codificador, tabla de verdad y obtención del esquema en puertas lógicas La realización de este circuito es sencilla, y simplemente tienes que implementar el esquema de puertas mostrado a la derecha de la figura 8.1, e indicar los pines a los que van conectados. Las conexiones con los pulsadores y LED se muestra a la izquierda de la figura 8.1. Así que crea un nuevo proyecto llamado codif4a2, una fuente del mismo nombre, conecta los pines correspondiente y bájalo a la FPGA. Como puedes ver, la entrada I0 no está conectada en el esquema de puertas, por lo tanto, no hace falta que la crees ni que le asignes pines. Ahora debes comprobar que funciona bien. ¿Qué debe suceder? Está mostrado para algunos casos en la figura 8.2. Entrada activa (pulsador) LEDs encendidos y codificación

ninguna LD1 00

BTN1

BTN0 LD1

LD0

LD1

LD0

00

01

BTN2 LD1

LD0 10

BTN3

LD0

LD1

BTN1 y BTN2 LD1

LD0

11

LD0

11

Figura 8.2: Salidas del circuito codificador según las entradas Cuando pulsamos el pulsador BTN0 no se enciende ningún LED, y está bien ya que está mostrando un cero: 002, y por tanto, los dos tienen que estar apagados. Sin embargo, vemos que el resultado es el mismo de cuando no hay ningún botón pulsado. Así que con este circuito, no podemos distinguir entre el caso en que no hay ningún botón pulsado y el caso en que el botón cero (BTN0) está pulsado. Por otro lado, cuando pulsamos varios botones a la vez ocurren situaciones imprevistas. Por ejemplo, como se muestra en la derecha de la figura 8.2, cuando se pulsan los botones uno y dos (BTN1 y BTN2), se encienden los dos LED, mostrando por tanto que es el pulsador 3 (BTN3) el que está encendido. Esto es porque en el planteamiento inicial no hemos considerado que se puedan pulsar dos botones simultáneamente. Así que tenemos que solucionar dos cosas: • •

Definir las prioridades para que sólo esté una línea activa Diferenciar cuándo está la línea del BTN0 activa de cuando no hay ninguna línea activa.

8.2. Codificador de 4 a 2 con prioridad, línea activa y habilitación Así que ampliaremos el codificador de modo que con una señal de salida (A) indiquemos si hay algún botón pulsado. Así podremos distinguir el botón cero con la situación en la que no hay ningún botón pulsado. Para ello basta con incluir una puerta OR con todas las entradas, ya que cuando cualquiera de las entradas esté activa (sea '1') la salida será '1'. La figura 8.3 muestra cómo quedaría este circuito. Diseño digital con esquemáticos y FPGA. v1.8 - 04/06/2008

42

Departamento de Tecnología Electrónica

salidas S1 S0 0 0 0 0 0 1 1 0 1 1

entrada activa -I0 I1 I2 I3

8. Codificadores

I1 Diferencia entre pulsar I0 y no pulsar nada

A 0 1 1 1 1

S0

I2 I3

A se enciende cuando cualquier entrada esté activa: I0 + I1 + I2 + I3

S1

A

I0

Figura 8.3: Esquema del codificador que incluye la señal A, que indica si hay algún línea de entrada activa Si quieres puedes bajar a la placa este circuito, poniendo la señal A como el LED 7 o bien continuar realizando las modificaciones que queremos realizar. Llama al proyecto codif4a2. Ahora queremos incluir un módulo que determine las prioridades, de manera que, aunque dos botones estén pulsados, sólo una línea de entrada del decodificador esté activa. Pondremos la prioridad más alta para el bit más significativo, de modo que si I2 e I1 estuviesen pulsados, el codificador mostrase un 102 y no un 112 como estaba haciendo hasta ahora (recuerda el caso de la derecha de la figura 8.2). El esquema que queremos implementar se muestra en la figura 8.4

PRIOR BTN0 BTN1 BTN2 BTN3

I0 I1 I2 I3

CODIF P0 P1 P2 P3

puede haber más de una que valga 1

P0 P1 P2 P3

S0 S1

S0 SA

A

A

como máximo sólo habrá una señal que valga 1

Figura 8.4: Bloque de prioridades previo al codificador

¿Cómo hacemos un módulo que establezca las prioridades? Podemos usar las puertas AND ya que sabemos que si una de las entradas de estas puertas es cero, la salida será cero. Mientras que si es uno, la salida será lo que la otra entrada valga. Así la señal prioritaria pasará directamente y la señales menos prioritarias dependerán del valor de la prioritaria. En la figura 8.5 se muestra un esquema que establece la prioridad de I3 sobre I2. Cuando I3='1' se pone un cero en la salida P2, mientras que si I3='0' la señal P2 valdrá lo que valga I2. Si I3='1' entonces P2='0' I2

I3

'0'

'0'

'1'

Si I3='1' entonces P2=I2 I2

P2

I2

P3

I3

P2

'1'

"no deja pasar I2"

'0'

'0'

P3

"deja pasar I2"

Figura 8.5: Prioridad de I3 sobre I2 Así que se puede aplicar la misma estrategia para el resto de señales, quedando como muestra la figura 8.6. En la derecha de la figura se muestra la tabla de verdad del circuito. I0

I1

I2

I3

P0

P0 sólo podrá valer '1' cuando no sean '1' ni I3, ni I2, ni I1

P1

P1 sólo podrá valer '1' cuando no sean '1' ni I3, ni I2

P2

P2 podrá valer '1' cuando I3 no sea '1'

P3

P3 siempre podrá valer '1' (según lo que valga I3)

I3 0 0 0 0 1

I2 0 0 0 1 X

I1 0 0 1 X X

I0 0 1 X X X

P3 0 0 0 0 1

P2 0 0 0 1 0

P1 0 0 1 0 0

P0 0 1 0 0 0

independientemente de lo que valga I0, P0 = '0' porque I3='1'

Figura 8.6: Circuito para establecer prioridades y su tabla de verdad Para simplificar la tabla de verdad se han puesto X en las señales de entrada de la tabla (I0, I1, I2). En las tablas de verdad, las X en las entradas tienen un significado distinto que las X en las salidas. Una X en una entrada significa que tanto si esa entrada vale '0' ó '1', el valor a la salida será el mismo. Con esto me ahorro dibujar una tabla mucho mayor. En este caso, en vez de dibujar una tabla de 16 casos (4 entradas → 24= 16), dibujo una tabla con 5 casos. Esto es gracias a las X de las entradas, pero el circuito será el mismo dibuje la tabla con X o sin ellas. Sin embargo, una X a la salida significa que puedo simplificar el circuito, esto es, para ese caso yo podré poner un '1' ó un '0' según me convenga más. Es decir, me da libertad para realizar un Diseño digital con esquemáticos y FPGA. v1.8 - 04/06/2008

43

Departamento de Tecnología Electrónica

8. Codificadores

circuito más sencillo debido a que ese caso nunca se va a dar. Esta libertad no la tengo con las entradas.

X

en las

Para terminar nos quedaría unir los módulos tal como se muestra en la figura 8.4, sin embargo, antes vamos a incluir la señal de habilitación (Enable). Cuando la señal de habilitación vale cero (Enable='0') hace que todas las salidas valgan '0'. Si está habilitado, el circuito funciona normalmente. Además, los codificadores con habilitación incluyen una nueva señal de salida (EO: enable out), que nos permitirá conectar varios codificadores y extender su capacidad. Esta señal nos indica si el codificador está habilitado pero no hay ninguna señal de entrada activa, nos diferencia de cuando el codificador no está habilitado. El bloque que queremos realizar se muestra en la figura 8.7 CODIF BTN0 BTN1 BTN2 BTN3

I0 I1 I2 I3

SW7

EI

EO

LED7

S0 S1

LED0 LED1

A

LED6

EI 0 1 1 1 1 1

I3 X 0 0 0 0 1

I2 X 0 0 0 1 X

I1 X 0 0 1 X X

I0 X 0 1 X X X

S1 0 0 0 0 1 1

S0 0 0 0 1 0 1

A EO 0 0 0 1 1 0 1 0 1 0 1 0

Figura 8.7: Bloque y tabla de verdad del codificador con prioridad y habilitación Como vemos de la tabla de verdad de la figura 8.7, la salida EO vale '1' cuando alturas, esta condición nos debería ser fácil de implementar en puertas lógicas.

A0='0'

y

EI='1'.

A estas

El circuito final nos quedará como muestra la figura 8.8. PRIOR

EO

I0

P0

I1

P1

A

S0 I2

P2 S1

I3

P3

EI

Figura 8.8: Esquema en puertas del codificador con prioridad y habilitación Implementa este diseño en la FPGA, poniendo los pines que se muestran en el bloque de la izquierda de la figura 8.7 y comprueba que funciona correctamente.

8.3. Codificador de 4 a 2 con conversión a 7 segmentos Por último se deja como ejercicio conectar el codificador que acabamos de diseñar (figura 8.8) con el conversor a siete segmentos que hemos realizado en el capítulo 7. Así, además de ver el número resultante codificado con los LED, lo veremos en el display de siete segmentos. Para ello, primero crea el símbolo del codificador que acabas de crear (el de la figura 8.8). Recuerda que se hacía con el comando: Tools→Symbol Wizard (se explicó en el apartado 4.4). Ahora vamos a añadir el conversor a 7 segmentos que realizamos en el capítulo 7. Para ello, ejecutamos "Proyect→Add Copy of Source..." y vamos al directorio donde hicimos el conversor, que debería ser "c:/practicas/edi/tunombre/sieteseg/" y allí seleccionas los ficheros: "hex7seg.sch" y "decod4a16.sch". Ahora creamos un símbolo del esquemático hex7seg.shc, para ello ejecutamos Tools→Symbol Wizard y en la siguiente ventana, en el apartado Using Schematic seleccionamos el módulo hex7seg. Esto es importante porque si no estaríamos haciendo el símbolo de otro módulo. En la siguiente ventana podemos ordenar la entradas y salidas, o dejarlas así y tener cuidado de no equivocarnos cuando hagamos las conexiones. Para ordenarlas tenemos que pinchar en la columna que indica Order y en ella indicar señal por señal, el orden que le asignamos (como puedes ver no es muy cómo el método de ordenamiento). Ahora crea una nueva fuente "Proyect→ New Source" de tipo esquemático llamada codif4a2_7seg en la que pondremos tanto el codificador de la figura 8.8 como el conversor a 7 segmentos. En la ventana de símbolos Diseño digital con esquemáticos y FPGA. v1.8 - 04/06/2008

44

Departamento de Tecnología Electrónica

8. Codificadores

seleccionamos la categoría de nuestro proyecto (la 2ª fila donde sale la ruta de nuestro proyecto). En la subventana de Symbols estarán los tres símbolos de nuestro proyecto: codif4a2, decod4a16 y hex7seg. El símbolo decod4a16 está dentro del hex7seg y por eso aparece. Nosotros usaremos el codif4a2 y el hex7seg. La conexión de los circuitos se haría como muestra la figura 8.9. Como el codificador es de 4 a 2, tiene dos salidas para indicar el número (S0 y S1), el resto de entradas del conversor a 7 segmentos (I2 e I3) irán a tierra (a cero), para que los número que muestre sean del 0 al 3. Si estuviesen las dos a '1', mostraría los números del 12 a 15. Y si no las pusieses a ningún valor, tendrías un valor indeterminado en las entradas del decodificador, y quién sabe que número te saldría. Esto es: Las entradas siempre deben tener un valor determinado, no se deben dejar "al aire".

Figura 8.9: Esquema del circuito final Antes de implementar el circuito en la FPGA debes de crear el fichero UCF, que es el fichero de restricciones, donde se indican las conexiones de los puertos del esquema ( figura 8.9) con los pines de la FPGA. Para no tener que hacer de nuevo todo el fichero de restricciones, puedes abrir el que ya tenías del conversor de 7 segmentos (código 7.1) y copiar y pegar en el que vas a crear. Una vez que lo tengas en la placa, comprueba que funciona, que se se encienden los LED y el display de 7 segmentos. Y que también funcionan correctamente las salidas A y EO (Enable Out), que usaremos en el siguiente ejercicio.

Diseño digital con esquemáticos y FPGA. v1.8 - 04/06/2008

45

9. Extensión de la capacidad de un codificador

Departamento de Tecnología Electrónica

9. Extensión de la capacidad de un codificador En este ejercicio usaremos el codificador de 4 a 2 que hemos realizado en la práctica anterior (capítulo 8) y lo ampliaremos para hacer un codificador de 8 a 3. El resultado lo visualizaremos con los LED y con el display de siete segmentos.

9.1. Codificador de 8 a 3 a partir de codificadores de 4 a 2 En la figura 9.1 se muestra el esquema y las conexiones con los pines. A la derecha de la figura se muestra la tabla de verdad. Esta tabla de verdad se ha dividido para hacer poder realizar el codificador en función de codificadores de 4 a 2. SW4 SW5 SW6 SW7 BTN0 BTN1 BTN2 BTN3

I0 I1 I2 I3 I4 I5 I6 I7

SW0

EI

CODIF

EO

LED7

S0 S1 S2

LED0 LED1 LED2

A

LED6

EI 0 1 1 1 1 1 1 1 1 1

I7 X 0 0 0 0 0 0 0 0 1

I6 X 0 0 0 0 0 0 0 1 X

I5 X 0 0 0 0 0 0 1 X X

I4 X 0 0 0 0 0 1 X X X

I3 X 0 0 0 0 1 X X X X

I2 X 0 0 0 1 X X X X X

I1 X 0 0 1 X X X X X X

I0 X 0 1 X X X X X X X

S2 0 0 0 0 0 0 1 1 1 1

S1 0 0 0 0 1 1 0 0 1 1

S0 0 0 0 1 0 1 0 1 0 1

A EO 0 0 0 1 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0

Figura 9.1: Entradas y salidas del codificador, y su tabla de verdad La extensión de un codificador se realiza como se muestra en la figura 9.2. En la extensión, la S0 del codificador de 8 a 3 (codif8a3) se forma con la OR de las S0 de los codificadores de 4 a 2. Lo mismo ocurre con la S1. Los codificadores de 4 a 2 se han llamado P_CODIF y G_CODIF, siendo el primero el que recibe los bits menos significativos (P de pequeño), y el segundo los más significativos (G de grande). Para obtener la señal S2 basta con tomar la señal A (activo) del codificador de los bits más significativos (G_CODIF). La A del codificador de 8 a 3 se obtiene realizando la OR de las señales de Activo de los codificadores de 4 a 2, ya que estará activo si cualquiera de ellos está activo. CODIF8a3 P_CODIF SW4 SW5 SW6 SW7

I0 I1 I2 I3

S0 S1 A

EI

S0 S1

G_CODIF BTN0 BTN1 BTN2 BTN3 SW0

I4 I5 I6 I7 EI

I0 I1 I2 I3 EI

LED7

EO

I0 I1 I2 I3

EO

S2

S0 S1 A

A

LED0 LED1

LED2

LED6

Figura 9.2: Extensión de un codificador Para facilitar la comprensión del diseño, la figura 9.3 incluye la tabla de verdad del codificador de 8 a 3 incluyendo las señales internas que entran y salen en los codificadores de 4 a 2. Como se puede apreciar, cuando alguna de las señales de I4 a I7 está activa, el codificador P_CODIF estará deshabilitado, y la salida S2 se pondrá a 1. Cuando ninguna señal de I4 a I7 está activa, se habilita el codificador P_CODIF y la salida S2 estará inactiva.

Diseño digital con esquemáticos y FPGA. v1.8 - 04/06/2008

46

9. Extensión de la capacidad de un codificador

Departamento de Tecnología Electrónica

Señales internas de los codificadores de 4 a 2

ninguna entrada de G_CODIF activa → habilita a P_CODIF alguna entrada de G_CODIF activa → deshabilita a P_CODIF

ENTRADAS G_CODIF P_CODIF EI EI 0 1 1 1 1 1 1 1 1 1

I3 I7 X 0 0 0 0 0 0 0 0 1

I2 I6 X 0 0 0 0 0 0 0 1 X

I1 I5 X 0 0 0 0 0 0 1 X X

I0 I4 X 0 0 0 0 0 1 X X X

EI I3 I3 0 X 1 0 1 0 1 0 1 0 1 1 0 X 0 X 0 X 0 X

I2 I2 X 0 0 0 1 X X X X X

I1 I1 X 0 0 1 X X X X X X

SALIDAS P_CODIF

G_CODIF I0 I0 X 0 1 X X X X X X X

S1 S0 A EO 0 0 0 0 0 0 0 0 1 1

0 0 0 0 0 0 0 1 0 1

0 0 0 0 0 0 1 1 1 1

La salida EO del codificador G_CODIF entra como habilitación (EI) del P_CODIF

0 1 1 1 1 1 0 0 0 0

CODIF8a3

S1 S0 A EO 0 0 0 0 1 1 0 0 0 0

0 0 0 1 0 1 0 0 0 0

0 0 1 1 1 1 0 0 0 0

0 1 0 0 0 0 0 0 0 0

S2 0 0 0 0 0 0 1 1 1 1

S1 0 0 0 0 1 1 0 0 1 1

S0 0 0 0 1 0 1 0 1 0 1

A EO 0 0 0 1 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0

Señales externas (puertos) del codificador de 8 a 3

S1 y S2 del CODIF8a3 lo proporciona P_CODIF S1 y S2 del CODIF8a3 lo proporciona G_CODIF

P_CODIF deshabilitado

Figura 9.3: Tabla de verdad del codificador de 8 a 3 con las señales internas Ahora implementa en la placa el diseño de la figura 9.3: • • • • • • • •

Crea un nuevo proyecto llamado CODIF8a3 Añade una copia del codificador de 4 a 2 que creaste en la práctica anterior (capítulo 8): "Proyect→Add Copy of Source..." y busca el "c:/practicas/edi/tunombre/codif4a2/codif4a2.sch" Crea un símbolo de este codificador: Tools→Symbol Wizard Crea una nueva fuente de tipo esquemático llamada codif8a3 (Proyect→New Source) Realiza el circuito de la figura 9.2 Crea el fichero UCF con los pines que la figura 9.2 indica Baja el circuito a la FPGA Comprueba que funciona correctamente

9.2. Inclusión del convertidor a siete segmentos Ahora puedes repetir el paso que realizaste en el apartado 8.3 pero con el codificador de 8 a 3. De la misma manera tendrás que añadir el convertidor a siete segmentos y crear un símbolo para éste y para el codificador de 8 a 3. El esquema final se muestra en la figura 9.4, que es muy parecido al que habíamos hecho anteriormente (figura 8.9). La mayor diferencia es que ahora la entrada I2 del convertidor a siete segmentos está conectada con la salida S2 del codificador de 8 a 3.

Figura 9.4: Esquema del circuito final

9.3. Codificador mayores Se deja como ejercicio realizar un codificador de 12 entradas a 4 salidas a partir de codificadores de 4 a 2. Para ello las 12 entradas serán los 4 pulsadores y los 8 interruptores (no uses un interruptor como habilitación sino que lo dejas a '1' permanentemente). Normalmente estos codificadores son de 16 a 4, pero lo haremos de 12 a 4 porque no tenemos más pulsadores ni interruptores en la placa.

Diseño digital con esquemáticos y FPGA. v1.8 - 04/06/2008

47

Departamento de Tecnología Electrónica

10. Comparadores

10. Comparadores Ya hemos aprendido a realizar varios diseños: puertas lógicas, decodificadores, codificadores y un convertidor de hexadecimal a siete segmentos. Ahora vamos a hacer un comparador, primero lo haremos de un sólo bit y luego, con comparadores de un bit construiremos uno de dos bits.

10.1. Comparador de un bit Lo primero que haremos es comparar dos números de un bit. Realizar esta comparación es fácil, simplemente tenemos que construir la tabla de verdad y obtener las ecuaciones lógicas. En la figura 10.1 se muestra esta tabla de verdad y la obtención de sus ecuaciones lógicas. Se ha llamado AM a la señal que indica que A es mayor (A>B) y BM a la señal que indica que B es mayor (AB

AB1 • •

O cuando (A1=B1) y A0>B0

A es menor que B (BM=1) cuando • A1B1) ó [(A1=B1) Y (A0>B0)] AM_1=1

IGUAL_1=1

AM_0=1

AM = AM_1 + (IGUAL_1 · AM_0)

Figura 10.4: Comparador de dos bits hecho con comparadores de un bit (falta el AB lucirá el led LD0 de la placa, en otro caso permanecerá apagado Si A=B entonces LD1 se encenderá, en otro caso permanecerá apagado Si AB, la que habíamos llamado AM en el comparador de la figura 11.3. El multiplexor de dos entradas de datos y su esquema en puertas se muestra en la figura 12.1.

Diseño digital con esquemáticos y FPGA. v1.8 - 04/06/2008

55

Departamento de Tecnología Electrónica

MUX A

A

1

S

S

B

0

B

12. El multiplexor

AM

Si AM='1', por la salida S tendremos A Si AM='0', por la salida S tendremos B

AM

Figura 12.1: Multiplexor de dos entradas de datos y una de selección En nuestro caso las entradas de dato del multiplexor tendrán más de un bit, por lo tanto tendríamos que usar una variante de este multiplexor con entradas de tipo bus. Por ejemplo, un multiplexor de dos bits se realizaría como muestra la figura 12.2. En la figura se puede observar que se usa un multiplexor de un bit de ancho para cada bit y que todos los multiplexores tienen la misma señal de selección. A(1:0)

A(1)

A(1)

2

0

A(0)

MUX2_2b A(1:0) B(1:0)

2 2

B(1)

equivalente 0

2

S(1)

1

AM

S(1:0)

2

S(1:0)

1 B(1:0) 2

AM

A(0)

B(1)

0

B(0)

B(0)

S(0)

1

AM

AM

Figura 12.2: Multiplexor de dos entradas de datos de dos bits de ancho Al realizar un diseño, normalmente no hay una única solución para un circuito, sin embargo hay algunas que son más ventajosas que otras. Unas pueden tener menor número de puertas, otras podrán ser más complicadas o ser más rápidas (tienen menos retardos). Por ejemplo, una opción valida para nuestro diseño sería hacerlo como muestra la figura 12.3. En este diseño se convierten los números A y B a siete segmentos, dichas señales convertidas se han llamado A_7SEG y B_7SEG respectivamente. Estas señales pasan por un multiplexor que las va a seleccionar según el valor de AM (según si A>B). Este valor será el que salga por el display. Por otro lado, se muestran también las señales AN_0 y AN_3, que harán que se encienda uno de los dos displays o los dos a la vez si son iguales. El display de la derecha (AN_0) se encenderá cuando A>B (AM='1') ó cuando A=B (IGUAL='1'). El display de la izquierda (AN_3) se encenderá cuando A