Documentos de Académico
Documentos de Profesional
Documentos de Cultura
Diseño Digital Con Esquematicos y FPGA
Diseño Digital Con Esquematicos y FPGA
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
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
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
ndice
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
LED, 4 displays de 7 segmentos, 4 botones, 8 interruptores, un puerto PS/2 (para ratn o teclado), y puerto
VGA (para conectar un monitor), y varios puertos de expansin. En la figura 1.1 se muestra la placa Pegasus,
y en la que se sealan varios de sus componentes. La foto de la placa no coincide exactamente con la versin
de la placa que tenemos en el laboratorio y hay algunos componentes que no estn en el mismo lugar,
aunque s todos los que se han sealado.
http://gtebim.es
Herramienta gratuita que se puede descargar en http://www.xilinx.com
3 http://www.digilentinc.com
1
2
Conector JTAG
FPGA
2. Encender un LED
Memoria
Flash
VGA
Alimentacin
Jumpers de
configuracin
PS/2
Display
7 segmentos
LED
Pulsadores
Interruptores
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 FPGA. As, podemos ver cmo al lado del LED 0 (LD0) de la
placa est el nmero 46 entre parntesis. Podemos apreciar que esto se cumple para casi todos los
componentes: pulsadores, interruptores, ...
'1' Encendido
'0' Apagado
390
Spartan-II
PIN
46
45
44
43
42
41
37
36
LED
LD0
LD1
LD2
LD3
LD4
LD5
LD6
LD7
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.
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 a crear nuestro nuevo proyecto, pinchamos en FileNew Project... y nos saldr la ventana New
Project Wizard Create New Project como la mostrada en la figura 2.2. En ella pondremos el nombre del
proyecto, que lo llamaremos led0, indicamos la ruta donde guardaremos el proyecto
(C:/practica/edi/tunombre). Respecto al nombre y a la ruta, no es conveniente trabajar desde un
dispositivo de memoria USB, ni tampoco incluir en la ruta o el nombre ni acentos ni 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 esquemticos.
tipo de dispositivo
encapsulado
XC2S200
2. Encender un LED
cdigo de fecha
PQ208
cdigo de lote
velocidad
5C
rango de operacin
C: comercial
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 el proyecto creado y ahora nos disponemos a crear nuestro diseo. Para ello creamos una nueva
fuente pinchando en ProjectNew Source.
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 Next y en la siguiente ventana en Finish.
2. Encender un LED
Seleccionar led0.sch
2. Encender un LED
Opciones
Fuentes
Smbolos
Procesos
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 de alimentacin, seguramente la veas un poco pequea. Para ampliar la
zona puedes pinchar en ViewZoomZoom In (o bien pulsar F8).
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 seleccin (con su flechita habitual) basta con pulsar
la tecla de escape (Esc) o bien pulsar el icono de la flechita que est en la barra de herramientas
Si por error hemos incluido un 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 cortar de la misma manera que
se hace en Windows.
2. Encender un LED
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.
10
2. Encender un LED
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
11
2. Encender un LED
jumper desconectado
sin perder su caperuza
jumper
desconectado
su caperuza
est perdida y
pisoteada por el
suelo del labo
Representacin:
12
2. Encender un LED
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 ventana sin cambiar nada (si disemos a Verify dara un error de programacin).
13
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
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
4,7k
Spartan-II
3,3V
Spartan-II
3,3V
interruptor
SW0
SW1
SW2
SW3
SW4
SW5
SW6
SW7
4,7k
4,7k
0,1F
PIN pulsador
59
BTN0
58
BTN1
57
BTN2
154 BTN3
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.
AND de 2 entradas
and2b1
and3b2
OR,
y su salida la
15
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
SW1
BRN0)
y 4 salidas (LD0,
LD1, LD2
LD3).
Y deber tener el
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 el esquemtico: FileSave (esto deberas hacerlo regularmente).
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.
En la parte superior de la ventana de fuentes, vemos que indica Sources for: "Synthesis/Implementation" (ver
figura 3.9). El men desplegable permite seleccionar el tipo de ficheros fuente con los que se quiere trabajar:
para simulacin o para sntesis. Es importante conocer esta opcin, debido a que nos puede ocurrir que no
veamos un fichero que hemos creado a causa de tener seleccionada una opcin que no lo muestra. Por
ejemplo, los ficheros para simulacin no se vern en caso de tener seleccionada la opcin de sntesis.
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.
17
"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 combinacional, y por tanto, en el
apartado de Clock Information, seleccionamos Combinatorial (or internal clock). Adems, deseleccionamos la
casilla GSR (FPGA) y el resto de opciones las dejamos como estn y pinchamos en Finish.
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
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 que se quieren asignar a los puertos
de entrada y los intervalos de tiempo en que se asignarn. Tambin se muestra los valores que deben salir
(los valores de los LED) y que ms adelante comprobaremos si coinciden con los de la simulacin.
LD1: OR
LD0: AND
tiempo
0-100ns
100-200
200-300
300-400
tiempo
0-100ns
100-200
200-300
300-400
LD2: NOT
SW2 SW3 LD1
0
0
0
0
1
1
1
0
1
1
1
1
tiempo
0-200ns
200-400
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 diseo 4: UUT swt0(swt0.sch).
UUT indica el componente que se est comprobando, es el acrnimo del ingls: Unit Under Test
19
20
4. Decodificador de 2 a 4
4. Decodificador de 2 a 4
En este ejercicio implementaremos un decodificador de 2 a 4 como los que hemos visto en clase. Un
decodificador de 2 a 4 recibe dos entradas que 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
S0
S1
A1
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
C:/practica/edi/tunombre.
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 inversores de las entradas A1 y A0. Y posteriormente les
conectamos los puertos de entrada (figura 4.2).
Figura 4.2: Inversores colocados a las entradas para formar los trminos mnimos
). El otro lado del cable lo
Ahora conectamos un cable a la salida de cada inversor (mediante el icono
dejamos al aire: pinchamos en un punto 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 AddNet Name
(tambin hay un icono
). Y en la ventana de opciones, en el apartado Name ponemos el nombre del cable.
Para el negado de A1 lo llamamos N_A1, y el negado de A0 lo llamamos N_A0. Para colocarlo nos ponemos al
final del cable y pinchamos encima. Para colocar el segundo, cambiamos el nombre y repetimos la operacin.
Llegados a este punto, deberamos tener:
21
4. Decodificador de 2 a 4
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 las uniones se forma
un cuadradito que indica la conexin entre cable. Al terminar de unir los cables tendremos un circuito como
el siguiente. Si te equivocas, usa CTRL+Z para deshacer la ltima unin.
22
4. Decodificador de 2 a 4
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
m0
E
S0
S0='0'
S0=m0
Como slo tenemos 3 entradas, introduciremos las 8 combinaciones posibles. stas se muestran en la figura
4.8.
23
4. Decodificador de 2 a 4
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
24
4. Decodificador de 2 a 4
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.
25
4. Decodificador de 2 a 4
Esquema
Esquema en
en puertas
puertas
Smbolo
Smbolo
26
5. Decodificador de 3 a 8
5. Decodificador de 3 a 8
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.
S0
A0
S1
DECOD 3a8
A1
A2
E
0
1
1
1
1
1
1
1
1
S2
S3
S4
S5
S6
S7
A2
X
0
0
0
0
1
1
1
1
A1
X
0
0
1
1
0
0
1
1
A0
X
0
1
0
1
0
1
0
1
S7
0
0
0
0
0
0
0
0
1
S6
0
0
0
0
0
0
0
1
0
S5
0
0
0
0
0
0
1
0
0
S4
0
0
0
0
0
1
0
0
0
S3
0
0
0
0
1
0
0
0
0
S2
0
0
0
1
0
0
0
0
0
S1
0
0
1
0
0
0
0
0
0
S0
0
1
0
0
0
0
0
0
0
A2
(figura 5.2),
S4
S3
S0
S0
S7
S4
A2 A1 A0
X X X
S7 S6 S5 S4 S3 S2 S1 S0
0 0 0 0 0 0 0 0
todas '0'
E
1
1
1
1
A2
0
0
0
0
A1
0
0
1
1
A0
0
1
0
1
S7
0
0
0
0
S6
0
0
0
0
S5
0
0
0
0
S4
0
0
0
0
todas '0'
misma
secuencia
E
1
1
1
1
A2
1
1
1
1
A1
0
0
1
1
A0
0
1
0
1
S7
0
0
0
1
S6
0
0
1
0
S5
0
1
0
0
S3
0
0
0
1
S2
0
0
1
0
S1
0
1
0
0
S0
1
0
0
0
A2 = '0'
S3
0
0
0
0
S2
0
0
0
0
S1
0
0
0
0
S0
0
0
0
0
A2 = '1'
todas '0'
27
5. Decodificador de 3 a 8
Intenta realizarlo t mismo, y si no te sale puedes ver la solucin en la figura 5.5. A continuacin vamos a
disearlo.
Smbolos
Smbolos del
del proyecto
proyecto
Smbolo
Smbolo del
del decodificador
decodificador de
de 22 aa 44
Decodificador
Decodificador de
de 22 aa 44
28
5. Decodificador de 3 a 8
En el mapa del circuito aadimos dos referencias a decod2a4, que como ya hemos dicho, un decodificador es
para las 4 primeras salidas y el otro para el resto.
Ahora realizamos las conexiones entre los decodificadores decod2a4 y las entradas y salidas del nuevo
decodificador decod3a8. Incluyendo tambin las seales de habilitacin de cada uno de ellos, usando para
ello puertas AND. Nota que para la habilitacin del decodificador superior, la puerta AND debe tener la
entrada de A2 negada. El circuito final se muestra en la figura 5.5.
Figura 5.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
6. Decodificador de 4 a 16
6. Decodificador de 4 a 16
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.
A1
A1
X
0
0
1
1
0
0
1
1
0
0
1
1
0
0
1
1
S8
0
0
0
0
0
0
0
0
0
1
0
0
0
0
0
0
0
S7
0
0
0
0
0
0
0
0
1
0
0
0
0
0
0
0
0
S6
0
0
0
0
0
0
0
1
0
0
0
0
0
0
0
0
0
S5
0
0
0
0
0
0
1
0
0
0
0
0
0
0
0
0
0
S4
0
0
0
0
0
1
0
0
0
0
0
0
0
0
0
0
0
S3
0
0
0
0
1
0
0
0
0
0
0
0
0
0
0
0
0
S2
0
0
0
1
0
0
0
0
0
0
0
0
0
0
0
0
0
S1
0
0
1
0
0
0
0
0
0
0
0
0
0
0
0
0
0
S0
0
1
0
0
0
0
0
0
0
0
0
0
0
0
0
0
0
decod 4
A2
X
0
0
0
0
1
1
1
1
0
0
0
0
1
1
1
1
decod 3
A3
X
0
0
0
0
0
0
0
0
1
1
1
1
1
1
1
1
decod 2
A3
DECOD4a16
A2
E
0
1
1
1
1
1
1
1
1
1
1
1
1
1
1
1
1
decod 1
S0
S1
S2
S3
S4
S5
S6
S7
S8
S9
S10
S11
S12
S13
S14
S15
A0
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
A3
0
0
0
0
A2
1
1
1
1
A1
0
0
1
1
A3
1
1
1
1
A2
0
0
0
0
A1
0
0
1
1
A3 = '1'
A2 = '0'
E
1
1
1
1
A3
1
1
1
1
A2
1
1
1
1
A3 = '1'
misma A2 = '1'
secuencia
S6
0
0
0
0
S5
0
0
0
0
A1
0
0
1
1
S8
0
0
0
0
S7
0
0
0
1
S6
0
0
1
0
S5
0
1
0
0
S8
1
0
0
0
S7
0
0
0
0
S6
0
0
0
0
S5
0
0
0
0
S2
0
0
1
0
S1
0
1
0
0
S0
1
0
0
0
decod 0
activo cuando
A3 = '0'
A2 = '0'
S4
1
0
0
0
S3
0
0
0
0
S2
0
0
0
0
S1
0
0
0
0
S0
0
0
0
0
decod 1
activo cuando
A3 = '0'
A2 = '1'
todas '0'
S4
0
0
0
0
S3
0
0
0
0
S2
0
0
0
0
S1
0
0
0
0
S0
0
0
0
0
S1
0
0
0
0
S0
0
0
0
0
decod 2
activo cuando
A3 = '1'
A2 = '0'
todas '0'
igual que
decod2a4
igual que
decod2a4
S3
0
0
0
1
igual que
decod2a4
todas '0'
S4
0
0
0
0
todas '0'
A3 = '0'
A2 = '1'
E
1
1
1
1
S7
0
0
0
0
todas '0'
A3 = '0'
A2 = '0'
E
1
1
1
1
S8
0
0
0
0
S8
0
0
0
0
S7
0
0
0
0
S6
0
0
0
0
S5
0
0
0
0
S4
0
0
0
0
S3
0
0
0
0
S2
0
0
0
0
decod 3
activo cuando
A3 = '1'
A2 = '1'
todas '0'
30
6. Decodificador de 4 a 16
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.
Seales de habilitacin de los 4 decodificadores
E
0
1
1
1
1
A3
X
0
0
1
1
A2
X
0
1
0
1
E3
0
0
0
0
1
E2
0
0
0
1
0
E1
0
0
1
0
0
E0
0
1
0
0
0
31
6. Decodificador de 4 a 16
32
6. Decodificador de 4 a 16
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
entradas A0, A2, A2 y A3, e incluimos unas cuantas ms para probar que la habilitacin E funciona bien. En la
figura 6.7 se muestra los valores a las entradas. Con lneas discontinuas se han sealado el intervalo de
tiempo en el cual una de las seales de salida se deben activar. En la parte inferior de la figura, entre las
lneas discontinuas, se muestra cul de las seales de salida es la que se debe activar. Observa tambin que al
principio y al final de la simulacin se ha puesto la seal de habilitacin a cero para ver si funciona bien.
Intenta entender el cronograma para que en ejercicios posteriores puedas hacerlo t solo.
inhabilitado
0 1
2 3 4 5
6 7 8 9 10 11 12 13 14 15 0 1
inhabilitado
33
6. Decodificador de 4 a 16
Tiempo de simulacin
Simular por el tiempo especificado
34
7. Convertidor de hexadecimal a 7
segmentos
A
F
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 estar encendidos los segmentos B y C.
Para el nmero 8 todos los segmentos debern estar encendidos.
DP
A continuacin se muestra la codificacin de los 16 nmeros hexadecimales (figura 7.2), como podrs
apreciar, algunos nmeros admiten ms de una representacin, por ejemplo, el 6 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, usaremos la de la figura 7.2.
A
F
E
G
D
B
C
A
F
B
C
A
F
E
G
D
B
C
A
F
B
C
A
F
E
G
D
B
C
A
F
A
F
E
G
D
B
C
A
F
B
C
A
F
E
G
D
B
C
A
F
B
C
A
F
E
G
D
B
C
A
F
A
F
E
G
D
B
C
A
F
A
F
E
G
D
B
C
A
F
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.
35
7. Convertidor de hexadecimal a 7
segmentos
HEX7SEG
SEG_A
SEG_B
SEG_C
SEG_D
SEG_E
SEG_F
SEG_G
SEG_DT
AN_0
AN_1
AN_2
AN_3
I0
Nmero codificado:
I1
A los interruptores:
SW0, SW1, SW2, SW3
I2
I3
Habilitacin:
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
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 el nmero de puertas para un diseo pequeo como el nuestro no es problemtico.
5
Disponible en http://laimbio08.escet.urjc.es/assets/files/docencia/EDI/pbs3_02.pdf
36
7. Convertidor de hexadecimal a 7
segmentos
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.
Para la A tomamos las salidas 1, 4, 11 y 13
I3
0
0
0
0
0
0
0
0
1
1
1
1
1
1
1
1
I2
0
0
0
0
1
1
1
1
0
0
0
0
1
1
1
1
I1
0
0
1
1
0
0
1
1
0
0
1
1
0
0
1
1
I0
0
1
0
1
0
1
0
1
0
1
0
1
0
1
0
0
A
0
1
0
0
1
0
0
0
0
0
0
1
0
1
0
0
I0
I1
m1
I2
I3
E
m4
A0
A1
A2
A3
E
S0
S1
S2
S3
S4
S5
S6
S7
S8
S9
S10
S11
S12
S13
S14
S15
m11
m13
SEG_A
Lgica negada:
I2
0
0
0
0
1
1
1
1
0
0
0
0
1
1
1
1
I1
0
0
1
1
0
0
1
1
0
0
1
1
0
0
1
1
I0
0
1
0
1
0
1
0
1
0
1
0
1
0
1
0
0
A
0
1
0
0
1
0
0
0
0
0
0
1
0
1
0
0
m1
m4
SEGA
m1
m11
m13
m4
Los 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
A
F
A
F
E
G
D
B
C
D
13
A
F
B
C
A
F
E
G
D
B
C
I3
0
0
0
0
0
0
0
0
1
1
1
1
1
1
1
1
I2
0
0
0
0
1
1
1
1
0
0
0
0
1
1
1
1
I1
0
0
1
1
0
0
1
1
0
0
1
1
0
0
1
1
I0
0
1
0
1
0
1
0
1
0
1
0
1
0
1
0
0
A
1
0
1
1
0
1
1
1
1
1
1
0
1
0
1
1
m0
m2
m3
m5
m6
m7
m8
m9
m10
m12
m14
m15
m0
m2
m3
m5
m7
m8
m9
m10
m12
m14
m15
SEGA
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.
Diseo digital con esquemticos y FPGA. v1.8 - 04/06/2008
37
7. Convertidor de hexadecimal a 7
segmentos
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 salida se trata). Ver figura 7.7.
Ahora, a la primera entrada de la puerta OR le conectamos un cable corto. Esto es necesario porque los
cables son los que reciben el nombre y no las entradas de las puertas o componentes. Y por el mismo motivo,
a la salida S5 del decodificador le conectamos otro cable corto (ver figura 7.8). Vers que el final de ambos
cables estn en rojo, esto es porque estn desconectados.
S0
S1
S2
S3
S4
S5
S6
S7
S8
SEG_B
S9
S10
S11
S12
S13
S14
S15
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 el cable y volverle a conectar uno nuevo, porque si
renombramos, estaremos renombrando tanto ese cable que est en la pata de la OR como el cable de la salida
del decodificador. De todos modos, si intentsemos renombrar el cable sin borrarlo, seguramente aparecer
una advertencia que indica que ese otro nombre ya existe, pues corresponde a otra salida del decodificador.
38
7. Convertidor de hexadecimal a 7
segmentos
7.2. Implementacin
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 esquemticos que tenemos,
el convertidor de hexadecimal a 7 segmentos est por encima del decodificador. El convertidor debe de tener
el smbolo
, que significa que es el diseo de ms alta jerarqua. Si no estuviese tendras que pinchar con
el botn derecho del ratn encima de l y seleccionar "Set as Top Module".
Diseo digital con esquemticos y FPGA. v1.8 - 04/06/2008
39
7. Convertidor de hexadecimal a 7
segmentos
El decodificador es un
componente del convertidor
Aqu se escriben
las restricciones
40
7. Convertidor de hexadecimal a 7
segmentos
Ahora tenemos que escribir los puertos en el fichero UCF, que en realidad es lo que hace la herramienta
PACE. El texto que tenemos que escribir se muestra en el cdigo 7.1. El formato de estos ficheros es muy
sencillo:
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 as, intenta entender el
significado, ya que para las siguientes ocasiones tendrs que escribirlo t solo.
#Numero codificado en los interruptores SW0, SW1, SW2, SW3
NET "I0" LOC = "P89" ;
NET "I1" LOC = "P88" ;
NET "I2" LOC = "P87" ;
NET "I3" LOC = "P86" ;
#Enable en el SW7
NET "E" LOC = "P81"
#Encendido de los
NET "AN_0" LOC =
NET "AN_1" LOC =
NET "AN_2" LOC =
NET "AN_3" LOC =
#7 segmentos
NET "SEG_A"
NET "SEG_B"
NET "SEG_C"
NET "SEG_D"
NET "SEG_E"
NET "SEG_F"
NET "SEG_G"
LOC
LOC
LOC
LOC
LOC
LOC
LOC
displays
"P60" ;
"P69" ;
"P71" ;
"P75" ;
=
=
=
=
=
=
=
"P74"
"P70"
"P67"
"P62"
"P61"
"P73"
"P68"
#Punto decimal
NET "SEG_DT" LOC = "P63"
;
;
;
;
;
;
;
;
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, "SynthesizeXST", "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. Quizs crea que no funciona nada, y lo que
sucede es que tienes el circuito deshabilitado (SW7='0').
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.
I0
I1
I2
I3
S0
S1
entrada
activa
I0
I1
I2
I3
LED0
LED1
salidas
S1 S0
0 0
0 1
1 0
1 1
S0 se enciende cuando
I1 est activa o (OR)
cuando I3 est activa
I1
S0
I2
I3
S1 se enciende cuando
I2 est activa o (OR)
cuando I3 est activa
S1
Figura 8.1: Entradas y salidas del codificador, tabla de verdad y 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
BTN1
BTN0
LD1
LD0
LD1
LD0
00
01
BTN2
LD1
LD0
10
BTN3
LD0
LD1
BTN1 y BTN2
LD1
LD0
11
LD0
11
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.
42
salidas
S1 S0
0 0
0 0
0 1
1 0
1 1
entrada
activa
-I0
I1
I2
I3
8. Codificadores
I1
Diferencia entre
pulsar I0 y no
pulsar nada
A
0
1
1
1
1
S0
I2
I3
A se enciende cuando
cualquier entrada
est activa:
I0 + I1 + I2 + I3
S1
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 A como el LED 7 o bien continuar
realizando las modificaciones que queremos realizar. Llama al proyecto codif4a2.
Ahora queremos incluir un mdulo que determine las
prioridades, de manera que, aunque dos botones estn
pulsados, slo una lnea de entrada del decodificador
est activa. Pondremos la prioridad ms alta para el
bit ms significativo, de modo que si I2 e I1 estuviesen
pulsados, el codificador mostrase un 102 y no un 112
como estaba haciendo hasta ahora (recuerda el caso de
la derecha de la figura 8.2). El esquema que queremos
implementar se muestra en la figura 8.4
PRIOR
BTN0
BTN1
BTN2
BTN3
I0
I1
I2
I3
CODIF
P0
P1
P2
P3
puede haber ms de
una que valga 1
P0
P1
P2
P3
S0
S1
S0
SA
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 I3='0' la seal P2 valdr lo que
valga I2.
Si I3='1' entonces P2='0'
I2
I3
'0'
'0'
'1'
P2
I2
P3
I3
P2
'1'
'0'
'0'
P3
I1
I2
I3
P0
P1
P2
P3
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
43
8. Codificadores
circuito ms sencillo debido a que ese caso nunca se va a dar. Esta libertad no la tengo con las
entradas.
en las
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 el codificador est habilitado pero no hay
ninguna seal de entrada activa, nos diferencia de cuando el codificador no est habilitado. El bloque que
queremos realizar se muestra en la figura 8.7
CODIF
BTN0
BTN1
BTN2
BTN3
I0
I1
I2
I3
SW7
EI
EO
LED7
S0
S1
LED0
LED1
LED6
EI
0
1
1
1
1
1
I3
X
0
0
0
0
1
I2
X
0
0
0
1
X
I1
X
0
0
1
X
X
I0
X
0
1
X
X
X
S1
0
0
0
0
1
1
S0
0
0
0
1
0
1
A EO
0 0
0 1
1 0
1 0
1 0
1 0
Figura 8.7: Bloque y tabla de verdad del codificador con prioridad y habilitacin
Como vemos de la tabla de verdad de la figura 8.7, la salida EO vale '1' cuando
alturas, esta condicin nos debera ser fcil de implementar en puertas lgicas.
A0='0'
EI='1'.
A estas
EO
I0
P0
I1
P1
S0
I2
P2
S1
I3
P3
EI
44
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 tener un valor
determinado, no se deben dejar "al aire".
45
9. Extensin de la capacidad de un
codificador
I0
I1
I2
I3
I4
I5
I6
I7
SW0
EI
CODIF
EO
LED7
S0
S1
S2
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
I0
I1
I2
I3
S0
S1
A
EI
S0
S1
G_CODIF
BTN0
BTN1
BTN2
BTN3
SW0
I4
I5
I6
I7
EI
I0
I1
I2
I3
EI
LED7
EO
I0
I1
I2
I3
EO
S2
S0
S1
A
LED0
LED1
LED2
LED6
46
9. Extensin de la capacidad de un
codificador
Seales internas de
los codificadores
de 4 a 2
ninguna entrada de
G_CODIF activa
habilita a P_CODIF
alguna entrada de
G_CODIF activa
deshabilita a P_CODIF
ENTRADAS
G_CODIF
P_CODIF
EI
EI
0
1
1
1
1
1
1
1
1
1
I3
I7
X
0
0
0
0
0
0
0
0
1
I2
I6
X
0
0
0
0
0
0
0
1
X
I1
I5
X
0
0
0
0
0
0
1
X
X
I0
I4
X
0
0
0
0
0
1
X
X
X
EI I3
I3
0 X
1 0
1 0
1 0
1 0
1 1
0 X
0 X
0 X
0 X
I2
I2
X
0
0
0
1
X
X
X
X
X
I1
I1
X
0
0
1
X
X
X
X
X
X
SALIDAS
P_CODIF
G_CODIF
I0
I0
X
0
1
X
X
X
X
X
X
X
S1 S0 A EO
0
0
0
0
0
0
0
0
1
1
0
0
0
0
0
0
0
1
0
1
0
0
0
0
0
0
1
1
1
1
0
1
1
1
1
1
0
0
0
0
CODIF8a3
S1 S0 A EO
0
0
0
0
1
1
0
0
0
0
0
0
0
1
0
1
0
0
0
0
0
0
1
1
1
1
0
0
0
0
0
1
0
0
0
0
0
0
0
0
S2
0
0
0
0
0
0
1
1
1
1
S1
0
0
0
0
1
1
0
0
1
1
S0
0
0
0
1
0
1
0
1
0
1
A EO
0 0
0 1
1 0
1 0
1 0
1 0
1 0
1 0
1 0
1 0
Seales externas
(puertos) del
codificador de 8 a 3
S1 y S2 del CODIF8a3
lo proporciona P_CODIF
S1 y S2 del CODIF8a3
lo proporciona G_CODIF
P_CODIF
deshabilitado
Figura 9.3: Tabla de verdad del codificador de 8 a 3 con las seales internas
Ahora implementa en la placa el diseo de la figura 9.3:
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.
B
0
1
0
1
A=B
A>B
A<B
IGUAL
AM
0
0
1
0
BM
0
1
0
0
1
0
0
1
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
A B y A
B (estas se llaman and2b1 y tienen una bolita de
una entrada negada para implementar la funcin
negacin en una de sus entradas). Tambin tienes funciones XNOR para implementar la salida IGUAL.
Pon los puertos con los mismos nombres de la figura 10.1. Cuando tengas el circuito listo gurdalo (CRTL+S)
y comprueba el esquemtico (ToolsCheck Schematic).
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.
SW0
SW1
AM
LD0
IGUAL
LD1
BM
LD2
48
10. Comparadores
COMPA2
bit ms
significativo
bit ms
significativo
COMPA2
A0
A(1:0)
A1
IGUAL
AM
BM
B0
B1
B(1:0)
IGUAL
AM
BM
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 tabla 10.2.
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
IGUAL
1
0
0
0
0
1
0
0
0
0
1
0
0
0
0
1
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
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
A1>B1
Igual=0
AM=1
BM=0
A1=B1
comprobar
el LSB
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:
49
10. Comparadores
IGUAL=0 ; AM=0 ; BM = 1
IGUAL=0 ; AM=1 ; BM = 0
IGUAL=1 ; AM=0 ; BM = 0
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 Boole y puertas lgicas. La
figura 10.4 muestra la construccin del comparador de dos bits para las seales IGUAL y AM. Para no complicar
el esquema, no se ha dibujado el diagrama de puertas para la seal BM, pero es similar al de la seal AM.
Iguales
Si (A1=B1) y (A0=B0)
IGUAL_1=1
COMPA1
A0
B0
IGUAL_0
AM_0
IGUAL_0=1
BM_0
COMPA1
A1
B1
IGUAL_1
AM
AM_1
BM_1
IGUAL_1=1
AM_0=1
Figura 10.4: Comparador de dos bits hecho con comparadores de un bit (falta el A<B)
A0
SW0
A1
SW1
B0
SW2
B1
SW3
AM
LD0
IGUAL
LD1
BM
LD2
Tabla 10.3:
Asignacin de seales
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.
Diseo digital con esquemticos y FPGA. v1.8 - 04/06/2008
50
COMPA2
IGUAL_10
AM_10
A0
A1
IGUAL
BM_10
B0
B1
COMPA2
A2
A3
IGUAL_32
B2
B3
BM_32
AM
AM_32
BM
bits 3 y 2
IGUAL
AM
BM
IGUAL_LSB
AM_LSB
BM_LSB
B0_MSB
B1_MSB
A2
A3
COMP2_CAS
A0
A1
'1'
'0'
'0'
B0
B1
Comparador de
los bits ms
significativos
COMP2_CAS
A0_MSB
A1_MSB
A0_MSB
A1_MSB
IGUAL_LSB
IGUAL
AM_LSB
AM
BM_LSB
BM
IGUAL_LSB
AM_LSB
BM_LSB
B0_MSB
B1_MSB
B0_MSB
B1_MSB
IGUAL
AM
BM
IGUAL
AM
BM
B2
B3
Figura 11.3: Comparador de 4 bits conectando dos comparadores de dos bits en cascada
Diseo digital con esquemticos y FPGA. v1.8 - 04/06/2008
51
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.
Entradas de las
comparaciones de los bits
menos significativos (LSB)
IGUAL_LSB
AM_LSB
IGUAL
BM_LSB
Bits ms
significativos:
COMPA2
A0_MSB
A1_MSB
IGUAL
B0_MSB
B1_MSB
BM
AM
AM
BM
52
Ahora queremos conectar cada una de las lneas de los buses a las entradas del comparador. Para ello
empezamos aadiendo un conector al bus con el comando AddBus Tap. Al seleccionar ste comando, en la
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.
Nombre
Nombre
Increase
Increase the
the name
name
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 11.8.
el
esquemtico
(ToolsCheck
Schematic)
la
jerarqua
SW0
B(0)
SW4
IGUAL
LD1
A(1)
SW1
B(1)
SW5
AM
LD0
A(2)
SW2
B(2)
SW6
BM
LD2
A(3)
SW3
B(3)
SW7
LOC = "P89"
LOC = "P88"
;
;
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:
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
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.
55
MUX
A
12. El multiplexor
AM
AM
A(1)
A(1)
A(0)
MUX2_2b
A(1:0)
B(1:0)
2
2
B(1)
equivalente
0
S(1)
AM
S(1:0)
S(1:0)
1
B(1:0) 2
AM
A(0)
B(1)
B(0)
B(0)
S(0)
AM
AM
A(3:0)
SEG(6:0)
A_7SEG
7
HEX7SEG
SEG(6:0)
B(3:0)
SEG_A
SEG_B
SEG_C
SEG_D
SEG_E
SEG_F
SEG_G
MUX
I(3:0)
B_7SEG
I(3:0)
COMP4
A(3:0)
AM
IGUAL
B(3:0)
BM
AN_0
AN_3
56
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 a ti.
HEX7SEG
MUX
A(3:0)
B(3:0)
I(3:0)
COMP4
SEG(6:0)
SEG_A
SEG_B
SEG_C
SEG_D
SEG_E
SEG_F
SEG_G
A(3:0)
AM
IGUAL
B(3:0)
BM
AN_0
AN_3
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 decod4a16.sch y hex7seg.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
Ordenamos los puertos si no estuviesen ordenados.
hex7seg.
A continuacin vamos a crear un multiplexor de 2 entradas de dato y una de seleccin, con 4 bits en cada
entrada de dato. Creamos una nueva fuente llamada mux2_4bit. Podramos crear el multiplexor con puertas
como se muestra en la figura 12.1 (con la diferencia que ahora cada lnea de datos tiene 4 bits) sin embargo
para tardar menos vamos a usar los multiplexores de dos entradas de 1 bit que tiene el ISE: ventana de
smbolos, selecciona la categora Mux, y dentro de los smbolos selecciona el m2_1. El multiplexor diseado
debera quedar parecido a como lo muestra 12.5. Hemos llamado a las entradas D0 y D1, que se refieren al
dato que se selecciona cuando SEL vale 0, y cuando SEL vale 1, respectivamente.
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 A y B sern iguales? pues cuando ni A sea mayor que B ni A sea menor que B. Y esto que acabamos
GT
LT . Otra manera de decirlo es que A y B son
de decir en lgebra de Boole se traduce como: IGUAL =
GT+LT . Fjate que las dos
iguales cuando no ocurre que A sea mayor que B, o que A sea menor que B: IGUAL =
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 entiendes todo.
58
12. El multiplexor
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.
13.1. Especificaciones
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).
Si queremos sumar dos nmeros de un bit, podemos realizar un semisumador (HA: half adder), con el que
obtenemos el resultado de la suma (S) y el acarreo (C). En la figura 13.1 se muestra la tabla de verdad de la
suma y el acarreo, y el circuito que lo implementa. La obtencin de este circuito a partir de la tabla de verdad
ya te debera ser fcil si has estudiado el tema 3: lgebra de Boole y funciones lgicas.
HA
A
0
0
1
1
B
0
1
0
1
S
0
1
1
0
C
0
0
0
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
S
CI
HA
A
CO
60
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
B3
A
CO
Acarreo de salida
(o desbordamiento)
CO
CI
C2
A2
B2
CO
CI
C1
A1
B1
CO
CI
C0
A0
B0
CO
CI
S3
S2
S1
S0
bits menos
significativos
(LSB)
CI
Acarreo de
entrada a cero
CI
A(3:0)
B(3:0)
S(3:0)
CO
SUM4BITS
61
13. El sumador
modificamos en el ejercicio 12. Los pasos para importarlo estaban descritos en el apartado 12.3, pero los
recordamos:
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: hex7seg.sch. Para ello ejecutamos el comando ProyectAdd Copy of Source... y seleccionamos los
ficheros decod4a16.sch y hex7seg.sch
El convertidor vamos a modificarlo un poco, vamos a eliminar el puerto SEG_DT en ese 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 que es el diseo que contiene
al resto de componentes del circuito.
Ya deberas poder terminar el diseo t solo, an as, a continuacin se muestra una implementacin posible
(figura 13.6). Si no has sabido hacerla por ti mismo intenta entender todo el circuito propuesto.
62
14. Sumador/restador
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.
14.1. Especificaciones
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 display de 7 segmentos. El resultado se
deber mostrar en el display en signo magnitud (para que lo podamos entender los humanos). Para mostrar
el signo negativo se utilizar el punto decimal, es decir, si el punto decimal est luciendo significa que el
resultado es el nmero mostrado pero negativo.
En caso de que haya desbordamiento (overflow) el display mostrar la letra E.
Adems los cuatro LED de la derecha (de LD0 a LD3) mostrarn el resultado directo (en complemento a 2).
El resultado se dar por el display de siete segmentos de la derecha. Se usar LD7 para el acarreo de salida y
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.
LD6
OPB(3:0)
Indica si se
suma o se resta
SUMADOR/RESTADOR
SUMA: RES_SUM='1'
RESTA: RES_SUM='0'
RES_SUM
+ , RESUL(3:0)
acarreo
desbordamiento
LEDS
C
OV
VISUALIZACION
A
F
B
C
63
14. Sumador/restador
S(3:0)
S(3:0)
OPA(3:0)
A(3:0)
CO
Ca2(B)
CA2
4
OPB(3:0)
B(3:0)
RES_SUM
SUM4BITS
VCC
CI
El otro sumando
vale '0'
A(3:0)
Ca2(B)
El resultado es el
complemento a 2 de B
S(3:0)
S(3:0)
CO
OPB(3:0)
B(3:0)
complementar
cada bit
64
14. Sumador/restador
SUM4BITS
CI
S(3:0)
OPA(3:0)
A(3:0)
0
4
4
OPB(3:0)
S(3:0)
CO
B(3:0)
RES_SUM
Sel
0
0
1
1
0
S
1
B
0
1
0
1
S
1
0
0
1
Sel=0 S=B
B
Sel
Sel=1 S=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.
equivalente
B
Sel
B
Sel
equivalente
B
Sel
SUM4BITS
CI
RES_SUM
OPA(3:0)
A(3:0)
S(3:0)
S(3:0)
CO
OPB(0)
OPB(1)
4
B(3:0)
OPB(2)
OPB(3)
65
14. Sumador/restador
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
coincide con B
suma
0011+0101
3
+5
8
0011
+0101
1000
00110101 0011+Ca2(0101)
Ca2(0101)=1011
ste es B
310
0011
-510
+1011
Es representable
-210
1110
No es representable
en Ca2 de 4 bits
distintos
al estar en Ca2
representa a
ste es OPB
resta
en Ca2 de 4 bits
iguales
-210
signos diferentes: no hay desbordamiento
-8
Cambio de signodesbordamiento
B3
0
0
1
1
0
0
1
1
S3
0
1
0
1
0
1
0
1
OV
0
1
0
0
0
0
1
0
A(3)
B(3)
S(3)
OV
B2
A3
A2
CO
CO
DE
CI
C2
B0
B1
A1
CO
CI
C1
A0
CO
CI
C0
CO
CI
S3
S2
S1
S0
RES_SUM
Desbordamiento
Si OV='0' y S(3)='0', significar que tenemos un nmero positivo, por lo tanto lo mostramos tal cual
Diseo digital con esquemticos y FPGA. v1.8 - 04/06/2008
66
14. Sumador/restador
y S(3)='1', significar que tenemos un nmero negativo, y por lo tanto tendremos que calcular su
complemento a 2 y encender el punto decimal.
Si OV='0'
Cuando tenemos condiciones de tipo "Si.... entonces", stas se pueden implementar fcilmente con un
multiplexor. En la figura 14.11 se muestra esta "traduccin".
S(3:0)
Ca2
S(3)
El nmero 14
muestra la E
1
4
1110
1
OV
0
4
A
HEX7SEG
I(3:0)
SEG(6:0)
S(3)
B
C
SEG_DT
S(3:0)
Ca2
1000
1000
S(3) 1
1110
1000
OV
0
4
A
HEX7SEG
1000
I(3:0)
Se muestra un 8
SEG(6:0)
S(3)
SEG_DT
B
C
encender el punto:
signo
67
14. Sumador/restador
14.3. Diseo
Creamos un nuevo proyecto llamado
(el sumador)
addsub.
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 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 desbordamiento
(figura 14.9). Aunque el resultado final se muestra en la figura 14.13, intenta no copiarlo, sino hacerlo t solo,
y si acaso comprobarlo luego. Al terminar crea un 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
14. Sumador/restador
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).
AN_3
Como siempre, una vez que lo hayas terminado, guardas el diseo, lo compruebas, y asignas los pines.
Luego lo implementas en la FPGA.
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 minuendo si estamos
en la resta (BTN0 sin pulsar), as que mantenemos los cuatro interruptores del sustraendo (OPB: de SW4 a SW7) a
cero, y vamos codificando todos los nmeros de OPA. As que:
69
14. Sumador/restador
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.
Si OPA="0000" y OPB="0001", y no pulsamos BTN0 (BTN0='0'), entonces estamos haciendo 0-1=-1. Y por
tanto tendremos un -1 en el display (el signo menos lo indica el punto decimal). Los cuatro LED de la
derecha lucirn, ya que -1 en complemento a dos es "1111".
Si pulsamos
apagarn.
Podemos continuar haciendo esto hasta OPB="0111" entonces estamos haciendo 0-7=-7. Y por tanto
tendremos un -7 en el display (el signo menos lo indica el punto decimal). En los cuatro LED de la
derecha vendr codificado el 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.
BTN0
Ahora prueba cualquier otra combinacin de nmeros, entiende qu estas representando y qu operacin
haces, y comprueba que est bien.
Si, has comprobado que sale todo bien, ya sabes hacer una pequea calculadora! aunque sea un poco
rudimentaria y con slo dos operaciones.
70
15.1. Especificaciones
Realizar una unidad aritmtico lgica con dos operandos de 4 bits (OPA y OPB) y 4 operaciones.
Los operandos vendrn dados por los interruptores. El operando OPA se codificar mediante los 4
interruptores de la derecha (de SW0 a SW3), y el operando OPB con los cuatro interruptores de la izquierda (de
SW4 a SW7).
Las operaciones que se realizarn son: suma, multiplicacin por 2, mayor y la operacin lgica
realizar una operacin se deben de pulsar uno de los 4 pulsadores:
AND.
Para
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 LD0 a LD3), adems se mostrar
por el display de la derecha.
Segn qu operacin se est realizando LD7 mostrar:
Cuando no haya ningn botn pulsado, todos los LED permanecern apagados, y tambin el display.
71
OPA(3:0) OPB(3:0)
OPA(3:0)
OPB(3:0)
MULT2
4
CO
OV
MAYOR
R_MULT(3:0)
R_SUM(3:0)
AND
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 orden, o el inverso (OPER="00" para la suma, OPER="01" para la multiplicacin, OPER="10" para el
mayor, y OPER"11" para la AND).
OPA(3:0)
OPA(3:0) OPB(3:0)
OPA(3:0)
OPB(3:0)
+
CO
OPA(3:0) OPB(3:0)
MULT2
4
OV
R_SUM
MAYOR
AND
R_MAY
R_MULT
R_AND
OPER(1:0)
11
10
01
4
Cdigos de operacin
00
: AND
01
: MAYOR
10
: MULT
11
: SUMA
00
R_(3:0)
I0
I1
I2
I3
EI
EO
S0
S1
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
72
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 muestra la figura 15.4.
OPA(3:0)
OPA(3:0) OPB(3:0)
OPA(3:0)
CODIF
BTN3
BTN2
BTN1
BTN0
'1'
I0
I1
I2
I3
MULT2
4
CO
R_SUM
OV
MAYOR
AND
R_MAY
R_MULT
R_AND
EO
S0
S1
OPER(1:0)
OP_ACT
11
10
01
4
EI
OPB(3:0)
Cdigos de operacin
00
: AND
01
: MAYOR
10
: MULT
11
: SUMA
OPA(3:0) OPB(3:0)
00
R_(3:0)
OPA(3:0) OPB(3:0)
OPA(3:0)
CODIF
BTN3
BTN2
BTN1
BTN0
'1'
I0
I1
I2
I3
EI
MULT2
4
R_SUM
OV
MAYOR
CO
R_AND
OPER(1:0)
SEL
EN
OP_ACT
11
10
01
4
00
R(3:0)
A
AN_0
OV
AND
R_MAY
R_MULT
EO
S0
S1
+
CO
OPA(3:0) OPB(3:0)
OPB(3:0)
Cdigos de operacin
00
: AND
01
: MAYOR
10
: MULT
11
: SUMA
HEX7SEG
I(3:0)
0
LD7
SEG(6:0)
B
C
LEDS
OPER(0)
OPER(1)
73
'0'
'0'
OPER(0)
0
1
LD7
OV
OV
CO
CO
OPER(0)
OV
CO
LD7
OPER(0)
OPER(1)
OPER(0)
OPER(1)
LD7
OPER(1)
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.
Ejemplos:
A3 A 2 A1 A0
0
6: 01102
5: 01012
9: 10012
x2
x2
x2
12: 11002
10: 10102
18:100102
overflow
no cabe en 4 bits
OV S3 S2 S1 S0
74
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.
Creamos una nueva fuente llamada and_4bit.sch y realizamos el circuito de la figura 15.10.
75
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 multiplexores de dos
entradas de datos. Como ste ya lo tenemos, nos sera fcil. Tendramos que aadir la seal de habilitacin
Vamos a realizarlo segn esta ltima forma. La formacin del multiplexor a partir de los multiplexores
pequeos se muestra en la figura 15.11.
R_AND
R_MAY
R_MULT
R_SUM
00
01
10
R_MAY
0
1
R(3:0)
OPER(0)
11
2
OPER(1:0)
R_AND
R_MULT
R_SUM
R(3:0)
0
1
EN
EN
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 figura.
76
R_AND
R_MAY
R_MULT
R_SUM
00
01
10
R_MAY
R(3:0)
habilitacin
OPER(0)
11
OPER(1:0)
R_AND
R_MULT
R_SUM
R(3:0)
0
1
EN
EN
OPER(0)
Si OPER(1)='1' , entonces OPER(0)
selecciona entre R_MULT y R_SUM
OPER(1)
77
78
16.1. Especificaciones
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 entrada K lo pone a
cero; si las dos entradas estn a cero se mantiene el valor mientras
que si las dos estn a uno, invierte el valor guardado.
Por tanto, el esquemtico ser como el mostrado en la figura 16.1.
Cuando lo tengas, guarda el diseo para implementarlo.
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.
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 Xilinx Constraints Editor.
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 y por lo tanto, lo que percibimos es que el LED luce menos (la mitad).
80
17.1. Ideas
Se nos pueden ocurrir varias ideas para implementar el circuito. Antes de seguir leyendo intenta pensar
cmo lo haras t.
FTC
BTN0
CLK
LED0
CLR
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 observar que cuando
se presiona el pulsador (BTN0='1') , la salida del biestable oscila. Al terminar de pulsar, el biestable
permanecer en el ltimo valor. En el caso del ejemplo de la figura, el LED se ha quedado apagado.
'0' Q guarda valor
'1' cambio en Q
BTN0-T
CLK
50 MHz
LED0-Q
81
Vcc
Atencin:
Circuito MAL DISEADO
FTC
T
BTN0
LED0
CLR
FD
D
FTC
T
LED0
CLR
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 esos rebotes tendras que poner un contador que elimine los pulsos que se produzcan
durante un tiempo despus de recibir un pulso, que puede ser de unos 200 ms.
82
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.1. Especificaciones
Hacer que LD0 parpadee a una frecuencia de dos segundos. Esto es, permanecer encendido durante un
segundo y apagado durante el segundo siguiente, y as sucesivamente. La frecuencia del reloj de la placa es
de 50MHz.
18.2. 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 objetivo. Evidentemente, la seales de entrada y salida no estn a escala.
(no est a escala)
T=1 s
T=20 ns
T=20 ns
DivFrec
Clk
Clk1Hz
Clear
50 Mz
Biestable T
1 Hz
Q
Clk
LED
Cada segundo le
llega un '1' y
entonces cambiar
de estado (se
encender y apagar)
en
tra
da =
20
ns
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
CONT5
T100NS
4 0 1 2 3 4 0 1 2 3 4 0 1 2 3 4 0
50 MHz
Clk
T100NS
CLEAR
50MHz
CLK
10 MHz
10MHz
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
llevan la cuenta. Cada vez que hay un flanco de subida del reloj CLK, el contador incrementa su cuenta, ya
Diseo digital con esquemticos y FPGA. v1.8 - 04/06/2008
84
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
0 a 3) la salida Q2 permanece a cero. La secuencia de la cuenta se muestra en la figura 18.5.
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 entonces
1
1
hacemos CONT5=1
0
2
1
3
0
4
Iniciar la cuenta
0
0
1
1
f=50MHz
T=20ns
conta5
1
Clk
Aqu contamos
ciclos de T100NS
no de reloj, y por eso
es la entrada de CE
f=10MHz
T=100ns
CE
Clk
f=1MHz
T=1s=1000ns
conta10
T100NS
T100NS
CLEAR
Divisor de frecuencia x5
CE
Clk
T1US
T1US
Hemos conseguido
divididir la frecuencia
por 50=5x10
CLEAR
85
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
T1US
1 MHz
Se inicializa cuando la
cuenta sea 9 y CE=1
86
19.1. Especificaciones
La primera parte consistir en hacer un segundero digital que vaya de 0 a 9 y se muestre por el primer display
de 7 segmentos. El punto decimal parpadear cada segundo. Esto es, que en un segundo se apague y se
encienda. Por tanto, tendr un periodo de un segundo.
La segunda parte ser hacer un reloj, los dos displays de la derecha se 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.
contador10
segundero
CE
Clk
CLEAR
Q0
Q1
Q2
Q3
T500MS
T1S
CE
HEX7SEG
I0
I1
I2
I3
SEG(6:0)
B
C
Clk
CLEAR
87
Divisor de frecuencia x5
f=10Hz
T=100ms
T100MS
Clk
CE
Divisor de frecuencia x2
f=2Hz
T=500ms
conta5
T500MS
Clk
CLEAR
Entrada de 100 ms
T500MS
f=1Hz
T=1000ms=1s
conta2
CE
Clk
T1S
T1S
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
....
No es el nico
que tiene Q2='1'
Q2='1'
El nico que tiene
Q3='1' y Q0='1'
Q0
Q1
Q2
Q3
CE
T500MS
Detectar 9 (fin de cuenta)
basta con detectar los '1':
No olvidar el CE
(en este caso es T100MS)
Q0
Q3
T1S
CE
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
mostradas en la figura 19.5. Para que lo podamos
usar en los siguientes esquemticos.
segundero
CE
T500MS
Clk
CLEAR
T1S
Figura 19.6: Esquemtico del circuito que muestra las unidades de segundo
89
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 figura 19.7.
T=1 ms
T1ms
Minutos
CUENTA4MS
Segundos
AN_0
AN_1
DM
UM
DS
US
AN_3
AN_2
AN_1
AN_2
AN_0
AN_3
NumDispl
US
DS
UM
DM
US
DS
UM
DM
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.
19.3.1. Implementacin
Varias cosas fundamentales tenemos que hacer en este diseo:
segundero
T1MS
CE
Clk
CLEAR
T500MS
T1S
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 segn se muestra en la figura 19.7. Ya hemos visto cmo se
realiza esto: para seleccionar se utilizan los multiplexores (recuerda el captulo 12). En este caso es de 4
90
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
00
DS
01
UM
DM
10
11
HEX7SEG
I0
I1
I2
I3
SEG(6:0)
B
C
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
00
01
10
1
0
1
D
11
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 de los displays.
Ya estando tan avanzados en el curso, intenta hacerlo por ti mismo. Si lo logras, comprueba con un reloj que
tengas si es un buen reloj, es decir, si se retrasa o adelanta. Si funciona bien significa que ya sabes bastante
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 solamente cuando est activo AN_2.
Ya que es ese punto decimal el que queremos que luzca, por eso ponemos la puerta NAND. Fjate que se
pone antes de invertirla. Por ltimo, ponemos una puerta NAND, porque SEG_DT es activo a nivel bajo.
91
92
Figura 19.13: Multiplexor para la seleccin del dgito a mostrar por los displays
93