CuadernoLabMic PDF

Universidad de Sevilla
Departamento de Ingeniería Electrónica
LABORATORIO DE
MICROELECTRÓNICA
Dr. Miguel Ángel Aguirre Echánove

Dr. Fernando Muñoz Chavero
Dr. Jonathan Noel Tombs
Dr. Hipólito Guzmán Miranda
Dr. Javier Nápoles Luengo
Enero 2010
Laboratorio de Microelectrónica Digital
1 Universidad de Sevilla. 2010

Tabla de contenidos
Práctica 1. Control del Display de 7 segmentos ..................................................................... 3
1. Objetivo propuesto......................................................................................................... 4
2. Tarjeta S3 de Digilent ..................................................................................................... 4
2.1. Display de 7 segmentos y cuatro dígitos ............................................................ 4
2.2. Señal de reloj ........................................................................................................... 8
2.3. Pulsadores y reset asíncrono................................................................................. 8
3. Realización de la práctica .............................................................................................. 8
3.1. Divisor de frecuencia ........................................................................................... 10
3.2. Contador de 0 a 9 .................................................................................................. 10
3.3. Registro de desplazamiento ................................................................................ 10
3.4. Decodificador de binario a 7 segmentos ........................................................... 11
3.5. Bloque de jerarquía superior ................................................................................... 11
Práctica 2. Control de un monitor VGA ................................................................................ 13
1. Objetivo propuesto....................................................................................................... 14
2. Conexión VGA en la Tarjeta S3 de Digilent.............................................................. 14
3. Monitor VGA en modo 640x480 ................................................................................. 15
4. Realización de la práctica ............................................................................................ 19
4.1. Contador ................................................................................................................ 20
4.2. Comparador .......................................................................................................... 20
4.3. Dibuja ..................................................................................................................... 21
4.4. Gen_color............................................................................................................... 22
4.5. Frec_pixel............................................................................................................... 23
4.6. Nivel de jerarquía superior ................................................................................. 24
Práctica 3. Transmisión por línea serie .................................................................................. 25
1. Objetivo propuesto....................................................................................................... 26
2. Enlace Serie.................................................................................................................... 26
3. Realización de la práctica ............................................................................................ 27
a. Diseño de la memoria ROM utilizando CORE Generator.................................. 28
b. Realización de la práctica ........................................................................................ 35
c. Configuración del Hyperterminal. ........................................................................ 40
Práctica 4. PRÁCTICA DE SISTEMAS EMBEBIDOS USANDO EDK .............................. 42
1. Introducción .................................................................................................................. 43
2. Primera Parte ................................................................................................................ 43
3. Segunda Parte ............................................................................................................... 60

Práctica 1. Control del Display de 7 segmentos
Este práctica es la primera de un grupo de tres dedicada a entrenar al

alumno con el entorno de trabajo Xilinx ISE 8.2 y la tarjeta Digilent S3.
Se diseñarán una serie de contadores síncronos que permitirán controlar

los cuatro displays de 7 segmentos disponibles en la tarjeta. Los
principales objetivos didácticos son los siguientes:
1. Aprender las opciones básicas de simulación e implementación del

entorno Xilinx ISE 8.2.
2. Aprender a utilizar la hoja de características de la tarjeta S3 para

asignar correctamente los puertos de la FPGA en función de la
aplicación.

1. Objetivo propuesto
La tarjeta Digilent S3 de Xilinx es una placa de desarrollo para la FPGA de Xilinx

Spartan-3. Dicha tarjeta dispone de múltiples dispositivos de entrada/salida conectados
directamente a la FPGA. En la presente práctica nos centraremos en la utilización del
display LED de 7 segmentos y cuatro dígitos.
El objetivo es convertir el display en un contador que se incremente a una

velocidad “visible”. Para ello necesitaremos diseñar:
• Un contador de 25 bits que para dividir la frecuencia de reloj.
• Un contador entre 0 y 9 con reset síncrono y señal de saturación. Se utilizarán
cuatro contadores de este tipo.
• Un decodificador de binario a código de 7 segmentos.
• Pequeño registro de desplazamiento que controlará la señal de habilitación de
cada dígito.
2. Tarjeta S3 de Digilent
Para la realización de esta práctica utilizaremos la tarjeta S3 de Digilent. En este
apartado se explicará cómo funcionan los recursos de la tarjeta que utilizaremos en la
práctica1.
2.1. Display de 7 segmentos y cuatro dígitos
Básicamente, la tarjeta Digilent S3 consiste en una FPGA (Xilinx Spartan-3 con 200K
puertas equivalentes) cuyos puertos están unidos directamente a una serie de
periféricos. En la figura 1 Se muestra el diagrama de bloques básicos de la tarjeta.
Los cuatro displays de 7 segmentos están situados en la parte inferior derecha de la

tarjeta. El control de los displays está explicado en la figura 2. Se utilizarán las
siguientes señales (conectadas a puertos de la FPGA):
• A, B, C, D, E, F, G, y DP: 8 señales comunes para los cuatro dígitos. Cuando una
de estas señales se activa (fijando un ‘0’ desde la FPGA) se encenderá el
segmento correspondiente.
• AN0, AN1, AN2 y AN3: Señal de habilitación (activa a nivel bajo). Tendremos
una habilitación independiente para cada dígito, de forma que sólo se
encenderá el que esté habilitado.
1Toda la información de este apartado se ha extraída del documento Spartan-3 Starter Kit Borrad User
Guide disponible en la página de Digilent. Se anima al alumno a utilizar el documento original.

Figura 1. Diagrama de bloques de la tarjeta S3
A modo de ejemplo, en la figura 2, se ilustra qué estímulos (en azul) habría que
proporcionar a los displays para conseguir que aparezca un 2 en el primer dígito:
• Se activan (valor lógico ‘0’) las entradas A, B, E, D y G. Se dejan desactivadas

todas las demás.
• Se selecciona sólo el primer dígito (AN3=’0’), manteniendo desactivados los
demás (AN0=AN1=AN2=’1’).
Figura 2. Control de los displays de 7 segmentos

Es muy sencillo deducir (tabla 1) el código de entrada necesario para

representar un carácter en el display.
Un aspecto muy importante a la hora de implementar un diseño es selección de

puertos en la FPGA. En función de los periféricos o conectores que vayamos a utilizar
en nuestro proyecto utilizaremos unos puertos concretos de la FPGA, que deberán ser
especificados al realizar la implementación. Para conocer los puertos necesitamos
conocer la conexión entre la FPGA en la tarjeta S3.
En tabla 2 se especifica cómo está conectada la FPGA y los displays de 7

segmentos. El diseño final de esta práctica, una vez implementado en la FPGA, debe
controlar los pines del display a través de estos puertos.
Tabla 1. Códigos necesarios para la representación de caracteres

Tabla 2. Conexiones entre la FPGA y los displays de 7 segmentos (activos a nivel bajo)
En este punto podríamos hacernos una pregunta. Si, como hemos comentado
anteriormente, los cuatro displays comparten los 8 bits que encienden cada uno de los
segmentos: ¿cómo podemos utilizar los cuatro displays simultáneamente? La respuesta
podemos encontrarla en la figura 3.
Figura 3. Utilización de los 4 dígitos simultáneamente
Las señales de habilitación de los displays (AN0-3) servirán para multiplexar

en el tiempo las señales de activación de los segmentos (A,B, …, DP). De esta forma
estamos encendiendo sucesivamente un display y apagando todos los demás. Debido a
la persistencia de la visión, el cerebro humano percibe que todos lo caracteres se
encienden simultáneamente.

2.2. Señal de reloj
La tarjeta S3 dispone de un reloj de 50MHz (Epson SG-8002JF) y de un zócalo para

un generador de reloj opcional. En el laboratorio utilizaremos siempre la entrada de
reloj de 50 MHz disponible en el puerto T9 de la FPGA. Si fuera necesario utilizar otras
frecuencias de reloj se podrían obtener a partir de los 50MHz utilizando el Digital
Clock Manager de la Spatan 3.
2.3. Pulsadores y reset asíncrono
Para introducir el reset asíncrono a nuestro diseño utilizaremos uno de los cuatro
pulsadores de la parte inferior izquierda de la tarjeta. Debajo de los pulsadores
podemos encontrar una etiqueta con un nombre asignado al mismo (BTN3-0), y en la
tabla 3 de especifican los puertos de la FPGA conectados a los mismos. Al pulsar un
botón producimos un nivel lógico ‘1’ en el puerto correspondiente de la FPGA2.
Tabla 3. Puertos asociados a los pulsadores
Utilizaremos como reset asíncrono activo a nivel alto el pulsador BTN3

conectado al puerto L14 de la FPGA.
3. Realización de la práctica
En la figura 4 se muestra el esquema general de la práctica. Podemos distinguir los
siguientes bloques a diseñar en VHDL:
2Normalmente, para utilizar los pulsadores en un proyecto será necesario implementar un filtro de glitches
en la FPGA. En la presenta práctica, que utilizaremos el pulsador como reset asíncrono, no es necesario.

DIV_FREC CONT_DIGITO
sat enable cuenta 4
sat2 sat
clk reset clk reset
CONT_DIGITO
4
cuenta
enable
sat DECODIFICADOR
clk reset
4 binario siete_seg 7 7
A, B, C, D, E, F, G
CONT_DIGITO
cuenta 4
enable
sat
clk reset
‘1’ DP
CONT_DIGITO
cuenta 4
enable
sat
clk reset
REG_DESP 4 4
AN3-0
enable
Display_enable 4
clk reset
clk reset
Figura 4. Diseño a realizar en la práctica 1
1) DIV_FREC: Un contador de 26 bits para dividir la frecuencia de reloj a

frecuencia más visible por el ojo humano. Proporciona también una señal de
195KHz para la conmutación entre los displays.
2) CONT_DIGITO: Un contador de 0 a 9. Asignaremos un contador de este tipo a
cada dígito del display.
3) DECODIFICADOR: Un decodificador de binario a siete segmentos.
4) REG_DESP: Un pequeño registro de desplazamiento que controlará la señal de
habilitación de cada dígito. La señal de habilitación estará controlada por la
salida del bloque DIV_FREC a 195KHz.
Los bloques sombreados de la figura 4 (multiplexor y puertas AND) se

implementarán directamente, mediante órdenes concurrentes, en el nivel de
jerarquía superior.

3.1. Divisor de frecuencia

DIV_FREC
Descripción En la tarjeta S3 tenemos un reloj de 50MHz. Este bloque dividirá la esta
frecuencia por 226 para obtener una señal a una frecuencia de 0.74Hz.
El bloque consiste en un contador de 26bits que produce:
• Un pulso a la salida cada vez que
cuenta=”11111111111111111111111111”.
• Un pulso a la salida cada vez que
cuenta(7 downto 0) =”11111111”.
Entidad3 entity div_frec is
Port ( clk : in STD_LOGIC;
reset : in STD_LOGIC;
sat : out STD_LOGIC;
sat2 : out STD_LOGIC);
end div_frec;
Descripción de los puertos
Clk Reloj
reset Reset asíncrono activo a nivel alto
sat Se produce un pulso, de duración un solo ciclo de reloj, cada vez que el
contador llega la final de la cuenta:
cuenta=”11111111111111111111111111”
Sat2 Se produce un pulso, de duración un solo ciclo de reloj, cada vez que los ocho
bits menos significativos de cuenta llegan a:
cuenta(7 downto 0) =”11111111”
3.2. Contador de 0 a 9
CONT_DIGITO
Descripción Contador síncrono con habilitación. Cuando está activa la habilitación se
contará de 0 a 9, volviendo a comenzar de nuevo por 0.
Entidad entity cont_digito is
enable : in STD_LOGIC;
cuenta : out STD_LOGIC_VECTOR (3 downto 0);
sat : out STD_LOGIC);
end cont_digito;
clk Reloj
enable Señal de habilitación activa a nivel alto. Si enable=’1’ el contador avanzará
uno en la cuenta en el flanco positivo de reloj.
cuenta Salida de cuatro bits. Comenzará en “0000” y terminará en “1001”, volviendo
a empezar de nuevo.
sat Si cuenta sea igual a “1001”, sat estará activada (activa a nivel alto).
3.3. Registro de desplazamiento
3 Con objetivo de definir correctamente la interfaz del bloque se proporciona la entidad. El

trabajo del alumno consiste en declarar las librerías correctas y escribir la arquitectura.

REG_DESP
Descripción Registro de desplazamiento circular. El valor del registro al producirse un
reset asíncrono será “1110”, por tanto, la secuencia que se producirá será:
“1110” “1101” “1011” “0111” “1110”. (Ver figura 3). Sólo se
producirá un desplazamiento si módulo está habilitado.
El valor de registro se utilizará para controlar las señales de habilitación de
los displays: AN3:0.
Entidad entity reg_desp is
display_enable : out STD_LOGIC_VECTOR (3 downto
0));
end reg_desp;
clk Reloj
enable Habilitación activa a nivel alto
display_enable Valor del registro de desplazamiento. Con enable=’1’, se producirá un
desplazamiento cada flanco positivo de reloj:
• Todos los bits de desplazarán una posición a la izquierda (hacia el
BIT más significativo).
• El BIT menos significativo pasa a tener el valor del BIT más
significativo.
3.4. Decodificador de binario a 7 segmentos
DECODIFICADOR
Descripción Bloque combinacional que produce el código correcto para la activación del
display de 7 segmentos a partir del número en binario.
El diseño de este bloque es trivial utilizando la tabla 1 y una sentencia case
Entidad entity decoficador is
Port (binario : in STD_LOGIC_VECTOR (3 downto 0);
siete_seg : out STD_LOGIC_VECTOR (6 downto 0));
end decoficador;
binario Código binario sin signo
siete_seg Código de 7 segmentos según la tabla 1. Se corresponde, de más a menos
significativo, con las entradas A,B,C,D,E,F y G del display.
3.5. Bloque de jerarquía superior
Una vez diseñados y simulados los bloques anteriores pararemos a conectarlos tal
como se muestra en la figura 4.

CONTROL_DISPLAY
Descripción Realizará un contador de 4 dígitos en el display de 7 segmentos.
Bloque de mayor jerarquía que llama a todos los anteriores como
componentes.
Entidad entity control_display is
A : out STD_LOGIC;
B : out STD_LOGIC;
C : out STD_LOGIC;
D : out STD_LOGIC;
E : out STD_LOGIC;
F : out STD_LOGIC;
G : out STD_LOGIC;
DP : out STD_LOGIC;
AN : out STD_LOGIC_VECTOR (3 downto 0));
end control_display;
clk Reloj
A,B,C,D,E,F,G Salidas activas a nivel bajo que encienden los leds correspondientes del
display (ver figura 2)
DP Salida activa a nivel bajo que enciende el punto del display. Siempre estará
desactivada.
AN Habilitación de los diferentes dígitos del display. Se formará una secuencia
como se indica en la figura 3.

Práctica 2. Control de un monitor VGA
La tarjeta S3 dispone de un conector VGA cableado a la FPGA.

Utilizando dicho conector es posible conectar directamente un monitor
compatible con el estándar VGA.
El objetivo de la práctica consiste en:
1. Diseñar un driver VGA que permita representar imágenes con un

formato de 60Hz, 640x480 y 8 colores. Este driver será muy útil para
la mayor parte de los proyectos de la asignatura.
2. Ver un caso práctico de la utilización de GENERICS.
Esta práctica es la segunda de un grupo de tres dedicada a entrenar al

alumno con el entorno de trabajo Xilinx ISE 8.2 y la tarjeta Digilent S3.

En la presente práctica conectaremos directamente la FPGA a un monitor

compatible VGA (figura 5). Para ello, mediante una serie de contadores síncronos,
generaremos todas las señales necesarias para controlar el monitor en modo 60Hz,
640x480 y 8 colores.
Para conseguir nuestro objetivo necesitaremos diseñar:

• Un contador con reset síncrono y número de bits parametrizable mediante
GENERICS.
• Un comparador síncrono cuyos umbrales sean programables mediante
GENERICS.
• Un bloque que, a partir de las coordenadas de pantalla, genere los tres bits de
color necesarios.
Figura 5. Objetivo de la práctica
2. Conexión VGA en la Tarjeta S3 de

Digilent

La tarjeta S3 dispone de un conector DB15 cableado a puertos de la FPGA. Dicho

conector permite la conexión con la pantalla del PC utilizando un cable estándar VGA.
La conexión entre la FPGA y el conector se muestra en la figura 6.
Se utilizarán cinco puertos: HS (sincronismo horizontal), VS (sincronismo vertical),

R (rojo), G (verde) y B (azul).
Figura 6. Conexión entre la FPGA y el conector VGA
Teóricamente, Las señales de color (R, G y B) son analógicas y determinan la

intensidad de color de cada píxel. Sin embargo, en la placa están conectadas a un
puerto digital (entre 0 y 3.3V) a través de una resistencia de 270Ω. Al estar el cable
VGA terminado a 75Ω, un ‘1’ en la FPGA fijará una señal de 0.7V (máxima intensidad
de color) y un ‘0’ será 0V. Por tanto, tendremos sólo dos niveles por color, pudiendo
representar hasta 8 colores como se muestran en la tabla 4.
R G B Color
0 0 0 Negro
0 0 1 Azul
0 1 0 Verde
0 1 1 Cian
1 0 0 Rojo
1 0 1 Magenta
1 1 0 Amarillo
1 1 1 Blanco
Tabla 4. Representación de 8 colores
3. Monitor VGA en modo 640x480

En este apartado se explicará cómo deben generarse las señales HS, VS, R, G y B
para representar una imagen en un monitor en modo 60Hz, 640x480 y 8 colores. Es
decir, explicaremos brevemente el protocolo VGA.
Para explicar el protocolo VGA es necesario conocer el funcionamiento básico

de un Tubo de Rayos Catódicos (CRT)4. El funcionamiento básico de un CRT se explica
en la figura 7.
Figura 7. Funcionamiento del CRT
Tres cañones de electrones (1) producen tres haces de electrones, uno por cada
color básico (rojo, azul y verde). Estos haces de electrones se focalizan (2), utilizando
una bobina, para conseguir que converjan en un punto de la pantalla. Posteriormente,
mediante un campo magnético generado por un par de bobinas (horizontal y vertical)
se direccionan al punto deseado de la pantalla. En la pantalla de visualización (5), los
rayos son separados (3) por una máscara e inciden en una capa fosforescente con zonas
receptivas para cada color (4).
Por otro lado, la intensidad luminosa dependerá de la potencia a la que se emite

el haz de electrones, controlable mediante las señales analógicas R, G y B.
Se representarán imágenes en pantalla haciendo que el haz de electrones la

recorra en una sucesión de líneas (de izquierda a derecha) comenzando por la esquina
superior izquierda (figura 8).
4El tubo de rayos catódicos está quedando obsoleto, sin embargo los nuevos monitores LCD
mantienen la misma temporización en las señales de entrada VGA.

Figura 8. Representación de una imagen en un CRT
En la figura 8, la onda en forma de diente de sierra representa la corriente que

pasa por la bobina que crea el campo magnético para la deflexión horizontal. Se puede
comprobar, que se representa la imagen (Horizontal display time) cuando el haz de
electrones va de izquierda a derecha y está apuntando correctamente a la pantalla,
existiendo un tiempo (retrace time) para que el cañón vuelva al comienzo de la
siguiente línea. El pulso de sincronismo vertical (HS) marca el instante en que el cañón
debe comenzar una nueva línea, pudiendo distinguir un tiempo anterior (“front
porch”) en que el cañón está apuntando fuera de la pantalla y un tiempo posterior
(“pack porch”) necesario para que el haz se posicione en el inicio de la siguiente línea.
Es importante que durante todo el “retrace time” los cañones de electrones estén
apagados.
La frecuencia a la que se proporcionan los pulsos de sincronismos vertical y

horizontal determina la velocidad y el número de veces que el haz de electrones
recorre la pantalla. De esta forma seleccionamos la resolución de visualización de la

imagen en el monitor. El estándar VGA admite diferentes resoluciones, para las que
tendríamos que utilizar diferentes frecuencias en HS y VS5.
En esta práctica vamos diseñar un controlador VGA para la resolución 640x480

píxeles y 60 Hz de refresco de pantalla. Consideraremos una frecuencia de píxel de
25MHz, para lo que dividiremos por dos la frecuencia de reloj disponible de 50MHz
utilizando un biestable6.
Figura 9. Temporización necesaria para la resolución 640x480 píxel.
Todos los datos necesarios para generar correctamente las señales VGA se
proporcionan en la figura 9. En la tabla de la figura 9, el número de periodos (Clocks)
se refiere siempre a la frecuencia de píxel (25MHz) y no al reloj general del sistema
(50MHz).
Por tanto, el problema a resolver es cómo generar los pulsos de VS y HS con

duración y frecuencia adecuados para que sean entendidos por un monitor compatible
con el estándar VGA. En el siguiente apartado estudiaremos una solución sencilla y
eficiente a este problema.
5 En http://www.epanorama.net/documents/pc/vga_timing.html se proporciona un estudio que

permite seleccionar la frecuencia de HS y VS en función de la resolución de pantalla que
queremos conseguir.
6 También es posible configura la frecuencia de reloj a la que funcionarán los circuitos en la
FPGA utilizando el Digital Clock Manager de la Spartan 3.

En la figura 10 se representa el diagrama de bloques del diseño a realizar en la
presente práctica. Podemos distinguir:
1. CONTADOR: Contador con reset síncrono y señal de habilitación. El
número de bits del contador será parametrizable utilizando GENERICS.
2. COMPARADOR: Comprador síncrono. Los umbrales de comparación serán
parametrizables mediante GENERICS.
3. FREC_PIXEL: Generador de la frecuencia de píxel. Dividirá la frecuencia de
reloj por dos para obtener una señal de 25MHz. Es un bloque tan sencillo
que puede ser diseñado directamente en el nivel de jerarquía superior.
4. GENCOLOR: Este bloque asegura que el cañón sólo esté activo el tiempo en
que está apuntando a la pantalla. El resto del tiempo, que denominamos en
el apartado anterior retrace time el color presentantazo debe ser negro (R=’0’,
G=’0’ y B=’0’). Es decir, el cañón debe estar apagado el tiempo de retorno. Se
recomienda que este bloque se diseñe directamente en el nivel de jerarquía
superior.
5. DIBUJA: Genera los colores (R, G y B) deseados en función de las
coordenadas de pantalla. Dependiendo cómo se diseñe este bloque se
representará una imagen diferente en pantalla.
Figura 10. Diagrama de bloques del controlador VGA

4.1. Contador
CONTADOR
Descripción Contador síncrono de Nbit con habilitación y reset síncrono
Entidad entity contador is
Generic (Nbit: INTEGER := 8);
resets : in STD_LOGIC;
Q : out STD_LOGIC_VECTOR (Nbit-1 downto 0));
end contador;
clk Reloj
enable Señal de habilitación activa a nivel alto. Si enable=’1’ el contador
avanzará uno en la cuenta en el flanco positivo de reloj.
resets Reset síncrono activo a nivel alto. Si resets=’1’ el contador pasará a
cero en el siguiente flanco positivo de reloj.
Q Salida de Nbit igual al valor de la cuenta.
4.2. Comparador
COMPARADOR
Descripción Comparado síncrono. Las salidas O1, O2 y O3 cambiarán en los
flancos positivos de reloj7.
Entidad entity comparador is
Generic (Nbit: integer :=8;
End_Of_Screen: integer :=10;
Start_Of_Pulse: integer :=20;
End_Of_Pulse: integer := 30;
End_Of_Line: integer := 40);
data : in STD_LOGIC_VECTOR (Nbit-1 downto 0);
O1 : out STD_LOGIC;
O2 : out STD_LOGIC;
O3 : out STD_LOGIC);
end comparador;
clk Reloj
data Dato de entrada de Nbit
7 Se realiza el comparador síncrono para filtrar los posibles gitches. Es crítico que los pulsos de
sincronismo (HS y VS) estén limpios de glitches, pudiendo incluso dañar el monitor CRT.

O1 Cuando se produzca un flanco positivo de reloj:

O1=’1’ si data>End_Of_Screen
O1=’0’ en caso contrario
O2=’0’ si Start_Of_Pulse<data<End_Of_Pulse
O3=’1’ si data=End_Of_Line
4.3. Dibuja
DIBUJA
Descripción Bloque combinacional que generará, a partir de las coordenadas de
pantalla (eje_x y eje_y), las salidas de color necesarias (R,G y B) para
producir una imagen. Se deja la funcionalidad a la imaginación del
alumno8.
Entidad entity dibuja is
Port ( eje_x : in STD_LOGIC_VECTOR (9 downto 0);
eje_y : in STD_LOGIC_VECTOR (9 downto 0);
R : out STD_LOGIC;
G : out STD_LOGIC;
B : out STD_LOGIC);
end dibuja;
eje_x Coordenada horizontal del píxel. Sólo estarán dentro de la pantalla los
píxeles con coordenadas comprendidas entre 0 y 639.
eje_y Coordenada vertical del píxel. Sólo estarán dentro de la pantalla los
píxeles con coordenadas comprendidas entre 0 y 479.
R Salida de color rojo para el píxel
G Salida de color verde para el píxel
B Salida de color azul para el píxel
8 Se puede comenzar, por deferencia al profesor Jon Tombs, con el siguiente código:
process(eje_x, eje_y)
begin
G<='1'; B<='1'; R<='1';
if ((eje_x>279 and eje_x<359) or (eje_y>209 and eje_y<269)) then
R<='1';G<='0';B<='0';
end if;
end process;

4.4. Gen_color
DIBUJA
Descripción Bloque combinacional que asegura que el cañón de electrones esté
apagado cuando apunta fuera de la pantalla o está volviendo al
comienzo de otra línea.
Se puede diseñar:
a. Como un bloque independiente, con la entidad especificada a
continuación.
b. Como un process (con una sentencia if ) en el nivel de jerarquía
superior9.
Entidad entity gen_color is
Port ( blank_h : in STD_LOGIC;
(opción a) blank_v : in STD_LOGIC;
R_in : in STD_LOGIC;
G_in : in STD_LOGIC;
B_in : in STD_LOGIC;
R : out STD_LOGIC;
G : out STD_LOGIC;
B : out STD_LOGIC);
end gen_color;
Process gen_color:process(Blank_H, Blank_V, R_in, G_in, B_in)
begin
(opción b) if (Blank_H='1' or Blank_V='1') then
R<='0'; G<='0'; B<='0';
else
R<=R_in; G<=G_in; B<=B_in;
end if;
end process;
Blank_h Indicador de que está fuera de pantalla del comparador horizontal
Blank_v Indicador de que está fuera de pantalla del comparador vertical
R_in, G_in, Entradas de color procedentes del bloque DIBUJA
B_in
R, G, B Salidas de color del controlador VGA
9 Opción recomentada

4.5. Frec_pixel
FREC_PIXEL
Descripción Divide por dos la frecuencia de reloj, produciendo en su salida una
señal de 25MHz:
Se puede diseñar:
c. Como un bloque independiente, con la entidad especificada.
d. Como un process síncrono en el nivel de jerarquía superior10.
Entidad entity frec_pixel is
(opción a) reset : in STD_LOGIC;
clk_pixel : out STD_LOGIC);
end frec_pixel;
Proceso div_frec:process(clk,reset)
begin
(opción b) if (reset='1') then
clk_pixel<='0';
elsif (clk='1' and clk'event) then
clk_pixel<= not clk_pixel;
end if;
end process;
clk Reloj de entrada
Clk_pixel Señal generada de 25MHz
10 Opción recomendada

4.6. Nivel de jerarquía superior
VGA_DRIVER
Descripción Nivel de jearquía superior mostrado en la figura 10.
El valor de los generics para las diferentes instancias vale11:

a. Conth: Nbit=10.
b. Contv: Nbit=10.
c. Comph: Nbit=10, End_Of_Screen=639, Start_Of_Pulse=655,
End_Of_Pulse=751, End_Of_Line=799.
d. Compv: Nbit=10, End_Of_Screen=479, Start_Of_Pulse=489,
End_Of_Pulse=491, End_Of_Line=520.
Entidad entity VGA_driver is
VS : out STD_LOGIC;
HS : out STD_LOGIC;
R : out STD_LOGIC;
G : out STD_LOGIC;
B : out STD_LOGIC);
end VGA_driver;
clk Reloj de entrada
VS Sincronismo vertical
HS Sincronismo horizontal
R Rojo
G Verde
B Azul
11 El valor asignado a los generics se ha calculado a partir de los tiempos proporcionados en la

figura 9

Práctica 3. Transmisión por línea serie
Esta práctica es la tercera de un grupo de tres dedicada a entrenar al

alumno con el entorno de trabajo Xilinx ISE y la tarjeta Digilent S3.
Durante la práctica se diseñará un transmisor serie asíncrono que

utilizará la línea RS232 disponible en la tarjeta. Dicho transmisor
permitirá enviar datos ASCII almacenados en una memoria ROM desde

la FPGA hasta un PC a través de su puerto serie.
Los objetivos de la práctica son los siguientes:
3. Perfeccionar el entrenamiento con el entorno Xilinx ISE..
4. Aprender a diseñar utilizando máquinas de estado.
5. Aprender a generar dispositivos utilizando la herramienta “Core

Generator”.
Los objetivos didácticos propuestos en la práctica son los siguientes:
• Generación de una memoria ROM utilizando la herramienta Core Generator (o

“coregen”). En la memoria se almacenará un mensaje en ASCII.
• Diseño de una máquina de estado que extraiga los datos de la ROM y los
transmita a través del puerto serie
• Proveer de un mecanismo de transferencia de información entre la tarjeta y el
usuario para posibles aplicaciones en los proyectos.
2. Enlace Serie
Las principales características del enlace serie a diseñar serán:
• Comunicación asíncrona: El RS232 (Recommended Standard 232) es un

estándar de comunicación serie que define tanto comunicaciones síncronas
como asíncronas, aunque en esta práctica nos centraremos exclusivamente en la
comunicación asíncrona.
• Sólo diseñaremos el transmisor: Al definir líneas independientes para la
transmisión y recepción, el estándar RS232 permite una comunicación full
dúplex. En esta práctica sólo necesitaremos transmitir datos desde la FPGA al
ordenador.
• Transmitiremos los datos en ASCII: El estándar RS232 no define nada sobre la
codificación de los datos. Nosotros transmitiremos caracteres ASCII que serán
interpretados por el HyperTerminal de Windows para su representación en
pantalla.
• Características básicas de la transmisión: 8 bits de datos (ASCII), paridad par, 1
start, 1 de stop y velocidad de 9600 baudios. En la Figura 1 se presenta un
diagrama temporal de la transmisión de un byte tal como habría que realizarla
en la presente práctica. El objetivo de la práctica consistirá en generar una señal
como la de la Figura 1 con la temporización adecuada.

• La transmisión se realizará por el pin R13 de la FPGA: La conexión del puerto

serie con la FPGA se representa en la Figura 2. Se puede observar que el pin de
transmisión del conector DB9 (pin 2) está conectado a pin R13 de la FPGA a
través del circuito integrado MAX3232. Dicho circuito integrado realizará la
translación entre los 0-1.2V de tensión a la salida de la FPGA a los ±15V
requeridos por el estándar RS232.
Start B0 B7 Paridad Stop
Figura 1. Ejemplo de transmisión de un byte.
Figura 2. Conexión entre el puerto RS232 y la FGA
Para recibir los datos en el PC utilizaremos programa HyperTerminarl de Windows.

Dicho programa nos permitirá configurar el puerto COM1 con las características
básicas de la comunicación (9600 baudios, paridad pare, etc), interpretará los caracteres
ASCII y los mostrará por pantalla. Se realizará una explicación del HyperTerminal en
el apartado 3.3.
La práctica consta de tres apartados:

• En primer lugar generaremos la memoria ROM con el mensaje en ASCII que

pretendemos comunicar al PC.
• A continuación diseñaremos una máquina de estado que leerá los datos de la
ROM y los trasmitirá de forma serie por el pin R13. Uniremos la máquina de
estado con la memoria ROM mediante un bloque de jerarquía superior.
• Configuraremos el programa HyperTerminal para que utilice el mismo
protocolo serie que nuestro diseño.
a. Diseño de la memoria ROM utilizando CORE

Generator
Para implementar la memoria ROM empotrada en la FPGA utilizaremos la

herramienta CORE Generator. Esta herramienta permite utilizar primitivas específicas
de la FPGA que normalmente no son accesibles directamente desde código VHDL12,
como por ejemplo memorias empotradas, bloques DSP48, Digital Clock Managers
(DCMs), etc. Al utilizarla, nos generará un ‘core’, una caja negra que podremos
instanciar en nuestro diseño como si de un componente más se tratara.
Los cores generados por la herramienta están optimizados para FPGAs13 de

Xilinx, por lo que como diseñadores podremos confiar (hasta cierto punto14) en el
correcto funcionamiento de estos bloques.
Generación de nuestro primer core: Memoria de Bloque Empotrada
Si bien podemos arrancar CORE Generator de forma independiente, para esta práctica
nos servirá arrancarlo desde ISE. Seleccionamos Project -> New Source, y seleccionamos
la opción IP (Coregen & Architecture Wizard). Ver Figura 3.
12 Realmente muchas de las primitivas se pueden acceder directamente desde código VHDL,
pero su manejo es bastante más complicado (por ejemplo: describir unos registros de forma que
el sintetizador infiera una memoria empotrada)
13 Por esta razón es necesario especificar qué modelo de FPGA concreto estamos utilizando en
nuestro proyecto. Si se realiza a través del Coregen & Architecture Wizard, como se explica en
este apartado, se tomará por defecto la FPGA definida al crear el proyecto.
14 Ante la duda, se pueden consultar los datasheet de los cores, utilizando el botón View Data
Sheet que aparece en la esquina inferior izquierda de las ventanas del Wizard de CORE
Generator

Figura 3. Cómo arrancar el Coregen directamente desde ISE
En la pantalla de selección de IP seleccionamos la primitiva que queremos instanciar,

en nuestro caso una memoria de bloque o BlockRAM. El nombre “BlockRAM” significa
que toda la memoria se encuentra, implementada en silicio, en una zona dedicada de la
FPGA, a diferencia de las “Distributed RAM”, que utilizan los bits de memoria las
LUTs de distintos bloques lógicos repartidos por la FPGA (Figura 4).
Figura 4. Queremos generar una memoria del tipo Block Memory

Tras lo que nos aparece una pantalla de resumen de las opciones seleccionadas (Figura
5). Fijémonos en el ‘Source Name’ del fichero que nos va a generar. Si queremos
guardar únicamente los ficheros fuente de un proyecto que use cores, guardaremos,
además de los ficheros .vhd y .ucf, los ficheros .xco (Xilinx Core) correspondientes a los
cores generados y, en su caso, los ficheros de coeficientes .coe.
Figura 5. Resumen de las opciones seleccionadas en el asistente. Tras pulsar Finish se llamará a la
aplicación Coregen con estas opciones.
Al pulsar ‘Finish’ finalizará el asistente y arrancará propiamente la herramienta CORE

Generator. Como ya le hemos dicho qué primitiva queremos, directamente nos saldrá
el Generador de Memorias de Bloque, en el que seleccionaremos el tipo de memoria
que queremos (Memoria ROM de un solo puerto). Ver Figura 6.

Figura 6. Primer menú del Core Generator para la generación de una memoria Block Memory. Se
especifica el tipo de memoria.
Ya que queremos almacenar caracteres ASCII en la memoria, configuramos la misma

con una anchura de 8 bits. Seleccionamos una profundidad de 16 palabras (cada
palabra será del ancho que hayamos configurado). Ver Figura 7.

Figura 7. Segundo menú del Core Generator para la generación de Block Memory. Entre otras opciones
se configura el tamaño de la memoria.
Marcamos la opción Register Port A of Output Memory Primitives, esta opción nos
sintetizará un registro a la salida de la memoria, de forma que cuando se cambie el
valor del bus de direcciones (ADDRA), el nuevo dato (DOUTA) estará disponible al
siguiente ciclo de reloj (en este caso no tenemos señal Enable, la memoria siempre está
habilitada para lectura, ya que seleccionaremos la opción Always Enabled).
El último paso es utilizar un fichero .coe (Coefficients) para dar los valores iniciales a la
memoria (en este caso, tratándose de una ROM, es la única forma que tenemos de
introducir dichos valores en la misma). En la siguiente sección se detalla la sintaxis que
han de seguir los ficheros .coe. Marcamos también la opción Fill Remaining Memory
Locations, con el valor 0, para asegurarnos de que las posiciones de memoria que no
queden descritas por el fichero .coe se inicializen a cero.

Figura 8. Tercer menú del Core Generator para la generación de Block Memory. Se direcciona un
fichero .coe con los datos inciales de la memoria.
En la última pantalla (opciones de simulación) dejamos las opciones por defecto:

Figura 9. Cuarto menú del Core Generator para la generación de Block Memory.
Cuando pulsemos ‘Finish’ nos generará la IP. Es un proceso que tarda un poco, y por la
consola de ISE nos avisará cuando haya terminado, o si detecta algún error.
Sintaxis del fichero .coe
El fichero .coe es un fichero de texto plano, que contiene un vector con los valores que
se han de introducir en la memoria, y una variable ‘radix’ (que significa ‘base
numérica’ en inglés), que indica en qué base numérica debemos interpretar los datos15.
Un ejemplo de fichero .coe es el siguiente:

; Un punto y coma (semicolon) significa comentario
memory_initialization_radix = 16;
memory_initialization_vector =
<LISTA DE VALORES SEPARADOS POR ESPACIO> ;
15Recordemos que, por ejemplo, los dígitos “10”, según se interpreten en binario, decimal,
hexadecimal u octal, significan “dos”, “diez”, “dieciséis” u “ocho” respectivamente

Recordamos que radix 16 sería hexadecimal (base 16), radix 8 octal, radix 10 decimal…
Instanciación de la memoria y manejo de los puertos
Para poder utilizar la memoria que acabamos de generar, necesitaremos una definición
de componente, igual que para los componentes que tengamos definidos en VHDL.
¿De dónde obtenemos esta definición?
Una vez que coregen ha terminado de generar la memoria, si seleccionamos el nuevo

core en la ventana de procesos (lo reconoceremos porque tiene un icono diferente al de
los módulos VHDL), nos aparecerán tres procesos para realizar sobre el mismo:
♦ Manage Cores: Nos permite volver a configurar nuestro core, en caso de que nos
hayamos equivocado en algo o simplemente de que queramos cambiar su
configuración.
♦ Regenerate Core: Genera todos los ficheros intermedios del software de Xilinx a
partir del .xco original.
♦ View HDL functional model: Nos muestra el modelo HDL para simulación
funcional de la primitiva generada. Este modelo tiene una sección ENTITY que
podemos copiar para obtener la declaración de componente necesaria para
instanciarlo.
El manejo de la memoria es muy sencillo. Tiene dos entradas (ADDRA y CLK), y una
salida (DOUTA). Ya que no existe señal enable, y hemos puesto un registro a la salida
de la memoria, cuando cambie ADDRA obtendremos un dato nuevo en DOUTA al
siguiente flanco de reloj.
b. Realización de la práctica
El envío de los datos a través del puerto serie se va a controlar mediante una máquina
de estados16. Dicha máquina de estados pedirá el dato que necesita en cada momento a
través del puerto direcc y lo recibirá por el puerto data. Dichos puertos estarán
conectados a los puertos de la memoria en un nivel jerárquico superior.
Por otro lado, para implementar la comunicación síncrona de la Figura 1, Irá contando
el número de ciclos de reloj que hay que esperar para poder transmitir cada bit de
forma correcta respetando el protocolo. Para ello utilizará un contador interno que
deberá estar generado con sendas señales cont y p_cont del tipo std_logic_vector y el
ancho apropiado (dependerá de la tasa de transmisión). Para poder generar la
dirección correcta del dato a transmitir en cada momento también se usará un contador
16En el nivel de abstracción RTL que utiliza normalmente en VHDL una máquina de estado un
un bloque muy potente y versátil. Se recomienda la utilización de máquinas de estado en los
proyectos de los alumnos dentro de lo posible.

interno debidamente descrito con las señales dir y p_dir que se incrementará cada vez
que se transmite un byte completo.
A continuación se describe el comportamiento que debe tener la máquina de estados.

También se añade un diagrama de bolas para aclarar su funcionamiento. La máquina
dispone de un total de 14 estados aunque su funcionamiento es muy sencillo tal y
como se aprecia en el diagrama. Se han omitido los estados b_1, b_2, b_3, b_4, b_5 y b_6
por claridad aunque son equivalentes a los estados b_0 y b_7 sin más que cambiar el bit
que se envía en cada caso.
1. Reposo
Inicialmente (y si se produce un reset) partimos del estado de reposo. En dicho estado
tanto el contador interno como la dirección del dato a leer están a cero.
2. Inicio
Si se activa el puerto button17 pasamos al estado de inicio que simplemente consiste en
un ciclo de espera para que la memoria ponga el b a la salida. Por el tipo de memoria
implementada, una vez que se cambia la dirección a leer es necesario esperar al
siguiente ciclo de reloj para que el dato se cargue en el registro de salida que incorpora
la memoria y esté disponible para el usuario.
3. Test_data
Después pasamos al estado test_data donde el nuevo dato ya estará disponible para el
usuario. Si el nuevo dato es igual a 0x00 entonces ya hemos terminado de transmitir
toda la cadena de caracteres y volveríamos a reposo. Si el dato es distinto de cero
entonces pasamos al estado b_start donde se va a enviar el bit de start.
4. B_start
En este estado se pone la línea de transmisión a ‘0’ durante el tiempo que indica el
protocolo. Iremos incrementando el contador interno hasta que se alcance el valor
VAL_SAT_CONT. Cuando se cumpla esa condición reiniciaremos el contador interno y
pasaremos al siguiente estado b_0. Para reinicializar el contador basta con asignar ceros
al próximo valor del contador (el nuevo valor se hará efectivo en el siguiente flanco de
reloj y coincidirá con la transición de la máquina de estados al nuevo estado).
5. Bits de datos
En el estado b_0 se transmite el primer bit del dato a enviar. Se empieza por el menos
significativo. De nuevo esperamos a que el contador interno alcance el valor
VAL_SAT_CONT. Cuando se produzca esa condición se reinicia el contador para
empezar la cuenta desde cero en el siguiente bit.
En los sucesivos estados b_1,…,b_7 se irán transmitiendo cada uno de los bits del dato
a enviar. En todos los casos se espera hasta que el contador alcance el valor de
VAL_SAT_CONT.
6. B_paridad
Después de transmitir todos los bits del dato se manda un bit de paridad para
comprobar que no ha habido errores en la comunicación. Dicho bit se genera de forma
combinacional en este estado con puertas xor. De nuevo esperamos el tiempo
correspondiente a un bit.
7. B_stop
17 Cuando pulsamos el botón correspondiente.

Por último enviamos el bit de stop. La línea de transmisión se vuelve a poner a ‘1’
durante un tiempo de bit. Cuando se cumpla el tiempo de bit se resetea el contador
interno y se incrementa la dirección del siguiente dato a leer. Pasamos al estado inicio
para esperar a que el nuevo dato esté disponible.
De nuevo en el estado test_data volvemos a comprobar si el nuevo dato es distinto de

cero para transmitirlo. Cuando todos los datos previstos hayan sido enviados leeremos
un cero de la memoria y pasaremos al estado de reposo a esperar a que se vuelva a
activar la señal button.
En la Figura 10 aparece representado el diagrama de bolas de la máquina de estados.

Se han indicado únicamente las transiciones entre los distintos estados y las
asignaciones que hay que realizar en algunas de ellas. Cuando no se cumpla alguna de
las condiciones que permiten cambiar de estado se entiende que dicho estado no
cambia. En aquellos estados en los que no se especifica ningún valor para la señales
p_cont o p_dir se entiende que conservarán su valor previo.

Figura 10. Diagrama de bolas de la máquina de estados que controla la transmisión.

FSM
Descripción Circuito de control del proceso de transmisión.
Entidad entity fsm is
Generic (ancho_bus_dir:integer:=4;
VAL_SAT_CONT:integer:=20000;
ANCHO_CONTADOR:integer:=20);

rst : in STD_LOGIC;
button : in STD_LOGIC;
data : in std_logic_vector(7 downto 0);
direcc : out std_logic_vector(ancho_bus_dir-1
downto 0);
TX : out STD_LOGIC);
end fsm;
Descripción de los generics
ancho_bus_dir
Indica el ancho del bus de direcciones de la memoria de la
que se van a leer los datos.
VAL_SAT_CONT Valor en el que el contador alcanza un número de ciclos de
reloj equivalente al tiempo que debe durar la trasmisión de
un bit. Dependerá de la velocidad de transmisión.
ANCHO_CONTADOR Número de líneas del contador que calcula el tiempo de bit.
Debe ser suficiente para poder alcanzar el valor especificado
en VAL_SAT_CONT.
clk Reloj de 50MHz.
rst Reset asíncrono activo a nivel alto.
button Pulso externo que inicia la transmisión de los datos.
data Bus de datos de la memoria que contiene los datos a
transmitir.
direcc Bus de direcciones de la memoria que contiene los datos a
transmitir.
TX Pin de transmisión que va al conector DB9.
Integración de los distintos componentes

El bloque de más alto nivel jerárquico debe contener como componentes la máquina de
estados y la memoria. Habrá que definir todas las señales que sean necesarias para
conectar estos bloques. Simplemente hay que instanciar cada componente y especificar
los valores correctos a los generics. Para una tasa de transmisión de 9600 baudios los
valores correctos de las constantes aparecen detallados en la siguiente tabla. En la
Figura 11 aparece representado el esquema de conexionado y los puertos externos.
GENERICS PARA 9600 BAUDIOS

VAL_SAT_CONT 5208
ANCHO_CONTADOR 13

PRACTICA_3
MSG_ROM FSM
DATA[7:0]
MEMORIA MÁQUINA DE TX
ROM ESTADOS
DIRECC[3:0]
CLK
RST
BUTTON
Figura 11. Esquema de conexionado completo y puertos externos.
Conexionado de pines de E/S.
EL fichero “USER CONSTRAINTS FILE” debe contener la siguiente información:
NET "clk" LOC = "T9";

NET "rst" LOC = "L14";
NET "TX" LOC = "R13";
NET "button" LOC = "L13";
c. Configuración del Hyperterminal.
HyperTerminal es una aplicación de Windows que permite realizar operaciones de

comunicación por diferentes canales, y en particular por el puerto serie, identificado
como COM1:. Se encuentra en Inicio -> Programas -> Accesorios -> Comunicaciones ->
Hyperterminal. Aparecerá la ventana mostrada en la Figura 12.
Figura 12. Interfaz básico del HyperTerminal de Windows

Con el programa desconectado (icono del teléfono descolgado), Archivo->Propiedades
Figura 13. Propiedades de comunicación serie.
Debe aparecer conectar usando COM1. Aquí presionar el botón ·”Configurar”. Aquí
debe aparecer la configuración de la velocidad del puerto serie:
Figura 14. Configuración del puerto serie.
La Figura 14 muestra la configuración del puerto serie para realizar esta práctica. Una
vez configurado la información que se escriba desde teclado en la consola del
hyperterminal se transfiere automáticamente al puerto serie, y la información recibida
será escrita en la consola. Los caracteres escritos no aparecen en la configuración por
defecto de la consola.

Práctica 4. PRÁCTICA DE SISTEMAS EMBEBIDOS USANDO EDK
Esta práctica está dedicada a mostrar metodologías de uso de

procesadores embebidos
Se incide en el concepto de Microprocesador “Soft Core” y las

herramientas de uso que el fabricante Xilinx provee para el desarrollo
de aplicaciones se muestra en detalle para comprender la nueva
metodología hardware/ software.

1. Introducción
Esta práctica pretende introducir al alumno en el diseño de sistemas embebidos
utilizando el sistema de desarrollo EDK del fabricante Xilinx.
Para ello se va a utilizar como plataforma hardware la tarjeta XS3 de Digilent que
incluye una FPGA Spartan 3 de Xilinx de 200.000 puertas equivalentes. Esta capacidad
es más que suficiente para implementar tanto un microprocesador softcore como otros
periféricos que requiera el usuario.
En este caso se va a utilizar el sistema EDK (Embeded Design Kit) para implementar el
microprocesador MicroBlaze de Xilinx. Se trata de un microprocesador de 32 bits que
se puede implementar en muchas familias de FPGAs de Xilinx. La descripción del
microprocesador incluida en el EDK es del tipo post síntesis pero previa a la
implementación de forma que no es posible acceder al código VHDL que describe el
comportamiento del microprocesador aunque esto no es necesario para poder
utilizarlo.
Aunque existen diferentes formas de diseñar un sistema embebido con el software de
Xilinx vamos a utilizar las dos más habituales.
En la primera parte de la práctica se va a implementar únicamente el MicroBlaze en la
FPGA por lo que solamente será necesario utilizar el EDK. En esta parte se le añadirán
al micro periféricos hardware de librería para poder utilizar todos los componentes de
la placa. En concreto, se usará el puerto RS232 como entrada y salida estándar del
programa que se esté ejecutando en el MicroBlaze. Este caso consiste en realizar el
¡Hola Mundo! en la FPGA.
En la segunda parte se integrará el MicroBlaze como un componente más en la
estructura jerárquica de un proyecto ISE. En este caso estará implementado en la FPGA
junto con otros periféricos VHDL definidos por el usuario. En esta parte de la práctica
se pretende que el alumno realice un sistema embebido más completo y que sirva de
ejemplo de un sistema real. Partiendo de este sistema básico debería ser posible
fácilmente añadir más periféricos hasta conseguir un sistema que se adapte a los
requerimientos de una aplicación concreta.
2. Primera Parte
Comenzaremos arrancando la aplicación principal del EDK, el Xilinx Platform Studio.
Lo podemos encontrar en el menú del EDK dentro del software de Xilinx.
A continuación nos aparece la ventana de la Figura 1 donde el software nos ofrece tres
alternativas:
• Utilizar el asistente para crear un nuevo proyecto desde cero.
• Crear un nuevo proyecto en blanco.
• Abrir un proyecto previo.

Figura 1 Menú de selección al crear un nuevo proyecto.
Si esta ventana no aparece seleccionar New Project en el menú File.

Elegimos la primera que consiste en crear un nuevo proyecto guiados por un Wizard.
A continuación el software nos pide el nombre y la ruta del nuevo proyecto (ver Fig. 2).
Figura 2 Título del nuevo proyecto.
Elegir un nombre para el proyecto (incluyendo la extensión .xmp) y la ruta en la que se

quiere que se guarde.
A continuación el software nos ofrece crear un nuevo diseño (opción por defecto) o
continuar cargando la configuración de un diseño previo18 (segunda opción).
Seleccionamos la opción por defecto.
18Es posible almacenar la configuración de un diseño en un archivo con extensión .bsb. Esto
permite configurar rápidamente un diseño partiendo de la configuración de otro previo.

Figura 3 Ventana de selección para crear un nuevo diseño o cargar la configuración de uno
previo.
A continuación nos aparece una nueva ventana en la que poder seleccionar si vamos a
crear un proyecto para una placa conocida19 o para una placa a medida. Configurar las
distintas opciones tal y como aparece detallado en la Figura XXX. En el campo Board
Description puede apreciarse cómo el software ha identificado la placa y nos describe
todos los componentes que incluye.
19 Muchos fabricantes de placas de desarrollo crean los archivos donde se describen las
restricciones de pineado de la FPGA que incluyen y la de los periféricos que incorpora la placa.
Este archivo puede añadirse al EDK para que el Wizard nos configure automáticamente el
proyecto adaptándose a nuestra placa en concreto.

Figura 4 Selección de una tarjeta conocida cuyas características están incluidas en el EDK.
A continuación nos muestra la FPGA que incluye la placa y el tipo de microprocesador

que se va a utilizar. En esta familia no está disponible el PowerPC por lo que
únicamente se puede usar el MicroBlaze. En el campo Processor Desciption aparece una
breve descripción del microprocesador que se ha elegido, en este caso el MicroBlaze.

Figura 5 Selección del tipo de microprocesador a utilizar. En la familia Spartan 3 solamente

se puede utilizar el MicroBlaze.
En la siguiente ventana el software nos ofrece la posibilidad de configurar algunas

cosas del microprocesador como la frecuencia de reloj, si se desea incluir una FPU
(unidad de punto flotante) que se encuentra desactivada por defecto, si se desea incluir
un depurador y el tamaño de la memoria local del microprocesador. Esta memoria va a
estar integrada dentro de la propia FPGA y será utilizada tanto para datos como para
instrucciones. En esta FPGA únicamente podemos seleccionar tamaños de 8, 16, 32 y 64
KB que serán implementados utilizando bloques de RAM interna (BRAM). En este caso
tan simple basta con utilizar 8KB20.
A continuación (Figura 6) se nos muestra la descripción de algunos de los periféricos
de librería que el Wizard ha añadido al proyecto para poder controlar todo el hardware
que incluye la placa. Podemos desactivar algunos de ellos si no fueran necesarios o
20 Si las aplicaciones de usuario necesitaran más de 64KB, entonces es posible utilizar memorias
externas como memoria del sistema aunque siempre es necesario implementar una memoria
local mínima de 8KB dentro de la FPGA. Si se desea utilizar memoria RAM externa como
memoria principal entonces es posible almacenar en la memoria local de la FPGA un programa
(llamado bootloader) que lee desde una memoria externa no volátil el contenido inicial de la
memoria y lo copia a la memoria RAM externa antes de que empiece ningún procesado.
Después de copiar todo el programa a la RAM salta a la primera instrucción de dicho programa
y comienza la ejecución normal del mismo.

cambiar el periférico que va a controlar el hardware en cada caso. Por ejemplo, en el

caso del puerto serie se puede seleccionar entre el XPS UARTLITE (opción por defecto)
y el XPS UART 16550. Algunos periféricos admiten modo de trabajo por interrupciones
que aparece desactivado por defecto. En este ejemplo no va a ser necesario utilizarlas
para controlar el hardware. En esta figura puede verse la configuración por defecto del
puerto serie. Esta configuración puede modificarse por software en tiempo de
ejecución.
También es posible consultar el Data Sheet del periférico de librería que tengamos
seleccionado en cada caso donde viene descrito su funcionamiento. Dejamos todas las
opciones por defecto y pasamos a la siguiente ventana donde vienen descritos dos
periféricos más.
Figura 6 Lista de periféricos hardware de librería incluidos en el diseño por defecto para
poder controlar el hardware que incorpora la placa XS3 de Digilent.

Figura 7 Periféricos restantes incluidos en la placa XS3.
Por último es posible añadir más periféricos como temporizadores o controladores de

otras memorias externas.

Figura 8 Ventana final donde se pueden añadir más periféricos.
Figura 9 Detalle de la lista de periféricos que se pueden añadir.
La siguiente ventana nos permite configurar la entrada y salida estándar y la memoria

desde la que se quiere que arranque el micro. Por defecto se encuentra seleccionada la
ilmb_controller que corresponde a la memoria interna de la FPGA. Dejamos de nuevo
todas las opciones por defecto.
Más abajo aparecen activadas por defecto dos aplicaciones demo que se generan de
forma automática. La primera permite testar la memoria y la segunda los periféricos.
Dejamos las opciones activas por defecto para que nos genere dichas aplicaciones.

Figura 10 Direccionamiento de la entrada y salida estándar y memoria de arranque de los

programas.
A continuación nos pide que le indiquemos dónde van a ir ubicadas las distintas partes
de cada uno de los programas que nos va a generar automáticamente. Por un lado está
la parte dedicada a las instrucciones que componen el programa, en segundo lugar los
datos y variables, y en tercer lugar la pila (Stack) y la reserva dinámica de memoria
(Heap). Por defecto y para el programa de test de memoria está seleccionada la
memoria interna de la FPGA para las tres partes. Dejamos activa dicha opción ya que
la memoria interna es suficiente para almacenar las tres partes del programa.

Figura 11 Ubicación de las distintas partes del programa de test de memoria.
En la aplicación del testado de periféricos aparece seleccionada por defecto la memoria

SRAM externa para las tres partes del programa. Lo dejamos así porque luego la
cambiaremos cuando vayamos a ejecutar dicho programa.

Figura 12 El wizard nos propone por defecto ubicar todas las partes del programa de test de
periféricos en la RAM externa.
Por último el software nos muestra un resumen con el rango de direcciones asignado a
cada uno de los periféricos detallando el tipo de bus al que está conectado cada uno.
Hacemos Lclik en generate y nos aparece un resumen de todos los archivos generados y
la opción activada de generar un archivo .bsb con todas las selecciones realizadas en el
Wizard para que pueda ser utilizada en proyectos futuros.

Figura 13 Resumen del rango de direcciones asignado por defecto a todos los periféricos
incluidos en el proyecto.

Figura 14 Detalle final de todos los archivos generados por el wizard.
Pulsamos Finish para terminar con el wizard y nos aparece la ventana normal de
trabajo del EDK que debe tener un aspecto similar al que se ilustra en la Figura 15.

Figura 15 Ventana de trabajo normal del EDK.
Con las distintas pestañas podemos ver todos los archivos que contiene el proyecto
(Figura 15), el conjunto de aplicaciones que tengamos definidas en ese momento
(Figura 16) o la lista de periféricos de librería disponibles que podemos añadir a
nuestro proyecto (Figura 17).
Figura 16 Aplicaciones generadas por el wizard. Por defecto está activa la del test de
memoria.

Figura 17 Lista de periféricos de librería disponibles para el usuario.
Se puede consultar (y modificar si se desea) el código fuente de los programas que se

han generado tal y como aparece reflejado en la Figura 18.
Figura 18 Detalle del código fuente del programa que testa la memoria generado
asmáticamente por el EDK.
Una vez llegado este punto podemos hacer varias cosas. Podemos implementar el
hardware que hemos configurado en el menú Hardware con la opción Generate Netlist.
Luego podremos rellenar los bloques internos de memoria de la FPGA con el programa
compilado que queramos. También podemos compilar el código fuente de las
aplicaciones que nos ha generado automáticamente el wizard. Esto puede hacerse con
la opción Build All users applications del menú Software (Figura 19) ó haciendo Rclick en
cada aplicación y luego seleccionando Build Project (Figura 20). También podemos
hacerlo todo directamente seleccionando la opción Update Bitstream del menú Device
Configuration como aparece detallado en la Figura 21. Esto realizará primero la
implementación para esa FPGA de todo el hardware incluyendo el MicroBlaze y todos
los periféricos que hayamos incluido. Luego realizará la compilación del código que se

va a incluir en la memoria interna de la FPGA, en este caso el test de memoria. Por

último actualiza el archivo de programación
Figura 19 Opción para compilar todas las aplicaciones de usuario del menú Software.
Figura 20 Opción para compilar una aplicación concreta haciendo Rclick sobre ella.
Figura 21 Opción que actualiza el bitstream con el ejecutable de la aplicación que se haya
especificado para la memoria interna de la FPGA.
Una vez generado el bitstream se puede programar la FPGA usando el IMPACT al

igual que cuando se genera un diseño con el ISE. Para poder recibir los datos por el
puerto serie (que hemos configurado como entrada y salida estándar) se puede utilizar
el hyperterminal de Windows. Es necesario configurarlo del mismo modo que el
periférico que hemos añadido al MicroBlaze (Figura 6). Una vez ejecutado el programa
debemos ver una ventana parecida a la que aparece reflejada en la Figura 22.
FFFFFFFFFFFFFFFFFFFffff
Añadir captura hiperterminal.
Figura 22 Captura del hyperterminal una vez ejecutado el programa de testado de memoria.

FFFFFFFFFFFFFFFFFFFffff
Vamos a crear ahora un nuevo programa para nuestro proyecto. Para crear una nueva
aplicación software seleccionamos la opción Add Software Application Project del menú
Software (Figura 23).
Figura 23 Opción para añadir nuevas aplicaciones software al proyecto.
También es posible añadir nuevas programas a nuestro proyecto usando el acceso

directo que se encuentra en la pestaña Applications.
Figura 24 Acceso directo de la pestaña Applications para añadir nuevos programas al

proyecto.
Después de elegir el nombre del programa podemos añadir archivos con el código
fuente a ejecutar (ya sea un archivo nuevo o creado externamente) haciendo Rclik sobre
la sección Sources de nuestro nuevo programa (Figura 25).

Figura 25 Añadir nuevos archivos fuente a un programa.
Elegimos el nombre del nuevo archivo fuente y una vez creado lo abrimos para escribir
el código a ejecutar. Para crear el “Hola Mundo” basta con el siguiente código.
#include <stdio.h>
Main{
}
Una vez compilado el código podemos actualizar el bitstream (archivo .bit) con dicho
código compilado. Usamos la opción descrita en la Figura 21.
Una vez programada la FPGA debemos observar en el hyperterminal un texto similar
al que aparecen en la XXXXXXXXXXXX. De nuevo el puerto serie del hyperterminal
debe estar configurado de la misma forma que el del periférico hardware (Figura 6).
3. Segunda Parte
En esta segunda parte de la práctica vamos a implementar el MicroBlaze junto con un
contador desde el ISE. Se va a utilizar el hyperterminal de Windows para modificar la
velocidad del contador (el paso de cada cuenta). Para ello vamos a conectar el puerto
RS232 de la placa al MicroBlaze y éste al módulo top descrito en VHDL. El MicroBlaze
va a controlar el puerto serie y mediante un protocolo muy sencillo va a ir
incrementando o decrementando un valor que va a poner en un puerto de salida. Este
puerto de salida se va a leer desde el módulo top y su contenido se va a interpretar
como el paso del contador.
Este ejemplo tan sencillo permite ilustrar cómo es posible integrar un microprocesador
en un desarrollo hardware y utilizarlo
Vamos a iniciar un nuevo proyecto en el ISE como siempre y a la hora de añadir
componentes vamos a elegir un VHDL Module llamado top.vhd. Será el top que
contendrá al microprocesador. Los puertos que debe contener el top aparecen
detallados en la .

Figura 26 Selección de un microprocesador empotrado en un diseño ISE.
Añadimos primero
Añadimos ahora un nuevo archivo fuente del tipo Implementation Constraints File
llamado top.ucf. Será el archivo que contenga las restricciones de pineado.
Añadimos un nuevo archivo fuente y seleccionamos ahora la última opción de la lista:

Embedded Processor (Figura 26).

Automáticamente nos arrancará el EDK y podremos configurar el micro siguiendo los

mismos pasos descritos en la primera parte de la práctica. En esta ocasión el asistente
no nos va a añadir por defecto ningún periférico y tendremos que elegirlos nosotros.
Necesitaremos un puerto serie RS232 y un bloque general de entrada/salida (GPIO)
como se aprecia en la XXXX.
Una vez configurado el micro pulsamos Generate y el software nos informa de que en el
ISE se podrá consultar un archivo que contiene las restricciones de pines para la placa
seleccionada.

Pulsamos Finish para que el EDK termine de generar el hardware. Creamos una nueva
aplicación software que incluya el código que queremos ejecutar. El código fuente del
programa a ejecutar aparece detallado a continuación.
XXXXXXXXXXXXXXXX Incluir código XXXXXXXXXXXXXXXXXx
#define GPIO_DIR_BASE
#define G_DATA_OUT_R 2
main(int i){
char aux;
int cuenta=0;
unsigned int *ip=0;
while (1){
aux=getc();
if (aux==”+”){
cuenta=2*cuenta;
if (cuenta>=10000) cuenta=10000;
}
else if (aux==”-“){
if (cuenta<=100) cuenta=100;
}
ip[GPIO_DIR_BASE + G_DATA_OUT_R]=cuenta;
}
Return 0;
}
Le damos a salvar proyecto y ya podemos cerrar el EDK para continuar desde el ISE.
De nuevo en el ISE vamos a crear un archivo VHDL Module llamado top que va a
incluir el MicroBlaze como componente. Creamos también un archivo de restricciones
Implementation Constraints File asociado al top. El top va a contener los siguientes
puertos:
XXXXXXXXXXXXXx
Para poder instanciar el MicroBlaze como componente podemos usar una plantilla que
nos genera automáticamente el ISE donde se incluyen todos los periféricos que le
hayamos añadido al micro en el EDK ().
XXXXXXXXXXX Figura de vista del Template XXXXXXXXXXXXXXXx
De esta forma podemos copiar y pegar directamente (tal y como nos indican) el código
de la plantilla en el top para declarar e instanciar el MicroBlaze.
Únicamente nos falta completar el código del módulo top y del ucf. El pineado exacto
de los periféricos que incluye la placa puede encontrarse en la hoja de datos (data
sheet) de la misma aunque también puede consultarse en el archivo ucf generado por
el asistente en el proyecto de la primera parte de la práctica. A continuación aparecen
unos posibles códigos que permiten generar el diseño que se desea conseguir.
XXXXXXXXXXXXX Códigos XXXXXXXXXXXXXXXx
Únicamente nos falta completar la implementación y programar la FPGA. Una vez
hecho esto debemos observar en el hyperterminal un comportamiento parecido al que
aparece reflejado en la ().


CuadernoLabMic PDF

Cargado por

Información del documento

Título original

Derechos de autor

Formatos disponibles

Compartir este documento

Compartir o incrustar documentos

Opciones para compartir

¿Le pareció útil este documento?

¿Este contenido es inapropiado?

Copyright:

Formatos disponibles

CuadernoLabMic PDF

Cargado por

Copyright:

Formatos disponibles

Universidad de Sevilla

Departamento de Ingeniería Electrónica

Dr. Miguel Ángel Aguirre Echánove

1 Universidad de Sevilla. 2010

2 Universidad de Sevilla. 2010

Práctica 1. Control del Display de 7 segmentos

Este práctica es la primera de un grupo de tres dedicada a entrenar al

Se diseñarán una serie de contadores síncronos que permitirán controlar

1. Aprender las opciones básicas de simulación e implementación del

2. Aprender a utilizar la hoja de características de la tarjeta S3 para

3 Universidad de Sevilla. 2010

La tarjeta Digilent S3 de Xilinx es una placa de desarrollo para la FPGA de Xilinx

El objetivo es convertir el display en un contador que se incremente a una

2.1. Display de 7 segmentos y cuatro dígitos

Los cuatro displays de 7 segmentos están situados en la parte inferior derecha de la

4 Universidad de Sevilla. 2010

Figura 1. Diagrama de bloques de la tarjeta S3

• Se activan (valor lógico ‘0’) las entradas A, B, E, D y G. Se dejan desactivadas

Figura 2. Control de los displays de 7 segmentos

5 Universidad de Sevilla. 2010

Es muy sencillo deducir (tabla 1) el código de entrada necesario para

Un aspecto muy importante a la hora de implementar un diseño es selección de

En tabla 2 se especifica cómo está conectada la FPGA y los displays de 7

Tabla 1. Códigos necesarios para la representación de caracteres

6 Universidad de Sevilla. 2010

Figura 3. Utilización de los 4 dígitos simultáneamente

Las señales de habilitación de los displays (AN0-3) servirán para multiplexar

7 Universidad de Sevilla. 2010

2.2. Señal de reloj

La tarjeta S3 dispone de un reloj de 50MHz (Epson SG-8002JF) y de un zócalo para

2.3. Pulsadores y reset asíncrono

Tabla 3. Puertos asociados a los pulsadores

Utilizaremos como reset asíncrono activo a nivel alto el pulsador BTN3

8 Universidad de Sevilla. 2010

sat enable cuenta 4

1) DIV_FREC: Un contador de 26 bits para dividir la frecuencia de reloj a

Los bloques sombreados de la figura 4 (multiplexor y puertas AND) se

9 Universidad de Sevilla. 2010

3.1. Divisor de frecuencia

3.3. Registro de desplazamiento

3 Con objetivo de definir correctamente la interfaz del bloque se proporciona la entidad. El

10 Universidad de Sevilla. 2010

3.4. Decodificador de binario a 7 segmentos

3.5. Bloque de jerarquía superior

11 Universidad de Sevilla. 2010

12 Universidad de Sevilla. 2010

Práctica 2. Control de un monitor VGA

La tarjeta S3 dispone de un conector VGA cableado a la FPGA.

El objetivo de la práctica consiste en:

1. Diseñar un driver VGA que permita representar imágenes con un

2. Ver un caso práctico de la utilización de GENERICS.

Esta práctica es la segunda de un grupo de tres dedicada a entrenar al

13 Universidad de Sevilla. 2010

En la presente práctica conectaremos directamente la FPGA a un monitor

Para conseguir nuestro objetivo necesitaremos diseñar:

Figura 5. Objetivo de la práctica

2. Conexión VGA en la Tarjeta S3 de

14 Universidad de Sevilla. 2010

La tarjeta S3 dispone de un conector DB15 cableado a puertos de la FPGA. Dicho

Se utilizarán cinco puertos: HS (sincronismo horizontal), VS (sincronismo vertical),

Figura 6. Conexión entre la FPGA y el conector VGA

Teóricamente, Las señales de color (R, G y B) son analógicas y determinan la

3. Monitor VGA en modo 640x480