Pract Xilinx92 0708

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

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

Í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

Departamento de Tecnología Electrónica Índice

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

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

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ónica1 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 Xilinx2. 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 Digilent3, 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.

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

Departamento de Tecnología Electrónica 2. Encender un LED


FPGA MemoriaFlash

Display7 segmentosLED

Pulsadores Interruptores

Conector JTAG

Jumpers de configuración

Alimentación

VGA

PS/2

Conectorde expansiónFPGA Memoria

Flash

Display7 segmentosLED

Pulsadores Interruptores

Conector JTAG

Jumpers de configuración

Alimentación

VGA

PS/2

Conectorde expansión

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, ...

390Ω

PIN LED46 LD045 LD144 LD243 LD342 LD441 LD537 LD636 LD7

'1' → Encendido

'0' → Apagado

Spartan-II

390Ω

PIN LED46 LD045 LD144 LD243 LD342 LD441 LD537 LD636 LD7

'1' → Encendido

'0' → Apagado

Spartan-II

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



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.



XC2S200PQ208

5C

tipo de dispositivoencapsulado

velocidadrango de operación

C: comercial

código de lote

código de fechaXC2S200PQ208

5C

tipo de dispositivoencapsulado

velocidadrango de operación

C: comercial

código de lote

código de fecha

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

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.



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.schSeleccionar 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.



Plano donde dibujaremos el circuito

SímbolosFuentesOpciones

Procesos

Plano donde dibujaremos el circuitoPlano donde dibujaremos el circuito

SímbolosSímbolosFuentesFuentesOpcionesOpciones

ProcesosProcesos

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.



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 en el icono de la barra de herramientas. Verás que la ventana de opciones cambia, en ella puedes 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



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.



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.



Representación:

jumperdesconectado

jumperconectado

jumper desconectado sin perder su caperuza

su caperuza está perdida y

pisoteada por el suelo del labo

Representación:

jumperdesconectado

jumperconectadojumper

conectadojumper desconectado sin perder su caperuza

su caperuza está perdida y

pisoteada por el suelo del labo

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).



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



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.

Departamento de Tecnología Electrónica 3. Puertas lógicas, interruptores y pulsadores


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.

4,7kΩ

PIN interruptor89 SW088 SW187 SW286 SW384 SW483 SW582 SW681 SW7

Spartan-II3,3V

4,7kΩ

PIN pulsador59 BTN058 BTN157 BTN2154 BTN3

Spartan-II3,3V

4,7kΩ 0,1μF

4,7kΩ

PIN interruptor89 SW088 SW187 SW286 SW384 SW483 SW582 SW681 SW7

Spartan-II3,3V

4,7kΩ

PIN pulsador59 BTN058 BTN157 BTN2154 BTN3

Spartan-II3,3V

4,7kΩ 0,1μF

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.

and2b1

AND de 2 entradas con una de ellas negada

and3b2

AND de 3 entradas con dos de ellas negadas

and2

AND de 2 entradas

and2b1


and2b1


and3b2


and3b2


and2

AND de 2 entradas

and2

AND de 2 entradas

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 OR, y su salida la conectaremos a LD1, obteniendo algo similar a la figura 3.4.



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 implementan pinchando en Add→Wire, o bien con el icono , o bien tecleando CTRL+W. Una vez que hemos 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, SW1 y BRN0) y 4 salidas (LD0, LD1, LD2 y LD3). Y deberá tener el siguiente aspecto:

Figura 3.8: Diseño final del ejercicio



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

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



"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 de entradaPuertos de entrada Eje temporalEje temporal

Valores de las señales en el tiempoValores de las señales en el tiempoPuertos de salidaPuertos de salida

Puertos de entradaPuertos de entrada Eje temporalEje temporal

Valores de las señales en el tiempoValores de las señales en el tiempoPuertos de salidaPuertos de salida

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



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.

tiempo SW0 SW1 LD0 0-100ns 0 0 0100-200 0 1 0200-300 1 0 0300-400 1 1 1

LD0: ANDtiempo SW2 SW3 LD1 0-100ns 0 0 0100-200 0 1 1200-300 1 0 1300-400 1 1 1

LD1: ORtiempo BTN0 LD2 LD3 0-200ns 0 1 0200-400 1 0 1

LD2: NOTtiempo SW0 SW1 LD0 0-100ns 0 0 0100-200 0 1 0200-300 1 0 0300-400 1 1 1

LD0: ANDtiempo SW2 SW3 LD1 0-100ns 0 0 0100-200 0 1 1200-300 1 0 1300-400 1 1 1

LD1: ORtiempo BTN0 LD2 LD3 0-200ns 0 1 0200-400 1 0 1

LD2: NOT

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ño4: 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



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.

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.

A0

A1

S0

S1

S2

S3E

DECOD 2a4E A1 A0 S3 S2 S1 S00 X X 0 0 0 01 0 0 0 0 0 11 0 1 0 0 1 01 1 0 0 1 0 01 1 1 1 0 0 0

A0

A1

S0

S1

S2

S3E

DECOD 2a4E A1 A0 S3 S2 S1 S00 X X 0 0 0 01 0 0 0 0 0 11 0 1 0 0 1 01 1 0 0 1 0 01 1 1 1 0 0 0

E A1 A0 S3 S2 S1 S00 X X 0 0 0 01 0 0 0 0 0 11 0 1 0 0 1 01 1 0 0 1 0 01 1 1 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 salida S0 es el término mínimo 0 (m0=A1 ⎯⎯ ·A0 ⎯⎯ ); la salida S1 es el término mínimo 1 (m1=A1 ⎯⎯ ·A0), y de manera 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 C:/practica/edi/tunombre. 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. 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

Ahora conectamos un cable a la salida de cada inversor (mediante el icono ). El otro lado del cable lo 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



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



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

m0S0

E='0'

m0S0='0'

E='0' → Salida inhabilitada

E='1'

m0S0=m0

E='1' → Salida habilitadaE → Habilitación

E

m0S0

E='0'

m0S0='0'

E='0' → Salida inhabilitada

E='1'

m0S0=m0

E='1' → Salida habilitadaE → Habilitación

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.



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.



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.



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 en puertasEsquema en puertas SímboloSímboloEsquema en puertasEsquema en puertas SímboloSí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.



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.

A0

A1

S0

S1

S2

S3

E

DECOD 3a8

S4

S5

S6

S7

A2

E A2 A1 A0 S7 S6 S5 S4 S3 S2 S1 S00 X X X 0 0 0 0 0 0 0 01 0 0 0 0 0 0 0 0 0 0 11 0 0 1 0 0 0 0 0 0 1 01 0 1 0 0 0 0 0 0 1 0 01 0 1 1 0 0 0 0 1 0 0 01 1 0 0 0 0 0 1 0 0 0 01 1 0 1 0 0 1 0 0 0 0 01 1 1 0 0 1 0 0 0 0 0 01 1 1 1 1 0 0 0 0 0 0 0

A0

A1

S0

S1

S2

S3

E

DECOD 3a8

S4

S5

S6

S7

A2



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 E y A2 (figura 5.2), podemos ver que:

• Cuando E=0, el circuito está inactivo • Cuando E=1, y A2=0, las señales S7 a S4 están inactivas, y las señales S3 a S0 se comportan igual que el

decodificador de 2 a 4. • Cuando E=1, y A2=1, las señales S3 a S0 están inactivas, y las señales S7 a S4 se comportan igual que el

decodificador de 2 a 4.

E A2 A1 A0 S7 S6 S5 S4 S3 S2 S1 S01 0 0 0 0 0 0 0 0 0 0 11 0 0 1 0 0 0 0 0 0 1 01 0 1 0 0 0 0 0 0 1 0 01 0 1 1 0 0 0 0 1 0 0 0

A2 = '1'

E A2 A1 A0 S7 S6 S5 S4 S3 S2 S1 S00 X X X 0 0 0 0 0 0 0 0

A2 = '0'

todas '0' igual que decod2a4

E A2 A1 A0 S7 S6 S5 S4 S3 S2 S1 S01 1 0 0 0 0 0 1 0 0 0 01 1 0 1 0 0 1 0 0 0 0 01 1 1 0 0 1 0 0 0 0 0 01 1 1 1 1 0 0 0 0 0 0 0

todas '0'igual que decod2a4

todas '0'

misma secuencia

E A2 A1 A0 S7 S6 S5 S4 S3 S2 S1 S01 0 0 0 0 0 0 0 0 0 0 11 0 0 1 0 0 0 0 0 0 1 01 0 1 0 0 0 0 0 0 1 0 01 0 1 1 0 0 0 0 1 0 0 0

A2 = '1'

E A2 A1 A0 S7 S6 S5 S4 S3 S2 S1 S00 X X X 0 0 0 0 0 0 0 0E A2 A1 A0 S7 S6 S5 S4 S3 S2 S1 S00 X X X 0 0 0 0 0 0 0 0

A2 = '0'

todas '0' igual que decod2a4

E A2 A1 A0 S7 S6 S5 S4 S3 S2 S1 S01 1 0 0 0 0 0 1 0 0 0 01 1 0 1 0 0 1 0 0 0 0 01 1 1 0 0 1 0 0 0 0 0 01 1 1 1 1 0 0 0 0 0 0 0

E A2 A1 A0 S7 S6 S5 S4 S3 S2 S1 S01 1 0 0 0 0 0 1 0 0 0 01 1 0 1 0 0 1 0 0 0 0 01 1 1 0 0 1 0 0 0 0 0 01 1 1 1 1 0 0 0 0 0 0 0

todas '0'igual que decod2a4

todas '0'

misma secuencia

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 E=1 y A2=0 ; esto es E·A2 ⎯⎯ ; y otro decodificador para las señales S7 a S4, que se activará cuando E=1 y A2=1 (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.



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 del proyectoSímbolos del proyecto

Símbolo del decodificador de 2 a 4Símbolo del decodificador de 2 a 4

Decodificador de 2 a 4Decodificador de 2 a 4

Símbolos del proyectoSímbolos del proyecto

Símbolo del decodificador de 2 a 4Símbolo del decodificador de 2 a 4

Decodificador de 2 a 4Decodificador de 2 a 4

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



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.



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.

A0

A1

S0S1S2S3

E

DECOD4a16

S4S5S6S7

A2

A3

S8S9S10S11S12S13S14S15

E A3 A2 A1 A0 S15 S14 S13 S12 S11 S10 S9 S8 S7 S6 S5 S4 S3 S2 S1 S00 X X X X 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 01 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 11 0 0 0 1 0 0 0 0 0 0 0 0 0 0 0 0 0 0 1 01 0 0 1 0 0 0 0 0 0 0 0 0 0 0 0 0 0 1 0 01 0 0 1 1 0 0 0 0 0 0 0 0 0 0 0 0 1 0 0 01 0 1 0 0 0 0 0 0 0 0 0 0 0 0 0 1 0 0 0 01 0 1 0 1 0 0 0 0 0 0 0 0 0 0 1 0 0 0 0 01 0 1 1 0 0 0 0 0 0 0 0 0 0 1 0 0 0 0 0 01 0 1 1 1 0 0 0 0 0 0 0 0 1 0 0 0 0 0 0 01 1 0 0 0 0 0 0 0 0 0 0 1 0 0 0 0 0 0 0 0 1 1 0 0 1 0 0 0 0 0 0 1 0 0 0 0 0 0 0 0 0 1 1 0 1 0 0 0 0 0 0 1 0 0 0 0 0 0 0 0 0 0 1 1 0 1 1 0 0 0 0 1 0 0 0 0 0 0 0 0 0 0 0 1 1 1 0 0 0 0 0 1 0 0 0 0 0 0 0 0 0 0 0 0 1 1 1 0 1 0 0 1 0 0 0 0 0 0 0 0 0 0 0 0 0 1 1 1 1 0 0 1 0 0 0 0 0 0 0 0 0 0 0 0 0 0 1 1 1 1 0 1 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0

decod1

decod2

decod3

decod4

A0

A1

S0S1S2S3

E

DECOD4a16

S4S5S6S7

A2

A3

S8S9S10S11S12S13S14S15

E A3 A2 A1 A0 S15 S14 S13 S12 S11 S10 S9 S8 S7 S6 S5 S4 S3 S2 S1 S00 X X X X 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 01 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 11 0 0 0 1 0 0 0 0 0 0 0 0 0 0 0 0 0 0 1 01 0 0 1 0 0 0 0 0 0 0 0 0 0 0 0 0 0 1 0 01 0 0 1 1 0 0 0 0 0 0 0 0 0 0 0 0 1 0 0 01 0 1 0 0 0 0 0 0 0 0 0 0 0 0 0 1 0 0 0 01 0 1 0 1 0 0 0 0 0 0 0 0 0 0 1 0 0 0 0 01 0 1 1 0 0 0 0 0 0 0 0 0 0 1 0 0 0 0 0 01 0 1 1 1 0 0 0 0 0 0 0 0 1 0 0 0 0 0 0 01 1 0 0 0 0 0 0 0 0 0 0 1 0 0 0 0 0 0 0 0 1 1 0 0 1 0 0 0 0 0 0 1 0 0 0 0 0 0 0 0 0 1 1 0 1 0 0 0 0 0 0 1 0 0 0 0 0 0 0 0 0 0 1 1 0 1 1 0 0 0 0 1 0 0 0 0 0 0 0 0 0 0 0 1 1 1 0 0 0 0 0 1 0 0 0 0 0 0 0 0 0 0 0 0 1 1 1 0 1 0 0 1 0 0 0 0 0 0 0 0 0 0 0 0 0 1 1 1 1 0 0 1 0 0 0 0 0 0 0 0 0 0 0 0 0 0 1 1 1 1 0 1 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0

decod1

decod2

decod3

decod4

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 A3 A2 A1 A0 S15 S14 S13 S12 S11 S10 S9 S8 S7 S6 S5 S4 S3 S2 S1 S00 X X X X 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0

todas '0'

E = '0':Inhabilitado

E A3 A2 A1 A0 S15 S14 S13 S12 S11 S10 S9 S8 S7 S6 S5 S4 S3 S2 S1 S01 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 11 0 0 0 1 0 0 0 0 0 0 0 0 0 0 0 0 0 0 1 01 0 0 1 0 0 0 0 0 0 0 0 0 0 0 0 0 0 1 0 01 0 0 1 1 0 0 0 0 0 0 0 0 0 0 0 0 1 0 0 0

todas '0' igual que decod2a4para las entradas A1 y A0

A3 = '0'A2 = '0'

A3 = '0'A2 = '0'

decod 0activo cuando

todas '0' igual quedecod2a4

A3 = '0'A2 = '1'

A3 = '0'A2 = '1'



todas '0'

todas '0'igual quedecod2a4

A3 = '1'A2 = '0'

A3 = '1'A2 = '0'


todas '0'

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


A3 = '1'A2 = '1'

A3 = '1'A2 = '1'



misma secuencia

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

todas '0'

E = '0':Inhabilitado



todas '0' igual que decod2a4para las entradas A1 y A0

A3 = '0'A2 = '0'

A3 = '0'A2 = '0'


todas '0' igual quedecod2a4

A3 = '0'A2 = '1'

A3 = '0'A2 = '1'



todas '0'


A3 = '1'A2 = '0'

A3 = '1'A2 = '0'


todas '0'



A3 = '1'A2 = '1'

A3 = '1'A2 = '1'



misma secuencia

Figura 6.2: Tabla de verdad del decodificador de 4 a 16 dividida según el valor de E y de A3 y A2



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.

E A3 A2 E3 E2 E1 E00 X X 0 0 0 01 0 0 0 0 0 11 0 1 0 0 1 01 1 0 0 1 0 01 1 1 1 0 0 0

Señales de habilitación de los 4 decodificadores

decodificador 0 habilitadoNingún decodificador habilitado

decodificador 1 habilitadodecodificador 2 habilitadodecodificador 3 habilitado

E A3 A2 E3 E2 E1 E00 X X 0 0 0 01 0 0 0 0 0 11 0 1 0 0 1 01 1 0 0 1 0 01 1 1 1 0 0 0

E A3 A2 E3 E2 E1 E00 X X 0 0 0 01 0 0 0 0 0 11 0 1 0 0 1 01 1 0 0 1 0 01 1 1 1 0 0 0

Señales de habilitación de los 4 decodificadores

decodificador 0 habilitadoNingún decodificador habilitado

decodificador 1 habilitadodecodificador 2 habilitadodecodificador 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).



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.



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 →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.



Tiempo de simulación

Simular por el tiempo especificado

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.

Departamento de Tecnología Electrónica 7. Convertidor de hexadecimal a 7 segmentos


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. 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.

A

G

D

B

CDP

F

E

A

G

D

B

CDP

F

E

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.

A

G

D

B

C

F

E

0A

G

D

B

C

F

E

1A

G

D

B

C

F

E

2A

G

D

B

C

F

E

3A

G

D

B

C

F

E

4A

G

D

B

C

F

E

5A

G

D

B

C

F

E

6A

G

D

B

C

F

E

7

A

G

D

B

C

F

E

8A

G

D

B

C

F

E

9A

G

D

B

C

F

E

AA

G

D

B

C

F

E

BA

G

D

B

C

F

E

CA

G

D

B

C

F

E

DA

G

D

B

C

F

E

EA

G

D

B

C

F

E

F

A

G

D

B

C

F

E

0A

G

D

B

C

F

E

1A

G

D

B

C

F

E

2A

G

D

B

C

F

E

3A

G

D

B

C

F

E

4A

G

D

B

C

F

E

5A

G

D

B

C

F

E

6A

G

D

B

C

F

E

7

A

G

D

B

C

F

E

8A

G

D

B

C

F

E

9A

G

D

B

C

F

E

AA

G

D

B

C

F

E

BA

G

D

B

C

F

E

CA

G

D

B

C

F

E

DA

G

D

B

C

F

E

EA

G

D

B

C

F

E

F

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.



I0

I1

SEG_ASEG_BSEG_CSEG_D

E

HEX7SEG

SEG_ESEG_FSEG_GSEG_DT

I2

I3

AN_0AN_1AN_2AN_3

Número codificado:A los interruptores:

SW0, SW1, SW2, SW3

Habilitación:

Salida a los 7 segmentos

Encendido de los displaysAN0: display de la derecha

Punto decimal del display

I0

I1

SEG_ASEG_BSEG_CSEG_D

E

HEX7SEG

SEG_ESEG_FSEG_GSEG_DT

I2

I3

AN_0AN_1AN_2AN_3

Número codificado:A los interruptores:

SW0, SW1, SW2, SW3

Habilitación:

Salida a los 7 segmentos

Encendido de los displaysAN0: display de la derecha

Punto decimal del display

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).

nº I3 I2 I1 I0 A B C D E F G0 0 0 0 0 0 0 0 0 1 0 0 0 1 1 0 0 1 2 0 0 1 0 0 0 1 0 3 0 0 1 1 0 0 0 0 4 0 1 0 0 1 0 0 1 5 0 1 0 1 0 1 0 0 6 0 1 1 0 0 1 0 0 7 0 1 1 1 0 0 0 1 8 1 0 0 0 0 0 0 0 9 1 0 0 1 0 0 0 1 A 1 0 1 0 0 0 0 1 B 1 0 1 1 1 1 0 0 C 1 1 0 0 0 1 1 0 D 1 1 0 1 1 0 0 0 E 1 1 1 0 0 1 1 0 F 1 1 1 0 0 1 1 1

segmentos

ojo esto son números en hex,

no son los segmentos

nº I3 I2 I1 I0 A B C D E F G0 0 0 0 0 0 0 0 0 1 0 0 0 1 1 0 0 1 2 0 0 1 0 0 0 1 0 3 0 0 1 1 0 0 0 0 4 0 1 0 0 1 0 0 1 5 0 1 0 1 0 1 0 0 6 0 1 1 0 0 1 0 0 7 0 1 1 1 0 0 0 1 8 1 0 0 0 0 0 0 0 9 1 0 0 1 0 0 0 1 A 1 0 1 0 0 0 0 1 B 1 0 1 1 1 1 0 0 C 1 1 0 0 0 1 1 0 D 1 1 0 1 1 0 0 0 E 1 1 1 0 0 1 1 0 F 1 1 1 0 0 1 1 1

segmentos

ojo esto son números en hex,

no son los segmentos

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 35. 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



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.

S1S2S3S4S5S6S7S8S9

S10S11S12S13S14S15

A0A1A2A3E

I3 I2 I1 I0 A 0 0 0 0 0 0 0 0 1 1 0 0 1 0 0 0 0 1 1 0 0 1 0 0 10 1 0 1 00 1 1 0 00 1 1 1 01 0 0 0 01 0 0 1 01 0 1 0 01 0 1 1 11 1 0 0 01 1 0 1 11 1 1 0 01 1 1 0 0

m1

m4

Para la A tomamos las salidas 1, 4, 11 y 13

m11

m13

SEG_A

I0

I1

I2

I3

E

S0S1S2S3S4S5S6S7S8S9

S10S11S12S13S14S15

A0A1A2A3E

I3 I2 I1 I0 A 0 0 0 0 0 0 0 0 1 1 0 0 1 0 0 0 0 1 1 0 0 1 0 0 10 1 0 1 00 1 1 0 00 1 1 1 01 0 0 0 01 0 0 1 01 0 1 0 01 0 1 1 11 1 0 0 01 1 0 1 11 1 1 0 01 1 1 0 0

m1

m4

Para la A tomamos las salidas 1, 4, 11 y 13

m11

m13

SEG_A

I0I0

I1I1

I2I2

I3I3

EE

S0

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.

I3 I2 I1 I0 A 0 0 0 0 0 0 0 0 1 1 0 0 1 0 0 0 0 1 1 0 0 1 0 0 10 1 0 1 00 1 1 0 00 1 1 1 01 0 0 0 01 0 0 1 01 0 1 0 01 0 1 1 11 1 0 0 01 1 0 1 11 1 1 0 01 1 1 0 0

m1

m4

m11

m13

Lógica negada: números que hacen "No lucir" el segmento A

SEGAm1m4

m13m11

A

G

D

B

C

F

E

1A

G

D

B

C

F

E

4

A

G

D

B

C

F

E

B11

A

G

D

B

C

F

E

D13

A

G

D

B

C

F

E

1A

G

D

B

C

F

E

4

A

G

D

B

C

F

E

B11

A

G

D

B

C

F

E

D13

I3 I2 I1 I0 A 0 0 0 0 10 0 0 1 00 0 1 0 10 0 1 1 10 1 0 0 00 1 0 1 10 1 1 0 10 1 1 1 11 0 0 0 11 0 0 1 11 0 1 0 11 0 1 1 01 1 0 0 11 1 0 1 01 1 1 0 11 1 1 0 1

m0

m2

m12

Lógica afirmada: números que hacen "lucir" el segmento A

SEGA

m0m2

m5m3

m3

m5m6m7m8m9m10

m14m15

m7m8

m10m9

m12

m15m14

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

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á

I3 I2 I1 I0 A 0 0 0 0 0 0 0 0 1 1 0 0 1 0 0 0 0 1 1 0 0 1 0 0 10 1 0 1 00 1 1 0 00 1 1 1 01 0 0 0 01 0 0 1 01 0 1 0 01 0 1 1 11 1 0 0 01 1 0 1 11 1 1 0 01 1 1 0 0

m1

m4

m11

m13

Lógica negada: números que hacen "No lucir" el segmento A

SEGAm1m4

m13m11

SEGAm1m4

m1m4

m13m11

A

G

D

B

C

F

E

1A

G

D

B

C

F

E

4

A

G

D

B

C

F

E

B11

A

G

D

B

C

F

E

D13

A

G

D

B

C

F

E

1A

G

D

B

C

F

E

4

A

G

D

B

C

F

E

B11

A

G

D

B

C

F

E

D13

I3 I2 I1 I0 A 0 0 0 0 10 0 0 1 00 0 1 0 10 0 1 1 10 1 0 0 00 1 0 1 10 1 1 0 10 1 1 1 11 0 0 0 11 0 0 1 11 0 1 0 11 0 1 1 01 1 0 0 11 1 0 1 01 1 1 0 11 1 1 0 1

m0

m2

m12

Lógica afirmada: números que hacen "lucir" el segmento A

SEGA

m0m2

m5m3

m3

m5m6m7m8m9m10

m14m15

m7m8

m10m9

m12

m15m14

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

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á

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.



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.

S1

S2

S3

S4

S5

S6

S7

S8

S9

S10

S11

S12

S13

S14

S15

S0

SEG_B

S1

S2

S3

S4

S5

S6

S7

S8

S9

S10

S11

S12

S13

S14

S15

S0

SEG_BSEG_B

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.



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".



Convertidor HEX a 7SEGdiseño de mayor jerarquía El decodificador es un

componente del convertidor: Símbolo que indica el

componente de mayor jerarquía

Convertidor HEX a 7SEGdiseño de mayor jerarquía 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).

Fichero de restricciones .ucfFichero de restricciones .ucf

Aquí se escribenlas restricciones

Edit Constraints (Text)

Fichero de restricciones .ucfFichero de restricciones .ucf

Aquí se escribenlas restriccionesAquí se escribenlas restricciones

Edit Constraints (Text)Edit Constraints (Text)

Figura 7.14: Edición de las restricciones en texto



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 displays NET "AN_0" LOC = "P60" ; NET "AN_1" LOC = "P69" ; NET "AN_2" LOC = "P71" ; NET "AN_3" LOC = "P75" ; #7 segmentos NET "SEG_A" LOC = "P74" ; NET "SEG_B" LOC = "P70" ; NET "SEG_C" LOC = "P67" ; NET "SEG_D" LOC = "P62" ; NET "SEG_E" LOC = "P61" ; NET "SEG_F" LOC = "P73" ; NET "SEG_G" LOC = "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, "Synthesize-XST", "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').

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

BTN3 I3

BTN2 I2BTN1 I1BTN0 I0

LED0S0LED1S1

I0I1I2I3

entradaactiva

salidasS1 S00 00 11 01 1

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

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

S1

I1

I3I2

CODIF

BTN3 I3BTN3 I3

BTN2 I2BTN2 I2BTN1 I1BTN1 I1BTN0 I0BTN0 I0

LED0S0LED1S1

I0I1I2I3

entradaactiva

salidasS1 S00 00 11 01 1


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

I1I2I3

entradaactiva

salidasS1 S00 00 11 01 1


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

S1

I1

I3I2

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) ninguna BTN0 BTN1 BTN2 BTN3 BTN1 y BTN2

LD0LD1

00

LD0LD1

00

LD0LD1

01

LD0LD1

10

LD0LD1

11

LD0LD1

11

LEDsencendidos ycodificación

Entrada activa(pulsador) ninguna BTN0 BTN1 BTN2 BTN3 BTN1 y BTN2

LD0LD1

00

LD0LD1

00

LD0LD1

01

LD0LD1

10

LD0LD1

11

LD0LD1

11

LEDsencendidos ycodificación

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.



S0

S1

I1

I3I2

AI0

A se enciende cuando cualquier entrada esté activa:

I0 + I1 + I2 + I3

--I0I1I2I3

entradaactiva

salidasS1 S0 A0 0 00 0 10 1 11 0 11 1 1

Diferencia entre pulsar I0 y no

pulsar nada

S0

S1

I1

I3I2

AI0

A se enciende cuando cualquier entrada esté activa:

I0 + I1 + I2 + I3

--I0I1I2I3

entradaactiva

salidasS1 S0 A0 0 00 0 10 1 11 0 11 1 1

Diferencia entre pulsar I0 y no

pulsar nada

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

BTN3 I3

BTN2 I2BTN1 I1BTN0 I0 P0

P1P2P3

CODIF

S0S1

A

S0SA

AP3P2P1

P0

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

puede haber más de una que valga 1

PRIOR

BTN3 I3BTN3 I3

BTN2 I2BTN2 I2BTN1 I1BTN1 I1BTN0 I0BTN0 I0 P0

P1P2P3

CODIF

S0S1

A

S0SA

AP3P2P1

P0

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

puede haber más de una 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.

I3 P3

I2 P2

Si I3='1' entonces P2='0'

I3 P3

I2 P2

Si I3='1' entonces P2=I2

'1'

'0''0'

'0'

'1'I2

'0'

"deja pasar I2""no deja pasar I2"I3 P3

I2 P2

Si I3='1' entonces P2='0'

I3 P3

I2 P2

Si I3='1' entonces P2=I2

'1'

'0''0'

'0'

'1'I2

'0'

"deja pasar I2""no 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.

I3 P3

I2 P2

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

I1P1

I0P0

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

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

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

I3 I2 I1 I0 P3 P2 P1 P00 0 0 0 0 0 0 00 0 0 1 0 0 0 10 0 1 X 0 0 1 00 1 X X 0 1 0 01 X X X 1 0 0 0

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

I3 P3

I2 P2


I1P1

I0P0



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

I2 P2


I1P1

I0P0



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

I3 I2 I1 I0 P3 P2 P1 P00 0 0 0 0 0 0 00 0 0 1 0 0 0 10 0 1 X 0 0 1 00 1 X X 0 1 0 01 X X X 1 0 0 0


I3 I2 I1 I0 P3 P2 P1 P00 0 0 0 0 0 0 00 0 0 1 0 0 0 10 0 1 X 0 0 1 00 1 X X 0 1 0 01 X X X 1 0 0 0

I3 I2 I1 I0 P3 P2 P1 P00 0 0 0 0 0 0 00 0 0 1 0 0 0 10 0 1 X 0 0 1 00 1 X X 0 1 0 01 X X X 1 0 0 0


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



circuito más sencillo debido a que ese caso nunca se va a dar. Esta libertad no la tengo con las X en las entradas. 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

EI I3 I2 I1 I0 S1 S0 A EO0 X X X X 0 0 0 01 0 0 0 0 0 0 0 11 0 0 0 1 0 0 1 01 0 0 1 X 0 1 1 01 0 1 X X 1 0 1 01 1 X X X 1 1 1 0

CODIF

BTN3 I3BTN2 I2BTN1 I1BTN0 I0

LED0S0LED1S1

LED6AEI

EO

SW7

LED7EI I3 I2 I1 I0 S1 S0 A EO0 X X X X 0 0 0 01 0 0 0 0 0 0 0 11 0 0 0 1 0 0 1 01 0 0 1 X 0 1 1 01 0 1 X X 1 0 1 01 1 X X X 1 1 1 0


CODIF

BTN3 I3BTN2 I2BTN1 I1BTN0 I0

LED0S0LED1S1

LED6AEI

EO

SW7

LED7CODIF

BTN3 I3BTN3 I3BTN2 I2BTN2 I2BTN1 I1BTN1 I1BTN0 I0BTN0 I0

LED0S0LED1S1

LED6AEI

EO

SW7

LED7

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 A0='0' y EI='1'. A estas alturas, esta condición nos debería ser fácil de implementar en puertas lógicas. El circuito final nos quedará como muestra la figura 8.8.

I3P3

I2 P2

I1 P1

I0 P0

A

EI

S0

S1

EOPRIOR

I3P3

I2 P2

I1 P1

I0 P0

A

EI

S0

S1

EOPRIOR

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



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.

Departamento de Tecnología Electrónica 9. Extensión de la capacidad de un codificador


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.

EI I7 I6 I5 I4 I3 I2 I1 I0 S2 S1 S0 A EO0 X X X X X X X X 0 0 0 0 01 0 0 0 0 0 0 0 0 0 0 0 0 11 0 0 0 0 0 0 0 1 0 0 0 1 01 0 0 0 0 0 0 1 X 0 0 1 1 01 0 0 0 0 0 1 X X 0 1 0 1 01 0 0 0 0 1 X X X 0 1 1 1 01 0 0 0 1 X X X X 1 0 0 1 01 0 0 1 X X X X X 1 0 1 1 01 0 1 X X X X X X 1 1 0 1 01 1 X X X X X X X 1 1 1 1 0

CODIF

SW7 I3

SW6 I2SW5 I1SW4 I0

LED0S0

LED1S1

LED6A

EI

EO

SW0

LED7

LED2S2

BTN3 I7




CODIF

SW7 I3

SW6 I2SW5 I1SW4 I0

LED0S0

LED1S1

LED6A

EI

EO

SW0

LED7

LED2S2

BTN3 I7


CODIF

SW7 I3

SW6 I2SW5 I1SW4 I0

LED0S0

LED1S1

LED6A

EI

EO

SW0

LED7

LED2S2

BTN3 I7


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.

SW7

I3

SW6

I2

SW5

I1

SW4

I0S0S1

LED6AEI

EO

SW0

P_CODIF

I3

I2I1I0

S0S1

AEI

EO LED7

G_CODIF

BTN3

BTN2BTN1BTN0

I3

I2I1I0

I7I6I5I4

EIA

LED1S1

LED0S0

LED2S2

CODIF8a3

SW7

I3

SW6

I2

SW5

I1

SW4

I0S0S1

LED6AEI

EO

SW0

P_CODIF

I3

I2I1I0

S0S1

AEI

EO LED7

G_CODIF

BTN3

BTN2BTN1BTN0

I3

I2I1I0

I7I6I5I4

EIA

LED1S1

LED0S0

LED2S2

CODIF8a3

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.

Departamento de Tecnología Electrónica 9. Extensión de la capacidad de un codificador


EI I7 I6 I5 I4 I3 I2 I1 I0 S2 S1 S0 A EO0 X X X X 0 X X X X 0 0 0 0 0 0 0 0 0 0 0 0 01 0 0 0 0 1 0 0 0 0 0 0 0 1 0 0 0 1 0 0 0 0 11 0 0 0 0 1 0 0 0 1 0 0 0 1 0 0 1 0 0 0 0 1 01 0 0 0 0 1 0 0 1 X 0 0 0 1 0 1 1 0 0 0 1 1 01 0 0 0 0 1 0 1 X X 0 0 0 1 1 0 1 0 0 1 0 1 01 0 0 0 0 1 1 X X X 0 0 0 1 1 1 1 0 0 1 1 1 01 0 0 0 1 0 X X X X 0 0 1 0 0 0 0 0 1 0 0 1 01 0 0 1 X 0 X X X X 0 1 1 0 0 0 0 0 1 0 1 1 01 0 1 X X 0 X X X X 1 0 1 0 0 0 0 0 1 1 0 1 01 1 X X X 0 X X X X 1 1 1 0 0 0 0 0 1 1 1 1 0

EI I3 I2 I1 I0 EI I3 I2 I1 I0 S1 S0 A EO S1 S0 A EO

G_CODIF P_CODIF G_CODIF P_CODIF CODIF8a3ENTRADAS SALIDAS

Señales externas (puertos) del

codificador de 8 a 3

Señales internas de los codificadores

de 4 a 2

La salida EO del codificador G_CODIF entra como

habilitación (EI) del P_CODIF

P_CODIFdeshabilitado

ninguna entrada de G_CODIF activa →habilita a P_CODIF

alguna entrada de G_CODIF activa →

deshabilita a P_CODIF

S1 y S2 del CODIF8a3lo proporciona P_CODIF

S1 y S2 del CODIF8a3lo proporciona G_CODIF

EI I7 I6 I5 I4 I3 I2 I1 I0 S2 S1 S0 A EO0 X X X X 0 X X X X 0 0 0 0 0 0 0 0 0 0 0 0 01 0 0 0 0 1 0 0 0 0 0 0 0 1 0 0 0 1 0 0 0 0 11 0 0 0 0 1 0 0 0 1 0 0 0 1 0 0 1 0 0 0 0 1 01 0 0 0 0 1 0 0 1 X 0 0 0 1 0 1 1 0 0 0 1 1 01 0 0 0 0 1 0 1 X X 0 0 0 1 1 0 1 0 0 1 0 1 01 0 0 0 0 1 1 X X X 0 0 0 1 1 1 1 0 0 1 1 1 01 0 0 0 1 0 X X X X 0 0 1 0 0 0 0 0 1 0 0 1 01 0 0 1 X 0 X X X X 0 1 1 0 0 0 0 0 1 0 1 1 01 0 1 X X 0 X X X X 1 0 1 0 0 0 0 0 1 1 0 1 01 1 X X X 0 X X X X 1 1 1 0 0 0 0 0 1 1 1 1 0

EI I3 I2 I1 I0 EI I3 I2 I1 I0 S1 S0 A EO S1 S0 A EO

G_CODIF P_CODIF G_CODIF P_CODIF CODIF8a3ENTRADAS SALIDAS

Señales externas (puertos) del

codificador de 8 a 3

Señales internas de los codificadores

de 4 a 2

La salida EO del codificador G_CODIF entra como

habilitación (EI) del P_CODIF

P_CODIFdeshabilitado

ninguna entrada de G_CODIF activa →habilita a P_CODIF

alguna entrada de G_CODIF activa →

deshabilita a P_CODIF

S1 y S2 del CODIF8a3lo proporciona P_CODIF

S1 y S2 del CODIF8a3lo proporciona G_CODIF

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.

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 (A<B).

A B IGUAL AM BM0 0 1 0 00 1 0 0 11 0 0 1 01 1 1 0 0

A=B A>B A<B

IGUAL=(A·B)+(A·B)=A⊕B

AM = m2 = A·B

BM = m1 = A·B A

B

IGUALAMBM

COMPA1A B IGUAL AM BM0 0 1 0 00 1 0 0 11 0 0 1 01 1 1 0 0

A=B A>B A<B

IGUAL=(A·B)+(A·B)=A⊕B

AM = m2 = A·BAM = m2 = A·B

BM = m1 = A·B A

B

IGUALAMBM

COMPA1

A

B

IGUALAMBM

COMPA1

Figura 10.1: Tabla de verdad, ecuaciones lógicas, y entradas y salidas del comparador de un bit

El diseño de este circuito es bien fácil, sólo son tres puertas, dos puertos de entrada y tres de salida (figura 10.1). Cierra el proyecto anterior, abre uno nuevo llamado compa y crea un nuevo fichero llamado compa1. Una vez que tengas el plano del circuito, añade las puertas lógicas, recuerda que tienes puertas AND con una entrada negada para implementar la función A ⎯⎯ ·B y A· B ⎯⎯ (estas se llaman and2b1 y tienen una bolita de negación en una de sus entradas). También tienes funciones XNOR para implementar la salida IGUAL. Pon los puertos con los mismos nombres de la figura 10.1. Cuando tengas el circuito listo guárdalo (CRTL+S) y comprueba el esquemático (Tools→Check Schematic). Si el diseño está bien pasaremos a implementarlo en la FPGA. Ahora asignamos los pines, ya sabes como se hace, o bien con el fichero UCF o con la herramienta PACE. Los vas a asignar como muestra la tabla 10.1: Recuerda que en los pines tienes que poner el que indica en la placa, por ejemplo para SW0 pondrás P89. Y por fin implementa el comparador y comprueba que funciona bien.

A SW0 B SW1

AM LD0 IGUAL LD1

BM LD2

Tabla 10.1: Tabla de asignación de señales

10.2. Comparador de dos bits Un comparador de un solo bit es bastante fácil ya que sólo tenemos 4 posibles combinaciones. Para uno de dos bits hay que pensárselo un poco más. El bloque que queremos implementar se muestra en la figura 10.2. A partir de dos señales de 2 bits, queremos saber si son iguales, o si una es mayor que la otra. Como son señales de dos bits tenemos que saber cuál es el bit más significativo. Recuerda que no es lo mismo 102 que 012. A pesar de que tienen el mismo número de unos y ceros, el orden en que están situados determina la diferencia. Por lo tanto tenemos que diferenciar cuál es el bit más significativo. Para eso podemos representar el circuito como el bloque de la izquierda de la figura 10.2. En donde se muestran uno por uno todos los bits (o cables) de cada señal. Sin embargo, para evitar tener que poner un cable para cada bit, se puede representar como un bus. Esta representación se muestra a la derecha de la figura 10.2. Para este ejemplo no se nota mucho la diferencia, pero imagínate que quieras hacer un comparador de 32 bits.



A0

B0

IGUALAMBM

COMPA2

A1

B1

bit mássignificativo


A(1:0)

IGUALAMBM

COMPA2

B(1:0)

2

2

ancho del bus

A0

B0

IGUALAMBM

COMPA2

A1

B1



A(1:0)

IGUALAMBM

COMPA2

B(1:0)

2

2

ancho del bus Figura 10.2: Diagramas de entradas y salidas del comparador de dos bits. A la izquierda con cables simple, a

la.derecha con buses.

El comparador de 2 bits lo podríamos hacer igual que el cuarto ejercicio de los propuestos del tema 3. Como tenemos cuatro variables es un número adecuado para hacerlo por Karnaugh. Sin embargo, ya que tenemos el comparador de 1 bit, lo utilizaremos para hacerlo modularmente. La tabla de verdad del circuito se muestra en la tabla 10.2.

A1 A0 B1 B0 IGUAL AM BM0 0 0 0 1 0 00 0 0 1 0 0 10 0 1 0 0 0 10 0 1 1 0 0 10 1 0 0 0 1 00 1 0 1 1 0 0 0 1 1 0 0 0 10 1 1 1 0 0 11 0 0 0 0 1 01 0 0 1 0 1 01 0 1 0 1 0 01 0 1 1 0 0 11 1 0 0 0 1 01 1 0 1 0 1 01 1 1 0 0 1 01 1 1 1 1 0 0

A1 A0 B1 B0 IGUAL AM BM0 0 0 0 1 0 00 0 0 1 0 0 10 0 1 0 0 0 10 0 1 1 0 0 10 1 0 0 0 1 00 1 0 1 1 0 0 0 1 1 0 0 0 10 1 1 1 0 0 11 0 0 0 0 1 01 0 0 1 0 1 01 0 1 0 1 0 01 0 1 1 0 0 11 1 0 0 0 1 01 1 0 1 0 1 01 1 1 0 0 1 01 1 1 1 1 0 0

Tabla 10.2: Tabla de de verdad del comparador de dos bits

Para comprender mejor el funcionamiento del comparador, reordenaremos la tabla de verdad por los bits más significativos. Ya que el bit más significativo "manda" sobre el menos significativo, esto se aprecia mejor en la tabla de la figura 10.3.

A1 B1 A0 B0 IGUAL AM BM0 0 0 0 1 0 00 0 0 1 0 0 10 0 1 0 0 1 00 0 1 1 1 0 00 1 0 0 0 0 10 1 0 1 0 0 1 0 1 1 0 0 0 10 1 1 1 0 0 11 0 0 0 0 1 01 0 0 1 0 1 01 0 1 0 0 1 01 0 1 1 0 1 01 1 0 0 1 0 01 1 0 1 0 0 11 1 1 0 0 1 01 1 1 1 1 0 0

A1<B1

A1>B1

AM=0Igual=0

BM=1

MSB LSB

AM=1Igual=0

BM=0

A1=B1comprobar

el LSB

A1=B1comprobar

el LSB

A1 B1 A0 B0 IGUAL AM BM0 0 0 0 1 0 00 0 0 1 0 0 10 0 1 0 0 1 00 0 1 1 1 0 00 1 0 0 0 0 10 1 0 1 0 0 1 0 1 1 0 0 0 10 1 1 1 0 0 11 0 0 0 0 1 01 0 0 1 0 1 01 0 1 0 0 1 01 0 1 1 0 1 01 1 0 0 1 0 01 1 0 1 0 0 11 1 1 0 0 1 01 1 1 1 1 0 0

A1<B1

A1>B1

AM=0Igual=0

BM=1

MSB LSB

AM=1Igual=0

BM=0

A1=B1comprobar

el LSB

A1=B1comprobar

el LSB

Figura 10.3: Tabla de verdad del comparador de dos bits ordenada desde los bits más significativos a los menos

Fíjate en la tabla de verdad de la figura 10.3: • Cuando A1<B1 entonces A es menor que B: IGUAL=0 ; AM=0 ; BM = 1 • Cuando A1>B1 entonces A es mayor que B: IGUAL=0 ; AM=1 ; BM = 0



• Cuando A1=B1 entonces comprobamos el bit cero: • Si A0<B0 entonces A es menor que B: IGUAL=0 ; AM=0 ; BM = 1

• Si A0>B0 entonces A es mayor que B: IGUAL=0 ; AM=1 ; BM = 0

• Si A0=B0 entonces A es igual que B: IGUAL=1 ; AM=0 ; BM = 0 De estos puntos podemos extraer que:

• A es igual a B (IGUAL=1) cuando: • A1=B1 y A0=B0

• A es mayor que B (AM=1) cuando • A1>B1

• O cuando (A1=B1) y A0>B0 • A es menor que B (BM=1) cuando

• A1<B1 • O cuando (A1=B1) y A0<B0

Date cuenta que en estos puntos sólo estamos haciendo comparaciones bit a bit. Esto es, podemos hacer comparaciones individuales. Y podemos traducir estas sentencias a algebra de Boole y puertas lógicas. La figura 10.4 muestra la construcción del comparador de dos bits para las señales IGUAL y AM. Para no complicar el esquema, no se ha dibujado el diagrama de puertas para la señal BM, pero es similar al de la señal AM.

A0

B0

IGUAL_0AM_0

BM_0

COMPA1

A1

B1

IGUAL_1

AM_1

BM_1

COMPA1

IGUAL

Si (A1=B1) y (A0=B0)

IGUAL_1=1 IGUAL_0=1

Si (A1>B1) ó [(A1=B1) Y (A0>B0)]

AM_1=1 IGUAL_1=1 AM_0=1

IGUAL= IGUAL_1 · IGUAL_0

AM = AM_1 + (IGUAL_1 · AM_0)

AM

Iguales

A>B

A0

B0

IGUAL_0AM_0

BM_0

COMPA1

A1

B1

IGUAL_1

AM_1

BM_1

COMPA1

IGUAL

Si (A1=B1) y (A0=B0)

IGUAL_1=1 IGUAL_0=1

Si (A1>B1) ó [(A1=B1) Y (A0>B0)]

AM_1=1 IGUAL_1=1 AM_0=1

IGUAL= IGUAL_1 · IGUAL_0

AM = AM_1 + (IGUAL_1 · AM_0)

AM

Iguales

A>B

Figura 10.4: Comparador de dos bits hecho con comparadores de un bit (falta el A<B)

10.2.1. Diseño del comparador Ahora tienes que diseñar el comparador. Puedes crearlo en el mismo proyecto. Ya sabes los pasos, esquemáticamente son:

• Crear un símbolo para el comparador de un bit • Crear un nuevo esquemático de nombre compa2 (no lo llames comp2 porque ya existe

ese componente en la biblioteca de Xilinx y puede llevar a error) que contenga un diseño similar al de la figura 10.4, incluyendo el circuito de la señal de salida BM

• Al terminar el diseño, guardarlo y comprobar el circuito • Opcionalmente puedes simularlo • Y para implementarlo, asignarle los pines de entrada y salida, que serán los

mostrados en la tabla 10.3. • Sintetizar, Implementar y programar la FPGA

A0 SW0 A1 SW1 B0 SW2 B1 SW3

AM LD0 IGUAL LD1

BM LD2

Tabla 10.3: Asignación de señales

Una vez que lo hayas implementado en la FPGA, comprueba en la placa que el circuito funciona bien. Presta atención al comportamiento de las salidas en función de los cambios en las entradas. Fíjate cómo el bit más significativo "manda" sobre el menos significativo.

Departamento de Tecnología Electrónica 11. Comparadores en cascada


11. Comparadores en cascada El mecanismo para hacer un comparador de más bits es el mismo, por ejemplo, si a partir del comparador de dos bits quisiésemos realizar un comparador de 4 bits, los conectaríamos de manera similar a la figura 10.4 aunque en este caso los bloques comparadores que usamos serían de dos bits en vez de uno. El circuito final nos quedaría como el de la figura 11.1.

A0

B1

IGUAL_10

AM_10

BM_10

COMPA2

IGUAL_32

AM_32

BM_32

COMPA2

IGUAL

bits 1 y 0

AM

A1

B0

A2

B3

A3

B2

bits 3 y 2

BM

A0

B1

IGUAL_10

AM_10

BM_10

COMPA2

IGUAL_32

AM_32

BM_32

COMPA2

IGUAL

bits 1 y 0

AM

A1

B0

A2

B3

A3

B2

bits 3 y 2

BM

Figura 11.1: Comparador de 4 bits hecho con comparadores de dos bits

Por lo tanto, siguiendo este esquema podríamos construir cualquier comparador del número de entradas que quisiésemos. Sin embargo, la lógica de comparación que une los dos comparadores es un poco incómoda y sería más adecuado poder conectar los comparadores directamente, sin tener que añadir esas puertas. Lo que queremos se muestra en la figura 11.2.

COMP2_CASA0_MSB

B1_MSB

A1_MSB

B0_MSB

BM

IGUALAM

IGUAL_LSBAM_LSBBM_LSB

Comparaciones de los bits menos

significativos (LSB)

COMP2_CASA0_MSB

B1_MSB

A1_MSB

B0_MSB

BM

IGUALAM


COMP2_CASA0_MSB

B1_MSB

A1_MSB

B0_MSB

BM

IGUALAM


Comparaciones de los bits menos

significativos (LSB)

Figura 11.2: Comparador de dos bits que se puede poner en cascada

El bloque (COMP2_CAS) de la figura 11.2, además de los dos bits correspondientes que quiere comparar, recibe las entradas de la comparación de los bits menos significativos. Por tanto, los comparadores se pueden conectar directamente, como se muestra en la figura 11.3. Fíjate el valor de las entradas de comparación del comparador de los bits menos significativos: cuando no hay más bits que comparar, se ponen como si fuesen iguales (IGUAL_LSB='1').

IGUAL

COMP2_CAS

BM

IGUAL

AM

IGUAL_LSB

AM_LSBBM_LSB

A0_MSB

A1_MSB

B1_MSBB0_MSB

BM

IGUAL

AM

IGUAL_LSB

AM_LSBBM_LSB

A0_MSB

A1_MSB

B1_MSBB0_MSB

COMP2_CAS

AMBM

A2A3

B3B2

'1''0''0'

A0A1

B0B1

Comparador de los bits menos significativos

Comparador de los bits más

significativos

IGUAL

COMP2_CAS

BM

IGUAL

AM

IGUAL_LSB

AM_LSBBM_LSB

A0_MSB

A1_MSB

B1_MSBB0_MSB

BM

IGUAL

AM

IGUAL_LSB

AM_LSBBM_LSB

A0_MSB

A1_MSB

B1_MSBB0_MSB

COMP2_CAS

AMBM

A2A3

B3B2

'1''0''0'

A0A1

B0B1

IGUAL

COMP2_CAS

BM

IGUAL

AM

IGUAL_LSB

AM_LSBBM_LSB

A0_MSB

A1_MSB

B1_MSBB0_MSB

BM

IGUAL

AM

IGUAL_LSB

AM_LSBBM_LSB

A0_MSB

A1_MSB

B1_MSBB0_MSB

COMP2_CAS

AMBM

A2A3A2

A3

B3B2

'1''0''0'

A0A1

B0B1

Comparador de los bits menos significativos

Comparador de los bits más

significativos

Figura 11.3: Comparador de 4 bits conectando dos comparadores de dos bits en cascada



¿Cómo podríamos hacer un comparador para que se pueda conectar en cascada? Simplemente tenemos que quitar el comparador de los bits menos significativos de la figura 11.1 y hacer que lo que eran sus salidas sean ahora las entradas del bloque. Esto se muestra en la figura 11.4, compáralo con el de la figura 11.1.

IGUAL_LSB

COMPA2

IGUAL

Entradas de las comparaciones de los bits

menos significativos (LSB)

AM

AM_LSB

BM_LSB

A0_MSB

B1_MSB

A1_MSB

B0_MSB

BMBM

IGUAL

AM

Bits más significativos:

IGUAL_LSB

COMPA2

IGUAL

Entradas de las comparaciones de los bits

menos significativos (LSB)

AM

AM_LSB

BM_LSB

A0_MSB

B1_MSB

A1_MSB

B0_MSB

BMBM

IGUAL

AM

Bits más significativos:

Figura 11.4: Comparador de dos bits que se puede conectar en cascada

Para implementar el comparador de dos bits de la figura 11.2 y 11.4 crearemos un nuevo proyecto comp2_cas. A este proyecto vamos a añadirle el fichero de los comparadores ya hemos creado comp1.sch y comp2.sch Para ello ejecutamos "Proyect→Add Copy of Source" y nos movemos por las carpetas en busca de los ficheros (C:/practicas/EDI/tunombre/compa/.) . Cuando los encontremos le damos a Abrir. Ahora crea un nuevo símbolo para compa2. Haz que las señales A0 y A1 estén juntas en la figura del símbolo. Puede ser que en la configuración de tu navegador de Windows no lo tengas configurado de manera que se puedan ver las extensiones de los ficheros, y por tanto te sea difícil encontrarlo. Si esto te ocurre, abre un explorador de archivos de Windows, ejecuta "Herramientas→Opciones de Carpeta ..." y dentro de la ventana que te sale selecciona la pestaña Ver. En ella, casi al final, quítale la marca a "Ocultar las extensiones de archivo para tipos de archivo conocido". Y luego pincha en aceptar. Y ya empezaremos a crear el comparador de dos bits conectable en cascada. Para ello creamos una nueva fuente llamada comp2_cas.sch. En el editor de esquemáticos le añadimos el símbolo del comparador de dos bits, y realizamos el circuito de la figura 11.4. Cuando terminemos, grabamos, y comprobamos el esquemático (Tools→Check Syntax) y haz que compruebe jerárquicamente (Tools→Check Syntax). Creamos el símbolo de este esquemático. Ordena los puertos como están en la figura 11.2. Y ahora crea un nueva fuente llamada comp4_cas.sch, que implementará el comparador de 4 bits mostrado en la figura 11.3. Sin embargo, para este circuito vamos a aprender a usar buses. Un bus es un cable que representa un conjunto de cables, y con esto hacemos el esquema del diseño más claro. Lo primero que haremos es incluir en nuestro diseño dos referencias al comparador de dos bits en cascada que acabamos de realizar. Encima y debajo de él ponemos dos cables. Al cable de arriba lo llamaremos A(3:0) y el de abajo B(3:0). Recuerda que para nombrar un cable ejecutábamos "Add→Net Name" y teníamos que poner el nombre en la ventaja de opciones. Fíjate que después de poner el nombre el cable se muestra más grueso. La figura 11.5 muestra esta primera parte del diseño.

Figura 11.5: Inicio del diseño con comparadores en cascada y buses



Ahora queremos conectar cada una de las líneas de los buses a las entradas del comparador. Para ello empezamos añadiendo un conector al bus con el comando Add→Bus Tap. Al seleccionar éste comando, en la ventana de opciones podemos elegir la orientación del terminal triangular. Éste tiene que ir en el lado del bus, así que para el bus A tendrías que seleccionar Top, mientras que para el bus B seleccionarías Bottom. El diseño debería quedar como muestra la figura 11.6.

Figura 11.6: Buses con los conectores

Ahora vamos a unir cada conector del bus con las entradas de los comparadores. Ya sabemos cómo se hace esto (con el comando Add→Wire). Y a continuación nombraremos cada cable para así identificar a qué bit del bus se refiere. Los bits individuales del bus se nombran con el nombre del bus y entre paréntesis el índice. En nuestro caso, para A(3:0) serán A(3), A(2), A(1) y A(0). Usamos el comando Add→Net Name. Para poner el nombre más cómodamente podemos empezar por el A(0), y seleccionar la opción Increase the name. Con esto, automáticamente después de nombrar a A(0)¸ el nombre que se pondría sería A(1), evitándonos tener que cambiarlo manualmente. La figura 11.7 muestra dónde se seleccionan estas opciones y el esquemático resultante. Debes fijarte bien en qué elementos del bus conectas con las entradas de los comparadores y asegurarte de que entiendes lo que estas haciendo.

Increase the nameIncrease the name

NombreNombre

Increase the nameIncrease the name

NombreNombre

Figura 11.7:Nombre de los cables de los buses



Ahora conectamos los buses a los puertos de entrada de nuestro diseño. Esto se hace igual que hemos hecho hasta ahora. Como lo conectamos al bus, que ya tiene nombre, el puerto de entrada adquiere el mismo nombre que el bus. Por último, realizamos las interconexiones entre los comparadores, les conectamos los puertos de salida, y los valores de las entradas, igual que se muestra en la figura 11.3 y en la 11.8.

Figura 11.8:Diseño final del comparador de 4 bits

Guardamos el diseño, comprobamos el esquemático (Tools→Check Schematic) y la jerarquía (Tools→Hierarchical Check). Si lo deseas, puedes simular el circuito o bien implementarlo directamente. Asignamos los pines con la herramienta PACE: en la ventana de procesos: "User Constraints→Assign Package Pines". Los 4 interruptores de la derecha serán para el bus A (SW3, SW2, SW1, SW0), los cuatro interruptores de la izquierda para B. Y usaremos los mismo LED que en el comparador anterior.

A(0) SW0 B(0) SW4 IGUAL LD1 A(1) SW1 B(1) SW5 AM LD0 A(2) SW2 B(2) SW6 BM LD2 A(3) SW3 B(3) SW7

Tabla 11.1: Conexiones de los puertos con los pines de la FPGA

En caso de que prefieras editar el fichero .UCF a mano, los buses se escriben así: NET "A<0>" LOC = "P89" ; NET "A<1>" LOC = "P88" ;

Código 11.1: Ejemplo de conexión de pines con elementos de un bus

Y ahora ya implementa el circuito en la FPGA, los pasos supongo que ya los sabes. Comprueba que el circuito compara correctamente.

Departamento de Tecnología Electrónica 12. El multiplexor


12. El multiplexor El diseño que acabamos de realizar está bien pero ahora nos gustaría que el circuito no sólo indique con los LED qué número es mayor, sino que también nos muestre el número mayor por el display de siete segmentos. A partir de ahora se van a dar las especificaciones del sistema que queremos realizar, de modo que sean suficientes para diseñar el circuito. Posteriormente se darán algunas explicaciones de cómo se puede realizar. Intenta realizar el diseño sin mirar la solución o al menos pensarlo. Luego, si no te sale, o si lo quieres comprobar, consulta la solución. Habitualmente, la empresa de ingeniería o el ingeniero tiene que realizar el diseño de un sistema a partir de unas especificaciones que le da el cliente o su jefe. No siempre el cliente tiene las cosas claras o sabe explicar lo que quiere. Por tanto, la tarea de realizar las especificaciones dura varias sesiones en las que las dos partes se ponen de acuerdo en las prestaciones del diseño, el coste, el tiempo en que el producto va a estar disponible, ...

12.1. Especificaciones Comparador de dos números de 4 bits. El circuito debe comparar dos números de 4 bits (A y B) que estarán codificados por medio de los interruptores de la placa. El circuito indicará a través de tres LED el resultado de la comparación:

• Si A>B 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 A<B entonces LD2 se encenderá, en otro caso permanecerá apagado

Además, el circuito mostrará por un display de siete segmentos el número mayor. En caso de que sea A el número mayor, lo mostrará por el display de la derecha (AN0), en caso de que A sea menor lo mostrará por el display de la izquierda (AN3), y en caso de que sean iguales se mostrará por los dos displays anteriores (el de la izquierda y el de la derecha: AN0 y AN3). Los 4 interruptores de la derecha corresponderán con el número A, de modo que:

• A(0) será el interruptor SW0 • A(1) será el interruptor SW1 • A(2) será el interruptor SW2 • A(3) será el interruptor SW3

Los 4 interruptores de la izquierda corresponderán con el número B, de modo que: • B(0) será el interruptor SW4 • B(1) será el interruptor SW5 • B(2) será el interruptor SW6 • B(3) será el interruptor SW7

Con esta información se debe diseñar el circuito con bloques e implementarlo en la FPGA. Aunque muchos de los bloques ya estén hechos y no volvamos a repetir cómo se hacen, deberás saber cómo se realizan en puertas.

12.2. Diagrama de bloques del circuito Realmente el diseño no es mucho más complicado que el comparador de 4 bits anterior, únicamente debemos añadir la visualización del número mayor por el display de siete segmentos. La comparación de los números debe seleccionar qué número se mostrará en los displays. Los bloques que realizan un selección son los multiplexores. En este caso necesitamos seleccionar entre dos números: A y B, y por lo tanto necesitamos un multiplexor de 2 entradas (y una señal de selección). La señal que va a seleccionar será la que indica si A>B, 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.



1

0

MUX

A

B

S

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

A

B

AM

S1

0

MUX

A

B

S

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

A

B

AM

S

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.

AM

A(1:0)0

1

MUX2_2b

S(1:0)B(1:0)

2

22

equivalente

AM

A(1:0)

0

1

S(1:0)

B(1:0)

2

2

2

A(1)

A(0)

B(1)

B(0)

0

1

A(0)

B(1)

S(1)

S(0)B(0)

A(1)

AM

AM

AM

A(1:0)0

1

MUX2_2b

S(1:0)B(1:0)

2

22

AM

A(1:0)0

1

MUX2_2b

S(1:0)B(1:0)

22

2222

equivalenteequivalente

AM

A(1:0)

0

1

S(1:0)

B(1:0)

2

2

2

A(1)

A(0)

B(1)

B(0)

0

1

A(0)

B(1)

S(1)

S(0)B(0)

A(1)

AM

AM

AM

A(1:0)

0

1

S(1:0)

B(1:0)

22

22

22

A(1)

A(0)

B(1)

B(0)

0

1

A(0)

B(1)

S(1)

S(0)B(0)

A(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<B (BM='1') ó cuando A=B (IGUAL='1').Fíjate que hay una puerta NOR debido a que las señales AN funcionan con lógica negada.

I(3:0)SEG_ASEG_B

SEG_C

SEG_D

HEX7SEG

SEG_E

SEG_F

SEG_G

COMP4

BM

IGUALAMA(3:0)

B(3:0)

A(3:0)4

1

0

MUX

7

4

AN_0

AN_3

SEG(6:0)

I(3:0)

HEX7SEG

B(3:0)4

SEG(6:0)

7

7

A_7SEG

B_7SEG

I(3:0)SEG_ASEG_B

SEG_C

SEG_D

HEX7SEG

SEG_E

SEG_F

SEG_G

COMP4

BM

IGUALAMA(3:0)

B(3:0)

A(3:0)4

1

0

MUX

7

4

AN_0

AN_3

SEG(6:0)

I(3:0)

HEX7SEG

B(3:0)4

SEG(6:0)

7

7

A_7SEG

B_7SEG

Figura 12.3: Primera propuesta para el diseño



Otra alternativa para realizar el circuito es la mostrada en la figura 12.4. Fíjate que en ella no sólo hay un menor número de componentes (sólo hay un convertidor de hex a 7 segmentos) sino que además las entradas del multiplexor utilizado tienen 4 elementos en vez de siete, lo que hace que sea bastante menor. Así que esta alternativa es más sencilla y será la que implementemos. Seguramente haya otras alternativas y alguna de ellas se te ha podido ocurrir a ti.

COMP4

BM

IGUALAMA(3:0)

B(3:0)

A(3:0)4

B(3:0)

1

0

MUX

4

4

4

AN_0

AN_3

I(3:0)

HEX7SEG

SEG(6:0)

SEG_ASEG_B

SEG_C

SEG_DSEG_E

SEG_F

SEG_G

7

COMP4

BM

IGUALAMA(3:0)

B(3:0)

A(3:0)4

B(3:0)

1

0

MUX

4

4

4

AN_0

AN_3

I(3:0)

HEX7SEG

SEG(6:0)

SEG_ASEG_B

SEG_C

SEG_DSEG_E

SEG_F

SEG_G

7

Figura 12.4: Alternativa para el diseño

12.3. Diseño Del circuito de la figura 12.4 ya hemos realizado todos los bloques excepto el multiplexor. Creamos un nuevo proyecto llamado mux7seg. Ahora vamos a añadir el convertidor de 7 segmentos que hicimos en el ejercicio Y añadimos una copia de la fuente del circuito que hicimos en el ejercicio 7, el convertidor de hexadecimal a siete segmentos (el proyecto se llamaba hex7seg). Para ello tenemos copiamos y añadimos al proyecto el decodificador y el convertidor: (Proyect→Add Copy of Source...) y seleccionamos los ficheros decod4a16.sch y hex7seg.sch Vamos a realizar alguna modificación al convertidor para luego crear un módulo: seleccionamos todas las salidas AN que habíamos creado y las eliminamos. Pues ahora las vamos a gobernar desde fuera del convertidor. La señal SEG_DT la podemos dejar. Una vez que lo hayamos hecho, guardamos y comprobamos el esquemático (Tools→Check Schematic y también Tools→Hierachical Check). Si todo sale bien, ahora creamos un símbolo de este diseño: (Tools→Symbol Wizard) y seleccionamos el hex7seg. Ordenamos los puertos si no estuviesen ordenados. A continuación vamos a crear un multiplexor de 2 entradas de dato y una de selección, con 4 bits en cada entrada de dato. Creamos una nueva fuente llamada mux2_4bit. Podríamos crear el multiplexor con puertas como se muestra en la figura 12.1 (con la diferencia que ahora cada línea de datos tiene 4 bits) sin embargo para tardar menos vamos a usar los multiplexores de dos entradas de 1 bit que tiene el ISE: ventana de símbolos, selecciona la categoría Mux, y dentro de los símbolos selecciona el m2_1. El multiplexor diseñado debería quedar parecido a como lo muestra 12.5. Hemos llamado a las entradas D0 y D1, que se refieren al dato que se selecciona cuando SEL vale 0, y cuando SEL vale 1, respectivamente.



Figura 12.5: Multiplexor de 2 datos de 4 bits cada dato (una señal de selección)

Guarda el diseño, comprueba el esquemático y crea un símbolo de este multiplexor para poder usarlo en el diseño de más alto nivel: el que va a reunir a todos, como el de la figura 12.4. Creamos el diseño de más alto nivel de nuestro circuito, que será como el de la figura 12.4. Añadimos nueva fuente llamada mux7seg.sch. Necesitamos un comparador, o bien usamos el comparador que hemos creado en la práctica 11 (ya sabes cómo se importa) o bien podemos usar el comparador de la biblioteca de Xilinx. Si coges el de Xilinx, dentro de la ventana de opciones, en la categoría Comparator, escoge el compm4. Este comparador es de 4 bits, y tiene como salidas GT (A mayor) y LT (A menor). Nos falta el igual, pero lo podemos obtener fácilmente, ya que ¿cuándo A y B serán iguales? pues cuando ni A sea mayor que B¸ ni A sea menor que B. Y esto que acabamos de decir en álgebra de Boole se traduce como: IGUAL = GT ⎯⎯⎯ · LT ⎯⎯⎯ . Otra manera de decirlo es que A y B son iguales cuando no ocurre que A sea mayor que B, o que A sea menor que B: IGUAL = GT+LT⎯⎯⎯⎯⎯⎯⎯⎯⎯ . Fíjate que las dos expresiones son equivalentes por el teorema de De Morgan. Aún así, si te lías, puedes hacer la tabla de verdad. El diseño final del circuito podría quedarte como lo muestra la figura 12.6. Fíjate que entre otros, también se han añadido los puertos que van a los LED (AM, BM, IGUAL) Asegúrate que entiendes todo.



Figura 12.6: Diseño final del circuito

Una vez que lo termines, guarda el diseño, comprueba el esquemático, y asigna los pines. La especificación de los pines la tenías en el apartado 12.1. Seguramente no salga el PACE y la tengas que hacer editando el UCF. Intenta hacerlo sin mirar, aún así, a continuación se incluye el fichero UCF para los puertos de la figura.

# ----------- Datos: A y B -------------------- NET "A<0>" LOC = "P89" ; NET "A<1>" LOC = "P88" ; NET "A<2>" LOC = "P87" ; NET "A<3>" LOC = "P86" ; NET "B<0>" LOC = "P84" ; NET "B<1>" LOC = "P83" ; NET "B<2>" LOC = "P82" ; NET "B<3>" LOC = "P81" ; # ---------------- LEDS ----------------------- NET "AM" LOC = "P46" ; NET "BM" LOC = "P44" ; NET "IGUAL" LOC = "P45" ; # ----------- Encendido de los displays ------- NET "AN_0" LOC = "P60" ; NET "AN_1" LOC = "P69" ; NET "AN_2" LOC = "P71" ; NET "AN_3" LOC = "P75" ; # ----------- 7 segmentos --------------------- NET "SEG_A" LOC = "P74" ; NET "SEG_B" LOC = "P70" ; NET "SEG_C" LOC = "P67" ; NET "SEG_D" LOC = "P62" ; NET "SEG_E" LOC = "P61" ; NET "SEG_F" LOC = "P73" ; NET "SEG_G" LOC = "P68" ; # ----------- Punto decimal ------------------- NET "SEG_DT" LOC = "P63" ;

Código 2: Contenido del fichero UCF

Finalmente implementa el diseño en la FPGA y comprueba que todo funciona como se ha especificado. Si es así, enhorabuena, este ha sido un diseño de cierta complejidad.

Departamento de Tecnología Electrónica 13. El sumador


13. El sumador En clase se ha explicado el sumador, y en este ejercicio simplemente aplicaremos la teoría para realizarlo. Así que las especificaciones van a ser muy sencillas. Después de leer las especificaciones puedes intentar hacerlo tú sólo o ir al apartado siguiente donde se explica el diseño del sumador.

13.1. Especificaciones Sumador de dos números de 4 bits. El circuito debe sumar dos números sin signo de 4 bits (A y B) que estarán codificados por medio de los interruptores de la placa. El circuito mostrará en el display de la derecha el resultado de la suma y en caso de que haya desbordamiento encenderá el LED de la izquierda (LD7), además encenderá el punto decimal del display cuando haya desbordamiento. La correspondencia de los interruptores con los números A y B es la misma que la del ejercicio 12 (apartado 12.1). Esto es, los cuatro de la derecha se corresponden con la señal A y los cuatro de la izquierda con B. Además el sumador recibirá el acarreo de entrada por medio del pulsador de la derecha (BTN0). Opcionalmente también se podrá sacar el resultado codificado en binario por los cuatro LED de la derecha (de LD0 a LD3).

13.2. Diseño Empezaremos realizando el diseño de un sumador de 1 bit, para luego ir juntando estos sumadores de un bit. Realizando lo que se llama un sumador en paralelo con acarreo en serie (también llamado en cascada). Si queremos sumar dos números de un bit, podemos realizar un semisumador (HA: half adder), con el que obtenemos el resultado de la suma (S) y el acarreo (C). En la figura 13.1 se muestra la tabla de verdad de la suma y el acarreo, y el circuito que lo implementa. La obtención de este circuito a partir de la tabla de verdad ya te debería ser fácil si has estudiado el tema 3: Álgebra de Boole y funciones lógicas.

A B S C0 0 0 00 1 1 01 0 1 01 1 0 1

A

B

S

C

HA

A B S C0 0 0 00 1 1 01 0 1 01 1 0 1

A B S C0 0 0 00 1 1 01 0 1 01 1 0 1

A

B

S

C

HA

A

B

S

C

HA

Figura 13.1: Tabla de verdad y circuito que implementa el semisumador

Crearemos un proyecto llamado sumador. En el proyecto creamos una fuente llamada ha.sch y en ella realizamos el circuito de la figura 13.1. Lo guardamos, lo comprobamos (Tools →Check Schematic) y creamos un símbolo (Tools →Symbol Wizard). Acabamos de realizar un semi-sumador, y se llama así porque no hemos incluido el acarreo de entrada. Al incluir este formamos un sumador completo (full-adder: FA). En el sumador completo tenemos la señal CI que se corresponde con el acarreo de entrada, y el acarreo de salida se llama ahora CO. La figura 13.2 muestra la tabla de verdad del sumador completo y cómo se forma éste con semisumadores. También se podía haber realizado resolviendo las ecuaciones lógicas de S y CO mediante mapas de Karnaugh.

A B CI S CO0 0 0 0 00 0 1 1 00 1 0 1 00 1 1 0 11 0 0 1 01 0 1 0 11 1 0 0 11 1 1 1 1

A

B

HA

S

CO

CI

HAA B CI S CO0 0 0 0 00 0 1 1 00 1 0 1 00 1 1 0 11 0 0 1 01 0 1 0 11 1 0 0 11 1 1 1 1

A

B

HA

S

CO

CI

HA

A

B

HA

S

CO

CI

HA

Figura 13.2: Sumador completo a partir de semisumadores

Creamos una nueva fuente llamada fa.sch para realizar el sumador completo. Puedes realizarlo igual que la 13.2, usando los semisumadores que ya hemos realizado, o puedes hacerlo por Karnaugh, como tú prefieras. Cuando hayas terminado, lo grabas, compruebas el esquemático (Tools→Check Schematic) y creas un símbolo para el sumador completo. Si tienes alguna duda o quieres comprobar el diseño puedes simularlo o implementarlo en la placa (ya sabes cómo se hace). Si no continuamos realizando el sumador de 4 bits.



Una vez que tenemos un sumador completo de 1 bit, la realización de un sumador de 4 bits es bastante fácil. Simplemente tenemos que conectar los acarreos consecutivamente del bit menos significativo al más significativo. Y conectar las entradas de A y B en paralelo, en sus sumadores correspondientes. El diseño se muestra en la figura 13.3.

A B

CICO

S

A B

CICO

S

A B

CICO

S

A B

CICO

S

A3 B3 A2 B2 A1 B1 A0 B0

S3 S2 S1 S0

COC0C1C2 CI

bits menos significativos

(LSB)

bits más significativos

(MSB)

Acarreo de salida (o desbordamiento) Acarreo de

entrada a cero

A B

CICO

S

A B

CICO

S

A B

CICO

S

A B

CICO

S

A3 B3 A2 B2 A1 B1 A0 B0

S3 S2 S1 S0

COC0C1C2 CI

A B

CICO

S

A B

CICO

S

A B

CICO

S

A B

CICO

S

A3 B3 A2 B2 A1 B1 A0 B0

S3 S2 S1 S0

COC0C1C2 CI

bits menos significativos

(LSB)

bits más significativos

(MSB)

Acarreo de salida (o desbordamiento) Acarreo de

entrada a cero

Figura 13.3: Sumador de 4 bits a partir de sumadores completos

Para diseñar el sumador de 4 bits creamos una nueva fuente llamada sum4bits.sch. En ella incluimos los bloques FA que acabamos de realizar. Los podemos colocar verticalmente, como muestra la figura 13.4 ó bien rotarlos y voltearlos (rotate & mirror). Al contrario que como sale en la figura 13.3, el acarreo de entrada CI, lo vamos a poner como puerto de entrada (figura 13.4), para así poder conectar varios módulos en cascada, o en nuestro caso introducirlo cuando apretemos el pulsador BTN0.

Figura 13.4: Esquemático del sumador de 4 bits

Guardamos el esquemático y lo comprobamos (Tools→Check Schematic y Tools→Hierarchical Check). Y creamos un símbolo del diseño (Tools→Symbol Wizard) de manera que el orden de los puertos quede como muestra la figura 13.5.

A(3:0)

B(3:0)SUM4BITS

S(3:0)

CO

CI

4

4

4

A(3:0)

B(3:0)SUM4BITS

S(3:0)

CO

CI

4

4

4

Figura 13.5: Bloque del sumador de 4 bits

Ya tenemos el sumador hecho, aunque todavía nos queda la parte de visualización del resultado. Antes de realizar la parte de la visualización, puedes simular el circuito para comprobar que está bien, o incluso implementarlo, haciendo que los cuatro LED de la derecha se correspondan con la salida del sumador (te recomiendo que lo hagas). Ahora vamos a implementar el circuito completo, incluyendo la parte de visualización. Para esto tenemos que añadir al proyecto el convertidor a siete segmentos que hemos realizado en ejercicio 7 y que luego



modificamos en el ejercicio 12. Los pasos para importarlo estaban descritos en el apartado 12.3, pero los recordamos:

• Añadir una copia de algunas las fuentes de los circuitos que hicimos en el ejercicio12 (el proyecto se llamaba mux7seg). Estos son el decodificador de 4 a 16: decod4a16.sch y el bloque que lo contenía, el convertidor a 7 segmentos: hex7seg.sch. Para ello ejecutamos el comando Proyect→Add Copy of Source... y seleccionamos los ficheros decod4a16.sch y hex7seg.sch

• El convertidor vamos a modificarlo un poco, vamos a eliminar el puerto SEG_DT¸ en ese diseño la teníamos siempre a uno, ahora la quitamos completamente. Guardamos el diseño, y comprobamos el esquemático (Tools→Check Schematic y también Tools→Hierachical Check).

• Por último creamos un símbolo del convertidor (Tools→Symbol Wizard) y seleccionamos el hex7seg. Asegúrate que los puertos estén ordenados.

Ahora creamos una nueva fuente llamada top_sumador.sch que va a contener el sumador y el convertidor de hexadecimal a 7 segmentos. La hemos nombrado con el prefijo top para indicar que es el diseño que contiene al resto de componentes del circuito. Ya deberías poder terminar el diseño tú solo, aún así, a continuación se muestra una implementación posible (figura 13.6). Si no has sabido hacerla por ti mismo intenta entender todo el circuito propuesto.

Figura 13.6: Esquemático del sumador de 4 bits con el convertidor a 7 segmentos

Cuando termines de diseñarlo haz lo de siempre: grabar, comprobar, asignar los pines con PACE o editando el UCF (puedes copiar y modificar los UCF que has creado en diseños anteriores), y por último, sintetizar e implementar en la FPGA. En caso de que hayas implementado la versión anterior (la que no mostraba nada por el display), ten cuidado de no programar la FPGA con el fichero sum4bits.bit, sino que la deberás programar con el nuevo fichero: top_sumador.bit. Al terminar comprueba que funciona bien, fíjate en los LED y en lo que muestra el display y verifica que se trata del mismo número. Comprueba también que la suma está bien, y si funciona el acarreo de entrada: el pulsador de la derecha (BTN0). Y también el acarreo de salida (desbordamiento) que se debería mostrar con el LED de la izquierda y con el punto decimal. Aprovecha también para repasar los conceptos teóricos del tema 2 (Sistemas de numeración y codificación): números en binario y cómo se realiza la suma. Si has logrado realizar este circuito por ti mismo te estás convirtiendo en un buen diseñador de circuitos digitales.

Departamento de Tecnología Electrónica 14. Sumador/restador


14. Sumador/restador Queremos hacer un circuito que reste, para ello podríamos hacer un circuito restador de un bit a partir de la tabla de verdad de la resta. Esto se haría de manera similar a como se hace el semi-sumador y el sumador completo (ver figuras 13.1 y 13.2). Y aunque esto es un buen ejercicio que conviene que sepas hacer, en esta práctica vamos a aprovechar los conocimientos de representación numérica que vimos en el tema 2. En aquel tema vimos que usando el complemento a 2 (Ca2) podíamos realizar una resta sumando. Así que nos ahorramos realizar un nuevo bloque restador y lo que haremos será calcular el complemento a dos del sustraendo y sumarlo al minuendo.

14.1. Especificaciones Sumador/restador de dos números de 4 bits. El circuito debe sumar o restar dos números codificados en complemento a 2 con 4 bits (OPA y OPB) y cuyos valores estarán determinados por la posición de los interruptores de la placa. El circuito mostrará en el display de la derecha el resultado de la suma o la resta. Los operandos vendrán dados por los interruptores. El minuendo (o uno de los sumandos: OPA) se codificará mediante los 4 interruptores de la derecha (de SW0 a SW3), y el sustraendo (o el otro sumando: OPB) con los cuatro interruptores de la izquierda (de SW4 a SW7). Recuerda que los números vienen codificados en complemento a 2. EL pulsador BTN0 indicará qué operación se realiza. Cuando esté pulsador se hará la resta, mientras que cuando no esté pulsado se efectuará la suma. El resultado de la operación (suma o resta) se mostrará por el primer display de 7 segmentos. El resultado se deberá mostrar en el display en signo magnitud (para que lo podamos entender los humanos). Para mostrar el signo negativo se utilizará el punto decimal, es decir, si el punto decimal está luciendo significa que el resultado es el número mostrado pero negativo. En caso de que haya desbordamiento (overflow) el display mostrará la letra E. Además los cuatro LED de la derecha (de LD0 a LD3) mostrarán el resultado directo (en complemento a 2). El resultado se dará por el display de siete segmentos de la derecha. Se usará LD7 para el acarreo de salida y LD6 para el desbordamiento en la resta. El pulsador BTN0 se usará para indicar que se realiza la suma o la resta. Cuando BTN0 esté pulsado se mostrará la suma, cuando no esté pulsado se mostrará la resta.

14.2. Diagrama de bloques Primero vamos a realizar el bloque sumador/restador y posteriormente estudiaremos cómo implementamos la parte de la visualización por el display. Esto es común en el diseño de circuitos digitales, cuando un problema es grande es conveniente dividirlo y abordar cada una de sus partes de manera separada. Posteriormente se une cada uno de los bloques. Incluso, para diseños muy grandes, cada parte la realizan personas o grupos diferentes y luego otros se encargan de unirlo todo y de comprobar que funciona bien. Así que lo primero que hacemos es un esquema preliminar que seguramente no sea definitivo y que al ir realizando cada bloque puede que necesitemos realizar alguna modificación. El esquema mostrado en la figura 14.1 puede ser un ejemplo de esto. En él hay un bloque que se encarga de realizar las operaciones de suma o resta, y otro bloque de mostrar el resultado de la operación en el display de siete segmentos.

OPB(3:0)

+ , -

SUMADOR/RESTADORRES_SUM

OPA(3:0)4 4

4

RESUL(3:0)

VISUALIZACION

8 A

G

D

B

C

F

E

COV

LEDS

Indica si se suma o se resta

acarreo desbordamiento

SUMA: RES_SUM='1'RESTA: RES_SUM='0'

OPB(3:0)

+ , -

SUMADOR/RESTADORRES_SUM

OPA(3:0)4 4

4

RESUL(3:0)

VISUALIZACION

8 A

G

D

B

C

F

E

A

G

D

B

C

F

E

COV

LEDS

Indica si se suma o se resta

acarreo desbordamiento

SUMA: RES_SUM='1'RESTA: RES_SUM='0'

Figura 14.1: Esquema inicial del sumador restador con visualización



En los siguientes subapartados iremos refinando el diseño.

14.2.1. Bloque sumador/restador Conceptualmente, lo que tenemos que hacer es seleccionar la entrada del sustraendo o segundo sumando (OPB), de modo que cuando tengamos que restar, la entrada B del sumador tenga el complemento a 2 de OPB; mientras que cuando tengamos que sumar, entre directamente el número OPB. Esto se muestra en la figura 14.2, en donde tenemos el módulo CA2 que transforma la señal OPB en su complemento a dos. Y tenemos un multiplexor que selecciona la señal B complementada o no, según si hay que restar o sumar: si RES_SUM=0 se resta, si RES_SUM=1 es suma.

OPA(3:0)

SUM4BITS

S(3:0)

CO

CI

4

4

4

0

1

RES_SUM

A(3:0)

B(3:0)

S(3:0)

OPB(3:0) 4

4CA2

Ca2(B)

OPA(3:0)

SUM4BITS

S(3:0)

CO

CI

4

4

4

0

1

RES_SUM

A(3:0)

B(3:0)

S(3:0)

OPB(3:0) 4

4CA2

Ca2(B)

Figura 14.2: Esquema inicial del módulo sumador/restador (sin visualización)

Se podría realizar el diseño así, sin embargo los diseñadores digitales han tendido siempre a minimizar el número de bloques y puertas del diseño. En este caso se puede hacer una versión más compacta. Esto ocurría sobre todo hace unos años, cuando tenían que hacer el diseño en componentes discretos o con dispositivos programables con poco espacio. Ahora esto no es tan crítico, aún así, a continuación veremos cómo hacer el circuito más compacto. El complemento a dos de un número se realiza complementando cada bit y añadiéndole 1 al resultado. Y podríamos realizarlo como se muestra en la figura 14.3, utilizando el sumador de cuatro bits para añadir 1.

SUM4BITS

S(3:0)

CO

CI

44A(3:0)

B(3:0)

S(3:0)

OPB(3:0)

VCC

4

complementar cada bit

Acarreo de entrada = '1' :sumamos 1

Ca2(B)El resultado es el

complemento a 2 de BEl otro sumando

vale '0'

también se podía poner el acarreo de entrada a cero y poner un uno en A(0)

SUM4BITS

S(3:0)

CO

CI

44A(3:0)

B(3:0)

S(3:0)

OPB(3:0)

VCC

4

complementar cada bit

Acarreo de entrada = '1' :sumamos 1

Ca2(B)El resultado es el

complemento a 2 de BEl otro sumando

vale '0'

también se podía poner el acarreo de entrada a cero y poner un uno en A(0)

Figura 14.3: Circuito que calcula el complemento a 2 de un número de cuatro bits

Pero si nos fijamos en las figuras 14.2 y 14.3, vemos que ambas utilizan un sumador de 4 bits, y que, por un lado la figura 14.2 no utiliza el acarreo de entrada CI (está a tierra), mientras que la figura 14.3 no utiliza la entrada A. Así que podemos utilizar el mismo sumador para las dos operaciones. Cuando queramos hacer la resta, por la entrada B del sumador entrará el complemento de cada bit de OPB, y pondremos el acarreo de entrada a 1 (CI='1'). Cuando queramos hacer la suma, por B entrará directamente la señal OPB, y pondremos el acarreo de entrada a 0 (CI='0'). Entonces el circuito quedaría como muestra la figura 14.4.



OPA(3:0)

SUM4BITS

S(3:0)

CO

CI

4

4

4

0

1

RES_SUM

A(3:0)

B(3:0)

S(3:0)

OPB(3:0) 4

4

SUMA: RES_SUM='1' → CI='0'RESTA: RES_SUM='0' → CI='1'

OPA(3:0)

SUM4BITS

S(3:0)

CO

CI

4

4

4

0

1

RES_SUM

A(3:0)

B(3:0)

S(3:0)

OPB(3:0) 4

4


Figura 14.4: Otra versión del circuito sumador/restador (sin visualización)

Pero esto todavía no es el circuito final, ya que los inversores y el multiplexor aún se pueden sustituir por algo más pequeño. Con el multiplexor estamos eligiendo la señal OPB complementada o no según el valor de RES_SUM. Esto es equivalente a utilizar una XNOR, ya que según el valor de una entrada deja pasar la otra tal cual o complementada (ver figura 14.5).

0

1

Sel

B

S

Sel B S0 0 10 1 01 0 01 1 1

Sel=0 → S=B

Sel=1 → S=B

BS

Sel

equivalente a XNOR

0

1

Sel

B

S

Sel B S0 0 10 1 01 0 01 1 1

Sel=0 → S=B

Sel=1 → S=B

BS

SelB

SSel

equivalente a XNOR

Figura 14.5: Equivalencia entre el circuito con multiplexor y el circuito con puerta XNOR

Quizá te sorprenda que se utilice una XNOR y no una XOR, ya que eso es lo que vimos en teoría. Esto se debe a que la señal de sumar/restar (RES_SUM) está complementada. En este ejercicio se suma cuando RES_SUM=1, mientras que en la teoría se suma cuando vale cero. Es por esto que sale una XNOR, ya que la XNOR es equivalente a una XOR con una de las entradas negadas. Esta entrada negada es la señal RES_SUM. En la figura 14.6 se muestra esta equivalencia.

BS

SelB

SSel

equivalente equivalenteB

SSel

BS

SelB

SSel

BS

SelB

SSel

BS

Sel

equivalente equivalenteB

SSel

BS

Sel Figura 14.6: Equivalencia entre puertas XNOR y XOR

Así que cambiamos los multiplexores e inversores por las puertas XOR, y nos queda el circuito de la figura 14.7.

OPA(3:0)

SUM4BITS

S(3:0)

CO

CI

4

4

A(3:0)

B(3:0)

S(3:0)

4


OPB(3)

OPB(2)

OPB(1)

OPB(0)

RES_SUM

OPA(3:0)

SUM4BITS

S(3:0)

CO

CI

4

4

A(3:0)

B(3:0)

S(3:0)

4


OPB(3)

OPB(2)

OPB(1)

OPB(0)

RES_SUM

Figura 14.7: Penúltima versión del circuito sumador/restador (sin visualización)

Bueno, quizás podamos pensar que la figura 14.7 corresponde el diseño definitivo, pero no es así, ya que tenemos que ocuparnos del acarreo de salida y el desbordamiento. El acarreo de salida se deja como está, para así poder conectar varios sumadores/restadores en cascada. Pero el desbordamiento hay que analizarlo. Como estamos trabajando en complemento a dos, el desbordamiento funciona de manera diferente. ¿Cuándo se desbordaba la suma en complemento a dos?



cuando los sumandos tienen el mismo signo y el resultado tenga el signo contrario. Si no te acuerdas de esto repasa los ejercicios propuestos del tema 2. De todos modos en la figura 14.8 se muestra un ejemplo para refrescarte la memoria.

0011+01011000

3+58

al estar en Ca2representa a

-8

Cambio de signo→desbordamiento

No es representable en Ca2 de 4 bits

distintos

0011–0101 → 0011+Ca2(0101)Ca2(0101)=1011

0011+10111110

310-510-210

-210

Es representableen Ca2 de 4 bits

iguales

signos diferentes: no hay desbordamiento

0011+0101

suma restaéste es OPB y por ser suma coincide con B

éste es B

éste es OPB

0011+01011000

3+58


-8



distintos

0011+01011000

3+58


-8



distintos

0011–0101 → 0011+Ca2(0101)Ca2(0101)=1011

0011+10111110

310-510-210

-210


iguales


0011+10111110

310-510-210

-210


iguales


0011+0101

suma restaéste es OPB y por ser suma coincide con B

éste es B

éste es OPB

Figura 14.8: Desbordamiento en sumas en complemento a dos

Así que lo que tenemos que hacer es comprobar el cambio de signo entre los operandos y el resultado, siempre que los operandos tengan el mismo signo. Para ello podríamos hacer la tabla de verdad y calcular la función lógica del desbordamiento (overflow). Eso ya sabes como se hace (figura 14.9).

B(3)

A3 B3 S3 OV0 0 0 00 0 1 10 1 0 00 1 1 01 0 0 01 0 1 01 1 0 11 1 1 0

A(3)

S(3)OV

B(3)

A3 B3 S3 OV0 0 0 00 0 1 10 1 0 00 1 1 01 0 0 01 0 1 01 1 0 11 1 1 0

A(3)

S(3)OV

Figura 14.9: Tabla de verdad y circuito que calcula el desbordamiento en complemento a 2

Por último, decir que el desbordamiento todavía se puede calcular de manera más simplificada, haciendo la XOR del acarreo de salida, con el penúltimo acarreo. Esto se muestra en la figura 14.10, en la que se ha dibujado el sumador/restador con los bloques sumadores de un bit.

A B

CICO

S

A B

CICO

S

A B

CICO

S

A B

CICO

S

A3

B3

A2

B2

A1 A0

S3 S2 S1 S0

COC0C1C2 RES_SUM

Desbordamiento

B1 B0

DE

A B

CICO

S

A B

CICO

S

A B

CICO

S

A B

CICO

S

A3

B3

A2

B2

A1 A0

S3 S2 S1 S0

COC0C1C2 RES_SUM

Desbordamiento

B1 B0

DE

Figura 14.10: Otra alternativa para calcular el desbordamiento en complemento a 2

14.2.2. Bloque de visualización El bloque de visualización recibe un número en complemento a 2 de cuatro bits, una señal de desbordamiento (OV), y debe mostrar en un display de 7 segmentos el número resultante en signo y magnitud. En caso de que el número fuese negativo, mostrará el correspondiente número positivo y el signo menos se indicará encendiendo el punto decimal del display. Cuando haya desbordamiento se mostrará la letra E. Lo primero que podemos hacer es analizar el rango de datos que vamos a mostrar. Como son números en complemento a dos de 4 bits, el menor número será -8 y el mayor 7. Así que para estos números nuestro convertidos de 7 segmentos funciona, además podemos mostrar la letra E, sin que se preste a confusión, ya que el número 14 en hexadecimal (E: 11102) nunca se mostrará (por ser el rango menor). Tenemos tres casos:

• Siempre que OV='1' entonces mostraremos la letra E • Si OV='0' y S(3)='0', significará que tenemos un número positivo, por lo tanto lo mostramos tal cual



• Si OV='0' y S(3)='1', significará que tenemos un número negativo, y por lo tanto tendremos que calcular su complemento a 2 y encender el punto decimal.

Cuando tenemos condiciones de tipo "Si.... entonces", éstas se pueden implementar fácilmente con un multiplexor. En la figura 14.11 se muestra esta "traducción".

7

A

G

D

B

C

F

E

1 0OV

I(3:0)

HEX7SEG

SEG(6:0)

4

1110El número 14 muestra la E

Ca2

1 0S(3)

4

S(3:0)

SEG_DTS(3)

7

A

G

D

B

C

F

E

A

G

D

B

C

F

E

1 0OV

I(3:0)

HEX7SEG

SEG(6:0)

4

1110El número 14 muestra la E

Ca2

1 0S(3)

4

S(3:0)

SEG_DTS(3) SEG_DTS(3) Figura 14.11: Diagrama de bloques del módulo de visualización

En esta figura ya tenemos hechos los multiplexores y el convertidor a 7 segmentos (HEX7SEG). Nos faltaría por hacer el módulo que se encarga de calcular el complemento a dos de la señal S(3:0), éste ya lo vimos en la figura 14.3. Antes de comenzar a diseñar, acuérdate que la representación en complemento a 2 no era simétrica, y por tanto, había un número negativo más que positivo. En nuestro ejemplo, para cuatro bits, existe el -8 pero no el +8. Por tanto, si se calcula el complemento a 2 de -8 (S=1000) resulta el mismo número (1000). ¿Qué sucedería en este caso? ¿Qué pasa si queremos representar el número -8? Si pones los valores en el circuito para este caso (ver figura 14.12), obtenemos el -8 en el display a pesar de que el complemento a dos no se puede calcular. Pero como la representación sale bien, lo realizaremos así.

7

A

G

D

B

C

F

E

1 0OV

I(3:0)

HEX7SEG

SEG(6:0)

4

1110

Ca2

1 0S(3)

4

S(3:0)

SEG_DTS(3)

1

1000

1000 1000

1000

0

0

1000

Se muestra un 8

1 encenderá el punto:signo −

7

A

G

D

B

C

F

E

A

G

D

B

C

F

E

1 0OV

I(3:0)

HEX7SEG

SEG(6:0)

4

1110

Ca2

1 0S(3)

4

S(3:0)

SEG_DTS(3) SEG_DTS(3)

1

1000

1000 1000

1000

0

0

1000

Se muestra un 8Se muestra un 8

1 encenderá el punto:signo −

Figura 14.12: Diagrama de bloques y valores para cuando el resultado sea -8



14.3. Diseño Creamos un nuevo proyecto llamado addsub. Añadimos una copia de las siguientes fuentes del ejercicio 13 (el sumador)

• decod4_16.sch • hex7seg.sch • ha.sch • fa.sch • sum4bits.sch

Y del ejercicio del multiplexor (ejercicio 12), añadimos una copia de: • mux2_4bit.sch

Crea un símbolo para el sumador, convertidor de siete segmentos y el multiplexor de dos entradas con 4 bits. Primero vamos a crear el bloque sumador/restador (recuerda la figura 14.1 y el apartado 14.2.1). Para ello, vamos a crear un nuevo fichero de tipo esquemático para crear el bloque sumador/restador, lo llamamos addsub.sch y en él implementamos el diseño de la figura 14.7 con el añadido de la parte del desbordamiento (figura 14.9). Aunque el resultado final se muestra en la figura 14.13, intenta no copiarlo, sino hacerlo tú solo, y si acaso comprobarlo luego. Al terminar crea un símbolo.

Figura 14.13: Esquemático del sumador/restador de 4 bits

Ahora procederemos a crear el bloque de visualización (recuerda la figura 14.1 y el apartado 14.2.2). Antes de hacer la unidad de visualización, tenemos que crear el bloque que calcula el complemento a dos de un número de 4 bits (mira este bloque en la figura 14.11). Creamos una nueva fuente llamada ca2.sch, y en ella creamos el diseño de la figura 14.3. En la figura 14.14 se muestra el esquemático de este diseño, de él tendrás que crear un símbolo.

Figura 14.14: Esquemático del circuito Ca2 que calcula el complemento a 2 de un número

Ahora creamos un nuevo fichero para la unidad de visualización, lo vamos a llamar visualiza.sch. En él implementamos el circuito de la figura 14.11, resultando el esquemático mostrado en la figura 14.15. Al terminar, comprueba el esquemático y crea un símbolo de este circuito.



Figura 14.15: Esquemático del circuito Visualiza, que se encarga de mostrar el resultado por el display de siete

segmentos

Y ya sólo falta crear la unidad de más alto nivel llamada top_addsub.sch, que se encargará de unir los bloques sumador/restador y visualiza. El diagrama de bloques se mostró en la figura 14.1 y su realización en el ISE se muestra a continuación (figura 14.16).

Figura 14.16: Esquemático de la unidad de más alto nivel del diseño

En la figura 14.16 están también los puertos AN_0, AN_1, AN_2 y AN_3 que eran con los que se controlaban los displays que iban a lucir (en este caso sólo el de la derecha). Como siempre, una vez que lo hayas terminado, guardas el diseño, lo compruebas, y asignas los pines. Luego lo implementas en la FPGA.

14.4. Comprobación del diseño Buf, este ha sido un diseño con cierta complejidad, así que ¡enhorabuena si has llegado hasta aquí! De todos modos, aún no está todo hecho. Ahora hay que comprobar que el diseño funciona bien. Esto además nos valdrá para repasar los números en complemento a 2, y sus sumas y restas. Podemos seguir este esquema para comprobar primero que el display representa bien los números, y luego las operaciones.

• Ponemos todos los interruptores a 0: debe salir un 0 en el display. Ya que estamos haciendo 0-0=0. Todos los LED van a estar apagados excepto LD7, que estará luciendo. Éste es el acarreo de salida, pero como estamos restando, no se utiliza. Si pulsamos BTN0, veremos que se apaga, ya que al pulsar estamos sumando 0+0.

• Recuerda que los cuatro interruptores de la derecha (señal OPA: de SW0 a SW3) codifican el minuendo si estamos en la resta (BTN0 sin pulsar), así que mantenemos los cuatro interruptores del sustraendo (OPB: de SW4 a SW7) a cero, y vamos codificando todos los números de OPA. Así que:



• Si SW7=SW6=SW5=SW4=SW3=SW2=SW1='0' y SW0='1'. Estamos codificando OPA="0001" y OPB="0000". Así que estamos haciendo 1-0=1. Por tanto el display mostrará un 1, así como los LEDs. Recuerda que LD7, cambia según sea resta o suma. El punto decimal deberá estar apagado, ya que en nuestro sistema, el punto representa el signo negativo.

• Si SW7=SW6=SW5=SW4=SW3=SW2=SW0='0' y SW1='1'. Estamos codificando OPA="0010" y OPB="0000". Así que estamos haciendo 2-0=2. Por tanto el display mostrará un 2, así como los LEDs.

• Si SW7=SW6=SW5=SW4=SW3=SW2='0' y SW1=SW0='1'. Estamos codificando OPA="0011" y OPB="0000". Así que estamos haciendo 3-0=3. Por tanto el display mostrará un 3, así como los LEDs.

• Continuamos probando todas las combinaciones de OPA, hasta que SW7=SW6=SW5=SW4=SW3='0' y SW2=SW1=SW0='1'. Estamos codificando OPA="0111" y OPB="0000". Así que estamos haciendo 7-0=7. Por tanto el display mostrará un 7, así como los LEDs.

• Ahora toca codificar hacer que OPA="1000" y OPB="0000". Como las entradas están en complemento a dos. estamos haciendo -8-0=-8. Por tanto el display mostrará un -8, con el punto decimal encendido, ya que representa el signo negativo.

• Continuamos variando SW0, SW1 y SW2, de modo que consigamos todos los números negativos desde -8 hasta -1. Por ejemplo si OPA="1011" y OPB="0000", estamos haciendo -5-0=-5. Por tanto el display mostrará un -5, con el punto decimal encendido, ya que representa el signo negativo.

• Ahora vamos a mantener OPA="0000" y variaremos OPB. • Si OPA="0000" y OPB="0001", y no pulsamos BTN0 (BTN0='0'), entonces estamos haciendo 0-1=-1. Y por

tanto tendremos un -1 en el display (el signo menos lo indica el punto decimal). Los cuatro LED de la derecha lucirán, ya que -1 en complemento a dos es "1111".

• Si pulsamos BTN0¸ se mostrará un +1, ya que estamos haciendo 0+1=1. Los 4 LED de la derecha se apagarán.

• Podemos continuar haciendo esto hasta OPB="0111"¸ entonces estamos haciendo 0-7=-7. Y por tanto tendremos un -7 en el display (el signo menos lo indica el punto decimal). En los cuatro LED de la derecha vendrá codificado el número "1001", ya que -1 en complemento a dos es 1111.

• Si pulsamos BTN0¸ se mostrará un +7, ya que estamos haciendo 0+7=1. En los 4 LED de la derecha se codificará 7, esto es "0111".

• Pero cuando hacemos que OPB="1000"¸ entonces aparece E. ¿Por qué? estamos haciendo 0-(-8)=+8. Y en complemento a dos con 4 bits, el +8 no se puede representar. Fíjate que luce LD6, que representa el desbordamiento de la resta.

• Sin embargo, si pulsamos BTN0, estamos haciendo 0+(-8)=-8, lo que sí se puede representar, y debe salir el 8, con el punto decimal. Fíjate también que se apaga LD6.

• El resto de combinaciones de OPB son representables, por ejemplo, si OPB="1001" entonces estamos haciendo 0-(-7)=7, que sí se puede representar, y debe salir un 7 en el display, sin punto decimal, y en los LED de la derecha "0111", y LD6 apagado.

• Pulsando BTN0 obtenemos -7, ya que hacemos 0+(-7)=-7. • Ahora prueba cualquier otra combinación de números, entiende qué estas representando y qué operación

haces, y comprueba que está bien. Si, has comprobado que sale todo bien, ¡ya sabes hacer una pequeña calculadora! aunque sea un poco rudimentaria y con sólo dos operaciones.

Departamento de Tecnología Electrónica 15. Unidad aritmético lógica


15. Unidad aritmético lógica Una unidad aritmético lógica (UAL, pero más conocida como ALU por sus siglas en inglés) es un circuito que permite realizar operaciones aritméticas y lógicas entre los operandos de las entradas. La ALU suele constar de unos bloques que realizan las operaciones aritméticas y lógicas, y de un multiplexor que escoge las salidas de esos bloques según la operación seleccionada. Muchas de las operaciones aritméticas ya las hemos visto: suma, resta, comparación, ... Y las operaciones lógicas suelen ser aplicar unas operaciones a nivel de bits, por ejemplo, invertir todos los bits, realizar la operación AND entre cada bit de los operandos. A veces también se incluyen operaciones de desplazamiento y rotación, esto es, los bits de un operando se desplazan o se ruedan. Por ejemplo, si tuviese el operando OPA="0010" y lo desplazo a la izquierda obtendría "0100".

15.1. Especificaciones Realizar una unidad aritmético lógica con dos operandos de 4 bits (OPA y OPB) y 4 operaciones. Los operandos vendrán dados por los interruptores. El operando OPA se codificará mediante los 4 interruptores de la derecha (de SW0 a SW3), y el operando OPB con los cuatro interruptores de la izquierda (de SW4 a SW7). Las operaciones que se realizarán son: suma, multiplicación por 2, mayor y la operación lógica AND. Para realizar una operación se deben de pulsar uno de los 4 pulsadores:

• BTN0: realiza la suma S=OPA+OPB • BTN1: multiplica por 2 el operando OPA. S=2xOPA • BTN2: devuelve el número mayor entre OPA y OPB • BTN3: aplica la función lógica AND entre los bits de OPA y OPB

En caso de que se pulsen dos o más pulsadores al mismo tiempo, tendrá prioridad el pulsador que esté más a la derecha en la placa. Por ejemplo si se pulsan BTN1 y BTN3 al mismo tiempo, el resultado será la multiplicación por 2 (BTN1) y no la función lógica AND. Para el caso de la operación suma, multiplicación y mayor, se considera que los operandos OPA y OPB están codificados en binario puro (sin signo). Para la operación lógica AND, no es necesario considerar ninguna codificación. El resultado de la operación se mostrará por los cuatro LED de la derecha (de LD0 a LD3), además se mostrará por el display de la derecha. Según qué operación se esté realizando LD7 mostrará:

• En la suma: el acarreo de salida • En la multiplicación: el desbordamiento • En la operación "mayor que": se mantendrá apagado • En la operación lógica AND, se mantendrá apagado

Cuando no haya ningún botón pulsado, todos los LED permanecerán apagados, y también el display.

15.2. Diagrama de bloques Como es un diseño grande, vamos a ir construyéndolo poco a poco. Primero sabemos que tenemos que realizar cuatro operaciones, por lo tanto necesitaremos un circuito para cada una de las operaciones. Luego veremos cómo implementamos cada una de estas operaciones (algunas ya las hemos hecho), pero por ahora los consideramos como bloques. A veces a esto se le llaman cajas negras: sabemos qué entradas y salidas dan, pero no sabemos que hay en su interior. En la figura 15.1 se muestran estos cuatro bloques que se encargarán de realizar las cuatro operaciones que tenemos que hacer. En estos bloques vemos que todos menos el multiplicador tienen dos entradas (OPA y OPB). Y que el sumador y el multiplicador tienen una señal más de salida, la de acarreo de salida para el sumador y la del desbordamiento overflow para el multiplicador.



OPB(3:0)

+

OPA(3:0)4 4

MULT2

OPA(3:0)4

MAYOR

OPA(3:0)4

OPB(3:0)4

AND

OPA(3:0)4

OPB(3:0)4

4 4 4 4CO OV

R_SUM(3:0) R_MULT(3:0) R_MAY(3:0) R_AND(3:0)

OPB(3:0)

+

OPA(3:0)4 4

MULT2

OPA(3:0)4

MAYOR

OPA(3:0)4

OPB(3:0)4

AND

OPA(3:0)4

OPB(3:0)4

4 4 4 4CO OV

R_SUM(3:0) R_MULT(3:0) R_MAY(3:0) R_AND(3:0) Figura 15.1: Los cuatro bloques que harán las operaciones de la ALU

Según que operación hayamos escogido, debemos seleccionar el resultado de uno de los bloques que realizan las operaciones. Por ejemplo, si queremos sumar debemos seleccionar la señal R_SUM (figura 15.1). Como ya sabes, la selección se suele implementar mediante multiplexores, y es lo que hacemos en la figura 15.2. Según la operación seleccionada OPER, escogemos el resultado de uno de los bloques. Y quizás te preguntes ¿quién determina los códigos de operación? ¿por qué cuando OPER="11" cogemos la suma y no la AND? Es una buena pregunta, hemos escogidos éstos igual que podíamos haber escogido otros ya que el enunciado no nos lo especificaba. Lo que sí es importante es cogerlos seguidos, esto es, ya que hay una prioridad para las operaciones, conviene que estén ordenadas según esa prioridad. Así que podíamos haber escogido este orden, o el inverso (OPER="00" para la suma, OPER="01" para la multiplicación, OPER="10" para el mayor, y OPER"11" para la AND).

11 10 01 00OPER(1:0)

OPB(3:0)

+

OPA(3:0)4 4

MULT2

OPA(3:0)4

MAYOR

OPA(3:0)4

OPB(3:0)4

AND

OPA(3:0)4

OPB(3:0)4

4

2

4

4

4R_SUM R_MULT R_MAY R_AND

4R_(3:0)Códigos de operación

00 : AND01 : MAYOR10 : MULT11 : SUMA

CO OV

11 10 01 00OPER(1:0)

OPB(3:0)

+

OPA(3:0)4 4

MULT2

OPA(3:0)4

MAYOR

OPA(3:0)4

OPB(3:0)4

AND

OPA(3:0)4

OPB(3:0)4

4

2

4

4


4R_(3:0)

11 10 01 00OPER(1:0)

OPB(3:0)

+

OPA(3:0)4 4

MULT2

OPA(3:0)4

MAYOR

OPA(3:0)4

OPB(3:0)4

AND

OPA(3:0)4

OPB(3:0)4

4

2

4

4


4R_(3:0)Códigos de operación

00 : AND01 : MAYOR10 : MULT11 : SUMA

CO OV

Figura 15.2: Selección de la operación a realizar

En las operaciones lo único que nos importa es que cuando apretemos un botón se seleccione la operación adecuada, pero la persona que use la ALU no va a saber, ni le interesa, cómo está codificada internamente esa operación (esto es, cuánto vale OPER). El siguiente paso es establecer la correspondencia entre los botones pulsados y el código de operación. Fíjate, tenemos cuatro pulsadores y queremos 2 salidas OPER que van a codificar la operación seleccionada. Cuando pulsemos BTN0 queremos que OPER sea igual a "11" (suma); cuando pulsemos BTN1 y no esté pulsado BTN0 queremos que OPER="10" (multiplicación). Y así con el resto, entonces ¿qué bloque me implementa esto? pues un codificador con prioridad (recuerda el capítulo 8). Las entradas y salidas de un codificador con prioridad de 4 a 2 se muestran en la figura 15.3. En esta figura también se muestra la tabla de verdad.

CODIF

BTN0 I3


OPER(0)S0OPER(1)S1

OP_ACTAEI

EOEI I3 I2 I1 I0 S1 S0 A EO0 X X X X 0 0 0 01 0 0 0 0 0 0 0 11 0 0 0 1 0 0 1 01 0 0 1 X 0 1 1 01 0 1 X X 1 0 1 01 1 X X X 1 1 1 0

CODIF

BTN0 I3


OPER(0)S0OPER(1)S1

OP_ACTAEI

EOCODIF

BTN0 I3BTN0 I3


OPER(0)S0OPER(1)S1

OP_ACTAEI

EOEI I3 I2 I1 I0 S1 S0 A EO0 X X X X 0 0 0 01 0 0 0 0 0 0 0 11 0 0 0 1 0 0 1 01 0 0 1 X 0 1 1 01 0 1 X X 1 0 1 01 1 X X X 1 1 1 0


Figura 15.3: Entradas y salidas de un codificador con prioridad de 4 a 2, y su tabla de verdad



Tenemos que conectar BTN0 a la entrada de mayor prioridad (I3), y BTN3 a la de menor prioridad (I0). Si te fijas en la tabla de verdad, cuando I3=1, la salida del codificador vale S="11", por lo tanto, es justo el código de operación de la suma (figura 15.2). Por tanto, las salidas del codificador van directamente a la selección del multiplexor (OPER). Si hubiésemos tomado el código de la suma como OPER="00", simplemente tendríamos que invertir la salida del codificador. Así que, incluyendo el codificador para los pulsadores de entrada, el circuito queda como muestra la figura 15.4.

11 10 01 00OPER(1:0)

OPB(3:0)

+

OPA(3:0)4 4

MULT2

OPA(3:0)4

MAYOR

OPA(3:0)4

OPB(3:0)4

AND

OPA(3:0)4

OPB(3:0)4

4

2

4

4


4R_(3:0)

Códigos de operación00 : AND01 : MAYOR10 : MULT11 : SUMA

CODIF

BTN0 I3


S0S1

OP_ACTAEI

EO

'1'

CO OV

11 10 01 00OPER(1:0)

OPB(3:0)

+

OPA(3:0)4 4

MULT2

OPA(3:0)4

MAYOR

OPA(3:0)4

OPB(3:0)4

AND

OPA(3:0)4

OPB(3:0)4

4

2

4

4


4R_(3:0)


CODIF

BTN0 I3


S0S1

OP_ACTAEI

EO

'1'

11 10 01 00OPER(1:0)

OPB(3:0)

+

OPA(3:0)4 4

MULT2

OPA(3:0)4

MAYOR

OPA(3:0)4

OPB(3:0)4

AND

OPA(3:0)4

OPB(3:0)4

4

2

4

4


4R_(3:0)



CODIF

BTN0 I3BTN0 I3


S0S1

OP_ACTAEI

EO

'1'

CO OV

Figura 15.4: Codificación de las entradas de selección de la operación

Ya casi está el diagrama de bloques del circuito completo, nos falta la representación del resultado. Simplemente añadimos el bloque del convertidos a 7 segmentos (figura 15.5). Cuando no hay ningún pulsador apretado, se desconecta el display y por eso se conecta la salida A (activo) del codificador, a pin AN_0 que controla el display de la derecha. Recuerda que se conecta invertida debido a que AN_0 es activa a nivel bajo. Además hemos puesto una habilitación al multiplexor, para que cuando no haya ningún botón pulsado, el multiplexor no saque ningún resultado.

11 10 01 00OPER(1:0)

OPB(3:0)

+

OPA(3:0)4 4

MULT2

OPA(3:0)4

MAYOR

OPA(3:0)4

OPB(3:0)4

AND

OPA(3:0)4

OPB(3:0)4

4

2

4

4


R(3:0)


CODIF

BTN0 I3


S0S1

OP_ACTAEI

EO

'1'

CO OV

7

A

G

D

B

C

F

EI(3:0)

HEX7SEG

SEG(6:0)

4

AN_0

0

1

OV

CO

OPER(0)

ENSEL

OPER(1)

LD7

LEDS

11 10 01 00OPER(1:0)

OPB(3:0)

+

OPA(3:0)4 4

MULT2

OPA(3:0)4

MAYOR

OPA(3:0)4

OPB(3:0)4

AND

OPA(3:0)4

OPB(3:0)4

4

2

4

4


R(3:0)



CODIF

BTN0 I3BTN0 I3


S0S1

OP_ACTAEI

EO

'1'

CO OV

7

A

G

D

B

C

F

E

A

G

D

B

C

F

EI(3:0)

HEX7SEG

SEG(6:0)

4

AN_0

0

1

OV

CO

OPER(0)

ENSEL

OPER(1)

LD7

LEDS

Figura 15.5: Diagrama de bloques del circuito

Fíjate en la señal LD7 y asegúrate que entiendes por qué es así, si no lo entiendes, quizás te ayude la siguiente figura:



0

1

OV

CO

OPER(0)

0

1

'0'

'0'

OPER(0) 0

1

OPER(1)

LD70

1

OV

CO

OPER(0)

'0' 0

1

OPER(1)

LD7

0

1

OV

CO

OPER(0)

OPER(1)

LD7

Ya que es '0' en los dos casos

Cuando OPER(1)= '0' → LD7='0'

0

1

OV

CO

OPER(0)

0

1

'0'

'0'

OPER(0) 0

1

OPER(1)

LD70

1

OV

CO

OPER(0)

'0' 0

1

OPER(1)

LD7

0

1

OV

CO

OPER(0)

OPER(1)

LD7

Ya que es '0' en los dos casos

Cuando OPER(1)= '0' → LD7='0'

Figura 15.6: Simplificación del multiplexor para LD7

15.3. Diseño Muchos de los bloques de la figura 15.5 ya los tenemos hechos, lo que nos permitirá ahorrar tiempo. Creamos un nuevo proyecto llamado alu. Añadimos una copia (Proyect→Add Copy of Source) de las siguientes fuentes del ejercicio 13 (el sumador)

• decod4_16.sch • hex7seg.sch • ha.sch • fa.sch • sum4bits.sch

Y del ejercicio del multiplexor (ejercicio 12), añadimos una copia de: • mux2_4bit.sch

Crea un símbolo del conversor a siete segmentos (hex7seg.sch), el sumador de 4 bits (sum4bits.sch) y el multiplexor (mux2_4bit.sch). Haz también que las señales tengan un orden razonable (sobre todo en el convertidor de 7 segmentos). Para obtener el mismo orden que ya as obtenido en otras prácticas puedes seguir los siguientes pasos:

• Abre el hex7seg.sch • Ejecuta Tools→Symbol Wizard. • Selecciona Using Schematic : hex7seg y más abajo selecciona Use Reference Symbol, allí pincha en Browse y busca

en el directorio del sumador el fichero hex7seg.sym para que coja el mismo símbolo y con el mismo orden. Repite esto para el sumador y el multiplexor.

Ya tenemos el sumador, el convertidor de siete segmentos y el multiplexor de dos entradas con 4 bits. También podríamos coger el comparador que hemos realizado en la práctica 11, sin embargo para éste usaremos el símbolo que proporciona el ISE. A continuación vamos a ir haciendo cada uno de los bloques que nos faltan de la figura 15.5.

15.3.1. Multiplicador por 2 Tenemos que multiplicar el operando OPA por 2. Si te acuerdas del tema 2, (sistemas de numeración y codificación), la multiplicación por 2 en binario era similar a la multiplicación por 10 en decimal. Simplemente hay que desplazar los números hacia la izquierda. Y en el bit menos significativo se pone un cero. Si hubiese un uno en el bit más significativo habría que indicar que ha habido desbordamiento. Este circuito por lo tanto es muy sencillo, se muestra en la figura 15.7, en donde también se han incluido varios ejemplos para demostrar el funcionamiento.

A3 A2 A1 A0

S3 S2 S1 S0

0

OV

Multiplicador x2 Ejemplos:

6: 01102

12: 11002

x2

5: 01012

10: 10102

x2

9: 10012

18:100102

x2

overflowno cabe en 4 bits

A3 A2 A1 A0

S3 S2 S1 S0

0

OV

Multiplicador x2 Ejemplos:

6: 01102

12: 11002

x2

5: 01012

10: 10102

x2

9: 10012

18:100102

x2

overflowno cabe en 4 bits

Figura 15.7: Circuito multiplicador por 2



Para hacer este circuito creamos una nueva fuente llamada mult2.sch y creamos este sencillo circuito. Recuerda que en el ISE no es posible conectar señales ni puertos con distinto nombre, así que tendremos que poner un buffer, como ya hemos hecho alguna vez. Realizamos el circuito con buses, quedando como muestra la figura 15.8.

Figura 15.8: Esquemático del multiplicador por 2

Guardamos el circuito, lo comprobamos y creamos un símbolo.

15.3.2. Circuito comparador, "mayor" Para este circuito crea una nueva fuente llamada mayor.sch. Este circuito ya lo deberías saber hacer, ya que es casi igual que el dibujado en las figuras 12.4 y 12.6 (del la práctica del multiplexor). Así que no lo vamos a explicar mucho, simplemente representaremos el esquemático por si tienes alguna duda. Si no lo tienes muy desordenado, puedes incluso copiar el circuito del la figura 12.6, y adaptarlo al que tenemos que realizar ahora (esto ya sabes que tiene algún riesgo). El esquemático se muestra en la figura 15.9.

Figura 15.9: Esquemático del bloque comparador (mayor)

15.3.3. Circuito operación lógica AND Bueno, con este circuito no deberías de tener ningún problema. Simplemente hay que realizar la operación lógica AND, entre los operadores. Se realiza bit a bit, esto es, R(0)=OPA(0) AND OPB(0); R(1)=OPA(1) AND OPB(1); ...; R(i)=OPA(i) AND OPB(i)

Creamos una nueva fuente llamada and_4bit.sch y realizamos el circuito de la figura 15.10.



Figura 15.10: Esquemático del bloque que realiza la AND lógica

Al terminar, como siempre, guardamos, comprobamos el esquemático y creamos un símbolo.

15.3.4. Multiplexor de 4 entradas datos con habilitación Ahora queremos realizar un multiplexor de cuatro entradas de datos y por tanto, dos de selección. Cada dato tiene cuatro bits. Además, incluiremos una señal de habilitación para que no saque ningún dato en el caso de que no se haya seleccionado ninguna operación. Tenemos tres opciones para realizar el multiplexor (bueno, más, pero aquí propondremos éstas):

• La primera consistiría en realizar el multiplexor completamente con puertas lógicas, tal como se ha explicado en clase. Ésta no lo vamos a hacer, aunque deberías saber cómo se hace.

• La segunda última alternativa propuesta sería hacer el multiplexor con la ayuda del decodificador de 2 a 4. • La última opción sería construir el multiplexor de 4 entradas de datos a partir de tres multiplexores de dos

entradas de datos. Como éste ya lo tenemos, nos sería fácil. Tendríamos que añadir la señal de habilitación Vamos a realizarlo según esta última forma. La formación del multiplexor a partir de los multiplexores pequeños se muestra en la figura 15.11.

OPER(1:0)

4

2

R_SUM

R_MULT

R_MAY

R_AND

R(3:0)

4

4

4

4

EN

00

01

10

11

R_MAY

R_AND

4

4 0

1

R_SUM

R_MULT

4

4 0

1

0

1 R(3:0)

44

EN

OPER(0)

OPER(0)

OPER(1)

OPER(1:0)

4

2

R_SUM

R_MULT

R_MAY

R_AND

R(3:0)

4

4

4

4

EN

00

01

10

11

OPER(1:0)

4

2

R_SUM

R_MULT

R_MAY

R_AND

R(3:0)

4

4

4

4

EN

00

01

10

11

R_MAY

R_AND

4

4 0

1

R_SUM

R_MULT

4

4 0

1

0

1 R(3:0)

44

EN

OPER(0)

OPER(0)

OPER(1)

R_MAY

R_AND

4

4 0

1

0

1

R_SUM

R_MULT

4

4 0

1

0

1

0

1

0

1 R(3:0)

44

EN

OPER(0)

OPER(0)

OPER(1) Figura 15.11: Construcción de un multiplexor con habilitación de 4 entradas de datos a partir de multiplexores de dos

entradas de datos

Al final del multiplexor se le ha añadido la habilitación, una para cada bit. Para poner las señales de selección en los multiplexores pequeños tenemos que analizar qué grupos de señales selecciona cada bit. Por ejemplo, cuando OPER(1)='0' se selecciona a R_AND o a R_MAY, mientras que cuando OPER(1)='1' se selecciona a R_MULT o a R_SUM. Quizás te ayude la siguiente figura.



OPER(1:0)

4

2

R_SUM

R_MULT

R_MAY

R_AND

R(3:0)

4

4

4

4

EN

00

01

10

11

R_MAY

R_AND

4

4 0

1

R_SUM

R_MULT

4

4 0

1

0

1 R(3:0)

44

EN

OPER(0)

OPER(0)

OPER(1)Si OPER(1)='1' , entonces OPER(0) selecciona entre R_MULT y R_SUM

Si OPER(1)='0' , entonces OPER(0) selecciona entre R_AND y R_MAY

habilitación

OPER(1:0)

4

2

R_SUM

R_MULT

R_MAY

R_AND

R(3:0)

4

4

4

4

EN

00

01

10

11

OPER(1:0)

4

2

R_SUM

R_MULT

R_MAY

R_AND

R(3:0)

4

4

4

4

EN

00

01

10

11

R_MAY

R_AND

4

4 0

1

0

1

R_SUM

R_MULT

4

4 0

1

0

1

0

1

0

1 R(3:0)

44

EN

OPER(0)

OPER(0)

OPER(1)Si OPER(1)='1' , entonces OPER(0) selecciona entre R_MULT y R_SUM

Si OPER(1)='0' , entonces OPER(0) selecciona entre R_AND y R_MAY

habilitación

Figura 15.12: Señales de selección en los multiplexores pequeños

Así que creamos una nueva fuente llamada mux4d_4b_e.sch (indica que tiene 4 datos, de 4 bits y habilitación). El esquemático del circuito se muestra a continuación (figura 15.13). Llama a los puertos de entrada con un nombre genérico (D00, D01, D10, D11), para que puedas utilizarlo en otras ocasiones y entender a qué puerto se corresponden ya que si los llamases R_AND, R_MAY,... si lo utilizas en otro diseño no sabrás qué entrada de selección los activa, ni el significado de esos nombres.

Figura 15.13: Esquemático del multiplexor de 4 datos con habilitación

Como siempre, para terminar, guarda el diseño, compruébalo y crea su símbolo poniendo un orden adecuado a las entradas.

15.3.5. Codificador con prioridad de 4 entradas El codificador con prioridad ya lo hemos visto en el capítulo 8 y su tabla de verdad se mostró en la figura 15.3. Como sabes consta de dos bloques, uno que establece las prioridades de modo que sólo una señal pueda estar activa y otro que codifica. Puedes, o bien usar el codificador que ya creaste, o crear una nueva fuente llamada codif4a2prior.sch para crear el codificador de 4 entradas con prioridad y habilitación. En la figura 15.14 se muestra el codificador, en donde también están los puertos de salida EN_OUT y A (Activo).



Figura 15.14: Esquemático del codificador de 4 entradas con prioridad y habilitación

Guarda el diseño, compruébalo y crea su símbolo poniendo un orden adecuado a las entradas.

15.3.6. Componente de mayor jerarquía Ya tenemos todos los componentes necesarios para implementar el circuito (figura 15.5). Así que vamos a crear el diseño que los integra. Creamos un fichero llamado top_alu.sch, y realizamos el diseño de la figura 15.5. La solución se muestra a continuación (figura 15.15). Luego guarda el diseño y compruébalo.

Figura 15.15: Esquemático final de la ALU

15.4. Implementación y comprobación Ya sólo falta crear el fichero UCF con los puertos, implementar el diseño en la FPGA y comprobar que funciona bien. Este ha sido un diseño bastante completo.

Departamento de Tecnología Electrónica 16. Elementos de memoria


16. Elementos de memoria En esta práctica vamos a usar elementos de memoria, en concreto un biestable activado por flanco. Así que además necesitaremos una señal de reloj para el biestable. Para ello utilizaremos la señal de reloj de la placa Pegasus. Esta señal va a 50MHz, y entra por el pin 77 de la FPGA. Puedes localizar el reloj de la placa a la izquierda de los displays de 7 segmentos, y allí se indica la frecuencia del reloj y el pin que recibe la señal de reloj. Este primer ejercicio secuencial va a ser muy sencillo.

16.1. Especificaciones Diseñar un circuito que al apretar el pulsador BTN0 encienda LD0 y que cuando se deje de pulsar mantenga encendido el LED. Para apagar el LED debemos de pulsar BTN1.

16.2. Diseño Este circuito se podría realizar con un latch S-R, pero como no hay latches de este tipo en la biblioteca de Xilinx, usaremos un biestable J-K activado por flanco de subida. Creamos un nuevo proyecto llamado led_on.sch. Y creamos una fuente con el mismo nombre. En la ventana de símbolos escogemos la categoría Flip_Flop, y escogemos el símbolo fjkc. Que se corresponde con un biestable J-K, con clear asíncrono. La señal clear (CLR) funciona a nivel alto, es decir con un '1' lógico se pone el biestable a cero. El funcionamiento del biestable J-K ya lo conoces: un uno en la entrada J pone a uno el biestable; un uno en la entrada K lo pone a cero; si las dos entradas están a cero se mantiene el valor mientras que si las dos están a uno, invierte el valor guardado. Por tanto, el esquemático será como el mostrado en la figura 16.1. Cuando lo tengas, guarda el diseño para implementarlo.

Figura 16.1: Esquemático del circuito que

enciende y apaga el LED

16.3. Implementación Cuando los circuitos tienen señal de reloj hay que especificar quién es la señal de reloj y su frecuencia. Para ello ejecutamos el comando "Create Timming Constraints", que se encuentra en la ventana de procesos, en el apartado "User Constraints". Nos saldrá una ventana como la de la figura 16.2.

Figura 16.2: Editor de restricciones del ISE

En dicha ventana seleccionamos la pestaña Global. Y donde pone Clock Net Name, debe salir nuestra señal de reloj: Clk.

Departamento de Tecnología Electrónica 16. Elementos de memoria


En ella hay un hueco para poner el periodo. Como nuestro reloj es de 50MHz, su periodo es 1/50MHz = 20 ns. Ya que 1MHz= 106 Hz. Y por otro lado: 1 ns = 10-9 ns. Así que en dicho hueco ponemos el número 20, y la herramienta se encarga de poner los nanosegundos y el tiempo que el reloj está a nivel alto (50% por defecto), lo dejamos como está, guardamos y cerramos el Xilinx Constraints Editor.

Figura 16.3: Especificación del periodo de reloj en el editor de restricciones del ISE

Ahora tenemos que asignar los pines, con la herramienta PACE no siempre sale bien, así que lo hacemos editándolo a mano. Al abrir el fichero UCF vemos que ya tiene algo escrito. Esto lo ha escrito el Xilinx Constraints Editor, ya que en el fichero UCF también se guarda la información de la señal de reloj. Aunque ya sabes cómo se rellena el fichero UCF, ya que hay algunas novedades, a continuación se muestra cómo debe quedar.

NET "CLK" TNM_NET = "CLK"; TIMESPEC "TS_CLK" = PERIOD "CLK" 20 ns HIGH 50 %; NET "LED0" LOC = "P46" ; NET "BTN0" LOC = "P59" ; NET "BTN1" LOC = "P58" ; NET "CLK" LOC = "P77" ;

Código 16.1: Especificación del periodo de reloj en el editor de restricciones del ISE

Guarda el fichero, e implementa el circuito en la placa. Y comprueba que funciona. Esto que acabamos de realizar no se puede hacer con un circuito combinacional, necesitaríamos mantener el dedo pulsado para que la luz se mantenga encendida. Con este circuito hemos logrado memorizar cuál fue la última tecla pulsada, la de encender o apagar. Como curiosidad, decir que hemos usado un biestable J-K, y por tanto si pulsamos las teclas de encendido y apagado se debería de cambiar el estado en que estaba, pero date cuenta que es prácticamente imposible pulsar ambas teclas a la vez. Y lo que es más, ten en cuenta que el reloj va a 50MHz (50 millones de ciclos en un segundo), por tanto, si mantienes pulsadas ambas teclas durante un segundo, lo que sucederá es que el LED se apagará y encenderá 25 millones de veces. Nuestros ojos (y nuestro cerebro) no son capaces de percibir este parpadeo y por lo tanto, lo que percibimos es que el LED luce menos (la mitad).

Departamento de Tecnología Electrónica 17. Interruptor con pulsador


17. Interruptor con pulsador En esta práctica queremos hacer una variación del circuito del capítulo anterior. Ahora, en vez de encender el LED con un pulsador y apagarlo con otro distinto, queremos encenderlo y apagarlo con el mismo pulsador de modo que si está encendido lo apaguemos, y si está apagado lo encendamos.

17.1. Ideas Se nos pueden ocurrir varias ideas para implementar el circuito. Antes de seguir leyendo intenta pensar cómo lo harías tú.

17.1.1. Conectando el pulsador a la entrada del biestable T En principio podemos pensar en el biestable T, ya que cuando T='1' cambiará el valor del biestable, y por tanto, se apagará o se encenderá según como estuviese anteriormente. Podemos realizar el circuito mostrado en la figura 17.1. Escogemos el biestable T con señal de clear asíncrono (CLR). Este biestable está en la categoría Flip_Flop y se llama FTC. Ponemos el clear a cero para que nunca se active (también se podría haber puesto conectado con otro pulsador para activarlo a voluntad).

T Q

CLR

FTC

CLK

BTN0 LED0T Q

CLR

FTC

CLK

BTN0 LED0

Figura 17.1: Primera versión del

circuito

La señal de reloj de la placa se conecta a la señal de reloj del biestable y la entrada T del biestable se conecta al pulsador que queremos que funcione como interruptor. Prueba a implementar el circuito en la placa. Recuerda del capítulo 16 cómo se define el reloj (figura 16.3) y mira a ver qué sucede.... Si implementas el circuito verás que unas veces funciona y otras veces se queda en el mismo estado, y que durante el tiempo en que mantienes presionado el pulsador, el LED luce un poco, pero no tan intensamente. Antes de seguir leyendo, intenta pensar por qué se comporta así. Lo que ocurre es que somos mucho más lentos que el reloj de la placa. Este reloj va a 50MHz, por lo tanto, en un segundo tiene 50 millones de flancos de subida. Y suponiendo que presionamos el pulsador durante un segundo, el biestable va a oscilar entre '0' y '1' unas 50 millones de veces. En el momento en que soltemos el pulsador, el valor que se fije dependerá en qué valor tenga el biestable en ese preciso instante. Instante que dura menos de una millonésima de segunda (20 ns). Por lo tanto se puede decir que es aleatorio, con la misma probabilidad de que se quede encendido o apagado. En la figura 17.2 se muestra un cronograma del funcionamiento del circuito. Se puede observar que cuando se presiona el pulsador (BTN0='1') , la salida del biestable oscila. Al terminar de pulsar, el biestable permanecerá en el último valor. En el caso del ejemplo de la figura, el LED se ha quedado apagado.

50 MHz

CLK

LED0-Q

BTN0-T

'1' → cambio en Q

Oscilará hasta que soltemos el pulsador

'0' → Q guarda valor

Valor final depende del estado al soltar el pulsador

50 MHz

CLK

LED0-Q

BTN0-T

'1' → cambio en Q

Oscilará hasta que soltemos el pulsador

'0' → Q guarda valor

Valor final depende del estado al soltar el pulsador

Figura 17.2: Cronograma del circuito de la figura 17.1

17.1.2. Conectando el pulsador al reloj del biestable T Para evitar que el biestable esté cambiando continuamente de valor mientras se mantiene el pulsador presionado, se podría pensar en utilizar la señal del pulsador como reloj, ya que esta señal sólo tiene un flanco de subida. Y es en los flancos de subida cuando pueden cambiar de valor estos biestables. Antes de seguir, puntualizaremos que este ejemplo muestra lo QUE NO SE DEBE HACER, ya que para crear diseños síncronos y seguros, la señal de reloj del circuito es la única que debe entrar en las entradas de reloj de los biestables. Sólo diseñadores experimentados deberían arriesgarse a realizar circuitos asíncronos. En la figura 17.3 se muestra el circuito que se propone. La entrada T del biestable está siempre a '1', por lo tanto, siempre que se reciba un flanco de subida de BTN0 cambiará el valor del biestable.



T Q

CLR

FTC

BTN0

LED0

Vcc

No se debe poner en la entrada de reloj una señal distinta a la

señal de reloj del circuito

Atención:Circuito MAL DISEÑADO T Q

CLR

FTC

BTN0

LED0

Vcc

T Q

CLR

FTC

BTN0

LED0

Vcc

No se debe poner en la entrada de reloj una señal distinta a la

señal de reloj del circuito

Atención:Circuito MAL DISEÑADO

Figura 17.3: Segunda versión del circuito, que no se debe realizar

Si pruebas este circuito en la placa, quizás veas que tiene un comportamiento extraño. De todos modos, aunque funcionase bien, tenemos que buscar otra solución que cumpla las normas de diseño síncrono de manera que sólo la señal de reloj se conecte a las entradas de reloj de los biestables.

17.2. Circuito detector de flanco En este curso no aprendemos a crear circuitos secuenciales con funcionalidad definida, a excepción de biestables sencillos, registros y contadores. Sin embargo, sí aprendemos a analizarlos e identificar su funcionalidad. Así que observa el circuito de la figura 17.4 e intenta descubrir su funcionalidad. Fíjate que los dos biestables de la izquierda son del tipo D y el de la derecha es del tipo T. Los biestables tienen dibujado dentro un símbolo que indica que son activos por flanco de subida.

B

Clk

FDC

FD

F

BTN0 D QD Q LED0FTC

T Q

CLR

B

Clk

FDC

FD

F

BTN0 D QD Q LED0FTC

T Q

CLR

Figura 17.4: Circuito detector de flanco e interruptor

Suponiendo que en el tiempo inicial los tres biestables están a cero (Q='0'), obtén el cronograma de las señales B, C, F y LED0 para las entradas mostradas en la figura 17.5.

BTN0

B

C

F

clk

Clk

LED0

BTN0

B

C

F

clk

Clk

LED0

Figura 17.5: Obtén el cronograma de las señales para el circuito de la figura 17.4

Te deberá salir que por cada pulso largo de BTN0, el circuito lo transforma en un pulso de único ciclo de reloj: la se señal F . Este pulso de F hace que el biestable T cambie sólo una vez por cada pulso de BTN0. Si no sabes cómo obtener el cronograma, puedes simular el circuito, o bien, en el apartado 17.3 se muestra la solución. Es muy importante que entiendas cómo se obtiene, ya que en el examen suelen caer problemas de este tipo, normalmente algo más complejos. Implementa el circuito en la placa. Seguramente veas que funciona correctamente. Sin embargo, si estás usando la placa Basys, puedes apreciar que no funciona del todo bien. Eso es porque al presionar el pulsador se producen rebotes que forman varios pulsos. La placa Pegasus tiene condensadores en las entradas de los pulsadores para evitar esos rebotes (recuerda la figura de la derecha de la figura 3.1). La placa Basys no los tienes, y para evitar esos rebotes tendrías que poner un contador que elimine los pulsos que se produzcan durante un tiempo después de recibir un pulso, que puede ser de unos 200 ms.



17.3. Solución al cronograma A continuación se muestra la solución al cronograma de la figura 17.4. Fíjate que la señal B es la misma que la señal BTN0 pero retrasada al siguiente flanco de reloj. La señal C es igual que B pero retrasada exactamente un ciclo de reloj. Y que la señal F sólo será igual a 1 cuando B='1' y C='0', esto sólo ocurrirá después del flanco de reloj de subida de BTN0.

BTN0

B

C

F

clk

Clk

LED0

BTN0

B

C

F

clk

Clk

LED0

Figura 17.6: Solución al cronograma de las señales para el circuito de la figura 17.4

Departamento de Tecnología Electrónica 18. Parpadeo de un LED


18. Parpadeo de un LED Ahora vamos a hacer que un LED parpadee (se encienda y se apague intermitentemente) él solo. Así de simple.

18.1. Especificaciones Hacer que LD0 parpadee a una frecuencia de dos segundos. Esto es, permanecerá encendido durante un segundo y apagado durante el segundo siguiente, y así sucesivamente. La frecuencia del reloj de la placa es de 50MHz.

18.2. Diseño Lo que tenemos que hacer es un divisor de frecuencia y esto se hace con contadores. El reloj de la placa Pegasus va a 50MHz. Como 1MHz = 106 Hz entonces el reloj tiene 50 millones de ciclos en un segundo. Nosotros queremos obtener una señal que vaya a 1 Hz, esto es, que tenga un periodo de un segundo. Esta señal será la que hará cambiar cada segundo el valor del LED, por lo que el LED tendrá una frecuencia de 0,5 Hz (2 segundos de periodo). El esquema de lo que queremos hacer se muestra en la figura 18.1: tenemos una señal de reloj que realiza 50 millones de ciclos por segundo. Por tanto, nosotros dividiremos la frecuencia contando hasta 50 millones, ya que entonces habrá pasado un segundo. Al final de la cuenta, el circuito pondrá durante un sólo ciclo de reloj su salida a uno, y el resto del tiempo a cero. Pasado otro segundo (después de volver a contar otros 50 millones), volverá a poner la salida a uno. Esta salida, irá a un biestable T que cambiará de estado cada segundo (cada vez que se termina la cuenta) y por tanto apagará o encenderá el LED cada segundo, que es nuestro objetivo. Evidentemente, la señales de entrada y salida no están a escala.

DivFrec

Clk1HzClk

Clear

T=1 s

1 Hz50 Mz

T=20 nsT=20 ns Biestable T

Q

Clk

T LED

Cada segundo le llega un '1' y

entonces cambiaráde estado (se

encenderá y apagará)

(no está a escala)

DivFrec

Clk1HzClk

Clear

T=1 s

1 Hz50 Mz

T=20 nsT=20 ns Biestable T

Q

Clk

T LED

Cada segundo le llega un '1' y

entonces cambiaráde estado (se

encenderá y apagará)

(no está a escala)

Figura 18.1: Esquema del circuito

Contar 50 millones puede parecernos demasiado, pero lo podemos hacer poco a poco. Primero vamos a contar 5, para dejar los 20 ns del reloj en un número redondo. Ya que si contamos 5 ciclos de 20ns, obtendremos una señal con periodo de 100ns.

conta5

CONT5

Clk

CLEAR

50 MHz

Tsalida=100ns

0 1 2 3 4 0 14

10 MHz

CLK

T100NS

T entra

da=20

ns

2 3 4 1 2 3 40 0

5x20ns

CE'1'

CLK

T100NS

50MHz 10MHz

conta5

CONT5

Clk

CLEAR

50 MHz

Tsalida=100ns

0 1 2 3 4 0 14

10 MHz

CLK

T100NS

T entra

da=20

ns

2 3 4 1 2 3 40 0

5x20ns

CE'1'

CLK

T100NS

50MHz 10MHz

Figura 18.2: Bloque que cuenta hasta 5, con sus entradas y salidas

Creamos un nuevo proyecto llamado segundero en C:\practicas\edi\tunombre. Recuerda: sin espacios, eñes, tildes, ..... Dentro del proyecto creamos una nueva fuente para realizar este contador llamada conta5.sch. Dentro de la ventana de símbolos, vamos a la categoría de contadores (counter) y allí escogemos el contador cb4cle. Esto es un Contador Binario de 4 bits, con Clear asíncrono, carga paralelo de dato (Load) y habilitación (Enable). Fíjate que se han marcado en mayúsculas y negrita las letras que hacen formar el nombre del contador. Cómo hacer para contar 5 ciclos de reloj. La figura 18.3 muestra el esquemático. En él, las salidas Q0 a Q3 llevan la cuenta. Cada vez que hay un flanco de subida del reloj CLK, el contador incrementa su cuenta, ya



que el count enable (CE) está siempre a uno. Por otro lado hay una señal de carga de dato (L: Load), esta señal se pone a uno cuando la salida Q2 está a uno. Esto ocurre cuando se llega a 4, pues en el resto de los casos (de 0 a 3) la salida Q2 permanece a cero. La secuencia de la cuenta se muestra en la figura 18.5.

Figura 18.3: Esquemático del contador de cinco

ciclos de reloj

Figura 18.4: Otra versión del esquemático del contador de

cinco ciclos de reloj (más genérica)

Como se ve en la figura 18.2, al llegar a 4 debemos de inicializar el contador. La puesta a cero la haremos siempre síncrona. Y por tanto, activaremos la señal de carga L para introducir un cero (inicializar síncronamente) en el contador. Aunque existe un CLEAR asíncrono que inicializa el contador, por ser asíncrono, nosotros no lo usaremos para contar (sí lo podríamos utilizar para inicializar el circuito, al arrancar la primera vez, por ejemplo, pero no para contar).

Q3 Q2 Q1 Q0 Cuenta0 0 0 0 00 0 0 1 10 0 1 0 20 0 1 1 30 1 0 0 40 0 0 0 00 0 0 1 10 0 1 0 20 0 1 1 30 1 0 0 40 0 0 0 00 0 0 1 1.....

Iniciar la cuenta

Iniciar la cuenta

cuando Q2=1 entonceshacemos CONT5=1

Q3 Q2 Q1 Q0 Cuenta0 0 0 0 00 0 0 1 10 0 1 0 20 0 1 1 30 1 0 0 40 0 0 0 00 0 0 1 10 0 1 0 20 0 1 1 30 1 0 0 40 0 0 0 00 0 0 1 1.....

Iniciar la cuenta

Iniciar la cuenta

cuando Q2=1 entonceshacemos CONT5=1

Figura 18.5: Secuencia del contador

En la figura 18.4 se muestra un contador de 5 más genérico que el de la figura 18.3, ya que la entrada CE no está fija a uno. Por lo tanto, permite conectar el contador a otra cuenta anterior. El fin de cuenta: CONT5, será cuando Q2='1' y CE='1', como en nuestro caso CE es siempre uno, los circuitos son equivalentes. Al terminar este diseño, guárdalo y crea un símbolo. Es bastante recomendable que lo simules para que veas el funcionamiento del contador. Ahora, a la salida de conta5 tenemos una señal de 10MHz (100ns). Utilizaremos esta señal, y contaremos 10 ciclos de esta señal. A la salida de nuestro nuevo contador tendremos una señal de 1MHz (1000ns=1µs). El esquema que queremos realizar se muestra a continuación.

conta5T100NS

Clk

CLEAR

conta10

T1USClk

CLEAR

f=50MHzT=20ns

Clk

f=10MHzT=100ns

CECE‘1’

Aquí contamos ciclos de T100NS

no de reloj, y por eso es la entrada de CE

T100NS

f=1MHzT=1µs=1000ns

T1US

Hemos conseguido divididir la frecuencia

por 50=5x10

Divisor de frecuencia x5 Divisor de frecuencia x10

conta5T100NS

Clk

CLEAR

conta10

T1USClk

CLEAR

f=50MHzT=20ns

Clk

f=10MHzT=100ns

CECE‘1’

Aquí contamos ciclos de T100NS

no de reloj, y por eso es la entrada de CE

T100NS

f=1MHzT=1µs=1000ns

T1US

Hemos conseguido divididir la frecuencia

por 50=5x10

Divisor de frecuencia x5 Divisor de frecuencia x10 Figura 18.6: Dos contadores en cascada para dividir la frecuencia por 10

Ahora la situación es distinta, ya que antes teníamos la entrada CE permanentemente a uno, ahora esta entrada estará un ciclo de reloj a uno, y cuatro ciclos de reloj a cero (ver figura 18.2). La inicialización del contador se realiza cuando la cuenta sea 9 y además la entrada CE sea uno. Si no se esperase a que CE=1, entonces la cuenta de 9 duraría tan sólo un ciclo de reloj. En la figura 18.7 se muestra este cronograma.



50 MHz

10 MHz

CLK

T100NS

0 1 2 3 4 0 14 2 3 4 1 2 3 40 0 1 2 3 4 0 1 2 3 4 1 2 3 40 0

9 0 1 2 3 4 5 6

1 2 3 4 0 1 2 3 4 1 2 3 40 0

7 8

1 2 3 4 0 1 2 3 4 1 2 3 40 0

8 9 0

1 MHz

T1US

Se inicializa cuando la cuenta sea 9 y CE=1

50 MHz

10 MHz

CLK

T100NS

0 1 2 3 4 0 14 2 3 4 1 2 3 40 0 1 2 3 4 0 1 2 3 4 1 2 3 40 01 2 3 4 0 1 2 3 4 1 2 3 40 0

9 0 1 2 3 4 5 6

1 2 3 4 0 1 2 3 4 1 2 3 40 01 2 3 4 0 1 2 3 4 1 2 3 40 0

7 8

1 2 3 4 0 1 2 3 4 1 2 3 40 01 2 3 4 0 1 2 3 4 1 2 3 40 0

8 9 0

1 MHz

T1US

Se inicializa cuando la cuenta sea 9 y CE=1

Figura 18.7: Cronograma del contador de 10

Así pues, creamos una nueva fuente llamada conta10.sch y la hacemos parecida a la anterior, con la diferencia que la entrada CE no la ponemos a uno, ya que irá conectada a la salida del contador de 5. Además, ahora el fin de cuenta se determinará al llegar a 9 y no a 4, e incluye la señal CE para que espere a la siguiente orden de cuenta para cambiar de valor.

Figura 18.8: Esquemático del contador de 10

Al terminar, guardamos el diseño, lo comprobamos y creamos su símbolo. Igualmente sería conveniente simularlo. Si conectamos estos dos bloques como se muestra en la figura 18.6 tendremos la señal T1US cuya frecuencia es de 1MHz. Todavía tenemos que dividir la frecuencia entre un millón (106), para lograr la frecuencia de 1 Hz (1 ciclo por segundo). Aunque hay maneras más eficientes para realizarlo, ahora simplemente conectaremos en cascada 6 divisores de frecuencia como el de la figura 18.8. Y en el último conectamos un biestable T para que encienda y apague el LED. Por ejemplo, podíamos haber creado un divisor por 1000 y haber conectado dos de ellos, en vez de usar estos seis. Creamos una nueva fuente que será la que contenga los contadores que acabamos de crear, la llamaremos blink.sch (blink significa parpadeo en inglés) El diseño se muestra en la figura 18.9.

Figura 18.9: Esquemático del diseño del parpadeo de un LED

Ahora, implementa el circuito y comprueba con un reloj que más o menos funciona bien. Ten en cuenta que durante un segundo el LED deberá estar luciendo y en el siguiente segundo estará apagado.

Departamento de Tecnología Electrónica 19. Reloj digital


19. Reloj digital Ahora vamos a hacer un pequeño reloj digital. Lo haremos con segundos y minutos, ya que si lo hacemos con minutos y horas no nos va a dar tiempo para comprobarlo en clase. Esta práctica constará de dos partes, primero haremos un segundero de 0 a 9, con el que usaremos solamente un display de 7 segmentos. Y luego haremos el reloj completo.

19.1. Especificaciones • La primera parte consistirá en hacer un segundero digital que vaya de 0 a 9 y se muestre por el primer display

de 7 segmentos. El punto decimal parpadeará cada segundo. Esto es, que en un segundo se apague y se encienda. Por tanto, tendrá un periodo de un segundo.

• La segunda parte será hacer un reloj, los dos displays de la derecha se mostrarán los 60 segundos de un minuto: irá por tanto de 0 a 59. Los dos displays de la derecha mostrarán los 60 minutos de una hora. Por tanto, también irá de 0 a 59. Además, el punto decimal del medio parpadeará cada segundo. Esto es, que en un segundo se apague y se encienda. Por tanto, tendrá un periodo de un segundo.

19.2. Contador de 10 segundos Para hacer este circuito partiremos de lo que tenemos anteriormente. Para ello, creamos un nuevo proyecto llamado displ_segund. Importamos ficheros de tipo .sch de la práctica anterior conta5.sch, conta10.sch y de la práctica del sumador (o cualquier otra que lo use) coge las fuentes decod4_16.sch y hex7seg.sch. Ya sabes cómo se hacer, recuerda usar la instrucción Project→Add Copy of Source para que se copie en tu proyecto y no modifique lo que has hecho antes. El diagrama bloques inicial (que puede sufrir modificaciones) se muestra en la figura 19.1. En éste, realizaremos un primer bloque segundero que nos dará dos señales de frecuencias 1 segundo y medio segundo (esta última, para el parpadeo del punto del display). Luego, un bloque que contará diez cuentas de la señal del segundero. Este bloque en realidad lo haremos en el propio bloque de mayor jerarquía.

segundero

T500MS

Clk

CE

T1SCLEAR

contador10

7

A

G

D

B

C

F

E

I0I1I2I3

HEX7SEG

SEG(6:0)

Q0Q1Q2Q3

Clk

CLEAR

Vcc

CE

segundero

T500MS

Clk

CE

T1SCLEAR

contador10

7

A

G

D

B

C

F

E

A

G

D

B

C

F

E

I0I1I2I3

HEX7SEG

SEG(6:0)

Q0Q1Q2Q3

Clk

CLEAR

Vcc

CE

Figura 19.1: Diagrama de bloques inicial

19.2.1. Bloque segundero Para hacer este bloque usaremos parte de lo que hicimos en la práctica anterior. Copia el fichero blink.sch del anterior proyecto y cópialo en el directorio de tu nuevo proyecto, y cámbialo de nombre: segundero.sch. Y añádelo al proyecto: Project→Add Source (no hace falta que sea copia porque ya lo hemos copiado nosotros). Abre el esquemático segundero.sch y vamos a modificarlo. Lo que vamos a hacer es un bloque que nos devuelva una señal de periodo un segundo y otro de medio segundo. ¿Cómo lo harías? intenta hacerlo tú, o al menos pensarlo un poco. Realmente, lo que queremos hacer es un divisor de frecuencia con dos salidas, una que divide 50 millones de veces y otra 25. Con esta información deberías poder hacerlo tú sólo. Para hacerlo, podríamos quitar el último contador de diez, y poner un contador de cinco y otro de dos. Dando la cuenta final lo mismo (5x2=10), pero a la salida del contador de 5 tendríamos cuentas de medio segundo (periodo T=500ms=0,5s). La figura 19.2 muestra cómo se haría este circuito.



conta5T500MS

Clk

CLEAR

conta2

T1SClk

CLEAR

Clk

f=2HzT=500ms

CECET500MS

f=1HzT=1000ms=1s

T1S


T100MS

f=10HzT=100ms

T1ST500MS

Salida de medio segundoSalida de un segundoEntrada de 100 ms

conta5T500MS

Clk

CLEAR

conta2

T1SClk

CLEAR

Clk

f=2HzT=500ms

CECET500MS

f=1HzT=1000ms=1s

T1S


T100MS

f=10HzT=100ms

T1ST500MS

Salida de medio segundoSalida de un segundoEntrada de 100 ms

Figura 19.2: Esquema para obtener una señal de medio segundo y de un segundo.

Otra alternativa es hacerlo con un único contador de 10, pero detectando cuándo llega a cinco. La cuenta de medio segundo se activará cuando el contador valga 4 (de 0 a 5) o cuando el contador valga 9. En ambos casos hay que incluir la condición que la CE='1' (en este caso la señal CE es la señal T100ms. La figura 19.3 muestra esta otra alternativa.

Figura 19.3: Alternativa al circuito que obtiene una señal de un segundo y otra de medio segundo

Esta alternativa tiene varios puntos interesantes: por un lado utilizamos sólo un contador. Pero lo más importante que hay que tener en cuenta es lo relativo a la señal que detecta el 4 en binario. En este caso hay que detectar los unos y los ceros porque como la cuenta no termina en cuatro, los números 5, 6 y 7 también tienen que Q2='1'. Otro aspecto interesante es que la señal de periodo medio segundo (T500MS) se forma con la OR de las señales que identifican la cuenta de 4 y 9. Por último, no olvides incluir la señal CE en las detecciones, porque si no, la señal no duraría un sólo pulso de reloj, sino todo el tiempo que el contador estuviese a 4 o a 9. La figura 19.4 puede ayudarte a entender esto.



0: 00001: 00012: 00103: 00114: 01005: 01016: 01107: 01118: 10009: 10010: 00001: 0001.. ....

Cuenta

El único que tieneQ3='1' y Q0='1'

No es el únicoque tiene Q2='1'

Q2='1'

Detectar 9 (fin de cuenta)basta con detectar los '1':

T1S

Q0Q3

Detectar 4 (no es fin de cuenta)Hay que detectar los '1' y los '0':

CE

Q0

Q2

CE

Q1

Q3

Esta señal tiene periodo de un segundo también, por lo que hay que hacer

la OR con la de la cuenta de 9

T500MS

Esta señal tiene periodo de

medio segundo.No olvidar el CE

(en este caso es T100MS)

0: 00001: 00012: 00103: 00114: 01005: 01016: 01107: 01118: 10009: 10010: 00001: 0001.. ....

Cuenta

El único que tieneQ3='1' y Q0='1'

No es el únicoque tiene Q2='1'

Q2='1'

Detectar 9 (fin de cuenta)basta con detectar los '1':

T1S

Q0Q3

Detectar 4 (no es fin de cuenta)Hay que detectar los '1' y los '0':

CE

Q0

Q2

CE

Q1

Q3

Esta señal tiene periodo de un segundo también, por lo que hay que hacer

la OR con la de la cuenta de 9

T500MS

Esta señal tiene periodo de

medio segundo.No olvidar el CE

(en este caso es T100MS) Figura 19.4: Detección del 4 en una cuenta de 0 a 9, y generación de la señal de periodo de 500ms

Independientemente de qué alternativa hayas escogido para hacer el circuito, crea un símbolo del circuito que debe tener las entradas y salidas mostradas en la figura 19.5. Para que lo podamos usar en los siguientes esquemáticos.

segundero

T500MS

Clk

CE

T1SCLEAR

las entradas asíncronas se suelen dibujar debajo

segundero

T500MS

Clk

CE

T1SCLEAR

las entradas asíncronas se suelen dibujar debajo

Figura 19.5: Bloque del segundero

19.2.2. Bloque de mayor jerarquía Este bloque contendrá los bloques de la figura 19.1. Creamos una nueva fuente llamada displ_segund.sch. En realidad este bloque lo deberías saber hacer sólo. Así que simplemente en la figura 19.6 se muestra una posible solución. Asegúrate que si copias la solución, la entiendes (si no, no vale de nada).

Figura 19.6: Esquemático del circuito que muestra las unidades de segundo

19.3. Reloj digital con segundos y minutos Este diseño es algo más complejo, no por contar los segundos y minutos, que si has entendido el ejercicio anterior no te será difícil, sino por el manejo de los cuatro displays de siete segmentos.



Quizás te hayas fijado que sólo hay una letra de cada segmento para los cuatro displays, es decir, sólo hay una A, B, C,..., G para los cuatro. Y luego hay una señal de control AN para cada segmento. Así que, ¿cómo podríamos mostrar números diferentes en cada display? Lo que se hace es multiplexar en el tiempo. Esto es, se divide el tiempo en cuatro partes, y se asigna cada parte a un display. Así, en un ciclo va a estar encendido el primer display con un número determinado, y en el siguiente ciclo, el siguiente display con otro número. Y así los cuatro, al final, cada display lucirá sólo un cuarto de tiempo (así que lucirán con menos intensidad), pero lo hará tan rápido que nuestro ojo no notará que gran parte del tiempo no está luciendo. Lo que queremos generar se muestra en la figura 19.7.

4 x 1 ms

0 1 3 0 1 2 3

T1ms

CUENTA4MS

AN_0

T=1 ms

2

AN_1

AN_2

AN_3

US DS DMNumDispl UM US DS DMUM

DM UM DS US

Minutos

decenas unidades

Segundos

decenas unidades

Según el valor de CUENTA4MS se selecciona las unidades o

decenas de minutos o segundos

AN_3 AN_2 AN_1 AN_0

4 x 1 ms

0 1 3 0 1 2 3

T1ms

CUENTA4MS

AN_0

T=1 ms

2

AN_1

AN_2

AN_3

US DS DMNumDispl UM US DS DMUM

DM UM DS US

Minutos

decenas unidades

Segundos

decenas unidades

Según el valor de CUENTA4MS se selecciona las unidades o

decenas de minutos o segundos

AN_3 AN_2 AN_1 AN_0

Figura 19.7: Cronograma para mostrar los minutos y segundos por los displays.

Quizá te preguntes para qué tanto rollo y por qué no se saca por la FPGA cada uno de los 7 segmentos de los cuatro displays. Esto se hace así para ahorrar pines de la FPGA. Haz cuentas: 7 segmentos más el punto decimal por 4 displays son 32 pines. Estos son muchos pines, nuestra FPGA tiene 208 pines, pero no todos son utilizables como entradas/salidas. Por lo que estaríamos desperdiciando un alto porcentaje de los pines disponibles para algo que en realidad no es necesario. Con esta alternativa se usan 8 pines (más las 4 señales de encendido: AN_0,..., pero éstas se tienen que añadir también a los 32 pines de antes). Y ahora, ¿se te ocurre cómo hacer el circuito que implementa el reloj? ¿cómo generar las señales AN_0,...,AN_3 y NumDispl de la figura 19.7? Intenta pensarlo antes de mirar la solución ya que todos los conceptos necesarios para implementarlos se han visto ya.

19.3.1. Implementación Varias cosas fundamentales tenemos que hacer en este diseño: Tenemos que ampliar el bloque segundero (recuerda las

figuras 19.2 y 19.3) de modo que saque una salida adicional de periodo 1 ms. Para esto simplemente tienes que sacar la señal de periodo 1 ms como salida. Esto es, hacer un bloque como muestra la figura 19.8 Luego, utilizaremos la señal de 1 ms (T1MS) para contar cuatro cuentas de 1 ms. Obteniendo la señal CUENTA4MS (figura 19.7), que irá de 0 a 3, esto es, de 00 a 11.

segundero

T500MS

Clk

CE

T1SCLEAR

T1MS

segundero

T500MS

Clk

CE

T1SCLEAR

T1MS

Figura 19.8: Nueva versión del segundero

Posteriormente ampliar el reloj que hemos hecho en el apartado 19.2. Lo ampliamos para que cuente decenas de segundo (DS), unidades de minuto (US) y decenas de minuto (DM).

Luego queremos según en qué cuenta estemos de la señal CUENTA1MS se seleccione las unidades o decenas de minutos o segundos. Por ejemplo, si CUENTA1MS=00 entonces queremos que por el display entren las unidades de segundo (US), y así para el resto según se muestra en la figura 19.7. Ya hemos visto cómo se realiza esto: para seleccionar se utilizan los multiplexores (recuerda el capítulo 12). En este caso es de 4



alternativas, por tanto dos bits para la señal de selección (CUENTA4MS), y con 4 bits cada alternativa. La figura 19.9 muestra cómo se podría realizar esta parte.

CUENTA4MS(1:0)

4

2

DM

UM

DS

US

NumDispl(3:0)

4

4

4

4

00

01

10

11

7

A

G

D

B

C

F

E

I0I1I2I3

HEX7SEG

SEG(6:0)

CUENTA4MS(1:0)

4

2

DM

UM

DS

US

NumDispl(3:0)

4

4

4

4

00

01

10

11

7

A

G

D

B

C

F

E

A

G

D

B

C

F

E

I0I1I2I3

HEX7SEG

SEG(6:0)

Figura 19.9: Selección de las unidades o decenas de minuto o segundo según el valor de CUENTA4MS

En el capítulo no vimos cómo hacer un multiplexor de 4 entradas de datos (y dos bits de selección) a partir de multiplexores de dos entradas de dato (1 bit de selección). Esto se ha explicado en clase y la figura 19.10 te lo recuerda. Aunque las señales de dato (A, B, C y D) sólo tienen bit y no 4, la extensión es similar (recuerda la figura 12.2).

A 0

1B

SEL1

A 00

01

10

11

MUX4

Z

B

C

D

SEL0

SEL0

C 0

1D

SEL1

0

1Z

A 0

1B

SEL1

A 00

01

10

11

MUX4

Z

B

C

D

SEL0SEL1

A 00

01

10

11

MUX4

Z

B

C

D

SEL0

SEL0

C 0

1D

SEL1

0

1Z

Figura 19.10: Multiplexor de 4 entradas de dato a partir de multiplexores de dos entradas de dato

Por último, para generar las señales de encendido de los displays nos podemos fijar que sólo uno está activo en cada momento (aunque a nivel bajo). Cuando CUENTA4MS=00 se activa AN_0, cuando CUENTA4MS=01 se activa AN_1, y así sucesivamente. Esto ya hemos visto que se realiza con un decodificador. Estamos decodificando el valor de la cuenta con las señales de encendido de los displays.

Ya estando tan avanzados en el curso, intenta hacerlo por ti mismo. Si lo logras, comprueba con un reloj que tengas si es un buen reloj, es decir, si se retrasa o adelanta. Si funciona bien significa que ya sabes bastante electrónica digital, sabes realizar un reloj digital. Si no te sale y estás perdido, a continuación se muestra un solución.

19.3.2. Solución Como el diseño es bastante grande, se dará la solución por partes. Primero, en la figura 19.11 se muestra cómo hacer la decodificación del control de los displays. El contador de 4 milisegundos obtiene un número de 0 a 3 que se decodifica y activa las señales AN_0, AN_1, AN_2 ó AN_3. Fíjate que hay que invertirlas por ser a nivel bajo. La señal del punto decimal, que va a separar segundos de minutos. Se genera igual que en el contador de 10 segundos (capítulo 19.2), sin embargo la salida queremos que esté activa solamente cuando esté activo AN_2. Ya que es ese punto decimal el que queremos que luzca, por eso ponemos la puerta NAND. Fíjate que se pone antes de invertirla. Por último, ponemos una puerta NAND, porque SEG_DT es activo a nivel bajo.



Figura 19.11: Decodificación del control de los displays

En la figura 19.12 se muestra la cuenta de segundos y minutos. Esta cuenta la deberías de saber hacer tú sólo. Es muy importante ya que es algo básico que además suele caer en los exámenes.

Figura 19.12: Contador de segundos y minutos

Por último, en la figura 19.13 se muestra el multiplexor que selecciona qué dígito se va a mostrar según qué segmento está activado. Fíjate que el multiplexor no lo hemos hecho. En el capítulo 12 hicimos un multiplexor de dos datos y un bit de señal de selección. Ahora son 4 entradas de datos (figura 19.9).



Figura 19.13: Multiplexor para la selección del dígito a mostrar por los displays

Documents

Pract Xilinx92 0708