Você está na página 1de 38

Grado en ingeniera de Computadores

Grado en Ingeniera de Software


Universidad de Extremadura

ESTRUCTURA DE COMPUTADORES
Curso 2013/2014

Prctica 1:
Modelacin,
simulacin e
implementacin
del procesador
MIPS

Julio Ballesteros Rubio, Juan Antonio Gmez-Pulido


Departamento de Tecnologa de Computadores y Comunicaciones
Universidad de Extremadura
(c) 2014
Version: 14/febrero/2014

Prctica 1:Modelacin, simulacin e implementacin del procesador MIPS

ndice.
Planificacin de la prctica. ................................................................................................................................. 3
1.1.
Sesin 1: Proyecto ISE, diseo VHDL y simulacin. .................................................................................. 3
1.2.
Sesin 2: Simulacin de componentes del procesador................................................................................. 3
1.3.
Sesin 3: Simulacin de las memorias de datos e instrucciones. ................................................................. 3
1.4.
Sesin 4: Descripcin y simulacin del procesador. .................................................................................... 3
1.5.
Sesin 5: Descripcin, simulacin y prueba del sistema final. .................................................................... 3
2.
Introduccin. ........................................................................................................................................................ 5
3.
Sesin 1: Proyecto ISE, diseo VHDL y simulacin. .......................................................................................... 7
3.1.
Consideraciones iniciales ............................................................................................................................. 7
3.2.
Planteamiento del circuito decodificador ..................................................................................................... 7
3.2.1.
Mdulo "dec2a4" ................................................................................................................................ 8
3.2.2.
Mdulo "mux4a1_4bits" ..................................................................................................................... 8
3.2.3.
Mdulo "hex2led" ............................................................................................................................... 8
3.3.
Creacin del proyecto .................................................................................................................................. 9
3.4.
Diseo del mdulo "Seldigit_CodLEDS" .................................................................................................. 10
3.4.1.
Diseo de los mdulos VHDL .......................................................................................................... 10
3.4.2.
Conectando los mdulos mediante VHDL........................................................................................ 12
3.5.
Simulacin del mdulo "Seldigit_CodLEDS" ........................................................................................... 13
4.
Sesin 2: Simulacin de componentes del procesador. ..................................................................................... 17
5.
Sesin 3: Simulacin de las memorias de datos e instrucciones. ....................................................................... 19
5.1.
Memoria de instrucciones. ......................................................................................................................... 19
5.1.1.
Modelo. ............................................................................................................................................. 19
5.1.2.
Simulacin. ....................................................................................................................................... 20
5.2.
Memoria de datos. ..................................................................................................................................... 21
5.2.1.
Modelo. ............................................................................................................................................. 21
5.2.2.
Simulacin. ....................................................................................................................................... 21
6.
Sesin 4: Descripcin y simulacin del procesador........................................................................................... 23
6.1.
Desarrollo. ................................................................................................................................................. 23
6.2.
Componentes del procesador. .................................................................................................................... 23
6.3.
Descripcin VHDL del procesador. ........................................................................................................... 23
6.4.
Simulacin. ................................................................................................................................................ 25
7.
Sesin 5: Descripcin, simulacin y prueba del sistema final. .......................................................................... 27
7.1.
Interfaz del procesador............................................................................................................................... 27
7.1.1.
Descripcin VHDL. .......................................................................................................................... 27
7.2.
Simulacin. ................................................................................................................................................ 28
7.3.
Implementacin hardware del circuito. ...................................................................................................... 28
7.3.1.
Asignacin de pines de la FPGA en la descripcin VHDL. .............................................................. 28
7.3.2.
Sntesis e implementacin. ................................................................................................................ 30
7.4.
Prueba del procesador en la tarjeta de prototipado. ................................................................................... 30
8.
Apndice: Instalacin de Xilinx ISE.................................................................................................................. 31
8.1.
Introduccin ............................................................................................................................................... 31
8.2.
Descarga del software y registro en Xilinx ................................................................................................ 31
8.3.
Instalacin .................................................................................................................................................. 32
9.
Apndice: Errores frecuentes y consideraciones generales en ISE. ................................................................... 35
9.1.
Errores en el diseo del proyecto: .............................................................................................................. 35
9.2.
Errores durante la sntesis e implementacin. ............................................................................................ 35
10. Apndice: Tarjetas Nexys / Nexys2. .................................................................................................................. 37
10.1. Manuales. ................................................................................................................................................... 37
10.2. Comprobaciones iniciales. ......................................................................................................................... 37
10.3. Configuracin de la FPGA. ....................................................................................................................... 37
10.4. FPGAs. ...................................................................................................................................................... 38
10.5. Pines de la tarjeta. ...................................................................................................................................... 38
10.5.1. Nexys. ............................................................................................................................................... 38
10.5.2. Nexys2. ............................................................................................................................................. 38
10.5.3. Seleccin del reloj en la tarjeta Nexys. ............................................................................................. 38
1.

Planificacin de la prctica.

1. Planificacin de la prctica.
La prctica consta de 5 sesiones, una cada semana. Cada sesin dura dos horas.

1.1. Sesin 1: Proyecto ISE, diseo VHDL y simulacin.

En esta sesin se comenzar creando un proyecto de diseo con la herramienta Xilinx ISE.

Se aprender a modelar circuitos en VHDL y a simularlos mediante testbenches. Para ello, trabajaremos con el
componente del interfaz del procesador "Seldigit_CodLEDS.vhd".

1.2. Sesin 2: Simulacin de componentes del procesador.

Simular los componentes del procesador "ALU16bits.vhd" y "registro_PC.vhd".

Se suministran los cdigos VHDL completos de estos componentes.

El alumno crear los archivos de simulacin testbench correspondientes a estos dos componentes, y realizar la
simulacin comprobando los resultados.

1.3. Sesin 3: Simulacin de las memorias de datos e instrucciones.

Simulacin de los componentes del procesador "Mem_Ia_256x8.vhd" y "ram_datos.vhd".

Se suministran los cdigos VHDL completos de estos componentes.

El alumno crear el archivo de simulacin testbench correspondiente al componente "Mem_Ia_256x8.vhd", y


recibir del profesor el testbench completo correspondiente al componente "ram_datos.vhd".

1.4. Sesin 4: Descripcin y simulacin del procesador.

El alumno realizar una descripcin VHDL estructural del procesador, utilizando todos los componentes, a
partir de un modelo incompleto suministrado por el profesor.

Despus el alumno crear el testbench correspondiente y lo simular para comprobar su funcionamiento.

1.5. Sesin 5: Descripcin, simulacin y prueba del sistema final.

El alumno realizar una descripcin VHDL del sistema final, consistente en el procesador ms el interfaz y los
acondicionadores de la seal de reloj.

Despus, realizar una simulacin de este sistema a partir del testbench suministrado por el profesor.

Finalmente, implementar en hardware el sistema, comprobando su funcionamiento en la tarjeta de prototipado


Nexys.

Prctica 1:Modelacin, simulacin e implementacin del procesador MIPS

Introduccin.

2. Introduccin.
En esta prctica se disear una aproximacin al procesador MIPS, con todos los elementos necesarios para su
prototipado en hardware. Segn se puede observar en la siguiente figura, el procesador MIPS requiere de dos
elementos adicionales (acondicionamiento de la seal de reloj e interfaz con la tarjeta de prototipado) para su
implementacin. Cada uno de los elementos del sistema est descrito por un archivo VHDL, el cual necesitar, a su
vez, de otros archivos VHDL con los componentes que lo forman, y que se listan a continuacin.
seal de reloj

entradas
Sistema
final

Acondicionamiento de la seal de reloj


Son dos archivos de componentes

Procesador MIPS
Archivo Mips_Nucleo1.vhd
Est formado por 10 archivos de componentes

Interfaz con la tarjeta de prototipado


Archivo Seldigit_CodLEDS.vhd
Est formado por 3 archivos de componentes

salidas

Procesador
Mips_Nucleo1.vhd
Componentes:
ALU16bits.vhd
ALUcontrol_0.vhd
BReg_3port_lec.vhd
Mem_Ia_256x8.vhd
mux2A1_16bits.vhd
mux3a1_16bits.vhd
mux3a1_5bits.vhd
ram_datos.vhd
registro_PC.vhd
unicontrol_rel1.vhd

Interfaz
Seldigit_CodLEDS.vhd
Componentes:
dec2a4.vhd
hex2led.vhd
mux4a1_4bits.vhd

Generadores seal de reloj


cont_div_frec_refresh.vhd
cont_pausa_gen.vhd
Archivo de restricciones
nexys2.ucf

Sistema final
MIPS_interface.vhd
top_vhd.sch

Prctica 1:Modelacin, simulacin e implementacin del procesador MIPS

Sesin 1: Proyecto ISE, diseo VHDL y simulacin.

3. Sesin 1: Proyecto ISE, diseo


VHDL y simulacin.
3.1. Consideraciones iniciales
Este captulo introduce al estudiante en el uso de las herramientas software necesarias para la prctica. Para ello, se
comenzar un proyecto software en el que definiremos el mdulo "Seldigit_CodLEDS", encargado de visualizar en
un display de la tarjeta de prototipado el contenido de unos registros del procesador.
En este captulo se aprendern a modelar circuitos mediante cdigo VHDL. Tambin se aprender a simular el
comportamiento del circuito para comprobar ha sido correctamente diseado.

3.2. Planteamiento del circuito decodificador


Vamos a modelar un circuito llamado "Seldigit_CodLEDS", cuyo propsito ser servir de interfaz del futuro
procesador MIPS con los perifricos de visualizacin de la tarjeta de prototipado (displays). Este mdulo consta de
dos entradas ("refresh(1:0)" y "regs(15:0)") y dos salidas ("anodos(3:0)" y "catodos(7:0)").

entradas

salidas

El circuito est formado, a su vez, por tres mdulos ("dec2a4", "mux4a1_4bits" y "hex2led"), conectados de la
forma que se observa en la siguiente figura:

Seldigit_CodLEDS

Decodificador
dec2a4

refresh(1:0)

regs(15:0)

Multiplexor 4 a 1 de 4 bits
mux4a1_4bits

Codificador hexadecimal a led


hex2led

anodos(3:0)

Leds_7seg(6:0)
catodos(7:0)

Este circuito se utiliza para visualizar el contenido de registros de 16 bit en un display de 7 segmentos de la tarjeta
de prototipado. El contenido del registro se divide en 4 partes que son enviados al display.

Prctica 1:Modelacin, simulacin e implementacin del procesador MIPS

3.2.1. Mdulo "dec2a4"


Es un decodificador de la entrada de 2 bits "d" a la salida de 4 bits "y", segn la siguiente tabla de verdad:

d(1:0)
00
01
10
11
otros casos

y(0:3)
0111
1011
1101
1110
1111

y(3:0)
1110
1101
1011
0111
1111

3.2.2. Mdulo "mux4a1_4bits"


Es un multiplexor de 4 seales de entrada a 1 seal de salida, todas de 4 bits, con una seal de seleccin de 2 bit,
segn la siguiente tabla de verdad:

sel(1:0)
00
01
10
11

s(3:0)
d0(3:0)
d1(3:0)
d2(3:0)
d3(3:0)

3.2.3. Mdulo "hex2led"


Es un codificador de la entrada de 4 bits "HEX" a la salida de 7 bits "LED", segn la siguiente tabla de verdad. El
objetivo es encender (bit 0) o apagar (bit 1) los segmentos correspondientes de un display de 7 segmentos de forma
que el aspecto visual sea el de un dgito hexadecimal desde el 0 hasta el F.

HEX(3:0)

LED(6:0)

0000
0001
0010
0011
0100
0101
0110
0111
1000
1001
1010
1011
1100
1101
1110
1111

0000001
1111001
0010010
0000110
1001100
0100100
0100000
0001111
0000000
0000100
0001000
1100000
0110001
1000010
0110000
0111000

Aspecto del
display de 7
segmentos
0
1
2
3
4
5
6
7
8
9
A
b
C
d
E
F

Sesin 1: Proyecto ISE, diseo VHDL y simulacin.

3.3. Creacin del proyecto

Crear una carpeta en el ordenador que cumpla los siguientes requisitos:


o

Que cuelgue de la carpeta "C:\GIEC\".

Que no contenga espacios en blancos, ni tildes, ni la letra "", y no sea de longitud excesiva.

Que identifique al alumno, de forma que dicha carpeta no sea utilizada por otra persona y que pueda ser
reutilizada en posteriores sesiones de laboratorio sin que nadie la haya alterado. En este tutorial
utilizaremos la carpeta de nombre "alumno", que en cada caso podra ser, por ejemplo, el nombre de email
del alumno (sin "@alumnos.unex.es").

Por tanto, el ejemplo a seguir, y que utilizaremos en este tutorial, es: "C:\GIEC\alumno\".

Es altamente recomendable que esta ruta sea la misma cuando se vayan a utilizar distintos ordenadores, ya
que si hacemos una copia de seguridad para llevar el diseo a otro ordenador, algunos archivos del diseo
pueden tener en su descripcin interna la ruta del computador original que, si no se respeta en el
computador de destino, puede producir errores en algn momento.

Ejecutar la aplicacin "Xilinx ISE Design Suite" > "ISE Design Tools" > "Project Navigator".

"File" > "New Project" > Consignamos el nombre de la prctica "Prac1" bajo la ruta "C:\GIEC\alumno" y
seleccionamos para "top-level source type" la opcin "HDL". Esto significa que el modo de disear el circuito
en el nivel ms alto de la jerarqua de diseo ser mediante un cdigo VHDL.

Siguiendo el asistente, seleccionamos la tarjeta de prototipado "Nexys 2-500 Board". Si no aparece,


seleccionamos: Product Category = All; Family = Spartan3E; Device = XC3S500E; Package = FG320; Speed =
-4. Tambin seleccionamos "Preferred Language" = "VHDL", y comprobamos que "Simulator" = "ISim".

Al finalizar el asistente, aparece la ventana principal del proyecto donde identificamos estas secciones:

Prctica 1:Modelacin, simulacin e implementacin del procesador MIPS

ruta del proyecto


Seccin de archivos del diseo.
Contiene los archivos fuente del proyecto, dispuestos
de forma jerrquica (rbol del proyecto)
Los archivos pueden visualizarse segn su uso para
diseo o implementacin (por defecto, usaremos
siempre esta vista) o para su uso para simulacin (que
seleccionaremos solo cuando vayamos a simular)
Nombre del proyecto
Dispositivo FPGA sobre el que se implementar el proyecto
Aqu se irn colocando los archivos fuente del diseo jerrquicamente
Seccin de procesos del diseo. Contiene las herramientas y
programas (procesos) que se pueden ejecutar para cada uno de
los archivos del diseo o para el diseo completo.
Pestaa para visualizar el diseo del proyecto. Usaremos siempre
esta pestaa por defecto, aunque podemos usar la pestaa Files
para ver el listado de todos los archivos del proyecto y la pestaa
Libraries para ver las libreras del mismo.
Consola de mensajes

3.4. Diseo del mdulo "Seldigit_CodLEDS"


El circuito "Seldigit_CodLEDS" consta de tres mdulos: "dec2a4", "mux4a1_4bits" y "hex2led". Vamos a definir en
primer lugar estos tres mdulos utilizando el lenguaje VHDL, crearemos los archivos fuentes correspondientes (con
extensin ".vhd") y los aadiremos al proyecto. Una vez hecho esto, conectaremos los tres mdulos de forma que
construyan el mdulo "Seldigit_CodLEDS". Para ello, crearemos un cdigo VHDL que contenga la descripcin de
la conexin de los mdulos.
3.4.1. Diseo de los mdulos VHDL
Vamos a disear a continuacin los mdulos "dec2a4", "mux4a1_4bits" y "hex2led" como cdigos VHDL,
ilustrando las dos formas para hacerlo: utilizando el asistente de ISE o crendolos directamente.
Mdulo "mux4a1_4bits".

Aadimos un nuevo archivo al proyecto con el cdigo del mdulo "mux4a1_4bits" usando un asistente para
mdulos VHDL: "Project" > "New Source" > categora "VHDL Module" > consignamos el nombre del archivo
"mux4a1_4bits" > Declaramos las entradas y salidas del mdulo, tal ste se describi anteriormente.

Al finalizar el asistente se genera un cdigo VHDL con la estructura del mdulo, pero a falta de consignar el
comportamiento del circuito. Este comportamiento lo escribimos directamente en el cdigo, segn la tabla de
verdad correspondiente.

10

Sesin 1: Proyecto ISE, diseo VHDL y simulacin.

library IEEE;
use IEEE.STD_LOGIC_1164.ALL;
entity mux4a1_4bits
Port ( D0 : in
D1 : in
D2 : in
D3 : in
SEL : in
S : out
end mux4a1_4bits;

is
STD_LOGIC_VECTOR (3 downto 0);
STD_LOGIC_VECTOR (3 downto 0);
STD_LOGIC_VECTOR (3 downto 0);
STD_LOGIC_VECTOR (3 downto 0);
STD_LOGIC_VECTOR (1 downto 0);
STD_LOGIC_VECTOR (3 downto 0));

architecture Behavioral of mux4a1_4bits is


begin
S <= D0 when
D1 when
D2 when
D3 when
X"0";

SEL="00" else
SEL ="01" else
SEL ="10" else
SEL ="11" else

end Behavioral;

Finalmente, el archivo fuente "mux4a1_4bits" es creado y aadido al proyecto, tal como puede verse en el rbol
del diseo.

Comprobamos que el cdigo VHDL no contiene errores. En el rbol del proyecto, sealamos "mux4a1_4bits",
vamos a la ventana de procesos y buscamos la herramienta "Check Syntax" (que puede estar bajo la categora
"Synthesize XST"). Sobre "Check Syntax" accionamos el botn derecho del ratn > "Run". El cdigo VHDL
se compilar, y el resultado se muestra en la consola. Si no hay errores, aparecer "Process "Check Syntax"
completed successfully".

Mdulo "dec2a4".

Vamos a crear y aadir al proyecto el cdigo VHDL correspondiente a este mdulo sin utilizar el asistente. Para
ello, procedemos de la siguiente forma:
o

En un editor de texto plano, bien sea fuera del entorno ISE (con WorPad, por ejemplo) o dentro ("File" >
"New" > "Text file"), escribimos el cdigo VHDL del mdulo y lo guardamos en el archivo "dec2a4.vhd",
dentro de la carpeta raz del proyecto. El cdigo VHDL corresponde con la tabla de verdad consignada
anterioremente.

Aadimos este archivo al proyecto: "Project" > "Add Source" > Seleccionamos el archivo > "Ok".
Comprobamos que el archivo se ha aadido al rbol del proyecto.

Comprobar el cdigo mediante "Check Syntax".

library IEEE;
use IEEE.STD_LOGIC_1164.ALL;
entity dec2a4 is
Port ( d : in STD_LOGIC_VECTOR (1 downto 0);
y : out STD_LOGIC_VECTOR (0 to 3));
end dec2a4;
architecture Behavioral of dec2a4 is
begin
with d select
y <= "0111" when "00",
"1011" when "01",
"1101" when "10",
"1110" when "11",
"1111" when others;
end Behavioral;

Mdulo "hex2led".
Para crear el archivo "hex2led.vhd" con el cdigo VHDL correspondiente a este mdulo, podemos utilizar
cualquiera de los dos mtodos anteriores (utilizar el asistente o aadiendo el archivo al proyecto). El cdigo VHDL
del mdulo corresponde con la tabla de verdad descrita anteriormente. Una vez aadido el archivo al proyecto,
comprobar el cdigo mediante "Check Syntax".

11

Prctica 1:Modelacin, simulacin e implementacin del procesador MIPS


library IEEE;
use IEEE.STD_LOGIC_1164.ALL;
entity hex2led is
Port ( HEX : in STD_LOGIC_VECTOR (3 downto 0);
LED : out STD_LOGIC_VECTOR (6 downto 0));
end hex2led;
architecture Behavioral of hex2led
begin
-- Codificacion segmentos array en
-6
----- 1 |
| 5
---<- 0 ---- 2 |
| 4
----3
with HEX select
LED <= "0000001" when "0000",
"1111001" when "0001",
"0010010" when "0010",
"0000110" when "0011",
"1001100" when "0100",
"0100100" when "0101",
"0100000" when "0110",
"0001111" when "0111",
"0000000" when "1000",
"0000100" when "1001",
"0001000" when "1010",
"1100000" when "1011",
"0110001" when "1100",
"1000010" when "1101",
"0110000" when "1110",
"0111000" when "1111",
"0000001" when others;
end Behavioral;

is
sentido descendente

--0
--1
--2
--3
--4
--5
--6
--7
--8
--9
--A
--b
--C
--d
--E
--F
--0

3.4.2. Conectando los mdulos mediante VHDL


Vamos ahora a conectar estos tres mdulos para formar el circuito "Seldigit_CodLEDS". Ahora lo haremos
mediante un cdigo VHDL. Si miramos la descripcin de este circuito al principio del captulo, observaremos cmo
estn conectados los mdulos y cules son las seales internas y de E/S. En base a ello, creamos el archivo
"Seldigit_CodLEDS.vhd" (por cualquiera de los mtodos descritos anteriormente: asistente o archivo de texto) que
aadiremos al proyecto, y que contendr las siguientes sentencias:
library IEEE;
use IEEE.STD_LOGIC_1164.ALL;
entity Seldigit_CodLEDS is
Port ( regs : in STD_LOGIC_VECTOR (15 downto 0);
refresh : in STD_LOGIC_VECTOR (1 downto 0);
anodos : out STD_LOGIC_VECTOR (3 downto 0);
catodos: out STD_LOGIC_VECTOR (7 downto 0));
end Seldigit_CodLEDS ;
architecture Behavioral of Seldigit_CodLEDS is
signal hexLED: STD_LOGIC_VECTOR(6 DOWNTO 0); -- para concatenar con punto
signal punto: std_logic:='1';
signal digHEX: STD_LOGIC_VECTOR(3 DOWNTO 0);
alias
alias
alias
alias

12

digit3:
digit2:
digit1:
digit0:

STD_LOGIC_VECTOR(3
STD_LOGIC_VECTOR(3
STD_LOGIC_VECTOR(3
STD_LOGIC_VECTOR(3

DOWNTO
DOWNTO
DOWNTO
DOWNTO

0)
0)
0)
0)

is
is
is
is

REGS(15 DOWNTO 12);


REGS(11 DOWNTO 8);
REGS(7 DOWNTO 4);
REGS(3 DOWNTO 0);

E/S del
circuito

Sesin 1: Proyecto ISE, diseo VHDL y simulacin.


COMPONENT dec2a4
PORT(
d : IN std_logic_vector(1 downto 0);
y : OUT std_logic_vector(0 to 3)
);
END COMPONENT;

declaracin de los
componentes

COMPONENT mux4a1_4bits
PORT(
d0 : IN std_logic_vector(3 downto 0);
d1 : IN std_logic_vector(3 downto 0);
d2 : IN std_logic_vector(3 downto 0);
d3 : IN std_logic_vector(3 downto 0);
sel : IN std_logic_vector(1 downto 0);
S : OUT std_logic_vector(3 downto 0)
);
END COMPONENT;
COMPONENT hex2led
PORT(
HEX : IN std_logic_vector(3 downto 0);
LED : OUT std_logic_vector(6 downto 0)
);
END COMPONENT;
begin
catodos <= HExled & punto;
Inst_mux4a1_4bits: mux4a1_4bits
PORT MAP(
d0 => digit3,
d1 => digit2,
d2 => digit1,
d3 => digit0,
sel => refresh,
s => digHex
);
Inst_dec2a4: dec2a4
PORT MAP(
d => refresh,
y => anodos
);

Instancias de los componentes,


donde se especificn las
conexiones entre ellos

Inst_hex2led: hex2led
PORT MAP(
hex => digHEX,
led => HEXled
);
end Behavioral;

Como puede observarse, el archivo "Seldigit_CodLEDS.vhd" aparece en el rbol del proyecto en un nivel por
encima de los archivos ".vhd" de los mdulos, ya que se trata de una jerarqua.

3.5. Simulacin del mdulo "Seldigit_CodLEDS"


La simulacin de los circuitos es un paso imprescindible en el llamado "ciclo de diseo", ya que permite depurar
errores que, si no se detectan, se irn propagando conforme avancemos en el diseo del sistema final. Cada etapa de
modelacin o diseo debe ser seguida por una simulacin.
Para simular un circuito, se utilizan un cdigo VHDL llamado "Test Bench" (en adelante, abreviamos este trmino
por las siglas TB). Este cdigo, recogido en un archivo VHDL, contiene la descripcin de la aplicacin de los
estmulos o valores que se asignan a las entradas del circuito a simular. La herramienta o software simulador que
13

Prctica 1:Modelacin, simulacin e implementacin del procesador MIPS

viene integrado en ISE ("ISim") ejecuta este "Test Bench", es decir, sigue las rdenes descritas en ese cdigo para
generar y mostrar grficamente el comportamiento (valores que toman las salidas) del circuito.
Vamos ahora a simular el circuito "Seldigit_CodLEDS".

Cambiamos a vista "Simulation".

"Project" > "New Source" > "VHDL Test Bench" con nombre "TB_Seldigit_CodLEDS" > Se pide cul es el
circuito que queremos simular con este TB; especificamos "Seldigit_CodLEDS" > Se crea el archivo
"TB_Seldigit_CodLEDS.vhd" que contiene un esqueleto o modelo de TB, el cual es automticamente
comprobado en su sintaxis VHDL. Ignoramos si da errores, pues vamos a modificarlo a continuacin.
Diseo en modo vista de simulacin

Test Bench
Circuito que simular el test bench

Herramienta simulador
Comprueba el cdigo del test bench
Ejecuta el test bench para simular el circuito

14

Una vez generado el TB, lo editamos para consignar el siguiente cdigo:

Sesin 1: Proyecto ISE, diseo VHDL y simulacin.


LIBRARY ieee;
USE ieee.std_logic_1164.ALL;
USE ieee.std_logic_arith.ALL;

Aadimos

ENTITY TB_Seldigit_CodLEDS IS
END TB_Seldigit_CodLEDS;
ARCHITECTURE behavior OF TB_Seldigit_CodLEDS IS
-- Component Declaration for the Unit Under Test (UUT)
COMPONENT Seldigit_CodLEDS
PORT(
regs
: IN std_logic_vector(15 downto 0);
refresh : IN std_logic_vector(1 downto 0);
anodos : OUT std_logic_vector(3 downto 0);
catodos : OUT std_logic_vector(7 downto 0)
);
END COMPONENT;
--Inputs
signal regs : std_logic_vector(15 downto 0) := (others => '0');
signal refresh : std_logic_vector(1 downto 0) := (others => '0');
--Outputs
signal anodos : std_logic_vector(3 downto 0);
signal catodos : std_logic_vector(7 downto 0);
constant <clock>_period : time := 10 ns;

Eliminamos

BEGIN
-- Instantiate the Unit Under Test (UUT)
uut: Seldigit_CodLEDS PORT MAP (
regs => regs,
refresh => refresh,
anodos => anodos,
catodos => catodos
);
-- Clock process definitions
<clock>_process :process
begin
<clock> <= '0';
wait for <clock>_period/2;
<clock> <= '1';
wait for <clock>_period/2;
end process;

Eliminamos

-- Stimulus process
stim_proc: process
begin
-- hold reset state for 100 ns.
wait for 100 ns;
regs <= X"0123";
for i in 0 to 3 loop
refresh <= conv_std_logic_vector(i,2);
wait for 20 ns;
end loop;
regs <= X"4567";
for i in 0 to 3 loop
refresh <= conv_std_logic_vector(i,2);
wait for 20 ns;
end loop;
regs <= X"89AB";
for i in 0 to 3 loop
refresh <= conv_std_logic_vector(i,2);
wait for 20 ns;
end loop;
regs <= X"CDEF";
for i in 0 to 3 loop
refresh <= conv_std_logic_vector(i,2);
wait for 20 ns;
end loop;
wait for 50 ns;
wait for <clock>_period*10;

Aadimos

Eliminamos

wait;
end process;
END;

15

Prctica 1:Modelacin, simulacin e implementacin del procesador MIPS

Una vez consignado este cdigo, comprobamos que est libre de errores, en la vista "Simulation", seleccionando
el archivo testbench, y ejecutando "Behavioral Check Syntax", debajo de "Isim Simulator".

A continuacin, ejecutamos "Simulate Behavioral Model" > "Run". Aparece la representacin grfica de la
simulacin, sobre la cual podemos comprobar el correcto funcionamiento del circuito. Por defecto, la
simulacin mostrar siempre el final de la misma y en el nivel mximo de detalle. Para poder ver toda la
simulacin, hay que pulsar varias veces la lupa con el "-" o una sola vez la lupa con la "x". Una vez comprimida
toda la simulacin, podemos ampliar la zona de inters mediante la lupa con el "+".

Zona inestable
del comportamiento
del circuito

Zona estable
del comportamiento
del circuito

Valores de las E/S para el instante


seleccionado de la simulacin

16

Instante
seleccionado de
la simulacin

Sesin 2: Simulacin de componentes del procesador.

4. Sesin
2:
Simulacin
componentes del procesador.

de

Desarrollo.

Simular los componentes del procesador "ALU16bits.vhd" y "registro_PC.vhd".

Se suministran los cdigos VHDL completos de estos componentes.

El alumno crear los archivos de simulacin testbench correspondientes a estos dos componentes, y realizar la
simulacin comprobando los resultados.

Entradas y salidas de los componentes:

Operaciones de la ALU:

17

Prctica 1:Modelacin, simulacin e implementacin del procesador MIPS

18

Sesin 3: Simulacin de las memorias de datos e instrucciones.

5. Sesin 3: Simulacin de las


memorias de datos e instrucciones.
En esta sesin el alumno simular los componentes del procesador "Mem_Ia_256x8.vhd" (memoria de
instrucciones) y "ram_datos.vhd" (memoria de datos), cuyos cdigos VHDL se suministran.
El alumno crear un testbench para la memoria de instrucciones, y recibir del profesor el testbench completo para
la memoria de datos, pero que deber modificar para asignar nuevos datos a esta memoria.

5.1. Memoria de instrucciones.


5.1.1. Modelo.

La descripcin VHDL de la memoria de instrucciones, "Mem_Ia_256x8.vhd", define el programa ensamblador


MIPS que est almacenado en esta memoria. Los 8 bits de direccin pueden direccionar hasta 256 Bytes, porque en
la arquitectura MIPS cada direccin de memoria se asigna o direcciona 1 Byte de memoria, no una palabra
de 32 bits. Una instruccin MIPS ocupa una palabra de memoria de 32 bits (4 Bytes), donde el direccionamiento
sigue el criterio big-endian, es decir, la direccin de la instruccin se asigna al Byte ms significativo de la
instruccin. El tamao mximo de programa ensamblador que podemos tener almacenado es de 256 direcciones / 4
Bytes que tiene una instruccin = 64 instrucciones de 32 bits = 256 Bytes.
El programa ensamblador MIPS que inicialmente definimos en esta memoria es el siguiente:

Fin:

0
4
8
12
16
20
24
28
32
36
40
44
48

60
Rutina: 64
68
Bucle: 72
76
80
84
88
92
96
ret:
100

Direccin
de memoria

Sub $3, $0, $4


addi $1, $3, 23
And $2, $1, $3
Nor $5, $0, $0
Sw $5, 48($0)
Sw $4, 8($0)
Lw $6, 20($0)
Jal rutina
Sw $2, 12($0)
Addi $15, $31, 0
Bne $0, $3, -1
X"0000"
X"0000"
... ...
X"0000"
xor $3,$1,$1
Ori $2, $0, 0
slt $1, $3, $6
Beq $1, $0, ret
Lw $5, 0($4)
Addi $3, $3, 1
Addi $4, $4, 4
Add $2, $2, $5
J bucle
jr $31

# $4 inicializado con direccion inicio array ( =24)


# $3 <- -24
# $1 <- -1

carga en $6

num elem array (20/2=10)

# guarda en dir 0 resultado suma


#
#
#
#
#
#
#
#
#
#
#
#
#

(bucle infinito)
(rellenar con 32 0`s
(rellenar con 32 0`s
(rellenar con 32 0`s
(rellenar con 32 0`s
i <- 0 (indice en $3)
suma v 0 en $2
si i > = n entonces $1 <- 0
salta a ret si i > = n
$5 <- x(i) (<$4> = 24 inicialmente)
i <- i + 1
actualiza $4
suma <- suma + x(i)

Instrucciones
ensamblador

19

Prctica 1:Modelacin, simulacin e implementacin del procesador MIPS

Las instrucciones del ensamblador se almacenan codificadas en binario en las palabras de la memoria de
instrucciones. El siguiente listado corresponde a la codificacin binaria de este programa. No obstante, la
inicializacin de esta memoria est inacabada: Falta por codificar las instrucciones sealadas.
type rom_type is array (0 to 255) of std_logic_vector (7 downto 0);
( "00000000", "00000100", -- 0
"00011000", "00100010", -- Sub $3, $0, $4
"uuuuuuuu", "uuuuuuuu", -- 4
"uuuuuuuu", "uuuuuuuu", -- addi $1, $3, 23
"00000000", "00100011", -- 8
"00010000", "00100100", -- And $2, $1, $3
"00000000", "00000000", -- 12
"00101000", "00100111", -- Nor $5, $0, $0 (cambio)
"10101100", "00000101", -- 16
"00000000", "00110000", -- Sw $5, 48($0)
"10101100", "00000100", -- 20
"00000000", "00001000", -- Sw $4, 8($0)
"10001100", "00000110", -- 24
"00000000", "00010100", -- Lw $6, 20($0)
-- 20/2=10
"00001100", "00000000", -- 28
"00000000", "01000000", --Jal rutina = 64
"10101100", "00000010", -- 32
"00000000", "00001100", -- Sw $2, 12($0)
"00100011", "11101111", -- 36
"00000000", "00000000", -- addi $15, $31, 0
"00010100", "00000011", -- 40
"11111111", "11111111", -- Bne $0, $3, -1
-- SECCION DE MEMORIA NO USADA
"00000000", "00000000", -- 44
"00000000", "00000000", -- no utilizada
"00000000", "00000000", -- 48
"00000000", "00000000", -- no utilizada
"00000000", "00000000", -- 52
"00000000", "00000000", -- no utilizada
"00000000", "00000000", -- 56
"00000000", "00000000", -- no utilizada
"00000000", "00000000", -- 60
"00000000", "00000000", -- no utilizada
"uuuuuuuu", "uuuuuuuu", -- 64
"uuuuuuuu", "uuuuuuuu", -- xor $3,$1,$1 = INI rutina
"00110100", "00000010", -- 68
"00000000", "00000000", -- Ori $2, $0, 0
"00000000", "01100110", -- 72 = ini bucle
"00001000", "00101010", -- slt $1, $3, $6
"uuuuuuuu", "uuuuuuuu", -- 76
"uuuuuuuu", "uuuuuuuu", -- Beq $1, $0, ret
"uuuuuuuu", "uuuuuuuu", -- 80
"uuuuuuuu", "uuuuuuuu", -- Lw $5, 0($4)
"00100000", "01100011", -- 84
"00000000", "00000001", -- Addi $3, $3, 1
"00100000", "10000100", -- 88
"00000000", "00000100", -- Addi $4, $4, 4
"00000000", "01000101", -- 92
"00010000", "00100000", -- Add $2, $2, $5
"00001000", "00000000", -- 96
"00000000", "01001000", -- J bucle
"00000011", "11100000", -- 100
"00000000", "00001000", -- jr $31
others => X"00" );

EJERCICIO:
Codificar en binario las
instrucciones sealadas, e
incorporar esos datos
binarios al archivo
Mem_Ia_256x8.vhd antes
de simularlo (sustituir
uuuuuuuu por los datos
correspondientes).

5.1.2. Simulacin.
Como ayuda para crear el testbench para la memoria de instrucciones, considerar el siguiente cdigo VHDL (se
puede crear un testbench automticamente, quitar toda referencia de seal de reloj la memoria de instrucciones es
combinacional- y sustituir el proceso de estmulos por el siguiente):
---------

A PARTIR DE AQUI ES CODIGO VHDL


Proceso estimulo para el test bench de la memoria de instrucciones
EXPLICACION: En la memoria de instrucciones caben hasta 64 instrucciones de 4 bytes
cada una. Se generan las direcciones enteras desde 0 hasta 63 y se convierten
a numeros binarios de 6 bits asignando el resultado de la conversin a la
variable dir_palabra, declarada en la seccin declaratival del proceso.
Se multiplica por 4 esta variable (contatenando dos bits "00" a la derecha
Se asigna el resultado a la seal dir que corresponde al estmulo de direccin de la memoria.

----

VEASE CDIGO VHDL

USE ieee.std_logic_arith.ALL;

20

--

necesaria esta clasula para usar funcin de conversin.

Sesin 3: Simulacin de las memorias de datos e instrucciones.


--- proceso estmulos
stim_proc: process
variable dir_palabra: std_logic_vector(5 downto 0); -- 63 instrucciones
begin
wait for 20 ns;
for i in 0 to 63 loop
dir_palabra:= conv_std_logic_vector(i,6);
dir <= dir_palabra & "00";
wait for 20 ns;
end loop;
wait;
end process;
-- FIN DE CODIGO VHDL

5.2. Memoria de datos.


5.2.1. Modelo.

La descripcin VHDL de la memoria de datos, "ram_datos.vhd", define el contenido de las palabras de la memoria
con unos datos concretos, que son los que residirn en la memoria cuando se configure la FPGA de la tarjeta de
prototipado. Estos datos son:
Direccin
de memoria

Contenido de la memoria
(palabras de memoria de 2 bytes = 8
bits)

0
...
10
11
12
13
14
15
16
17
18
19
20
21
22
23
...
254

0x00
0x00
0x00
0x06
0xff
0xff
0xff
0xfe
0xff
0xfc
0x22
0xbf
0x80
0x90
0x7f
0xff
...
0x00

6 = nmero de elementos del array

DATO 1: - 1 = 0xffff
DATO 2: - 2 = 0xfffe
DATO 3: - 4 = 0xfffc
DATO 4: 8895 = 0x22bf
DATO 5: 32624 = 0x8090

array
= 9031 = 234716

DATO 6: 32767 = 0x7fff

Para obtener una direccin par de la memoria de datos hay que dividir por 2 las direcciones mltiplo de 4
codificadas en la memoria de instrucciones.
5.2.2. Simulacin.
Para realizar la simulacin de la memoria de datos, se suministra el testbench "ram_datos_tb.vhd". No obstante, en
la simulacin el alumno definir nuevos datos en la memoria (que deber cambiar en el archivo VHDL del modelo
de la memoria, "ram_datos.vhd"), concretamente del DATO 2 al DATO 6. Para ello, se toma como elemento de
referencia el DNI del alumno, que consta de 8 dgitos, numerndose dichos dgitos de izquierda a derecha en sentido
ascendente.
21

Prctica 1:Modelacin, simulacin e implementacin del procesador MIPS

Nmero de elementos del array = 6 (en direcciones 10 y 11).


Contenido del array:

DATO 1: - 1

(en direcciones 12,13) , NO CAMBIAR

DATO 2: digito 1 DNI con signo negativo. Si es 0 se pone 0 (en direcciones 14,15).

DATO 3: Nmero positivo ms alto representable con 16 bits: 32767 (en direc. 16,17)

DATO 4: nmero negativo ms bajo representable con 16 bits: -32768 (en direc. 18,19)

DATO 5: valor decimal obtenido al considerar los digitos 2, 3, 4 y 5 del DNI (en direc. 20,21)

DATO 6: valor decimal obtenido al considerar los digitos 6, 7 y 8 del DNI (en direc. 22, 23)

Por ejemplo, para el DNI 76026769:


7
digito 1

6
digito 2

Dato 1 = -1

Dato 2 = -7

Dato 3 = 32767

Dato 4 = -32768

Dato 5 = 6026

Dato 6 = 769

22

0
digito 3

2
digito 4

6
digito 5

7
digito 6

6
digito 7

9
digito 8

Sesin 4: Descripcin y simulacin del procesador.

6. Sesin 4: Descripcin y simulacin


del procesador.
6.1. Desarrollo.

El alumno realizar una descripcin VHDL estructural del procesador, utilizando todos los componentes, a
partir de un modelo incompleto suministrado por el profesor: "Mips_Nucleo1.vhd". Se trata de completar este
archivo, colocando todos los componentes e instancias con sus correspondientes conexiones. Para ello, ser
necesario examinar la figura arquitectura del procesador.

Despus el alumno crear el testbench correspondiente para simular el procesador y comprobar su


funcionamiento.

6.2. Componentes del procesador.


En la figura arquitectura del procesador podemos ver los bloques y conexiones que forman el procesador MIPS.
Los componentes del procesador son los siguientes:
Archivo
ALU16bits.vhd
ALUcontrol_0.vhd
BReg_3port_lec.vhd
Mem_Ia_256x8.vhd
mux2A1_16bits.vhd
mux3a1_16bits.vhd
mux3a1_5bits.vhd
ram_datos.vhd
registro_PC.vhd
unicontrol_rel1.vhd

Mdulo
Unidad aritmtico lgica (ALU)
Control de la ALU
Banco de registros
Memoria de instrucciones
Multiplexor 2x1 de 16 bits
Multiplexor 3x1 de 16 bits
Multiplexor 3x1 de 5 bits
Memoria de datos
Contador de programa
Unidad de control

6.3. Descripcin VHDL del procesador.


El archivo VHDL incompleto "Mips_Nucleo1.vhd" describe estructuralmente el procesador. Hay que completarlo
conectando adecuadamente las instancias de los componentes del procesador, siguiendo el esquema que se ve en la
figura arquitectura del procesador.
Todos los componentes tienen que estar descritos una sola vez en el cdigo, pero habr tantas instancias de un
mismo componente como veces aparezca en la figura. Por ejemplo, el multiplexor 3x1 de 16 bits aparece dos veces
en la arquitectura del procesador, por lo que pondremos dos instancias de este componente en el cdigo.

23

Prctica 1:Modelacin, simulacin e implementacin del procesador MIPS

Figura: arquitectura del procesador

24

Sesin 4: Descripcin y simulacin del procesador.

6.4. Simulacin.
Una vez completado el archivo "Mips_Nucleo1.vhd", hay que simularlo para verificar que hemos hecho todas las
conexiones correctamente.

Cambiar a vista "Simulation" -> New Source -> VHDL Test Bench (ponemos como nombre
"TB_Mips_Nucleo1") -> Lo asociamos al mdulo "MIPS_nucleo1" -> Se genera el testbench.

En el testbench generamos, aadimos en la seccin de estmulos, una nica sentencia para indicar que queremos
seleccionar, mediante la seal de entrada "selreg", el registro $3 para que se muestre, mediante la seal de salida
"salreg", su valor al final de la simulacin:
stim_proc: process
begin
-- hold reset state for 100 ns.
wait for 100 ns;
wait for clock_period*10;
-- insert stimulus here
selreg <= "00011";
wait;
end process;

Ejecutamos la simulacin:

Podemos observar que el programa ha finalizado cuando la seal "pcout" toma el valor 40 (entero sin signo).

Para comprobar que el programa se ha ejecutado correctamente, deberamos examinar el contenido de los
registros. Para ello, hay que aadir a la ventana de simulacin de seales (waveform) los registros. Procedemos
de la siguiente forma:
o

En la ventana "Instances and Processes", expandimos "tb_mips_nucleo1" -> expandimos la instancia "uut"
-> picamos en "Inst_BReg_3port" -> en la ventana "Simulation Objects" aparecen las seales y
componentes de la instancia "Inst_BReg_3port", entre ellos aparece "banco_reg" -> picamos en
banco_reg[0:31] -> con el botn derecho del ratn: "Add To Wave Window" -> aparece "banco_reg[0:31]"
en la ventana de simulacin de seales.

Si expandimos "banco_reg[0:31]", veremos el valor de cada uno de los 32 registros del procesador al final
de la simulacin. Para ver los valores que han ido tomando durante la simulacin, debemos reiniciarla. Para
ello hacemos "Simulation" -> "Restart" para poner "a cero" los registros, y luego "Simulation" -> "Run".
Ahora podemos ver la evolucin del sus valores.

25

Prctica 1:Modelacin, simulacin e implementacin del procesador MIPS

26

Si observamos el registro $3 = $v1 = 00000000000000000000000000000111, coincide con el valor de la


seal "salreg", pues habamos seleccionado ese registro en el testbench mediante "selreg".

Podemos comprobar si el valor de los registros corresponde con el valor que toman cuando el programa se
ejecuta. La siguiente figura corresponde con la simulacin del procesador y el contenido de los registros
(decimal con signo) durante la ejecucin del programa. Algunos valores que aparecen en la imagen pueden
ser distintos a los que tenga el alumno, porque la memoria de datos es distinta. Tambin puede haber
alguna diferencia ms si se ha codificado mal alguna instruccin en la memoria de instrucciones.

Sesin 5: Descripcin, simulacin y prueba del sistema final.

7. Sesin 5: Descripcin, simulacin


y prueba del sistema final.
7.1. Interfaz del procesador.
Una vez diseado el procesador MIPS, modelado en el archivo "Mips_Nucleo1.vhd", procederemos a prototiparlo
en hardware, configurando el chip FPGA de la tarjeta de prototipado Nexys/Nexys2. Pero, para que podamos
interaccionar con el procesador MIPS en la tarjeta (a travs de conmutadores como entradas y leds y displays como
salidas), necesitaremos, adems, algn otro mdulo que haga de interfaz entre el procesador MIPS y los perifricos
de la tarjeta. De esta forma, la FPGA se configura con el procesador MIPS ms el interfaz.
El interfaz del procesador es el mdulo "Seldigit_CodLEDS.vhd" que se estudi al principio de la prctica, en la
primera sesin. Necesitaremos, adems, dos mdulos adicionales, "cont_div_frec_refresh.vhd" y
"cont_pausa_gen.vhd", para acondicionar las seales de reloj de los circuitos.
7.1.1. Descripcin VHDL.
Se proporciona un archivo VHDL llamado "MIPS_interface.vhd". Este archivo contiene la descripcin VHDL en
estilo estructural del sistema final, que incluye 4 componentes: "cont_div_frec_refresh", "cont_pausa_gen",
"Seldigit_CodLEDS" y "MIPs_nucleo1".

En esta descripcin VHDL del sistema final, tendremos el archivo "MIPS_interface.vhd" en el nivel ms alto del
rbol del proyecto en el entorno ISE:
27

Prctica 1:Modelacin, simulacin e implementacin del procesador MIPS

7.2. Simulacin.
Para realizar la simulacin del sistema completo, el alumno utilizar un fichero de testbench proporcionado llamado
"Mips_interface_tb.vhd". Al estar los dos contadores ("cont_div_frec_refresh" y "cont_pausa_gen") parametrizados
mediante genricos, podemos realizar la simulacin con una escala de tiempo distinta a los tiempos que intervienen
en la sntesis. Para conseguir esto, basta con utilizar parmetros distintos en simulacin y sntesis (implementacin).
Para ello, se cambia el valor del genrico en las sentencia de instanciacin de los componentes
"cont_div_frec_refresh" y "cont_pausa_gen" (observar los comentarios introducidos en ambas sentencias de
instanciacin).
Inst_div_frec: cont_div_frec_refresh
generic map (n => 19)
-- 3 para simulacin y 19 para sintesis
PORT MAP(
clk50Mhz => clk50Mhz,
refresh => refresco,
clk_hercios => reloj1);
--Inst_cont_pausa_gen: cont_pausa_gen
GENERIC MAP ( n => 5)
-- 2 para simulacin ; 4 a 7 para sintesis
PORT MAP(
clock => reloj1,
pausa => clock_en,
clk_sal => reloj2);

7.3. Implementacin hardware del circuito.


Las seales de E/S del sistema final son:

Entradas:
o

"clk50Mhz". Oscilador de la tarjeta.

"clock_en". Conmutador SW7 de la tarjeta que nos permite habilitar el reloj del circuito del procesador.

"selREG". Conmutadores de la tarjeta que nos permiten seleccionar el registro.

Salidas:
o

"anodos" (nodos) y "HEXleds" (ctodos). Ambas seales controlan la visualizacin en los displays de 7
segmentos de la tarjeta.

"pc_LSB". LEDs de la tarjeta que se encienden o apagan en funcin del valor del registro PC.

Ahora hay que especificar la asignacin de estas seales a los pines de la FPGA.
7.3.1. Asignacin de pines de la FPGA en la descripcin VHDL.
Cada seal E/S en "MIPS_interface.vhd" ha de asignarse a determinados pines de la FPGA, segn su propsito. Los
pines de la FPGA estn conectados con perifricos de la tarjeta. Por ejemplo, la seal "clk50MHz" en el procesador,
que est dentro de la FPGA, debe conectarse con el pin de la FPGA que est conectado con el oscilador de la tarjeta:

28

Sesin 5: Descripcin, simulacin y prueba del sistema final.

Para saber qu pines de la FPGA corresponden con cada perifrico o dispositivo de la tarjeta, debemos consultar el
anexo "Tarjetas Nexys / Nexys2" de este documento.
En el diseo ISE debemos especificar la asignacin de las seales E/S del circuito con los pines de la FPGA,
utilizando el archivo de restricciones UCF. Este es un archivo de texto plano, con extensin ".ucf", que lista dicha
asignacin, solo para las seales del circuito que vayan a ser utilizadas.

"Project" -> "New Source" -> "Implementation Constraints File", teclear "nexys" (o "nexys2", dependiendo de
la tarjeta que vayamos a utilizar) -> "Next" -> seleccionar "mips_interface" como componente de alto nivel del
diseo al que se va a asociar este archivo de restricciones (este paso de seleccin solo se aplica en el caso de
haber ms de un componente de alto nivel en el diseo) -> "Finish". Aparece un archivo vaco titulado
"nexys2.ucf". Este archivo cuelga de la jerarqua del diseo del proyecto.

Editamos el archivo "nexys2.ucf" (podemos editarlo/modificarlo en cualquier momento, ejecutando el proceso


"Edit Constraints (Text)" bajo "User Constraints" en la ventana "Processes"), para hacer la asignacin de pines.
Consignar el siguiente contenido (el correspondiente a la tarjeta que vayamos a utilizar):

Tarjeta Nexys-1000

Tarjeta Nexys2-500

Tarjeta Nexys2-1200

NET "clk50Mhz" LOC = "A8";

NET "clk50Mhz" LOC = "B8";

NET "clk50Mhz" LOC = "B8";

NET "clock_en" LOC = "N16";

NET "clock_en" LOC = "R17";

NET "clock_en" LOC = "R17";

NET
NET
NET
NET

NET
NET
NET
NET

NET
NET
NET
NET

"anodos<0>"
"anodos<1>"
"anodos<2>"
"anodos<3>"

LOC
LOC
LOC
LOC

=
=
=
=

"G14";
"G12";
"G13";
"F12";

"anodos<0>"
"anodos<1>"
"anodos<2>"
"anodos<3>"

LOC
LOC
LOC
LOC

=
=
=
=

"F17";
"H17";
"C18";
"F15";

"anodos<0>"
"anodos<1>"
"anodos<2>"
"anodos<3>"

LOC
LOC
LOC
LOC

=
=
=
=

"F17";
"H17";
"C18";
"F15";

#catodos para 7 segmentos


NET "HEXleds<0>" LOC = "H14";
NET "HEXleds<1>" LOC = "G16";
NET "HEXleds<2>" LOC = "E14";
NET "HEXleds<3>" LOC = "J14";
NET "HEXleds<4>" LOC = "H13";
NET "HEXleds<5>" LOC = "G15";
NET "HEXleds<6>" LOC = "E13";
NET "HEXleds<7>" LOC = "F13";

#catodos para 7 segmentos


NET "HEXleds<0>" LOC = "C17";
NET "HEXleds<1>" LOC = "H14";
NET "HEXleds<2>" LOC = "J17";
NET "HEXleds<3>" LOC = "G14";
NET "HEXleds<4>" LOC = "D16";
NET "HEXleds<5>" LOC = "D17";
NET "HEXleds<6>" LOC = "F18";
NET "HEXleds<7>" LOC = "L18";

#catodos para 7 segmentos


NET "HEXleds<0>" LOC = "C17";
NET "HEXleds<1>" LOC = "H14";
NET "HEXleds<2>" LOC = "J17";
NET "HEXleds<3>" LOC = "G14";
NET "HEXleds<4>" LOC = "D16";
NET "HEXleds<5>" LOC = "D17";
NET "HEXleds<6>" LOC = "F18";
NET "HEXleds<7>" LOC = "L18";

NET
NET
NET
NET
NET
NET
NET
NET

"pc_LSB<0>"
"pc_LSB<1>"
"pc_LSB<2>"
"pc_LSB<3>"
"pc_LSB<4>"
"pc_LSB<5>"
"pc_LSB<6>"
"pc_LSB<7>"

LOC
LOC
LOC
LOC
LOC
LOC
LOC
LOC

=
=
=
=
=
=
=
=

"L14";
"L13";
"M14";
"L12";
"N14";
"M13";
"P14";
"R16";

NET
NET
NET
NET
NET
NET
NET
NET

"pc_LSB<0>"
"pc_LSB<1>"
"pc_LSB<2>"
"pc_LSB<3>"
"pc_LSB<4>"
"pc_LSB<5>"
"pc_LSB<6>"
"pc_LSB<7>"

LOC
LOC
LOC
LOC
LOC
LOC
LOC
LOC

=
=
=
=
=
=
=
=

"J14";
"J15";
"K15";
"K14";
"E17";
"P15";
"F4";
"R4";

NET
NET
NET
NET
NET
NET
NET
NET

"pc_LSB<0>"
"pc_LSB<1>"
"pc_LSB<2>"
"pc_LSB<3>"
"pc_LSB<4>"
"pc_LSB<5>"
"pc_LSB<6>"
"pc_LSB<7>"

LOC
LOC
LOC
LOC
LOC
LOC
LOC
LOC

=
=
=
=
=
=
=
=

"J14";
"J15";
"K15";
"K14";
"E16";
"P16";
"E4";
"P4";

NET
NET
NET
NET

"selREG<0>"
"selREG<1>"
"selREG<2>"
"selREG<3>"

LOC
LOC
LOC
LOC

=
=
=
=

"N15";
"J16";
"K16";
"K15";

NET
NET
NET
NET

"selREG<0>"
"selREG<1>"
"selREG<2>"
"selREG<3>"

LOC
LOC
LOC
LOC

=
=
=
=

"G18";
"H18";
"K18";
"K17";

NET
NET
NET
NET

"selREG<0>"
"selREG<1>"
"selREG<2>"
"selREG<3>"

LOC
LOC
LOC
LOC

=
=
=
=

"G18";
"H18";
"K18";
"K17";

29

Prctica 1:Modelacin, simulacin e implementacin del procesador MIPS

7.3.2. Sntesis e implementacin.


Procedemos a compilar el circuito (procesos de sntesis e implementacin) para generar el archivo
"mips_interface.bit con la descripcin de la configuracin de la FPGA con nuestro circuito del procesador:

Seleccionar " mips_interface " en la ventana "Design"-"Implementation".

Ir a "Processes" > seleccionar "Implement Design" > botn derecho del ratn > "Process Properties" > expandir
el campo "Property display level" y seleccionar "Advanced", y entonces activar la casilla "Perform Advanced
Analysis" en la categora "Post-Place & Route Static Timing Report Properties" -> OK.

Seleccionar "Generate Programming File" > "Process Properties" > seleccionar "JTAG Clock" en el campo
"FPGA Start-Up Clock" en la categora "Startup Options" -> OK.

Seleccionar "Generate Programming File" > "Run". En este momento comienza el proceso de implementacin.
Pasados unos minutos, finalizan los distintos procesos de la implementacin ("Synthesize", "Translate", "Map",
"Place" y "Route"). Al final, se habr generado el archivo " mips_interface.bit", listo para configurar la FPGA.

7.4. Prueba del procesador en la tarjeta de prototipado.

30

En el captulo "Apndice: Tarjetas Nexys / Nexys2" se muestran los pasos para cargar el diseo (archivo ".bit")
en la FPGA, en los apartados "Comprobaciones iniciales" y "Configuracin de la FPGA".

Apndice: Instalacin de Xilinx ISE

8. Apndice: Instalacin de Xilinx ISE


8.1. Introduccin
Xilinx ISE es una herramienta software que permite programar circuitos para implementarse en dispositivos FPGA.
En este tutorial, todos los nombres de variables se mostrarn entre comillas ("").

8.2. Descarga del software y registro en Xilinx


Es necesario registrarse en la web de Xilinx.

Ir a www.xilinx.com -> Support -> Downloads.

Seleccionar la versin ISE 14.6 (que es la misma instalada en los laboratorios y que no dar problemas de
compatibilidad) y el instalador compatible con nuestro sistema operativo.

En este momento nos pedir que ingresemos las credenciales de nuestro perfil en Xilinx. Si no lo tenemos,
tenemos que registrarnos.

Comprobamos que hemos recibido un correo-e y activamos la cuenta clicando en el enlace suministrado en
dicho correo. Es necesario que rellenemos toda la informacin requerida del perfil de la cuenta.

Finalmente, accedemos con nuestra cuenta para proceder a la descarga del software.
31

Prctica 1:Modelacin, simulacin e implementacin del procesador MIPS

Descargar el archivo de instalacin para Windows para el SO correspondiente. Este archivo tiene un gran
tamao, por lo que la descarga tardar mucho tiempo.

8.3. Instalacin

Una vez descargado, descomprimimos el archivo en una carpeta temporal, por ejemplo en "C:/Temp". Es
importante que la ruta a esta carpeta temporal no tenga espacios en blanco y que tampoco sea muy larga, porque
se corre el riesgo de que durante el proceso de instalacin se generen rutas de ms de 255 caracteres y se
interrumpa la instalacin.

Una vez descomprimido, instalar accionando el archivo "xsetup.exe". Aceptar los acuerdos de licencia. A
continuacin, seleccionar la opcin "WebPack".

Se puede de-seleccionar las opciones de instalar los paquetes de WinPCap y SourceryG++ para ahorrar espacio
de disco y aumentar en velocidad.

Dejamos por defecto el resto de opciones y comenzamos la instalacin, la cual tardar bastante tiempo. Hacia el
final se pedir confirmacin de la instalacin de controladores de Xilinx y Digilent. Decimos que s.

32

Apndice: Instalacin de Xilinx ISE

Una vez finalizada la instalacin, se nos pide la configuracin de la licencia. Seleccionamos que queremos
obtener una licencia para el software WebPack.

La licencia se generar personalizada para el computador en el que se instala el software, para lo cual aparece
una ventana con los datos del ordenador, y accionamos el botn "Connect Now".

Se nos pide acceder con la cuenta de Xilinx. En la informacin de nuestro perfil clicamos en "Next" (si algn
campo de informacin del perfil es incorrecto o falta, no podremos continuar sin consignarlo correctamente).

Una vez en la ventana de generacin de la licencia (pestaa "Create New Licenses"), activamos la casilla "ISE
Design Suite WebPack License" y clicamos el botn "Generate Node-Locked License".

El proceso de generacin de la licencia consta de tres sencillos pasos (tan solo hay que clicar el botn "Next")
que concluyen con la aceptacin del acuerdo de licencia.

Al finalizar, en la pestaa "Manage Licenses" podemos descargarnos el archivo de licencia "xilinx.lic" al clicar
en el icono de descarga. Guardamos el archivo en una carpeta o en el escritorio.

Finalmente, en la ventana "Xilinx License Configuration Manager", en la pestaa "Manage Xilinx Licenses",
clicamos el botn "Copy License" y seleccionamos el archivo descargado "xilinx.lic". Cerramos la ventana, al
confirmarse que la operacin se ha realizado correctamente y que la instalacin del software de Xilinx ha
finalizado.

33

Prctica 1:Modelacin, simulacin e implementacin del procesador MIPS

34

Apndice: Errores frecuentes y consideraciones generales en ISE.

9. Apndice: Errores frecuentes y


consideraciones generales en ISE.
9.1. Errores en el diseo del proyecto:

En el rbol del proyecto no aparece un elemento, o aparece con una interrogacin. Si lo aadimos, sale un
mensaje de error avisando que ya est en el proyecto:
o

En la ventana "Sources", ir a la pestaa "Libraries".

Expandir la categora "Work".

Localizar el elemento en cuestin, y borrarlo (botn derecho del ratn, y "Remove").

Volver a la ventana "Sources", volver a aadir el elemento mediante "Add Source".

Para hacer una limpieza de archivos no necesarios que pueden provocar algn problema: "Project" -> "Cleanup
Project Files".

9.2. Errores durante la sntesis e implementacin.


Generalmente, los informes de errores y avisos durante este proceso nos pueden dar una pista de la causa del error.
No obstante, estas son las causas ms habituales:

A veces se producen errores durante la sntesis e implementacin debido a la no actualizacin de los


componentes del diseo (normalmente, los IP cores). Esto suele suceder habitualmente cuando guardamos todo
el proyecto en un medio extrable para volver a grabarlo posteriormente en cualquier equipo. La solucin es:
o

En la ventana "Sources", seleccionamos con el ratn la parte ms superior del rbol del diseo, donde
aparece el nombre del mismo (por encima del tipo de FPGA seleccionado).

En la ventana "Processes", expandimos la categora "Design Utilities".

Ejecutamos "Regenerate All Cores".

Ejecutamos "Update All Schematic Files".

Las seales en el diseo no se corresponden con las seales en el archivo UCF.

El diseo es demasiado grande para la FPGA seleccionada.

35

Prctica 1:Modelacin, simulacin e implementacin del procesador MIPS

36

Apndice: Tarjetas Nexys / Nexys2.

10. Apndice:
Nexys2.

Tarjetas

Nexys

10.1. Manuales.
Es recomendable tener a mano para consulta, los manuales de usuario de las tarjetas de prototipado que se van a
utilizar. Pueden obtenerse en la web www.digilentinc.com o en arco.unex.es/resources. No obstante, a continuacin
se expone la informacin bsica de estas tarjetas para el desarrollo de las prcticas.

10.2. Comprobaciones iniciales.


Antes de utilizar las tarjetas, realizar las siguientes comprobaciones:

La tarjeta debe estar configurada con los jumpers azules en estas posiciones:
o

JP3 in JTAG position.

J4 in USB position.

JP4 in 100 MHZ position.

JPA, JPB, JPC, JPD in 3V3 position.

J6 in TDI-TDO position.

Switch POWER in OFF position.

Para nexys2:
o

JP9 (mode) in JTAG position.

JP7 (power select) in USB position.

JA1, JB1, JC1, JD1 in 3V3 position.

JP8 and JP10 must have placed jumpers.

Switch POWER in OFF position.

All DIP switches in LOW position.

Fuente de alimentacin y comunicacin con el PC:


o

Para nexys:

Conectar el cable USB a un puerto USB en el PC y al puerto mini-USB port en la tarjeta.

Software: El computador debe tener instalado el software "Digilent Adept".

10.3. Configuracin de la FPGA.

Conectar la tarjeta al PC utilizando el cable "Digilent USB".

Encender la tarjeta. Si an no se han instalado, los controladores de la tarjeta se instalan por primera vez en ese
momento.

Ejecutar el software "Adept". La aplicacin detecta automticamente la tarjeta y su correspondiente chip FPGA.

Seleccionar en el campo "FPGA" el archivo de configuracin ".bit" generado en la prctica.

Clicar en "Program".

No olvidar apagar la tarjeta al finalizar la prctica.


37

Prctica 1:Modelacin, simulacin e implementacin del procesador MIPS

10.4. FPGAs.

Nexys-1000: Xilinx Spartan3-1000 FT256 (XC3S1000-FT256-4).

Nexys-500: Xilinx Spartan3E-500 FG320 (XC3S500E-FG320-4).

Nexys-1200: Xilinx Spartan3E-1200 FG320 (XC3S1200E-FG320-4).

10.5. Pines de la tarjeta.


10.5.1. Nexys.
Device on board

FPGA pin

Device on board

FPGA pin

Device on board

FPGA pin

LED - LD0
LED - LD1
LED - LD2
LED - LD3
LED - LD4
LED - LD5
LED - LD6
LED - LD7

L14
L13
M14
L12
N14
M13
P14
R16

DIP switch SW0


DIP switch SW1
DIP switch SW2
DIP switch SW3
DIP switch SW4
DIP switch SW5
DIP switch SW6
DIP switch SW7

N15
J16
K16
K15
L15
M16
M15
N16

Button BTN0
Button BTN1
Button BTN2
Button BTN3

J13
K14
K13
K12

Clock (oscillator)

A8

AN0
AN1
AN2
AN3

G14
G12
G13
F12

CA
CB
CC
CD

F13
E13
G15
H13

CE
CF
CG
DP

J14
E14
G16
H14

10.5.2. Nexys2.
Device on board

FPGA pin

Device on board

FPGA pin

Device on board

FPGA pin

LED - LD0
LED - LD1
LED - LD2
LED - LD3
LED - LD4
LED - LD5
LED - LD6
LED - LD7

J14
J15
K15
K14
E17 (E16*)
P15 (P16*)
F4 (E4*)
R4 (P4*)

DIP switch SW0


DIP switch SW1
DIP switch SW2
DIP switch SW3
DIP switch SW4
DIP switch SW5
DIP switch SW6
DIP switch SW7

G18
H18
K18
K17
L14
L13
N17
R17

Button BTN0
Button BTN1
Button BTN2
Button BTN3

B18
D18
E18
H13

Clock (oscillator)

B8

AN0
AN1
AN2
AN3

F17
H17
C18
F15

CA
CB
CC
CD

L18
F18
D17
D16

CE
CF
CG
DP

G14
J17
H14
C17

(*) Nexys2-1200

10.5.3. Seleccin del reloj en la tarjeta Nexys.

25 MHz:

38

50 MHz:

100 MHz: