Pract Xilinx92

Departamento de Tecnologa Electrnica
Diseo digital con esquemticos y FPGA.
Felipe Machado Snchez Norberto Malpica Gonzlez de Vega
ndice
ndice .................................................................................................................................................................................. 1 1. Introduccin..................................................................................................................................................................... 3 2. Encender un LED ............................................................................................................................................................ 4
2.1. Diseo del circuito ............................................................................................................................................................................ 5 2.2. Sntesis e implementacin del circuito............................................................................................................................................ 10 2.3. Programacin de la FPGA .............................................................................................................................................................. 11
3. Puertas lgicas, interruptores y pulsadores .................................................................................................................. 15

3.1. Diseo del circuito .......................................................................................................................................................................... 15 3.2. Simulacin del circuito .................................................................................................................................................................... 17 3.3. Sntesis e implementacin del circuito............................................................................................................................................ 20
4. Decodificador de 2 a 4 .................................................................................................................................................. 21
4.1. Diseo del decodificador ................................................................................................................................................................ 21 4.2. Comprobacin del diseo ............................................................................................................................................................... 23 4.3. Implementacin del diseo ............................................................................................................................................................. 24 4.4. Creacin de un bloque.................................................................................................................................................................... 24
5. Decodificador de 3 a 8 .................................................................................................................................................. 27
5.1. Diseo del decodificador con bloques ............................................................................................................................................ 28
6. Decodificador de 4 a 16 ................................................................................................................................................ 30
6.1. Diseo del decodificador con bloques prediseados ..................................................................................................................... 31 6.2. Comprobacin del diseo ............................................................................................................................................................... 33
7. Convertidor de hexadecimal a 7 segmentos ................................................................................................................. 35

7.1. Diseo del convertidor de hexadecimal a 7 segmentos ................................................................................................................ 35 7.2. Implementacin .............................................................................................................................................................................. 39
8. Codificadores ................................................................................................................................................................ 42
8.1. Codificador de 4 a 2 sin prioridad ................................................................................................................................................... 42 8.2. Codificador de 4 a 2 con prioridad, lnea activa y habilitacin........................................................................................................ 42 8.3. Codificador de 4 a 2 con conversin a 7 segmentos...................................................................................................................... 44
9. Extensin 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. Inclusin 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. Diseo 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. Diseo........................................................................................................................................................................................... 57
13. El sumador .................................................................................................................................................................. 60

13.1. Especificaciones ........................................................................................................................................................................... 60 13.2. Diseo........................................................................................................................................................................................... 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 visualizacin ....................................................................................................................................................... 66 14.3. Diseo........................................................................................................................................................................................... 68 Diseo digital con esquemticos y FPGA. v1.8 - - 04/06/2008 1
Departamento de Tecnologa ndice Electrnica 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. Solucin al cronograma ................................................................................................................................................................ 83
18. Parpadeo de un LED................................................................................................................................................... 84

18.1. Especificaciones ........................................................................................................................................................................... 84 18.2. Diseo........................................................................................................................................................................................... 84
19. Reloj digital.................................................................................................................................................................. 87

19.1. Especificaciones ........................................................................................................................................................................... 87 19.2. Contador de 10 segundos ............................................................................................................................................................
Diseo digital con esquemticos y FPGA. v1.8 - 04/06/2008
1. Introduccin
1. Introduccin
El objetivo de esta prcticas guiadas es introducir al alumno en el diseo con esquemticos mediante el uso de herramientas CAD (computer aided design). Estas prcticas parten de un nivel elemental y se pretende que puedan ser seguidas como complemento en un curso bsico de electrnica digital. Estas prcticas se han desarrollado en el departamento de Tecnologa Electrnica 1 de la Universidad Rey Juan Carlos. Estas prcticas consistirn en un grupo de ejercicios con los que aprenderemos a programar una FPGA utilizando la herramienta gratuita de diseo electrnico digital ISE-WebPACK de Xilinx 2. En las prcticas de este curso realizaremos diseos con esquemticos: puertas lgicas, bloques combinacionales y secuenciales. Una vez que hayamos realizado el diseo en la herramienta, lo sintetizaremos y lo implementaremos en la FPGA. La sntesis es la tarea que transforma un diseo desde un nivel de descripcin a otro nivel de descripcin ms bajo. En nuestro caso, el diseo lo tendremos en esquemticos y la herramienta lo transformar en una descripcin que indica las conexiones internas y configuracin de la FPGA para que funcione de la misma manera a como funcionara nuestro diseo original en esquemticos. Por suerte, la sntesis la realiza la herramienta automticamente, durante la sntesis nosotros nos ocuparemos de supervisar el proceso, analizando los errores y advertencias (warnings) que aparezcan. Antes de implementar el diseo en la FPGA es recomendable simular el diseo para comprobar que funciona correctamente. Es ms fcil detectar errores de diseo mediante simulacin, que en la placa. Imagina que has implementado el diseo en la FPGA y que sta no hace nada. Para descubrir el fallo tendras que usar un polmetro o un osciloscopio y comprobar los niveles de tensin de los pines. Adems con el inconveniente de que slo tienes accesibles los puertos de entrada y salida, y no las seales internas del diseo. Mediante la simulacin puedes comprobar todas las seales (internas y externas) y directamente de un vistazo, sin recurrir a medidas elctricas. Una vez que tenemos el diseo verificado por simulacin, lo implementaremos en la FPGA. La herramienta de diseo crear un fichero de configuracin (con extensin .bit). Este fichero contiene la informacin de la implementacin de nuestro diseo en la FPGA. Para programar la FPGA, en nuestro caso, utilizaremos un cable JTAG, que es un cable que cumple un protocolo de depuracin y programacin: Boundary Scan.. Este cable se conecta al puerto paralelo de nuestro ordenador. Una vez programada la FPGA, nuestro diseo estar implementado en la FPGA y por lo tanto estar funcionando. Dependiendo del diseo implementado, interactuar con el exterior de distinta manera y podremos comprobar su correcto funcionamiento. Para las prcticas utilizaremos la placa Pegasus de Digilent 3, que contiene una FPGA de Xilinx de modelo Spartan-II XC2S200 con encapsulado PQ208. Esta FPGA tiene 200000 puertas lgicas equivalentes y 140 pines disponibles para el usuario. Con esta capacidad podemos hacer diseos digitales bastante grandes. La placa Pegasus contiene distintos perifricos que nos facilitarn la tarea del diseo, como por ejemplo: 8
http://gtebim.es Herramienta gratuita que se puede descargar en http://www.xilinx.com

1 2
Departamento de Tecnologa Electrnica FPGA Conector JTAG Conector de expansin
2. Encender un LED Memoria Fla Flash
VGA
Alimentacin Jumpers de configuracin PS/2 LED D Display segmentos 7s Pulsadores Interruptores
Figura 1.1: Placa Pegasus de Digilent A medida que vayamos avanzando con la prctica iremos aprendiendo la funcionalidad de la placa. An as se puede consultar en la pgina web de la asignatura (http://gtebim.es/docencia/EDI) el manual de la placa (en ingls), y una versin resumida de dicho manual en espaol. Bueno, es hora ya de empezar con las practicas ...
2. Encender un LED
Cuando nos enfrentamos por primera vez a disear mediante una metodologa y herramientas nuevas, lo ms aconsejable es empezar con ejemplos lo ms sencillos posibles. Y a partir de stos se ir aumentando la complejidad del diseo. Son muchas cosas las que pueden fallar, tanto en el uso de las herramientas de diseo como en la placa de la FPGA. Por consiguiente, si de primeras probamos con un diseo complejo, en caso de que no funcione correctamente no sabremos si es el diseo que est mal o es algn paso que no hemos realizado bien. De manera similar, los informticos 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. Tambin podramos usar el display de 7 segmentos, pero su uso es algo ms 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 conexin de los LED se muestra en la figura 2.1. En ella se indican qu pines de la FPGA estn conectados a los LED. Por ejemplo el LED nmero 0, est conectado al pin 46. Para facilitar esta identificacin, la placa lleva impresos la identificacin del LED y el pin asociado de la
'1' Encendido '0' Apagado 390 Spartan-II PIN 46 45 44 43 42 41 37 36 LED LD0 LD1 LD2 LD3 LD4 LD5 LD6 LD7
Figura 2.1: Conexin de los LED de la placa Pegasus Viendo el esquema elctrico de la figura 2.1 podemos deducir que si ponemos un '1' lgico en el pin 46 de la FPGA encenderemos el LED, ya que con un '1' lgico la FPGA pondr 3,3 voltios en ese pin
Diseo digital con esquemticos y FPGA. v1.8 - 04/06/2008 4
2. Encender un LED
de tensin de ese pin de la FPGA). Por el contrario, si ponemos un '0' lgico 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 despus 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 teora, hacindolo as no deberan 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. Diseo del circuito

El diseo del circuito lo haremos con la herramienta ISE-Foundation o con ISE-WebPack de Xilinx, esta ltima es la versin gratuita que se puede descargar en la pgina web de Xilinx. Esta prctica est referida a la versin 9.2, debido a que existen nuevas versiones, puedes descargar esta versin en:
http://www.xilinx.com/ise/logic_design_prod/classics.htm
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:
FileClose Project.
Para empezar nuestro nuevo pinchamos en dond saldr la FileNewguardarem Project... y nos proyect quea crear lo llamaremo led0,proyecto, indicamos la ruta el o, s ). Respecto al nombre y a la e ruta, osno es conveniente ( C:/practica/edi/tunombre trabajar desde un dispositivo de memoria USB, ni tampoco incluir en la ruta o el nombre ni acentos ni ees, ni caracteres extraos, lo ms conveniente es limitarse a caracteres alfanumricos, y usar el guin bajo en vez del espacio. Para el ltimo recuadro de la ventana, donde pone Top-Level Source Type seleccionaremos Schematic, ya que nuestro diseo lo haremos mediante
Figura 2.2: Ventana para la creacin de nuevo proyecto Una vez que hemos rellenado los tres recuadros pinchamos en Next. Ahora nos aparece la ventana de seleccin 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 observacin 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.
2. Encender un LED
tipo de dispositivo encapsulado velocidad rango de operacin C: comercial
XC2S200 XC2S200 PQ208
cdigo de fecha cdigo de lote
5C
Figura 2.3: Interpretacin del texto del encapsulado de la FPGA Para la seleccin de la herramienta de sntesis no tenemos alternativa, y para el simulador en esta prctica no es importante y lo dejamos en ISE Simulator (VHDL/Verilog). En el lenguaje de descripcin de hardware preferido (Preferred Language) se deja el VHDL. Al terminar pinchamos en Next.
Mirar en la FPGA Mirar en la FPGA
Figura 2.4: Ventana para la seleccin 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 proyecto creado y ahora nos disponemos creamos una el nueva fuente pinchando en Project New Source. a crear nuestro diseo. Para ello Esto har saltar a una nueva ventana que nos pedir que seleccionemos el tipo de fuente que queremos crear. Como estamos trabajando en esquemticos, seleccionamos Schematic, y nombramos al fichero led0. Este paso se muestra en la figura 2.5. Posteriormente pinchamos en
2. Encender un LED
Figura 2.5: Seleccin del tipo de nueva fuente Si al terminar el proceso la herramienta nos muestra la siguiente imagen, debemos seleccionar el fichero que hemos creado pinchando en Window led0.sch (led0.sch) como se muestra en la figura 2.6. Tambin se puede
Seleccionar led0.sch
Figura 2.6: Seleccin de la ventana del fichero led0.sch Ahora veremos el plano donde podremos dibujar el esquemtico. En la figura 2.7 se muestra la apariencia de la herramienta. En ella se han movido las subventanas para tener una disposicin ms cmoda. Muvelas de manera que queden de una forma similar a la figura 2.7. Esta operacin no siempre es fcil de realizar y a veces las subventanas se resisten a ser movidas. Otra opcin es pinchar en WindowTile Vertically. Luego, para dejarlo como muestra la figura 2.7, habra que maximizar la subventana del plano donde
2. Encender un LED
Plano donde dibujaremos el circuito
Opciones Opciones Procesos
Fuentes Fuentes
Smbolos
Figura 2.7: Apariencia de la herramienta para empezar a realizar el esquema del circuito En la figura 2.7 se han sealado algunas pestaas que utilizaremos durante el proceso de diseo y a las que se har referencia durante el ejercicio. As que familiarzate con sus nombres y vuelve a esta figura si durante la prctica no sabes a qu pestaa 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 esquemtico. La ventana de smbolos nos permite dibujar las puertas lgicas y los distintos componentes de nuestro diseo. En la ventana de fuentes se muestran los ficheros de nuestro diseo (en este caso slo 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 disear volvemos a la ventana de smbolos. En ella, seleccionamos la categora General y tomamos el smbolo vcc. Una vez que los hemos seleccionado podemos apreciar que el puntero del ratn cambia de forma cuando lo situamos en el plano del circuito. Si pinchamos en cualquier parte del plano se situar el smbolo correspondiente a Vcc, que es la fuente de alimentacin, y por tanto, en electrnica digital es un '1' lgico (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 ratn, pues colocaras varias Vcc por tu circuito. Cuando hayas colocado tu fuente alimentacin, la veas ampliar la zona puedes pinchar ende View ZoomZoom seguramente In (o bien pulsar F8). un poco pequea. Para Siempre que se haya seleccionado un smbolo, al pinchar con el ratn en el mapa del circuito se aade dicho smbolo. Esto puede resultar incmodo ya que podemos estar aadiendo componentes sin (querer. Para quitar esta opcin y tener en cursor del ratn en .modo de 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 smbolo ms de una vez, para borrarlo vamos al modo seleccin (tecla Esc) y pinchamos encima del smbolo que queramos eliminar. ste cambiar a color rojo, y entonces o bien lo borramos con la tecla Supr, o bien pinchamos con el botn derecho del ratn y del men seleccionamos Delete. Como podrs apreciar viendo dicho men, tambin puedes copiar y
2. Encender un LED
Figura 2.8: Creacin de un nivel lgico alto: '1' Ahora conectaremos dicho '1' lgico a un puerto de salida, para ello pincha en AddI/O Marker, o en el icono de la barra de herramientas. Vers que la ventana de opciones cambia, en ella puedes determinar tipo de puerto y cambiar la orientacin del smbolo dibujado. EstoAhora, lo el posteriormente seleccionando el smbolo y pinchando con el botn derecho del ratn. con el ratn te pones encima del final del cable del smbolo de la fuente (VCC) y encima de l pinchas con el ratn. Aparecer el smbolo del puerto, con un nombre similar a XLXN_1. Seguramente est vertical, para ponerlo horizontal, seleccinalo (habiendo pulsado antes la tecla Esc) y pulsa CTRL+R para rotarlo y CTRL+M para voltearlo, tambin lo puedes hacer pinchando con el botn derecho del ratn. 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 botn derecho del ratn, seleccionamos la opcin Rename Port. En el cuadro de dilogo escribiremos LD0, que hace referencia al LED 0 de la placa.
Figura 2.9: El 1-lgico conectado al puerto LD0 Ahora realizaremos el mismo proceso para conectar el puerto LD1 a un 0-lgico. Para ello, primero situamos el smbolo de tierra en el mapa del circuito. En la ventana superior de smbolos mantenemos la seleccin General y en la ventana inferior seleccionamos gnd (del ingls 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 nmero 1 de la placa.
Figura 2.10: Esquema final de nuestro circuito

2. Encender un LED
Ya tenemos nuestro primer diseo hecho. Le damos a guardar (es algo que deberas hacer de vez en cuando), y procederemos a implementarlo en la FPGA. Fjate que cuando no has guardado, el nombre del circuito que est en la pestaa del esquemtico tiene un asterisco.
2.2. Sntesis e implementacin 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 diseo los vamos a conectar deberemos lanzar la herramienta PACE. Esto lo hacemos desde la ventana de procesos, en ella despliega la seccin 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 aadir 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 diseo, y por
Figura 2.11: Seleccin para la asignacin de pines Ahora nos aparecer la herramienta Xilinx PACE. En ella podemos distinguir tres subventanas, la de la derecha, tiene 2 pestaas en su parte inferior, en una se muestra la arquitectura de la FPGA y en la otra la asignacin 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 direccin 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 nmero que indica la placa aadindole una P). Para el puerto LD1 le asignamos el pin
10
2. Encender un LED
Figura 2.12: Herramienta PACE para la asignacin de pines Le damos a guardar y nos saldr una ventana que nos pregunta por el formato del fichero que guardar esta informacin. Aunque nos es indiferente, seleccionamos la primera opcin "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 debera mostrar el aspecto de la figura 2.13. Si es as, ya estamos en disposicin de programar la FPGA. Puede ser que aparezca algn warning y que el proceso de sntesis tenga un smbolo amarillo triangular. Los warnings se pueden ver en la ventana de design summary. De todos
Figura 2.13: Aspecto de la subventana de procesos una vez que se ha sintetizado e implementado el diseo correctamente. En la ventana de la derecha, en el proceso de sntesis ha habido advertencias (warnings) que no siempre son importantes, y por eso tiene un smbolo triangular de color amarillo
2.3. Programacin de la FPGA

Si hemos llegado hasta aqu, ya habremos generado el fichero de programacin de la FPGA (que tiene extensin .bit). Ahora veremos los pasos que hay que dar para programarla. Lo primero que tenemos que hacer es quitar los tres jumpers de configuracin: M0, M1 y M2 del conector J4, (ver situacin en la figura 1.1). Para no perder las caperuzas conctalos a un slo conector dejando el otro al aire como se muestra a la derecha de la figura 2.14.
11
Departamento de Tecnologa Electrnica jumper conectado jumper desconectado

su caperuza est perdida y pisoteada por el suelo del labo
2. Encender un LED jumper desconectado sin perder su caperuza
Representacin:
Figura 2.14: Jumpers y su conexin Cuando estos jumpers estn conectados, la FPGA se programa desde la memoria flash de la placa, en la que se guarda un fichero de configuracin para la FPGA. La Spartan-II es un tipo de FPGA voltil, esto es, requiere estar alimentada para mantener su configuracin. 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 electrnico, se pone una memoria flash que la programa automticamente. Si esto no fuese posible, este tipo de FPGA perdera casi toda su utilidad, ya que no seran autnomas y prcticamente slo valdran 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 seales de la placa coincidan con los nombres de las seales 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 continuacin conectamos el cable de alimentacin de la placa y lo enchufamos a la red elctrica (y cuando lo desenchufes fjate en que no se quede enchufado el adaptador de la clavija plana americana a clavija redonda europea). Al enchufar la placa vers que se enciende el LED LD8. + . Y pinchamos dos veces en "Configure Device signo + dentro: (iMPACT)". Esto arrancar la herramienta iMPACT, que nos mostrar un ventana en la que se ofrecen varias opciones, dejamos la opcin 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). Despus de esto la herramienta procede a identificar a la placa y debera encontrar dos componentes: la FPGA y la memoria flash. La FPGA la identifica como xc2s200 y la memoria como xcf02s. A continuacin nos pedir los ficheros de programacin para cada uno de los componentes (figura 2.15).
12
2. Encender un LED
Figura 2.15: iMPACT: componentes detectados y asignacin de un fichero de configuracin 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 adems la extensin 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 configuracin 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 pondrn de color verde. Si pinchamos en la FPGA (xc2s200 xc2s50) con el botn derecho del ratn, 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 ratn enganchado; para evitarlo, pincha con el botn izquierdo en cualquier parte de la ventana fuera de los smbolos de los chips y vuelve a intentarlo. Ahora, en el men que aparece podemos asignar un fichero de configuracin 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
Figura 2.16: Orden para programar la FPGA

2. Encender un LED
Despus de la orden de programar la FPGA, aparece un cuadro que muestra la evolucin y, si todo ha salido bien, la herramienta nos avisar de que hemos tenido xito en la programacin mostrando un aviso como el de la figura
Figura 2.17: Programacin realizada con xito Ahora miramos la placa y debera 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 diseo de la FPGA El LED LD1 deber estar apagado, pues lo hemos puesto a un '0' lgico. Y el resto de LED tambin estarn 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 diseos ms complejos.
14
3. Puertas lgicas, interruptores y pulsadores

En este ejercicio vamos disear un circuito sencillo con el que podamos interactuar. Para ello usaremos como entradas del circuito los interruptores y pulsadores de la placa. Adems incluiremos alguna lgica interna. A partir de ahora no se va a realizar una explicacin tan detallada como la del primer ejercicio, si durante la ejecucin de este ejercicio has olvidado algn 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-lgico a la entrada de la FPGA. En la placa, a la derecha del Spartan-II
3,3V 4,7k Spartan-II PIN 89 88 87 86 84 83 82 81 3,3V interruptor rup SW0 SW1 SW2 SW3 SW4 SW5 SW6 SW7 4,7k PIN pulsador puls 59 BTN0 58 BTN1 57 BTN2 154 BTN3
4,7k
0,1F
Figura 3.1: Esquema elctrico de las conexiones de los interruptores y pulsadores en la placa Pegasus Para los pulsadores, cuando estn pulsados transmiten un 1-lgico a la entrada y cuando no estn pulsados ponen 0 voltios a la entrada. Observa que los pulsadores tienen un pequeo circuito con resistencias y un condensador, esto es para eliminar los rebotes que se producen al pulsar y as enviar una seal sin ruido.
3.1. Diseo del circuito
Creamos un nuevo proyecto (FileNew Proyect...) llamado swt0 con las mismas caractersticas que el anterior. Creamos una nueva fuente de tipo esquemtico llamada similar a la de la figura 2.7.
swt0.sch.
Y tendremos una pantalla
Como vamos a realizar el circuito con puertas lgicas, en la subventana de categoras (Categories) dentro de la ventana de smbolos, seleccionamos el elemento Logic. Veremos como
and2 and2b1 and3b2
AND de 2 entradas
AND de 2 entradas con una de ellas negada
AND de 3 entradas con dos de ellas negadas
Figura 3.2: Ejemplos de la nomenclatura de las puerta lgicas Lo primero que haremos es aadir una puerta (and2) en elentrada mapa ylos conectamos sus entradas y salidas con puertos (Add I/O Marker ). AND Los puertos de llamaremos SW0 y SW1, que se correspondern con los interruptores 0 y 1. Y el puerto de salida lo renombraremos como LD0, que ser el LED nmero cero. Quedando como muestra la figura 3.3.
Figura 3.3: Implementacin de la puerta AND De manera similar conectaremos los interruptores SW2 y SW3 con la entrada de una puerta y su salida la conectaremos a LD1, obteniendo algo similar a la figura 3.4.
OR,
15
Figura 3.4: Implementacin de la puerta OR Ahora conectaremos un inversor al pulsador conectaremos a LD2:
BTN0
y su salida la
Figura 3.5: Implementacin de un inversor Adems 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 categoras (Categories) seleccionamos Buffer. Para el smbolo seleccionamos buf y lo situamos encima del inversor (fjate que el smbolo 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 con cables implementan pinchando en AddWire, o bien el los , o bien tecleando CTRL+W. Una vez que hemos icono seleccionado este comando, veremos que en la ventana de opciones aparecen las opciones para situar los cables. En ella seleccionamos la primera opcin: 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 botn del ratn, 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 slo 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
Figura 3.7: Conexin final del buffer e inversor Nuestro diseo final tiene 3 entradas (SW0, salidas (LD0, siguiente aspecto:
SW1
BRN0)
y4
LD1, LD2
y LD3). Y deber tener el
Figura 3.8: Diseo final del ejercicio
16
Para comprobar que hemos hecho la conexin bien podemos pinchar en ToolsCheck Schematic,
y revisamos la ventana inferior (Console) para ver si ha detectado algn error o
advertencia. Grabamos
regularmente).
el
esquemtico:
FileSave
(esto
deberas
hacerlo
Debido a que es un diseo pequeo podramos probar el circuito directamente en la placa, sin embargo vamos a simularlo antes para aprender el proceso.
3.2. Simulacin del circuito

Una vez que hemos terminado el esquemtico y lo hemos grabado, seleccionamos la ventana de fuentes (Sources) y la ventana de procesos (Processes).
Seleccin de fuentes para: - Sntesis/Implementacin - Simulacin comportamental - Simulacin post-rutado
Figura 3.9: Seleccin de los ficheros fuente segn 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 seleccin, la ventana de procesos cambia. Por lo tanto, si en cualquier momento ves que la ventana de procesos no est como piensas que debera estar, comprueba que has seleccionado el men de fuentes adecuado. Por ejemplo, puede pasar que quieras sintetizar el diseo y no aparezca el comando, entonces mira qu opcin tienes seleccionada. Ahora crearemos un nuevo fichero para simular nuestro diseo. Mediante un cronograma, este fichero indicar al simulador qu valores toman las entradas en funcin 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: Creacin de una fuente para la simulacin 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 diseo 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 cmo y por qu). La siguiente ventana nos pide que seleccionemos el diseo 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 informacin (figura 3.11). Como nuestro circuito no tiene reloj ni elementos de memoria (ya los estudiaremos en el tema 7) es un circuito
Figura 3.11: Opciones de la temporizacin de la simulacin 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 seales segn el tiempo en que estemos.
Puertos Puertos de de entrada entrada
Eje Eje temporal temporal
Puertos Puertos de de salida salida
Valores Valores de de las las seales seales en en el el tiempo tiempo
Figura 3.12: Ventana de los cronogramas de las seales de simulacin
18
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 seales entre s, para comprobar de manera ms fcil los resultados de la simulacin. 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 arrastrndolo 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 diseo pequeo, los valores de las entradas que vamos a asignar cubrirn 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
LD0: AND tiempo 0-100ns 100-200 200-300 300-400 LD1: OR LD2: NOT tiempo 0-200ns 200-400 SW0 SW1 LD0 0 0 0 0 1 0 1 0 0 1 1 1 tiempo 0-100ns 100-200 200-300 300-400 SW2 SW3 LD1 0 0 0 0 1 1 1 0 1 1 1 1 BTN0 LD2 LD3 0 1 0 1 0 1
Figura 3.13: Asignacin 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 cmo aparece en la ventana de fuentes: tb_swt0.tbw, y cmo dentro de l est nuestro diseo4: UUT swt0(swt0.sch).
Figura 3.14: Valores en los puertos de entrada para la simulacin 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 simulacin, y finalmente obtendremos los resultados de la simulacin en el cronograma (figura 3.15). Las seales 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' slo cuando SW0 y SW1 estn 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 habamos
UUT indica el componente que se est comprobando, es el acrnimo del ingls: Unit Under Test Diseo digital con esquemticos y FPGA. v1.8 - 04/06/2008
4
19
Figura 3.15: Resultados de la simulacin Despus de haber comprobado implementarlo en la FPGA la funcionalidad del circuito, nos disponemos a
3.3. Sntesis e implementacin 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 simulacin, lo primero que tienes que hacer es seleccionar en la ventana de fuentes las fuentes para sntesis: Sources for: "Synthesis/Implementation" (ver figura 3.9). Debemos tambin activar la ventana de procesos, que es donde le indicaremos a la herramienta que comandos de sntesis debe ejecutar (recuerda la figura 2.7). Antes de dar la orden de sintetizar debes asignar los pines de la FPGA. Ahora tenemos ms pines que asignar. Repite el mismo proceso y asigna los pines conforme a la numeracin 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
20
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 estn codificadas en binario y segn que nmero est codificado activa la salida correspondiente a ese nmero. Por ejemplo, si el nmero de la entrada es 102, activar la salida 2, ya que 102 es dos en binario. Adems, los decodificadores suelen tener una seal de habilitacin (enable) que en caso de no estar activa, todas las salidas estarn tambin 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 tambin se muestra. DECOD 2a4
A0 A1 E S0 S1 S2 S3 E 0 1 1 1 1 A1 X 0 0 1 1 A0 X 0 1 0 1 S3 0 0 0 0 1 S2 0 0 0 1 0 S1 0 0 1 0 0 S0 0 1 0 0 0
Figura 4.1: Decodificador de 2 a 4 y su tabla de verdad
4.1. Diseo 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 trmino mnimo de A1 y A0. Por ejemplo, la salida S0 es el trmino mnimo 0 (m0= A1 A0 ); la salida S1 es el trmino mnimo 1 (m1= A1 A0), y de manera similar para el resto. Luego slo tendremos que aadir la habilitacin y obtendremos las salidas. Empecemos a disear: primero creamos un nuevo proyecto llamado decod2a4 en el directorio C:/practica/edi/tunombre. Recuerda no poner tildes ni ees, y mejor si no pones espacios. El proyecto debe tener las mismas caractersticas de los proyectos anteriores. Creamos tambin una nueva fuente con el mismo nombre y de tipo esquemtico (Schematic). Ya tendremos que tener el plano vaco de nuestro circuito. Ya que el decodificador implementa todos los trminos mnimos, necesitaremos todas las entradas negadas y afirmadas (no negadas). Como los puertos no se pueden colocar solos (se deben conectar a las patas de algn componente), empezamos colocando los dos
Figura 4.2: Inversores colocados a las entradas para formar los trminos mnimos Ahora conectamos un cable a la salida de cada inversor ). El otro lado del cable (mediante icono lo dejamos al el aire: pinchamos en un punto ms 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 (tambin hay un ). Y en la ventana de opciones, en el apartado Name ponemos el nombre iconoel negado de A1 lodel cable. N_A1, y el negado de A0 lo llamamos N_A0. Para colocarlo nos Para llamamos ponemos al final del cable y pinchamos encima. Para colocar el segundo, cambiamos el nombre y repetimos la operacin.
Figura 4.3: Inversores con nombre a la salida
21
A continuacin incluiremos 4 puertas AND de dos entradas que se encargarn de crear los 4 trminos mnimos. 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 trminos mnimos Ahora vamos a conectar las entradas de cada una de las puertas. La puerta de arriba ser la del trmino mnimo 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 AddNet y dejamos la opcin por defecto: Use the Autorouter to add one or more line segments between the points you indicate. Al unir los cables veremos que en
Figura 4.5: Trminos mnimos del decodificador Aade tambin los nombres de cada uno de los trminos mnimos (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 opcin: Increase the name; el ndice de trmino mnimo se incrementar por s solo. Ahora slo nos queda incluir la seal de habilitacin. Cuando sta es cero, las salidas son cero, por tanto se puede aadir al final de cada trmino mnimo mediante una puerta AND. Recuerda que la puerta AND
acta 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 Habilitacin E='0' Salida inhabilitada
m0 E='0'
E='1' Salida habilitada

m0 E='1'
m0 E
S0
S0='0'
S0=m0
Figura 4.6: Puerta AND como habilitacin Aadimos las puertas y las conectamos con la seal de habilitacin. El circuito debera quedarnos como la siguiente figura
Figura 4.7: Esquema de puertas del decodificador Antes de seguir, debemos guardar el . fichero (CRTL+S ) y errores comprobar si todas las conexiones estn bien hechas: ToolsCheck Schematic Debemos ver los o advertencias que puedan aparecer en la consola (ventana de abajo). Si hubiese algn error, debemos comprobar qu cable o componente se trata, moverlo para ver si realmente est conectado y conectarlo bien. Vuelve a comprobar el esquemtico (Tools Check Schematic) cuantas veces haga falta hasta que no tengas errores, y el final guarda el fichero.
4.2. Comprobacin del diseo

Antes de implementarlo en la placa vamos a ver si est bien diseado. Para ello seguimos los mismos pasos que en el apartado 3.2: Seleccionamos en la ventana de fuentes (Sources) la opcin 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 diseo 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 slo tenemos 3 entradas, introduciremos las 8 combinaciones posibles. stas se muestran en la figura
23
Figura 4.8: Valores introducidos en el cronograma para la simulacin del decodificador Despus de la simulacin, los resultados de las salidas son:
Figura 4.9: Cronograma de la simulacin Podemos ver que los resultados de la simulacin son correctos. Cuando E='0' no hay ninguna salida activa, y cuando E='1' se van activando las distintas salidas segn cambian las entradas.
4.3. Implementacin del diseo

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 simulacin, lo primero que tienes que hacer es seleccionar en la ventana de fuentes las fuentes para sntesis: Sources for: "Synthesis/Implementation" (ver figura 3.9). Activa la ventana de procesos, que es donde le indicaremos a la herramienta que comandos de sntesis 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 habilitacin a el interruptor SW7. Los 4 LED de salida asgnalos consecutivamente. Sintetiza e implementa el diseo Comprueba que funciona como debe funcionar
4.4. Creacin de un bloque

Si hemos llegado hasta aqu significa que nuestro diseo funciona bien, tanto en simulacin como fsicamente en la placa, ahora vamos a crear un mdulo que integre este codificador para que cada vez que lo necesitemos implementar en diseos ms grandes, no tengamos que crear todo el esquema de puertas sino que conectaremos un bloque como el de la figura 4.1. Sera similar a un componente MSI (Medium Scale Integration) como los chips disponibles para diseo con componentes discretos. Por ejemplo los decodificadores 74LS138 y 74LS139. Esto nos permitir subir el nivel de abstraccin y disear con bloques lgicos en vez de con puertas, lo que har que podamos disear de manera ms rpida y con menos probabilidad de equivocarnos, ya que cada uno de los bloques estn 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 seleccionndolo directamente en la pestaa de la ventana grande. Para crear el mdulo (Xilinx lo llama smbolo) pinchamos en ToolsSymbol Wizard, lo que har que aparezca una ventana (figura 4.10) que nos preguntar para qu componente vamos a
Figura 4.10: Seleccin del componente para el que vamos a crear un smbolo Pinchamos en Next y aparecer una ventana con las entradas y salidas del mdulo. En ella podemos cambiar el lugar donde aparecern (derecha o izquierda) y el orden. Ponemos el mismo orden de la figura 4.11.
Figura 4.11: Determinacin de la posicin de los pines del smbolo Pinchando en Next la siguiente ventana nos preguntan por las distancias y los tamaos del smbolo. 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 smbolo de nuestro decodificador (figura 4.12). Si nos gusta pinchamos en Finish.
25
Figura 4.12: Aspecto final del smbolo de nuestro decodificador Por ltimo tendremos el decodificador en el editor de esquemticos (figura 4.13), en donde hay una pestaa para acceder al esquema en puertas.
Esquema Esquema en en puertas puertas
Smbolo Smbolo
Figura 4.13: Smbolo del decodificador en el editor de esquemticos Ahora podremos utilizar este smbolo en otros diseos. En esto va a consistir el prximo ejercicio.
26
Hemos realizado el decodificador de 2 a 4, utilizando dos interruptores encendamos 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). Podramos 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 disearlo de manera mucho ms rpida y entendible. Es difcil de entender el funcionamiento de un diseo grande en puertas, mientras que si lo hacemos con bloques es ms claro.
A0 DECOD 3a8 A1 A2 S0 S1 S2 S3 S4 S5 S6 E S7 E 0 1 1 1 1 1 1 1 1 A2 X 0 0 0 0 1 1 1 1 A1 X 0 0 1 1 0 0 1 1 A0 X 0 1 0 1 0 1 0 1 S7 0 0 0 0 0 0 0 0 1 S6 0 0 0 0 0 0 0 1 0 S5 0 0 0 0 0 0 1 0 0 S4 0 0 0 0 0 1 0 0 0 S3 0 0 0 0 1 0 0 0 0 S2 0 0 0 1 0 0 0 0 0 S1 0 0 1 0 0 0 0 0 0 S0 0 1 0 0 0 0 0 0 0
Figura 5.1: Esquema del decodificador de 3 a 8 y su tabla de verdad Si analizamos la tabla de verdad y la dividimos en tres partes segn los valores de (figura 5.2), podemos ver que: Cuando E=0, el circuito est inactivo Cuando E=1, y A2=0, las seales S7 a S4 estn inactivas, y las seales S3 a S0 se comportan igual que el decodificador de 2 a 4. Cuando E=1, y A2=1, las seales S3 a S0 estn inactivas, y las seales S7 a S4 se comportan igual que el decodificador de 2 a 4.
E 0 A2 A1 A0 X X X S7 S6 S5 S4 S3 S2 S1 S0 0 0 0 0 0 0 0 0 todas '0' E 1 1 1 1 misma secuencia E 1 1 1 1 A2 1 1 1 1 A1 0 0 1 1 A0 0 1 0 1 S7 0 0 0 1 A2 0 0 0 0 A1 0 0 1 1 A0 0 1 0 1 S7 0 0 0 0 S6 0 0 0 0 S5 0 0 0 0 S4 0 0 0 0 S3 0 0 0 1 S2 0 0 1 0 S1 0 1 0 0 S0 1 0 0 0
E
A2
A2 = '0'
todas '0' S6 0 0 1 0 S5 0 1 0 0 S4 1 0 0 0
igual que decod2a4 S3 0 0 0 0 S2 0 0 0 0 S1 0 0 0 0 S0 0 0 0 0
A2 = '1'
igual que decod2a4
todas '0'
Figura 5.2: Tabla de verdad del decodificador de 3 a 8 dividida segn el valor de E y A2 Por tanto, podemos usar dos decodificadores de 2 a 4, uno para las seales S3 a S0, que se activar cuando E=1 y A2=0 ; esto es E A2 ; y otro decodificador para las seales S7 a S4, que se activar cuando E=1 y A2=1 (EA2). 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 seales.
27
Intenta realizarlo t mismo, y si no te sale puedes ver la solucin en la figura 5.5. A continuacin vamos a disearlo.
5.1. Diseo del decodificador con bloques

Aunque lo podramos 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 caractersticas del proyecto estaremos en la ventana principal, y pincharemos en ProyectAdd Copy of Source.... Con ello vamos a aadir una copia del decodificador que ya hemos hecho a este nuevo proyecto. Vamos a hacer una copia para evitar
Figura 5.3: Fichero fuente que vamos a aadir Despus de esto tendremos en nuestra ventana de fuentes (Sources) el componente decod2a4. Al importar decod2a4.sch se ha importado su esquemtico, pero no el smbolo que habamos creado para l. As que volvemos a crear el smbolo 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 esquemticos vaco (el plano de nuestro nuevo diseo), y veremos que en la ventan de fuentes tenemos dos diseos: el decod2a4 que acabamos de aadir y el nuevo decod3a8 que vamos a disear. Seleccionamos la pestaa de la ventana de smbolos, y vemos que en la seccin de categoras
Smbolos Smbolos del del proyecto proyecto
Smbolo Smbolo del del decodificador decodificador de de 2 2a a4 4
Decodificador Decodificador de de 2 2a a4 4
Figura 5.4: Implementacin del decodificador de 2 a 4 en el nuevo decodificador
28
5. Decodificador de 3 a 8 decod2a4,
En el mapa del circuito aadimos dos referencias a decodificador es para las 4 primeras salidas y el otro para el resto.
que como ya hemos dicho, un
Ahora realizamos las conexiones entre los decodificadores decod2a4 y las entradas y salidas del nuevo decodificador decod3a8. Incluyendo tambin las seales de habilitacin de cada uno de ellos, usando para ello puertas AND. Nota que para la habilitacin del decodificador
Figura 5.5: Esquema final del decodificador de 3 a 8 Fjate en lo rpido que lo has podido disear y lo simple del circuito, y compralo con lo que te hubiese supuesto haberlo hecho todo en puertas lgicas. Antes de pasar al siguiente paso, guarda el diseo (CTRL+S) y comprueba que el diseo es correcto (ToolsCheck 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: Conexin de los puertos del diseo con los pines de la FPGA Una vez implementado, comprueba que funciona correctamente y compralo con los valores de la tabla de verdad y la simulacin.
29
Y cmo haramos 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 A2 S0 S1 S2 S3 S4 S5 S6 S7 S8 S9 S10 S11 S12 S13 S14 S15 E 0 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 A3 X 0 0 0 0 0 0 0 0 1 1 1 1 1 1 1 1 A2 X 0 0 0 0 1 1 1 1 0 0 0 0 1 1 1 1 A1 X 0 0 1 1 0 0 1 1 0 0 1 1 0 0 1 1 A0 S15 S14 S13 S12 X 0 0 0 0 0 0 0 0 0 1 0 0 0 0 0 0 0 0 0 1 0 0 0 0 0 0 0 0 0 1 0 0 0 0 0 0 0 0 0 1 0 0 0 0 0 0 0 0 0 1 0 0 0 0 0 0 0 0 0 1 0 0 0 0 0 0 0 1 0 1 1 0 0 1 0 0 0 0 1 0 0 0 0 1 0 0 0 0 S11 S10 S9 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 1 0 1 0 1 0 0 0 0 0 0 0 0 0 0 0 0 0 0 S8 0 0 0 0 0 0 0 0 0 1 0 0 0 0 0 0 0 S7 0 0 0 0 0 0 0 0 1 0 0 0 0 0 0 0 0 S6 0 0 0 0 0 0 0 1 0 0 0 0 0 0 0 0 0 S5 0 0 0 0 0 0 1 0 0 0 0 0 0 0 0 0 0 S4 0 0 0 0 0 1 0 0 0 0 0 0 0 0 0 0 0 S3 0 0 0 0 1 0 0 0 0 0 0 0 0 0 0 0 0 S2 0 0 0 1 0 0 0 0 0 0 0 0 0 0 0 0 0 S1 0 0 1 0 0 0 0 0 0 0 0 0 0 0 0 0 0 S0 0 1 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0
decod 1
DECOD4a16
A3
decod 2 decod 3
decod 4
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 seales de salida se han agrupado de cuatro en cuatro. En la figura 6.2 se han separado estos grupos, ms 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 diseado. Todos los decodificadores tendrn las mismas entradas A1 y A0. La nica diferencia est en las salidas a las que se conecta cada decodificador y la habilitacin. Por ejemplo, el primer decodificador tendr como salidas S0, S1, S2 y S3 y slo estar habilitado cuando A3='0' y A2='0'; el segundo decodificador estar habilitado cuando A3='0' y A2='1'. Y de manera similar para el tercer y cuarto decodificador (como lo muestra la figura).
E 0 A3 A2 A1 A0 S15 S14 S13 S12 S11 S10 S9 S8 S7 S6 S5 S4 S3 S2 S1 S0 X X X X 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0
E = '0': Inhabilitado
todas '0'
E 1 1 1 1 A3 0 0 0 0 A2 0 0 0 0 A1 0 0 1 1 A0 S15 S14 S13 S12 S11 S10 S9 0 0 0 0 0 0 0 0 1 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 1 0 0 0 0 0 0 0 S8 0 0 0 0 S7 0 0 0 0 S6 0 0 0 0 S5 0 0 0 0 S4 0 0 0 0 S3 0 0 0 1 S2 0 0 1 0 S1 0 1 0 0 S0 1 0 0 0
decod 0 activo cuando

A3 = '0' A2 = '0'
A3 = '0' A2 = '0' E 1 1 1 1 A3 0 0 0 0 A2 1 1 1 1 A1 0 0 1 1
todas '0'
igual que decod2a4 para las entradas A1 y A0

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

A3 = '0' A2 = '1'
A3 = '0' A2 = '1' E 1 1 1 1 A3 1 1 1 1 A2 0 0 0 0 A1 0 0 1 1
todas '0'
A0 S15 S14 S13 S12 S11 S10 S9 0 0 0 0 0 0 0 0 1 0 0 0 0 0 0 1 0 0 0 0 0 0 1 0 1 0 0 0 0 1 0 0 S8 1 0 0 0
igual que decod2a4

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

A3 = '1' A2 = '0'
A3 = '1' A2 = '0' E 1 1 1 1 A3 1 1 1 1 A2 1 1 1 1 A1 0 0 1 1
todas '0'
igual que decod2a4

S8 0 0 0 0 S7 0 0 0 0 S6 0 0 0 0 S5 0 0 0 0
todas '0'
S4 0 0 0 0 S3 0 0 0 0 S2 0 0 0 0 S1 0 0 0 0 S0 0 0 0 0
A0 S15 S14 S13 S12 S11 S10 S9 0 0 0 0 1 0 0 0 1 0 0 1 0 0 0 0 0 0 1 0 0 0 0 0 0 1 0 0 0 0 0 0

A3 = '1' A2 = '1'
misma A2 = '1' secuencia
A3 = '1'
igual que decod2a4
todas '0'
Figura 6.2: Tabla de verdad del decodificador de 4 a 16 dividida segn el valor de E y de A3 y A2

As que usaremos cuatro decodificadores de 2 a 4 para las 16 salidas. Adems necesitaremos crear la lgica que se encargue de habilitar cada decodificador. Si nos fijamos en las seales A3 y A2 de la tabla de verdad, y de cmo habilitan a cada decodificador, podemos extraer la tabla de verdad de la figura 6.3. En ella se ponen las seales de habilitacin de cada decodificador (E3, E2, E1, E0) en funcin de la habilitacin 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 seales de habilitacin de los cuatro decodificadores usaremos otro decodificador de 2 a 4.
E 0 1 1 1 1 A3 X 0 0 1 1 A2 X 0 1 0 1 E3 0 0 0 0 1 E2 0 0 0 1 0 E1 0 0 1 0 0 E0 0 1 0 0 0 Ningn decodificador habilitado decodificador 0 habilitado decodificador 1 habilitado decodificador 2 habilitado decodificador 3 habilitado
Figura 6.3: Tabla de verdad de las seales de habilitacin de los 4 decodificadores Con estas indicaciones (adems de lo visto en clase) ya podemos disear el decodificador de 4 a 16.
6.1. Diseo del decodificador con bloques prediseados

Vamos a crear un nuevo proyecto en C:/practicas/edi/tunombre llamado sieteseg. Quizs 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 segmento s. Creamos una nueva fuente (ProjectNew Source) de tipo esquemtico (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 diseamos en el ejercicio 4 utilizaremos un decodificador disponible en la biblioteca de smbolos de Xilinx. Si no tenemos en pantalla el plano para dibujar el circuito (el editor de esquemticos) pinchamos dos veces en decod4a16.sch en la ventana de fuentes (Sources). Seleccionamos la ventana de smbolos 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 smbolos en la subventana de categoras (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 caractersticas del componente seleccionado, incluyendo su tabla de verdad, se pueden consultar pinchando el botn que dice Symbol Info. Si te fijas, hay ms componentes, incluso hay un decodificador de 4 a 16, pero no lo usaremos, ya que en tal caso, este ejercicio ya estara hecho.
31
Figura 6.4: Seleccin 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 diseo final se muestra en la figura 6.5. Observa la seal de habilitacin 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: Diseo final del decodificador de 4 a 16 Una vez que lo hayas realizado, grbalo y comprueba que todo est bien conectado (ToolsCheck Schematic). Date cuenta de lo rpido que se puede disear usando bloques y lo tedioso que hubiese sido realizar este decodificador enteramente con puertas lgicas.
32
Ahora crearemos el smbolo de este decodificador para poder utilizarlo en el ejercicio siguiente. Recuerda el apartado 4.4, en donde se explicaba la creacin de un smbolo (o bloque): Pinchar en ToolsSymbol Wizard Aparecer una ventana (figura 4.10) que nos preguntar para qu componente vamos a crear un smbolo: seleccionamos Using Schematic y quedar seleccionado el nico que hay decod4a16. La ventana de los pines la dejamos como est, ya Figura 6.6: Smbolo del decodificador que aunque la disposicin de los pines parece de 4 a 16 desordenada, en la columna Order estn bien, pinchamos en Next. Y terminamos pinchando en Finish. En la placa slo tenemos 8 LED disponibles para usar, y sin embargo nuestro decodificador tiene 16 salidas. As que no lo podemos probar fcilmente. En el siguiente ejercicio lo podremos probar, pero antes podemos simularlo. Procedemos como en el apartado 3.2, que lo recordaremos esquemticamente: Seleccionamos en la ventana de fuentes (Sources) la opcin 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 diseo 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 BenchSet End of Test Bench" y ponemos 3000 ns. Esto lo hacemos para realizar un banco de pruebas ms
largo (vers que se ampla el tiempo del banco de pruebas). Ahora introducimos las 16 posibles combinaciones para las
inhabilitado
2 3 4
6 7 8 9 10 11 12 13 14 15 0 1
inhabilitado
Figura 6.7: Valores introducidos en el cronograma para la simulacin 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 simulacin saldr sloque para 1000 ns, como nuestro banco pruebas lo queremos 3000 ns, le indicaremos simule el tiempo restante. Para de ello ejecutamos dos veces para el comando "SimulationRun For Specified Time". El tiempo especificado por defecto para la simulacin son 1000 ns. Este tiempo se puede modificar (figura 6.8) y adems, como se muestra en la figura, existe un botn para ejecutar la simulacin. Finalmente comprobamos si los valores a las salidas son correctos.
33
Tiempo de simulacin 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 simulacin, se puede observar cmo se van activando las salidas consecutivamente mientras la seal de habilitacin (E) est a uno. Cuando sta vale 0, no hay ninguna salida activa.
Figura 6.9: Resultado de la simulacin En el siguiente ejercicio usaremos el decodificador para un diseo que implementaremos en la placa.
34
7. Convertidor de hexadecimal a 7 segmentos

En los ejercicios de los decodificadores tenamos un nmero codificado en los interruptores de la placa y lo decodificbamos mostrndolo en los LED. Ahora queremos mostrar un nmero hexadecimal (4 bits) en un visualizador o display de siete segmentos. Antes de empezar a disear el circuito veamos cmo funcionan los displays de siete segmentos. Un display de siete segmentos permite iluminar 7 segmentos (y a veces tambin el punto decimal) de manera independiente, de forma que se pueden representar todos los nmeros y algunas letras y smbolos. Los segmentos del display se nombran como muestra la figura 7.1. Segn qu segmentos estn encendidos, se mostrarn diferentes nmeros. Por ejemplo, para el nmero 1 debern
A F E G D B C DP
Figura 7.1: Display de 7 segmentos
A continuacin se muestra la codificacin de los 16 nmeros hexadecimales (figura 7.2), como podrs podra no tener el segmento A iluminado (pero se confundira con la B). El 9 podra tener el segmento D iluminado. La A, la C y la E se podran representar en minsculas. Puedes ver muchas otras representaciones en http://en.wikipedia.org/wiki/Seven-segment_display. Nosotros,A usaremos A la de la figura 7.2. A A A A A A
F E
G D
B C
F E
G D
B C
F E
G D
B C
F E
G D
B C
F E
G D
B C
F E
G D
B C
F E
G D
B C
F E
G D
B C
A F E G D B C
A F E G D B C
A F E G D B C
A F E G D B C
A F E G D B C
A F E G D B C
A F E G D B C
A F E G D B C
Figura 7.2: Codificacin de los segmentos para mostrar los 16 nmeros hexadecimales Existen tambin otros visualizadores de 14 16 segmentos, para poder representar todos los caracteres alfanumricos. Tambin se usan las matrices de puntos que tienen distintas resoluciones. En nuestra placa, para activar el display de la derecha, debemos poner la seal AN_0='0'. El pin correspondiente de la FPGA es el P60, como puedes ver en la placa encima de donde estn los displays. En la placa tambin se muestran los pines correspondientes a cada segmento, para encender un segmento tenemos que poner su pin correspondiente a cero. Funcionan por tanto con lgica negada. Cuando no quieres que se encienda un display tendrs que poner un uno, por ejemplo en los pines de las seales AN_1, AN_2 y AN_3, correspondientes a los otros tres displays. As, para representar el uno, tendras que poner los segmentos B y C a cero y el resto a uno, poniendo tambin la seal AN_0=0. Con esta informacin ya podemos hacer el diseo, ms adelante, en otros ejercicios, veremos las conexiones elctricas y cmo encender varios displays.
7.1. Diseo del convertidor de hexadecimal a 7 segmentos

El objetivo es mostrar en un display el nmero hexadecimal codificado en los cuatro interruptores de la derecha (SW0, SW1, SW2 y SW3), ya que con cuatro bits podemos formar 16
35
HEX7SEG I0 Nmero codificado:

A los interruptores: SW0, SW1, SW2, SW3 SEG_A SEG_B SEG_C SEG_D SEG_E SEG_F SEG_G SEG_DT AN_0 AN_1 AN_2 AN_3
I1 I2 I3
Salida a los 7 segmentos
Punto decimal del display Encendido de los displays AN0: display de la derecha
Habilitacin:
Figura 7.3: Diagrama de entradas y salidas del convertidor hexadecimal a 7segmentos Ya hemos visto en clase cmo se disea el circuito que convierte de BCD a 7 segmentos. Ahora tenemos que modificar la tabla de verdad para que incluya las salidas de los nmeros del 10 (A16) al 15 (F16), ya que en BCD para ellos ponamos 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 nmeros 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 ests entendiendo nada. Para implementar el circuito podramos realizar el mapa de Karnaugh para cada uno de los 7 segmentos y obtener la funcin lgica. Este mtodo es perfectamente vlido 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 0 1 2 3 4 5 6 7 8 9 A B C D E F I3 0 0 0 0 0 0 0 0 1 1 1 1 1 1 1 1 I2 0 0 0 0 1 1 1 1 0 0 0 0 1 1 1 1 I1 0 0 1 1 0 0 1 1 0 0 1 1 0 0 1 1 I0 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 0 A 0 1 0 0 1 0 0 0 0 0 0 1 0 1 0 0 B 0 0 0 0 0 1 1 0 0 0 0 1 1 0 1 1 C 0 0 1 0 0 0 0 0 0 0 0 0 1 0 1 1 D 0 1 0 0 1 0 0 1 0 1 1 0 0 0 0 1 E F G
ojo esto son nmeros 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 mtodo. Hemos visto en clase que mediante decodificadores se pueden implementar funciones lgicas. Normalmente no es un mtodo muy eficiente en puertas, es decir, si realizamos la funcin lgica a partir del mapa de Karnaugh suelen salir muchas menos puertas que hacindolo con decodificadores. Esto se debe a que el decodificador obtiene todos los trminos mnimos, sean o no necesarios para la ecuacin, y adems, al hacerlo con los trminos mnimos, se implementa la ecuacin en la primera forma normal (1FN), sta suele ser de bastante mayor tamao que la ecuacin obtenida por Karnaugh. Esto ltimo lo has podido comprobar si hiciste el primer ejercicio propuesto del tema 3 5. Sin embargo, cuando necesitamos obtener varias funciones lgicas a partir de un mismo grupo de entradas (como es el caso) el uso de decodificadores no es tan descabellado, ya que un trmino mnimo puede ser utilizado en varias salidas. Es decir, en nuestro caso necesitamos siete funciones lgicas, una para cada segmento, y por tanto un trmino mnimo puede ser usado en varias funciones. Adems, ya tenemos el decodificador implementado y encima disponemos de una FPGA con 50000 200000 puertas equivalentes, por lo que excedernos en
http://laimbio08.escet.urjc.es/assets/files/docencia/EDI/pbs3_02.pdf
Quizs ahora ests intentando recordar de clase cmo se diseaban funciones lgicas con decodificadores. Bueno, es muy fcil, simplemente tenemos que unir con una puerta OR todos los trminos mnimos de la funcin. Por ejemplo, la salida A del display es la OR de los trminos mnimos 1, 4, 11 y 13 (m1, m4, m11, m13). Mira la figura 7.5, en ella se han tomado estas salidas para crear la funcin que implementa el segmento A.
I3 0 0 0 0 0 0 0 0 1 1 1 1 1 1 1 1 I2 0 0 0 0 1 1 1 1 0 0 0 0 1 1 1 1 I1 0 0 1 1 0 0 1 1 0 0 1 1 0 0 1 1 I0 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 0 A 0 1 0 0 1 0 0 0 0 0 0 1 0 1 0 0
I0 I1
m1 m4
I2 I3 E
A0 A1 A2 A3 E
m11 m13
S0 S0 S1 S1 S2 S2 S3 S3 S4 S4 S5 S6 S7 S8 S9 S10 S11 S12 S13 S14 S15
SEG_A
Figura 7.5: Implementacin de la funcin para activar el segmento A Esto adems 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 nmeros 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 lgica negada, y por eso decimos "no lucir". Otra alternativa sera haberlo hecho con lgica afirmada (sin negar). Entonces cada uno de los 7 segmentos estaran complementados. Para obtener la salida negada se tomaran los trminos mnimos complementarios, y habra que negar la OR (sera una NOR). La figura 7.6 muestra las dos formas equivalentes de realizar el circuito para el segmento A.
Lgica negada:
nmeros que hacen "No lucir" el segmento A I3 0 0 0 0 0 0 0 0 1 1 1 1 1 1 1 1 I2 0 0 0 0 1 1 1 1 0 0 0 0 1 1 1 1 I1 0 0 1 1 0 0 1 1 0 0 1 1 0 0 1 1 I0 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 0 A 0 1 0 0 1 0 0 0 0 0 0 1 0 1 0 0
Lgica afirmada:
nmeros que hacen "lucir" el segmento A SEGA I3 0 0 0 0 0 0 0 0 1 1 1 1 1 1 1 1 I2 0 0 0 0 1 1 1 1 0 0 0 0 1 1 1 1 I1 0 0 1 1 0 0 1 1 0 0 1 1 0 0 1 1 I0 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 0 A 1 0 1 1 0 1 1 1 1 1 1 0 1 0 1 1
m1 m4
m1 m4 m11 m13
m0 m2 m3 m5 m6 m7 m8 m9 m10 m12 m14 m15
Los nmeros 1, 4, B y D pondrn un 1 en la salida, y por tanto, no lucir el segmento A. El resto pondr un 0 y lucir
1 m11 m13 B 11
E
A F GG D C B
4
E
A F G D B C
m0 m2 m3 m5 m7 m8 m9 m10 m12 m14 m15
SEGA
A F E G D B C
D 13
A F E G D B C
Negar la salida para que los nmeros que hacen lucir el segmeno A pongan un cero
Figura 7.6: Formas equivalentes de realizar el circuito: a la izquierda con lgica negada. A la derecha, con lgica 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 trminos mnimos (tambin lo podramos hacer de la manera en que muestra en la derecha de la figura 7.6). Empecemos a disearlo, nos mantenemos en el mismo proyecto que en el anterior. Primero, como venimos de la simulacin, seleccionamos en la ventana de fuentes (Sources) la opcin de Synthesis Implementation. Ahora creamos una nueva fuente de tipo esquemtico llamada hex7seg. Tenemos la ventana de opciones y de smbolos activas.
En la ventana de smbolos, en la subventana de categoras (Categories) escogemos la primera de ellas que hace referencia a nuestro proyecto (C:/practicas/edi/...). Y en la ventana de smbolos estar el decodificador de 4 a 16 que creamos en el ejercicio anterior. Incluimos una referencia a este smbolo en nuestro nuevo diseo, y realizamos las conexiones del decodificador con las salidas al display segn la tabla de verdad de la figura 7.4 y el ejemplo de la figura 7.5. Conecta tambin las 4 entradas del decodificador, llmalas I0, I1, I2, I3. Y la habilitacin E. Quizs veas que si sigues conectando cables a las siete puertas OR que tienes que incluir, se va enmaraar todo el circuito. Para evitar esto, una mejor opcin es nombrar los cables, ya que si dos cables tienen el mismo nombre, aunque no estn unidos se consideran como el mismo cable. Vemoslo para el segmento B. Segn la tabla de verdad de la figura 7.4, el segmento B no luce para los nmeros 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
S0 S1 S2 S3 S4 S5 S6 S7 S8 S9 S10 S11 S12 S13 S14 S15 SEG_B SEG_B
Figura 7.7: Paso 1, ponemos la puerta OR de 6 entradas
Figura 7.8: Paso 2, conectamos un cable pequeo a la salida S5 del decodificador y a una entrada de la puerta OR
Ahora pinchamos en "AddNet Name" y en la ventana de opciones rellenamos en el apartado Name el nombre m5, ya que vamos a poner el trmino mnimo m5. A continuacin pinchamos en el esquemtico cerca de los cables que hemos puesto (figura 7.9). Por ltimo, repetimos la operacin 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 trmino mnimo, y nombramos una pata de la OR con un trmino mnimo equivocado, tendremos que borrar
38
Figura 7.9: Paso 3, nombramos ambos cables con el mismo nombre Figura 7.10: Paso 4, repetimos la operacin con el resto de entradas As que tienes dos mtodos para realizar las conexiones del circuito: unir cables o nombrarlos, puedes combinarlos o usar el que ms te guste, aunque para este ejemplo, si conectas todos los cables va a resultar un circuito muy poco claro, y difcil 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 seal AN_0 recuerda que estacuando seal es un pin va al display de la derecha. Cuando AN_0=0 el segmento encendido) AN0=1 el que display estar independientemente de que apagado tengas los segmentos encendidos. Lo que vamos a hacer es encender el display cuando el circuito est habilitado (E). Como la seal de habilitacin es a nivel alto y la seal AN_0 es a nivel bajo, tendrs que conectarlas con un inversor. Es fcil, pero si no se te ocurre cmo hacerlo observa la figura 7.11. Por ltimo conectars 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) cmo se conectaba una salida a un uno lgico. Si no se te ocurre cmo hacerlo puedes mirar la figura 7.11. Tambin debers 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 alimentacin (Vcc), exactamente igual que el las seales (AN_1, AN_2, AN_3)
En este punto deberas tener todo el circuito diseado. Grbalo y comprueba que el esquemtico est bien conectado Esta vez, en vez de simular el circuito vamos a implementarlo directamente, ya que la funcionalidad del circuito es muy fcilmente comprobable en la placa, pues slo 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 vers una imagen similar a la de la figura 7.12. En ella puedes apreciar que de los dos el , que significa que es el diseo de ms alta jerarqua. Si no estuviese tendras que smbolo pinchar el botn derecho del con ratn encima de l y seleccionar "Set as Top Module".
Figura 7.11: Detalle de la conexin de las seales AN_0 y AN_1
Convertidor HEX a 7SEG diseo de mayor jerarqua : Smbolo que indica el componente de mayor jerarqua
El decodificador es un componente del convertidor
Figura 7.12: Representacin de la jerarqua 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 seleccionbamos el comando "User ConstraintsAssign Package Pins". Sin embargo a veces hay un error y salen unos puertos que no son los que tienes en tu diseo. En la figura 7.13 se muestran los pines que salan al hacer este ejercicio
Figura 7.13: Ventana de puertos errnea 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 extensin .UCF. Y lo puedes editar con cualquier editor de texto o desde la propia herramienta ISE. En la ventana de procesos, dentro de "User Constraints", dos comandos por debajo del que acabamos de usar para arrancar el PACE est el comando: "Edit Constraints (Text)", pincha dos veces en l y te saldr un editor de texto en la ventana grande de la derecha (ver figura 7.14).
Aqu se escriben las restricciones
Edit Constraints (Text) Fichero Fichero de de restricciones restricciones .ucf .ucf Figura 7.14: Edicin 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 cdigo 7.1. El formato de estos ficheros es muy sencillo: Los comentarios se consideran a partir del signo # Cada puerto de nuestro diseo se conecta con la lnea:
NET "Nombre_del_Puerto" LOC = "Nombre_del_Pin"
Con estas indicaciones, y tras identificar los pines en la placa, ya la podras hacer t solo. Sin embargo, por ser la primera vez, a continuacin se muestra el contenido del fichero. An entende el as, intenta r significado, ya que para las siguientes ocasiones tendrs que escribirlo t solo. #Numero codificado en los interruptores SW0, SW1, SW2, SW3
NET NET NET NET "I0" "I1" "I2" "I3" LOC LOC LOC LOC = = = = "P89" ; "P88" ; "P87" ; "P86" ; ;
#Enable en el SW7 NET "E" LOC = "P81" #Encendido de los NET "AN_0" LOC = NET "AN_1" LOC = NET "AN_2" LOC = NET "AN_3" LOC = #7 segmentos NET "SEG_A" NET "SEG_B" NET "SEG_C" NET "SEG_D" NET "SEG_E" NET "SEG_F" NET "SEG_G" LOC LOC LOC LOC LOC LOC LOC
displays "P60" ; "P69" ; "P71" ; "P75" ; "P74" ; "P70" ; "P67" ; "P62" ; "P61" ; "P73" ; "P68" ; ;
= = = = = = =
#Punto decimal NET "SEG_DT" LOC = "P63"
Cdigo 7.1: Conexin de los puertos del diseo 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 diseo. El cdigo 7.1 est hecho para los nombres de la figura 7.3. Si por descuido has puesto otros nombres en el diseo, o bien cambias los nombres del diseo, o cambias el UCF. Guarda el fichero UCF una vez que lo hayas terminado. Sintetiza el diseo, y posteriormente implemntalo. Esto ese haca desde la ventana de procesos, "Synthesize- XST", "Implement Design". Observa si hay algn error, sobre todo despus de la implementacin. Si te has equivocado al nombrar los puertos te saldr un mensaje diciendo qu puerto falta, si es as, corrige el UCF o el esquemtico 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 nmeros segn estn los interruptores del cero al tres. Si ves que algn nmero no se visualiza correctamente, identifica qu segmento est mal y revisa el esquemtico. Comprueba tambin que la habilitacin funciona.
41
8. Codificadores
8. Codificadores
En esta prctica realizaremos varios codificadores. Primero haremos un codificador de 4 a 2. En un principio lo haremos sin prioridad y luego incluiremos un mdulo que establezca las prioridades. Posteriormente, en el captulo 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 prctica el codificador tendr 4 entradas y devolver en formato binario la entrada que est activa. En un principio realizaremos la versin ms 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 permanecern apagados, ya que mostrarn un cero en binario (002). Cuando est la entrada I1 activa, se encender el LED0 mostrando un uno en binario (012). De anloga sucede con los dos casos
CODIF BTN0 BTN1 BTN2 BTN3 I0 I1 I2 I3 entrada activa I0 I1 I2 I3 salidas S1 S0 0 0 0 1 1 0 1 1 S0 se enciende cuando I1 est activa o (OR) cuando I3 est activa S1 se enciende cuando I2 est activa o (OR) cuando I3 est activa I1 I2 I3 S0 S1
S0 S1
LED0 LED1
Figura 8.1: Entradas y salidas del codificador, tabla de verdad y obtencin del esquema en puertas lgicas La realizacin 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 bjalo a la FPGA. Como puedes ver, la entrada I0 no est conectada en el esquema de puertas, por lo tanto, no hace falta que la crees ni que le asignes pines. Ahora debes comprobar que funciona bien. Qu debe suceder? Est mostrado para algunos casos en la figura 8.2.
Entrada activa (pulsador) LEDs encendidos y codificacin ninguna LD1 00 LD0 00 BTN0 LD1 LD0 01 BTN1 LD1 LD0 10 BTN2 LD1 LD0 11 BTN3 LD1 LD0 11 BTN1 y BTN2 LD1 LD0
Figura 8.2: Salidas del circuito codificador segn las entradas Cuando pulsamos el pulsador BTN0 no se enciende ningn 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 ningn botn pulsado. As que con este circuito, no podemos distinguir entre el caso en que no hay ningn botn pulsado y el caso en que el botn 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 simultneamente. As que tenemos que solucionar dos cosas: Definir las prioridades para que slo est una lnea activa Diferenciar cundo est la lnea del BTN0 activa de cuando no hay ninguna lnea activa.
8.2. Codificador de 4 a 2 con prioridad, lnea activa y habilitacin

As que ampliaremos el codificador de modo que con una seal de salida (A) indiquemos si hay algn botn pulsado. As podremos distinguir el botn cero con la situacin en la que no hay
Departamento de Tecnologa Electrnica entrada activa -I0 I1 I2 I3 salidas S1 S0 0 0 0 0 0 1 1 0 1 1 I1 A 0 1 1 1 1 Diferencia entre pulsar I0 y no pulsar nada A se enciende cuando cualquier entrada est activa: I0 + I1 + I2 + I3 I2 I3 S0 S1
8. Codificadores
I0
Figura 8.3: Esquema del codificador que incluye la seal A, que indica si hay algn lnea de entrada activa Si quieres puedes bajar a la placa este circuito, poniendo la seal LED 7 o continua A como el bien r realizando las modificaciones que queremos realizar. Llama al proyecto PRIOR CODIF Ahora queremos incluir un mdulo que determine las I0 P0 BTN0 P0 S0 S0 I1 BTN1 prioridades, de manera que, aunque dos P1 P1 SA S1 BTN2 botones estn pulsados, slo una lnea de I2 P2 P2 A A entrada del decodificador est activa. BTN3 I3 P3 P3 Pondremos la prioridad ms alta para el bit ms significativo, de modo que si I2 e I1 puede haber ms de como mximo slo habr estuviesen pulsados, el codificador mostrase un una que valga 1 una seal que valga 1 102 y no un 112 como estaba haciendo hasta ahora (recuerda el caso de la derecha de la Figura 8.4: Bloque de prioridades previo al codificador Cmo hacemos un mdulo 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 seal prioritaria pasar directamente y la seales menos prioritarias dependern 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
Si I3='1' entonces P2='0' I2 '0' '1' "no deja pasar I2" '0' P2 Si I3='1' entonces P2=I2 I2 I2 '1' '0' "deja pasar I2" P2
I3
P3
I3
'0'
P3
Figura 8.5: Prioridad de I3 sobre I2 As que se puede aplicar la misma estrategia para el resto de seales, quedando como muestra la figura 8.6. En la derecha de la figura se muestra la tabla de verdad del circuito.
I0 P0 P0 slo podr valer '1' cuando no sean '1' ni I3, ni I2, ni I1 P1 slo 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' (segn lo que valga I3)
I1
P1
I2
P2
I3 0 0 0 0 1
I2 0 0 0 1 X
I1 0 0 1 X X
I0 0 1 X X X
P3 0 0 0 0 1
P2 0 0 0 1 0
P1 0 0 1 0 0
P0 0 1 0 0 0
independientemente de lo que valga I0, P0 = '0' porque I3='1'
I3
P3
Figura 8.6: Circuito para establecer prioridades y su tabla de verdad Para simplificar la tabla de verdad se han puesto X en las seales 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
8. Codificadores
circuito ms sencillo debido a que ese caso nunca se va a dar. Esta libertad no la tengo con las X en las entrada s. Para terminar nos quedara unir los mdulos tal como se muestra en la figura 8.4, sin embargo, antes vamos a incluir la seal de habilitacin (Enable). Cuando la seal de habilitacin vale cero (Enable='0') hace que todas las salidas valgan '0'. Si est habilitado, el circuito funciona normalmente. Adems, los codificadores con habilitacin incluyen una nueva seal de salida (EO: enable out), que nos permitir conectar varios codificadores y extender su capacidad. Esta seal nos indica si EI el I3 codificador habilitado pero no hay I2 I1 I0 est S1 S0 A EO CODIF
BTN0 BTN1 BTN2 BTN3 SW7 I0 I1 I2 I3 EI EO LED7 S0 S1 A LED0 LED1 LED6
0 1 1 1 1 1
X 0 0 0 0 1
X 0 0 0 1 X
X 0 0 1 X X
X 0 1 X X X
0 0 0 0 1 1
0 0 0 1 0 1
0 0 1 1 1 1
0 1 0 0 0 0
Figura 8.7: Bloque y tabla de verdad del codificador con prioridad y habilitacin 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 condicin nos debera ser fcil de implementar en puertas lgicas. El circuito final nos quedar como muestra la figura 8.8.
PRIOR I0 P0 A I1 P1 S0 I2 P2 S1 I3 P3 EO
EI
Figura 8.8: Esquema en puertas del codificador con prioridad y habilitacin Implementa este diseo 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 conversin a 7 segmentos

Por ltimo se deja como ejercicio conectar el codificador que acabamos de disear (figura 8.8) con el conversor a siete segmentos que hemos realizado en el captulo 7. As, adems de ver el nmero resultante codificado con los LED, lo veremos en el display de siete segmentos. Para ello, que primero crea el el smbolo del Tools codificador acabas de crear de la figura Recuerda se haca con comando: Symbol que Wizard (se explic en el(el apartado 4.4). 8.8). Ahora vamos a aadir el conversor a 7 segmentos que realizamos en el captulo 7. Para ello, ejecutamos "ProyectAdd Copy of Source..." y vamos al directorio donde hicimos el conversor, que debera ser " c:/practicas/edi/tunombre/sieteseg/" y all seleccionas los ficheros: "hex7seg.sch" y " decod4a16.sch". Ahora creamos un smbolo del esquemtico hex7seg.shc, para ello ejecutamos Tools Symbol Wizard y en la siguiente ventana, en el apartado Using Schematic seleccionamos el mdulo hex7seg. Esto es importante porque si no estaramos haciendo el smbolo de otro mdulo. 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 seal por seal, el orden que le asignamos (como puedes ver no es muy cmo el mtodo de ordenamiento). Ahora crea una nueva fuente "Proyect New Source" de tipo esquemtico llamada codif4a2_7seg
8. Codificadores
seleccionamos la categora de nuestro proyecto (la 2 fila donde sale la ruta de nuestro proyecto). En la subventana de Symbols estarn los tres smbolos de nuestro proyecto: codif4a2, decod4a16 y hex7seg. El smbolo decod4a16 est dentro del hex7seg y por eso aparece. Nosotros usaremos el codif4a2 y el hex7seg. La conexin de los circuitos se hara como muestra la figura 8.9. Como el codificador es de 4 a 2, tiene dos salidas para indicar el nmero (S0 y S1), el resto de entradas del conversor a 7 segmentos (I2 e I3) irn a tierra (a cero), para que los nmero que muestre sean del 0 al 3. Si estuviesen las dos a '1', mostrara los nmeros del 12 a 15. Y si no las pusieses a ningn valor, tendras un valor indeterminado en las entradas del decodificador, y quin sabe que nmero te saldra. Esto es: Las entradas siempre deben
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 figura 8.9) con los pines de la esquema ( FPGA. Para no tener que hacer de nuevo todo el fichero de restricciones, puedes abrir el que ya tenas del conversor de 7 segmentos (cdigo 7.1) y copiar y pegar en el que vas a crear. Una vez queYlo tengas en lafuncionan placa, comprueba que funciona, que se se encienden los LED y segmentos. que tambin correctamente las (Enable Out), que usaremos salidas A y EO en el siguiente ejercicio.
45
9. Extensin de la capacidad de un codificador

En este ejercicio usaremos el codificador de 4 a 2 que hemos realizado en la prctica anterior (captulo 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 funcin de codificadores de 4 a 2.
SW4 SW5 SW6 SW7 BTN0 BTN1 BTN2 BTN3 SW0 I0 I1 I2 I3 I4 I5 I6 I7 EI CODIF EO S0 S1 S2 A A LED7 LED0 LED1 LED2 LED6
EI 0 1 1 1 1 1 1 1 1 1
I7 X 0 0 0 0 0 0 0 0 1
I6 X 0 0 0 0 0 0 0 1 X
I5 X 0 0 0 0 0 0 1 X X
I4 X 0 0 0 0 0 1 X X X
I3 X 0 0 0 0 1 X X X X
I2 X 0 0 0 1 X X X X X
I1 X 0 0 1 X X X X X X
I0 X 0 1 X X X X X X X
S2 0 0 0 0 0 0 1 1 1 1
S1 0 0 0 0 1 1 0 0 1 1
S0 0 0 0 1 0 1 0 1 0 1
A EO 0 0 0 1 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0
Figura 9.1: Entradas y salidas del codificador, y su tabla de verdad La extensin de un codificador se realiza como se muestra en la figura 9.2. En la extensin, 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 pequeo), y el segundo los ms significativos (G de grande). Para obtener la seal S2 basta con tomar la seal A (activo) del codificador de los bits ms significativos (G_CODIF). La A del codificador de 8 a 3 se obtiene realizando la OR de las seales de Activo de los codificadores de 4 a 2, ya que estar activo si cualquiera de ellos est activo.
CODIF8a3 P_CODIF SW4 SW5 SW6 SW7 I0 I1 I2 I3 I0 I0 I1 I1 I2 I3 I3 EI EO S0 S1 S1 A S0 S1 EO S0 S1 S1 A A A LED0 LED1 LED7
G_CODIF BTN0 BTN1 BTN2 BTN3 SW0 I4 I5 I6 I7 I7 EI I0 I0 I1 I1 I2 I3 I3 EI
S2
LED2
LED6
Figura 9.2: Extensin de un codificador Para facilitar la comprensin del diseo, la figura 9.3 incluye la tabla de verdad del codificador de 8 a 3 incluyendo las seales internas que entran y salen en los codificadores de 4 a 2. Como se puede apreciar, cuando alguna de las seales de I4 a I7 est activa, el codificador P_CODIF estar deshabilitado, y la salida S2 se pondr a 1. Cuando ninguna seal de I4 a I7 est activa, se habilita el codificador P_CODIF y la salida S2 estar inactiva.
46

Seales internas de los codificadores de 4 a 2 ENTRADAS G_CODIF P_CODIF EI EI 0 1 1 1 1 1 1 1 1 1 I3 I7 X 0 0 0 0 0 0 0 0 1 I2 I6 X 0 0 0 0 0 0 0 1 X I1 I5 X 0 0 0 0 0 0 1 X X I0 I4 X 0 0 0 0 0 1 X X X EI I3 I3 0 X 1 0 1 0 1 0 1 0 1 1 0 X 0 X 0 X 0 X I2 I2 X 0 0 0 1 X X X X X I1 I1 X 0 0 1 X X X X X X G_CODIF I0 S1 S0 I0 X 0 0 0 0 0 1 0 0 X 0 0 X 0 0 X 0 0 X 0 0 X 0 1 X 1 0 X 1 1 A EO 0 0 0 0 0 0 1 1 1 1 0 1 1 1 1 1 0 0 0 0 SALIDAS P_CODIF S1 S0 A EO 0 0 0 0 1 1 0 0 0 0 0 0 0 1 0 1 0 0 0 0 0 0 1 1 1 1 0 0 0 0 0 1 0 0 0 0 0 0 0 0 S2 0 0 0 0 0 0 1 1 1 1 S1 0 0 0 0 1 1 0 0 1 1 S0 0 0 0 1 0 1 0 1 0 1 A EO 0 0 0 1 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 CODIF8a3
Seales externas (puertos) del codificador de 8 a 3
ninguna entrada de G_CODIF activa habilita a P_CODIF alguna entrada de G_CODIF activa deshabilita a P_CODIF
S1 y S2 del CODIF8a3 lo proporciona P_CODIF S1 y S2 del CODIF8a3 lo proporciona G_CODIF
La salida EO del codificador G_CODIF entra como habilitacin (EI) del P_CODIF
P_CODIF deshabilitado
Figura 9.3: Tabla de verdad del codificador de 8 a 3 con las seales internas Ahora implementa en la placa el diseo de la figura 9.3: Crea un nuevo proyecto llamado CODIF8a3 Aade una copia del codificador de 4 a 2 que creaste en la prctica anterior (captulo 8): "ProyectAdd Copy of Source..." y busca el "c:/practicas/edi/tunombre/codif4a2/codif4a2.sch" Crea un smbolo de este codificador: ToolsSymbol Wizard Crea una nueva fuente de tipo esquemtico llamada codif8a3 (ProyectNew 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. Inclusin 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 tendrs que aadir el convertidor a siete segmentos y crear un smbolo 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 habamos hecho anteriormente (figura 8.9). La mayor
Figura 9.4: Esquema del circuito final
9.3. Codificador mayores

Se deja como ejercicio realizar un codificador de 12 entradas codificadores de 4 a 2. Para ello las 12 entradas sern los interruptores (no uses un interruptor como habilitacin permanentemente). Normalmente estos codificadores son de 16 a 4, porque no tenemos ms pulsadores ni interruptores en la placa.
a 4 salidas a partir de 4 pulsadores y los 8 sino que lo dejas a '1' pero lo haremos de 12 a 4
47
10. Comparadores
10. Comparadores
Ya hemos aprendido a realizar varios diseos: puertas lgicas, decodificadores, codificadores y un convertidor de hexadecimal a siete segmentos. Ahora vamos a hacer un comparador, primero lo haremos de un slo 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 nmeros de un bit. Realizar esta comparacin es fcil, simplemente tenemos que construir la tabla de verdad y obtener las ecuaciones lgicas. En la figura 10.1 se muestra esta tabla de verdad y la obtencin de sus ecuaciones lgicas. Se ha llamado A=B A>B A<B AM a la seal que indica que A es mayor (A>B) y BM a la seal
A 0 0 1 1 B 0 1 0 1
IGUAL
1 0 0 1
AM 0 0 1 0
BM 0 1 0 0
COMPA1
BM = m1 = AB
A B
IGUAL AM BM
AM = m2 = AB IGUAL=(AB)+(AB)=AB
Figura 10.1: Tabla de verdad, ecuaciones lgicas, y entradas y salidas del comparador de un bit El diseo de este circuito es bien fcil, slo 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, aade las puertas lgicas, recuerda que tienes puertas AND con una entrada negada para implementar la funcin A B y A B (estas se llaman and2b1 y tienen una bolita de negacin en una de sus entradas). Tambin tienes funciones XNOR para implementar la salida IGUAL. Si el diseo 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 pondrs P89. Y por fin implementa el comparador y comprueba que funciona bien.
A B AM IGUAL BM SW0 SW1 LD0 LD1 LD2
Tabla 10.1: Tabla de asignacin de seales
10.2. Comparador de dos bits

Un comparador de un solo bit es bastante fcil ya que slo tenemos 4 posibles combinaciones. Para uno de dos bits hay que pensrselo un poco ms. El bloque que queremos implementar se muestra en la figura 10.2. A partir de dos seales de 2 bits, queremos saber si son iguales, o si una es mayor que la otra. Como son seales de dos bits tenemos que saber cul es el bit ms significativo. Recuerda que no es lo mismo 102 que 012. A pesar de que tienen el mismo nmero de unos y ceros, el orden en que estn situados determina la diferenci a. Por lo tanto tenemos que diferenciar cul es el bit ms 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 seal. Sin embargo, para evitar tener que poner un cable para cada bit, se puede representar como
48
10. Comparadores
COMPA2
bit ms significativo
COMPA2 A(1:0)
IGUAL AM BM
2 2
A0 A1 B0 B1
bit ms significativo
IGUAL AM BM
B(1:0)
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 podramos hacer igual que el cuarto ejercicio de los propuestos del tema 3. Como tenemos cuatro variables es un nmero 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
A1 0 0 0 0 0 0 0 0 1 1 1 1 1 1 1 1 A0 0 0 0 0 1 1 1 1 0 0 0 0 1 1 1 1 B1 0 0 1 1 0 0 1 1 0 0 1 1 0 0 1 1 B0 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 1 0 0 0 0 1 0 0 0 0 1 0 0 0 0 1
IGUAL
AM 0 0 0 0 1 0 0 0 1 1 0 0 1 1 1 0
BM 0 1 1 1 0 0 1 1 0 0 0 1 0 0 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 ms significativos. Ya que el bit ms significativo "manda" sobre el menos significativo, esto se aprecia mejor en la tabla de la figura 10.3.
MSB A1 0 0 0 0 0 0 0 0 1 1 1 1 1 1 1 1 B1 0 0 0 0 1 1 1 1 0 0 0 0 1 1 1 1 LSB A0 0 0 1 1 0 0 1 1 0 0 1 1 0 0 1 1 B0 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1
IGUAL
1 0 0 1 0 0 0 0 0 0 0 0 1 0 0 1
AM 0 0 1 0 0 0 0 0 1 1 1 1 0 0 1 0
BM 0 1 0 0 1 1 1 1 0 0 0 0 0 1 0 0
A1=B1
comprobar el LSB
A1<B1
Igual=0 AM=0 BM=1 Igual=0 AM=1 BM=0 comprobar el LSB
A1>B1
A1=B1
Figura 10.3: Tabla de verdad del comparador de dos bits ordenada desde los bits ms significativos a los menos Fjate en la tabla de verdad de la figura 10.3: Cuando A1<B1 entonces A es menor que B: Cuando A1>B1 entonces A es mayor que B:
Diseo digital con esquemticos y FPGA. v1.8 - 04/06/2008 IGUAL=0 ; AM=0 ; BM = 1 IGUAL=0 ; AM=1 ; BM = 0 49
10. Comparadores
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 cuando
(AM=1)
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 slo estamos haciendo comparaciones bit a bit. Esto es, podemos hacer comparaciones individuales. Y podemos traducir estas sentencias a algebra de
Iguales
Si (A1=B1) y (A0=B0)
IGUAL_1=1
IGUAL_0=1
COMPA1 A0 B0
IGUAL_0 AM_0 BM_0
IGUAL= IGUAL_1 IGUAL_0 IGUAL
COMPA1 A1 B1
IGU IGUAL_1 AM_1 BM_1 AM
A>B Si (A1>B1) [(A1=B1) Y (A0>B0)]

AM_1=1 IGUAL_1=1 AM_0=1
AM = AM_1 + (IGUAL_1 AM_0)
Figura 10.4: Comparador de dos bits hecho con comparadores de un bit (falta el A<B)
10.2.1. Diseo del comparador

Ahora tienes que disear el comparador. Puedes crearlo en el Ya los mismo proyecto. sabes pasos, esquemticamente son: A0 SW0 Crear un smbolo para el comparador de un bit A1 SW1 Crear un nuevo esquemtico de nombre compa2 (no lo llames comp2 B0 SW2 porque ya existe ese componente en la biblioteca de Xilinx y puede B1 SW3 llevar a error) que contenga un AM LD0 diseo similar al de la figura 10.4, incluyendo el circuito de la seal IGUAL LD1 de salida BM BM LD2 Y para implementarlo, asignarle los de entrad y salida qu ser los a , e n pines Tabla 10.3: mostrados en la tabla 10.3. Asignacin de seales Sintetizar, Implementar y programar la Una vez que lo hayas implementado en la FPGA, comprueba en la placa que el circuito funciona bien. Presta atencin al comportamiento de las salidas en funcin de los cambios en las entradas. Fjate cmo el bit ms significativo "manda" sobre el menos significativo.
11. Comparadores en cascada

El mecanismo para hacer un comparador de ms bits es el mismo, por ejemplo, si a partir del comparador de dos bits quisisemos realizar un comparador de 4 bits, los conectaramos de manera similar a la figura 10.4 aunque en este caso los bloques comparadores que usamos seran de dos bits en vez de uno. El circuito final nos quedara como el de la figura 11.1.
bits 1 y 0
COMPA2 A0 A1 B0 B1 COMPA2 A2 A3 B2 B3
IGUAL_10 AM_10 BM_10 IGUAL
IGUAL_32 AM_32 BM_32
AM
BM bits 3 y 2
Figura 11.1: Comparador de 4 bits hecho con comparadores de dos bits Por lo tanto, siguiendo este esquema podramos construir cualquier comparador del nmero de entradas que quisisemos. Sin embargo, la lgica de comparacin que une los dos comparadores es un poco incmoda y sera ms adecuado poder conectar los comparadores directamente, sin tener que aadir esas puertas. Lo que queremos se muestra en la figura 11.2.
A0_MSB A1_MSB
Comparaciones de los bits menos significativos (LSB)
COMP2_CAS
IGUAL AM BM
IGUAL_LSB AM_LSB BM_LSB B0_MSB B1_MSB
Figura 11.2: Comparador de dos bits que se puede poner en cascada El bloque (COMP2_CAS) de la figura 11.2, adems de los dos bits correspondientes que quiere comparar, recibe las entradas de la comparacin de los bits menos significativos. Por tanto, los comparadores se pueden conectar directamente, como se muestra en la figura 11.3. Fjate el valor de las entradas de comparacin del comparador de los bits menos significativos: cuando no hay ms bits que comparar, se ponen como si fuesen iguales (IGUAL_LSB='1').
Comparador de los bits menos significativos
A2 A3
Comparador de los bits ms significativos
COMP2_CAS A0 A1
'1' '0' '0'
A0_MSB A1_MSB IGUAL_LSB IGUAL IGUAL AM_LSB AM BM_LSB BM BM B0_MSB B0_MSB B1_MSB B1_MSB
COMP2_CAS
A0_MSB A1_MSB IGUAL_LSB AM_LSB BM_LSB B0_MSB B1_MSB IGUAL AM BM
IGUAL AM BM
B0 B1
B2 B3
Figura 11.3: Comparador de 4 bits conectando dos comparadores de dos bits en cascada
Cmo podramos 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, compralo con el de la figura 11.1.
IGUAL_LSB AM_LSB BM_LSB
Bits ms significativos: Entradas de las IGUAL
COMPA2
IGUAL AM BM BM AM
A0_MSB A1_MSB B0_MSB B1_MSB
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 aadirle el fichero de los comparadores ya
hemos creado comp1.sch y comp2.sch Para ello ejecutamos "ProyectAdd 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 smbolo para compa2. Haz que las seales A0 y A1 estn juntas en la figura del smbolo. Puede ser que en la configuracin 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 difcil encontrarlo. Si esto te ocurre, abre un explorador de archivos de Windows, ejecuta "HerramientasOpciones de Carpeta ..." y dentro de la ventana que te sale selecciona la pestaa Ver. En ella, casi al final, qutale 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 esquemticos le aadimos el smbolo del comparador de dos bits, y realizamos el circuito de la figura 11.4. Cuando terminemos, grabamos, y comprobamos el esquemtico (ToolsCheck Syntax) y haz que compruebe jerrquicamente (ToolsCheck Syntax). Creamos el smbolo de este esquemtico. Ordena los puertos como estn 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
Figura 11.5: Inicio del diseo con comparadores en cascada y buses

Ahora queremos conectar cada una de las lneas de los buses a las entradas del comparador. Para ello empezamos ste comando, en la aadiendo un conector al bus con el comando AddBus Tap. Al seleccionar ventana de opciones podemos elegir la orientacin del terminal triangular. ste tiene que ir en el lado del bus, as que para el bus A tendras que seleccionar Top, mientras que para el bus B seleccionaras Bottom. El diseo debera quedar como muestra la figura 11.6.
Figura 11.6: Buses con los conectores Ahora vamos unir(con cada del bus con las entradas de los comparadores. Ya sabemos cmo se hace a esto elconector comando Add Wire ). Y a continuacin 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 parntesis el ndice. En nuestro caso, para A(3:0) sern A(3), A(2), A(1) y A(0). Usamos el comando AddNet Name. Para poner el nombre ms cmodamente podemos empezar por el A(0), y seleccionar la opcin Increase the name. Con esto, automticamente despus de nombrar a A(0) el nombre que se pondra sera A(1), evitndonos tener que cambiarlo manualmente. La figura 11.7 muestra dnde se seleccionan estas opciones y el esquemtico 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.
Nombre Nombre
Increase Increase the the name name
Figura 11.7:Nombre de los cables de los buses
53
Ahora conectamos los buses a los puertos de entrada de nuestro diseo. 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
Figura 11.8:Diseo final del comparador de 4 bits Guardamos el diseo, comprobamos el esquemtico (ToolsCheck Schematic) y jerarqua (ToolsHierarchical Check). Si lo deseas, puedes simular el circuito o bien implementarlo directamente.
la
Asignamos los pines con la herramienta PACE: en la ventana de procesos: "User ConstraintsAssign
Package Pines". Los 4 interruptores de la derecha sern para el bus A (SW3, SW2, SW1, SW0), los cuatro A(0) SW0 B(0) SW4 IGUAL LD1 A(1) A(2) A(3) SW1 SW2 SW3 B(1) SW5 B(2) SW6 B(3) SW7 AM BM LD0 LD2
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: LOC = "P89" ; NET "A<0>"
NET "A<1>" LOC = "P88" ;
Cdigo 11.1: Ejemplo de conexin 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.
54
12. El multiplexor
12. El multiplexor
El diseo que acabamos de realizar est bien pero ahora nos gustara que el circuito no slo indique con los LED qu nmero es mayor, sino que tambin nos muestre el nmero 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 disear el circuito. Posteriormente se darn algunas explicaciones de cmo se puede realizar. Intenta realizar el diseo sin mirar la solucin o al menos pensarlo. Luego, si no te sale, o si lo quieres comprobar, consulta la solucin. Habitualmente, la empresa de ingeniera o el ingeniero tiene que realizar el diseo 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 diseo, el coste, el tiempo en que el producto va a estar disponible, ...
12.1. Especificaciones
Comparador de dos nmeros de 4 bits. El circuito debe comparar dos nmeros de 4 bits (A y B) que estarn codificados por medio de los interruptores de la placa. El circuito indicar a travs de tres LED el resultado de la comparacin: 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 Adems, el circuito mostrar por un display de siete segmentos el nmero mayor. En caso de que sea A el nmero 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 correspondern con el nmero 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 correspondern con el nmero 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 informacin se debe disear el circuito con bloques e implementarlo en la FPGA. Aunque muchos de los bloques ya estn hechos y no volvamos a repetir cmo se hacen, debers saber cmo se realizan en puertas.
12.2. Diagrama de bloques del circuito

Realmente el diseo no es mucho ms complicado que el comparador de 4 bits anterior, nicamente debemos aadir la visualizacin del nmero mayor por el display de siete segmentos. La comparacin de los nmeros debe seleccionar qu nmero se mostrar en los displays. Los bloques que realizan un seleccin son los multiplexores. En este caso necesitamos seleccionar entre dos nmeros: A y B, y por lo tanto necesitamos un multiplexor de 2 entradas (y una seal de seleccin). La seal que va a seleccionar ser la que indica si A>B, la que habamos 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.
55
12. El multiplexor A
MUX
A B 1 0 S
S B
AM
Si AM='1', por la salida S tendremos A Si AM='0', por la salida S tendremos B
AM
Figura 12.1: Multiplexor de dos entradas de datos y una de seleccin En nuestro caso las entradas de dato del multiplexor tendrn ms de un bit, por lo tanto tendramos que usar una variante de este multiplexor con entradas de tipo bus. Por ejemplo, un multiplexor de dos bits se realizara 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 seal de seleccin.
A(1:0)
A(1) A(1) 2 A(0) B(1)
0 1
S(1)
MUX2_2b
A(1:0) B(1:0)
2 2
equivalente S(1:0)
0 1
AM
S(1:0)
B(1:0) 2 AM
B(1) B(0)
A(0)
0
B(0)
S(0)
AM
AM
Figura 12.2: Multiplexor de dos entradas de datos de dos bits de ancho Al realizar un diseo, normalmente no hay una nica solucin para un circuito, sin embargo hay algunas que son ms ventajosas que otras. Unas pueden tener menor nmero de puertas, otras podrn ser ms complicadas o ser ms rpidas (tienen menos retardos). Por ejemplo, una opcin valida para nuestro diseo sera hacerlo como muestra la figura 12.3. En este diseo se convierten los nmeros A y B a siete segmentos, dichas seales convertidas se han llamado A_7SEG y B_7SEG respectivamente. Estas seales pasan por un multiplexor que las va a seleccionar segn el valor de AM (segn si A>B). Este valor ser el que salga por el display. Por otro lado, se muestran tambin las seales AN_0 y AN_3, que harn 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').Fjate que hay una puerta NOR debido a que las seales AN funcionan con lgica negada.
HEX7SEG
4
SEG(6:0) I(3:0) HEX7SEG SEG(6:0)
A_7SEG
A(3:0)
MUX
7
1 B_7SEG
7
B(3:0)
SEG_A SEG_B SEG_C SEG_D SEG_E SEG_F SEG_G
I(3:0)
COMP4
A(3:0)
AM IGUAL B(3:0) BM
AN_0 AN_3
Figura 12.3: Primera propuesta para el diseo

12. El multiplexor
Otra alternativa para realizar el circuito es la mostrada en la figura 12.4. Fjate que en ella no slo hay un menor nmero de componentes (slo hay un convertidor de hex a 7 segmentos) sino que adems las entradas del multiplexor utilizado tienen 4 elementos en vez de siete, lo que hace que sea bastante menor. As que esta alternativa es ms sencilla y ser la que implementemos. Seguramente haya otras alternativas y alguna de ellas se te ha podido ocurrir
MUX
1 0
HEX7SEG I(3:0)
A(3:0) B(3:0)
SEG(6:0)
COMP4
A(3:0)
SEG_A SEG_B SEG_C SEG_D SEG_E SEG_F SEG_G
AM IGUAL B(3:0) BM
AN_0 AN_3
Figura 12.4: Alternativa para el diseo
12.3. Diseo
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 aadir el convertidor de 7 segmentos que hicimos en el ejercicio Y aadimos 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 aadimos al proyecto el decodificador y el convertidor: (ProyectAdd Copy of Source...) y seleccionamos los ficheros
hex7seg.sch decod4a16.sch
Vamos a realizar alguna modificacin al convertidor para luego crear un mdulo: seleccionamos todas las salidas AN que habamos creado y las eliminamos. Pues ahora las vamos a gobernar desde fuera del convertidor. La seal SEG_DT la podemos dejar. Una vez que lo hayamos hecho, guardamos y comprobamos el esquemtico (ToolsCheck Schematic y tambin ToolsHierachical Check). Si todo sale bien, ahora creamos un smbolo de este diseo: (ToolsSymbol Wizard) y seleccionamos el hex7seg. Ordenamos los puertos si no estuviesen ordenados.
57
12. El multiplexor
Figura 12.5: Multiplexor de 2 datos de 4 bits cada dato (una seal de seleccin) Guarda el diseo, comprueba el esquemtico y crea un smbolo de este multiplexor para poder usarlo en el diseo de ms alto nivel: el que va a reunir a todos, como el de la figura 12.4. Creamos el diseo de ms alto nivel de nuestro circuito, que ser como el de la figura 12.4. Aadimos nueva fuente llamada mux7seg.sch. Necesitamos un comparador, o bien usamos el comparador que hemos creado en la prctica 11 (ya sabes cmo 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 categora 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 fcilmente, ya que cundo y lgebra B sern iguales? pues cuando ni A sea mayor que B ni A sea B. Y esto T Otra de decir A en de Boole se traduce como: G manera de menor decirloque es que A y son IGUAL = B T . iguales cuando no ocurre que A sea mayor que B, o L que A sea menor que B: IGUAL = GT+LT . Fjate que las dos expresiones son equivalentes por el teorema de De Morgan. An as, si te las, puedes hacer la tabla de verdad. El diseo final del circuito podra quedarte como lo muestra la figura 12.6. Fjate que entre otros, tambin se han aadido los puertos que van a los LED (AM, BM, IGUAL) Asegrate que
58
12. El multiplexor
Figura 12.6: Diseo final del circuito Una vez que lo termines, guarda el diseo, comprueba el esquemtico, y asigna los pines. La especificacin de los pines la tenas en el apartado 12.1. Seguramente no salga el PACE y la tengas que hacer editando el UCF. Intenta hacerlo sin mirar, an as, a continuacin 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" ;
Cdigo 2: Contenido del fichero UCF Finalmente implementa el diseo en la FPGA y comprueba que todo funciona como se ha especificado. Si es as, enhorabuena, este ha sido un diseo de cierta complejidad.
59
13. El sumador
13. El sumador
En clase se ha explicado el sumador, y en este ejercicio simplemente aplicaremos la teora para realizarlo. As que las especificaciones van a ser muy sencillas. Despus de leer las especificaciones puedes intentar hacerlo t slo o ir al apartado siguiente donde se explica el diseo del sumador.
Sumador de dos nmeros de 4 bits. El circuito debe sumar dos nmeros sin signo de 4 bits (A y B) que estarn 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), adems encender el punto decimal del display cuando haya desbordamiento. La correspondencia de los interruptores con los nmeros 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 seal A y los cuatro de la izquierda con B. Adems el sumador recibir el acarreo de entrada por medio del pulsador de la derecha (BTN0). Opcionalmente tambin se podr sacar el resultado codificado en binario por los cuatro LED de la derecha (de LD0 a LD3).
13.2. Diseo
Empezaremos realizando el diseo 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 (tambin llamado en cascada).
A 0 0 1 1 B 0 1 0 1 S 0 1 1 0 C 0 0 0 1
A S
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 smbolo (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 seal 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 cmo se forma ste con semisumadores. Tambin se poda haber realizado resolviendo las ecuaciones lgicas de S y CO mediante mapas de Karnaugh.
A 0 0 0 0 1 1 1 1 B 0 0 1 1 0 0 1 1 CI 0 1 0 1 0 1 0 1 S 0 1 1 0 1 0 0 1 CO 0 0 0 1 0 1 1 1
HA CI HA A CO S
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 esquemtico (ToolsCheck Schematic) y creas un smbolo para el sumador completo. Si tienes alguna duda o quieres comprobar el diseo puedes simularlo o implementarlo en la placa (ya sabes cmo se hace). Si no continuamos realizando el sumador de 4 bits.
13. El sumador
Una vez que tenemos un sumador completo de 1 bit, la realizacin de un sumador de 4 bits es bastante fcil. Simplemente tenemos que conectar los acarreos consecutivamente del bit menos significativo al ms significativo. Y conectar las entradas de A y B en paralelo, en sus sumadores correspondientes. El diseo se muestra en la figura 13.3. bits ms
significativos (MSB)
A3 A
B3 B CI S S3
A2 A CO S S2
B2 B CI
A1 A CO S S1
B1 B CI
A0 A CO S S0
B0 B CI
bits menos significativos (LSB)
CO
Acarreo de salida (o desbordamiento)
CO
C2
C1
C0
CI
Acarreo de entrada a cero
Figura 13.3: Sumador de 4 bits a partir de sumadores completos Para disear 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 mdulos en cascada, o en nuestro caso introducirlo cuando apretemos el pulsador BTN0.
Figura 13.4: Esquemtico del sumador de 4 bits Guardamos el esquemtico y lo comprobamos (ToolsCheck Schematic y ToolsHierarchical Check). Y creamos un smbolo del diseo (ToolsSymbol Wizard) de manera que el orden de los puertos quede como
CI A(3:0) B(3:0)
4 4 4
S(3:0) CO
SUM4BITS
Figura 13.5: Bloque del sumador de 4 bits Ya tenemos el sumador hecho, aunque todava nos queda la parte de visualizacin del resultado. Antes de realizar la parte de la visualizacin, 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 visualizacin. Para esto tenemos que aadir al proyecto el convertidor a siete segmentos que hemos realizado en ejercicio 7 y que luego
13. El sumador
modificamos en el ejercicio 12. Los pasos para importarlo estaban descritos en el apartado 12.3, pero los recordamo s: Aadir 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 contena, el convertidor a 7 segmentos: Source... y seleccionamos los hex7seg.sch. Para ello ejecutamos el comando ProyectAdd Copy of ficheros decod4a16.sch y hex7seg.sch El convertidor vamos a modificarlo un poco, vamos a eliminar el puerto SEG_DT en ese diseo la tenamos siempre a uno, ahora la quitamos completamente. Guardamos el diseo, y comprobamos el esquemtico (ToolsCheck Schematic y tambin ToolsHierachical Check). Por ltimo creamos un smbolo del convertidor (ToolsSymbol Wizard) y seleccionamos el hex7seg. Asegrate que los puertos estn 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
Figura 13.6: Esquemtico del sumador de 4 bits con el convertidor a 7 segmentos Cuando termines de disearlo 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 diseos anteriores), y por ltimo, sintetizar e implementar en la FPGA. En caso de que hayas implementado la versin anterior (la que no mostraba nada por el display), ten cuidado de no programar la FPGA con el fichero sum4bits.bit, sino que la debers programar con el nuevo fichero: top_sumador.bit. Al terminar comprueba que funciona bien, fjate en los LED y en lo que muestra el display y verifica que se trata del mismo nmero. Comprueba tambin que la suma est bien, y si funciona el acarreo de entrada: el pulsador de la derecha (BTN0). Y tambin el acarreo de salida (desbordamiento) que se debera mostrar con el LED de la izquierda y con el punto decimal. Aprovecha tambin para repasar los conceptos tericos del tema 2 (Sistemas de numeracin y codificacin): nmeros en binario y cmo se realiza la suma.
62
14. Sumador/restador
Queremos hacer un circuito que reste, para ello podramos hacer un circuito restador de un bit a partir de la tabla de verdad de la resta. Esto se hara 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 prctica vamos a aprovechar los conocimientos de representacin numrica que vimos en el tema 2. En aquel tema vimos que usando el complemento a 2 (Ca2) podamos 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.
Sumador/restador de dos nmeros de 4 bits. El circuito debe sumar o restar dos nmeros codificados en complemento a 2 con 4 bits (OPA y OPB) y cuyos valores estarn determinados por la posicin 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 vendrn 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 nmeros vienen codificados en complemento a 2. EL pulsador BTN0 indicar qu operacin se realiza. Cuando est pulsador se har la resta, mientras que cuando no est pulsado se efectuar la suma. El resultado de la operacin (suma o resta) se mostrar por el primer El resultado se deber mostrar en el display en signo magnitud entender los humanos). Para mostrar el signo negativo se utilizar el si el punto decimal est luciendo significa que el resultado es el negativo. En caso de que haya desbordamiento (overflow) el display mostrar la letra E. Adems los cuatro LED de la derecha (de complemento a 2).
LD0
display de 7 segmentos. (para que lo podamos punto decimal, es decir, nmero mostrado pero
LD3)
mostrarn el resultado directo (en
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 cmo implementamos la parte de la visualizacin por el display. Esto es comn en el diseo 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 diseos muy grandes, cada parte OPA(3:0)la realizan OPB(3:0)personas o grupos diferentes y luego otros se
4 4
SUMADOR/RESTADOR + , RESUL(3:0) acarreo desbordamiento C OV

4
Indica si se suma o se resta RES_SUM

SUMA: RES_SUM='1' RESTA: RES_SUM='0'
LEDS
A F E G D B C
VISUALIZACION
Figura 14.1: Esquema inicial del sumador restador con visualizacin

En los siguientes subapartados iremos refinando el diseo.
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 nmero OPB. Esto se muestra en la figura 14.2, en donde tenemos el mdulo CA2 que transforma la seal OPB en su complemento a dos. Y tenemos un multiplexor que selecciona la seal B complementada o no, segn si hay que restar o sumar: si RES_SUM=0 se resta, si RES_SUM=1 es suma.
CI S(3:0)
4
S(3:0) CO
OPA(3:0)
Ca2(B)
A(3:0) 0 1
CA2 OPB(3:0) RES_SUM

4
B(3:0)
Figura 14.2: Esquema inicial del mdulo sumador/restador (sin visualizacin) Se podra realizar el diseo as, sin embargo los diseadores digitales han tendido siempre a minimizar el nmero de bloques y puertas del diseo. En este caso se puede hacer una versin ms compacta. Esto ocurra sobre todo hace unos aos, cuando tenan que hacer el diseo en componentes discretos o con dispositivos programables con poco espacio. Ahora esto no es tan crtico, an as, a continuacin veremos cmo hacer el circuito ms compacto. El complemento a dos de un nmero se realiza complementando cada bit y aadindole 1 al resultado. Y podramos realizarlo como se muestra en la figura 14.3, utilizando el sumador de cuatro bits para aadir 1.
tambin se poda poner el acarreo de entrada a cero y poner un uno en A(0) El otro sumando vale '0'
VCC
SUM4BITS CI
4
Ca2(B) El resultado es el complemento a 2 de B
A(3:0)
S(3:0)
S(3:0) CO
OPB(3:0)
B(3:0)
complementar cada bit
Figura 14.3: Circuito que calcula el complemento a 2 de un nmero 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 seal OPB, y pondremos el acarreo de entrada a 0 (CI='0'). Entonces el circuito quedara como muestra la figura 14.4.
64

SUMA: RESTA:RES_SUM='1' RES_SUM='0' CI='0' CI='1'
14. Sumador/restador SUM4BITS CI S(3:0)

4
S(3:0) CO
OPA(3:0)
A(3:0) 0 1
B(3:0)
OPB(3:0) RES_SUM
Figura 14.4: Otra versin del circuito sumador/restador (sin visualizacin) Pero esto todava no es el circuito final, ya que los inversores y el multiplexor an se pueden sustituir por algo ms pequeo. Con el multiplexor estamos eligiendo la seal OPB complementada o no segn el valor de RES_SUM. Esto es equivalente a utilizar una XNOR, ya que segn el valor de una entrada deja pasar la otra tal cual o complementada (ver figura 14.5).
equivalente a XNOR
0 S B Sel 1
Sel 0 0 1 1
B 0 1 0 1
S 1 0 0 1
Sel=0 S=B Sel=1 S=B
B Sel
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 teora. Esto se debe a que la seal de sumar/restar (RES_SUM) est complementada. En este ejercicio se suma cuando RES_SUM=1, mientras que en la teora 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 seal RES_SUM. En la figura 14.6 se muestra esta equivalencia.
B Sel equivalente S B Sel equivalente S B Sel S
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. SUMA: RES_SUM='1' CI='0' SUM4BITS
RESTA: RES_SUM='0' CI='1'
RES_SUM OPA(3:0) OPB(0) OPB(1)

4 4
CI A(3:0)
S(3:0)
S(3:0) CO
B(3:0)
OPB(2) OPB(3)
Figura 14.7: Penltima versin del circuito sumador/restador (sin visualizacin) Bueno, quizs podamos pensar que la figura 14.7 corresponde el diseo 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. Cundo 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. ste es OPB y por ser suma
suma coincide con B resta ste es OPB 0011+0101 0011 +0101 1000 3 +5 8 00110101 0011+Ca2(0101) Ca2(0101)=1011 ste es B 310 0011 +1011 -510 Es representable -210 1110 en Ca2 de 4 bits -210 signos diferentes: no hay desbordamiento
iguales
al estar en Ca2 representa a
No es representable en Ca2 de 4 bits distintos
-8
Cambio de signodesbordamiento
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 podramos hacer la tabla de verdad y calcular la funcin lgica del desbordamiento (overflow). Eso ya sabes como se hace (figura 14.9). A3 B3 S3 OV
0 0 0 0 1 1 1 1 0 0 1 1 0 0 1 1 0 1 0 1 0 1 0 1 0 1 0 0 0 0 1 0
A(3) B(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 todava se puede calcular de manera ms simplificada, haciendo la XOR del acarreo de salida, con el penltimo 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.
B3 B2 B1 B0
A3 A CO CO S DE
Desbordamiento
A2 B CI A CO S S2 B CI
A1 A CO S S1 B CI
A0 A CO S S0 B CI
C2
C1
C0
RES_SUM RES
S3
Figura 14.10: Otra alternativa para calcular el desbordamiento en complemento a 2
14.2.2. Bloque de visualizacin

El bloque de visualizacin recibe un nmero en complemento a 2 de cuatro bits, una seal de desbordamiento (OV), y debe mostrar en un display de 7 segmentos el nmero resultante en signo y magnitud. En caso de que el nmero fuese negativo, mostrar el correspondiente nmero 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 nmeros en complemento a dos de 4 bits, el menor nmero ser -8 y el mayor 7. As que para estos nmeros nuestro convertidos de 7 segmentos funciona, adems podemos mostrar la letra E, sin que se preste a confusin, ya que el nmero 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 66
Departamento de Tecnologa Electrnica Si OV='0'
y S(3)='1', significar que tenemos un nmero negativo, y por lo tanto tendremos que calcular su Cuando tenemos condiciones de tipo "Si.... entonces", stas se pueden implementar multiplexor. En la figura 14.11 se S(3:0) muestra esta "traduccin". fcilment con un e
Ca2
S(3)
El nmero 14 muestra la E
1
4
1110
1
4
OV
HEX7SEG I(3:0) SEG(6:0)

7 F E
A G D B C
S(3)
SEG_DT
Figura 14.11: Diagrama de bloques del mdulo de visualizacin En esta figura ya tenemos hechos los multiplexores y el convertidor a 7 segmentos (HEX7SEG). Nos faltara por hacer el mdulo que se encarga de calcular el complemento a dos de la seal S(3:0), ste ya lo vimos en la figura 14.3. Antes de comenzar a disear, acurdate que la representacin en complemento a 2 no era simtrica, y por tanto, haba un nmero negativo ms 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 nmero (1000). Qu sucedera en este caso? Qu pasa si queremos representar el nmero -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 representacin sale bien, lo realizaremos as.
S(3:0)
1000
Ca2
1000
S(3)
1000
1
4
1
1110
OV 1 0
4
1000 0
A 7 F G D B C
1000
Se mu estra un 8
HEX7SEG I(3:0) SEG(6:0)
S(3)
SEG_DT
encender el p unto: signo
Figura 14.12: Diagrama de bloques y valores para cuando el resultado sea -8

14.3. Diseo
Creamos un nuevo proyecto llamado ejercicio 13 (el sumador)
decod4_16.sch hex7seg.sch ha.sch fa.sch sum4bits.sch addsub.
Aadimos una copia de las siguientes fuentes del
Y del ejercicio del multiplexor (ejercicio 12), aadimos una copia de:
mux2_4bit.sch
Crea un smbolo 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 esquemtico para crear el bloque sumador/restador, lo llamamos addsub.sch y en l implementamos el diseo de la figura 14.7 con el aadido de la parte del
Figura 14.13: Esquemtico del sumador/restador de 4 bits Ahora procederemos a crear el bloque de visualizacin (recuerda la figura 14.1 y el apartado 14.2.2). Antes de hacer la unidad de visualizacin, tenemos que crear el bloque que calcula el complemento a dos de un nmero de 4 bits (mira este bloque en la figura 14.11). Creamos una nueva fuente llamada ca2.sch, y en ella creamos el diseo de la figura 14.3. En la figura 14.14 se muestra el esquemtico de este diseo, de l tendrs que crear un smbolo.
Figura 14.14: Esquemtico del circuito Ca2 que calcula el complemento a 2 de un nmero Ahora creamos un nuevo fichero para la unidad de visualizacin, lo vamos a llamar visualiza.sch. En l implementamos el circuito de la figura 14.11, resultando el esquemtico mostrado en la figura 14.15. Al terminar, comprueba el esquemtico y crea un smbolo de este circuito.
68
Figura 14.15: Esquemtico del circuito Visualiza, que se encarga de mostrar el resultado por el display de siete segmentos Y ya slo falta crear la unidad de ms 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 realizacin en el ISE se muestra a continuacin (figura 14.16).
Figura 14.16: Esquemtico de la unidad de ms alto nivel del diseo En la figura 14.16 estn tambin los puertos AN_0, controlaban los displays que iban a lucir (en este caso slo el de la derecha).
AN_1, AN_2
AN_3
que eran con los que se
Como siempre, una vez que lo hayas terminado, guardas el diseo, lo compruebas, y asignas los pines. Luego lo implementas en la FPGA.
14.4. Comprobacin del diseo

Buf, este ha sido un diseo con cierta complejidad, as que enhorabuena si has llegado hasta aqu! De todos modos, an no est todo hecho. Ahora hay que comprobar que el diseo funciona bien. Esto adems nos valdr para repasar los nmeros en complemento a 2, y sus sumas y restas. Podemos seguir este esquema para comprobar primero que el display representa bien los nmeros, 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 (seal OPA: de SW0 a SW3) codifican el
Si
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 segn sea resta o suma. El punto decimal deber estar apagado, ya que en nuestro sistema, el punto representa el signo negativo.
SW7=SW6=SW5=SW4=SW3=SW2=SW1='0'
SW0='1'.
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 estn 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 nmeros 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 01=-1. Y por tanto tendremos un -1 en el display (el signo menos lo indica el punto decimal). Los cuatro LED de la derecha lucirn, 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 apagarn. Podemos continuar haciendo esto hasta OPB="0111" entonces estamos haciendo 07=-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 nmero "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. Fjate 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. Fjate tambin 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.
70
15. Unidad aritmtico lgica

Una unidad aritmtico lgica (UAL, pero ms conocida como ALU por sus siglas en ingls) es un circuito que permite realizar operaciones aritmticas y lgicas entre los operandos de las entradas. La ALU suele constar de unos bloques que realizan las operaciones aritmticas y lgicas, y de un multiplexor que escoge las salidas de esos bloques segn la operacin seleccionada. Muchas de las operaciones aritmticas ya las hemos visto: suma, resta, comparacin, ... Y las operaciones lgicas suelen ser aplicar unas operaciones a nivel de bits, por ejemplo, invertir todos los bits, realizar la operacin AND entre cada bit de los operandos. A veces tambin se incluyen operaciones de desplazamiento y rotacin, 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 obtendra "0100".
Realizar una unidad aritmtico lgica con dos operandos de 4 bits (OPA y operaciones.
OPB)
y4 se codificar con los cuatro
Los operandos vendrn dados por los interruptores. El operando mediante los 4 interruptores de la derecha (de SW0 a SW3), y el operando interruptores de la izquierda (de SW4 a SW7).
OPA OPB
Las operaciones que se realizarn son: suma, multiplicacin por 2, mayor y la operacin lgica AND. Para realizar una operacin 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 nmero mayor entre OPA y OPB BTN3: aplica la funcin lgica AND entre los bits de OPA y OPB En caso de que se pulsen dos o ms pulsadores al mismo tiempo, tendr prioridad el pulsador que est ms a la derecha en la placa. Por ejemplo si se pulsan BTN1 y BTN3 al mismo tiempo, el resultado ser la multiplicacin por 2 (BTN1) y no la funcin lgica AND. Para el caso de la operacin suma, multiplicacin y mayor, se considera que los operandos OPA y OPB estn codificados en binario puro (sin signo). Para la operacin lgica AND, no es necesario considerar ninguna codificacin. El resultado de la operacin se mostrar por los cuatro LED de la derecha (de adems se mostrar por el display de la derecha. Segn qu operacin se est realizando LD7 mostrar: En la suma: el acarreo de salida En la multiplicacin: el desbordamiento En la operacin "mayor que": se mantendr apagado En la operacin lgica AND, se mantendr apagado Cuando no haya ningn botn pulsado, todos los LED permanecern apagados, y tambin el display.
LD0
LD3),
15.2. Diagrama de bloques

Como es un diseo grande, vamos a ir construyndolo 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 cmo 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
71
Departamento de Tecnologa Electrnica OPA(3:0) OPA(3:0) OPB(3:0)

4 4 4
15. Unidad aritmtico lgica OPA(3:0) OPB(3:0)

4 4
OPA(3:0)
4
OPB(3:0)
4
+ CO
4
MULT2 OV
4
MAYOR
4
AND
4
R_SUM(3:0)
R_MULT(3:0)
R_MAY(3:0)
R_AND(3:0)
Figura 15.1: Los cuatro bloques que harn las operaciones de la ALU Segn que operacin hayamos escogido, debemos seleccionar el resultado de uno de los bloques que realizan las operaciones. Por ejemplo, si queremos sumar debemos seleccionar la seal R_SUM (figura 15.1). Como ya sabes, la seleccin se suele implementar mediante multiplexores, y es lo que hacemos en la figura 15.2. Segn la operacin seleccionada OPER, escogemos el resultado de uno de los bloques. Y quizs te preguntes quin determina los cdigos de operacin? por qu cuando OPER="11" cogemos la suma y no la AND? Es una buena pregunta, hemos escogidos stos igual que podamos 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 estn ordenadas segn esa prioridad. As que podamos haber escogido este
OPA(3:0)
4
OPA(3:0) OPB(3:0)
4 4
OPA(3:0) OPB(3:0)
4 4
OPA(3:0)
4
OPB(3:0)
4
+ CO
4
MULT2 R_SUM OV
4
MAYOR R_MAY
4
AND R_AND
4
R_ R_MULT
OPER(1:0)
11
10
4
01 R_(3:0)
00
Cdigos de operacin 00 : AND 01 : MAYOR 10 : MULT 11 : SUMA
Figura 15.2: Seleccin de la operacin a realizar En las operaciones lo nico que nos importa es que cuando apretemos un botn se seleccione la operacin adecuada, pero la persona que use la ALU no va a saber, ni le interesa, cmo est codificada internamente esa operacin (esto es, cunto vale OPER). El siguiente paso es establecer la correspondencia entre los botones pulsados y el cdigo de operacin. Fjate, tenemos cuatro pulsadores y queremos 2 salidas OPER que van a codificar la operacin seleccionada. Cuando pulsemos BTN0 queremos que OPER sea igual a "11" (suma); cuando pulsemos BTN1 y no est pulsado BTN0 queremos que OPER="10" (multiplicacin). Y as con el resto, entonces qu bloque me implementa esto? pues un codificador con prioridad (recuerda el captulo 8). Las entradas y salidas de un codificador con prioridad de 4 a 2 se muestran en la figura 15.3. En esta figura tambin se muestra la tabla de verdad.
CODIF BTN3 BTN2 BTN1 BTN0 I0 I1 I2 I3 EI EO S0 S1 A OPER(0) OPER(1) OP_ACT
EI 0 1 1 1 1 1
I3 X 0 0 0 0 1
I2 X 0 0 0 1 X
I1 X 0 0 1 X X
I0 X 0 1 X X X
S1 0 0 0 0 1 1
S0 0 0 0 1 0 1
A EO 0 0 0 1 1 0 1 0 1 0 1 0
Figura 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 cdigo de operacin de la suma (figura 15.2). Por tanto, las salidas del codificador van directamente a la seleccin del multiplexor (OPER). Si hubisemos tomado el cdigo de la suma como OPER="00", simplemente tendramos que invertir la salida del codificador. As que, incluyendo el codificador para los pulsadores de entrada, el circuito queda como
OPA(3:0)
4
OPA(3:0) OPB(3:0)
4 4
OPA(3:0) OPB(3:0)
4 4
OPA(3:0)
4
OPB(3:0)
4
Cdigos de operacin 00 : AND 01 : MAYOR 10 : MULT 11 : SUMA CODIF BTN3 BTN2 BTN1 BTN0 '1' I0 I1 I2 I3 EI EO S0 S1 A
+ CO
4
MULT2 R_SUM OV
4
MAYOR R_MAY
4
AND R_AND
4
R_ R_MULT
OPER(1:0)
11
10
4
01 R_(3:0)
00
OP_ACT
Figura 15.4: Codificacin de las entradas de seleccin de la operacin Ya casi est el diagrama de bloques del circuito representacin del Simplemente aadimos el bloque del convertidos no hay ningn pulsador apretado, se desconecta el display y por codificador, a pin AN_0 que controla el display de invertida debido a que AN_0 es activa a nivel bajo.
OPA(3:0)
4
completo, nos falta la resultad a 7 segmentos (figura 15.5). o. Cuando eso se conecta la salida A (activo) del la derecha. Recuerda que se conecta
Adems hemos puesto una habilitacin al multiplexor, para que cuando no haya ningn botn pulsado, el multiplexor no saque ningn resultado.
OPA(3:0) OPB(3:0)
4 4
OPA(3:0) OPB(3:0)
4 4
OPA(3:0)
4
OPB(3:0)
4
Cdigos de operacin 00 : AND 01 : MAYOR 10 : MULT 11 : SUMA CODIF BTN3 BTN2 BTN1 BTN0 '1' I0 I1 I2 I3 EI EO S0 S1 A A
+ CO
4
MULT2 R_SUM OV
4
MAYOR R_MAY
4
AND R_AND
4
R_ R_MULT
OPER(1:0) OP_ACT
SEL EN
11
10
4
01 R(3:0)
00
AN_0 OV CO OPER(0) OPER(1) 0 1 LD7
HEX7SEG
F 7 E
G D
B C
I(3:0)
SEG(6:0)
LEDS
Figura 15.5: Diagrama de bloques del circuito Fjate en la seal LD7 y asegrate que entiendes por qu es as, si no lo entiendes, quizs te ayude la siguiente figura:
73

Ya que es '0' en los dos casos
'0' '0' OPER(0)
0 1 0 1 LD7
Cuando OPER(1)= '0' LD7='0' '0' 0 1 OV CO OPER(1) OPER(0) 0 1 OPER(1) OV LD7 CO OPER(0) OPER(1) 0 1 LD7
OV CO OPER(0)
0 1
Figura 15.6: Simplificacin del multiplexor para LD7
15.3. Diseo
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. Aadimos una copia (ProyectAdd 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), aadimos una copia de:
mux2_4bit.sch
Crea un smbolo del conversor a siete segmentos (hex7seg.sch), el sumador de 4 bits (sum4bits.sch) y el multiplexor (mux2_4bit.sch). Haz tambin que las seales tengan un orden razonable (sobre todo en el convertidor de 7 segmentos). Para obtener el mismo orden que ya as obtenido en otras prcticas puedes seguir los siguientes pasos: Abre el hex7seg.sch Ejecuta ToolsSymbol Wizard. Selecciona Using Schematic : hex7seg y ms 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 smbolo 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. Tambin podramos coger el comparador que hemos realizado en la prctica 11, sin embargo para ste usaremos el smbolo que proporciona el ISE. A continuacin 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 numeracin y codificacin), la multiplicacin por 2 en binario era similar a la multiplicacinMultiplicador por 10 x2 en decimal. Simplemente hay que desplazar los nmeros hacia la
Ejemplos: A3 A2 A1 A0 0 6: 0110 2 x2 12: 11002 OV S3 S2 S1 S0 5: 0101 2 x2 10: 10102 9: 10012 x2 18:100102 overflow no 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 seales 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: Esquemtico del multiplicador por 2 Guardamos el circuito, lo comprobamos y creamos un smbolo.
15.3.2. Circuito comparador, "mayor"

Para este circuito crea una nueva fuente llamada mayor.sch. Este circuito ya lo deberas saber hacer, ya que es casi igual que el dibujado en las figuras 12.4 y 12.6 (del la prctica del multiplexor). As que no lo vamos a explicar mucho, simplemente representaremos el esquemtico 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
Figura 15.9: Esquemtico del bloque comparador (mayor)
15.3.3. Circuito operacin lgica AND

Bueno, con este circuito no deberas de tener ningn problema. Simplemente hay que realizar la operacin lgica 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 figura 15.10.
and_4bit.sch
y realizamos el circuito de la
75
Figura 15.10: Esquemtico del bloque que realiza la AND lgica Al terminar, como siempre, guardamos, comprobamos el esquemtico y creamos un smbolo.
15.3.4. Multiplexor de 4 entradas datos con habilitacin

Ahora queremos realizar un multiplexor de cuatro entradas de datos y por tanto, dos de seleccin. Cada dato tiene cuatro bits. Adems, incluiremos una seal de habilitacin para que no saque ningn dato en el caso de que no se haya seleccionado ninguna operacin. Tenemos tres opciones para realizar el multiplexor (bueno, ms, pero aqu propondremos stas): La primera consistira en realizar el multiplexor completamente con puertas lgicas, tal como se ha explicado en clase. sta no lo vamos a hacer, aunque deberas saber cmo se hace. La segunda ltima alternativa propuesta sera hacer el multiplexor con la ayuda del
decodificador de 2 a 4. La ltima opcin sera construir el multiplexor de 4 entradas de datos a partir de tres
R_AND R_MAY R_MULT R_SUM
4
00 01 10 11
R_AND R_MAY
4
0 1 0 1
4 4
R(3:0)
OPER(0)
R(3:0)
R_MULT
2
0 1 EN
R_SUM EN
OPER(1:0)
OPER(0) OPER(1)
Figura 15.11: Construccin de un multiplexor con habilitacin de 4 entradas de datos a partir de multiplexores de dos entradas de datos Al final del multiplexor se le ha aadido la habilitacin, una para cada bit. Para poner las seales de seleccin en los multiplexores pequeos tenemos que analizar qu grupos de seales 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. Quizs te ayude la siguiente
76
Departamento de Tecnologa Electrnica Si OPER(1)='0' , entonces OPER(0) selecciona entre R_AND y R_MAY
R_AND R_MAY R_MULT R_SUM
00 01 10 11
R_AND R_MAY
4
0 1 0 1
4
habilitacin
R(3:0)
OPER(0)
R(3:0)
R_MULT
2
0 1 EN
R_SUM EN
OPER(1:0)
OPER(0) Si OPER(1)='1' , entonces OPER(0) selecciona entre R_MULT y R_SUM OPER(1)
Figura 15.12: Seales de seleccin en los multiplexores pequeos As que creamos una nueva fuente llamada mux4d_4b_e.sch (indica que tiene 4 datos, de 4 bits y habilitacin). El esquemtico del circuito se muestra a continuacin (figura 15.13). Llama a los puertos de entrada con un nombre genrico (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 diseo no sabrs qu entrada de seleccin los activa, ni el significado de esos nombres.
Figura 15.13: Esquemtico del multiplexor de 4 datos con habilitacin Como siempre, para terminar, guarda el poniendo un orden adecuado a las entradas. diseo, comprubalo y crea su smbolo
15.3.5. Codificador con prioridad de 4 entradas

El codificador con prioridad ya lo hemos visto en el captulo 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 slo una seal 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 habilitacin. En la figura 15.14 se muestra el codificador, en donde tambin estn los puertos de salida EN_OUT y A
77
Figura 15.14: Esquemtico del codificador de 4 entradas con prioridad y habilitacin Guarda el diseo, comprubalo y crea su smbolo poniendo un orden adecuado a las entradas.
15.3.6. Componente de mayor jerarqua

Ya tenemos todos los componentes necesarios para implementar el circuito (figura 15.5). As que vamos a crear el diseo que los integra. Creamos un fichero llamado top_alu.sch, y realizamos el diseo de la figura 15.5. La solucin se muestra a continuacin (figura 15.15). Luego guarda el diseo y comprubalo.
Figura 15.15: Esquemtico final de la ALU
15.4. Implementacin y comprobacin

Ya slo falta crear el fichero UCF con los puertos, implementar el diseo en la FPGA y comprobar que funciona bien. Este ha sido un diseo bastante completo.
78
16. Elementos de memoria

En esta prctica vamos a usar elementos de memoria, en concreto un biestable activado por flanco. As que adems necesitaremos una seal de reloj para el biestable. Para ello utilizaremos la seal de reloj de la placa Pegasus. Esta seal 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 seal de reloj. Este primer ejercicio secuencial va a ser muy sencillo.
Disear 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. Diseo
Este circuito se podra 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 smbolos escogemos la categora Flip_Flop, y escogemos el smbolo fjkc. Que se corresponde con un biestable J-K, con clear asncrono. La seal clear (CLR) funciona a nivel alto, es decir con un '1' lgico 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 Por tanto, el esquemtico ser como el mostrado en la figura 16.1. Cuando lo tengas, guarda el diseo para implementarlo. Figura 16.1: Esquemtico del circuito que enciende y apaga el LED
16.3. Implementacin Cuando los circuitos tienen seal de reloj hay que especificar quin es la seal 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 pestaa Global. Y donde pone Clock Net Name, debe salir nuestra seal de reloj: Clk.
79
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 nmero 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
Figura 16.3: Especificacin 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 editndolo 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 tambin se guarda la informacin de la seal de reloj. Aunque ya sabes cmo se rellena el fichero UCF, ya que hay algunas novedades, a continuacin se muestra cmo 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" ;
Cdigo 16.1: Especificacin 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, necesitaramos mantener el dedo pulsado para que la luz se mantenga encendida. Con este circuito hemos logrado memorizar cul 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 debera de cambiar el estado en que estaba, pero date cuenta que es prcticamente imposible pulsar ambas teclas a la vez. Y lo que es ms, 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
80
17. Interruptor con pulsador

En esta prctica queremos hacer una variacin del circuito del captulo 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 cmo lo haras t.
17.1.1. Conectando el pulsador del biestable T que En principio podemos pensara la enentrada el biestable T, ya
FTC BTN0 T Q LED0
cuando T='1' cambiar el valor del biestable, y por tanto, se apagar o se encender segn como estuviese anteriormente. Podemos realizar el circuito mostrado en la figura 17.1. Escogemos el biestable T con seal de clear asncrono (CLR). Este biestable est en la categora Flip_Flop y se llama FTC.
CLK
CLR
Ponemos el clear a cero para que nunca se active (tambin se Figura 17.1: Primera versin del circuito podra haber puesto conectado con otro pulsador para activarlo a La seal de reloj de la placa se conecta a la seal 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 captulo 16 cmo se define el reloj (figura 16.3) y mira a ver qu sucede.... Si implementas el circuito vers 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 ms 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 millonsima 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
'1' cambio en Q
BTN0-T CLK 50 MHz LED0-Q
'0' Q guarda valor
Oscilar hasta que soltemos el pulsador
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 podra pensar en utilizar la seal del pulsador como reloj, ya que esta seal slo 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 diseos sncronos y seguros, la seal de reloj del circuito es la nica que debe entrar en las entradas de reloj de los biestables. Slo diseadores experimentados deberan arriesgarse a realizar circuitos asncronos. En la figura 17.3 se muestra el circuito que se propone. La entrada T del biestable est siempre
Departamento de Tecnologa Electrnica Vcc Atencin: Circuito MAL DISEADO No se debe poner en la entrada de reloj una seal distinta a la seal de reloj del circuito BTN0 T
17. Interruptor con pulsador FTC Q LED0
CLR
Figura 17.3: Segunda versin del circuito, que no se debe realizar Si pruebas este circuito en la placa, quizs veas que tiene un comportamiento extrao. De todos modos, aunque funcionase bien, tenemos que buscar otra solucin que cumpla las normas de diseo sncrono de manera que slo la seal 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 excepcin 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. Fjate 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 smbolo que indica que son activos por flanco de subida. F
FD BTN0 D Q B FD D Q C FTC T Q LED0
CLR Clk
Figura 17.4: Circuito detector de flanco e interruptor Suponiendo que en el tiempo inicial los tres biestables estn a cero (Q='0'), obtn el cronograma de las seales B, C, F y LED0 para las entradas mostradas en la figura 17.5.
clk
Clk BTN0 B C F LED0
Figura 17.5: Obtn el cronograma de las seales 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 seal F . Este pulso de F hace que el biestable T cambie slo una vez por cada pulso de BTN0. Si no sabes cmo obtener el cronograma, puedes simular el circuito, o bien, en el apartado 17.3 se muestra la solucin. Es muy importante que entiendas cmo se obtiene, ya que en el examen suelen caer problemas de este tipo, normalmente algo ms complejos. Implementa el circuito en la placa. Seguramente veas que funciona correctamente. Sin embargo, si ests 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
17.3. Solucin al cronograma

A continuacin se muestra la solucin al cronograma de la figura 17.4. Fjate que la seal B es la misma que la seal BTN0 pero retrasada al siguiente flanco de reloj. La seal C es igual que B pero retrasada exactamente un ciclo de reloj. Y que la seal F slo ser igual a 1 cuando B='1' y C='0', esto slo ocurrir despus del flanco de reloj de subida de BTN0.
clk
Clk BTN0 B C F LED0
Figura 17.6: Solucin al cronograma de las seales para el circuito de la figura 17.4
83
18. Parpadeo de un LED

Ahora vamos a hacer que un LED parpadee (se encienda y se apague intermitentemente) l solo. As de simple.
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. Diseo
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 seal que vaya a 1 Hz, esto es, que tenga un periodo de un segundo. Esta seal 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 seal 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 slo ciclo de reloj su salida a uno, y el resto del tiempo a cero. Pasado otro segundo (despus 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 T=1 s
T=20 ns
DivFrec
Clk Clk1Hz Clear
T=20 ns
Biestable T
T Q Clk LED Cada segundo le llega un '1' y entonces cambiar de estado (se encender y apagar)
50 Mz
1 Hz
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 nmero redondo. Ya que si contamos 5 ciclos de 20ns, obtendremos una seal con periodo de 100ns.
conta5
'1' CLK CE Clk CLEAR 50MHz 10MHz T100NS CONT5 T100NS CLK
4 0 1 2 3 4 0 1 2 3 4 0 1 2 3 4 0
50 MHz
10 MHz
Tsalida=100ns 5x20ns
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, ees, tildes, ..... Dentro del proyecto creamos una nueva fuente para realizar este contador llamada conta5.sch. Dentro de la ventana de smbolos, vamos a la categora de contadores (counter) y all escogemos el contador cb4cle. Esto es un Contador Binario de 4 bits, con Clear asncrono, carga paralelo de dato (Load) y habilitacin (Enable). Fjate que se han marcado en maysculas y negrita las letras que hacen formar el nombre del contador. Cmo hacer para contar 5 ciclos de reloj. La figura 18.3 muestra el esquemtico. En l, las salidas Q0 a Q3
que el count enable (CE) est siempre a uno. Por otro lado hay una seal de carga de dato (L: Load), esta seal 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
Figura 18.3: Esquemtico del contador de cinco ciclos de reloj Como se ve en la figura 18.2, al 4 llegar a de inicializar el contador. La debemos puesta a cero la haremos siempre sncrona. Y por tanto, activaremos la seal de carga L para introducir un cero (inicializar sncronamente)en el contador. Aunque existe un CLEAR asncrono que inicializa el contador, por ser asncrono, nosotros no lo usaremos para
Figura 18.4: Otra versin del esquemtico del contador de cinco ciclos de reloj (ms genrica)
Q3 Q2 0 0 0 0 0 0 0 0 0 1 0 0 0 0 0 0 0 0 0 1 0 0 0 0 ..... Q1 0 0 1 1 0 0 0 1 1 0 0 0 Q0 Cuenta 0 0 1 1 0 2 1 3 0 4 Iniciar la cuenta 0 0 cuando Q2=1 ent 1 1 onces 0 2 1 3 0 4 Iniciar la cuenta 0 0 1 1
Figura 18.5: Secuencia del contador En la figura 18.4 se muestra un contador de 5 ms genrico 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 diseo, gurdalo y crea un smbolo. Es bastante recomendable que lo simules para que veas el funcionamiento del contador. Ahora, a la salida de conta5 tenemos una seal de 10MHz (100ns). Utilizaremos esta seal, y contaremos 10 ciclos de esta seal. A la salida de nuestro nuevo contador tendremos una seal de 1MHz (1000ns=1s).
f=10MHz T=100ns Aqu contamos ciclos de T100NS no de reloj, y por eso es la entrada de CE f=1MHz T=1s=1000ns
f=50MHz T=20ns
onta5
1 Clk CE Clk CLEAR T100NS T100NS
conta10
CE Clk CLEAR T1US 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 situacin es distinta, ya que antes tenamos 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 inicializacin del contador se realiza cuando la cuenta sea 9 y adems la entrada CE sea uno. Si no se esperase a que CE=1, entonces la cuenta de 9 durara tan slo un ciclo de reloj. En la figura 18.7 se muestra este cronograma.
4 0 1 2 3 4 0 1 2 3 4 0 1 2 3 4 0 1 2 3 4 0 1 2 3 4 0 1 2 3 4 0 1 2 3 4 0 1 2 3 4 0 1 2 3 4 0 1 2 3 4 0 1 2 3 4 0 1 2 3 4 0
CLK 50 MHz T100NS 10 MHz
8
T1US 1 MHz
Figura 18.7: Cronograma del contador de 10
Se inicializa cuando la cuenta sea 9 y CE=1
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. Adems, ahora el fin de cuenta se determinar al llegar a 9 y no a 4, e incluye la seal CE para que espere a la siguiente orden de cuenta para cambiar de valor.
Figura 18.8: Esquemtico del contador de 10 Al terminar, guardamos el diseo, lo comprobamos y creamos su smbolo. Igualmente sera conveniente simularlo. Si conectamos estos dos bloques como se muestra en la figura 18.6 tendremos la seal T1US cuya frecuencia es de 1MHz. Todava tenemos que dividir la frecuencia entre un milln (106), para lograr la frecuencia de 1 Hz (1 ciclo por segundo). Aunque hay maneras ms 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, podamos 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,
Figura 18.9: Esquemtico del diseo del parpadeo de un LED Ahora, implementa el circuito y comprueba con un reloj que ms o menos funciona bien. Ten en cuenta que durante un segundo el LED deber estar luciendo y en el siguiente segundo estar apagado.
19. Reloj digital
19. Reloj digital

Ahora vamos a hacer un pequeo 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 prctica 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.
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 mostrarn los 60 segundos de un minuto: ir por tanto de 0 a 59. Los dos displays de la derecha mostrarn los 60 minutos de una hora. Por tanto, tambin ir de 0 a 59. Adems, 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 prctica anterior conta5.sch, conta10.sch y de la prctica del sumador (o cualquier otra que lo use) coge las fuentes decod4_16.sch y hex7seg.sch. Ya sabes cmo se hacer, recuerda usar la instruccin ProjectAdd Copy of Source para que se copie en tu proyecto y no modifique lo que has hecho
Vcc
segundero
CE Clk CLEAR T500MS T1S CE
contador10
Q0 Q1 Q2 Q3 I0 I1 I2 I3
HEX7SEG
F
G D
B C
SEG(6:0)
Clk CLEAR
Figura 19.1: Diagrama de bloques inicial
19.2.1. Bloque segundero

Para hacer este bloque usaremos parte de lo que hicimos en la prctica anterior. Copia el fichero blink.sch del anterior proyecto y cpialo en el directorio de tu nuevo proyecto, y cmbialo de nombre: segundero.sch. Y adelo al proyecto: ProjectAdd Source (no hace falta que sea copia porque ya lo hemos copiado nosotros ). Abre el esquemtico segundero.sch y vamos a modificarlo. Lo que vamos a hacer es un bloque que nos devuelva una seal de periodo un segundo y otro de medio segundo. Cmo lo haras? 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 informacin deberas poder hacerlo t slo. Para hacerlo, podramos 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
87
Departamento de Tecnologa Electrnica Divisor de frecuencia x5 f=10Hz T=100ms T100MS Clk f=2Hz T=500ms T500MS T500MS Divisor de frecuencia x2 f=1Hz T=1000ms=1s T1S
19. Reloj digital
conta5
CE Clk
conta2
CE Clk
T1S
CLEAR Entrada de 100 ms
CLEAR T500MS Salida de medio segundo T1S Salida de un segundo
Figura 19.2: Esquema para obtener una seal de medio segundo y de un segundo. Otra alternativa es hacerlo con un nico contador de 10, pero detectando cundo 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 condicin que la CE='1' (en este caso la seal CE es la seal T100ms. La figura 19.3 muestra esta otra alternativa.
Figura 19.3: Alternativa al circuito que obtiene una seal de un segundo y otra de medio segundo Esta alternativa tiene varios puntos interesantes: por un lado utilizamos slo un contador. Pero lo ms importante que hay que tener en cuenta es lo relativo a la seal 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 nmeros 5, 6 y 7 tambin tienen que Q2='1'. Otro aspecto interesante es que la seal de periodo medio segundo (T500MS) se forma con la OR de las seales que identifican la cuenta de 4 y 9. Por ltimo, no olvides incluir la seal CE en las detecciones, porque si no, la seal no durara un slo 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.
88
Cuenta 0: 1: 2: 3: 4: 5: 6: 7: 8: 9: 0: 1: .. 0000 0001 0010 0011 0100 0101 0110 0111 1000 1001 0000 0001 ....
Departamento de Tecnologa Electrnica Detectar 4 (no es fin de cuenta) Hay que detectar los '1' y los '0': Q0 Q1 Q2 Q3 CE T500MS Detectar 9 (fin de cuenta) basta con detectar los '1': Q0 Q3 CE T1S Esta seal tiene periodo de medio segundo. Esta seal tiene periodo de un segundo tambin, por lo que hay que hacer la OR con la de la cuenta de 9
19. Reloj digital
No es el nico que tiene Q2='1' Q2='1' El nico que tiene Q3='1' y Q0='1'
No olvidar el CE (en este caso es T100MS)
Figura 19.4: Deteccin del 4 en una cuenta de 0 a 9, y generacin de la seal de periodo de 500ms Independientemente de qu alternativa hayas escogido para hacer el circuito, crea un smbolo del circuito que debe tener las entradas y salidas
segundero
CE Clk CLEAR T500MS T1S T1S
las entradas asncronas se suelen dibujar debajo
Figura 19.5: Bloque del segundero
19.2.2. Bloque de mayor jerarqua

Este bloque contendr los bloques de la figura 19.1. Creamos una nueva fuente llamada displ_segund.sch. En realidad este bloque lo deberas saber hacer slo. As que simplemente en la figura 19.6 se muestra una posible solucin. Asegrate que si copias la solucin, la entiendes (si no, no vale de nada).
Figura 19.6: Esquemtico del circuito que muestra las unidades de segundo
19.3. Reloj digital con segundos y minutos

Este diseo es algo ms complejo, no por contar los segundos y minutos, que si has entendido el ejercicio anterior no te ser difcil, sino por el manejo de los cuatro displays de siete segmentos.
19. Reloj digital
Quizs te hayas fijado que slo hay una letra de cada segmento para los cuatro displays, es decir, slo hay una A, B, C,..., G para los cuatro. Y luego hay una seal de control AN para cada segmento. As que, cmo podramos mostrar nmeros 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 nmero determinado, y en el siguiente ciclo, el siguiente display con otro nmero. Y as los cuatro, al final, cada display lucir slo un cuarto de tiempo (as que lucirn con menos intensidad), pero lo har tan rpido que nuestro ojo no notar que gran parte del tiempo no est luciendo. Lo que queremos generar se muestra en la
T1ms
Minutos Segundos
CUENTA4MS S AN_0 AN_1 AN_2
decenas unidades decenas unidades
DM
AN_3
UM
AN_2
DS
AN_1
US
AN_0
AN_3 NumDispl pl
US DS UM DM US DS UM DM
Segn el valor de CUENTA4MS se selecciona las unidades o decenas de minutos o segundos
4 x 1 ms
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 ms 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 estaramos desperdiciando un alto porcentaje de los pines disponibles para algo que en realidad no es necesario. Con esta alternativa se usan 8 pines (ms las 4 seales de encendido: AN_0,..., pero stas se tienen que aadir tambin a los 32 pines de antes). Y ahora, se te ocurre cmo hacer el circuito que implementa el reloj? cmo generar las seales AN_0,...,AN_3 y NumDispl de la figura 19.7? Intenta pensarlo antes de mirar la solucin ya que todos los conceptos necesarios para implementarlos se han visto ya. 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 seal de periodo 1 ms como salida. Esto es, hacer un bloque como muestra la figura 19.8
segundero
T1MS CE Clk CLEAR T500MS T1S T1S
Figura 19.8: Nueva versin del segundero
Luego, utilizaremos la seal de 1 ms (T1MS) para contar 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 segn en qu cuenta estemos de la seal 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
90
19. Reloj digital
alternativas, por tanto dos bits para la seal de seleccin (CUENTA4MS), y con 4 bits cada alternativa. La figura 19.9 muestra cmo se podra realizar esta parte.
US DS UM DM
4
00 01 10 11
2
HEX7SEG
4
A F G D B C
I0 I1 I2 I3
SEG(6:0)
NumDispl(3:0)
CUENTA4MS(1:0)
Figura 19.9: Seleccin de las unidades o decenas de minuto o segundo segn el valor de CUENTA4MS En el captulo no vimos cmo hacer un multiplexor de 4 entradas de datos (y dos bits de seleccin) a partir de multiplexores de dos entradas de dato (1 bit de seleccin). Esto se ha explicado en clase y la figura 19.10 te lo recuerda. Aunque las seales de dato (A, B, C y D) slo tienen bit y no 4, la extensin es similar (recuerda la figura 12.2).
MUX4
A B C D 00 01 10 11 Z 0 1 C D 0 1 Z A B 0 1
SEL1 SEL0 SEL0
SEL1
Figura 19.10: Multiplexor de 4 entradas de dato a partir de multiplexores de dos entradas de dato Por ltimo, para generar las seales de encendido de los displays nos podemos fijar que slo 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 seales de encendido deen losel displays Ya estando tan avanzados 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 electrnica digital, sabes realizar un reloj digital. Si no te sale y ests perdido, a continuacin se muestra un solucin.
19.3.2. Solucin
Como el diseo es bastante grande, se dar la solucin por partes. Primero, en la figura 19.11 se muestra cmo hacer la decodificacin del control de los displays. El contador de 4 milisegundos obtiene un nmero de 0 a 3 que se decodifica y activa las seales AN_0, AN_1, AN_2 AN_3. Fjate que hay que invertirlas por ser a nivel bajo. La seal del punto decimal, que va a separar segundos de minutos. Se genera igual que en el contador de 10 segundos (captulo 19.2), sin embargo la salida queremos que est activa
91
19. Reloj digital
Figura 19.11: Decodificacin del control de los displays En la figura 19.12 se muestra la cuenta de segundos y minutos. Esta cuenta la deberas de saber hacer t slo. Es muy importante ya que es algo bsico que adems suele caer en los exmenes.
Figura 19.12: Contador de segundos y minutos Por ltimo, en la figura 19.13 se muestra el multiplexor que selecciona qu dgito se va a mostrar segn qu segmento est activado. Fjate que el multiplexor no lo hemos hecho. En el captulo 12 hicimos un multiplexor de dos datos y un bit de seal de seleccin. Ahora son 4 entradas de datos (figura 19.9).
92
19. Reloj digital
Figura 19.13: Multiplexor para la seleccin del dgito a mostrar por los displays
93

Pract Xilinx92

Caricato da

Informazioni sul documento

Copyright

Formati disponibili

Condividi questo documento

Condividi o incorpora il documento

Opzioni di condivisione

Hai trovato utile questo documento?

Questo contenuto è inappropriato?

Copyright:

Formati disponibili

Pract Xilinx92

Caricato da

Copyright:

Formati disponibili

Departamento de Tecnologa Electrnica

Diseo digital con esquemticos y FPGA.

Felipe Machado Snchez Norberto Malpica Gonzlez de Vega

Departamento de Tecnologa Electrnica

3. Puertas lgicas, interruptores y pulsadores .................................................................................................................. 15

7. Convertidor de hexadecimal a 7 segmentos ................................................................................................................. 35

9. Extensin de la capacidad de un codificador ................................................................................................................ 46

10. Comparadores ............................................................................................................................................................ 48

13. El sumador .................................................................................................................................................................. 60

14. Sumador/restador ....................................................................................................................................................... 63

18. Parpadeo de un LED................................................................................................................................................... 84

19. Reloj digital.................................................................................................................................................................. 87

Diseo digital con esquemticos y FPGA. v1.8 - 04/06/2008

Departamento de Tecnologa Electrnica

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

Diseo digital con esquemticos y FPGA. v1.8 - 04/06/2008

Departamento de Tecnologa Electrnica FPGA Conector JTAG Conector de expansin

2. Encender un LED Memoria Fla Flash

Alimentacin Jumpers de configuracin PS/2 LED D Display segmentos 7s Pulsadores Interruptores

Departamento de Tecnologa Electrnica

2.1. Diseo del circuito

Departamento de Tecnologa Electrnica

tipo de dispositivo encapsulado velocidad rango de operacin C: comercial

XC2S200 XC2S200 PQ208

cdigo de fecha cdigo de lote

Mirar en la FPGA Mirar en la FPGA

Diseo digital con esquemticos y FPGA. v1.8 - 04/06/2008

Departamento de Tecnologa Electrnica

Departamento de Tecnologa Electrnica

Plano donde dibujaremos el circuito

Opciones Opciones Procesos

Diseo digital con esquemticos y FPGA. v1.8 - 04/06/2008

Departamento de Tecnologa Electrnica

Figura 2.10: Esquema final de nuestro circuito

Departamento de Tecnologa Electrnica

2.2. Sntesis e implementacin del circuito

Diseo digital con esquemticos y FPGA. v1.8 - 04/06/2008

Departamento de Tecnologa Electrnica

2.3. Programacin de la FPGA

Diseo digital con esquemticos y FPGA. v1.8 - 04/06/2008

Departamento de Tecnologa Electrnica jumper conectado jumper desconectado

2. Encender un LED jumper desconectado sin perder su caperuza

Diseo digital con esquemticos y FPGA. v1.8 - 04/06/2008

Departamento de Tecnologa Electrnica

Figura 2.16: Orden para programar la FPGA

Departamento de Tecnologa Electrnica

Diseo digital con esquemticos y FPGA. v1.8 - 04/06/2008

Departamento de Tecnologa Electrnica

3. Puertas lgicas, interruptores y pulsadores

3. Puertas lgicas, interruptores y pulsadores

3.1. Diseo del circuito

Y tendremos una pantalla

AND de 2 entradas con una de ellas negada

AND de 3 entradas con dos de ellas negadas

Diseo digital con esquemticos y FPGA. v1.8 - 04/06/2008

Departamento de Tecnologa Electrnica

3. Puertas lgicas, interruptores y pulsadores

y LD3). Y deber tener el

Figura 3.8: Diseo final del ejercicio

Diseo digital con esquemticos y FPGA. v1.8 - 04/06/2008

Departamento de Tecnologa Electrnica

3. Puertas lgicas, interruptores y pulsadores

3.2. Simulacin del circuito

Departamento de Tecnologa Electrnica