Diseño Digital Con Logica

DISEÑO DIGITAL CON LOGICA
PROGRAMABLE
MANUAL MAX+PLUS II
Sadot Alexandres F.
DISEÑO DE SISTEMAS DIGITALES
INDICE:
1.- INTRODUCCIÓN. ......................................................................................... 2

1.1.- ENTORNO MAX+PLUS II. ........................................................................................................3
1.2.- TARJETA PARA EL DESARROLLO DE PROTOTIPOS........................................................................4
1.2.1.- PLD’S .....................................................................................................................................5
1.2.2.- OSCILADOR.............................................................................................................................5
1.2.3.- PULSADORES ...........................................................................................................................5
1.2.4.- MICROINTERRUPTORES ...........................................................................................................6
1.2.5.- DISPOSITIVOS LUMINOSOS. .....................................................................................................7
1.2.6.- MEMORIA RAM......................................................................................................................9
1.2.7.- CONECTOR DE ACCESO A TERMINALES DE USUARIO..............................................................11
1.2.8.- ZONA DE WRAPPING..............................................................................................................12
1.2.9.- ACCESO A LOS TERMINALES DE LA TARJETA ......................................................................12
2.- DEFINICIÓN DE UN PROYECTO. ............................................................ 13
2.1.- JERARQUÍA DE UN PROYECTO...................................................................................................15
3.- EJEMPLO BÁSICO DE OPERACIÓN. ...................................................... 15
3.1.- CREACIÓN DEL PROYECTO......................................................................................................16
3.1.1.- CAPTURA DE ESQUEMAS......................................................................................................16
3.1.1.1.- CAPTURA POR OR CAD. ...................................................................................................18
3.1.1.2.- CAPTURA DE ESQUEMAS EN EL ENTORNO ALTERA . .....................................................19
3.1.1.4.- ASIGNACIÓN DEL PATILLAJE DE LA FPGA .....................................................................19
3.2.- VERIFICAR LAS REGLAS DE DISEÑO.............................................................................................21
3.3.- COMPILAR, COMPLETAR Y ENSAMBLAR. .............................................................................23
3.4.- PROGRAMAR LA TARJETA DE DESARROLLO CON EL EJEMPLO. ...................................28
3.6.- VERIFICACIÓN DEL FUNCIONAMIENTO. ...........................................................................32
4.- SIMULACIÓN LOGICA.............................................................................. 33
4.1.- SIMULACIÓN LÓGICA CON HERRAMIENTAS DE ALTERA...............................................33
4.2.- FICHEROS GRÁFICOS PARA SIMULACIÓN. .................................................................................34
4.3.- DEFINICIÓN DE ESTÍMULOS .......................................................................................................38
4.3.1.- DEFINICIÓN DE SEÑALES ....................................................................................................39
4.4.- PUESTA EN MARCHA DE LA SIMULACIÓN ........................................................................42
5.- LENGUAJES HDL. ...................................................................................... 44
5.1.- REALIZACIÓN PRÁCTICA DE CIRCUITOS MEDIANTE EL LENGUAJE HDL. ........................44
5.1.2.- CREAR UN FICHERO DE DISEÑO..........................................................................................46
5.1.2.1.- INTERFACE DEL DISPOSITIVO Y DECLARACIÓN DE ENTIDAD. .......................................47
5.2.- LIBRERIAS VHDL DE USUARIO...........................................................................................56
5.3.- INTEGRACIÓN DE MÓDULOS VHDL EN ESQUEMAS.........................................................57
1
1.- INTRODUCCIÓN.
Los entornos EDA (Electronic Design Automation) son las herramientas de trabajo más
comúnmente empleadas en el diseño e implantación de circuitos lógicos. Permiten una gran
versatilidad a la hora de simular cualquier posible situación en el funcionamiento de los diseños
efectuados por el profesional que emplea esta herramienta, además son sencillos de manejar gracias
a las interfaces gráficas que incorporan las plataformas de diseño como: ALTERA, OrCAD,
XILINX, que permiten la instrumentación de dichos diseños y su implantación en los PLD’s y
FPGA`s.
Dichas herramientas de trabajo son puestas al alcance del alumno en esta obra con el fin de dar
a conocer las últimas técnicas de diseño con una formación integral en todas ellas. Para ello, a lo
largo de los diferentes capítulos del tutorial y de las prácticas que en este libro se proponen, el
alumno adquirirá los conocimientos que le permitirán manejar los dispositivos fabricados por
ALTERA , junto con el soporte de software Max+plus II como principal herramienta de diseño,
verificación y simulación de prácticas y proyectos en el Laboratorio de Sistemas Digitales y
posteriormente en su vida profesional.
Para la implantación de los diseños que se efectuarán durante el curso, dispondremos de un

FPGA situado en una tarjeta de desarrollo que permitirá una fácil simulación de los circuitos y
prácticas propuestos, mediante una serie de visualizadores, pulsadores, microinterruptores y otros
elementos, útiles para realizar simulaciones físicas en la tarjeta de desarrollo de los diseños
realizados .
2
1.1.- ENTORNO MAX+PLUS II.
Primeramente nos familiarizaremos con el entorno de trabajo. El software que vamos a emplear
es una versión de ALTERA que se ofrece para estudiantes y Universidades. Al iniciar el programa
encontramos la siguiente pantalla:
En la parte superior de la misma nos encontramos con los menús típicos de las aplicaciones
bajo Windows. Además, por debajo está una línea de iconos que nos dan acceso a las diferentes
partes del programa. A continuación detallaremos el significado de cada uno de estos iconos y la
función que realizan:
Visualizador de jerarquías.
Editor de Patillajes y asignaciones. (Floorplan)
Compilador.
Ventana del simulador.
3
Analizador de tiempos.
Programador.
Especifica el nombre del proyecto.
Cambia el nombre del proyecto al del archivo que se está empleando.
Maneja el archivo de diseño de nivel superior.
Opciones para guardar (Archivos, simulador y compilador).
Si durante la ejecución del programa surge alguna duda, en cualquier momento, situando el
cursor del ratón sobre el icono correspondiente, aparece en la parte inferior de la pantalla una
descripción de su función.
1.2.- TARJETA PARA EL DESARROLLO DE PROTOTIPOS
En esta parte del documento se describe la tarjeta para el desarrollo de prototipos SEC-7000.
Esta tarjeta será empleada por el alumno para la implementación física de los diseños realizados en
el entorno MAX+plus II.
Los elementos de que disponemos en nuestra tarjeta de prototipos son:
1.- Una PLD de la familia MAX7000S de ALTERA.
2.- Un oscilador de cuarzo de 1.8432 MHz...
3.- 4 Pulsadores situados en la tarjeta.
4.- 16 Microinterruptores.
5.- 3 Indicadores de siete segmentos.
6.- 10 LED’s .
7.- Una memoria RAM (con posibilidad de ampliación).
8.- Zona de inserción de componentes complementarios al diseño.

9.- Conector de acceso a los terminales accesibles de la FPGA.
4
1.2.1.- PLD’S
La tarjeta dispone de cierta flexibilidad respecto al tipo de PLD que puede llevar instalada. En
concreto, puede ser cualquiera de las siguientes:
• EPM7064S.
• EPM7096S.
• EPM7128S.
• EPM7160S.
La tarjeta requiere que el integrado de la PLD's tenga un encapsulado PLCC de 84 pines para
poder ser colocados en el zócalo disponible en la tarjeta y funcione correctamente con el Software.
1.2.2.- OSCILADOR
El módulo oscilador genera una señal de frecuencia de 1’8432 MHz, que puede ser usada como
señal de reloj cuando sea preciso, dividiéndola si fuera necesario para alimentar de forma síncrona a
dispositivos de distinta frecuencia que empleemos en nuestros desarrollos.
El oscilador está conectado al pin 83 del PLD, que se corresponde con una de las entradas
dedicadas del mismo.
Las entradas dedicadas de las EPLD's de ALTERA tienen características especiales que las
hacen apropiadas para su conexión a señales que precisen de un alto FAN-OUT y un bajo skew,
tales como las de inicialización (reset) o reloj.
1.2.3.- PULSADORES.
Cada pulsador de la tarjeta dispone de un circuito “anti-rebote” de forma que pone un nivel alto
TTL (+5V) en un pin de la FPGA mientras se mantiene pulsado y en caso contrario se asigna de
forma permanente un nivel bajo (GND). Los cuatro pulsadores se identifican como S1 a S4.
Los tres últimos ( S2, S3 y S4 ) se encuentran conectados a entradas dedicadas y S1 se

encuentra conectado a un pin de entrada/salida.
La interconexión entre los pulsadores y los terminales de la PLD empleada en esta tarjeta de
circuito impreso se detalla en la siguiente tabla:
PULSADOR PIN F.P.G.A.
S1 39
S2 2
S3 1
S4 84
5
1.2.4.- MICROINTERRUPTORES.
La tarjeta dispone de dieciséis microinterruptores distribuidos en dos módulos de ocho que se

encuentran en la parte izquierda.
La forma con que se han identificado para su empleo en los diseños es el siguiente:
1.- Todos los nombres comienzan por SW.
2.- A continuación viene un 1 ó un 2 para identificar el módulo al que pertenecen.
3.- Finalmente viene el número que ocupa dentro del módulo de microinterruptores,
precedido por el símbolo “_” .
Cada uno de los microinterruptores se encuentra conectado a un terminal de la PLD y pone un

nivel bajo TTL (GND) en la posición “ON” mostrada en la serigrafía de los mismos y un nivel alto
(+5V) en la posición opuesta.
La interconexión de los microinterruptores y los terminal se muestra a continuación:
TERMINAL
MICROINTERRUPTOR
F.P.G.A.
SW1_1 12
SW1_2 15
SW1_3 16
SW1_4 17
SW1_5 18
SW1_6 20
SW1_7 21
SW1_8 22
SW2_1 24
SW2_2 25
W2_3 27
SW2_4 28
SW2_5 29
SW2_6 30
SW2_7 31
SW2_8 33
6
1.2.5.-DISPOSITIVOS LUMINOSOS.
La tarjeta dispone de tres indicadores luminosos de siete segmentos (con punto decimal) y
de una matriz que tiene diez LED’s. Para polarizar tanto los segmentos de los indicadores como los
LED’s hay que poner un nivel bajo “0” en el terminal al que están conectados, ya que son de ánodo
común.
Estos tres dispositivos están multiplexados entre sí junto con ocho de los LED’s de la matriz,
por lo que se emplea cuatro terminales de la FPGA para generar las señales de control adecuadas
para que se puedan emplear todos ellos de forma simultánea en los diseños que realice el alumno.
Cada señal de multiplexación habilita, con un nivel alto (+5V), el funcionamiento del indicador
o del grupo de LED’s individuales de la matriz con el que está asociado. En adelante se hará
referencia a los indicadores de siete segmentos de acuerdo con la siguiente notación:
• DISPLAY1 identificado por la etiqueta U6.
7
SW5 U6 U7 U8 U9
ON a
1
b a a a
c
d f b f b f b
e g g g
f e c e c e c
g d d d
punto
SW6 mux0
ON mux1
1
mux2
mux3
led9
ALTERA led10
MAX BUS DE DATOS
EPM7128SLC84 10 11
9 A0 O0 12
S1 A1 O1
8 13
7 A2 O2 15
BUS DE DIRECCIONES 6 A3 O3 16
S2 A4 O4
5 17
4 A5 O5 18
3 A6 O6 19
S3 A7 O7
25
24 A8
21 A9
S4 A10
23
2 A11
PULSADORES 26 A12
27 A13
A14 27256
20
22 CE
1 OE
VPP
MEMORIA RAM U16
OSCILADOR
1.8 MHz.
Los ocho LED’s que están multiplexados con los indicadores, de los diez que forman la matriz,
son los que van del número 1 al 8, empezando por arriba. Los LED 9 y 10 situados en la parte
inferior se encuentran asignados a terminales independientes de la F.P.G.A. y no requieren
multiplexación para su funcionamiento, es decir, se pueden asignar mediante un terminal de
entrada/salida de forma directa. Las señales de multiplexación se denominan MUX_0, MUX_1,
MUX_2 y MUX_3. Están asociadas a los displays y al grupo de Led’s tal y como se muestra en la
siguiente tabla:
SEÑAL DE DISPOSITIVO
MULTIPLEXACIÓN ASOCIADO
MUX_0 DISPLAY1
MUX_1 DISPLAY2
MUX_2 DISPLAY3
MUX_3 LED'S
Los terminales de la PLD conectados a las señales de multiplexación empleadas en el control

son los indicados en la siguiente tabla:
8
TERMINAL
SEÑAL DE MULTIPLEXACIÓN
F.P.G.A.
MUX_0 77
MUX_1 76
MUX_2 75
MUX_3 74
De la misma forma, los terminales que han sido conectados a los segmentos y al punto decimal
de los tres indicadores y a los ocho Led’s multiplexados de la matriz son los que aparecen en la
siguiente tabla:
SEGMENTOS DEL LED’S DE LA TERMINAL

INDICADOR MATRIZ F.P.G.A.
SEG A LED1 9
SEG B LED2 8
SEG C LED3 4
SEG D LED4 81
SEG E LED5 80
SEG F LED6 10
SEG G LED7 11
PUNTO DECIMAL LED8 5
Los dos Led’s restantes son denominados como LED_1 y LED_2. Los terminales de la PLD a
los que está asignada su conexión son:
TERMINAL
LED´S
F.P.G.A.
LED_1 70
LED_2 73
1.2.6.- MEMORIA RAM.
La memoria RAM de la tarjeta es un circuito integrado con una capacidad de 32K x 8 bits que
puede ser reemplazado por otro dispositivo de mayor capacidad con acuerdo al patillaje de la tarjeta
de circuito impreso que dispone de 28 terminales en el zócalo dispuesto para tal efecto. Dicha
sustitución del integrado de la memoria dará lugar a un nuevo replanteo de los terminales de entrada
y de salida con respecto a los terminales de la FPGA.
Las señales de interconexión entre la memoria y la PLD son las siguientes:
1.- El bus de direcciones: formado por quince líneas A0 ÷ A14.
9
2.- El bus de datos: formado por 8 líneas identificadas como DATA0 ÷ DATA7.
3.- Señales de control: Chip Select, Output Enable y Write Enable, que son tres
líneas identificadas como CS, OE y WE, que realizan el control de acceso a la memoria
y la realización de lectura y escritura en la misma.
La interconexión entre estas señales y los terminales de la FPGA se indica en la siguiente tabla:
TERMINAL DE LA TERMINAL
MEMORIA F.P.G.A.
A0 51
A1 49
A2 45
A3 54
A4 56
A5 58
A6 61
A7 64
A8 63
A9 60
A10 44
A11 57
A12 67
A13 65
A14 69
DATA0 52
DATA1 50
DATA2 48
DATA3 34
DATA4 36
DATA5 35
10
DATA6 37
DATA7 40
CS 41
OE 55
WE 68
El diagrama de bloques interno de la memoria RAM es el siguiente:
1.2.7.- CONECTOR DE ACCESO A TERMINALES DE USUARIO.
Los terminales de la EPLD que no están conectados a ninguno de los recursos anteriormente
descritos y que no están dedicados a la programación del dispositivo, son accesibles por medio de
un conector, situado junto a la memoria.
Los terminales libres de la PLD son 3, y se identifican como CUS_1 a CUS_3. Numerando los
pines del conector JP11 a partir del número 1 serigrafiado en la tarjeta, la asignación entre etiquetas
de las patillas del conector y los terminales de la EPLD se muestra en la siguiente figura.
NOMBRE DEL TERMINAL PATILLA DEL

TERMINAL F.P.G.A. CONECTOR
11
CUS2_1 46 1
CUS2_2 79 2
CUS2_3 6 3
1.2.8.- ZONA DE WRAPPING.
La zona de wrapping permite añadir hardware adicional para aplicaciones en que los recursos
de la placa sean insuficientes.
El hardware de esta zona puede conectarse con la EPLD por medio de los terminales de usuario
que se encuentren libres de otras conexiones y si estos son insuficientes, la conexión se realizará por
medio de los terminales de entrada/salida que no se hayan empleado en otras funciones o
cometidos. En el caso de que no sean necesarios estos elementos de hardware adicionales para otra
aplicación, pueden ser desalojados de la tarjeta y permitir la instalación de otros recursos que
resulten necesarios en cada caso .
1.2.9.- ACCESO A LOS TERMINALES DE LA TARJETA.
Los terminales asignados a recursos de la tarjeta están unidos a los ocho conectores que rodean
la EPLD, con el fin de permitir su monitorización con un analizador lógico o un osciloscopio, o que
se puedan utilizar como pines de usuario, en el caso de que se desmonten recursos de la placa o se
amplíen los mismos para aplicaciones personalizadas del prototipo de desarrollo.
La asignación de los terminales de los recursos de la tarjeta a los conectores se detalla en la

siguiente tabla:
12
CONECTOR P1 P2 P3 P4 P5 P6 P7 P8 P9 P10 P11
JP1 NC 15 17 NC 21 23 25 27 29 31 33
JP2 12 14 16 18 20 22 24 VCC 28 30 GND
JP3 53 51 49 GND 45 NC 41 39 37 35 NC
JP4 34 36 NC 40 NC 44 46 48 50 52 NC
JP5 74 GND 70 68 VCC 64 62 60 58 56 54
JP6 73 71 69 67 65 63 61 NC 57 55 NC
JP7 10 8 6 4 2 84 NC 80 NC 76 NC
JP8 75 77 79 81 83 1 VCC 5 GND 9 11
2.- DEFINICIÓN DE UN PROYECTO.
El primer paso que se debe dar al comenzar cualquier diseño es definir el proyecto. Más
adelante encontraremos todos los pasos necesarios para poder realizarlo, pero a modo de
13
introducción, comentaremos algunos aspectos de la jerarquía de los proyectos en el entorno

MAX+PLUS II.
Un proyecto está formado por una serie de ficheros, que pueden ser clasificados básicamente de
dos formas: Ficheros auxiliares ó Ficheros de diseño.
FICHEROS DE DISEÑO:
Puede ser de diversos tipos: Gráfico, de texto o de formas de onda. Contienen la información
que más tarde será procesada por un compilador que preparará el NETLIST para ser volcado junto
con otras informaciones sobre la tarjeta de prototipos.
A continuación se realiza una descripción de todos estos tipos de ficheros que podemos
encontrarnos:
1. Ficheros de texto HDL: Pueden estar en lenguaje AHDL con extensión (.tdf) ó
bien en VHDL (.vhd).
2. Ficheros gráficos: Si son generados por la captura de esquemas de nuestro propio

entorno de ALTERA, éstos tendrán la extensión (.gdf). En el caso de que usemos
OrCAD Capture, compatible con las librerías de ALTERA, entonces la extensión será
(.sch).
3. Ficheros NETLISTS: Éstos son formados al importar de otros entornos de trabajo

distintos a MAX+PLUS II y pueden estar en los formatos: EDIF (.edf), ó XNF (.xnf).
Cualquier otro formato de Netlist empleado no será reconocido por el software del
compilador.
4. Ficheros de formas de onda: Son generados por el editor de formas de ondas del
programa y especifican el tipo de onda empleado en simulaciones. La extensión de estos
ficheros es (.wdf).
5. Archivos de diseño de ALTERA. (.adf)
6. Archivos de máquinas de estado. (.smf)
FICHEROS AUXILIARES:
Son los asociados al proyecto en el que nos encontramos trabajando y los crea el programa de
ALTERA. Algunos de ellos se generan automáticamente por la aplicación que estemos ejecutando y
otros los crea el usuario al definir símbolos, situaciones especiales en el programa, etc.
Algunos de los más comunes que nos podemos encontrar son:
- Ficheros de programación del dispositivo PLD. (.sof , .pof , .hex )

- Ficheros de simulación. (.scf ó .snf )
- Informes de compilación. (.rpt)
14
- Ficheros de configuración. (.acf)

- Símbolos (.sym)
2.1.- JERARQUÍA DE UN PROYECTO.
Todo proyecto desarrollado en un capturador dispone de una jerarquía de archivos que son los
componentes del proyecto. Estos archivos se presentan de la siguiente manera, formando un árbol:
En la imagen mostrada anteriormente podemos ver como está compuesta la jerarquía de

archivos de un determinado diseño del cual parten otros diseños complementarios con la
información sobre los componentes y las simulaciones efectuadas en el transcurso del proyecto.
Las diversas ramificaciones del árbol nos llevan a los archivos de menor nivel en la jerarquía.
El punto de partida de estos va siendo otro archivo de mayor nivel, hasta llegar a la parte superior
del árbol (TOP LEVEL) en donde se encuentra el principal archivo del diseño que sirve de punto de
partida.
3.- EJEMPLO BÁSICO DE OPERACIÓN.

Para seguir con mejor precisión este manual, emplearemos unos sencillos proyectos, basados en
el diseño de circuitos combinacionales y secuenciales a los que alimentaremos con el reloj de la
tarjeta mediante unos divisores de frecuencia.
15
El proceso que se va a seguir para estudiar los ejemplos, así como todos los diseños que se
realicen, se muestra a continuación:
Crear el proyecto y capturar el esquema del ejemplo.
1. Verificar las reglas de diseño.
2. Compilar.
3. Corregir posibles fallos.
4. Programar la tarjeta de desarrollo con el ejemplo.
5. Verificación del funcionamiento.
3.1.- CREACIÓN DEL PROYECTO.
Primeramente se va a comentar los pasos a seguir para crear un nuevo proyecto. Para ello
debemos crear o importar el archivo que va a ser el nivel superior de la jerarquía e identificar el
directorio en el que se encuentra.
El primer paso consistirá, por tanto en la captura del ejemplo del contador y a partir de ahí se
establecerá el proyecto de trabajo.
3.1.1.- CAPTURA DE ESQUEMAS.
Existen varios procedimientos para realizar la captura de un esquema bajo diversas

plataformas, las más corrientes son:
- OrCAD (.sch)
- ALTERA (.gdf)
- EWB (.sch)
- PROTEL (.sch)
16
Para cualquiera de ellos emplearemos la opción del menú “FILE” mediante la opción “OPEN”
o la opción “PROJECT” dependiendo de la localización del archivo.
Si el archivo que vamos a emplear está en otro proyecto, lo podemos seleccionar a través de la
pantalla anterior, indicando el proyecto en el que se encuentra y seleccionando el visualizador de
jerarquías.
Posteriormente seleccionamos el elemento que queremos dentro del árbol de selección y

realizamos “doble click” sobre él para que se abra el editor gráfico del programa, con el archivo
especificado.
17
En caso de que se trate de un archivo que no se encuentre en nuestro proyecto de trabajo,

emplearemos la opción de apertura de ficheros e indicaremos en la misma el formato de fichero que
queremos abrir, la ruta de acceso a dicho fichero y el nombre del mismo en la pantalla que se
muestra a continuación:
3.1.1.1.- CAPTURA POR ORCAD.
Esta primera opción es la más adecuada para aquellas personas que tengan experiencia en el
manejo este tipo de software o estén familiarizados con el entorno OrCAD y sus funciones.
Los archivos resultantes de dicha captura son los que tienen la extensión (*.sch). El único
problema que puede surgir en estos casos es la compatibilidad entre librerías específicas de un
determinado entorno que no sean compatibles con nuestro software de ALTERA. En cualquiera de
estos casos, habrá que consultar al profesor para buscar la mejor solución. Los archivos que
proceden de OrCAD tienen la extensión “sch” por lo que será necesario indicarlo en la selección:
“Graphic Editor files” del menú “ OPEN ”.
18
3.1.1.2.- CAPTURA DE ESQUEMAS EN EL ENTORNO ALTERA.
La otra posibilidad para manejar un esquema es crearlo nosotros mismos dentro del propio
capturador que el programa de ALTERA nos proporciona. Esto lo haremos mediante las librerías de
componentes y accesorios que tiene el programa. Para crear un esquema nuevo seguiremos los
siguientes pasos.
En primer lugar, en el menú archivo, seleccionamos la opción “NEW” y nos encontraremos con
una pantalla en la que marcamos las opciones indicadas. Esta pantalla es la siguiente:
A partir de ahí, dibujaremos el esquema del contador, según se indicó en apartados anteriores y
siguiendo el modelo que podemos encontrar en el anexo a este documento.
3.1.1.4.- ASIGNACIÓN DEL PATILLAJE DE LA FPGA.
Como se indicó en el apartado de la tarjeta de desarrollo, la FPGA que estamos empleando se

encuentra dentro de una tarjeta de circuito impreso junto con otros componentes accesorios. La
asignación de cada una de las salidas de la FPGA a dichos periféricos se debe realizar en el
esquema principal de la siguiente manera:
1. Identificar en las tablas del apartado 1.2 los terminales que vamos a necesitar en
nuestra simulación.
19
2. Mediante el botón derecho del ratón, se tiene que seleccionar la opción “ASSIGN”,
“PIN/LOCATION/CHIP...”
Y la pantalla que nos encontraremos será la siguiente:
En esta pantalla asociamos una conexión o referencia del esquema a un terminal de la FPGA,
de forma que cuando se programe el circuito, la referencia del esquema será conectada internamente
con el terminal elegido del integrado.
20
3.2.- VERIFICAR LAS REGLAS DE DISEÑO.
Puesto que trabajamos con software o herramientas de diseño, se han definido una serie de
reglas de diseño mediante las cuales evitamos que el ensamblador del programa cometa error al
realizar los pasos finales (por ejemplo, si el compilador tiene un bucle).
Además, cumplir estas reglas es indispensable para realizar un diseño seguro, evitando así
muchos de los fallos más comunes como dejar componentes sin conectar, cortocircuitos de la
alimentación, y otros. La operación que tenemos que realizar para comprobar el circuito implica que
lo guardemos, al realizarse una orden conjunta de verificación y salvado del diseño con el que
estemos trabajando. Las órdenes para hacerlo son:
- En el menú “FILE”, seleccionamos la opción “PROJECT”.
- Una vez allí, seleccionamos “SAVE&CHECK” entre las opciones, y comenzará a

ejecutarse el verificador que al finalizar se quedará con la siguiente pantalla:
Que mostrará también los errores y advertencias que hayan podido surgir en el proceso de
verificación. Lo ideal es que aparezca de la siguiente manera:
21
Pero puede que al principio surjan errores que se puedan arreglar sin ninguna dificultad para el
alumno. Con respecto a las advertencias (Warnings), son cosas que no influyen directamente en el
correcto funcionamiento del diseño, pero es conveniente que sean revisadas por el alumno antes de
continuar con el proceso siguiente.
Pero, ¿Cómo solucionar los errores que tenga el diseño?
Para esta operación, el programa dispone de una ventana de avisos sobre errores o advertencias
en la cual nos indica cuál han sido estos y en que lugar del esquema se encuentran. Para acceder a
ellas, tras pulsar la aceptación en la ventana final que vimos antes, aparece otra ventana junto a la
del compilador donde se procesan los mensajes de error.
Seleccionamos uno de ellos con el cursor del ratón y se pulsa sobre el botón “Locate” de esa
ventana. Con ello se activa una búsqueda automática en el esquema en donde nos localizará el error.
Una vez localizado el error por el alumno, se procede a su corrección y se vuelve a iniciar este
apartado para verificar que todo está correcto.
22
3.3.- COMPILAR, COMPLETAR Y ENSAMBLAR.
El siguiente paso que tenemos que dar es convertir el esquema del editor gráfico que acabamos
de comprobar, en un archivo que el ordenador sea capaz de reconocer, simular y analizar. Para ello
empleamos el compilador, mediante las instrucciones: FILE, PROJECT, SAVE&COMPILE.
Automáticamente se guardará el archivo del proyecto y comenzará a ejecutarse el compilador

en una ventana como la siguiente:
Como podemos observar en la figura, se han creado varios archivos asociados a la compilación,
completado ó rellenado y ensamblaje del proyecto en curso. Estos archivos aparecerán
posteriormente en el visualizador de jerarquías como auxiliares que nos indican que el proyecto fue
compilado con el programa.
Al igual que en la verificación de las reglas de diseño, al concluir el proceso aparecerá una
ventana que nos indica los errores cometidos y las advertencias.
Como en el verificador de diseño, si se produce algún error en el proceso de compilado,

quedaría reflejado en la pantalla anterior y se podría seguir un proceso análogo en la verificación de
los errores mediante la pantalla de avisos:
23
Se corrigen los errores que se hayan podido cometer en el proceso y se vuelve a realizar la
compilación del proyecto según se mostró al comienzo de este apartado.
Si alguno de los errores mostrados anteriormente persiste una vez realizada la verificación y
corrección por el alumno, será conveniente que éste repase paso por paso con el profesor el proceso
seguido en busca del posible fallo, ó que emplee la ayuda disponible en el programa, accediendo a
ella mediante el botón: “HELP ON MESSAGE” situado en la parte inferior derecha de la pantalla
anterior.
24
EJEMPLO 1: Circuito Lógico 1. Decodificador Hexadecimal a 7 segmentos.
Realice el esquema lógico de la siguiente página en el editor gráfico de ALTERA. El

circuito corresponde a un decodificador de 4 bits en hexadecimal a un visualizador de 7 segmentos
que corresponden a la figura siguiente según los 4 bits de entrada.
25
26
En primer lugar inserte los componentes haciendo doble click con el cursor del ratón en la
ventana de dibujo. Aparecerá la siguiente pantalla de selección de componentes en la que existen
varias librerías:
Se realiza la selección del componente “and2” que corresponde, como su nombre indica, a
una puerta and de dos entradas. Con este mismo procedimiento se van ubicando todas y cada una de
las puertas lógicas del circuito mostrado en el enunciado y una vez emplazadas se procede a la
inserción de los terminales de entrada y de salida.
Estos componentes reciben el nombre de “output” e “input” y se pueden obtener de la

misma forma que las puertas lógicas que ya tenemos en nuestro esquema.
Para editar las propiedades de alguno de estos componentes, y en especial los nombres de
los terminales de entrada y salida, colocamos el ratón sobre el ítem a modificar y hacemos click
sobre él. Automáticamente el componente seleccionado es recuadrado en rojo, tal y como se
muestra en la figura:
Entonces se puede seleccionar el texto y editarlo, o bien pulsar con el botón derecho del
ratón y acceder a otras propiedades:
27
Para trazar el cableado entre los diferentes componentes, sitúe el cursor sobre uno de los
extremos del terminal origen y deslice éste sobre el tablero de dibujo hasta conseguir la forma del
cable que se adapte a las necesidades del circuito. Repita esta operación hasta completar el esquema
propuesto.
A continuación, siga los pasos descritos anteriormente en este tutorial para salvar el diseño
con el nombre: “hex7seg.gdf ” y a continuación realice una comprobación y la correspondiente
simulación hasta que no existan errores en el circuito.
3.4.- PROGRAMAR LA TARJETA DE DESARROLLO CON EL

EJEMPLO.
Nos encontramos en la parte final del proceso en donde ejecutamos una parte del programa en
la cual se produce la programación en la FPGA del diseño realizado por el alumno. Como ya se
explicó en los primeros apartados relacionados con la tarjeta de desarrollo de prototipos, los datos
del ordenador son “volcados” a la tarjeta a través del puerto paralelo del ordenador y un medio de
transmisión físico con el dispositivo que es el cable de conexión, según se muestra en la siguiente
figura:
28
La asignación de los contactos de dicho conector se muestra en la siguiente tabla:
En la parte que concierne al software, el programador de ALTERA realiza la función de

transferir el diseño efectuado a la tarjeta. Primeramente se tiene que especificar al programa qué
tipo de tarjeta, de entre las posibles alternativas posibles, se va a emplear. Es conveniente realizar
esta operación antes de asignar las patillas en el circuito esquemático y de compilar el diseño.
Esta operación se realizará en el menú “ASSIGN” en la opción “DEVICE”, mediante la

pantalla siguiente:
29
La Familia de FPGA ó EPLD seleccionada es la MAX7000S, y el dispositivo que tiene la

tarjeta de desarrollo del laboratorio es la EPM7128SLC84-7 (-15). Este elemento puede ser
detectado de forma automática por el software en el caso de no conocer exactamente el modelo que
estamos empleando, en el caso de trabajar con dispositivos diferentes al del Laboratorio.
Una vez realizada la selección, aceptamos los valores fijados y el sistema queda listo para
realizar la simulación con la tarjeta del laboratorio. Para ello, y continuando con el ejemplo
propuesto, vamos a activar la opción del programador. Como en ocasiones anteriores, se activará
automáticamente una pantalla en donde se procederá a la programación de nuestro diseño en la
memoria interna de la tarjeta para que podamos simular el circuito.
Para comenzar el proceso seleccionamos el botón “PROGRAM”. La pantalla del programador

tiene este aspecto:
Si todo ha transcurrido con normalidad, en ella se crearán los últimos archivos auxiliares en
donde se guarda la información necesaria para ejecutar la aplicación en la tarjeta.
Desde aquí también podemos seleccionar el dispositivo de hardware que vayamos a emplear y
verificar si éste está correctamente conectado a nuestro PC y se encuentra alimentado. En caso
contrario aparecerá el siguiente mensaje de error y tendremos que comprobar la alimentación y las
conexiones del aparato.
30
En este proceso, se definen físicamente las conexiones entre los terminales del integrado y el
dispositivo lógico que ha sido programado. Para visualizar cómo ha quedado distribuidas estas
conexiones empleamos el “FLOORPLAN EDITOR”, que es una herramienta de visualización con
una pantalla como la que se muestra a continuación:
Situando el cursor del ratón sobre la cabecera de los bloques representados en la figura, el
programa nos dará información acerca de ese contacto, su procedencia y la patilla de la FPGA a la
que corresponde la conexión (si es entrada ó salida) ó el integrado al que pertenecen de los
empleados en el diseño.
Además disponemos de un estudio estadístico de la congestión y el nivel de aprovechamiento

que tenemos de los recursos del sistema.
Para acceder a ella, hacemos “Doble click” sobre la cabecera del integrado del cual queramos
saber sus parámetros y encontraremos la siguiente pantalla:
31
Con este proceso se puede analizar cualquier nodo del circuito y plantear posibles
alternativas para mejorar los recursos de que se dispone. Esta información no será relevante en el
ejemplo propuesto en este manual pero, sin duda, puede ser muy útil cuando el diseño que se desee
realizar tenga mayores perspectivas y se encuentre próximo a superar las capacidades de la FPGA,
teniendo en cuenta que el integrado que empleamos es uno de los “Hermanos menores” de la
familia de EPLD que hay en el mercado.
3.6.- VERIFICACIÓN DEL FUNCIONAMIENTO.
Ya hemos realizado todos los pasos para convertir un proyecto “sobre el papel” en un modelo
ejecutable por el alumno en una tarjeta de circuito impreso diseñada para tal efecto. Ahora lo que
resta es que éste compruebe que las condiciones de funcionamiento que había especificado en su
diseño se ajusten a las que está observando en la tarjeta.
Hay que tener muy en cuenta que la alimentación de dicha tarjeta ha de ser de +5V y que no se
debe superar ésta o se provocará una avería. Las tarjetas están dotadas de una protección contra
sobretensiones, pero no es recomendable superar el valor antes mencionado al aplicar tensión en las
bornas de alimentación.
32
También hay que vigilar que la conexión de la tarjeta con el ordenador esté correcta y
asegurada, ya que si se desprende el conector puede dar lugar a un mal funcionamiento del proceso
de “volcado de datos” que es realizado al programar la tarjeta.
4.- SIMULACIÓN LOGICA.
Los primeros pasos a dar para realizar la simulación lógica pasan por la creación de un modelo
de simulación a partir de los ficheros que se han empleado para hacer el diseño y lo enfocaremos a
un tipo de simulación funcional o con retardos. Definiremos también una serie de “Vectores de
test” que son un conjunto de estímulos o señales que aplicamos a los elementos de entrada de
nuestro circuito para verificar su funcionamiento bajo una serie de características definidas en los
mismos.
La creación de estas señales de entrada ó vectores de test debe ser realizada con toda
precaución, ya que se trata de un paso muy importante en la simulación lógica que resulta ser la
base de la comprobación del circuito.
Esta operación puede ser efectuada mediante dos métodos: uno gráfico y otro mediante un
lenguaje de texto, como por ejemplo VHDL o VERILOG, muy extendidos en la Industria. La
complejidad de la simulación depende proporcionalmente del circuito que tratemos de verificar, ya
que a mayor nivel de circuito, más dificultad a resolver por la máquina.
En cualquier caso, para todas la aplicaciones que se verán en este curso, la simulación lógica no
tomará más de unos minutos de trabajo por parte del software de aplicación.
4.1.- SIMULACIÓN LÓGICA CON HERRAMIENTAS DE ALTERA.
Como ejemplo de la simulación lógica con MAX+PLUS II emplearemos el diseño del

decodificador BCD a 7 segmentos que realizamos unos capítulos atrás. Primero abriremos el
archivo que lo contiene y posteriormente activaremos el compilador. Ahora decidiremos el tipo de
simulación que se va a realizar, ya sea funcional o simulación con retardos de propagación en los
componentes lógicos empleados en la sintaxis del diseño.
En la barra de menú principal encontramos un menú desplegable con el nombre de

“PROCESSING”. Al abrirlo encontramos las posibles opciones de compilación.
Para una simulación funcional , activamos la opción “FUNCIONAL SNF EXTRACTOR” , tal
y como se muestra en la figura:
33
Y el compilador queda con la siguiente apariencia:
4.2.- FICHEROS GRÁFICOS PARA SIMULACIÓN.
Vamos a partir de un proyecto que ya haya sido compilado con éxito para proceder
posteriormente a la creación de un fichero de estímulos y asociar estos a las correspondientes
entradas o salidas de nuestro diseño. Los ficheros gráficos de simulación son los más fáciles de
estudiar ya que estamos más acostumbrados a este tipo de señales (ORCAD) que las generadas por
un archivo de texto.
Para crear un fichero gráfico que contenga los estímulos de entrada salida, establecemos el
proyecto de trabajo, con el diseño a comprobar, en el directorio en curso.
34
A continuación seleccionamos en el menú principal la opción “FILE”, “NEW” y una vez allí la
opción de “WAVEFORM EDITOR FILE”, tal y como se muestra en la figura:
Al aceptar esta opción nos encontraremos con una pantalla como esta:
El siguiente paso será definir en qué terminales vamos a introducir señales de simulación.
Para ello , en el menú principal activamos la opción “NODE” , “ENTER NODES FROM SNF”
y aparecerá la siguiente pantalla:
35
Arriba a la derecha pulsamos el botón “LIST” y nos aparecerán todos los terminales que
hayan sido declarados en el diseño del circuito (GDF). En la siguiente figura vemos el ejemplo del
decodificador BCD a 7 segmentos que diseñamos anteriormente mediante circuitos
combinacionales y que posteriormente se integró en un bloque.
Podemos observar que el programa nos muestra directamente la señales de entrada y de salida
claramente identificadas para que nosotros a continuación sólo tengamos que asignar una de ellas a
cada canal de simulación:
36
Los nodos ó terminales que llevan consigo la letra (I) son de entrada y los que tienen la (O) son
de salida. Seleccionamos, por ejemplo, el nodo d(I) de la lista que nos ofrecen y pulsamos el botón
“ => ” del centro de la pantalla para confirmar su selección. A continuación éste nodo se activará en
la lista de nodos seleccionados. Repetimos estos pasos para todas las entradas del decodificador.
Tras realizar esta operación pulsamos el botón “OK” y los nodos estarán entonces
representados en la pantalla principal en forma de ejes de abcisas en los que podremos componer las
señales mediante el simulador gráfico, emplazando las señales por cada canal de simulación como
si se tratase de un osciloscopio digital en el que se introducen las entradas procedentes de un
emulador digital.
Estas referencias de diseño abarcan todos y cada uno de las entradas o salidas seleccionadas
anteriormente, tal y como se muestra en la figura de la página siguiente.
Existe también la posibilidad de emular los Bits o palabras (Bytes) del contenido que se situaría
en una memoria del tipo RAM ó ROM de las que se incluyen en la librería, de forma que se podría
simular la entrada o salida de datos a uno de estos elementos con las dos opciones situadas en la
parte derecha del tipo de nodo.
37
4.3.- DEFINICIÓN DE ESTÍMULOS
La primera operación a efectuar es delimitar el tiempo total de simulación. Seleccionamos en el

menú “FILE” la opción “END TIME” y nos aparecerá por defecto el tiempo de 1 microsegundo en
la siguiente pantalla:
Escribimos el valor del tiempo de ejecución del sistema en la simulación, dependiendo de cada
diseño en particular. Para el ejemplo que estamos ilustrando en este manual de trabajo,
seleccionamos el tiempo de 10µs y pulsamos el botón “OK”.
38
A continuación adaptamos la rejilla y los valores de ésta. En el menú “OPTIONS” tenemos que
tener activado el “SNAP TO GIRD” y especificaremos el ancho de rejilla mediante la opción
“GIRD SIZE...” de ese mismo menú. Aparecerá entonces la siguiente pantalla en donde
actualizaremos el valor que queramos para la rejilla:
En principio podemos dejar este valor que aparece en la pantalla ya que no provocará que sea
demasiado densa ni muy extendida, sino equilibrada con respecto al tiempo límite de simulación
que especificamos anteriormente.
Para otro tipo de simulación realizada por el alumno, los tiempos totales y las divisiones del
mismo serán fijadas en cada caso, dependiendo de la aplicación a simular y a las condiciones de
diseño y funcionamiento de la misma.
4.3.1.- DEFINICIÓN DE SEÑALES.

En este apartado vamos a realizar las simulación de señales cuadradas de factor de servicio del
50%, óptimas para el ejemplo del decodificador y punto de partida para que ele alumno pueda
desarrollar el resto de señales que sean útiles para su propio modelo de simulación. Partiendo de la
pantalla principal del simulador lógico, seleccionamos sobre el campo “VALUE” de la señal de
entrada “d” del decodificador y a continuación pulsamos el icono situado en la barra de
herramientas de la izquierda que tiene la siguiente forma física: Con ello se activará la
pantalla siguiente :
Estos son los valores que aparecen por defecto y que tienen que ver con los parámetros de la
rejilla que definimos anteriormente. Si queremos que la frecuencia varíe sólo tenemos que
modificar el valor de multiplicación que está a mano derecha.
39
Con ello formaremos las señales de diferente periodo, tal y como se indica en la figura:
Realizamos este proceso multiplicando las señales de entrada por 2, 4, y 8 respectivamente, de

forma que tengamos un código binario natural aplicado a las entradas del decodificador, tal y como
se indica en la siguiente tabla:
NUMERO CODIFICACION
REPRESENTADO BINARIA
0 0000
1 0001
2 0010
3 0011
4 0100
5 0101
...... ......
14 1110
15 1111
40
La señal generada queda así:
En el caso de que la señal a crear sea para un BUS, los pasos serán muy similares al de una
señal sencilla, salvo que para asignar el valor a la misma, emplearemos el comando “EDIT”,
“OVERWRITE”, “COUNT VALUE...”. Y la pantalla que aparecerá será la siguiente:
41
Finalmente añadiremos los valores que vayamos a emplear y aceptaremos el cambio en las
opciones. Existen otros tipos de ficheros de estímulos basados en programas de texto muy similares
a los descritos en el apartado VHDL, pero no van a ser objeto de estudio en este manual.
4.4.- PUESTA EN MARCHA DE LA SIMULACIÓN.
Tras definir el archivo que contiene las señales que serán simuladas posteriormente, hay que
guardar éste con el mismo nombre que tenga el proyecto en curso . De lo contrario
no será capaz de encontrarlo al realizar la simulación y dará un mensaje de error.
Para realizar esta operación correctamente, activamos en el menú principal la siguiente

secuencia de operaciones: “FILE, SAVE AS” y después seleccionamos el mismo nombre que el
fichero del proyecto y la extensión SNF de entre las opciones disponibles, que corresponde a un
fichero gráfico de estímulos o señales (Waveform editor file). El siguiente paso será activar el
simulador. Bien desde los iconos de la barra de herramientas superior o desde el menú desplegable
de Max+plus II situado a la izquierda, arriba. En cualquiera de los dos casos aparecerá la siguiente
pantalla:
IMPORTANTE: La opción “USE DEVICE” no debe estar seleccionada para realizar la

simulación . En caso contrario aparecerá el siguiente mensaje de error:
42
Una vez tenido en cuenta este importante detalle, el siguiente paso a dar es iniciar la simulación
pulsando el botón “ START ” de la pantalla del simulador. Arranca en ese momento el compilador
del sistema de simulación y al finalizar ésta podemos encontrar dos posibilidades. Una de ellas es
que todo el proceso se haya desarrollado satisfactoriamente y aparezca la siguiente pantalla:
La segunda posibilidad es que exista algún error en la simulación, en cuyo caso aparecerá esta
misma pantalla, pero se indicarán en ella los errores o advertencias que se detectaron en el proceso
de simulación. Si acudimos a la ayuda existente en dicha ventana localizamos el error y lo
solucionamos. Una vez repasados los errores comprobamos el funcionamiento en la pantalla del
simulador de señales:
43
5.- LENGUAJES HDL.
Las siglas HDL (Hardware Description Lenguages) nos definen un lenguaje de especificación
de hardware que es empleado para el diseño, de manera alternativa a lo visto en los capítulos
anteriores, de forma que se realiza el proceso de diseño, comprobación y simulación de forma
homóloga a la captura o dibujo de esquemas de circuitos digitales.
Existen dos variantes de este lenguaje que son empleadas por el software de ALTERA y que
van a ser descritas a continuación:
• VHDL.- Es un lenguaje empleado en los entornos EDA que tiene un propósito general y
mantiene una alta compatibilidad con los diseños realizados sobre distintas plataformas ya
que sus ficheros son identificados y aceptados por cualquier programa de diseño. Esto se
debe a que este lenguaje ha sido normalizado por la IEEE.
• AHDL.- Este otro lenguaje es más particular del entorno EDA de ALTERA y sólo vale
para éste. Plantea una ventaja frente al VHDL, que por su parte es muy versátil, pero muy
complicado de manejar y dominar. El AHDL resulta más sencillo de aprender por el
alumno y éste puede emplearlo como base para estudiar otros lenguajes de este tipo de
mayor nivel de dificultad. El único inconveniente que plantea es que no es compatible con
ninguna otra plataforma de diseño que no sea ALTERA.
5.1.- REALIZACIÓN PRÁCTICA DE CIRCUITOS MEDIANTE EL

LENGUAJE HDL.
Continuando con el ejemplo que vimos en los capítulos anteriores o comenzando otro proyecto
de diseño diferente, los pasos que tenemos que dar para definir un fichero HDL en cualquiera de sus
dos versiones (VHDL ó AHDL), son:
1º.- Seleccionar un proyecto de trabajo en el que se desee crear el fichero.
2º.- Crear un fichero de diseño dentro de ese proyecto.
3º.- Escribir el código de programa y la descripción del mismo.
4º.- Comprobar el fichero de diseño que hemos creado.
5º.- Solucionar los posibles fallos encontrados y simular el diseño.
44
Siguiendo estos cinco sencillos pasos, el alumno será capaz de crear un fichero en alguno de los
lenguajes HDL y hacer una descripción de hardware en dicho código y comprobar su
funcionamiento por distintos métodos, entre ellos la simulación lógica, vista en el capítulo anterior
y de una gran utilidad tanto para el estudiante como para los diseñadores profesionales.
5.1.1.- SELECCIÓN DEL PROYECTO DE TRABAJO Y CREACIÓN EL

FICHERO HDL.
En primer lugar y siguiendo los pasos establecidos anteriormente, hay que abrir un nuevo
archivo de edición de texto para trabajar sobre él. Se hará mediante el menú “FILE”, en la opción
“NEW”, seleccionando las opciones que se han indicado en la siguiente imagen:
Una vez aceptada la pantalla anterior, nos encontramos con una ventana de edición de texto
como la mostrada en la siguiente figura:
45
Ahora para convertir este fichero de texto a otro de la forma VHD, tenemos que guardar el
fichero mediante el menú “FILE”, “SAVE AS”, teniendo en cuenta que la extensión tiene que ser
para un archivo de la forma VHDL, como se muestra a continuación:
(Nombre del fichero ) . vhd
Ya que el propio programa tendería a salvarlo por defecto con la extensión “ tdf ” que como
vimos al principio de este documento, se correspondía con los archivos de AHDL. La pantalla
empleada para esta función es la siguiente:
5.1.2.- CREAR UN FICHERO DE DISEÑO.
Como parte del ejercicio que estamos realizando, vamos a hacer el decodificador de BCD a 7
segmentos y lo incluiremos posteriormente en el diseño efectuado al principio, en sustitución del
integrado que fue empleado en capítulos anteriores y diseñado mediante un circuito combinacional.
En primer lugar tenemos que realizar las descripciones que son posibles sintetizar en VHDL
mediante el ejemplo descrito, y posteriormente, en el editor de texto que abrimos antes realizaremos
el programa que definirá el decodificador en el lenguaje HDL. Este fichero tendrá que conservar el
nombre de la entidad de programación.
Durante todas las operaciones de esta creación del archivo, si alguna de las terminologías
empleadas o conceptos descritos no se ha desarrollado con la suficiente claridad, el alumno puede
encontrar información complementaria en los archivos de ayuda de que dispone el programa de
ALTERA en la carpeta de ayuda de VHDL que encontrará en el menú principal de Ayuda (HELP).
46
5.1.2.1.- INTERFACE DEL DISPOSITIVO Y DECLARACIÓN DE

ENTIDAD.
A continuación se va a describir, dentro de este lenguaje, el nombre de los dispositivos con sus
entradas y salidas, puertos y declaración de entidades mediante la siguiente sintaxis:
ENTITY (Nombre del dispositivo) IS
PORT (
[Lista de puertos de entrada] : IN [Tipo de dato] ;

[Lista de puertos de bidireccionales] : INOUT [Tipo de dato] ;
[Lista de puertos de salida] : OUT [Tipo de dato] ;
[Lista de puertos de salida] : BUFFER [Tipo de dato] ;
END (Nombre de dispositivo)
Las normas principales que tenemos que observar a la hora de realizar nuestro diseño son:
• El nombre asignado al campo ENTITY debe coincidir con el fichero empleado para
la edición que hemos asignado en los pasos anteriores, en caso contrario no podrá
compilar el archivo.
• Para los nombres de los puertos definiremos etiquetas alfanuméricas que no

coincidan con los elementos de sintaxis definidos por el programa para operaciones. Una
vez que terminemos el diseño, estos nombres serán asignados a cada uno de los
terminales del circuito y podrán dar lugar a conflicto con el programador a la hora de
“volcar” los datos a la tarjeta de la FPGA.
• El flujo de entrada o salida que tienen cada uno de los terminales que hemos
asignado puede ser unidireccional (Entrada ó salida) o bidireccional. La descripción de
cada una de las funciones de los puertos será efectuada posteriormente.
• Los datos que van a recibir o enviar estos puertos deben ser definidos en tres grandes
grupos: Variables, constantes y señales. Este tratamiento específico nos permitirá asignar
operadores aritmético-matemáticos, lógicos (binarios o en matriz) o de conversión a cada
terminal, dependiendo de su funcionalidad.
• Para el caso de que los datos a manejar sean señales, el lenguaje VHDL nos permite
clasificarlos de otras dos formas: BIT y BIT_VECTOR, dependiendo del tamaño del
array o bus que se asigna a dicho elemento de entrada /salida / bidireccional, ya que si
éste puede ser de un solo bit o de 4, 8, etc.
47
Dentro de las ayudas que facilita el programa se encuentran una serie de plantillas de las
estructuras más comúnmente empleados en la programación con VHDL. Para activarla
seleccionamos en el menú “TEMPLATES” la opción que afecta al lenguaje de programación que
estemos empleando, tal y como se puede ver en la figura, pero seleccionando VHDL.
Posteriormente, el volver a esa misma opción del menú principal, lo que nos encontremos será
la siguiente ventana, en donde encontraremos una plantilla para cada uno de los siguiente casos
posibles:
Por ejemplo, seleccione de la opción “Library Clause”, posteriormente acepte.
Repita los pasos anteriores para los casos: “Use clause” y “Entity declaration”.
48
Al realizar esta operación aparecerá en el editor de texto el cuadro de opciones que estábamos
describiendo en las páginas anteriores, en donde podemos rellenar los datos que nos hagan falta
sustituyendo las condiciones adecuadas para el ejemplo que se esta siguiendo, tal y como se muestra
en las dos siguientes figuras:
Completando la plantilla descrita con los datos de programación del decodificador, tal y como
se muestra en la siguiente figura:
49
Se emplearán las letras mayúsculas para los comandos de función y las minúsculas para los
nombres de archivos y dispositivos auxiliares. Además, para estos últimos se emplea un color
negro, y para los primeros el color azul que identifica automáticamente nombre.
Una vez definido el comienzo del programa, procederemos a definir las especificaciones de
funcionamiento a través de una serie de “cuerpos de arquitectura ”. Podemos encontrar varios de
éstos dentro de un mismo componente ya que pueden existir pequeñas modificaciones en el
funcionamiento o diferencias de comportamiento por distintos por tener diferentes arquitecturas
para simulación y para síntesis.
Para estas descripciones emplearemos los “PROCESOS” que utilizan los algoritmos o
funciones que nos permiten determinar el valor de las salidas en función del valor que tomen las
variables de entrada al circuito o las de control si es que se han especificado estas últimas.
Al igual que en el paso anterior, existe una plantilla que nos va a permitir facilitar la tarea de
asignar la sintaxis adecuada al proceso de programación:
ARCHITECTURE [nombre de arquitectura] OF [nombre de entidad] IS
SIGNAL __signal_name : STD_LOGIC;

SIGNAL __signal_name : STD_LOGIC; Zona de declaración
BEGIN
-- Process Statement
-- Concurrent Procedure Call
-- Concurrent Signal Assignment
-- Conditional Signal Assignment Zona de descripción
-- Selected Signal Assignment
-- Component Instantiation Statement
-- Generate Statement
END [nombre de arquitectura];
El nombre que empleamos para la arquitectura hace referencia a la estructura o funcionamiento

de la misma.
50
En la zona de declaración, que se encuentra debajo del nombre de la arquitectura, se emplea

para realizar las declaraciones de la unidad, especificando las señales, tipos de datos, subprogramas
y componentes que vayan a ser empleados posteriormente en la descripción que empieza después
del comando “BEGIN” y donde escribiremos el código que describa el funcionamiento del circuito
especificado.
Para describir la funcionalidad del circuito combinacional que estamos empleando,

elaboraremos el “PROCESO” que será sensible a todas las señales de entrada y salida y nos
asignará a las salidas la combinación, adecuada en cada caso, de las señales de entrada al circuito.
El proceso tiene esta estructura:
__process_label:
PROCESS (__signal_name, __signal_name, __signal_name)
VARIABLE __variable_name : STD_LOGIC;

VARIABLE __variable_name : STD_LOGIC; Zona de declaración
BEGIN
-- Signal Assignment Statement
-- Variable Assignment Statement
-- Procedure Call Statement

Zona de descripción
-- If Statement
-- Case Statement
-- Loop Statement
END PROCESS __process_label;
Ahora que ya se conoce la estructura sintáctica de alguno de los componentes básicos de un

archivo VHDL, completaremos los datos correspondientes al diseño del alumno de un
decodificador BCD a 7 segmentos, tal y como se detalla a continuación.
En el archivo de texto que se había abierto con el nombre “decobcd7seg ” tras la declaración
de entidad vista anteriormente se sitúa la cabecera de arquitectura, completándola como se indica en
el ejemplo.
51
Se añade a continuación el proceso que tenga todas las señales de entrada y describa el
algoritmo de funcionamiento o tabla de verdad del decodificador buscado, empleando una sentencia
adecuada como es “CASE”, conocida en varios lenguajes de programación.
ARCHITECTURE funcional OF decobcd7seg IS
BEGIN
PROCESS (a,b,c,d)
VARIABLE index : STD_LOGIC_VECTOR (3 DOWNTO 0);
BEGIN
index := d & c & b & a ;
CASE index IS
WHEN “0000” => S <= “1111110”;

WHEN “0001” => S <= “1101101”;
WHEN “0010” => S <= “1111101”;
WHEN “0011” => S <= “1111001”;
WHEN “0100” => S <= “0110011”;
WHEN “0101” => S <= “1011011”;
WHEN “0110” => S <= “1011111”;
WHEN “0111” => S <= “1100000”;
WHEN “1000” => S <= “1111111”;
WHEN “1001” => S <= “1110011”;
WHEN OTHERS => S <= “0000000”;
END CASE;
END PROCESS;
END funcional;
Ahora se comprueba que ha sido introducido el código de programa satisfactoriamente

mediante la comprobación del compilador. Para ello se presiona las teclas CTRL + K y éste
arrancará.
52
Si se produce algún error en el proceso nos lo comunicará y lo solucionaremos. En caso de que

se haya completado con éxito la compilación, cerramos la ventana del compilador. En este
momento el programa habrá creado un símbolo para este nuevo módulo. Este lo podremos
encontrar abriendo el fichero decobcd7seg.sym mediante el menú principal de archivos.
Y el símbolo que se ha creado es el mostrado en la figura:
53
Una vez que hemos visto el símbolo creado mediante el programa, comprobamos si las
especificaciones iniciales que teníamos de dicho componente se asocian con la realidad que estamos
visualizando. En caso contrario, realizaremos las modificaciones del símbolo ó del módulo VHDL
mediante la edición del archivo de texto “decobcd7seg.vhd”.
Vamos a convertir el vector de salidas en elementos individuales, asignando cada uno de los
segmentos de visualizador a uno de los terminales de salidas del decodificador creado.
Modificamos y añadimos la siguiente secuencia de código al programa:
LIBRARY ieee;
USE ieee.std_logic_1164.ALL, ieee.std_logic_arith.ALL;
ENTITY decobcd7seg IS
PORT(
a,b,c,d : IN STD_LOGIC;
sa,sb,sc,sd,se,sf,sg : OUT STD_LOGIC;
);
END decobcd7seg;
ARCHITECTURE funcional OF decobcd7seg IS
BEGIN
PROCESS (a,b,c,d)
VARIABLE index : STD_LOGIC_VECTOR (3 DOWNTO 0);

VARIABLE S: STD_LOGIC_VECTOR (6 DOWNTO 0);
BEGIN
index := d & c & b & a ;
CASE index IS
WHEN "0000" => S := "1111110";

WHEN "0001" => S := "1101101";
WHEN "0010" => S := "1111101";
WHEN "0011" => S := "1111001";

WHEN "0100" => S := "0110011";
WHEN "0101" => S := "1011011";
WHEN "0110" => S := "1011111";
WHEN "0111" => S := "1100000";
54
WHEN "1000" => S := "1111111";

WHEN "1001" => S := "1110011";
WHEN OTHERS => S := "0000000";
END CASE;
sa <= S(6);
sb <= S(5);
sc <= S(4);
sd <= S(3);
se <= S(2);
sf <= S(1);
sg <= S(0);
END PROCESS;
END funcional;
Al compilar el archivo de texto mediante la orden CTRL + K y verificar que no han existido
errores, se procede a actualizar los puertos, abriendo el fichero que corresponde al símbolo creado.
Al realizar esta operación nos damos cuenta de que no han sido actualizados los puertos del mismo
y continúan siendo los del caso anterior. Para solucionar este problema se activa la opción del menú
“FILE”; “CREATE DEFAULT SYMBOL” y en ella se confirma la actualización de dicho puerto.
Para ello aparecerá la siguiente pantalla que debemos aceptar en caso de que sea correcta la
actualización que vamos a emplear:
Esta opción modifica el símbolo anterior y lo convierte al nuevo. Y tras aceptar esta opción el
programa genera el símbolo:
Al abrir el archivo decobcd7seg.sym podemos ver que los cambios han sido efectuados, tal y
como se puede ver en la siguiente imagen:
55
Estos pasos deberán efectuarse tantas veces como sea necesario para que quede cambiado el
símbolo con las distintas modificaciones que realicemos sobre él.
5.2.- LIBRERIAS VHDL DE USUARIO.
La primera condición que debemos cumplir para emplear las librerías VHDL es que éstas estén
incluidas en el directorio del proyecto con el que estamos trabajando. Una vez que se cumple esta
primera condición, para poder manejar una librería en el diseño en el que trabajemos, activamos el
compilador, seleccionamos la opción “INTERFACES” de la barra de menú principal y
posteriormente en el menú desplegable la opción “VHDL NETLIST READING SETTINGS...” con
lo que aparecerá la siguiente ventana:
56
Escribimos en las casillas correspondientes al nombre de la librería y al directorio que la

contiene y pulsamos el botón “ADD”, con lo que la librería quedará añadida al proyecto actual y
será posible acceder a ella en el transcurso del diseño.
Si hace falta alguna librería más, el alumno podrá repetir estos pasos y añadir las librerías
necesarias, bien las existentes en el entorno MAX+PLUS II o las creadas por él mismo.
5.3.- INTEGRACIÓN DE MÓDULOS VHDL EN ESQUEMAS.
Estos módulos que han sido descritos en los apartados anteriores pueden insertarse en cualquier
esquema que se realice, para ello, desde el directorio donde se encuentre asignado el proyecto en
curso, se inserta el módulo VHDL necesario y se emplean sus terminales de entrada/salida según los
requerimientos de diseño.
Posteriormente se guarda el esquema finalizado y se comprueba su funcionamiento mediante el

compilador y el programador, tal y como se definió en capítulos anteriores.
57

Diseño Digital Con Logica

Загружено:

Сведения о документе

Оригинальное название

Авторское право

Доступные форматы

Поделиться этим документом

Поделиться или встроить документ

Параметры публикации

Этот документ был вам полезен?

Это неприемлемый материал?

Авторское право:

Доступные форматы

Diseño Digital Con Logica

Загружено:

Авторское право:

Доступные форматы

DISEÑO DIGITAL CON LOGICA

1.- INTRODUCCIÓN. ......................................................................................... 2

Para la implantación de los diseños que se efectuarán durante el curso, dispondremos de un

1.1.- ENTORNO MAX+PLUS II.

Editor de Patillajes y asignaciones. (Floorplan)

Ventana del simulador.

Especifica el nombre del proyecto.

Cambia el nombre del proyecto al del archivo que se está empleando.

Maneja el archivo de diseño de nivel superior.

Opciones para guardar (Archivos, simulador y compilador).

1.2.- TARJETA PARA EL DESARROLLO DE PROTOTIPOS

Los elementos de que disponemos en nuestra tarjeta de prototipos son:

1.- Una PLD de la familia MAX7000S de ALTERA.

2.- Un oscilador de cuarzo de 1.8432 MHz...

3.- 4 Pulsadores situados en la tarjeta.

5.- 3 Indicadores de siete segmentos.

7.- Una memoria RAM (con posibilidad de ampliación).

8.- Zona de inserción de componentes complementarios al diseño.

Los tres últimos ( S2, S3 y S4 ) se encuentran conectados a entradas dedicadas y S1 se

PULSADOR PIN F.P.G.A.

La tarjeta dispone de dieciséis microinterruptores distribuidos en dos módulos de ocho que se

1.- Todos los nombres comienzan por SW.

2.- A continuación viene un 1 ó un 2 para identificar el módulo al que pertenecen.

Cada uno de los microinterruptores se encuentra conectado a un terminal de la PLD y pone un

La interconexión de los microinterruptores y los terminal se muestra a continuación:

• DISPLAY1 identificado por la etiqueta U6.

• DISPLAY2 identificado por la etiqueta U7.

• DISPLAY3 identificado por la etiqueta U8.

Los terminales de la PLD conectados a las señales de multiplexación empleadas en el control

SEGMENTOS DEL LED’S DE LA TERMINAL

1.2.6.- MEMORIA RAM.

Las señales de interconexión entre la memoria y la PLD son las siguientes:

1.- El bus de direcciones: formado por quince líneas A0 ÷ A14.

El diagrama de bloques interno de la memoria RAM es el siguiente:

1.2.7.- CONECTOR DE ACCESO A TERMINALES DE USUARIO.

NOMBRE DEL TERMINAL PATILLA DEL

1.2.8.- ZONA DE WRAPPING.

1.2.9.- ACCESO A LOS TERMINALES DE LA TARJETA.

La asignación de los terminales de los recursos de la tarjeta a los conectores se detalla en la

CONECTOR P1 P2 P3 P4 P5 P6 P7 P8 P9 P10 P11

2.- DEFINICIÓN DE UN PROYECTO.

introducción, comentaremos algunos aspectos de la jerarquía de los proyectos en el entorno

2. Ficheros gráficos: Si son generados por la captura de esquemas de nuestro propio

3. Ficheros NETLISTS: Éstos son formados al importar de otros entornos de trabajo

5. Archivos de diseño de ALTERA. (.adf)

6. Archivos de máquinas de estado. (.smf)

Algunos de los más comunes que nos podemos encontrar son:

- Ficheros de programación del dispositivo PLD. (.sof , .pof , .hex )

- Ficheros de configuración. (.acf)

2.1.- JERARQUÍA DE UN PROYECTO.

En la imagen mostrada anteriormente podemos ver como está compuesta la jerarquía de

3.- EJEMPLO BÁSICO DE OPERACIÓN.

Crear el proyecto y capturar el esquema del ejemplo.

1. Verificar las reglas de diseño.

3. Corregir posibles fallos.

4. Programar la tarjeta de desarrollo con el ejemplo.

5. Verificación del funcionamiento.

3.1.- CREACIÓN DEL PROYECTO.

3.1.1.- CAPTURA DE ESQUEMAS.

Existen varios procedimientos para realizar la captura de un esquema bajo diversas

Posteriormente seleccionamos el elemento que queremos dentro del árbol de selección y

En caso de que se trate de un archivo que no se encuentre en nuestro proyecto de trabajo,

3.1.1.1.- CAPTURA POR ORCAD.