EC_2013-2014_Prac1-MIPS-ISE

Grado en ingeniería de Computadores

Grado en Ingeniería de Software

Universidad de Extremadura

ESTRUCTURA DE COMPUTADORES Curso 2013/2014

PPrrááccttiiccaa 11:: MMooddeellaacciióónn,, ssiimmuullaacciióónn ee iimmpplleemmeennttaacciióónn ddeell pprroocceessaaddoorr MMIIPPSS

Julio Ballesteros Rubio, Juan Antonio Gómez-Pulido

Departamento de Tecnología de Computadores y Comunicaciones

Universidad de Extremadura

(c) 2014

Version: 14/febrero/2014

Práctica 1:Modelación, simulación e implementación del procesador MIPS

2

Índice. 1. Planificación de la práctica. ................................................................................................................................. 3

1.1. Sesión 1: Proyecto ISE, diseño VHDL y simulación. .................................................................................. 3 1.2. Sesión 2: Simulación de componentes del procesador................................................................................. 3 1.3. Sesión 3: Simulación de las memorias de datos e instrucciones. ................................................................. 3 1.4. Sesión 4: Descripción y simulación del procesador. .................................................................................... 3 1.5. Sesión 5: Descripción, simulación y prueba del sistema final. .................................................................... 3

2. Introducción. ........................................................................................................................................................ 5 3. Sesión 1: Proyecto ISE, diseño VHDL y simulación. .......................................................................................... 7

3.1. Consideraciones iniciales ............................................................................................................................. 7 3.2. Planteamiento del circuito decodificador ..................................................................................................... 7

3.2.1. Módulo "dec2a4" ................................................................................................................................ 8 3.2.2. Módulo "mux4a1_4bits" ..................................................................................................................... 8 3.2.3. Módulo "hex2led" ............................................................................................................................... 8

3.3. Creación del proyecto .................................................................................................................................. 9 3.4. Diseño del módulo "Seldigit_CodLEDS" .................................................................................................. 10

3.4.1. Diseño de los módulos VHDL .......................................................................................................... 10 3.4.2. Conectando los módulos mediante VHDL ........................................................................................ 12

3.5. Simulación del módulo "Seldigit_CodLEDS" ........................................................................................... 13 4. Sesión 2: Simulación de componentes del procesador. ..................................................................................... 17 5. Sesión 3: Simulación de las memorias de datos e instrucciones. ....................................................................... 19

5.1. Memoria de instrucciones. ......................................................................................................................... 19 5.1.1. Modelo. ............................................................................................................................................. 19 5.1.2. Simulación. ....................................................................................................................................... 20

5.2. Memoria de datos. ..................................................................................................................................... 21 5.2.1. Modelo. ............................................................................................................................................. 21 5.2.2. Simulación. ....................................................................................................................................... 21

6. Sesión 4: Descripción y simulación del procesador. .......................................................................................... 23 6.1. Desarrollo. ................................................................................................................................................. 23 6.2. Componentes del procesador. .................................................................................................................... 23 6.3. Descripción VHDL del procesador. ........................................................................................................... 23 6.4. Simulación. ................................................................................................................................................ 25

7. Sesión 5: Descripción, simulación y prueba del sistema final. .......................................................................... 27 7.1. Interfaz del procesador. .............................................................................................................................. 27

7.1.1. Descripción VHDL. .......................................................................................................................... 27 7.2. Simulación. ................................................................................................................................................ 28 7.3. Implementación hardware del circuito. ...................................................................................................... 28

7.3.1. Asignación de pines de la FPGA en la descripción VHDL. .............................................................. 28 7.3.2. Síntesis e implementación. ................................................................................................................ 30

7.4. Prueba del procesador en la tarjeta de prototipado. ................................................................................... 30 8. Apéndice: Instalación de Xilinx ISE.................................................................................................................. 31

8.1. Introducción ............................................................................................................................................... 31 8.2. Descarga del software y registro en Xilinx ................................................................................................ 31 8.3. Instalación .................................................................................................................................................. 32

9. Apéndice: Errores frecuentes y consideraciones generales en ISE. ................................................................... 35 9.1. Errores en el diseño del proyecto: .............................................................................................................. 35 9.2. Errores durante la síntesis e implementación. ............................................................................................ 35

10. Apéndice: Tarjetas Nexys / Nexys2. .................................................................................................................. 37 10.1. Manuales. ................................................................................................................................................... 37 10.2. Comprobaciones iniciales. ......................................................................................................................... 37 10.3. Configuración 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. Selección del reloj en la tarjeta Nexys. ............................................................................................. 38

Planificación de la práctica.

3

1. Planificación de la práctica.

La práctica consta de 5 sesiones, una cada semana. Cada sesión dura dos horas.

1.1. Sesión 1: Proyecto ISE, diseño VHDL y simulación.

• En esta sesión se comenzará creando un proyecto de diseño 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. Sesión 2: Simulación de componentes del procesador.

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

• Se suministran los códigos VHDL completos de estos componentes.

• El alumno creará los archivos de simulación testbench correspondientes a estos dos componentes, y realizará la simulación comprobando los resultados.

1.3. Sesión 3: Simulación de las memorias de datos e instrucciones.

• Simulación de los componentes del procesador "Mem_Ia_256x8.vhd" y "ram_datos.vhd".


• El alumno creará el archivo de simulación testbench correspondiente al componente "Mem_Ia_256x8.vhd", y recibirá del profesor el testbench completo correspondiente al componente "ram_datos.vhd".

1.4. Sesión 4: Descripción y simulación del procesador.

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

• Después el alumno creará el testbench correspondiente y lo simulará para comprobar su funcionamiento.

1.5. Sesión 5: Descripción, simulación y prueba del sistema final.

• El alumno realizará una descripción VHDL del sistema final, consistente en el procesador más el interfaz y los acondicionadores de la señal de reloj.

• Después, realizará una simulación 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.


4

Introducción.

5

2. Introducción.

En esta práctica se diseñará una aproximación al procesador MIPS, con todos los elementos necesarios para su prototipado en hardware. Según se puede observar en la siguiente figura, el procesador MIPS requiere de dos elementos adicionales (acondicionamiento de la señal de reloj e interfaz con la tarjeta de prototipado) para su implementación. 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 continuación.

Procesador Interfaz Generadores señal de reloj Mips_Nucleo1.vhd Seldigit_CodLEDS.vhd cont_div_frec_refresh.vhd Componentes: Componentes: cont_pausa_gen.vhd ALU16bits.vhd dec2a4.vhd ALUcontrol_0.vhd hex2led.vhd Archivo de restricciones BReg_3port_lec.vhd mux4a1_4bits.vhd nexys2.ucf Mem_Ia_256x8.vhd mux2A1_16bits.vhd Sistema final mux3a1_16bits.vhd MIPS_interface.vhd mux3a1_5bits.vhd top_vhd.sch ram_datos.vhd registro_PC.vhd unicontrol_rel1.vhd

Acondicionamiento de la señal 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

entradas señal de reloj

Sistema final

salidas


6

Sesión 1: Proyecto ISE, diseño VHDL y simulación.

7

3. Sesión 1: Proyecto ISE, diseño VHDL y simulación.

3.1. Consideraciones iniciales

Este capítulo introduce al estudiante en el uso de las herramientas software necesarias para la práctica. Para ello, se comenzará un proyecto software en el que definiremos el módulo "Seldigit_CodLEDS", encargado de visualizar en un display de la tarjeta de prototipado el contenido de unos registros del procesador.

En este capítulo se aprenderán a modelar circuitos mediante código VHDL. También se aprenderá a simular el comportamiento del circuito para comprobar ha sido correctamente diseñado.

3.2. Planteamiento del circuito decodificador

Vamos a modelar un circuito llamado "Seldigit_CodLEDS", cuyo propósito será servir de interfaz del futuro procesador MIPS con los periféricos de visualización de la tarjeta de prototipado (displays). Este módulo consta de dos entradas ("refresh(1:0)" y "regs(15:0)") y dos salidas ("anodos(3:0)" y "catodos(7:0)").

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

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.

Decodificador dec2a4

Multiplexor 4 a 1 de 4 bits mux4a1_4bits

Codificador hexadecimal a led hex2led

refresh(1:0)

anodos(3:0) Leds_7seg(6:0)

catodos(7:0)

1

regs(15:0) Seldigit_CodLEDS

salidas entradas


8

3.2.1. Módulo "dec2a4"

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

d(1:0) y(0:3) y(3:0) 00 0111 1110 01 1011 1101 10 1101 1011 11 1110 0111

otros casos 1111 1111

3.2.2. Módulo "mux4a1_4bits"

Es un multiplexor de 4 señales de entrada a 1 señal de salida, todas de 4 bits, con una señal de selección de 2 bit, según la siguiente tabla de verdad:

sel(1:0) s(3:0)

00 d0(3:0) 01 d1(3:0) 10 d2(3:0) 11 d3(3:0)

3.2.3. Módulo "hex2led"

Es un codificador de la entrada de 4 bits "HEX" a la salida de 7 bits "LED", según 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 dígito hexadecimal desde el 0 hasta el F.

HEX(3:0) LED(6:0) Aspecto del

display de 7 segmentos

0000 0000001 0 0001 1111001 1 0010 0010010 2 0011 0000110 3 0100 1001100 4 0101 0100100 5 0110 0100000 6 0111 0001111 7 1000 0000000 8 1001 0000100 9 1010 0001000 A 1011 1100000 b 1100 0110001 C 1101 1000010 d 1110 0110000 E 1111 0111000 F


9

3.3. Creación del proyecto

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

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

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

o 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 podría ser, por ejemplo, el nombre de email del alumno (sin "@alumnos.unex.es").

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

o 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 diseño a otro ordenador, algunos archivos del diseño pueden tener en su descripción interna la ruta del computador original que, si no se respeta en el computador de destino, puede producir errores en algún momento.

• Ejecutar la aplicación "Xilinx ISE Design Suite" > "ISE Design Tools" > "Project Navigator".

• "File" > "New Project" > Consignamos el nombre de la práctica "Prac1" bajo la ruta "C:\GIEC\alumno" y seleccionamos para "top-level source type" la opción "HDL". Esto significa que el modo de diseñar el circuito en el nivel más alto de la jerarquía de diseño será mediante un código 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. También seleccionamos "Preferred Language" = "VHDL", y comprobamos que "Simulator" = "ISim".

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


10

3.4. Diseño del módulo "Seldigit_CodLEDS"

El circuito "Seldigit_CodLEDS" consta de tres módulos: "dec2a4", "mux4a1_4bits" y "hex2led". Vamos a definir en primer lugar estos tres módulos utilizando el lenguaje VHDL, crearemos los archivos fuentes correspondientes (con extensión ".vhd") y los añadiremos al proyecto. Una vez hecho esto, conectaremos los tres módulos de forma que construyan el módulo "Seldigit_CodLEDS". Para ello, crearemos un código VHDL que contenga la descripción de la conexión de los módulos.

3.4.1. Diseño de los módulos VHDL

Vamos a diseñar a continuación los módulos "dec2a4", "mux4a1_4bits" y "hex2led" como códigos VHDL, ilustrando las dos formas para hacerlo: utilizando el asistente de ISE o creándolos directamente.

Módulo "mux4a1_4bits".

• Añadimos un nuevo archivo al proyecto con el código del módulo "mux4a1_4bits" usando un asistente para módulos VHDL: "Project" > "New Source" > categoría "VHDL Module" > consignamos el nombre del archivo "mux4a1_4bits" > Declaramos las entradas y salidas del módulo, tal éste se describió anteriormente.

• Al finalizar el asistente se genera un código VHDL con la estructura del módulo, pero a falta de consignar el

comportamiento del circuito. Este comportamiento lo escribimos directamente en el código, según la tabla de verdad correspondiente.

ruta del proyecto

Sección de archivos del diseño. Contiene los archivos fuente del proyecto, dispuestos de forma jerárquica (árbol del proyecto)

Sección de procesos del diseño. Contiene las herramientas y programas (procesos) que se pueden ejecutar para cada uno de los archivos del diseño o para el diseño completo.

Los archivos pueden visualizarse según su uso para diseño o implementación (por defecto, usaremos siempre esta vista) o para su uso para simulación (que seleccionaremos solo cuando vayamos a simular)

Nombre del proyecto

Dispositivo FPGA sobre el que se implementará el proyecto

Aquí se irán colocando los archivos fuente del diseño jerárquicamente

Consola de mensajes

Pestaña para visualizar el diseño del proyecto. Usaremos siempre esta pestaña por defecto, aunque podemos usar la pestaña “Files” para ver el listado de todos los archivos del proyecto y la pestaña “Libraries” para ver las librerías del mismo.


11

library IEEE; use IEEE.STD_LOGIC_1164.ALL; entity mux4a1_4bits is 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 mux4a1_4bits; architecture Behavioral of mux4a1_4bits is begin S <= D0 when SEL="00" else D1 when SEL ="01" else D2 when SEL ="10" else D3 when SEL ="11" else X"0"; end Behavioral;

• Finalmente, el archivo fuente "mux4a1_4bits" es creado y añadido al proyecto, tal como puede verse en el árbol del diseño.

• Comprobamos que el código VHDL no contiene errores. En el árbol del proyecto, señalamos "mux4a1_4bits", vamos a la ventana de procesos y buscamos la herramienta "Check Syntax" (que puede estar bajo la categoría "Synthesize – XST"). Sobre "Check Syntax" accionamos el botón derecho del ratón > "Run". El código VHDL se compilará, y el resultado se muestra en la consola. Si no hay errores, aparecerá "Process "Check Syntax" completed successfully".

Módulo "dec2a4".

• Vamos a crear y añadir al proyecto el código VHDL correspondiente a este módulo 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 código VHDL del módulo y lo guardamos en el archivo "dec2a4.vhd", dentro de la carpeta raíz del proyecto. El código VHDL corresponde con la tabla de verdad consignada anterioremente.

o Añadimos este archivo al proyecto: "Project" > "Add Source" > Seleccionamos el archivo > "Ok". Comprobamos que el archivo se ha añadido al árbol del proyecto.

o Comprobar el código 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;

Módulo "hex2led".

Para crear el archivo "hex2led.vhd" con el código VHDL correspondiente a este módulo, podemos utilizar cualquiera de los dos métodos anteriores (utilizar el asistente o añadiendo el archivo al proyecto). El código VHDL del módulo corresponde con la tabla de verdad descrita anteriormente. Una vez añadido el archivo al proyecto, comprobar el código mediante "Check Syntax".


12

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 is begin -- Codificacion segmentos array en sentido descendente -- 6 -- --- -- 1 | | 5 -- --- <- 0 --- -- 2 | | 4 -- --- -- 3 with HEX select LED <= "0000001" when "0000", --0 "1111001" when "0001", --1 "0010010" when "0010", --2 "0000110" when "0011", --3 "1001100" when "0100", --4 "0100100" when "0101", --5 "0100000" when "0110", --6 "0001111" when "0111", --7 "0000000" when "1000", --8 "0000100" when "1001", --9 "0001000" when "1010", --A "1100000" when "1011", --b "0110001" when "1100", --C "1000010" when "1101", --d "0110000" when "1110", --E "0111000" when "1111", --F "0000001" when others; --0 end Behavioral;

3.4.2. Conectando los módulos mediante VHDL

Vamos ahora a conectar estos tres módulos para formar el circuito "Seldigit_CodLEDS". Ahora lo haremos mediante un código VHDL. Si miramos la descripción de este circuito al principio del capítulo, observaremos cómo están conectados los módulos y cuáles son las señales internas y de E/S. En base a ello, creamos el archivo "Seldigit_CodLEDS.vhd" (por cualquiera de los métodos descritos anteriormente: asistente o archivo de texto) que añadiremos 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 digit3: STD_LOGIC_VECTOR(3 DOWNTO 0) is REGS(15 DOWNTO 12); alias digit2: STD_LOGIC_VECTOR(3 DOWNTO 0) is REGS(11 DOWNTO 8); alias digit1: STD_LOGIC_VECTOR(3 DOWNTO 0) is REGS(7 DOWNTO 4); alias digit0: STD_LOGIC_VECTOR(3 DOWNTO 0) is REGS(3 DOWNTO 0);

E/S del circuito


13

COMPONENT dec2a4 PORT( d : IN std_logic_vector(1 downto 0); y : OUT std_logic_vector(0 to 3) ); END COMPONENT; 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 ); 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 módulos, ya que se trata de una jerarquía.

3.5. Simulación del módulo "Seldigit_CodLEDS"

La simulación de los circuitos es un paso imprescindible en el llamado "ciclo de diseño", ya que permite depurar errores que, si no se detectan, se irán propagando conforme avancemos en el diseño del sistema final. Cada etapa de modelación o diseño debe ser seguida por una simulación.

Para simular un circuito, se utilizan un código VHDL llamado "Test Bench" (en adelante, abreviamos este término por las siglas TB). Este código, recogido en un archivo VHDL, contiene la descripción de la aplicación de los estímulos o valores que se asignan a las entradas del circuito a simular. La herramienta o software simulador que

declaración de los componentes

Instancias de los componentes, donde se especificn las conexiones entre ellos


14

viene integrado en ISE ("ISim") ejecuta este "Test Bench", es decir, sigue las órdenes descritas en ese código para generar y mostrar gráficamente 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 cuál 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 automáticamente comprobado en su sintaxis VHDL. Ignoramos si da errores, pues vamos a modificarlo a continuación.

• Una vez generado el TB, lo editamos para consignar el siguiente código:

Test Bench Circuito que simulará el test bench

Herramienta simulador Comprueba el código del test bench Ejecuta el test bench para simular el circuito

Diseño en modo vista de simulación


15

LIBRARY ieee; USE ieee.std_logic_1164.ALL; USE ieee.std_logic_arith.ALL; 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; 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; -- 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; wait; end process; END;

Añadimos

Eliminamos

Eliminamos

Eliminamos

Añadimos


16

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

• A continuación, ejecutamos "Simulate Behavioral Model" > "Run". Aparece la representación gráfica de la

simulación, sobre la cual podemos comprobar el correcto funcionamiento del circuito. Por defecto, la simulación mostrará siempre el final de la misma y en el nivel máximo de detalle. Para poder ver toda la simulación, hay que pulsar varias veces la lupa con el "-" o una sola vez la lupa con la "x". Una vez comprimida toda la simulación, podemos ampliar la zona de interés mediante la lupa con el "+".

Instante seleccionado de

la simulación Valores de las E/S para el instante

seleccionado de la simulación

Zona “inestable” del comportamiento

del circuito

Zona “estable” del comportamiento

del circuito

Sesión 2: Simulación de componentes del procesador.

17

4. Sesión 2: Simulación de componentes del procesador.

Desarrollo.

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


• El alumno creará los archivos de simulación testbench correspondientes a estos dos componentes, y realizará la simulación comprobando los resultados.

Entradas y salidas de los componentes:

Operaciones de la ALU:


18

Sesión 3: Simulación de las memorias de datos e instrucciones.

19

5. Sesión 3: Simulación de las memorias de datos e instrucciones.

En esta sesión el alumno simulará los componentes del procesador "Mem_Ia_256x8.vhd" (memoria de instrucciones) y "ram_datos.vhd" (memoria de datos), cuyos códigos 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 descripción 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 dirección pueden direccionar hasta 256 Bytes, porque en la arquitectura MIPS cada dirección de memoria se asigna o direcciona 1 Byte de memoria, no una palabra de 32 bits. Una instrucción MIPS ocupa una palabra de memoria de 32 bits (4 Bytes), donde el direccionamiento sigue el criterio big-endian, es decir, la dirección de la instrucción se asigna al Byte más significativo de la instrucción. El tamaño máximo de programa ensamblador que podemos tener almacenado es de 256 direcciones / 4 Bytes que tiene una instrucción = 64 instrucciones de 32 bits = 256 Bytes.

El programa ensamblador MIPS que inicialmente definimos en esta memoria es el siguiente: # $4 inicializado con direccion inicio array ( =24) 0 Sub $3, $0, $4 # $3 <- -24 4 addi $1, $3, 23 # $1 <- -1 8 And $2, $1, $3 12 Nor $5, $0, $0 16 Sw $5, 48($0) 20 Sw $4, 8($0) 24 Lw $6, 20($0) # carga en $6 num elem array (20/2=10) 28 Jal rutina 32 Sw $2, 12($0) # guarda en dir 0 resultado suma 36 Addi $15, $31, 0 Fin: 40 Bne $0, $3, -1 # (bucle infinito) 44 X"0000" # (rellenar con 32 0`s 48 X"0000" # (rellenar con 32 0`s ... ... # (rellenar con 32 0`s 60 X"0000" # (rellenar con 32 0`s Rutina: 64 xor $3,$1,$1 # i <- 0 (indice en $3) 68 Ori $2, $0, 0 # suma v 0 en $2 Bucle: 72 slt $1, $3, $6 # si i > = n entonces $1 <- 0 76 Beq $1, $0, ret # salta a ret si i > = n 80 Lw $5, 0($4) # $5 <- x(i) (<$4> = 24 inicialmente) 84 Addi $3, $3, 1 # i <- i + 1 88 Addi $4, $4, 4 # actualiza $4 92 Add $2, $2, $5 # suma <- suma + x(i) 96 J bucle ret: 100 jr $31

Dirección de memoria

Instrucciones ensamblador


20

Las instrucciones del ensamblador se almacenan codificadas en binario en las palabras de la memoria de instrucciones. El siguiente listado corresponde a la codificación binaria de este programa. No obstante, la inicialización de esta memoria está inacabada: Falta por codificar las instrucciones señaladas. 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" );

5.1.2. Simulación.

Como ayuda para crear el testbench para la memoria de instrucciones, considerar el siguiente código VHDL (se puede crear un testbench automáticamente, quitar toda referencia de señal de reloj –la memoria de instrucciones es combinacional- y sustituir el proceso de estímulos 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 conversión a la -- variable dir_palabra, declarada en la sección declaratival del proceso. -- Se multiplica por 4 esta variable (contatenando dos bits "00" a la derecha -- Se asigna el resultado a la señal dir que corresponde al estímulo de dirección de la memoria. ---- VEASE CÓDIGO VHDL USE ieee.std_logic_arith.ALL; -- necesaria esta claúsula para usar función de conversión.

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

Sesión 3: Simulación de las memorias de datos e instrucciones.

21

--- proceso estímulos 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 descripción 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 residirán en la memoria cuando se configure la FPGA de la tarjeta de prototipado. Estos datos son:

Dirección de memoria

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

bits) 0 0x00

... 0x00 10 0x00 11 0x06 12 0xff 13 0xff 14 0xff 15 0xfe 16 0xff 17 0xfc 18 0x22 19 0xbf 20 0x80 21 0x90 22 0x7f 23 0xff ... ... 254 0x00

Para obtener una dirección par de la memoria de datos hay que dividir por 2 las direcciones múltiplo de 4 codificadas en la memoria de instrucciones.

5.2.2. Simulación.

Para realizar la simulación de la memoria de datos, se suministra el testbench "ram_datos_tb.vhd". No obstante, en la simulación 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 dígitos, numerándose dichos dígitos de izquierda a derecha en sentido ascendente.

6 = número de elementos del array

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

array ∑ = 9031 = 234716


22

Número 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: Número positivo más alto representable con 16 bits: 32767 (en direc. 16,17)

• DATO 4: número negativo más 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 6 0 2 6 7 6 9 digito 1 digito 2 digito 3 digito 4 digito 5 digito 6 digito 7 digito 8

• Dato 1 = -1

• Dato 2 = -7

• Dato 3 = 32767

• Dato 4 = -32768

• Dato 5 = 6026

• Dato 6 = 769

Sesión 4: Descripción y simulación del procesador.

23

6. Sesión 4: Descripción y simulación del procesador.

6.1. Desarrollo.

• El alumno realizará una descripción 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”.

• Después 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 Módulo ALU16bits.vhd Unidad aritmético lógica (ALU) ALUcontrol_0.vhd Control de la ALU BReg_3port_lec.vhd Banco de registros Mem_Ia_256x8.vhd Memoria de instrucciones mux2A1_16bits.vhd Multiplexor 2x1 de 16 bits mux3a1_16bits.vhd Multiplexor 3x1 de 16 bits mux3a1_5bits.vhd Multiplexor 3x1 de 5 bits ram_datos.vhd Memoria de datos registro_PC.vhd Contador de programa unicontrol_rel1.vhd Unidad de control

6.3. Descripción 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 código, 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 código.


24

Figura: “arquitectura del procesador”

Sesión 4: Descripción y simulación del procesador.

25

6.4. Simulación.

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 módulo "MIPS_nucleo1" -> Se genera el testbench.

• En el testbench generamos, añadimos en la sección de estímulos, una única sentencia para indicar que queremos

seleccionar, mediante la señal de entrada "selreg", el registro $3 para que se muestre, mediante la señal de salida "salreg", su valor al final de la simulación:

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 simulación:

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

• Para comprobar que el programa se ha ejecutado correctamente, deberíamos examinar el contenido de los registros. Para ello, hay que añadir a la ventana de simulación de señales (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 señales y componentes de la instancia "Inst_BReg_3port", entre ellos aparece "banco_reg" -> picamos en banco_reg[0:31] -> con el botón derecho del ratón: "Add To Wave Window" -> aparece "banco_reg[0:31]" en la ventana de simulación de señales.

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


26

o Si observamos el registro $3 = $v1 = 00000000000000000000000000000111, coincide con el valor de la señal "salreg", pues habíamos seleccionado ese registro en el testbench mediante "selreg".

o 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 simulación del procesador y el contenido de los registros (decimal con signo) durante la ejecución 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. También puede haber alguna diferencia más si se ha codificado mal alguna instrucción en la memoria de instrucciones.

Sesión 5: Descripción, simulación y prueba del sistema final.

27

7. Sesión 5: Descripción, simulación y prueba del sistema final.

7.1. Interfaz del procesador.

Una vez diseñado 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 través de conmutadores como entradas y leds y displays como salidas), necesitaremos, además, algún otro módulo que haga de interfaz entre el procesador MIPS y los periféricos de la tarjeta. De esta forma, la FPGA se configura con el procesador MIPS más el interfaz.

El interfaz del procesador es el módulo "Seldigit_CodLEDS.vhd" que se estudió al principio de la práctica, en la primera sesión. Necesitaremos, además, dos módulos adicionales, "cont_div_frec_refresh.vhd" y "cont_pausa_gen.vhd", para acondicionar las señales de reloj de los circuitos.

7.1.1. Descripción VHDL.

Se proporciona un archivo VHDL llamado "MIPS_interface.vhd". Este archivo contiene la descripción 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 descripción VHDL del sistema final, tendremos el archivo "MIPS_interface.vhd" en el nivel más alto del árbol del proyecto en el entorno ISE:


28

7.2. Simulación.

Para realizar la simulación 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 genéricos, podemos realizar la simulación con una escala de tiempo distinta a los tiempos que intervienen en la síntesis. Para conseguir esto, basta con utilizar parámetros distintos en simulación y síntesis (implementación). Para ello, se cambia el valor del genérico en las sentencia de instanciación de los componentes "cont_div_frec_refresh" y "cont_pausa_gen" (observar los comentarios introducidos en ambas sentencias de instanciación). Inst_div_frec: cont_div_frec_refresh generic map (n => 19) -- 3 para simulación 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 simulación ; 4 a 7 para sintesis PORT MAP( clock => reloj1, pausa => clock_en, clk_sal => reloj2);

7.3. Implementación hardware del circuito.

Las señales de E/S del sistema final son:

• Entradas:

o "clk50Mhz". Oscilador de la tarjeta.

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

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

• Salidas:

o "anodos" (ánodos) y "HEXleds" (cátodos). Ambas señales controlan la visualización en los displays de 7 segmentos de la tarjeta.

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

Ahora hay que especificar la asignación de estas señales a los pines de la FPGA.

7.3.1. Asignación de pines de la FPGA en la descripción VHDL.

Cada señal E/S en "MIPS_interface.vhd" ha de asignarse a determinados pines de la FPGA, según su propósito. Los pines de la FPGA están conectados con periféricos de la tarjeta. Por ejemplo, la señal "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:

Sesión 5: Descripción, simulación y prueba del sistema final.

29

Para saber qué pines de la FPGA corresponden con cada periférico o dispositivo de la tarjeta, debemos consultar el anexo "Tarjetas Nexys / Nexys2" de este documento.

En el diseño ISE debemos especificar la asignación de las señales E/S del circuito con los pines de la FPGA, utilizando el archivo de restricciones UCF. Este es un archivo de texto plano, con extensión ".ucf", que lista dicha asignación, solo para las señales 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 diseño al que se va a asociar este archivo de restricciones (este paso de selección solo se aplica en el caso de haber más de un componente de alto nivel en el diseño) -> "Finish". Aparece un archivo vacío titulado "nexys2.ucf". Este archivo cuelga de la jerarquía del diseño 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 asignación 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 "clock_en" LOC = "N16"; NET "anodos<0>" LOC = "G14"; NET "anodos<1>" LOC = "G12"; NET "anodos<2>" LOC = "G13"; NET "anodos<3>" LOC = "F12"; #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"; NET "pc_LSB<0>" LOC = "L14"; NET "pc_LSB<1>" LOC = "L13"; NET "pc_LSB<2>" LOC = "M14"; NET "pc_LSB<3>" LOC = "L12"; NET "pc_LSB<4>" LOC = "N14"; NET "pc_LSB<5>" LOC = "M13"; NET "pc_LSB<6>" LOC = "P14"; NET "pc_LSB<7>" LOC = "R16"; NET "selREG<0>" LOC = "N15"; NET "selREG<1>" LOC = "J16"; NET "selREG<2>" LOC = "K16"; NET "selREG<3>" LOC = "K15";

NET "clk50Mhz" LOC = "B8"; NET "clock_en" LOC = "R17"; NET "anodos<0>" LOC = "F17"; NET "anodos<1>" LOC = "H17"; NET "anodos<2>" LOC = "C18"; NET "anodos<3>" LOC = "F15"; #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 "pc_LSB<0>" LOC = "J14"; NET "pc_LSB<1>" LOC = "J15"; NET "pc_LSB<2>" LOC = "K15"; NET "pc_LSB<3>" LOC = "K14"; NET "pc_LSB<4>" LOC = "E17"; NET "pc_LSB<5>" LOC = "P15"; NET "pc_LSB<6>" LOC = "F4"; NET "pc_LSB<7>" LOC = "R4"; NET "selREG<0>" LOC = "G18"; NET "selREG<1>" LOC = "H18"; NET "selREG<2>" LOC = "K18"; NET "selREG<3>" LOC = "K17";

NET "clk50Mhz" LOC = "B8"; NET "clock_en" LOC = "R17"; NET "anodos<0>" LOC = "F17"; NET "anodos<1>" LOC = "H17"; NET "anodos<2>" LOC = "C18"; NET "anodos<3>" LOC = "F15"; #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 "pc_LSB<0>" LOC = "J14"; NET "pc_LSB<1>" LOC = "J15"; NET "pc_LSB<2>" LOC = "K15"; NET "pc_LSB<3>" LOC = "K14"; NET "pc_LSB<4>" LOC = "E16"; NET "pc_LSB<5>" LOC = "P16"; NET "pc_LSB<6>" LOC = "E4"; NET "pc_LSB<7>" LOC = "P4"; NET "selREG<0>" LOC = "G18"; NET "selREG<1>" LOC = "H18"; NET "selREG<2>" LOC = "K18"; NET "selREG<3>" LOC = "K17";


30

7.3.2. Síntesis e implementación.

Procedemos a compilar el circuito (procesos de síntesis e implementación) para generar el archivo "mips_interface.bit” con la descripción de la configuración de la FPGA con nuestro circuito del procesador:

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

• Ir a "Processes" > seleccionar "Implement Design" > botón derecho del ratón > "Process Properties" > expandir el campo "Property display level" y seleccionar "Advanced", y entonces activar la casilla "Perform Advanced Analysis" en la categoría "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 categoría "Startup Options" -> OK.

• Seleccionar "Generate Programming File" > "Run". En este momento comienza el proceso de implementación.

Pasados unos minutos, finalizan los distintos procesos de la implementación ("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.

• En el capítulo "Apéndice: Tarjetas Nexys / Nexys2" se muestran los pasos para cargar el diseño (archivo ".bit") en la FPGA, en los apartados "Comprobaciones iniciales" y "Configuración de la FPGA".

Apéndice: Instalación de Xilinx ISE

31

8. Apéndice: Instalación de Xilinx ISE

8.1. Introducción

Xilinx ISE es una herramienta software que permite programar circuitos para implementarse en dispositivos FPGA.

En este tutorial, todos los nombres de variables se mostrarán 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 versión 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 información requerida del perfil de la cuenta.

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

http://www.xilinx.com/


32

• Descargar el archivo de instalación para Windows para el SO correspondiente. Este archivo tiene un gran

tamaño, por lo que la descarga tardará mucho tiempo.

8.3. Instalación

• 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 instalación se generen rutas de más de 255 caracteres y se interrumpa la instalación.

• Una vez descomprimido, instalar accionando el archivo "xsetup.exe". Aceptar los acuerdos de licencia. A continuación, seleccionar la opción "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 instalación, la cual tardará bastante tiempo. Hacia el

final se pedirá confirmación de la instalación de controladores de Xilinx y Digilent. Decimos que sí.

Apéndice: Instalación de Xilinx ISE

33

• Una vez finalizada la instalación, se nos pide la configuración 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 botón "Connect Now".

• Se nos pide acceder con la cuenta de Xilinx. En la información de nuestro perfil clicamos en "Next" (si algún

campo de información del perfil es incorrecto o falta, no podremos continuar sin consignarlo correctamente).

• Una vez en la ventana de generación de la licencia (pestaña "Create New Licenses"), activamos la casilla "ISE Design Suite WebPack License" y clicamos el botón "Generate Node-Locked License".

• El proceso de generación de la licencia consta de tres sencillos pasos (tan solo hay que clicar el botón "Next")

que concluyen con la aceptación del acuerdo de licencia.

• Al finalizar, en la pestaña "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 pestaña "Manage Xilinx Licenses", clicamos el botón "Copy License" y seleccionamos el archivo descargado "xilinx.lic". Cerramos la ventana, al confirmarse que la operación se ha realizado correctamente y que la instalación del software de Xilinx ha finalizado.


34

Apéndice: Errores frecuentes y consideraciones generales en ISE.

35

9. Apéndice: Errores frecuentes y consideraciones generales en ISE.

9.1. Errores en el diseño del proyecto:

• En el árbol del proyecto no aparece un elemento, o aparece con una interrogación. Si lo añadimos, sale un mensaje de error avisando que ya está en el proyecto:

o En la ventana "Sources", ir a la pestaña "Libraries".

o Expandir la categoría "Work".

o Localizar el elemento en cuestión, y borrarlo (botón derecho del ratón, y "Remove").

o Volver a la ventana "Sources", volver a añadir el elemento mediante "Add Source".

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

9.2. Errores durante la síntesis e implementación.

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 más habituales:

• A veces se producen errores durante la síntesis e implementación debido a la no actualización de los componentes del diseño (normalmente, los IP cores). Esto suele suceder habitualmente cuando guardamos todo el proyecto en un medio extraíble para volver a grabarlo posteriormente en cualquier equipo. La solución es:

o En la ventana "Sources", seleccionamos con el ratón la parte más superior del árbol del diseño, donde aparece el nombre del mismo (por encima del tipo de FPGA seleccionado).

o En la ventana "Processes", expandimos la categoría "Design Utilities".

o Ejecutamos "Regenerate All Cores".

o Ejecutamos "Update All Schematic Files".

• Las señales en el diseño no se corresponden con las señales en el archivo UCF.

• El diseño es demasiado grande para la FPGA seleccionada.


36

Apéndice: Tarjetas Nexys / Nexys2.

37

10. Apéndice: Tarjetas Nexys / Nexys2.

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 continuación se expone la información básica de estas tarjetas para el desarrollo de las prácticas.

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 Para nexys:

o JP3 in JTAG position.

o J4 in USB position.

o JP4 in 100 MHZ position.

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

o J6 in TDI-TDO position.

o Switch POWER in OFF position.

o Para nexys2:

o JP9 (mode) in JTAG position.

o JP7 (power select) in USB position.

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

o JP8 and JP10 must have placed jumpers.

o Switch POWER in OFF position.

o All DIP switches in LOW position.

• Fuente de alimentación y comunicación con el PC:

o 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. Configuración de la FPGA.

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

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

• Ejecutar el software "Adept". La aplicación detecta automáticamente la tarjeta y su correspondiente chip FPGA.

• Seleccionar en el campo "FPGA" el archivo de configuración ".bit" generado en la práctica.

• Clicar en "Program".

• No olvidar apagar la tarjeta al finalizar la práctica.

http://www.digilentinc.com/

http://arco.unex.es/resources


38

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 L14 DIP switch – SW0 N15 Button – BTN0 J13 LED - LD1 L13 DIP switch – SW1 J16 Button – BTN1 K14 LED - LD2 M14 DIP switch – SW2 K16 Button – BTN2 K13 LED - LD3 L12 DIP switch – SW3 K15 Button – BTN3 K12 LED - LD4 N14 DIP switch – SW4 L15 LED - LD5 M13 DIP switch – SW5 M16 Clock (oscillator) A8 LED - LD6 P14 DIP switch – SW6 M15 LED - LD7 R16 DIP switch – SW7 N16 AN0 G14 CA F13 CE J14 AN1 G12 CB E13 CF E14 AN2 G13 CC G15 CG G16 AN3 F12 CD H13 DP H14

10.5.2. Nexys2.

Device on board FPGA pin Device on board FPGA pin Device on board FPGA pin LED - LD0 J14 DIP switch – SW0 G18 Button – BTN0 B18 LED - LD1 J15 DIP switch – SW1 H18 Button – BTN1 D18 LED - LD2 K15 DIP switch – SW2 K18 Button – BTN2 E18 LED - LD3 K14 DIP switch – SW3 K17 Button – BTN3 H13 LED - LD4 E17 (E16*) DIP switch – SW4 L14 LED - LD5 P15 (P16*) DIP switch – SW5 L13 Clock (oscillator) B8 LED - LD6 F4 (E4*) DIP switch – SW6 N17 LED - LD7 R4 (P4*) DIP switch – SW7 R17 AN0 F17 CA L18 CE G14 AN1 H17 CB F18 CF J17 AN2 C18 CC D17 CG H14 AN3 F15 CD D16 DP C17

(*) Nexys2-1200

10.5.3. Selección del reloj en la tarjeta Nexys.

25 MHz: 50 MHz: 100 MHz:

EC_2013-2014_Prac1-MIPS-ISE

Documents

simulacin de componentes

diseo vhdl

mdulo seldigit

mdulos vhdl

mdulo mux4a1

mdulo dec2a4

mdulo hex2led

ingeniera de computadores